drivers/net/bnx2x/bnx2x_vfpf.c

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