kernel/drivers/net/ethernet/broadcom/bnx2x/bnx2x_vfpf.c

   1 /* bnx2x_vfpf.c: Broadcom Everest network driver.
   2  *
   3  * Copyright 2009-2013 Broadcom Corporation
   4  *
   5  * Unless you and Broadcom execute a separate written software license
   6  * agreement governing use of this software, this software is licensed to you
   7  * under the terms of the GNU General Public License version 2, available
   8  * at http://www.gnu.org/licenses/old-licenses/gpl-2.0.html (the "GPL").
   9  *
  10  * Notwithstanding the above, under no circumstances may you combine this
  11  * software in any way with any other Broadcom software provided under a
  12  * license other than the GPL, without Broadcom's express prior written
  13  * consent.
  14  *
  15  * Maintained by: Ariel Elior <ariel.elior@qlogic.com>
  16  * Written by: Shmulik Ravid
  17  *             Ariel Elior <ariel.elior@qlogic.com>
  18  */
  19
  20 #include "bnx2x.h"
  21 #include "bnx2x_cmn.h"
  22 #include <linux/crc32.h>
  23
  24 static int bnx2x_vfpf_teardown_queue(struct bnx2x *bp, int qidx);
  25
  26 /* place a given tlv on the tlv buffer at a given offset */
  27 static void bnx2x_add_tlv(struct bnx2x *bp, void *tlvs_list,
  28                           u16 offset, u16 type, u16 length)
  29 {
  30         struct channel_tlv *tl =
  31                 (struct channel_tlv *)(tlvs_list + offset);
  32
  33         tl->type = type;
  34         tl->length = length;
  35 }
  36
  37 /* Clear the mailbox and init the header of the first tlv */
  38 static void bnx2x_vfpf_prep(struct bnx2x *bp, struct vfpf_first_tlv *first_tlv,
  39                             u16 type, u16 length)
  40 {
  41         mutex_lock(&bp->vf2pf_mutex);
  42
  43         DP(BNX2X_MSG_IOV, "preparing to send %d tlv over vf pf channel\n",
  44            type);
  45
  46         /* Clear mailbox */
  47         memset(bp->vf2pf_mbox, 0, sizeof(struct bnx2x_vf_mbx_msg));
  48
  49         /* init type and length */
  50         bnx2x_add_tlv(bp, &first_tlv->tl, 0, type, length);
  51
  52         /* init first tlv header */
  53         first_tlv->resp_msg_offset = sizeof(bp->vf2pf_mbox->req);
  54 }
  55
  56 /* releases the mailbox */
  57 static void bnx2x_vfpf_finalize(struct bnx2x *bp,
  58                                 struct vfpf_first_tlv *first_tlv)
  59 {
  60         DP(BNX2X_MSG_IOV, "done sending [%d] tlv over vf pf channel\n",
  61            first_tlv->tl.type);
  62
  63         mutex_unlock(&bp->vf2pf_mutex);
  64 }
  65
  66 /* Finds a TLV by type in a TLV buffer; If found, returns pointer to the TLV */
  67 static void *bnx2x_search_tlv_list(struct bnx2x *bp, void *tlvs_list,
  68                                    enum channel_tlvs req_tlv)
  69 {
  70         struct channel_tlv *tlv = (struct channel_tlv *)tlvs_list;
  71
  72         do {
  73                 if (tlv->type == req_tlv)
  74                         return tlv;
  75
  76                 if (!tlv->length) {
  77                         BNX2X_ERR("Found TLV with length 0\n");
  78                         return NULL;
  79                 }
  80
  81                 tlvs_list += tlv->length;
  82                 tlv = (struct channel_tlv *)tlvs_list;
  83         } while (tlv->type != CHANNEL_TLV_LIST_END);
  84
  85         DP(BNX2X_MSG_IOV, "TLV list does not contain %d TLV\n", req_tlv);
  86
  87         return NULL;
  88 }
  89
  90 /* list the types and lengths of the tlvs on the buffer */
  91 static void bnx2x_dp_tlv_list(struct bnx2x *bp, void *tlvs_list)
  92 {
  93         int i = 1;
  94         struct channel_tlv *tlv = (struct channel_tlv *)tlvs_list;
  95
  96         while (tlv->type != CHANNEL_TLV_LIST_END) {
  97                 /* output tlv */
  98                 DP(BNX2X_MSG_IOV, "TLV number %d: type %d, length %d\n", i,
  99                    tlv->type, tlv->length);
 100
 101                 /* advance to next tlv */
 102                 tlvs_list += tlv->length;
 103
 104                 /* cast general tlv list pointer to channel tlv header*/
 105                 tlv = (struct channel_tlv *)tlvs_list;
 106
 107                 i++;
 108
 109                 /* break condition for this loop */
 110                 if (i > MAX_TLVS_IN_LIST) {
 111                         WARN(true, "corrupt tlvs");
 112                         return;
 113                 }
 114         }
 115
 116         /* output last tlv */
 117         DP(BNX2X_MSG_IOV, "TLV number %d: type %d, length %d\n", i,
 118            tlv->type, tlv->length);
 119 }
 120
 121 /* test whether we support a tlv type */
 122 bool bnx2x_tlv_supported(u16 tlvtype)
 123 {
 124         return CHANNEL_TLV_NONE < tlvtype && tlvtype < CHANNEL_TLV_MAX;
 125 }
 126
 127 static inline int bnx2x_pfvf_status_codes(int rc)
 128 {
 129         switch (rc) {
 130         case 0:
 131                 return PFVF_STATUS_SUCCESS;
 132         case -ENOMEM:
 133                 return PFVF_STATUS_NO_RESOURCE;
 134         default:
 135                 return PFVF_STATUS_FAILURE;
 136         }
 137 }
 138
 139 static int bnx2x_send_msg2pf(struct bnx2x *bp, u8 *done, dma_addr_t msg_mapping)
 140 {
 141         struct cstorm_vf_zone_data __iomem *zone_data =
 142                 REG_ADDR(bp, PXP_VF_ADDR_CSDM_GLOBAL_START);
 143         int tout = 100, interval = 100; /* wait for 10 seconds */
 144
 145         if (*done) {
 146                 BNX2X_ERR("done was non zero before message to pf was sent\n");
 147                 WARN_ON(true);
 148                 return -EINVAL;
 149         }
 150
 151         /* if PF indicated channel is down avoid sending message. Return success
 152          * so calling flow can continue
 153          */
 154         bnx2x_sample_bulletin(bp);
 155         if (bp->old_bulletin.valid_bitmap & 1 << CHANNEL_DOWN) {
 156                 DP(BNX2X_MSG_IOV, "detecting channel down. Aborting message\n");
 157                 *done = PFVF_STATUS_SUCCESS;
 158                 return -EINVAL;
 159         }
 160
 161         /* Write message address */
 162         writel(U64_LO(msg_mapping),
 163                &zone_data->non_trigger.vf_pf_channel.msg_addr_lo);
 164         writel(U64_HI(msg_mapping),
 165                &zone_data->non_trigger.vf_pf_channel.msg_addr_hi);
 166
 167         /* make sure the address is written before FW accesses it */
 168         wmb();
 169
 170         /* Trigger the PF FW */
 171         writeb(1, &zone_data->trigger.vf_pf_channel.addr_valid);
 172
 173         /* Wait for PF to complete */
 174         while ((tout >= 0) && (!*done)) {
 175                 msleep(interval);
 176                 tout -= 1;
 177
 178                 /* progress indicator - HV can take its own sweet time in
 179                  * answering VFs...
 180                  */
 181                 DP_CONT(BNX2X_MSG_IOV, ".");
 182         }
 183
 184         if (!*done) {
 185                 BNX2X_ERR("PF response has timed out\n");
 186                 return -EAGAIN;
 187         }
 188         DP(BNX2X_MSG_SP, "Got a response from PF\n");
 189         return 0;
 190 }
 191
 192 static int bnx2x_get_vf_id(struct bnx2x *bp, u32 *vf_id)
 193 {
 194         u32 me_reg;
 195         int tout = 10, interval = 100; /* Wait for 1 sec */
 196
 197         do {
 198                 /* pxp traps vf read of doorbells and returns me reg value */
 199                 me_reg = readl(bp->doorbells);
 200                 if (GOOD_ME_REG(me_reg))
 201                         break;
 202
 203                 msleep(interval);
 204
 205                 BNX2X_ERR("Invalid ME register value: 0x%08x\n. Is pf driver up?",
 206                           me_reg);
 207         } while (tout-- > 0);
 208
 209         if (!GOOD_ME_REG(me_reg)) {
 210                 BNX2X_ERR("Invalid ME register value: 0x%08x\n", me_reg);
 211                 return -EINVAL;
 212         }
 213
 214         DP(BNX2X_MSG_IOV, "valid ME register value: 0x%08x\n", me_reg);
 215
 216         *vf_id = (me_reg & ME_REG_VF_NUM_MASK) >> ME_REG_VF_NUM_SHIFT;
 217
 218         return 0;
 219 }
 220
 221 int bnx2x_vfpf_acquire(struct bnx2x *bp, u8 tx_count, u8 rx_count)
 222 {
 223         int rc = 0, attempts = 0;
 224         struct vfpf_acquire_tlv *req = &bp->vf2pf_mbox->req.acquire;
 225         struct pfvf_acquire_resp_tlv *resp = &bp->vf2pf_mbox->resp.acquire_resp;
 226         struct vfpf_port_phys_id_resp_tlv *phys_port_resp;
 227         struct vfpf_fp_hsi_resp_tlv *fp_hsi_resp;
 228         u32 vf_id;
 229         bool resources_acquired = false;
 230
 231         /* clear mailbox and prep first tlv */
 232         bnx2x_vfpf_prep(bp, &req->first_tlv, CHANNEL_TLV_ACQUIRE, sizeof(*req));
 233
 234         if (bnx2x_get_vf_id(bp, &vf_id)) {
 235                 rc = -EAGAIN;
 236                 goto out;
 237         }
 238
 239         req->vfdev_info.vf_id = vf_id;
 240         req->vfdev_info.vf_os = 0;
 241         req->vfdev_info.fp_hsi_ver = ETH_FP_HSI_VERSION;
 242
 243         req->resc_request.num_rxqs = rx_count;
 244         req->resc_request.num_txqs = tx_count;
 245         req->resc_request.num_sbs = bp->igu_sb_cnt;
 246         req->resc_request.num_mac_filters = VF_ACQUIRE_MAC_FILTERS;
 247         req->resc_request.num_mc_filters = VF_ACQUIRE_MC_FILTERS;
 248
 249         /* pf 2 vf bulletin board address */
 250         req->bulletin_addr = bp->pf2vf_bulletin_mapping;
 251
 252         /* Request physical port identifier */
 253         bnx2x_add_tlv(bp, req, req->first_tlv.tl.length,
 254                       CHANNEL_TLV_PHYS_PORT_ID, sizeof(struct channel_tlv));
 255
 256         /* Bulletin support for bulletin board with length > legacy length */
 257         req->vfdev_info.caps |= VF_CAP_SUPPORT_EXT_BULLETIN;
 258
 259         /* add list termination tlv */
 260         bnx2x_add_tlv(bp, req,
 261                       req->first_tlv.tl.length + sizeof(struct channel_tlv),
 262                       CHANNEL_TLV_LIST_END,
 263                       sizeof(struct channel_list_end_tlv));
 264
 265         /* output tlvs list */
 266         bnx2x_dp_tlv_list(bp, req);
 267
 268         while (!resources_acquired) {
 269                 DP(BNX2X_MSG_SP, "attempting to acquire resources\n");
 270
 271                 /* send acquire request */
 272                 rc = bnx2x_send_msg2pf(bp,
 273                                        &resp->hdr.status,
 274                                        bp->vf2pf_mbox_mapping);
 275
 276                 /* PF timeout */
 277                 if (rc)
 278                         goto out;
 279
 280                 /* copy acquire response from buffer to bp */
 281                 memcpy(&bp->acquire_resp, resp, sizeof(bp->acquire_resp));
 282
 283                 attempts++;
 284
 285                 /* test whether the PF accepted our request. If not, humble
 286                  * the request and try again.
 287                  */
 288                 if (bp->acquire_resp.hdr.status == PFVF_STATUS_SUCCESS) {
 289                         DP(BNX2X_MSG_SP, "resources acquired\n");
 290                         resources_acquired = true;
 291                 } else if (bp->acquire_resp.hdr.status ==
 292                            PFVF_STATUS_NO_RESOURCE &&
 293                            attempts < VF_ACQUIRE_THRESH) {
 294                         DP(BNX2X_MSG_SP,
 295                            "PF unwilling to fulfill resource request. Try PF recommended amount\n");
 296
 297                         /* humble our request */
 298                         req->resc_request.num_txqs =
 299                                 min(req->resc_request.num_txqs,
 300                                     bp->acquire_resp.resc.num_txqs);
 301                         req->resc_request.num_rxqs =
 302                                 min(req->resc_request.num_rxqs,
 303                                     bp->acquire_resp.resc.num_rxqs);
 304                         req->resc_request.num_sbs =
 305                                 min(req->resc_request.num_sbs,
 306                                     bp->acquire_resp.resc.num_sbs);
 307                         req->resc_request.num_mac_filters =
 308                                 min(req->resc_request.num_mac_filters,
 309                                     bp->acquire_resp.resc.num_mac_filters);
 310                         req->resc_request.num_vlan_filters =
 311                                 min(req->resc_request.num_vlan_filters,
 312                                     bp->acquire_resp.resc.num_vlan_filters);
 313                         req->resc_request.num_mc_filters =
 314                                 min(req->resc_request.num_mc_filters,
 315                                     bp->acquire_resp.resc.num_mc_filters);
 316
 317                         /* Clear response buffer */
 318                         memset(&bp->vf2pf_mbox->resp, 0,
 319                                sizeof(union pfvf_tlvs));
 320                 } else {
 321                         /* Determine reason of PF failure of acquire process */
 322                         fp_hsi_resp = bnx2x_search_tlv_list(bp, resp,
 323                                                             CHANNEL_TLV_FP_HSI_SUPPORT);
 324                         if (fp_hsi_resp && !fp_hsi_resp->is_supported)
 325                                 BNX2X_ERR("Old hypervisor - doesn't support current fastpath HSI version; Need to downgrade VF driver [or upgrade hypervisor]\n");
 326                         else
 327                                 BNX2X_ERR("Failed to get the requested amount of resources: %d. Breaking...\n",
 328                                           bp->acquire_resp.hdr.status);
 329                         rc = -EAGAIN;
 330                         goto out;
 331                 }
 332         }
 333
 334         /* Retrieve physical port id (if possible) */
 335         phys_port_resp = (struct vfpf_port_phys_id_resp_tlv *)
 336                          bnx2x_search_tlv_list(bp, resp,
 337                                                CHANNEL_TLV_PHYS_PORT_ID);
 338         if (phys_port_resp) {
 339                 memcpy(bp->phys_port_id, phys_port_resp->id, ETH_ALEN);
 340                 bp->flags |= HAS_PHYS_PORT_ID;
 341         }
 342
 343         /* Old Hypevisors might not even support the FP_HSI_SUPPORT TLV.
 344          * If that's the case, we need to make certain required FW was
 345          * supported by such a hypervisor [i.e., v0-v2].
 346          */
 347         fp_hsi_resp = bnx2x_search_tlv_list(bp, resp,
 348                                             CHANNEL_TLV_FP_HSI_SUPPORT);
 349         if (!fp_hsi_resp && (ETH_FP_HSI_VERSION > ETH_FP_HSI_VER_2)) {
 350                 BNX2X_ERR("Old hypervisor - need to downgrade VF's driver\n");
 351
 352                 /* Since acquire succeeded on the PF side, we need to send a
 353                  * release message in order to allow future probes.
 354                  */
 355                 bnx2x_vfpf_finalize(bp, &req->first_tlv);
 356                 bnx2x_vfpf_release(bp);
 357
 358                 rc = -EINVAL;
 359                 goto out;
 360         }
 361
 362         /* get HW info */
 363         bp->common.chip_id |= (bp->acquire_resp.pfdev_info.chip_num & 0xffff);
 364         bp->link_params.chip_id = bp->common.chip_id;
 365         bp->db_size = bp->acquire_resp.pfdev_info.db_size;
 366         bp->common.int_block = INT_BLOCK_IGU;
 367         bp->common.chip_port_mode = CHIP_2_PORT_MODE;
 368         bp->igu_dsb_id = -1;
 369         bp->mf_ov = 0;
 370         bp->mf_mode = 0;
 371         bp->common.flash_size = 0;
 372         bp->flags |=
 373                 NO_WOL_FLAG | NO_ISCSI_OOO_FLAG | NO_ISCSI_FLAG | NO_FCOE_FLAG;
 374         bp->igu_sb_cnt = bp->acquire_resp.resc.num_sbs;
 375         bp->igu_base_sb = bp->acquire_resp.resc.hw_sbs[0].hw_sb_id;
 376         strlcpy(bp->fw_ver, bp->acquire_resp.pfdev_info.fw_ver,
 377                 sizeof(bp->fw_ver));
 378
 379         if (is_valid_ether_addr(bp->acquire_resp.resc.current_mac_addr))
 380                 memcpy(bp->dev->dev_addr,
 381                        bp->acquire_resp.resc.current_mac_addr,
 382                        ETH_ALEN);
 383
 384 out:
 385         bnx2x_vfpf_finalize(bp, &req->first_tlv);
 386         return rc;
 387 }
 388
 389 int bnx2x_vfpf_release(struct bnx2x *bp)
 390 {
 391         struct vfpf_release_tlv *req = &bp->vf2pf_mbox->req.release;
 392         struct pfvf_general_resp_tlv *resp = &bp->vf2pf_mbox->resp.general_resp;
 393         u32 rc, vf_id;
 394
 395         /* clear mailbox and prep first tlv */
 396         bnx2x_vfpf_prep(bp, &req->first_tlv, CHANNEL_TLV_RELEASE, sizeof(*req));
 397
 398         if (bnx2x_get_vf_id(bp, &vf_id)) {
 399                 rc = -EAGAIN;
 400                 goto out;
 401         }
 402
 403         req->vf_id = vf_id;
 404
 405         /* add list termination tlv */
 406         bnx2x_add_tlv(bp, req, req->first_tlv.tl.length, CHANNEL_TLV_LIST_END,
 407                       sizeof(struct channel_list_end_tlv));
 408
 409         /* output tlvs list */
 410         bnx2x_dp_tlv_list(bp, req);
 411
 412         /* send release request */
 413         rc = bnx2x_send_msg2pf(bp, &resp->hdr.status, bp->vf2pf_mbox_mapping);
 414
 415         if (rc)
 416                 /* PF timeout */
 417                 goto out;
 418
 419         if (resp->hdr.status == PFVF_STATUS_SUCCESS) {
 420                 /* PF released us */
 421                 DP(BNX2X_MSG_SP, "vf released\n");
 422         } else {
 423                 /* PF reports error */
 424                 BNX2X_ERR("PF failed our release request - are we out of sync? Response status: %d\n",
 425                           resp->hdr.status);
 426                 rc = -EAGAIN;
 427                 goto out;
 428         }
 429 out:
 430         bnx2x_vfpf_finalize(bp, &req->first_tlv);
 431
 432         return rc;
 433 }
 434
 435 /* Tell PF about SB addresses */
 436 int bnx2x_vfpf_init(struct bnx2x *bp)
 437 {
 438         struct vfpf_init_tlv *req = &bp->vf2pf_mbox->req.init;
 439         struct pfvf_general_resp_tlv *resp = &bp->vf2pf_mbox->resp.general_resp;
 440         int rc, i;
 441
 442         /* clear mailbox and prep first tlv */
 443         bnx2x_vfpf_prep(bp, &req->first_tlv, CHANNEL_TLV_INIT, sizeof(*req));
 444
 445         /* status blocks */
 446         for_each_eth_queue(bp, i)
 447                 req->sb_addr[i] = (dma_addr_t)bnx2x_fp(bp, i,
 448                                                        status_blk_mapping);
 449
 450         /* statistics - requests only supports single queue for now */
 451         req->stats_addr = bp->fw_stats_data_mapping +
 452                           offsetof(struct bnx2x_fw_stats_data, queue_stats);
 453
 454         req->stats_stride = sizeof(struct per_queue_stats);
 455
 456         /* add list termination tlv */
 457         bnx2x_add_tlv(bp, req, req->first_tlv.tl.length, CHANNEL_TLV_LIST_END,
 458                       sizeof(struct channel_list_end_tlv));
 459
 460         /* output tlvs list */
 461         bnx2x_dp_tlv_list(bp, req);
 462
 463         rc = bnx2x_send_msg2pf(bp, &resp->hdr.status, bp->vf2pf_mbox_mapping);
 464         if (rc)
 465                 goto out;
 466
 467         if (resp->hdr.status != PFVF_STATUS_SUCCESS) {
 468                 BNX2X_ERR("INIT VF failed: %d. Breaking...\n",
 469                           resp->hdr.status);
 470                 rc = -EAGAIN;
 471                 goto out;
 472         }
 473
 474         DP(BNX2X_MSG_SP, "INIT VF Succeeded\n");
 475 out:
 476         bnx2x_vfpf_finalize(bp, &req->first_tlv);
 477
 478         return rc;
 479 }
 480
 481 /* CLOSE VF - opposite to INIT_VF */
 482 void bnx2x_vfpf_close_vf(struct bnx2x *bp)
 483 {
 484         struct vfpf_close_tlv *req = &bp->vf2pf_mbox->req.close;
 485         struct pfvf_general_resp_tlv *resp = &bp->vf2pf_mbox->resp.general_resp;
 486         int i, rc;
 487         u32 vf_id;
 488
 489         /* If we haven't got a valid VF id, there is no sense to
 490          * continue with sending messages
 491          */
 492         if (bnx2x_get_vf_id(bp, &vf_id))
 493                 goto free_irq;
 494
 495         /* Close the queues */
 496         for_each_queue(bp, i)
 497                 bnx2x_vfpf_teardown_queue(bp, i);
 498
 499         /* remove mac */
 500         bnx2x_vfpf_config_mac(bp, bp->dev->dev_addr, bp->fp->index, false);
 501
 502         /* clear mailbox and prep first tlv */
 503         bnx2x_vfpf_prep(bp, &req->first_tlv, CHANNEL_TLV_CLOSE, sizeof(*req));
 504
 505         req->vf_id = vf_id;
 506
 507         /* add list termination tlv */
 508         bnx2x_add_tlv(bp, req, req->first_tlv.tl.length, CHANNEL_TLV_LIST_END,
 509                       sizeof(struct channel_list_end_tlv));
 510
 511         /* output tlvs list */
 512         bnx2x_dp_tlv_list(bp, req);
 513
 514         rc = bnx2x_send_msg2pf(bp, &resp->hdr.status, bp->vf2pf_mbox_mapping);
 515
 516         if (rc)
 517                 BNX2X_ERR("Sending CLOSE failed. rc was: %d\n", rc);
 518
 519         else if (resp->hdr.status != PFVF_STATUS_SUCCESS)
 520                 BNX2X_ERR("Sending CLOSE failed: pf response was %d\n",
 521                           resp->hdr.status);
 522
 523         bnx2x_vfpf_finalize(bp, &req->first_tlv);
 524
 525 free_irq:
 526         /* Disable HW interrupts, NAPI */
 527         bnx2x_netif_stop(bp, 0);
 528         /* Delete all NAPI objects */
 529         bnx2x_del_all_napi(bp);
 530
 531         /* Release IRQs */
 532         bnx2x_free_irq(bp);
 533 }
 534
 535 static void bnx2x_leading_vfq_init(struct bnx2x *bp, struct bnx2x_virtf *vf,
 536                                    struct bnx2x_vf_queue *q)
 537 {
 538         u8 cl_id = vfq_cl_id(vf, q);
 539         u8 func_id = FW_VF_HANDLE(vf->abs_vfid);
 540
 541         /* mac */
 542         bnx2x_init_mac_obj(bp, &q->mac_obj,
 543                            cl_id, q->cid, func_id,
 544                            bnx2x_vf_sp(bp, vf, mac_rdata),
 545                            bnx2x_vf_sp_map(bp, vf, mac_rdata),
 546                            BNX2X_FILTER_MAC_PENDING,
 547                            &vf->filter_state,
 548                            BNX2X_OBJ_TYPE_RX_TX,
 549                            &bp->macs_pool);
 550         /* vlan */
 551         bnx2x_init_vlan_obj(bp, &q->vlan_obj,
 552                             cl_id, q->cid, func_id,
 553                             bnx2x_vf_sp(bp, vf, vlan_rdata),
 554                             bnx2x_vf_sp_map(bp, vf, vlan_rdata),
 555                             BNX2X_FILTER_VLAN_PENDING,
 556                             &vf->filter_state,
 557                             BNX2X_OBJ_TYPE_RX_TX,
 558                             &bp->vlans_pool);
 559
 560         /* mcast */
 561         bnx2x_init_mcast_obj(bp, &vf->mcast_obj, cl_id,
 562                              q->cid, func_id, func_id,
 563                              bnx2x_vf_sp(bp, vf, mcast_rdata),
 564                              bnx2x_vf_sp_map(bp, vf, mcast_rdata),
 565                              BNX2X_FILTER_MCAST_PENDING,
 566                              &vf->filter_state,
 567                              BNX2X_OBJ_TYPE_RX_TX);
 568
 569         /* rss */
 570         bnx2x_init_rss_config_obj(bp, &vf->rss_conf_obj, cl_id, q->cid,
 571                                   func_id, func_id,
 572                                   bnx2x_vf_sp(bp, vf, rss_rdata),
 573                                   bnx2x_vf_sp_map(bp, vf, rss_rdata),
 574                                   BNX2X_FILTER_RSS_CONF_PENDING,
 575                                   &vf->filter_state,
 576                                   BNX2X_OBJ_TYPE_RX_TX);
 577
 578         vf->leading_rss = cl_id;
 579         q->is_leading = true;
 580         q->sp_initialized = true;
 581 }
 582
 583 /* ask the pf to open a queue for the vf */
 584 int bnx2x_vfpf_setup_q(struct bnx2x *bp, struct bnx2x_fastpath *fp,
 585                        bool is_leading)
 586 {
 587         struct vfpf_setup_q_tlv *req = &bp->vf2pf_mbox->req.setup_q;
 588         struct pfvf_general_resp_tlv *resp = &bp->vf2pf_mbox->resp.general_resp;
 589         u8 fp_idx = fp->index;
 590         u16 tpa_agg_size = 0, flags = 0;
 591         int rc;
 592
 593         /* clear mailbox and prep first tlv */
 594         bnx2x_vfpf_prep(bp, &req->first_tlv, CHANNEL_TLV_SETUP_Q, sizeof(*req));
 595
 596         /* select tpa mode to request */
 597         if (fp->mode != TPA_MODE_DISABLED) {
 598                 flags |= VFPF_QUEUE_FLG_TPA;
 599                 flags |= VFPF_QUEUE_FLG_TPA_IPV6;
 600                 if (fp->mode == TPA_MODE_GRO)
 601                         flags |= VFPF_QUEUE_FLG_TPA_GRO;
 602                 tpa_agg_size = TPA_AGG_SIZE;
 603         }
 604
 605         if (is_leading)
 606                 flags |= VFPF_QUEUE_FLG_LEADING_RSS;
 607
 608         /* calculate queue flags */
 609         flags |= VFPF_QUEUE_FLG_STATS;
 610         flags |= VFPF_QUEUE_FLG_CACHE_ALIGN;
 611         flags |= VFPF_QUEUE_FLG_VLAN;
 612
 613         /* Common */
 614         req->vf_qid = fp_idx;
 615         req->param_valid = VFPF_RXQ_VALID | VFPF_TXQ_VALID;
 616
 617         /* Rx */
 618         req->rxq.rcq_addr = fp->rx_comp_mapping;
 619         req->rxq.rcq_np_addr = fp->rx_comp_mapping + BCM_PAGE_SIZE;
 620         req->rxq.rxq_addr = fp->rx_desc_mapping;
 621         req->rxq.sge_addr = fp->rx_sge_mapping;
 622         req->rxq.vf_sb = fp_idx;
 623         req->rxq.sb_index = HC_INDEX_ETH_RX_CQ_CONS;
 624         req->rxq.hc_rate = bp->rx_ticks ? 1000000/bp->rx_ticks : 0;
 625         req->rxq.mtu = bp->dev->mtu;
 626         req->rxq.buf_sz = fp->rx_buf_size;
 627         req->rxq.sge_buf_sz = BCM_PAGE_SIZE * PAGES_PER_SGE;
 628         req->rxq.tpa_agg_sz = tpa_agg_size;
 629         req->rxq.max_sge_pkt = SGE_PAGE_ALIGN(bp->dev->mtu) >> SGE_PAGE_SHIFT;
 630         req->rxq.max_sge_pkt = ((req->rxq.max_sge_pkt + PAGES_PER_SGE - 1) &
 631                           (~(PAGES_PER_SGE-1))) >> PAGES_PER_SGE_SHIFT;
 632         req->rxq.flags = flags;
 633         req->rxq.drop_flags = 0;
 634         req->rxq.cache_line_log = BNX2X_RX_ALIGN_SHIFT;
 635         req->rxq.stat_id = -1; /* No stats at the moment */
 636
 637         /* Tx */
 638         req->txq.txq_addr = fp->txdata_ptr[FIRST_TX_COS_INDEX]->tx_desc_mapping;
 639         req->txq.vf_sb = fp_idx;
 640         req->txq.sb_index = HC_INDEX_ETH_TX_CQ_CONS_COS0;
 641         req->txq.hc_rate = bp->tx_ticks ? 1000000/bp->tx_ticks : 0;
 642         req->txq.flags = flags;
 643         req->txq.traffic_type = LLFC_TRAFFIC_TYPE_NW;
 644
 645         /* add list termination tlv */
 646         bnx2x_add_tlv(bp, req, req->first_tlv.tl.length, CHANNEL_TLV_LIST_END,
 647                       sizeof(struct channel_list_end_tlv));
 648
 649         /* output tlvs list */
 650         bnx2x_dp_tlv_list(bp, req);
 651
 652         rc = bnx2x_send_msg2pf(bp, &resp->hdr.status, bp->vf2pf_mbox_mapping);
 653         if (rc)
 654                 BNX2X_ERR("Sending SETUP_Q message for queue[%d] failed!\n",
 655                           fp_idx);
 656
 657         if (resp->hdr.status != PFVF_STATUS_SUCCESS) {
 658                 BNX2X_ERR("Status of SETUP_Q for queue[%d] is %d\n",
 659                           fp_idx, resp->hdr.status);
 660                 rc = -EINVAL;
 661         }
 662
 663         bnx2x_vfpf_finalize(bp, &req->first_tlv);
 664
 665         return rc;
 666 }
 667
 668 static int bnx2x_vfpf_teardown_queue(struct bnx2x *bp, int qidx)
 669 {
 670         struct vfpf_q_op_tlv *req = &bp->vf2pf_mbox->req.q_op;
 671         struct pfvf_general_resp_tlv *resp = &bp->vf2pf_mbox->resp.general_resp;
 672         int rc;
 673
 674         /* clear mailbox and prep first tlv */
 675         bnx2x_vfpf_prep(bp, &req->first_tlv, CHANNEL_TLV_TEARDOWN_Q,
 676                         sizeof(*req));
 677
 678         req->vf_qid = qidx;
 679
 680         /* add list termination tlv */
 681         bnx2x_add_tlv(bp, req, req->first_tlv.tl.length, CHANNEL_TLV_LIST_END,
 682                       sizeof(struct channel_list_end_tlv));
 683
 684         /* output tlvs list */
 685         bnx2x_dp_tlv_list(bp, req);
 686
 687         rc = bnx2x_send_msg2pf(bp, &resp->hdr.status, bp->vf2pf_mbox_mapping);
 688
 689         if (rc) {
 690                 BNX2X_ERR("Sending TEARDOWN for queue %d failed: %d\n", qidx,
 691                           rc);
 692                 goto out;
 693         }
 694
 695         /* PF failed the transaction */
 696         if (resp->hdr.status != PFVF_STATUS_SUCCESS) {
 697                 BNX2X_ERR("TEARDOWN for queue %d failed: %d\n", qidx,
 698                           resp->hdr.status);
 699                 rc = -EINVAL;
 700         }
 701
 702 out:
 703         bnx2x_vfpf_finalize(bp, &req->first_tlv);
 704
 705         return rc;
 706 }
 707
 708 /* request pf to add a mac for the vf */
 709 int bnx2x_vfpf_config_mac(struct bnx2x *bp, u8 *addr, u8 vf_qid, bool set)
 710 {
 711         struct vfpf_set_q_filters_tlv *req = &bp->vf2pf_mbox->req.set_q_filters;
 712         struct pfvf_general_resp_tlv *resp = &bp->vf2pf_mbox->resp.general_resp;
 713         struct pf_vf_bulletin_content bulletin = bp->pf2vf_bulletin->content;
 714         int rc = 0;
 715
 716         /* clear mailbox and prep first tlv */
 717         bnx2x_vfpf_prep(bp, &req->first_tlv, CHANNEL_TLV_SET_Q_FILTERS,
 718                         sizeof(*req));
 719
 720         req->flags = VFPF_SET_Q_FILTERS_MAC_VLAN_CHANGED;
 721         req->vf_qid = vf_qid;
 722         req->n_mac_vlan_filters = 1;
 723
 724         req->filters[0].flags = VFPF_Q_FILTER_DEST_MAC_VALID;
 725         if (set)
 726                 req->filters[0].flags |= VFPF_Q_FILTER_SET_MAC;
 727
 728         /* sample bulletin board for new mac */
 729         bnx2x_sample_bulletin(bp);
 730
 731         /* copy mac from device to request */
 732         memcpy(req->filters[0].mac, addr, ETH_ALEN);
 733
 734         /* add list termination tlv */
 735         bnx2x_add_tlv(bp, req, req->first_tlv.tl.length, CHANNEL_TLV_LIST_END,
 736                       sizeof(struct channel_list_end_tlv));
 737
 738         /* output tlvs list */
 739         bnx2x_dp_tlv_list(bp, req);
 740
 741         /* send message to pf */
 742         rc = bnx2x_send_msg2pf(bp, &resp->hdr.status, bp->vf2pf_mbox_mapping);
 743         if (rc) {
 744                 BNX2X_ERR("failed to send message to pf. rc was %d\n", rc);
 745                 goto out;
 746         }
 747
 748         /* failure may mean PF was configured with a new mac for us */
 749         while (resp->hdr.status == PFVF_STATUS_FAILURE) {
 750                 DP(BNX2X_MSG_IOV,
 751                    "vfpf SET MAC failed. Check bulletin board for new posts\n");
 752
 753                 /* copy mac from bulletin to device */
 754                 memcpy(bp->dev->dev_addr, bulletin.mac, ETH_ALEN);
 755
 756                 /* check if bulletin board was updated */
 757                 if (bnx2x_sample_bulletin(bp) == PFVF_BULLETIN_UPDATED) {
 758                         /* copy mac from device to request */
 759                         memcpy(req->filters[0].mac, bp->dev->dev_addr,
 760                                ETH_ALEN);
 761
 762                         /* send message to pf */
 763                         rc = bnx2x_send_msg2pf(bp, &resp->hdr.status,
 764                                                bp->vf2pf_mbox_mapping);
 765                 } else {
 766                         /* no new info in bulletin */
 767                         break;
 768                 }
 769         }
 770
 771         if (resp->hdr.status != PFVF_STATUS_SUCCESS) {
 772                 BNX2X_ERR("vfpf SET MAC failed: %d\n", resp->hdr.status);
 773                 rc = -EINVAL;
 774         }
 775 out:
 776         bnx2x_vfpf_finalize(bp, &req->first_tlv);
 777
 778         return rc;
 779 }
 780
 781 /* request pf to config rss table for vf queues*/
 782 int bnx2x_vfpf_config_rss(struct bnx2x *bp,
 783                           struct bnx2x_config_rss_params *params)
 784 {
 785         struct pfvf_general_resp_tlv *resp = &bp->vf2pf_mbox->resp.general_resp;
 786         struct vfpf_rss_tlv *req = &bp->vf2pf_mbox->req.update_rss;
 787         int rc = 0;
 788
 789         /* clear mailbox and prep first tlv */
 790         bnx2x_vfpf_prep(bp, &req->first_tlv, CHANNEL_TLV_UPDATE_RSS,
 791                         sizeof(*req));
 792
 793         /* add list termination tlv */
 794         bnx2x_add_tlv(bp, req, req->first_tlv.tl.length, CHANNEL_TLV_LIST_END,
 795                       sizeof(struct channel_list_end_tlv));
 796
 797         memcpy(req->ind_table, params->ind_table, T_ETH_INDIRECTION_TABLE_SIZE);
 798         memcpy(req->rss_key, params->rss_key, sizeof(params->rss_key));
 799         req->ind_table_size = T_ETH_INDIRECTION_TABLE_SIZE;
 800         req->rss_key_size = T_ETH_RSS_KEY;
 801         req->rss_result_mask = params->rss_result_mask;
 802
 803         /* flags handled individually for backward/forward compatibility */
 804         if (params->rss_flags & (1 << BNX2X_RSS_MODE_DISABLED))
 805                 req->rss_flags |= VFPF_RSS_MODE_DISABLED;
 806         if (params->rss_flags & (1 << BNX2X_RSS_MODE_REGULAR))
 807                 req->rss_flags |= VFPF_RSS_MODE_REGULAR;
 808         if (params->rss_flags & (1 << BNX2X_RSS_SET_SRCH))
 809                 req->rss_flags |= VFPF_RSS_SET_SRCH;
 810         if (params->rss_flags & (1 << BNX2X_RSS_IPV4))
 811                 req->rss_flags |= VFPF_RSS_IPV4;
 812         if (params->rss_flags & (1 << BNX2X_RSS_IPV4_TCP))
 813                 req->rss_flags |= VFPF_RSS_IPV4_TCP;
 814         if (params->rss_flags & (1 << BNX2X_RSS_IPV4_UDP))
 815                 req->rss_flags |= VFPF_RSS_IPV4_UDP;
 816         if (params->rss_flags & (1 << BNX2X_RSS_IPV6))
 817                 req->rss_flags |= VFPF_RSS_IPV6;
 818         if (params->rss_flags & (1 << BNX2X_RSS_IPV6_TCP))
 819                 req->rss_flags |= VFPF_RSS_IPV6_TCP;
 820         if (params->rss_flags & (1 << BNX2X_RSS_IPV6_UDP))
 821                 req->rss_flags |= VFPF_RSS_IPV6_UDP;
 822
 823         DP(BNX2X_MSG_IOV, "rss flags %x\n", req->rss_flags);
 824
 825         /* output tlvs list */
 826         bnx2x_dp_tlv_list(bp, req);
 827
 828         /* send message to pf */
 829         rc = bnx2x_send_msg2pf(bp, &resp->hdr.status, bp->vf2pf_mbox_mapping);
 830         if (rc) {
 831                 BNX2X_ERR("failed to send message to pf. rc was %d\n", rc);
 832                 goto out;
 833         }
 834
 835         if (resp->hdr.status != PFVF_STATUS_SUCCESS) {
 836                 /* Since older drivers don't support this feature (and VF has
 837                  * no way of knowing other than failing this), don't propagate
 838                  * an error in this case.
 839                  */
 840                 DP(BNX2X_MSG_IOV,
 841                    "Failed to send rss message to PF over VF-PF channel [%d]\n",
 842                    resp->hdr.status);
 843         }
 844 out:
 845         bnx2x_vfpf_finalize(bp, &req->first_tlv);
 846
 847         return rc;
 848 }
 849
 850 int bnx2x_vfpf_set_mcast(struct net_device *dev)
 851 {
 852         struct bnx2x *bp = netdev_priv(dev);
 853         struct vfpf_set_q_filters_tlv *req = &bp->vf2pf_mbox->req.set_q_filters;
 854         struct pfvf_general_resp_tlv *resp = &bp->vf2pf_mbox->resp.general_resp;
 855         int rc, i = 0;
 856         struct netdev_hw_addr *ha;
 857
 858         if (bp->state != BNX2X_STATE_OPEN) {
 859                 DP(NETIF_MSG_IFUP, "state is %x, returning\n", bp->state);
 860                 return -EINVAL;
 861         }
 862
 863         /* clear mailbox and prep first tlv */
 864         bnx2x_vfpf_prep(bp, &req->first_tlv, CHANNEL_TLV_SET_Q_FILTERS,
 865                         sizeof(*req));
 866
 867         /* Get Rx mode requested */
 868         DP(NETIF_MSG_IFUP, "dev->flags = %x\n", dev->flags);
 869
 870         netdev_for_each_mc_addr(ha, dev) {
 871                 DP(NETIF_MSG_IFUP, "Adding mcast MAC: %pM\n",
 872                    bnx2x_mc_addr(ha));
 873                 memcpy(req->multicast[i], bnx2x_mc_addr(ha), ETH_ALEN);
 874                 i++;
 875         }
 876
 877         /* We support four PFVF_MAX_MULTICAST_PER_VF mcast
 878           * addresses tops
 879           */
 880         if (i >= PFVF_MAX_MULTICAST_PER_VF) {
 881                 DP(NETIF_MSG_IFUP,
 882                    "VF supports not more than %d multicast MAC addresses\n",
 883                    PFVF_MAX_MULTICAST_PER_VF);
 884                 return -EINVAL;
 885         }
 886
 887         req->n_multicast = i;
 888         req->flags |= VFPF_SET_Q_FILTERS_MULTICAST_CHANGED;
 889         req->vf_qid = 0;
 890
 891         /* add list termination tlv */
 892         bnx2x_add_tlv(bp, req, req->first_tlv.tl.length, CHANNEL_TLV_LIST_END,
 893                       sizeof(struct channel_list_end_tlv));
 894
 895         /* output tlvs list */
 896         bnx2x_dp_tlv_list(bp, req);
 897         rc = bnx2x_send_msg2pf(bp, &resp->hdr.status, bp->vf2pf_mbox_mapping);
 898         if (rc) {
 899                 BNX2X_ERR("Sending a message failed: %d\n", rc);
 900                 goto out;
 901         }
 902
 903         if (resp->hdr.status != PFVF_STATUS_SUCCESS) {
 904                 BNX2X_ERR("Set Rx mode/multicast failed: %d\n",
 905                           resp->hdr.status);
 906                 rc = -EINVAL;
 907         }
 908 out:
 909         bnx2x_vfpf_finalize(bp, &req->first_tlv);
 910
 911         return 0;
 912 }
 913
 914 int bnx2x_vfpf_storm_rx_mode(struct bnx2x *bp)
 915 {
 916         int mode = bp->rx_mode;
 917         struct vfpf_set_q_filters_tlv *req = &bp->vf2pf_mbox->req.set_q_filters;
 918         struct pfvf_general_resp_tlv *resp = &bp->vf2pf_mbox->resp.general_resp;
 919         int rc;
 920
 921         /* clear mailbox and prep first tlv */
 922         bnx2x_vfpf_prep(bp, &req->first_tlv, CHANNEL_TLV_SET_Q_FILTERS,
 923                         sizeof(*req));
 924
 925         DP(NETIF_MSG_IFUP, "Rx mode is %d\n", mode);
 926
 927         /* Ignore everything accept MODE_NONE */
 928         if (mode  == BNX2X_RX_MODE_NONE) {
 929                 req->rx_mask = VFPF_RX_MASK_ACCEPT_NONE;
 930         } else {
 931                 /* Current PF driver will not look at the specific flags,
 932                  * but they are required when working with older drivers on hv.
 933                  */
 934                 req->rx_mask = VFPF_RX_MASK_ACCEPT_MATCHED_MULTICAST;
 935                 req->rx_mask |= VFPF_RX_MASK_ACCEPT_MATCHED_UNICAST;
 936                 req->rx_mask |= VFPF_RX_MASK_ACCEPT_BROADCAST;
 937         }
 938
 939         req->flags |= VFPF_SET_Q_FILTERS_RX_MASK_CHANGED;
 940         req->vf_qid = 0;
 941
 942         /* add list termination tlv */
 943         bnx2x_add_tlv(bp, req, req->first_tlv.tl.length, CHANNEL_TLV_LIST_END,
 944                       sizeof(struct channel_list_end_tlv));
 945
 946         /* output tlvs list */
 947         bnx2x_dp_tlv_list(bp, req);
 948
 949         rc = bnx2x_send_msg2pf(bp, &resp->hdr.status, bp->vf2pf_mbox_mapping);
 950         if (rc)
 951                 BNX2X_ERR("Sending a message failed: %d\n", rc);
 952
 953         if (resp->hdr.status != PFVF_STATUS_SUCCESS) {
 954                 BNX2X_ERR("Set Rx mode failed: %d\n", resp->hdr.status);
 955                 rc = -EINVAL;
 956         }
 957
 958         bnx2x_vfpf_finalize(bp, &req->first_tlv);
 959
 960         return rc;
 961 }
 962
 963 /* General service functions */
 964 static void storm_memset_vf_mbx_ack(struct bnx2x *bp, u16 abs_fid)
 965 {
 966         u32 addr = BAR_CSTRORM_INTMEM +
 967                    CSTORM_VF_PF_CHANNEL_STATE_OFFSET(abs_fid);
 968
 969         REG_WR8(bp, addr, VF_PF_CHANNEL_STATE_READY);
 970 }
 971
 972 static void storm_memset_vf_mbx_valid(struct bnx2x *bp, u16 abs_fid)
 973 {
 974         u32 addr = BAR_CSTRORM_INTMEM +
 975                    CSTORM_VF_PF_CHANNEL_VALID_OFFSET(abs_fid);
 976
 977         REG_WR8(bp, addr, 1);
 978 }
 979
 980 /* enable vf_pf mailbox (aka vf-pf-channel) */
 981 void bnx2x_vf_enable_mbx(struct bnx2x *bp, u8 abs_vfid)
 982 {
 983         bnx2x_vf_flr_clnup_epilog(bp, abs_vfid);
 984
 985         /* enable the mailbox in the FW */
 986         storm_memset_vf_mbx_ack(bp, abs_vfid);
 987         storm_memset_vf_mbx_valid(bp, abs_vfid);
 988
 989         /* enable the VF access to the mailbox */
 990         bnx2x_vf_enable_access(bp, abs_vfid);
 991 }
 992
 993 /* this works only on !E1h */
 994 static int bnx2x_copy32_vf_dmae(struct bnx2x *bp, u8 from_vf,
 995                                 dma_addr_t pf_addr, u8 vfid, u32 vf_addr_hi,
 996                                 u32 vf_addr_lo, u32 len32)
 997 {
 998         struct dmae_command dmae;
 999
1000         if (CHIP_IS_E1x(bp)) {
1001                 BNX2X_ERR("Chip revision does not support VFs\n");
1002                 return DMAE_NOT_RDY;
1003         }
1004
1005         if (!bp->dmae_ready) {
1006                 BNX2X_ERR("DMAE is not ready, can not copy\n");
1007                 return DMAE_NOT_RDY;
1008         }
1009
1010         /* set opcode and fixed command fields */
1011         bnx2x_prep_dmae_with_comp(bp, &dmae, DMAE_SRC_PCI, DMAE_DST_PCI);
1012
1013         if (from_vf) {
1014                 dmae.opcode_iov = (vfid << DMAE_COMMAND_SRC_VFID_SHIFT) |
1015                         (DMAE_SRC_VF << DMAE_COMMAND_SRC_VFPF_SHIFT) |
1016                         (DMAE_DST_PF << DMAE_COMMAND_DST_VFPF_SHIFT);
1017
1018                 dmae.opcode |= (DMAE_C_DST << DMAE_COMMAND_C_FUNC_SHIFT);
1019
1020                 dmae.src_addr_lo = vf_addr_lo;
1021                 dmae.src_addr_hi = vf_addr_hi;
1022                 dmae.dst_addr_lo = U64_LO(pf_addr);
1023                 dmae.dst_addr_hi = U64_HI(pf_addr);
1024         } else {
1025                 dmae.opcode_iov = (vfid << DMAE_COMMAND_DST_VFID_SHIFT) |
1026                         (DMAE_DST_VF << DMAE_COMMAND_DST_VFPF_SHIFT) |
1027                         (DMAE_SRC_PF << DMAE_COMMAND_SRC_VFPF_SHIFT);
1028
1029                 dmae.opcode |= (DMAE_C_SRC << DMAE_COMMAND_C_FUNC_SHIFT);
1030
1031                 dmae.src_addr_lo = U64_LO(pf_addr);
1032                 dmae.src_addr_hi = U64_HI(pf_addr);
1033                 dmae.dst_addr_lo = vf_addr_lo;
1034                 dmae.dst_addr_hi = vf_addr_hi;
1035         }
1036         dmae.len = len32;
1037
1038         /* issue the command and wait for completion */
1039         return bnx2x_issue_dmae_with_comp(bp, &dmae, bnx2x_sp(bp, wb_comp));
1040 }
1041
1042 static void bnx2x_vf_mbx_resp_single_tlv(struct bnx2x *bp,
1043                                          struct bnx2x_virtf *vf)
1044 {
1045         struct bnx2x_vf_mbx *mbx = BP_VF_MBX(bp, vf->index);
1046         u16 length, type;
1047
1048         /* prepare response */
1049         type = mbx->first_tlv.tl.type;
1050         length = type == CHANNEL_TLV_ACQUIRE ?
1051                 sizeof(struct pfvf_acquire_resp_tlv) :
1052                 sizeof(struct pfvf_general_resp_tlv);
1053         bnx2x_add_tlv(bp, &mbx->msg->resp, 0, type, length);
1054         bnx2x_add_tlv(bp, &mbx->msg->resp, length, CHANNEL_TLV_LIST_END,
1055                       sizeof(struct channel_list_end_tlv));
1056 }
1057
1058 static void bnx2x_vf_mbx_resp_send_msg(struct bnx2x *bp,
1059                                        struct bnx2x_virtf *vf,
1060                                        int vf_rc)
1061 {
1062         struct bnx2x_vf_mbx *mbx = BP_VF_MBX(bp, vf->index);
1063         struct pfvf_general_resp_tlv *resp = &mbx->msg->resp.general_resp;
1064         dma_addr_t pf_addr;
1065         u64 vf_addr;
1066         int rc;
1067
1068         bnx2x_dp_tlv_list(bp, resp);
1069         DP(BNX2X_MSG_IOV, "mailbox vf address hi 0x%x, lo 0x%x, offset 0x%x\n",
1070            mbx->vf_addr_hi, mbx->vf_addr_lo, mbx->first_tlv.resp_msg_offset);
1071
1072         resp->hdr.status = bnx2x_pfvf_status_codes(vf_rc);
1073
1074         /* send response */
1075         vf_addr = HILO_U64(mbx->vf_addr_hi, mbx->vf_addr_lo) +
1076                   mbx->first_tlv.resp_msg_offset;
1077         pf_addr = mbx->msg_mapping +
1078                   offsetof(struct bnx2x_vf_mbx_msg, resp);
1079
1080         /* Copy the response buffer. The first u64 is written afterwards, as
1081          * the vf is sensitive to the header being written
1082          */
1083         vf_addr += sizeof(u64);
1084         pf_addr += sizeof(u64);
1085         rc = bnx2x_copy32_vf_dmae(bp, false, pf_addr, vf->abs_vfid,
1086                                   U64_HI(vf_addr),
1087                                   U64_LO(vf_addr),
1088                                   (sizeof(union pfvf_tlvs) - sizeof(u64))/4);
1089         if (rc) {
1090                 BNX2X_ERR("Failed to copy response body to VF %d\n",
1091                           vf->abs_vfid);
1092                 goto mbx_error;
1093         }
1094         vf_addr -= sizeof(u64);
1095         pf_addr -= sizeof(u64);
1096
1097         /* ack the FW */
1098         storm_memset_vf_mbx_ack(bp, vf->abs_vfid);
1099         mmiowb();
1100
1101         /* copy the response header including status-done field,
1102          * must be last dmae, must be after FW is acked
1103          */
1104         rc = bnx2x_copy32_vf_dmae(bp, false, pf_addr, vf->abs_vfid,
1105                                   U64_HI(vf_addr),
1106                                   U64_LO(vf_addr),
1107                                   sizeof(u64)/4);
1108
1109         /* unlock channel mutex */
1110         bnx2x_unlock_vf_pf_channel(bp, vf, mbx->first_tlv.tl.type);
1111
1112         if (rc) {
1113                 BNX2X_ERR("Failed to copy response status to VF %d\n",
1114                           vf->abs_vfid);
1115                 goto mbx_error;
1116         }
1117         return;
1118
1119 mbx_error:
1120         bnx2x_vf_release(bp, vf);
1121 }
1122
1123 static void bnx2x_vf_mbx_resp(struct bnx2x *bp,
1124                               struct bnx2x_virtf *vf,
1125                               int rc)
1126 {
1127         bnx2x_vf_mbx_resp_single_tlv(bp, vf);
1128         bnx2x_vf_mbx_resp_send_msg(bp, vf, rc);
1129 }
1130
1131 static void bnx2x_vf_mbx_resp_phys_port(struct bnx2x *bp,
1132                                         struct bnx2x_virtf *vf,
1133                                         void *buffer,
1134                                         u16 *offset)
1135 {
1136         struct vfpf_port_phys_id_resp_tlv *port_id;
1137
1138         if (!(bp->flags & HAS_PHYS_PORT_ID))
1139                 return;
1140
1141         bnx2x_add_tlv(bp, buffer, *offset, CHANNEL_TLV_PHYS_PORT_ID,
1142                       sizeof(struct vfpf_port_phys_id_resp_tlv));
1143
1144         port_id = (struct vfpf_port_phys_id_resp_tlv *)
1145                   (((u8 *)buffer) + *offset);
1146         memcpy(port_id->id, bp->phys_port_id, ETH_ALEN);
1147
1148         /* Offset should continue representing the offset to the tail
1149          * of TLV data (outside this function scope)
1150          */
1151         *offset += sizeof(struct vfpf_port_phys_id_resp_tlv);
1152 }
1153
1154 static void bnx2x_vf_mbx_resp_fp_hsi_ver(struct bnx2x *bp,
1155                                          struct bnx2x_virtf *vf,
1156                                          void *buffer,
1157                                          u16 *offset)
1158 {
1159         struct vfpf_fp_hsi_resp_tlv *fp_hsi;
1160
1161         bnx2x_add_tlv(bp, buffer, *offset, CHANNEL_TLV_FP_HSI_SUPPORT,
1162                       sizeof(struct vfpf_fp_hsi_resp_tlv));
1163
1164         fp_hsi = (struct vfpf_fp_hsi_resp_tlv *)
1165                  (((u8 *)buffer) + *offset);
1166         fp_hsi->is_supported = (vf->fp_hsi > ETH_FP_HSI_VERSION) ? 0 : 1;
1167
1168         /* Offset should continue representing the offset to the tail
1169          * of TLV data (outside this function scope)
1170          */
1171         *offset += sizeof(struct vfpf_fp_hsi_resp_tlv);
1172 }
1173
1174 static void bnx2x_vf_mbx_acquire_resp(struct bnx2x *bp, struct bnx2x_virtf *vf,
1175                                       struct bnx2x_vf_mbx *mbx, int vfop_status)
1176 {
1177         int i;
1178         struct pfvf_acquire_resp_tlv *resp = &mbx->msg->resp.acquire_resp;
1179         struct pf_vf_resc *resc = &resp->resc;
1180         u8 status = bnx2x_pfvf_status_codes(vfop_status);
1181         u16 length;
1182
1183         memset(resp, 0, sizeof(*resp));
1184
1185         /* fill in pfdev info */
1186         resp->pfdev_info.chip_num = bp->common.chip_id;
1187         resp->pfdev_info.db_size = bp->db_size;
1188         resp->pfdev_info.indices_per_sb = HC_SB_MAX_INDICES_E2;
1189         resp->pfdev_info.pf_cap = (PFVF_CAP_RSS |
1190                                    PFVF_CAP_TPA |
1191                                    PFVF_CAP_TPA_UPDATE);
1192         bnx2x_fill_fw_str(bp, resp->pfdev_info.fw_ver,
1193                           sizeof(resp->pfdev_info.fw_ver));
1194
1195         if (status == PFVF_STATUS_NO_RESOURCE ||
1196             status == PFVF_STATUS_SUCCESS) {
1197                 /* set resources numbers, if status equals NO_RESOURCE these
1198                  * are max possible numbers
1199                  */
1200                 resc->num_rxqs = vf_rxq_count(vf) ? :
1201                         bnx2x_vf_max_queue_cnt(bp, vf);
1202                 resc->num_txqs = vf_txq_count(vf) ? :
1203                         bnx2x_vf_max_queue_cnt(bp, vf);
1204                 resc->num_sbs = vf_sb_count(vf);
1205                 resc->num_mac_filters = vf_mac_rules_cnt(vf);
1206                 resc->num_vlan_filters = vf_vlan_rules_visible_cnt(vf);
1207                 resc->num_mc_filters = 0;
1208
1209                 if (status == PFVF_STATUS_SUCCESS) {
1210                         /* fill in the allocated resources */
1211                         struct pf_vf_bulletin_content *bulletin =
1212                                 BP_VF_BULLETIN(bp, vf->index);
1213
1214                         for_each_vfq(vf, i)
1215                                 resc->hw_qid[i] =
1216                                         vfq_qzone_id(vf, vfq_get(vf, i));
1217
1218                         for_each_vf_sb(vf, i) {
1219                                 resc->hw_sbs[i].hw_sb_id = vf_igu_sb(vf, i);
1220                                 resc->hw_sbs[i].sb_qid = vf_hc_qzone(vf, i);
1221                         }
1222
1223                         /* if a mac has been set for this vf, supply it */
1224                         if (bulletin->valid_bitmap & 1 << MAC_ADDR_VALID) {
1225                                 memcpy(resc->current_mac_addr, bulletin->mac,
1226                                        ETH_ALEN);
1227                         }
1228                 }
1229         }
1230
1231         DP(BNX2X_MSG_IOV, "VF[%d] ACQUIRE_RESPONSE: pfdev_info- chip_num=0x%x, db_size=%d, idx_per_sb=%d, pf_cap=0x%x\n"
1232            "resources- n_rxq-%d, n_txq-%d, n_sbs-%d, n_macs-%d, n_vlans-%d, n_mcs-%d, fw_ver: '%s'\n",
1233            vf->abs_vfid,
1234            resp->pfdev_info.chip_num,
1235            resp->pfdev_info.db_size,
1236            resp->pfdev_info.indices_per_sb,
1237            resp->pfdev_info.pf_cap,
1238            resc->num_rxqs,
1239            resc->num_txqs,
1240            resc->num_sbs,
1241            resc->num_mac_filters,
1242            resc->num_vlan_filters,
1243            resc->num_mc_filters,
1244            resp->pfdev_info.fw_ver);
1245
1246         DP_CONT(BNX2X_MSG_IOV, "hw_qids- [ ");
1247         for (i = 0; i < vf_rxq_count(vf); i++)
1248                 DP_CONT(BNX2X_MSG_IOV, "%d ", resc->hw_qid[i]);
1249         DP_CONT(BNX2X_MSG_IOV, "], sb_info- [ ");
1250         for (i = 0; i < vf_sb_count(vf); i++)
1251                 DP_CONT(BNX2X_MSG_IOV, "%d:%d ",
1252                         resc->hw_sbs[i].hw_sb_id,
1253                         resc->hw_sbs[i].sb_qid);
1254         DP_CONT(BNX2X_MSG_IOV, "]\n");
1255
1256         /* prepare response */
1257         length = sizeof(struct pfvf_acquire_resp_tlv);
1258         bnx2x_add_tlv(bp, &mbx->msg->resp, 0, CHANNEL_TLV_ACQUIRE, length);
1259
1260         /* Handle possible VF requests for physical port identifiers.
1261          * 'length' should continue to indicate the offset of the first empty
1262          * place in the buffer (i.e., where next TLV should be inserted)
1263          */
1264         if (bnx2x_search_tlv_list(bp, &mbx->msg->req,
1265                                   CHANNEL_TLV_PHYS_PORT_ID))
1266                 bnx2x_vf_mbx_resp_phys_port(bp, vf, &mbx->msg->resp, &length);
1267
1268         /* `New' vfs will want to know if fastpath HSI is supported, since
1269          * if that's not the case they could print into system log the fact
1270          * the driver version must be updated.
1271          */
1272         bnx2x_vf_mbx_resp_fp_hsi_ver(bp, vf, &mbx->msg->resp, &length);
1273
1274         bnx2x_add_tlv(bp, &mbx->msg->resp, length, CHANNEL_TLV_LIST_END,
1275                       sizeof(struct channel_list_end_tlv));
1276
1277         /* send the response */
1278         bnx2x_vf_mbx_resp_send_msg(bp, vf, vfop_status);
1279 }
1280
1281 static bool bnx2x_vf_mbx_is_windows_vm(struct bnx2x *bp,
1282                                        struct vfpf_acquire_tlv *acquire)
1283 {
1284         /* Windows driver does one of three things:
1285          * 1. Old driver doesn't have bulletin board address set.
1286          * 2. 'Middle' driver sends mc_num == 32.
1287          * 3. New driver sets the OS field.
1288          */
1289         if (!acquire->bulletin_addr ||
1290             acquire->resc_request.num_mc_filters == 32 ||
1291             ((acquire->vfdev_info.vf_os & VF_OS_MASK) ==
1292              VF_OS_WINDOWS))
1293                 return true;
1294
1295         return false;
1296 }
1297
1298 static int bnx2x_vf_mbx_acquire_chk_dorq(struct bnx2x *bp,
1299                                          struct bnx2x_virtf *vf,
1300                                          struct bnx2x_vf_mbx *mbx)
1301 {
1302         /* Linux drivers which correctly set the doorbell size also
1303          * send a physical port request
1304          */
1305         if (bnx2x_search_tlv_list(bp, &mbx->msg->req,
1306                                   CHANNEL_TLV_PHYS_PORT_ID))
1307                 return 0;
1308
1309         /* Issue does not exist in windows VMs */
1310         if (bnx2x_vf_mbx_is_windows_vm(bp, &mbx->msg->req.acquire))
1311                 return 0;
1312
1313         return -EOPNOTSUPP;
1314 }
1315
1316 static void bnx2x_vf_mbx_acquire(struct bnx2x *bp, struct bnx2x_virtf *vf,
1317                                  struct bnx2x_vf_mbx *mbx)
1318 {
1319         int rc;
1320         struct vfpf_acquire_tlv *acquire = &mbx->msg->req.acquire;
1321
1322         /* log vfdef info */
1323         DP(BNX2X_MSG_IOV,
1324            "VF[%d] ACQUIRE: vfdev_info- vf_id %d, vf_os %d resources- n_rxq-%d, n_txq-%d, n_sbs-%d, n_macs-%d, n_vlans-%d, n_mcs-%d\n",
1325            vf->abs_vfid, acquire->vfdev_info.vf_id, acquire->vfdev_info.vf_os,
1326            acquire->resc_request.num_rxqs, acquire->resc_request.num_txqs,
1327            acquire->resc_request.num_sbs, acquire->resc_request.num_mac_filters,
1328            acquire->resc_request.num_vlan_filters,
1329            acquire->resc_request.num_mc_filters);
1330
1331         /* Prevent VFs with old drivers from loading, since they calculate
1332          * CIDs incorrectly requiring a VF-flr [VM reboot] in order to recover
1333          * while being upgraded.
1334          */
1335         rc = bnx2x_vf_mbx_acquire_chk_dorq(bp, vf, mbx);
1336         if (rc) {
1337                 DP(BNX2X_MSG_IOV,
1338                    "VF [%d] - Can't support acquire request due to doorbell mismatch. Please update VM driver\n",
1339                    vf->abs_vfid);
1340                 goto out;
1341         }
1342
1343         /* Verify the VF fastpath HSI can be supported by the loaded FW.
1344          * Linux vfs should be oblivious to changes between v0 and v2.
1345          */
1346         if (bnx2x_vf_mbx_is_windows_vm(bp, &mbx->msg->req.acquire))
1347                 vf->fp_hsi = acquire->vfdev_info.fp_hsi_ver;
1348         else
1349                 vf->fp_hsi = max_t(u8, acquire->vfdev_info.fp_hsi_ver,
1350                                    ETH_FP_HSI_VER_2);
1351         if (vf->fp_hsi > ETH_FP_HSI_VERSION) {
1352                 DP(BNX2X_MSG_IOV,
1353                    "VF [%d] - Can't support acquire request since VF requests a FW version which is too new [%02x > %02x]\n",
1354                    vf->abs_vfid, acquire->vfdev_info.fp_hsi_ver,
1355                    ETH_FP_HSI_VERSION);
1356                 rc = -EINVAL;
1357                 goto out;
1358         }
1359
1360         /* acquire the resources */
1361         rc = bnx2x_vf_acquire(bp, vf, &acquire->resc_request);
1362
1363         /* store address of vf's bulletin board */
1364         vf->bulletin_map = acquire->bulletin_addr;
1365         if (acquire->vfdev_info.caps & VF_CAP_SUPPORT_EXT_BULLETIN) {
1366                 DP(BNX2X_MSG_IOV, "VF[%d] supports long bulletin boards\n",
1367                    vf->abs_vfid);
1368                 vf->cfg_flags |= VF_CFG_EXT_BULLETIN;
1369         } else {
1370                 vf->cfg_flags &= ~VF_CFG_EXT_BULLETIN;
1371         }
1372
1373 out:
1374         /* response */
1375         bnx2x_vf_mbx_acquire_resp(bp, vf, mbx, rc);
1376 }
1377
1378 static void bnx2x_vf_mbx_init_vf(struct bnx2x *bp, struct bnx2x_virtf *vf,
1379                               struct bnx2x_vf_mbx *mbx)
1380 {
1381         struct vfpf_init_tlv *init = &mbx->msg->req.init;
1382         int rc;
1383
1384         /* record ghost addresses from vf message */
1385         vf->spq_map = init->spq_addr;
1386         vf->fw_stat_map = init->stats_addr;
1387         vf->stats_stride = init->stats_stride;
1388         rc = bnx2x_vf_init(bp, vf, (dma_addr_t *)init->sb_addr);
1389
1390         /* set VF multiqueue statistics collection mode */
1391         if (init->flags & VFPF_INIT_FLG_STATS_COALESCE)
1392                 vf->cfg_flags |= VF_CFG_STATS_COALESCE;
1393
1394         /* Update VF's view of link state */
1395         if (vf->cfg_flags & VF_CFG_EXT_BULLETIN)
1396                 bnx2x_iov_link_update_vf(bp, vf->index);
1397
1398         /* response */
1399         bnx2x_vf_mbx_resp(bp, vf, rc);
1400 }
1401
1402 /* convert MBX queue-flags to standard SP queue-flags */
1403 static void bnx2x_vf_mbx_set_q_flags(struct bnx2x *bp, u32 mbx_q_flags,
1404                                      unsigned long *sp_q_flags)
1405 {
1406         if (mbx_q_flags & VFPF_QUEUE_FLG_TPA)
1407                 __set_bit(BNX2X_Q_FLG_TPA, sp_q_flags);
1408         if (mbx_q_flags & VFPF_QUEUE_FLG_TPA_IPV6)
1409                 __set_bit(BNX2X_Q_FLG_TPA_IPV6, sp_q_flags);
1410         if (mbx_q_flags & VFPF_QUEUE_FLG_TPA_GRO)
1411                 __set_bit(BNX2X_Q_FLG_TPA_GRO, sp_q_flags);
1412         if (mbx_q_flags & VFPF_QUEUE_FLG_STATS)
1413                 __set_bit(BNX2X_Q_FLG_STATS, sp_q_flags);
1414         if (mbx_q_flags & VFPF_QUEUE_FLG_VLAN)
1415                 __set_bit(BNX2X_Q_FLG_VLAN, sp_q_flags);
1416         if (mbx_q_flags & VFPF_QUEUE_FLG_COS)
1417                 __set_bit(BNX2X_Q_FLG_COS, sp_q_flags);
1418         if (mbx_q_flags & VFPF_QUEUE_FLG_HC)
1419                 __set_bit(BNX2X_Q_FLG_HC, sp_q_flags);
1420         if (mbx_q_flags & VFPF_QUEUE_FLG_DHC)
1421                 __set_bit(BNX2X_Q_FLG_DHC, sp_q_flags);
1422         if (mbx_q_flags & VFPF_QUEUE_FLG_LEADING_RSS)
1423                 __set_bit(BNX2X_Q_FLG_LEADING_RSS, sp_q_flags);
1424
1425         /* outer vlan removal is set according to PF's multi function mode */
1426         if (IS_MF_SD(bp))
1427                 __set_bit(BNX2X_Q_FLG_OV, sp_q_flags);
1428 }
1429
1430 static void bnx2x_vf_mbx_setup_q(struct bnx2x *bp, struct bnx2x_virtf *vf,
1431                                  struct bnx2x_vf_mbx *mbx)
1432 {
1433         struct vfpf_setup_q_tlv *setup_q = &mbx->msg->req.setup_q;
1434         struct bnx2x_vf_queue_construct_params qctor;
1435         int rc = 0;
1436
1437         /* verify vf_qid */
1438         if (setup_q->vf_qid >= vf_rxq_count(vf)) {
1439                 BNX2X_ERR("vf_qid %d invalid, max queue count is %d\n",
1440                           setup_q->vf_qid, vf_rxq_count(vf));
1441                 rc = -EINVAL;
1442                 goto response;
1443         }
1444
1445         /* tx queues must be setup alongside rx queues thus if the rx queue
1446          * is not marked as valid there's nothing to do.
1447          */
1448         if (setup_q->param_valid & (VFPF_RXQ_VALID|VFPF_TXQ_VALID)) {
1449                 struct bnx2x_vf_queue *q = vfq_get(vf, setup_q->vf_qid);
1450                 unsigned long q_type = 0;
1451
1452                 struct bnx2x_queue_init_params *init_p;
1453                 struct bnx2x_queue_setup_params *setup_p;
1454
1455                 if (bnx2x_vfq_is_leading(q))
1456                         bnx2x_leading_vfq_init(bp, vf, q);
1457
1458                 /* re-init the VF operation context */
1459                 memset(&qctor, 0 ,
1460                        sizeof(struct bnx2x_vf_queue_construct_params));
1461                 setup_p = &qctor.prep_qsetup;
1462                 init_p =  &qctor.qstate.params.init;
1463
1464                 /* activate immediately */
1465                 __set_bit(BNX2X_Q_FLG_ACTIVE, &setup_p->flags);
1466
1467                 if (setup_q->param_valid & VFPF_TXQ_VALID) {
1468                         struct bnx2x_txq_setup_params *txq_params =
1469                                 &setup_p->txq_params;
1470
1471                         __set_bit(BNX2X_Q_TYPE_HAS_TX, &q_type);
1472
1473                         /* save sb resource index */
1474                         q->sb_idx = setup_q->txq.vf_sb;
1475
1476                         /* tx init */
1477                         init_p->tx.hc_rate = setup_q->txq.hc_rate;
1478                         init_p->tx.sb_cq_index = setup_q->txq.sb_index;
1479
1480                         bnx2x_vf_mbx_set_q_flags(bp, setup_q->txq.flags,
1481                                                  &init_p->tx.flags);
1482
1483                         /* tx setup - flags */
1484                         bnx2x_vf_mbx_set_q_flags(bp, setup_q->txq.flags,
1485                                                  &setup_p->flags);
1486
1487                         /* tx setup - general, nothing */
1488
1489                         /* tx setup - tx */
1490                         txq_params->dscr_map = setup_q->txq.txq_addr;
1491                         txq_params->sb_cq_index = setup_q->txq.sb_index;
1492                         txq_params->traffic_type = setup_q->txq.traffic_type;
1493
1494                         bnx2x_vfop_qctor_dump_tx(bp, vf, init_p, setup_p,
1495                                                  q->index, q->sb_idx);
1496                 }
1497
1498                 if (setup_q->param_valid & VFPF_RXQ_VALID) {
1499                         struct bnx2x_rxq_setup_params *rxq_params =
1500                                                         &setup_p->rxq_params;
1501
1502                         __set_bit(BNX2X_Q_TYPE_HAS_RX, &q_type);
1503
1504                         /* Note: there is no support for different SBs
1505                          * for TX and RX
1506                          */
1507                         q->sb_idx = setup_q->rxq.vf_sb;
1508
1509                         /* rx init */
1510                         init_p->rx.hc_rate = setup_q->rxq.hc_rate;
1511                         init_p->rx.sb_cq_index = setup_q->rxq.sb_index;
1512                         bnx2x_vf_mbx_set_q_flags(bp, setup_q->rxq.flags,
1513                                                  &init_p->rx.flags);
1514
1515                         /* rx setup - flags */
1516                         bnx2x_vf_mbx_set_q_flags(bp, setup_q->rxq.flags,
1517                                                  &setup_p->flags);
1518
1519                         /* rx setup - general */
1520                         setup_p->gen_params.mtu = setup_q->rxq.mtu;
1521
1522                         /* rx setup - rx */
1523                         rxq_params->drop_flags = setup_q->rxq.drop_flags;
1524                         rxq_params->dscr_map = setup_q->rxq.rxq_addr;
1525                         rxq_params->sge_map = setup_q->rxq.sge_addr;
1526                         rxq_params->rcq_map = setup_q->rxq.rcq_addr;
1527                         rxq_params->rcq_np_map = setup_q->rxq.rcq_np_addr;
1528                         rxq_params->buf_sz = setup_q->rxq.buf_sz;
1529                         rxq_params->tpa_agg_sz = setup_q->rxq.tpa_agg_sz;
1530                         rxq_params->max_sges_pkt = setup_q->rxq.max_sge_pkt;
1531                         rxq_params->sge_buf_sz = setup_q->rxq.sge_buf_sz;
1532                         rxq_params->cache_line_log =
1533                                 setup_q->rxq.cache_line_log;
1534                         rxq_params->sb_cq_index = setup_q->rxq.sb_index;
1535
1536                         /* rx setup - multicast engine */
1537                         if (bnx2x_vfq_is_leading(q)) {
1538                                 u8 mcast_id = FW_VF_HANDLE(vf->abs_vfid);
1539
1540                                 rxq_params->mcast_engine_id = mcast_id;
1541                                 __set_bit(BNX2X_Q_FLG_MCAST, &setup_p->flags);
1542                         }
1543
1544                         bnx2x_vfop_qctor_dump_rx(bp, vf, init_p, setup_p,
1545                                                  q->index, q->sb_idx);
1546                 }
1547                 /* complete the preparations */
1548                 bnx2x_vfop_qctor_prep(bp, vf, q, &qctor, q_type);
1549
1550                 rc = bnx2x_vf_queue_setup(bp, vf, q->index, &qctor);
1551                 if (rc)
1552                         goto response;
1553         }
1554 response:
1555         bnx2x_vf_mbx_resp(bp, vf, rc);
1556 }
1557
1558 static int bnx2x_vf_mbx_macvlan_list(struct bnx2x *bp,
1559                                      struct bnx2x_virtf *vf,
1560                                      struct vfpf_set_q_filters_tlv *tlv,
1561                                      struct bnx2x_vf_mac_vlan_filters **pfl,
1562                                      u32 type_flag)
1563 {
1564         int i, j;
1565         struct bnx2x_vf_mac_vlan_filters *fl = NULL;
1566         size_t fsz;
1567
1568         fsz = tlv->n_mac_vlan_filters *
1569               sizeof(struct bnx2x_vf_mac_vlan_filter) +
1570               sizeof(struct bnx2x_vf_mac_vlan_filters);
1571
1572         fl = kzalloc(fsz, GFP_KERNEL);
1573         if (!fl)
1574                 return -ENOMEM;
1575
1576         for (i = 0, j = 0; i < tlv->n_mac_vlan_filters; i++) {
1577                 struct vfpf_q_mac_vlan_filter *msg_filter = &tlv->filters[i];
1578
1579                 if ((msg_filter->flags & type_flag) != type_flag)
1580                         continue;
1581                 if (type_flag == VFPF_Q_FILTER_DEST_MAC_VALID) {
1582                         fl->filters[j].mac = msg_filter->mac;
1583                         fl->filters[j].type = BNX2X_VF_FILTER_MAC;
1584                 } else {
1585                         fl->filters[j].vid = msg_filter->vlan_tag;
1586                         fl->filters[j].type = BNX2X_VF_FILTER_VLAN;
1587                 }
1588                 fl->filters[j].add =
1589                         (msg_filter->flags & VFPF_Q_FILTER_SET_MAC) ?
1590                         true : false;
1591                 fl->count++;
1592         }
1593         if (!fl->count)
1594                 kfree(fl);
1595         else
1596                 *pfl = fl;
1597
1598         return 0;
1599 }
1600
1601 static void bnx2x_vf_mbx_dp_q_filter(struct bnx2x *bp, int msglvl, int idx,
1602                                        struct vfpf_q_mac_vlan_filter *filter)
1603 {
1604         DP(msglvl, "MAC-VLAN[%d] -- flags=0x%x\n", idx, filter->flags);
1605         if (filter->flags & VFPF_Q_FILTER_VLAN_TAG_VALID)
1606                 DP_CONT(msglvl, ", vlan=%d", filter->vlan_tag);
1607         if (filter->flags & VFPF_Q_FILTER_DEST_MAC_VALID)
1608                 DP_CONT(msglvl, ", MAC=%pM", filter->mac);
1609         DP_CONT(msglvl, "\n");
1610 }
1611
1612 static void bnx2x_vf_mbx_dp_q_filters(struct bnx2x *bp, int msglvl,
1613                                        struct vfpf_set_q_filters_tlv *filters)
1614 {
1615         int i;
1616
1617         if (filters->flags & VFPF_SET_Q_FILTERS_MAC_VLAN_CHANGED)
1618                 for (i = 0; i < filters->n_mac_vlan_filters; i++)
1619                         bnx2x_vf_mbx_dp_q_filter(bp, msglvl, i,
1620                                                  &filters->filters[i]);
1621
1622         if (filters->flags & VFPF_SET_Q_FILTERS_RX_MASK_CHANGED)
1623                 DP(msglvl, "RX-MASK=0x%x\n", filters->rx_mask);
1624
1625         if (filters->flags & VFPF_SET_Q_FILTERS_MULTICAST_CHANGED)
1626                 for (i = 0; i < filters->n_multicast; i++)
1627                         DP(msglvl, "MULTICAST=%pM\n", filters->multicast[i]);
1628 }
1629
1630 #define VFPF_MAC_FILTER         VFPF_Q_FILTER_DEST_MAC_VALID
1631 #define VFPF_VLAN_FILTER        VFPF_Q_FILTER_VLAN_TAG_VALID
1632
1633 static int bnx2x_vf_mbx_qfilters(struct bnx2x *bp, struct bnx2x_virtf *vf)
1634 {
1635         int rc = 0;
1636
1637         struct vfpf_set_q_filters_tlv *msg =
1638                 &BP_VF_MBX(bp, vf->index)->msg->req.set_q_filters;
1639
1640         /* check for any mac/vlan changes */
1641         if (msg->flags & VFPF_SET_Q_FILTERS_MAC_VLAN_CHANGED) {
1642                 /* build mac list */
1643                 struct bnx2x_vf_mac_vlan_filters *fl = NULL;
1644
1645                 rc = bnx2x_vf_mbx_macvlan_list(bp, vf, msg, &fl,
1646                                                VFPF_MAC_FILTER);
1647                 if (rc)
1648                         goto op_err;
1649
1650                 if (fl) {
1651
1652                         /* set mac list */
1653                         rc = bnx2x_vf_mac_vlan_config_list(bp, vf, fl,
1654                                                            msg->vf_qid,
1655                                                            false);
1656                         if (rc)
1657                                 goto op_err;
1658                 }
1659
1660                 /* build vlan list */
1661                 fl = NULL;
1662
1663                 rc = bnx2x_vf_mbx_macvlan_list(bp, vf, msg, &fl,
1664                                                VFPF_VLAN_FILTER);
1665                 if (rc)
1666                         goto op_err;
1667
1668                 if (fl) {
1669                         /* set vlan list */
1670                         rc = bnx2x_vf_mac_vlan_config_list(bp, vf, fl,
1671                                                            msg->vf_qid,
1672                                                            false);
1673                         if (rc)
1674                                 goto op_err;
1675                 }
1676         }
1677
1678         if (msg->flags & VFPF_SET_Q_FILTERS_RX_MASK_CHANGED) {
1679                 unsigned long accept = 0;
1680                 struct pf_vf_bulletin_content *bulletin =
1681                                         BP_VF_BULLETIN(bp, vf->index);
1682
1683                 /* Ignore VF requested mode; instead set a regular mode */
1684                 if (msg->rx_mask !=  VFPF_RX_MASK_ACCEPT_NONE) {
1685                         __set_bit(BNX2X_ACCEPT_UNICAST, &accept);
1686                         __set_bit(BNX2X_ACCEPT_MULTICAST, &accept);
1687                         __set_bit(BNX2X_ACCEPT_BROADCAST, &accept);
1688                 }
1689
1690                 /* A packet arriving the vf's mac should be accepted
1691                  * with any vlan, unless a vlan has already been
1692                  * configured.
1693                  */
1694                 if (!(bulletin->valid_bitmap & (1 << VLAN_VALID)))
1695                         __set_bit(BNX2X_ACCEPT_ANY_VLAN, &accept);
1696
1697                 /* set rx-mode */
1698                 rc = bnx2x_vf_rxmode(bp, vf, msg->vf_qid, accept);
1699                 if (rc)
1700                         goto op_err;
1701         }
1702
1703         if (msg->flags & VFPF_SET_Q_FILTERS_MULTICAST_CHANGED) {
1704                 /* set mcasts */
1705                 rc = bnx2x_vf_mcast(bp, vf, msg->multicast,
1706                                     msg->n_multicast, false);
1707                 if (rc)
1708                         goto op_err;
1709         }
1710 op_err:
1711         if (rc)
1712                 BNX2X_ERR("QFILTERS[%d:%d] error: rc %d\n",
1713                           vf->abs_vfid, msg->vf_qid, rc);
1714         return rc;
1715 }
1716
1717 static int bnx2x_filters_validate_mac(struct bnx2x *bp,
1718                                       struct bnx2x_virtf *vf,
1719                                       struct vfpf_set_q_filters_tlv *filters)
1720 {
1721         struct pf_vf_bulletin_content *bulletin = BP_VF_BULLETIN(bp, vf->index);
1722         int rc = 0;
1723
1724         /* if a mac was already set for this VF via the set vf mac ndo, we only
1725          * accept mac configurations of that mac. Why accept them at all?
1726          * because PF may have been unable to configure the mac at the time
1727          * since queue was not set up.
1728          */
1729         if (bulletin->valid_bitmap & 1 << MAC_ADDR_VALID) {
1730                 /* once a mac was set by ndo can only accept a single mac... */
1731                 if (filters->n_mac_vlan_filters > 1) {
1732                         BNX2X_ERR("VF[%d] requested the addition of multiple macs after set_vf_mac ndo was called\n",
1733                                   vf->abs_vfid);
1734                         rc = -EPERM;
1735                         goto response;
1736                 }
1737
1738                 /* ...and only the mac set by the ndo */
1739                 if (filters->n_mac_vlan_filters == 1 &&
1740                     !ether_addr_equal(filters->filters->mac, bulletin->mac)) {
1741                         BNX2X_ERR("VF[%d] requested the addition of a mac address not matching the one configured by set_vf_mac ndo\n",
1742                                   vf->abs_vfid);
1743
1744                         rc = -EPERM;
1745                         goto response;
1746                 }
1747         }
1748
1749 response:
1750         return rc;
1751 }
1752
1753 static int bnx2x_filters_validate_vlan(struct bnx2x *bp,
1754                                        struct bnx2x_virtf *vf,
1755                                        struct vfpf_set_q_filters_tlv *filters)
1756 {
1757         struct pf_vf_bulletin_content *bulletin = BP_VF_BULLETIN(bp, vf->index);
1758         int rc = 0;
1759
1760         /* if vlan was set by hypervisor we don't allow guest to config vlan */
1761         if (bulletin->valid_bitmap & 1 << VLAN_VALID) {
1762                 int i;
1763
1764                 /* search for vlan filters */
1765                 for (i = 0; i < filters->n_mac_vlan_filters; i++) {
1766                         if (filters->filters[i].flags &
1767                             VFPF_Q_FILTER_VLAN_TAG_VALID) {
1768                                 BNX2X_ERR("VF[%d] attempted to configure vlan but one was already set by Hypervisor. Aborting request\n",
1769                                           vf->abs_vfid);
1770                                 rc = -EPERM;
1771                                 goto response;
1772                         }
1773                 }
1774         }
1775
1776         /* verify vf_qid */
1777         if (filters->vf_qid > vf_rxq_count(vf)) {
1778                 rc = -EPERM;
1779                 goto response;
1780         }
1781
1782 response:
1783         return rc;
1784 }
1785
1786 static void bnx2x_vf_mbx_set_q_filters(struct bnx2x *bp,
1787                                        struct bnx2x_virtf *vf,
1788                                        struct bnx2x_vf_mbx *mbx)
1789 {
1790         struct vfpf_set_q_filters_tlv *filters = &mbx->msg->req.set_q_filters;
1791         int rc;
1792
1793         rc = bnx2x_filters_validate_mac(bp, vf, filters);
1794         if (rc)
1795                 goto response;
1796
1797         rc = bnx2x_filters_validate_vlan(bp, vf, filters);
1798         if (rc)
1799                 goto response;
1800
1801         DP(BNX2X_MSG_IOV, "VF[%d] Q_FILTERS: queue[%d]\n",
1802            vf->abs_vfid,
1803            filters->vf_qid);
1804
1805         /* print q_filter message */
1806         bnx2x_vf_mbx_dp_q_filters(bp, BNX2X_MSG_IOV, filters);
1807
1808         rc = bnx2x_vf_mbx_qfilters(bp, vf);
1809 response:
1810         bnx2x_vf_mbx_resp(bp, vf, rc);
1811 }
1812
1813 static void bnx2x_vf_mbx_teardown_q(struct bnx2x *bp, struct bnx2x_virtf *vf,
1814                                     struct bnx2x_vf_mbx *mbx)
1815 {
1816         int qid = mbx->msg->req.q_op.vf_qid;
1817         int rc;
1818
1819         DP(BNX2X_MSG_IOV, "VF[%d] Q_TEARDOWN: vf_qid=%d\n",
1820            vf->abs_vfid, qid);
1821
1822         rc = bnx2x_vf_queue_teardown(bp, vf, qid);
1823         bnx2x_vf_mbx_resp(bp, vf, rc);
1824 }
1825
1826 static void bnx2x_vf_mbx_close_vf(struct bnx2x *bp, struct bnx2x_virtf *vf,
1827                                   struct bnx2x_vf_mbx *mbx)
1828 {
1829         int rc;
1830
1831         DP(BNX2X_MSG_IOV, "VF[%d] VF_CLOSE\n", vf->abs_vfid);
1832
1833         rc = bnx2x_vf_close(bp, vf);
1834         bnx2x_vf_mbx_resp(bp, vf, rc);
1835 }
1836
1837 static void bnx2x_vf_mbx_release_vf(struct bnx2x *bp, struct bnx2x_virtf *vf,
1838                                     struct bnx2x_vf_mbx *mbx)
1839 {
1840         int rc;
1841
1842         DP(BNX2X_MSG_IOV, "VF[%d] VF_RELEASE\n", vf->abs_vfid);
1843
1844         rc = bnx2x_vf_free(bp, vf);
1845         bnx2x_vf_mbx_resp(bp, vf, rc);
1846 }
1847
1848 static void bnx2x_vf_mbx_update_rss(struct bnx2x *bp, struct bnx2x_virtf *vf,
1849                                     struct bnx2x_vf_mbx *mbx)
1850 {
1851         struct bnx2x_config_rss_params rss;
1852         struct vfpf_rss_tlv *rss_tlv = &mbx->msg->req.update_rss;
1853         int rc = 0;
1854
1855         if (rss_tlv->ind_table_size != T_ETH_INDIRECTION_TABLE_SIZE ||
1856             rss_tlv->rss_key_size != T_ETH_RSS_KEY) {
1857                 BNX2X_ERR("failing rss configuration of vf %d due to size mismatch\n",
1858                           vf->index);
1859                 rc = -EINVAL;
1860                 goto mbx_resp;
1861         }
1862
1863         memset(&rss, 0, sizeof(struct bnx2x_config_rss_params));
1864
1865         /* set vfop params according to rss tlv */
1866         memcpy(rss.ind_table, rss_tlv->ind_table,
1867                T_ETH_INDIRECTION_TABLE_SIZE);
1868         memcpy(rss.rss_key, rss_tlv->rss_key, sizeof(rss_tlv->rss_key));
1869         rss.rss_obj = &vf->rss_conf_obj;
1870         rss.rss_result_mask = rss_tlv->rss_result_mask;
1871
1872         /* flags handled individually for backward/forward compatibility */
1873         rss.rss_flags = 0;
1874         rss.ramrod_flags = 0;
1875
1876         if (rss_tlv->rss_flags & VFPF_RSS_MODE_DISABLED)
1877                 __set_bit(BNX2X_RSS_MODE_DISABLED, &rss.rss_flags);
1878         if (rss_tlv->rss_flags & VFPF_RSS_MODE_REGULAR)
1879                 __set_bit(BNX2X_RSS_MODE_REGULAR, &rss.rss_flags);
1880         if (rss_tlv->rss_flags & VFPF_RSS_SET_SRCH)
1881                 __set_bit(BNX2X_RSS_SET_SRCH, &rss.rss_flags);
1882         if (rss_tlv->rss_flags & VFPF_RSS_IPV4)
1883                 __set_bit(BNX2X_RSS_IPV4, &rss.rss_flags);
1884         if (rss_tlv->rss_flags & VFPF_RSS_IPV4_TCP)
1885                 __set_bit(BNX2X_RSS_IPV4_TCP, &rss.rss_flags);
1886         if (rss_tlv->rss_flags & VFPF_RSS_IPV4_UDP)
1887                 __set_bit(BNX2X_RSS_IPV4_UDP, &rss.rss_flags);
1888         if (rss_tlv->rss_flags & VFPF_RSS_IPV6)
1889                 __set_bit(BNX2X_RSS_IPV6, &rss.rss_flags);
1890         if (rss_tlv->rss_flags & VFPF_RSS_IPV6_TCP)
1891                 __set_bit(BNX2X_RSS_IPV6_TCP, &rss.rss_flags);
1892         if (rss_tlv->rss_flags & VFPF_RSS_IPV6_UDP)
1893                 __set_bit(BNX2X_RSS_IPV6_UDP, &rss.rss_flags);
1894
1895         if ((!(rss_tlv->rss_flags & VFPF_RSS_IPV4_TCP) &&
1896              rss_tlv->rss_flags & VFPF_RSS_IPV4_UDP) ||
1897             (!(rss_tlv->rss_flags & VFPF_RSS_IPV6_TCP) &&
1898              rss_tlv->rss_flags & VFPF_RSS_IPV6_UDP)) {
1899                 BNX2X_ERR("about to hit a FW assert. aborting...\n");
1900                 rc = -EINVAL;
1901                 goto mbx_resp;
1902         }
1903
1904         rc = bnx2x_vf_rss_update(bp, vf, &rss);
1905 mbx_resp:
1906         bnx2x_vf_mbx_resp(bp, vf, rc);
1907 }
1908
1909 static int bnx2x_validate_tpa_params(struct bnx2x *bp,
1910                                        struct vfpf_tpa_tlv *tpa_tlv)
1911 {
1912         int rc = 0;
1913
1914         if (tpa_tlv->tpa_client_info.max_sges_for_packet >
1915             U_ETH_MAX_SGES_FOR_PACKET) {
1916                 rc = -EINVAL;
1917                 BNX2X_ERR("TPA update: max_sges received %d, max is %d\n",
1918                           tpa_tlv->tpa_client_info.max_sges_for_packet,
1919                           U_ETH_MAX_SGES_FOR_PACKET);
1920         }
1921
1922         if (tpa_tlv->tpa_client_info.max_tpa_queues > MAX_AGG_QS(bp)) {
1923                 rc = -EINVAL;
1924                 BNX2X_ERR("TPA update: max_tpa_queues received %d, max is %d\n",
1925                           tpa_tlv->tpa_client_info.max_tpa_queues,
1926                           MAX_AGG_QS(bp));
1927         }
1928
1929         return rc;
1930 }
1931
1932 static void bnx2x_vf_mbx_update_tpa(struct bnx2x *bp, struct bnx2x_virtf *vf,
1933                                     struct bnx2x_vf_mbx *mbx)
1934 {
1935         struct bnx2x_queue_update_tpa_params vf_op_params;
1936         struct vfpf_tpa_tlv *tpa_tlv = &mbx->msg->req.update_tpa;
1937         int rc = 0;
1938
1939         memset(&vf_op_params, 0, sizeof(vf_op_params));
1940
1941         if (bnx2x_validate_tpa_params(bp, tpa_tlv))
1942                 goto mbx_resp;
1943
1944         vf_op_params.complete_on_both_clients =
1945                 tpa_tlv->tpa_client_info.complete_on_both_clients;
1946         vf_op_params.dont_verify_thr =
1947                 tpa_tlv->tpa_client_info.dont_verify_thr;
1948         vf_op_params.max_agg_sz =
1949                 tpa_tlv->tpa_client_info.max_agg_size;
1950         vf_op_params.max_sges_pkt =
1951                 tpa_tlv->tpa_client_info.max_sges_for_packet;
1952         vf_op_params.max_tpa_queues =
1953                 tpa_tlv->tpa_client_info.max_tpa_queues;
1954         vf_op_params.sge_buff_sz =
1955                 tpa_tlv->tpa_client_info.sge_buff_size;
1956         vf_op_params.sge_pause_thr_high =
1957                 tpa_tlv->tpa_client_info.sge_pause_thr_high;
1958         vf_op_params.sge_pause_thr_low =
1959                 tpa_tlv->tpa_client_info.sge_pause_thr_low;
1960         vf_op_params.tpa_mode =
1961                 tpa_tlv->tpa_client_info.tpa_mode;
1962         vf_op_params.update_ipv4 =
1963                 tpa_tlv->tpa_client_info.update_ipv4;
1964         vf_op_params.update_ipv6 =
1965                 tpa_tlv->tpa_client_info.update_ipv6;
1966
1967         rc = bnx2x_vf_tpa_update(bp, vf, tpa_tlv, &vf_op_params);
1968
1969 mbx_resp:
1970         bnx2x_vf_mbx_resp(bp, vf, rc);
1971 }
1972
1973 /* dispatch request */
1974 static void bnx2x_vf_mbx_request(struct bnx2x *bp, struct bnx2x_virtf *vf,
1975                                   struct bnx2x_vf_mbx *mbx)
1976 {
1977         int i;
1978
1979         /* check if tlv type is known */
1980         if (bnx2x_tlv_supported(mbx->first_tlv.tl.type)) {
1981                 /* Lock the per vf op mutex and note the locker's identity.
1982                  * The unlock will take place in mbx response.
1983                  */
1984                 bnx2x_lock_vf_pf_channel(bp, vf, mbx->first_tlv.tl.type);
1985
1986                 /* switch on the opcode */
1987                 switch (mbx->first_tlv.tl.type) {
1988                 case CHANNEL_TLV_ACQUIRE:
1989                         bnx2x_vf_mbx_acquire(bp, vf, mbx);
1990                         return;
1991                 case CHANNEL_TLV_INIT:
1992                         bnx2x_vf_mbx_init_vf(bp, vf, mbx);
1993                         return;
1994                 case CHANNEL_TLV_SETUP_Q:
1995                         bnx2x_vf_mbx_setup_q(bp, vf, mbx);
1996                         return;
1997                 case CHANNEL_TLV_SET_Q_FILTERS:
1998                         bnx2x_vf_mbx_set_q_filters(bp, vf, mbx);
1999                         return;
2000                 case CHANNEL_TLV_TEARDOWN_Q:
2001                         bnx2x_vf_mbx_teardown_q(bp, vf, mbx);
2002                         return;
2003                 case CHANNEL_TLV_CLOSE:
2004                         bnx2x_vf_mbx_close_vf(bp, vf, mbx);
2005                         return;
2006                 case CHANNEL_TLV_RELEASE:
2007                         bnx2x_vf_mbx_release_vf(bp, vf, mbx);
2008                         return;
2009                 case CHANNEL_TLV_UPDATE_RSS:
2010                         bnx2x_vf_mbx_update_rss(bp, vf, mbx);
2011                         return;
2012                 case CHANNEL_TLV_UPDATE_TPA:
2013                         bnx2x_vf_mbx_update_tpa(bp, vf, mbx);
2014                         return;
2015                 }
2016
2017         } else {
2018                 /* unknown TLV - this may belong to a VF driver from the future
2019                  * - a version written after this PF driver was written, which
2020                  * supports features unknown as of yet. Too bad since we don't
2021                  * support them. Or this may be because someone wrote a crappy
2022                  * VF driver and is sending garbage over the channel.
2023                  */
2024                 BNX2X_ERR("unknown TLV. type %d length %d vf->state was %d. first 20 bytes of mailbox buffer:\n",
2025                           mbx->first_tlv.tl.type, mbx->first_tlv.tl.length,
2026                           vf->state);
2027                 for (i = 0; i < 20; i++)
2028                         DP_CONT(BNX2X_MSG_IOV, "%x ",
2029                                 mbx->msg->req.tlv_buf_size.tlv_buffer[i]);
2030         }
2031
2032         /* can we respond to VF (do we have an address for it?) */
2033         if (vf->state == VF_ACQUIRED || vf->state == VF_ENABLED) {
2034                 /* notify the VF that we do not support this request */
2035                 bnx2x_vf_mbx_resp(bp, vf, PFVF_STATUS_NOT_SUPPORTED);
2036         } else {
2037                 /* can't send a response since this VF is unknown to us
2038                  * just ack the FW to release the mailbox and unlock
2039                  * the channel.
2040                  */
2041                 storm_memset_vf_mbx_ack(bp, vf->abs_vfid);
2042                 /* Firmware ack should be written before unlocking channel */
2043                 mmiowb();
2044                 bnx2x_unlock_vf_pf_channel(bp, vf, mbx->first_tlv.tl.type);
2045         }
2046 }
2047
2048 void bnx2x_vf_mbx_schedule(struct bnx2x *bp,
2049                            struct vf_pf_event_data *vfpf_event)
2050 {
2051         u8 vf_idx;
2052
2053         DP(BNX2X_MSG_IOV,
2054            "vf pf event received: vfid %d, address_hi %x, address lo %x",
2055            vfpf_event->vf_id, vfpf_event->msg_addr_hi, vfpf_event->msg_addr_lo);
2056         /* Sanity checks consider removing later */
2057
2058         /* check if the vf_id is valid */
2059         if (vfpf_event->vf_id - BP_VFDB(bp)->sriov.first_vf_in_pf >
2060             BNX2X_NR_VIRTFN(bp)) {
2061                 BNX2X_ERR("Illegal vf_id %d max allowed: %d\n",
2062                           vfpf_event->vf_id, BNX2X_NR_VIRTFN(bp));
2063                 return;
2064         }
2065
2066         vf_idx = bnx2x_vf_idx_by_abs_fid(bp, vfpf_event->vf_id);
2067
2068         /* Update VFDB with current message and schedule its handling */
2069         mutex_lock(&BP_VFDB(bp)->event_mutex);
2070         BP_VF_MBX(bp, vf_idx)->vf_addr_hi = vfpf_event->msg_addr_hi;
2071         BP_VF_MBX(bp, vf_idx)->vf_addr_lo = vfpf_event->msg_addr_lo;
2072         BP_VFDB(bp)->event_occur |= (1ULL << vf_idx);
2073         mutex_unlock(&BP_VFDB(bp)->event_mutex);
2074
2075         bnx2x_schedule_iov_task(bp, BNX2X_IOV_HANDLE_VF_MSG);
2076 }
2077
2078 /* handle new vf-pf messages */
2079 void bnx2x_vf_mbx(struct bnx2x *bp)
2080 {
2081         struct bnx2x_vfdb *vfdb = BP_VFDB(bp);
2082         u64 events;
2083         u8 vf_idx;
2084         int rc;
2085
2086         if (!vfdb)
2087                 return;
2088
2089         mutex_lock(&vfdb->event_mutex);
2090         events = vfdb->event_occur;
2091         vfdb->event_occur = 0;
2092         mutex_unlock(&vfdb->event_mutex);
2093
2094         for_each_vf(bp, vf_idx) {
2095                 struct bnx2x_vf_mbx *mbx = BP_VF_MBX(bp, vf_idx);
2096                 struct bnx2x_virtf *vf = BP_VF(bp, vf_idx);
2097
2098                 /* Handle VFs which have pending events */
2099                 if (!(events & (1ULL << vf_idx)))
2100                         continue;
2101
2102                 DP(BNX2X_MSG_IOV,
2103                    "Handling vf pf event vfid %d, address: [%x:%x], resp_offset 0x%x\n",
2104                    vf_idx, mbx->vf_addr_hi, mbx->vf_addr_lo,
2105                    mbx->first_tlv.resp_msg_offset);
2106
2107                 /* dmae to get the VF request */
2108                 rc = bnx2x_copy32_vf_dmae(bp, true, mbx->msg_mapping,
2109                                           vf->abs_vfid, mbx->vf_addr_hi,
2110                                           mbx->vf_addr_lo,
2111                                           sizeof(union vfpf_tlvs)/4);
2112                 if (rc) {
2113                         BNX2X_ERR("Failed to copy request VF %d\n",
2114                                   vf->abs_vfid);
2115                         bnx2x_vf_release(bp, vf);
2116                         return;
2117                 }
2118
2119                 /* process the VF message header */
2120                 mbx->first_tlv = mbx->msg->req.first_tlv;
2121
2122                 /* Clean response buffer to refrain from falsely
2123                  * seeing chains.
2124                  */
2125                 memset(&mbx->msg->resp, 0, sizeof(union pfvf_tlvs));
2126
2127                 /* dispatch the request (will prepare the response) */
2128                 bnx2x_vf_mbx_request(bp, vf, mbx);
2129         }
2130 }
2131
2132 void bnx2x_vf_bulletin_finalize(struct pf_vf_bulletin_content *bulletin,
2133                                 bool support_long)
2134 {
2135         /* Older VFs contain a bug where they can't check CRC for bulletin
2136          * boards of length greater than legacy size.
2137          */
2138         bulletin->length = support_long ? BULLETIN_CONTENT_SIZE :
2139                                           BULLETIN_CONTENT_LEGACY_SIZE;
2140         bulletin->crc = bnx2x_crc_vf_bulletin(bulletin);
2141 }
2142
2143 /* propagate local bulletin board to vf */
2144 int bnx2x_post_vf_bulletin(struct bnx2x *bp, int vf)
2145 {
2146         struct pf_vf_bulletin_content *bulletin = BP_VF_BULLETIN(bp, vf);
2147         dma_addr_t pf_addr = BP_VF_BULLETIN_DMA(bp)->mapping +
2148                 vf * BULLETIN_CONTENT_SIZE;
2149         dma_addr_t vf_addr = bnx2x_vf(bp, vf, bulletin_map);
2150         int rc;
2151
2152         /* can only update vf after init took place */
2153         if (bnx2x_vf(bp, vf, state) != VF_ENABLED &&
2154             bnx2x_vf(bp, vf, state) != VF_ACQUIRED)
2155                 return 0;
2156
2157         /* increment bulletin board version and compute crc */
2158         bulletin->version++;
2159         bnx2x_vf_bulletin_finalize(bulletin,
2160                                    (bnx2x_vf(bp, vf, cfg_flags) &
2161                                     VF_CFG_EXT_BULLETIN) ? true : false);
2162
2163         /* propagate bulletin board via dmae to vm memory */
2164         rc = bnx2x_copy32_vf_dmae(bp, false, pf_addr,
2165                                   bnx2x_vf(bp, vf, abs_vfid), U64_HI(vf_addr),
2166                                   U64_LO(vf_addr), bulletin->length / 4);
2167         return rc;
2168 }