bnx2x: Infrastructure for VF <-> PF request on PF side

Support interrupt from device which indicates VF has placed
A request on the VF <-> PF channel.
The PF driver issues a DMAE to retrieve the request from the VM
memory (the Ghost Physical Address of the request is contained
in the interrupt. The PF driver uses the GPA in the DMAE request,
which is translated by the IOMMU to the correct physical address).
The request which arrives is examined to recognize the sending VF.
The PF driver allocates a workitem to handle the VF Operation (vfop).

Signed-off-by: Ariel Elior <ariele@broadcom.com>
Signed-off-by: Eilon Greenstein <eilong@broadcom.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

1 files changed, 154 insertions, 0 deletions

diff --git a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_vfpf.c b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_vfpf.c
index d1a8644200d9..6e5e0638ee81 100644
--- a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_vfpf.c
+++ b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_vfpf.c
@@ -79,6 +79,24 @@ void bnx2x_dp_tlv_list(struct bnx2x *bp, void *tlvs_list)
            tlv->type, tlv->length);
 }
 
+/* test whether we support a tlv type */
+bool bnx2x_tlv_supported(u16 tlvtype)
+{
+        return CHANNEL_TLV_NONE < tlvtype && tlvtype < CHANNEL_TLV_MAX;
+}
+
+static inline int bnx2x_pfvf_status_codes(int rc)
+{
+        switch (rc) {
+        case 0:
+                return PFVF_STATUS_SUCCESS;
+        case -ENOMEM:
+                return PFVF_STATUS_NO_RESOURCE;
+        default:
+                return PFVF_STATUS_FAILURE;
+        }
+}
+
 /* General service functions */
 static void storm_memset_vf_mbx_ack(struct bnx2x *bp, u16 abs_fid)
 {
@@ -116,3 +134,139 @@ void bnx2x_vf_enable_mbx(struct bnx2x *bp, u8 abs_vfid)
         /* enable the VF access to the mailbox */
         bnx2x_vf_enable_access(bp, abs_vfid);
 }
