drivers/net/bnx2x/bnx2x_vfpf.c

   1 /*
   2  * Copyright (c) 2013-2015 Brocade Communications Systems, Inc.
   3  *
   4  * Copyright (c) 2015 QLogic Corporation.
   5  * All rights reserved.
   6  * www.qlogic.com
   7  *
   8  * See LICENSE.bnx2x_pmd for copyright and licensing details.
   9  */
  10
  11 #include "bnx2x.h"
  12
  13 /* calculate the crc in the bulletin board */
  14 static inline uint32_t
  15 bnx2x_vf_crc(struct bnx2x_vf_bulletin *bull)
  16 {
  17         uint32_t crc_sz = sizeof(bull->crc), length = bull->length - crc_sz;
  18
  19         return ECORE_CRC32_LE(0, (uint8_t *)bull + crc_sz, length);
  20 }
  21
  22 /* Checks are there mac/channel updates for VF
  23  * returns TRUE if something was updated
  24 */
  25 int
  26 bnx2x_check_bull(struct bnx2x_softc *sc)
  27 {
  28         struct bnx2x_vf_bulletin *bull;
  29         uint8_t tries = 0;
  30         uint16_t old_version = sc->old_bulletin.version;
  31         uint64_t valid_bitmap;
  32
  33         bull = sc->pf2vf_bulletin;
  34         if (old_version == bull->version) {
  35                 return FALSE;
  36         } else {
  37                 /* Check the crc until we get the correct data */
  38                 while (tries < BNX2X_VF_BULLETIN_TRIES) {
  39                         bull = sc->pf2vf_bulletin;
  40                         if (bull->crc == bnx2x_vf_crc(bull))
  41                                 break;
  42
  43                         PMD_DRV_LOG(ERR, "bad crc on bulletin board. contained %x computed %x",
  44                                         bull->crc, bnx2x_vf_crc(bull));
  45                         ++tries;
  46                 }
  47                 if (tries == BNX2X_VF_BULLETIN_TRIES) {
  48                         PMD_DRV_LOG(ERR, "pf to vf bulletin board crc was wrong %d consecutive times. Aborting",
  49                                         tries);
  50                         return FALSE;
  51                 }
  52         }
  53
  54         valid_bitmap = bull->valid_bitmap;
  55
  56         /* check the mac address and VLAN and allocate memory if valid */
  57         if (valid_bitmap & (1 << MAC_ADDR_VALID) && memcmp(bull->mac, sc->old_bulletin.mac, ETH_ALEN))
  58                 rte_memcpy(&sc->link_params.mac_addr, bull->mac, ETH_ALEN);
  59         if (valid_bitmap & (1 << VLAN_VALID))
  60                 rte_memcpy(&bull->vlan, &sc->old_bulletin.vlan, VLAN_HLEN);
  61
  62         sc->old_bulletin = *bull;
  63
  64         return TRUE;
  65 }
  66
  67 /* add tlv to a buffer */
  68 #define BNX2X_TLV_APPEND(_tlvs, _offset, _type, _length) \
  69         ((struct vf_first_tlv *)((unsigned long)_tlvs + _offset))->type   = _type; \
  70         ((struct vf_first_tlv *)((unsigned long)_tlvs + _offset))->length = _length
  71
  72 /* Initiliaze header of the first tlv and clear mailbox*/
  73 static void
  74 bnx2x_init_first_tlv(struct bnx2x_softc *sc, struct vf_first_tlv *tlv,
  75         uint16_t type, uint16_t len)
  76 {
  77         struct bnx2x_vf_mbx_msg *mbox = sc->vf2pf_mbox;
  78         PMD_DRV_LOG(DEBUG, "Preparing %d tlv for sending", type);
  79
  80         memset(mbox, 0, sizeof(struct bnx2x_vf_mbx_msg));
  81
  82         BNX2X_TLV_APPEND(tlv, 0, type, len);
  83
  84         /* Initialize header of the first tlv */
  85         tlv->reply_offset = sizeof(mbox->query);
  86 }
  87
  88 #define BNX2X_VF_CMD_ADDR_LO PXP_VF_ADDR_CSDM_GLOBAL_START
  89 #define BNX2X_VF_CMD_ADDR_HI BNX2X_VF_CMD_ADDR_LO + 4
  90 #define BNX2X_VF_CMD_TRIGGER BNX2X_VF_CMD_ADDR_HI + 4
  91 #define BNX2X_VF_CHANNEL_DELAY 100
  92 #define BNX2X_VF_CHANNEL_TRIES 100
  93
  94 static int
  95 bnx2x_do_req4pf(struct bnx2x_softc *sc, phys_addr_t phys_addr)
  96 {
  97         uint8_t *status = &sc->vf2pf_mbox->resp.common_reply.status;
  98         uint8_t i;
  99
 100         if (!*status) {
 101                 bnx2x_check_bull(sc);
 102                 if (sc->old_bulletin.valid_bitmap & (1 << CHANNEL_DOWN)) {
 103                         PMD_DRV_LOG(ERR, "channel is down. Aborting message sending");
 104                         *status = BNX2X_VF_STATUS_SUCCESS;
 105                         return 0;
 106                 }
 107
 108                 REG_WR(sc, BNX2X_VF_CMD_ADDR_LO, U64_LO(phys_addr));
 109                 REG_WR(sc, BNX2X_VF_CMD_ADDR_HI, U64_HI(phys_addr));
 110
 111                 /* memory barrier to ensure that FW can read phys_addr */
 112                 wmb();
 113
 114                 REG_WR8(sc, BNX2X_VF_CMD_TRIGGER, 1);
 115
 116                 /* Do several attempts until PF completes
 117                  * "." is used to show progress
 118                  */
 119                 for (i = 0; i < BNX2X_VF_CHANNEL_TRIES; i++) {
 120                         DELAY_MS(BNX2X_VF_CHANNEL_DELAY);
 121                         if (*status)
 122                                 break;
 123                 }
 124
 125                 if (!*status) {
 126                         PMD_DRV_LOG(ERR, "Response from PF timed out");
 127                         return -EAGAIN;
 128                 }
 129         } else {
 130                 PMD_DRV_LOG(ERR, "status should be zero before message"
 131                                 "to pf was sent");
 132                 return -EINVAL;
 133         }
 134
 135         PMD_DRV_LOG(DEBUG, "Response from PF was received");
 136         return 0;
 137 }
 138
 139 static inline uint16_t bnx2x_check_me_flags(uint32_t val)
 140 {
 141         if (((val) & ME_REG_VF_VALID) && (!((val) & ME_REG_VF_ERR)))
 142                 return ME_REG_VF_VALID;
 143         else
 144                 return 0;
 145 }
 146
 147 #define BNX2X_ME_ANSWER_DELAY 100
 148 #define BNX2X_ME_ANSWER_TRIES 10
 149
 150 static inline int bnx2x_read_vf_id(struct bnx2x_softc *sc)
 151 {
 152         uint32_t val;
 153         uint8_t i = 0;
 154
 155         while (i <= BNX2X_ME_ANSWER_TRIES) {
 156                 val = BNX2X_DB_READ(DOORBELL_ADDR(sc, 0));
 157                 if (bnx2x_check_me_flags(val))
 158                         return VF_ID(val);
 159
 160                 DELAY_MS(BNX2X_ME_ANSWER_DELAY);
 161                 i++;
 162         }
 163
 164         return -EINVAL;
 165 }
 166
 167 #define BNX2X_VF_OBTAIN_MAX_TRIES 3
 168 #define BNX2X_VF_OBTAIN_MAC_FILTERS 1
 169 #define BNX2X_VF_OBTAIN_MC_FILTERS 10
 170
 171 struct bnx2x_obtain_status {
 172         int success;
 173         int err_code;
 174 };
 175
 176 static
 177 struct bnx2x_obtain_status bnx2x_loop_obtain_resources(struct bnx2x_softc *sc)
 178 {
 179         int tries = 0;
 180         struct vf_acquire_resp_tlv *resp = &sc->vf2pf_mbox->resp.acquire_resp,
 181                                                                  *sc_resp = &sc->acquire_resp;
 182         struct vf_resource_query    *res_query;
 183         struct vf_resc            *resc;
 184         struct bnx2x_obtain_status     status;
 185         int res_obtained = false;
 186
 187         do {
 188                 PMD_DRV_LOG(DEBUG, "trying to get resources");
 189
 190                 if (bnx2x_do_req4pf(sc, sc->vf2pf_mbox_mapping.paddr)) {
 191                         /* timeout */
 192                         status.success = 0;
 193                         status.err_code = -EAGAIN;
 194                         return status;
 195                 }
 196
 197                 memcpy(sc_resp, resp, sizeof(sc->acquire_resp));
 198
 199                 tries++;
 200
 201                 /* check PF to request acceptance */
 202                 if (sc_resp->status == BNX2X_VF_STATUS_SUCCESS) {
 203                         PMD_DRV_LOG(DEBUG, "resources obtained successfully");
 204                         res_obtained = true;
 205                 } else if (sc_resp->status == BNX2X_VF_STATUS_NO_RESOURCES &&
 206                         tries < BNX2X_VF_OBTAIN_MAX_TRIES) {
 207                         PMD_DRV_LOG(DEBUG,
 208                            "PF cannot allocate requested amount of resources");
 209
 210                         res_query = &sc->vf2pf_mbox->query[0].acquire.res_query;
 211                         resc     = &sc_resp->resc;
 212
 213                         /* PF refused our request. Try to decrease request params */
 214                         res_query->num_txqs         = min(res_query->num_txqs, resc->num_txqs);
 215                         res_query->num_rxqs         = min(res_query->num_rxqs, resc->num_rxqs);
 216                         res_query->num_sbs          = min(res_query->num_sbs, resc->num_sbs);
 217                         res_query->num_mac_filters  = min(res_query->num_mac_filters, resc->num_mac_filters);
 218                         res_query->num_vlan_filters = min(res_query->num_vlan_filters, resc->num_vlan_filters);
 219                         res_query->num_mc_filters   = min(res_query->num_mc_filters, resc->num_mc_filters);
 220
 221                         memset(&sc->vf2pf_mbox->resp, 0, sizeof(union resp_tlvs));
 222                 } else {
 223                         PMD_DRV_LOG(ERR, "Resources cannot be obtained. Status of handling: %d. Aborting",
 224                                         sc_resp->status);
 225                         status.success = 0;
 226                         status.err_code = -EAGAIN;
 227                         return status;
 228                 }
 229         } while (!res_obtained);
 230
 231         status.success = 1;
 232         return status;
 233 }
 234
 235 int bnx2x_vf_get_resources(struct bnx2x_softc *sc, uint8_t tx_count, uint8_t rx_count)
 236 {
 237         struct vf_acquire_tlv *acq = &sc->vf2pf_mbox->query[0].acquire;
 238         int vf_id;
 239         struct bnx2x_obtain_status obtain_status;
 240
 241         bnx2x_vf_close(sc);
 242         bnx2x_init_first_tlv(sc, &acq->first_tlv, BNX2X_VF_TLV_ACQUIRE, sizeof(*acq));
 243
 244         vf_id = bnx2x_read_vf_id(sc);
 245         if (vf_id < 0)
 246                 return -EAGAIN;
 247
 248         acq->vf_id = vf_id;
 249
 250         acq->res_query.num_rxqs = rx_count;
 251         acq->res_query.num_txqs = tx_count;
 252         acq->res_query.num_sbs = sc->igu_sb_cnt;
 253         acq->res_query.num_mac_filters = BNX2X_VF_OBTAIN_MAC_FILTERS;
 254         acq->res_query.num_mc_filters = BNX2X_VF_OBTAIN_MC_FILTERS;
 255
 256         acq->bulletin_addr = sc->pf2vf_bulletin_mapping.paddr;
 257
 258         /* Request physical port identifier */
 259         BNX2X_TLV_APPEND(acq, acq->first_tlv.length,
 260                          BNX2X_VF_TLV_PHYS_PORT_ID,
 261                          sizeof(struct channel_tlv));
 262
 263         BNX2X_TLV_APPEND(acq,
 264                          (acq->first_tlv.length + sizeof(struct channel_tlv)),
 265                          BNX2X_VF_TLV_LIST_END,
 266                          sizeof(struct channel_list_end_tlv));
 267
 268         /* requesting the resources in loop */
 269         obtain_status = bnx2x_loop_obtain_resources(sc);
 270         if (!obtain_status.success)
 271                 return obtain_status.err_code;
 272
 273         struct vf_acquire_resp_tlv sc_resp = sc->acquire_resp;
 274
 275         sc->devinfo.chip_id        |= (sc_resp.chip_num & 0xFFFF);
 276         sc->devinfo.int_block       = INT_BLOCK_IGU;
 277         sc->devinfo.chip_port_mode  = CHIP_2_PORT_MODE;
 278         sc->devinfo.mf_info.mf_ov   = 0;
 279         sc->devinfo.mf_info.mf_mode = 0;
 280         sc->devinfo.flash_size      = 0;
 281
 282         sc->igu_sb_cnt  = sc_resp.resc.num_sbs;
 283         sc->igu_base_sb = sc_resp.resc.hw_sbs[0] & 0xFF;
 284         sc->igu_dsb_id  = -1;
 285
 286         sc->link_params.chip_id = sc->devinfo.chip_id;
 287         sc->doorbell_size = sc_resp.db_size;
 288         sc->flags |= BNX2X_NO_WOL_FLAG | BNX2X_NO_ISCSI_OOO_FLAG | BNX2X_NO_ISCSI_FLAG | BNX2X_NO_FCOE_FLAG;
 289
 290         PMD_DRV_LOG(DEBUG, "status block count = %d, base status block = %x",
 291                 sc->igu_sb_cnt, sc->igu_base_sb);
 292         strncpy(sc->fw_ver, sc_resp.fw_ver, sizeof(sc->fw_ver));
 293
 294         if (is_valid_ether_addr(sc_resp.resc.current_mac_addr))
 295                 (void)rte_memcpy(sc->link_params.mac_addr,
 296                        sc_resp.resc.current_mac_addr,
 297                        ETH_ALEN);
 298
 299         return 0;
 300 }
 301
 302 /* Ask PF to release VF's resources */
 303 void
 304 bnx2x_vf_close(struct bnx2x_softc *sc)
 305 {
 306         struct vf_release_tlv *query;
 307         struct vf_common_reply_tlv *reply = &sc->vf2pf_mbox->resp.common_reply;
 308         int vf_id = bnx2x_read_vf_id(sc);
 309
 310         if (vf_id >= 0) {
 311                 query = &sc->vf2pf_mbox->query[0].release;
 312                 bnx2x_init_first_tlv(sc, &query->first_tlv, BNX2X_VF_TLV_RELEASE,
 313                                 sizeof(*query));
 314
 315                 query->vf_id = vf_id;
 316                 BNX2X_TLV_APPEND(query, query->first_tlv.length, BNX2X_VF_TLV_LIST_END,
 317                                 sizeof(struct channel_list_end_tlv));
 318
 319                 bnx2x_do_req4pf(sc, sc->vf2pf_mbox_mapping.paddr);
 320                 if (reply->status != BNX2X_VF_STATUS_SUCCESS)
 321                         PMD_DRV_LOG(ERR, "Failed to release VF");
 322         }
 323 }
 324
 325 /* Let PF know the VF status blocks phys_addrs */
 326 int
 327 bnx2x_vf_init(struct bnx2x_softc *sc)
 328 {
 329         struct vf_init_tlv *query;
 330         struct vf_common_reply_tlv *reply = &sc->vf2pf_mbox->resp.common_reply;
 331         int i;
 332
 333         query = &sc->vf2pf_mbox->query[0].init;
 334         bnx2x_init_first_tlv(sc, &query->first_tlv, BNX2X_VF_TLV_INIT,
 335                         sizeof(*query));
 336
 337         FOR_EACH_QUEUE(sc, i) {
 338                 query->sb_addr[i] = (unsigned long)(sc->fp[i].sb_dma.paddr);
 339         }
 340
 341         query->stats_step = sizeof(struct per_queue_stats);
 342         query->stats_addr = sc->fw_stats_data_mapping +
 343                 offsetof(struct bnx2x_fw_stats_data, queue_stats);
 344
 345         BNX2X_TLV_APPEND(query, query->first_tlv.length, BNX2X_VF_TLV_LIST_END,
 346                         sizeof(struct channel_list_end_tlv));
 347
 348         bnx2x_do_req4pf(sc, sc->vf2pf_mbox_mapping.paddr);
 349         if (reply->status != BNX2X_VF_STATUS_SUCCESS) {
 350                 PMD_DRV_LOG(ERR, "Failed to init VF");
 351                 return -EINVAL;
 352         }
 353
 354         PMD_DRV_LOG(DEBUG, "VF was initialized");
 355         return 0;
 356 }
 357
 358 void
 359 bnx2x_vf_unload(struct bnx2x_softc *sc)
 360 {
 361         struct vf_close_tlv *query;
 362         struct vf_common_reply_tlv *reply = &sc->vf2pf_mbox->resp.common_reply;
 363         struct vf_q_op_tlv *query_op;
 364         int i, vf_id;
 365
 366         vf_id = bnx2x_read_vf_id(sc);
 367         if (vf_id > 0) {
 368                 FOR_EACH_QUEUE(sc, i) {
 369                         query_op = &sc->vf2pf_mbox->query[0].q_op;
 370                         bnx2x_init_first_tlv(sc, &query_op->first_tlv,
 371                                         BNX2X_VF_TLV_TEARDOWN_Q,
 372                                         sizeof(*query_op));
 373
 374                         query_op->vf_qid = i;
 375
 376                         BNX2X_TLV_APPEND(query_op, query_op->first_tlv.length,
 377                                         BNX2X_VF_TLV_LIST_END,
 378                                         sizeof(struct channel_list_end_tlv));
 379
 380                         bnx2x_do_req4pf(sc, sc->vf2pf_mbox_mapping.paddr);
 381                         if (reply->status != BNX2X_VF_STATUS_SUCCESS)
 382                                 PMD_DRV_LOG(ERR,
 383                                             "Bad reply for vf_q %d teardown", i);
 384                 }
 385
 386                 bnx2x_vf_set_mac(sc, false);
 387
 388                 query = &sc->vf2pf_mbox->query[0].close;
 389                 bnx2x_init_first_tlv(sc, &query->first_tlv, BNX2X_VF_TLV_CLOSE,
 390                                 sizeof(*query));
 391
 392                 query->vf_id = vf_id;
 393
 394                 BNX2X_TLV_APPEND(query, query->first_tlv.length,
 395                                 BNX2X_VF_TLV_LIST_END,
 396                                 sizeof(struct channel_list_end_tlv));
 397
 398                 bnx2x_do_req4pf(sc, sc->vf2pf_mbox_mapping.paddr);
 399                 if (reply->status != BNX2X_VF_STATUS_SUCCESS)
 400                         PMD_DRV_LOG(ERR,
 401                                     "Bad reply from PF for close message");
 402         }
 403 }
 404
 405 static inline uint16_t
 406 bnx2x_vf_q_flags(uint8_t leading)
 407 {
 408         uint16_t flags = leading ? BNX2X_VF_Q_FLAG_LEADING_RSS : 0;
 409
 410         flags |= BNX2X_VF_Q_FLAG_CACHE_ALIGN;
 411         flags |= BNX2X_VF_Q_FLAG_STATS;
 412         flags |= BNX2X_VF_Q_FLAG_VLAN;
 413
 414         return flags;
 415 }
 416
 417 static void
 418 bnx2x_vf_rx_q_prep(struct bnx2x_softc *sc, struct bnx2x_fastpath *fp,
 419                 struct vf_rxq_params *rxq_init, uint16_t flags)
 420 {
 421         struct bnx2x_rx_queue *rxq;
 422
 423         rxq = sc->rx_queues[fp->index];
 424         if (!rxq) {
 425                 PMD_DRV_LOG(ERR, "RX queue %d is NULL", fp->index);
 426                 return;
 427         }
 428
 429         rxq_init->rcq_addr = rxq->cq_ring_phys_addr;
 430         rxq_init->rcq_np_addr = rxq->cq_ring_phys_addr + BNX2X_PAGE_SIZE;
 431         rxq_init->rxq_addr = rxq->rx_ring_phys_addr;
 432         rxq_init->vf_sb_id = fp->index;
 433         rxq_init->sb_cq_index = HC_INDEX_ETH_RX_CQ_CONS;
 434         rxq_init->mtu = sc->mtu;
 435         rxq_init->buf_sz = fp->rx_buf_size;
 436         rxq_init->flags = flags;
 437         rxq_init->stat_id = -1;
 438         rxq_init->cache_line_log = BNX2X_RX_ALIGN_SHIFT;
 439 }
 440
 441 static void
 442 bnx2x_vf_tx_q_prep(struct bnx2x_softc *sc, struct bnx2x_fastpath *fp,
 443                 struct vf_txq_params *txq_init, uint16_t flags)
 444 {
 445         struct bnx2x_tx_queue *txq;
 446
 447         txq = sc->tx_queues[fp->index];
 448         if (!txq) {
 449                 PMD_DRV_LOG(ERR, "TX queue %d is NULL", fp->index);
 450                 return;
 451         }
 452
 453         txq_init->txq_addr = txq->tx_ring_phys_addr;
 454         txq_init->sb_index = HC_INDEX_ETH_TX_CQ_CONS_COS0;
 455         txq_init->flags = flags;
 456         txq_init->traffic_type = LLFC_TRAFFIC_TYPE_NW;
 457         txq_init->vf_sb_id = fp->index;
 458 }
 459
 460 int
 461 bnx2x_vf_setup_queue(struct bnx2x_softc *sc, struct bnx2x_fastpath *fp, int leading)
 462 {
 463         struct vf_setup_q_tlv *query;
 464         struct vf_common_reply_tlv *reply = &sc->vf2pf_mbox->resp.common_reply;
 465         uint16_t flags = bnx2x_vf_q_flags(leading);
 466
 467         query = &sc->vf2pf_mbox->query[0].setup_q;
 468         bnx2x_init_first_tlv(sc, &query->first_tlv, BNX2X_VF_TLV_SETUP_Q,
 469                         sizeof(*query));
 470
 471         query->vf_qid = fp->index;
 472         query->param_valid = VF_RXQ_VALID | VF_TXQ_VALID;
 473
 474         bnx2x_vf_rx_q_prep(sc, fp, &query->rxq, flags);
 475         bnx2x_vf_tx_q_prep(sc, fp, &query->txq, flags);
 476
 477         BNX2X_TLV_APPEND(query, query->first_tlv.length, BNX2X_VF_TLV_LIST_END,
 478                         sizeof(struct channel_list_end_tlv));
 479
 480         bnx2x_do_req4pf(sc, sc->vf2pf_mbox_mapping.paddr);
 481         if (reply->status != BNX2X_VF_STATUS_SUCCESS) {
 482                 PMD_DRV_LOG(ERR, "Failed to setup VF queue[%d]",
 483                                  fp->index);
 484                 return -EINVAL;
 485         }
 486
 487         return 0;
 488 }
 489
 490 int
 491 bnx2x_vf_set_mac(struct bnx2x_softc *sc, int set)
 492 {
 493         struct vf_set_q_filters_tlv *query;
 494         struct vf_common_reply_tlv *reply;
 495
 496         query = &sc->vf2pf_mbox->query[0].set_q_filters;
 497         bnx2x_init_first_tlv(sc, &query->first_tlv, BNX2X_VF_TLV_SET_Q_FILTERS,
 498                         sizeof(*query));
 499
 500         query->vf_qid = sc->fp->index;
 501         query->mac_filters_cnt = 1;
 502         query->flags = BNX2X_VF_MAC_VLAN_CHANGED;
 503
 504         query->filters[0].flags = (set ? BNX2X_VF_Q_FILTER_SET_MAC : 0) |
 505                 BNX2X_VF_Q_FILTER_DEST_MAC_VALID;
 506
 507         bnx2x_check_bull(sc);
 508
 509         rte_memcpy(query->filters[0].mac, sc->link_params.mac_addr, ETH_ALEN);
 510
 511         BNX2X_TLV_APPEND(query, query->first_tlv.length, BNX2X_VF_TLV_LIST_END,
 512                         sizeof(struct channel_list_end_tlv));
 513
 514         bnx2x_do_req4pf(sc, sc->vf2pf_mbox_mapping.paddr);
 515         reply = &sc->vf2pf_mbox->resp.common_reply;
 516
 517         while (BNX2X_VF_STATUS_FAILURE == reply->status &&
 518                         bnx2x_check_bull(sc)) {
 519                 /* A new mac was configured by PF for us */
 520                 rte_memcpy(sc->link_params.mac_addr, sc->pf2vf_bulletin->mac,
 521                                 ETH_ALEN);
 522                 rte_memcpy(query->filters[0].mac, sc->pf2vf_bulletin->mac,
 523                                 ETH_ALEN);
 524
 525                 bnx2x_do_req4pf(sc, sc->vf2pf_mbox_mapping.paddr);
 526         }
 527
 528         if (BNX2X_VF_STATUS_SUCCESS != reply->status) {
 529                 PMD_DRV_LOG(ERR, "Bad reply from PF for SET MAC message: %d",
 530                                 reply->status);
 531                 return -EINVAL;
 532         }
 533
 534         return 0;
 535 }
 536
 537 int
 538 bnx2x_vf_config_rss(struct bnx2x_softc *sc,
 539                           struct ecore_config_rss_params *params)
 540 {
 541         struct vf_rss_tlv *query;
 542         struct vf_common_reply_tlv *reply = &sc->vf2pf_mbox->resp.common_reply;
 543
 544         query = &sc->vf2pf_mbox->query[0].update_rss;
 545
 546         bnx2x_init_first_tlv(sc, &query->first_tlv, BNX2X_VF_TLV_UPDATE_RSS,
 547                         sizeof(*query));
 548
 549         /* add list termination tlv */
 550         BNX2X_TLV_APPEND(query, query->first_tlv.length, BNX2X_VF_TLV_LIST_END,
 551                         sizeof(struct channel_list_end_tlv));
 552
 553         rte_memcpy(query->rss_key, params->rss_key, sizeof(params->rss_key));
 554         query->rss_key_size = T_ETH_RSS_KEY;
 555
 556         rte_memcpy(query->ind_table, params->ind_table, T_ETH_INDIRECTION_TABLE_SIZE);
 557         query->ind_table_size = T_ETH_INDIRECTION_TABLE_SIZE;
 558
 559         query->rss_result_mask = params->rss_result_mask;
 560         query->rss_flags = params->rss_flags;
 561
 562         bnx2x_do_req4pf(sc, sc->vf2pf_mbox_mapping.paddr);
 563         if (reply->status != BNX2X_VF_STATUS_SUCCESS) {
 564                 PMD_DRV_LOG(ERR, "Failed to configure RSS");
 565                 return -EINVAL;
 566         }
 567
 568         return 0;
 569 }
 570
 571 int
 572 bnx2x_vf_set_rx_mode(struct bnx2x_softc *sc)
 573 {
 574         struct vf_set_q_filters_tlv *query;
 575         struct vf_common_reply_tlv *reply = &sc->vf2pf_mbox->resp.common_reply;
 576         unsigned long tx_mask;
 577
 578         query = &sc->vf2pf_mbox->query[0].set_q_filters;
 579         bnx2x_init_first_tlv(sc, &query->first_tlv, BNX2X_VF_TLV_SET_Q_FILTERS,
 580                         sizeof(*query));
 581
 582         query->vf_qid = 0;
 583         query->flags = BNX2X_VF_RX_MASK_CHANGED;
 584
 585         if (bnx2x_fill_accept_flags(sc, sc->rx_mode, &query->rx_mask, &tx_mask)) {
 586                 return -EINVAL;
 587         }
 588
 589         BNX2X_TLV_APPEND(query, query->first_tlv.length, BNX2X_VF_TLV_LIST_END,
 590                         sizeof(struct channel_list_end_tlv));
 591
 592         bnx2x_do_req4pf(sc, sc->vf2pf_mbox_mapping.paddr);
 593         if (reply->status != BNX2X_VF_STATUS_SUCCESS) {
 594                 PMD_DRV_LOG(ERR, "Failed to set RX mode");
 595                 return -EINVAL;
 596         }
 597
 598         return 0;
 599 }