1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright (c) 2013-2015 Brocade Communications Systems, Inc. 3 * Copyright (c) 2015-2018 Cavium Inc. 4 * All rights reserved. 5 * www.cavium.com 6 */ 7 8 #include "bnx2x.h" 9 10 /* calculate the crc in the bulletin board */ 11 static inline uint32_t 12 bnx2x_vf_crc(struct bnx2x_vf_bulletin *bull) 13 { 14 uint32_t crc_sz = sizeof(bull->crc), length = bull->length - crc_sz; 15 16 return ECORE_CRC32_LE(0, (uint8_t *)bull + crc_sz, length); 17 } 18 19 /* Checks are there mac/channel updates for VF 20 * returns TRUE if something was updated 21 */ 22 int 23 bnx2x_check_bull(struct bnx2x_softc *sc) 24 { 25 struct bnx2x_vf_bulletin *bull; 26 uint8_t tries = 0; 27 uint16_t old_version = sc->old_bulletin.version; 28 uint64_t valid_bitmap; 29 30 bull = sc->pf2vf_bulletin; 31 if (old_version == bull->version) { 32 return FALSE; 33 } else { 34 /* Check the crc until we get the correct data */ 35 while (tries < BNX2X_VF_BULLETIN_TRIES) { 36 bull = sc->pf2vf_bulletin; 37 if (bull->crc == bnx2x_vf_crc(bull)) 38 break; 39 40 PMD_DRV_LOG(ERR, sc, "bad crc on bulletin board. contained %x computed %x", 41 bull->crc, bnx2x_vf_crc(bull)); 42 ++tries; 43 } 44 if (tries == BNX2X_VF_BULLETIN_TRIES) { 45 PMD_DRV_LOG(ERR, sc, "pf to vf bulletin board crc was wrong %d consecutive times. Aborting", 46 tries); 47 return FALSE; 48 } 49 } 50 51 valid_bitmap = bull->valid_bitmap; 52 53 /* check the mac address and VLAN and allocate memory if valid */ 54 if (valid_bitmap & (1 << MAC_ADDR_VALID) && memcmp(bull->mac, sc->old_bulletin.mac, ETH_ALEN)) 55 rte_memcpy(&sc->link_params.mac_addr, bull->mac, ETH_ALEN); 56 if (valid_bitmap & (1 << VLAN_VALID)) 57 rte_memcpy(&bull->vlan, &sc->old_bulletin.vlan, VLAN_HLEN); 58 59 sc->old_bulletin = *bull; 60 61 return TRUE; 62 } 63 64 /* place a given tlv on the tlv buffer at a given offset */ 65 static void 66 bnx2x_add_tlv(__rte_unused struct bnx2x_softc *sc, void *tlvs_list, 67 uint16_t offset, uint16_t type, uint16_t length) 68 { 69 struct channel_tlv *tl = (struct channel_tlv *) 70 ((unsigned long)tlvs_list + offset); 71 72 tl->type = type; 73 tl->length = length; 74 } 75 76 /* Initiliaze header of the first tlv and clear mailbox*/ 77 static void 78 bnx2x_vf_prep(struct bnx2x_softc *sc, struct vf_first_tlv *first_tlv, 79 uint16_t type, uint16_t length) 80 { 81 struct bnx2x_vf_mbx_msg *mbox = sc->vf2pf_mbox; 82 83 rte_spinlock_lock(&sc->vf2pf_lock); 84 85 PMD_DRV_LOG(DEBUG, sc, "Preparing %d tlv for sending", type); 86 87 memset(mbox, 0, sizeof(struct bnx2x_vf_mbx_msg)); 88 89 bnx2x_add_tlv(sc, &first_tlv->tl, 0, type, length); 90 91 /* Initialize header of the first tlv */ 92 first_tlv->reply_offset = sizeof(mbox->query); 93 } 94 95 /* releases the mailbox */ 96 static void 97 bnx2x_vf_finalize(struct bnx2x_softc *sc, 98 __rte_unused struct vf_first_tlv *first_tlv) 99 { 100 PMD_DRV_LOG(DEBUG, sc, "done sending [%d] tlv over vf pf channel", 101 first_tlv->tl.type); 102 103 rte_spinlock_unlock(&sc->vf2pf_lock); 104 } 105 106 #define BNX2X_VF_CMD_ADDR_LO PXP_VF_ADDR_CSDM_GLOBAL_START 107 #define BNX2X_VF_CMD_ADDR_HI BNX2X_VF_CMD_ADDR_LO + 4 108 #define BNX2X_VF_CMD_TRIGGER BNX2X_VF_CMD_ADDR_HI + 4 109 #define BNX2X_VF_CHANNEL_DELAY 100 110 #define BNX2X_VF_CHANNEL_TRIES 100 111 112 static int 113 bnx2x_do_req4pf(struct bnx2x_softc *sc, rte_iova_t phys_addr) 114 { 115 uint8_t *status = &sc->vf2pf_mbox->resp.common_reply.status; 116 uint8_t i; 117 118 if (*status) { 119 PMD_DRV_LOG(ERR, sc, "status should be zero before message" 120 " to pf was sent"); 121 return -EINVAL; 122 } 123 124 bnx2x_check_bull(sc); 125 if (sc->old_bulletin.valid_bitmap & (1 << CHANNEL_DOWN)) { 126 PMD_DRV_LOG(ERR, sc, "channel is down. Aborting message sending"); 127 return -EINVAL; 128 } 129 130 REG_WR(sc, BNX2X_VF_CMD_ADDR_LO, U64_LO(phys_addr)); 131 REG_WR(sc, BNX2X_VF_CMD_ADDR_HI, U64_HI(phys_addr)); 132 133 /* memory barrier to ensure that FW can read phys_addr */ 134 wmb(); 135 136 REG_WR8(sc, BNX2X_VF_CMD_TRIGGER, 1); 137 138 /* Do several attempts until PF completes */ 139 for (i = 0; i < BNX2X_VF_CHANNEL_TRIES; i++) { 140 DELAY_MS(BNX2X_VF_CHANNEL_DELAY); 141 if (*status) 142 break; 143 } 144 145 if (!*status) { 146 PMD_DRV_LOG(ERR, sc, "Response from PF timed out"); 147 return -EAGAIN; 148 } 149 150 PMD_DRV_LOG(DEBUG, sc, "Response from PF was received"); 151 return 0; 152 } 153 154 static inline uint16_t bnx2x_check_me_flags(uint32_t val) 155 { 156 if (((val) & ME_REG_VF_VALID) && (!((val) & ME_REG_VF_ERR))) 157 return ME_REG_VF_VALID; 158 else 159 return 0; 160 } 161 162 #define BNX2X_ME_ANSWER_DELAY 100 163 #define BNX2X_ME_ANSWER_TRIES 10 164 165 static inline int bnx2x_read_vf_id(struct bnx2x_softc *sc, uint32_t *vf_id) 166 { 167 uint32_t val; 168 uint8_t i = 0; 169 170 while (i <= BNX2X_ME_ANSWER_TRIES) { 171 val = BNX2X_DB_READ(DOORBELL_ADDR(sc, 0)); 172 if (bnx2x_check_me_flags(val)) { 173 PMD_DRV_LOG(DEBUG, sc, 174 "valid register value: 0x%08x", val); 175 *vf_id = VF_ID(val); 176 return 0; 177 } 178 179 DELAY_MS(BNX2X_ME_ANSWER_DELAY); 180 i++; 181 } 182 183 PMD_DRV_LOG(ERR, sc, "Invalid register value: 0x%08x", val); 184 185 return -EINVAL; 186 } 187 188 #define BNX2X_VF_OBTAIN_MAX_TRIES 3 189 #define BNX2X_VF_OBTAIN_MAC_FILTERS 1 190 #define BNX2X_VF_OBTAIN_MC_FILTERS 10 191 192 static 193 int bnx2x_loop_obtain_resources(struct bnx2x_softc *sc) 194 { 195 struct vf_acquire_resp_tlv *resp = &sc->vf2pf_mbox->resp.acquire_resp, 196 *sc_resp = &sc->acquire_resp; 197 struct vf_resource_query *res_query; 198 struct vf_resc *resc; 199 int res_obtained = false; 200 int tries = 0; 201 int rc; 202 203 do { 204 PMD_DRV_LOG(DEBUG, sc, "trying to get resources"); 205 206 rc = bnx2x_do_req4pf(sc, sc->vf2pf_mbox_mapping.paddr); 207 if (rc) 208 return rc; 209 210 memcpy(sc_resp, resp, sizeof(sc->acquire_resp)); 211 212 tries++; 213 214 /* check PF to request acceptance */ 215 if (sc_resp->status == BNX2X_VF_STATUS_SUCCESS) { 216 PMD_DRV_LOG(DEBUG, sc, "resources obtained successfully"); 217 res_obtained = true; 218 } else if (sc_resp->status == BNX2X_VF_STATUS_NO_RESOURCES && 219 tries < BNX2X_VF_OBTAIN_MAX_TRIES) { 220 PMD_DRV_LOG(DEBUG, sc, 221 "PF cannot allocate requested amount of resources"); 222 223 res_query = &sc->vf2pf_mbox->query[0].acquire.res_query; 224 resc = &sc_resp->resc; 225 226 /* PF refused our request. Try to decrease request params */ 227 res_query->num_txqs = min(res_query->num_txqs, resc->num_txqs); 228 res_query->num_rxqs = min(res_query->num_rxqs, resc->num_rxqs); 229 res_query->num_sbs = min(res_query->num_sbs, resc->num_sbs); 230 res_query->num_mac_filters = min(res_query->num_mac_filters, resc->num_mac_filters); 231 res_query->num_vlan_filters = min(res_query->num_vlan_filters, resc->num_vlan_filters); 232 res_query->num_mc_filters = min(res_query->num_mc_filters, resc->num_mc_filters); 233 234 memset(&sc->vf2pf_mbox->resp, 0, sizeof(union resp_tlvs)); 235 } else { 236 PMD_DRV_LOG(ERR, sc, "Failed to get the requested " 237 "amount of resources: %d.", 238 sc_resp->status); 239 return -EINVAL; 240 } 241 } while (!res_obtained); 242 243 return 0; 244 } 245 246 int bnx2x_vf_get_resources(struct bnx2x_softc *sc, uint8_t tx_count, uint8_t rx_count) 247 { 248 struct vf_acquire_tlv *acq = &sc->vf2pf_mbox->query[0].acquire; 249 uint32_t vf_id; 250 int rc; 251 252 bnx2x_vf_close(sc); 253 bnx2x_vf_prep(sc, &acq->first_tlv, BNX2X_VF_TLV_ACQUIRE, sizeof(*acq)); 254 255 if (bnx2x_read_vf_id(sc, &vf_id)) { 256 rc = -EAGAIN; 257 goto out; 258 } 259 260 acq->vf_id = vf_id; 261 262 acq->res_query.num_rxqs = rx_count; 263 acq->res_query.num_txqs = tx_count; 264 acq->res_query.num_sbs = sc->igu_sb_cnt; 265 acq->res_query.num_mac_filters = BNX2X_VF_OBTAIN_MAC_FILTERS; 266 acq->res_query.num_mc_filters = BNX2X_VF_OBTAIN_MC_FILTERS; 267 268 acq->bulletin_addr = sc->pf2vf_bulletin_mapping.paddr; 269 270 /* Request physical port identifier */ 271 bnx2x_add_tlv(sc, acq, acq->first_tlv.tl.length, 272 BNX2X_VF_TLV_PHYS_PORT_ID, 273 sizeof(struct channel_tlv)); 274 275 bnx2x_add_tlv(sc, acq, 276 (acq->first_tlv.tl.length + sizeof(struct channel_tlv)), 277 BNX2X_VF_TLV_LIST_END, 278 sizeof(struct channel_list_end_tlv)); 279 280 /* requesting the resources in loop */ 281 rc = bnx2x_loop_obtain_resources(sc); 282 if (rc) 283 goto out; 284 285 struct vf_acquire_resp_tlv sc_resp = sc->acquire_resp; 286 287 sc->devinfo.chip_id |= (sc_resp.chip_num & 0xFFFF); 288 sc->devinfo.int_block = INT_BLOCK_IGU; 289 sc->devinfo.chip_port_mode = CHIP_2_PORT_MODE; 290 sc->devinfo.mf_info.mf_ov = 0; 291 sc->devinfo.mf_info.mf_mode = 0; 292 sc->devinfo.flash_size = 0; 293 294 sc->igu_sb_cnt = sc_resp.resc.num_sbs; 295 sc->igu_base_sb = sc_resp.resc.hw_sbs[0] & 0xFF; 296 sc->igu_dsb_id = -1; 297 sc->max_tx_queues = sc_resp.resc.num_txqs; 298 sc->max_rx_queues = sc_resp.resc.num_rxqs; 299 300 sc->link_params.chip_id = sc->devinfo.chip_id; 301 sc->doorbell_size = sc_resp.db_size; 302 sc->flags |= BNX2X_NO_WOL_FLAG | BNX2X_NO_ISCSI_OOO_FLAG | BNX2X_NO_ISCSI_FLAG | BNX2X_NO_FCOE_FLAG; 303 304 PMD_DRV_LOG(DEBUG, sc, "status block count = %d, base status block = %x", 305 sc->igu_sb_cnt, sc->igu_base_sb); 306 strncpy(sc->fw_ver, sc_resp.fw_ver, sizeof(sc->fw_ver)); 307 308 if (rte_is_valid_assigned_ether_addr(&sc_resp.resc.current_mac_addr)) 309 rte_ether_addr_copy(&sc_resp.resc.current_mac_addr, 310 (struct rte_ether_addr *)sc->link_params.mac_addr); 311 else 312 rte_eth_random_addr(sc->link_params.mac_addr); 313 314 out: 315 bnx2x_vf_finalize(sc, &acq->first_tlv); 316 317 return rc; 318 } 319 320 /* Ask PF to release VF's resources */ 321 void 322 bnx2x_vf_close(struct bnx2x_softc *sc) 323 { 324 struct vf_release_tlv *query; 325 struct vf_common_reply_tlv *reply = &sc->vf2pf_mbox->resp.common_reply; 326 uint32_t vf_id; 327 int rc; 328 329 query = &sc->vf2pf_mbox->query[0].release; 330 bnx2x_vf_prep(sc, &query->first_tlv, BNX2X_VF_TLV_RELEASE, 331 sizeof(*query)); 332 333 if (bnx2x_read_vf_id(sc, &vf_id)) { 334 rc = -EAGAIN; 335 goto out; 336 } 337 338 query->vf_id = vf_id; 339 340 bnx2x_add_tlv(sc, query, query->first_tlv.tl.length, 341 BNX2X_VF_TLV_LIST_END, 342 sizeof(struct channel_list_end_tlv)); 343 344 rc = bnx2x_do_req4pf(sc, sc->vf2pf_mbox_mapping.paddr); 345 if (rc || reply->status != BNX2X_VF_STATUS_SUCCESS) 346 PMD_DRV_LOG(ERR, sc, "Failed to release VF"); 347 348 out: 349 bnx2x_vf_finalize(sc, &query->first_tlv); 350 } 351 352 /* Let PF know the VF status blocks phys_addrs */ 353 int 354 bnx2x_vf_init(struct bnx2x_softc *sc) 355 { 356 struct vf_init_tlv *query; 357 struct vf_common_reply_tlv *reply = &sc->vf2pf_mbox->resp.common_reply; 358 int i, rc; 359 360 PMD_INIT_FUNC_TRACE(sc); 361 362 query = &sc->vf2pf_mbox->query[0].init; 363 bnx2x_vf_prep(sc, &query->first_tlv, BNX2X_VF_TLV_INIT, 364 sizeof(*query)); 365 366 FOR_EACH_QUEUE(sc, i) { 367 query->sb_addr[i] = (unsigned long)(sc->fp[i].sb_dma.paddr); 368 } 369 370 query->stats_step = sizeof(struct per_queue_stats); 371 query->stats_addr = sc->fw_stats_data_mapping + 372 offsetof(struct bnx2x_fw_stats_data, queue_stats); 373 374 bnx2x_add_tlv(sc, query, query->first_tlv.tl.length, 375 BNX2X_VF_TLV_LIST_END, 376 sizeof(struct channel_list_end_tlv)); 377 378 rc = bnx2x_do_req4pf(sc, sc->vf2pf_mbox_mapping.paddr); 379 if (rc) 380 goto out; 381 if (reply->status != BNX2X_VF_STATUS_SUCCESS) { 382 PMD_DRV_LOG(ERR, sc, "Failed to init VF"); 383 rc = -EINVAL; 384 goto out; 385 } 386 387 PMD_DRV_LOG(DEBUG, sc, "VF was initialized"); 388 out: 389 bnx2x_vf_finalize(sc, &query->first_tlv); 390 return rc; 391 } 392 393 void 394 bnx2x_vf_unload(struct bnx2x_softc *sc) 395 { 396 struct vf_close_tlv *query; 397 struct vf_common_reply_tlv *reply = &sc->vf2pf_mbox->resp.common_reply; 398 uint32_t vf_id; 399 int i, rc; 400 401 PMD_INIT_FUNC_TRACE(sc); 402 403 FOR_EACH_QUEUE(sc, i) 404 bnx2x_vf_teardown_queue(sc, i); 405 406 bnx2x_vf_set_mac(sc, false); 407 408 query = &sc->vf2pf_mbox->query[0].close; 409 bnx2x_vf_prep(sc, &query->first_tlv, BNX2X_VF_TLV_CLOSE, 410 sizeof(*query)); 411 412 if (bnx2x_read_vf_id(sc, &vf_id)) { 413 rc = -EAGAIN; 414 goto out; 415 } 416 417 query->vf_id = vf_id; 418 419 bnx2x_add_tlv(sc, query, query->first_tlv.tl.length, 420 BNX2X_VF_TLV_LIST_END, 421 sizeof(struct channel_list_end_tlv)); 422 423 rc = bnx2x_do_req4pf(sc, sc->vf2pf_mbox_mapping.paddr); 424 if (rc || reply->status != BNX2X_VF_STATUS_SUCCESS) 425 PMD_DRV_LOG(ERR, sc, 426 "Bad reply from PF for close message"); 427 428 out: 429 bnx2x_vf_finalize(sc, &query->first_tlv); 430 } 431 432 static inline uint16_t 433 bnx2x_vf_q_flags(uint8_t leading) 434 { 435 uint16_t flags = leading ? BNX2X_VF_Q_FLAG_LEADING_RSS : 0; 436 437 flags |= BNX2X_VF_Q_FLAG_CACHE_ALIGN; 438 flags |= BNX2X_VF_Q_FLAG_STATS; 439 flags |= BNX2X_VF_Q_FLAG_VLAN; 440 441 return flags; 442 } 443 444 static void 445 bnx2x_vf_rx_q_prep(struct bnx2x_softc *sc, struct bnx2x_fastpath *fp, 446 struct vf_rxq_params *rxq_init, uint16_t flags) 447 { 448 struct bnx2x_rx_queue *rxq; 449 450 rxq = sc->rx_queues[fp->index]; 451 if (!rxq) { 452 PMD_DRV_LOG(ERR, sc, "RX queue %d is NULL", fp->index); 453 return; 454 } 455 456 rxq_init->rcq_addr = rxq->cq_ring_phys_addr; 457 rxq_init->rcq_np_addr = rxq->cq_ring_phys_addr + BNX2X_PAGE_SIZE; 458 rxq_init->rxq_addr = rxq->rx_ring_phys_addr; 459 rxq_init->vf_sb_id = fp->index; 460 rxq_init->sb_cq_index = HC_INDEX_ETH_RX_CQ_CONS; 461 rxq_init->mtu = sc->mtu; 462 rxq_init->buf_sz = fp->rx_buf_size; 463 rxq_init->flags = flags; 464 rxq_init->stat_id = -1; 465 rxq_init->cache_line_log = BNX2X_RX_ALIGN_SHIFT; 466 } 467 468 static void 469 bnx2x_vf_tx_q_prep(struct bnx2x_softc *sc, struct bnx2x_fastpath *fp, 470 struct vf_txq_params *txq_init, uint16_t flags) 471 { 472 struct bnx2x_tx_queue *txq; 473 474 txq = sc->tx_queues[fp->index]; 475 if (!txq) { 476 PMD_DRV_LOG(ERR, sc, "TX queue %d is NULL", fp->index); 477 return; 478 } 479 480 txq_init->txq_addr = txq->tx_ring_phys_addr; 481 txq_init->sb_index = HC_INDEX_ETH_TX_CQ_CONS_COS0; 482 txq_init->flags = flags; 483 txq_init->traffic_type = LLFC_TRAFFIC_TYPE_NW; 484 txq_init->vf_sb_id = fp->index; 485 } 486 487 int 488 bnx2x_vf_setup_queue(struct bnx2x_softc *sc, struct bnx2x_fastpath *fp, int leading) 489 { 490 struct vf_setup_q_tlv *query; 491 struct vf_common_reply_tlv *reply = &sc->vf2pf_mbox->resp.common_reply; 492 uint16_t flags = bnx2x_vf_q_flags(leading); 493 int rc; 494 495 query = &sc->vf2pf_mbox->query[0].setup_q; 496 bnx2x_vf_prep(sc, &query->first_tlv, BNX2X_VF_TLV_SETUP_Q, 497 sizeof(*query)); 498 499 query->vf_qid = fp->index; 500 query->param_valid = VF_RXQ_VALID | VF_TXQ_VALID; 501 502 bnx2x_vf_rx_q_prep(sc, fp, &query->rxq, flags); 503 bnx2x_vf_tx_q_prep(sc, fp, &query->txq, flags); 504 505 bnx2x_add_tlv(sc, query, query->first_tlv.tl.length, 506 BNX2X_VF_TLV_LIST_END, 507 sizeof(struct channel_list_end_tlv)); 508 509 rc = bnx2x_do_req4pf(sc, sc->vf2pf_mbox_mapping.paddr); 510 if (rc) 511 goto out; 512 if (reply->status != BNX2X_VF_STATUS_SUCCESS) { 513 PMD_DRV_LOG(ERR, sc, "Failed to setup VF queue[%d]", 514 fp->index); 515 rc = -EINVAL; 516 } 517 out: 518 bnx2x_vf_finalize(sc, &query->first_tlv); 519 520 return rc; 521 } 522 523 int 524 bnx2x_vf_teardown_queue(struct bnx2x_softc *sc, int qid) 525 { 526 struct vf_q_op_tlv *query_op; 527 struct vf_common_reply_tlv *reply = &sc->vf2pf_mbox->resp.common_reply; 528 int rc; 529 530 query_op = &sc->vf2pf_mbox->query[0].q_op; 531 bnx2x_vf_prep(sc, &query_op->first_tlv, 532 BNX2X_VF_TLV_TEARDOWN_Q, 533 sizeof(*query_op)); 534 535 query_op->vf_qid = qid; 536 537 bnx2x_add_tlv(sc, query_op, 538 query_op->first_tlv.tl.length, 539 BNX2X_VF_TLV_LIST_END, 540 sizeof(struct channel_list_end_tlv)); 541 542 rc = bnx2x_do_req4pf(sc, sc->vf2pf_mbox_mapping.paddr); 543 if (rc || reply->status != BNX2X_VF_STATUS_SUCCESS) 544 PMD_DRV_LOG(ERR, sc, 545 "Bad reply for vf_q %d teardown", qid); 546 547 bnx2x_vf_finalize(sc, &query_op->first_tlv); 548 549 return rc; 550 } 551 552 int 553 bnx2x_vf_set_mac(struct bnx2x_softc *sc, int set) 554 { 555 struct vf_set_q_filters_tlv *query; 556 struct vf_common_reply_tlv *reply; 557 int rc; 558 559 query = &sc->vf2pf_mbox->query[0].set_q_filters; 560 bnx2x_vf_prep(sc, &query->first_tlv, BNX2X_VF_TLV_SET_Q_FILTERS, 561 sizeof(*query)); 562 563 query->vf_qid = sc->fp->index; 564 query->mac_filters_cnt = 1; 565 query->flags = BNX2X_VF_MAC_VLAN_CHANGED; 566 567 query->filters[0].flags = (set ? BNX2X_VF_Q_FILTER_SET_MAC : 0) | 568 BNX2X_VF_Q_FILTER_DEST_MAC_VALID; 569 570 bnx2x_check_bull(sc); 571 572 rte_memcpy(query->filters[0].mac, sc->link_params.mac_addr, ETH_ALEN); 573 574 bnx2x_add_tlv(sc, query, query->first_tlv.tl.length, 575 BNX2X_VF_TLV_LIST_END, 576 sizeof(struct channel_list_end_tlv)); 577 578 rc = bnx2x_do_req4pf(sc, sc->vf2pf_mbox_mapping.paddr); 579 if (rc) 580 goto out; 581 reply = &sc->vf2pf_mbox->resp.common_reply; 582 583 while (BNX2X_VF_STATUS_FAILURE == reply->status && 584 bnx2x_check_bull(sc)) { 585 /* A new mac was configured by PF for us */ 586 rte_memcpy(sc->link_params.mac_addr, sc->pf2vf_bulletin->mac, 587 ETH_ALEN); 588 rte_memcpy(query->filters[0].mac, sc->pf2vf_bulletin->mac, 589 ETH_ALEN); 590 591 rc = bnx2x_do_req4pf(sc, sc->vf2pf_mbox_mapping.paddr); 592 if (rc) 593 goto out; 594 } 595 596 if (BNX2X_VF_STATUS_SUCCESS != reply->status) { 597 PMD_DRV_LOG(ERR, sc, "Bad reply from PF for SET MAC message: %d", 598 reply->status); 599 rc = -EINVAL; 600 } 601 out: 602 bnx2x_vf_finalize(sc, &query->first_tlv); 603 604 return rc; 605 } 606 607 int 608 bnx2x_vf_config_rss(struct bnx2x_softc *sc, 609 struct ecore_config_rss_params *params) 610 { 611 struct vf_rss_tlv *query; 612 struct vf_common_reply_tlv *reply = &sc->vf2pf_mbox->resp.common_reply; 613 int rc; 614 615 query = &sc->vf2pf_mbox->query[0].update_rss; 616 617 bnx2x_vf_prep(sc, &query->first_tlv, BNX2X_VF_TLV_UPDATE_RSS, 618 sizeof(*query)); 619 620 /* add list termination tlv */ 621 bnx2x_add_tlv(sc, query, query->first_tlv.tl.length, 622 BNX2X_VF_TLV_LIST_END, 623 sizeof(struct channel_list_end_tlv)); 624 625 rte_memcpy(query->rss_key, params->rss_key, sizeof(params->rss_key)); 626 query->rss_key_size = T_ETH_RSS_KEY; 627 628 rte_memcpy(query->ind_table, params->ind_table, T_ETH_INDIRECTION_TABLE_SIZE); 629 query->ind_table_size = T_ETH_INDIRECTION_TABLE_SIZE; 630 631 query->rss_result_mask = params->rss_result_mask; 632 query->rss_flags = params->rss_flags; 633 634 rc = bnx2x_do_req4pf(sc, sc->vf2pf_mbox_mapping.paddr); 635 if (rc) 636 goto out; 637 638 if (reply->status != BNX2X_VF_STATUS_SUCCESS) { 639 PMD_DRV_LOG(ERR, sc, "Failed to configure RSS"); 640 rc = -EINVAL; 641 } 642 out: 643 bnx2x_vf_finalize(sc, &query->first_tlv); 644 645 return rc; 646 } 647 648 int 649 bnx2x_vf_set_rx_mode(struct bnx2x_softc *sc) 650 { 651 struct vf_set_q_filters_tlv *query; 652 struct vf_common_reply_tlv *reply = &sc->vf2pf_mbox->resp.common_reply; 653 int rc; 654 655 query = &sc->vf2pf_mbox->query[0].set_q_filters; 656 bnx2x_vf_prep(sc, &query->first_tlv, BNX2X_VF_TLV_SET_Q_FILTERS, 657 sizeof(*query)); 658 659 query->vf_qid = 0; 660 query->flags = BNX2X_VF_RX_MASK_CHANGED; 661 662 switch (sc->rx_mode) { 663 case BNX2X_RX_MODE_NONE: /* no Rx */ 664 query->rx_mask = VFPF_RX_MASK_ACCEPT_NONE; 665 break; 666 case BNX2X_RX_MODE_NORMAL: 667 query->rx_mask = VFPF_RX_MASK_ACCEPT_MATCHED_MULTICAST; 668 query->rx_mask |= VFPF_RX_MASK_ACCEPT_MATCHED_UNICAST; 669 query->rx_mask |= VFPF_RX_MASK_ACCEPT_BROADCAST; 670 break; 671 case BNX2X_RX_MODE_ALLMULTI: 672 query->rx_mask = VFPF_RX_MASK_ACCEPT_ALL_MULTICAST; 673 query->rx_mask |= VFPF_RX_MASK_ACCEPT_MATCHED_UNICAST; 674 query->rx_mask |= VFPF_RX_MASK_ACCEPT_BROADCAST; 675 break; 676 case BNX2X_RX_MODE_ALLMULTI_PROMISC: 677 case BNX2X_RX_MODE_PROMISC: 678 query->rx_mask = VFPF_RX_MASK_ACCEPT_ALL_UNICAST; 679 query->rx_mask |= VFPF_RX_MASK_ACCEPT_ALL_MULTICAST; 680 query->rx_mask |= VFPF_RX_MASK_ACCEPT_BROADCAST; 681 break; 682 default: 683 PMD_DRV_LOG(ERR, sc, "BAD rx mode (%d)", sc->rx_mode); 684 rc = -EINVAL; 685 goto out; 686 } 687 688 bnx2x_add_tlv(sc, query, query->first_tlv.tl.length, 689 BNX2X_VF_TLV_LIST_END, 690 sizeof(struct channel_list_end_tlv)); 691 692 rc = bnx2x_do_req4pf(sc, sc->vf2pf_mbox_mapping.paddr); 693 if (rc) 694 goto out; 695 696 if (reply->status != BNX2X_VF_STATUS_SUCCESS) { 697 PMD_DRV_LOG(ERR, sc, "Failed to set RX mode"); 698 rc = -EINVAL; 699 } 700 701 out: 702 bnx2x_vf_finalize(sc, &query->first_tlv); 703 704 return rc; 705 } 706 707 int 708 bnx2x_vfpf_set_mcast(struct bnx2x_softc *sc, 709 struct rte_ether_addr *mc_addrs, 710 uint32_t mc_addrs_num) 711 { 712 struct vf_set_q_filters_tlv *query; 713 struct vf_common_reply_tlv *reply = 714 &sc->vf2pf_mbox->resp.common_reply; 715 int rc = 0; 716 uint32_t i = 0; 717 query = &sc->vf2pf_mbox->query[0].set_q_filters; 718 bnx2x_vf_prep(sc, &query->first_tlv, BNX2X_VF_TLV_SET_Q_FILTERS, 719 sizeof(*query)); 720 /* We support PFVF_MAX_MULTICAST_PER_VF mcast addresses tops */ 721 if (mc_addrs_num > VF_MAX_MULTICAST_PER_VF) { 722 PMD_DRV_LOG(ERR, sc, 723 "VF supports not more than %d multicast MAC addresses", 724 VF_MAX_MULTICAST_PER_VF); 725 726 rc = -EINVAL; 727 goto out; 728 } 729 730 for (i = 0; i < mc_addrs_num; i++) { 731 PMD_DRV_LOG(DEBUG, sc, "Adding mcast MAC:%x:%x:%x:%x:%x:%x", 732 mc_addrs[i].addr_bytes[0], 733 mc_addrs[i].addr_bytes[1], 734 mc_addrs[i].addr_bytes[2], 735 mc_addrs[i].addr_bytes[3], 736 mc_addrs[i].addr_bytes[4], 737 mc_addrs[i].addr_bytes[5]); 738 memcpy(query->multicast[i], mc_addrs[i].addr_bytes, ETH_ALEN); 739 } 740 741 query->vf_qid = 0; 742 query->flags = BNX2X_VF_MULTICAST_CHANGED; 743 query->multicast_cnt = i; 744 745 /* add list termination tlv */ 746 bnx2x_add_tlv(sc, query, query->first_tlv.tl.length, 747 BNX2X_VF_TLV_LIST_END, 748 sizeof(struct channel_list_end_tlv)); 749 rc = bnx2x_do_req4pf(sc, sc->vf2pf_mbox_mapping.paddr); 750 if (rc) 751 goto out; 752 753 if (reply->status != BNX2X_VF_STATUS_SUCCESS) { 754 PMD_DRV_LOG(ERR, sc, "Set Rx mode/multicast failed: %d", 755 reply->status); 756 rc = -EINVAL; 757 } 758 759 out: 760 bnx2x_vf_finalize(sc, &query->first_tlv); 761 762 return rc; 763 } 764