+
+/* this works only on !E1h */
+static int bnx2x_copy32_vf_dmae(struct bnx2x *bp, u8 from_vf,
+                                dma_addr_t pf_addr, u8 vfid, u32 vf_addr_hi,
+                                u32 vf_addr_lo, u32 len32)
+{
+        struct dmae_command dmae;
+
+        if (CHIP_IS_E1x(bp)) {
+                BNX2X_ERR("Chip revision does not support VFs\n");
+                return DMAE_NOT_RDY;
+        }
+
+        if (!bp->dmae_ready) {
+                BNX2X_ERR("DMAE is not ready, can not copy\n");
+                return DMAE_NOT_RDY;
+        }
+
+        /* set opcode and fixed command fields */
+        bnx2x_prep_dmae_with_comp(bp, &dmae, DMAE_SRC_PCI, DMAE_DST_PCI);
+
+        if (from_vf) {
+                dmae.opcode_iov = (vfid << DMAE_COMMAND_SRC_VFID_SHIFT) |
+                        (DMAE_SRC_VF << DMAE_COMMAND_SRC_VFPF_SHIFT) |
+                        (DMAE_DST_PF << DMAE_COMMAND_DST_VFPF_SHIFT);
+
+                dmae.opcode |= (DMAE_C_DST << DMAE_COMMAND_C_FUNC_SHIFT);
+
+                dmae.src_addr_lo = vf_addr_lo;
+                dmae.src_addr_hi = vf_addr_hi;
+                dmae.dst_addr_lo = U64_LO(pf_addr);
+                dmae.dst_addr_hi = U64_HI(pf_addr);
+        } else {
+                dmae.opcode_iov = (vfid << DMAE_COMMAND_DST_VFID_SHIFT) |
+                        (DMAE_DST_VF << DMAE_COMMAND_DST_VFPF_SHIFT) |
+                        (DMAE_SRC_PF << DMAE_COMMAND_SRC_VFPF_SHIFT);
+
+                dmae.opcode |= (DMAE_C_SRC << DMAE_COMMAND_C_FUNC_SHIFT);
+
+                dmae.src_addr_lo = U64_LO(pf_addr);
+                dmae.src_addr_hi = U64_HI(pf_addr);
+                dmae.dst_addr_lo = vf_addr_lo;
+                dmae.dst_addr_hi = vf_addr_hi;
+        }
+        dmae.len = len32;
+        bnx2x_dp_dmae(bp, &dmae, BNX2X_MSG_DMAE);
+
+        /* issue the command and wait for completion */
+        return bnx2x_issue_dmae_with_comp(bp, &dmae);
+}
+
+/* dispatch request */
+static void bnx2x_vf_mbx_request(struct bnx2x *bp, struct bnx2x_virtf *vf,
+                                  struct bnx2x_vf_mbx *mbx)
+{
+        int i;
+
+        /* check if tlv type is known */
+        if (bnx2x_tlv_supported(mbx->first_tlv.tl.type)) {
+                /* switch on the opcode */
+                switch (mbx->first_tlv.tl.type) {
+                }
+        } else {
+                /* unknown TLV - this may belong to a VF driver from the future
+                 * - a version written after this PF driver was written, which
+                 * supports features unknown as of yet. Too bad since we don't
+                 * support them. Or this may be because someone wrote a crappy
+                 * VF driver and is sending garbage over the channel.
+                 */
+                BNX2X_ERR("unknown TLV. type %d length %d. first 20 bytes of mailbox buffer:\n",
+                          mbx->first_tlv.tl.type, mbx->first_tlv.tl.length);
+                for (i = 0; i < 20; i++)
+                        DP_CONT(BNX2X_MSG_IOV, "%x ",
+                                mbx->msg->req.tlv_buf_size.tlv_buffer[i]);
+        }
+}
+
+/* handle new vf-pf message */
+void bnx2x_vf_mbx(struct bnx2x *bp, struct vf_pf_event_data *vfpf_event)
+{
+        struct bnx2x_virtf *vf;
+        struct bnx2x_vf_mbx *mbx;
+        u8 vf_idx;
+        int rc;
+
+        DP(BNX2X_MSG_IOV,
+           "vf pf event received: vfid %d, address_hi %x, address lo %x",
+           vfpf_event->vf_id, vfpf_event->msg_addr_hi, vfpf_event->msg_addr_lo);
+        /* Sanity checks consider removing later */
+
+        /* check if the vf_id is valid */
+        if (vfpf_event->vf_id - BP_VFDB(bp)->sriov.first_vf_in_pf >
+            BNX2X_NR_VIRTFN(bp)) {
+                BNX2X_ERR("Illegal vf_id %d max allowed: %d\n",
+                          vfpf_event->vf_id, BNX2X_NR_VIRTFN(bp));
+                goto mbx_done;
+        }
+        vf_idx = bnx2x_vf_idx_by_abs_fid(bp, vfpf_event->vf_id);
+        mbx = BP_VF_MBX(bp, vf_idx);
+
+        /* verify an event is not currently being processed -
+         * debug failsafe only
+         */
+        if (mbx->flags & VF_MSG_INPROCESS) {
+                BNX2X_ERR("Previous message is still being processed, vf_id %d\n",
+                          vfpf_event->vf_id);
+                goto mbx_done;
+        }
+        vf = BP_VF(bp, vf_idx);
+
+        /* save the VF message address */
+        mbx->vf_addr_hi = vfpf_event->msg_addr_hi;
+        mbx->vf_addr_lo = vfpf_event->msg_addr_lo;
+        DP(BNX2X_MSG_IOV, "mailbox vf address hi 0x%x, lo 0x%x, offset 0x%x\n",
+           mbx->vf_addr_hi, mbx->vf_addr_lo, mbx->first_tlv.resp_msg_offset);
+
+        /* dmae to get the VF request */
+        rc = bnx2x_copy32_vf_dmae(bp, true, mbx->msg_mapping, vf->abs_vfid,
+                                  mbx->vf_addr_hi, mbx->vf_addr_lo,
+                                  sizeof(union vfpf_tlvs)/4);
+        if (rc) {
+                BNX2X_ERR("Failed to copy request VF %d\n", vf->abs_vfid);
+                goto mbx_error;
+        }
+
+        /* process the VF message header */
+        mbx->first_tlv = mbx->msg->req.first_tlv;
+
+        /* dispatch the request (will prepare the response) */
+        bnx2x_vf_mbx_request(bp, vf, mbx);
+        goto mbx_done;
+
+mbx_error:
+mbx_done:
+        return;
+}