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, 243 insertions, 4 deletions

diff --git a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_sriov.c b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_sriov.c
index d833a2d418ea..9233117ea506 100644
--- a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_sriov.c
+++ b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_sriov.c
@@ -518,6 +518,16 @@ static void bnx2x_vf_set_bars(struct bnx2x *bp, struct bnx2x_virtf *vf)
         }
 }
 
+void bnx2x_iov_remove_one(struct bnx2x *bp)
+{
+        /* if SRIOV is not enabled there's nothing to do */
+        if (!IS_SRIOV(bp))
+                return;
+
+        /* free vf database */
+        __bnx2x_iov_free_vfdb(bp);
+}
+
 void bnx2x_iov_free_mem(struct bnx2x *bp)
 {
         int i;
@@ -692,12 +702,241 @@ int bnx2x_iov_init_ilt(struct bnx2x *bp, u16 line)
         return line + i;
 }
 
-void bnx2x_iov_remove_one(struct bnx2x *bp)
+static u8 bnx2x_iov_is_vf_cid(struct bnx2x *bp, u16 cid)
 {
-        /* if SRIOV is not enabled there's nothing to do */
+        return ((cid >= BNX2X_FIRST_VF_CID) &&
+                ((cid - BNX2X_FIRST_VF_CID) < BNX2X_VF_CIDS));
+}
+
+static
+void bnx2x_vf_handle_classification_eqe(struct bnx2x *bp,
+                                        struct bnx2x_vf_queue *vfq,
+                                        union event_ring_elem *elem)
+{
+        unsigned long ramrod_flags = 0;
+        int rc = 0;
+
+        /* Always push next commands out, don't wait here */
+        set_bit(RAMROD_CONT, &ramrod_flags);
+
+        switch (elem->message.data.eth_event.echo >> BNX2X_SWCID_SHIFT) {
+        case BNX2X_FILTER_MAC_PENDING:
+                rc = vfq->mac_obj.complete(bp, &vfq->mac_obj, elem,
+                                           &ramrod_flags);
+                break;
+        case BNX2X_FILTER_VLAN_PENDING:
+                rc = vfq->vlan_obj.complete(bp, &vfq->vlan_obj, elem,
+                                            &ramrod_flags);
+                break;
+        default:
+                BNX2X_ERR("Unsupported classification command: %d\n",
+                          elem->message.data.eth_event.echo);
+                return;
+        }
+        if (rc < 0)
+                BNX2X_ERR("Failed to schedule new commands: %d\n", rc);
+        else if (rc > 0)
+                DP(BNX2X_MSG_IOV, "Scheduled next pending commands...\n");
+}
+
+static
+void bnx2x_vf_handle_mcast_eqe(struct bnx2x *bp,
+                               struct bnx2x_virtf *vf)
+{
+        struct bnx2x_mcast_ramrod_params rparam = {NULL};
+        int rc;
+
+        rparam.mcast_obj = &vf->mcast_obj;
+        vf->mcast_obj.raw.clear_pending(&vf->mcast_obj.raw);
+
+        /* If there are pending mcast commands - send them */
+        if (vf->mcast_obj.check_pending(&vf->mcast_obj)) {
+                rc = bnx2x_config_mcast(bp, &rparam, BNX2X_MCAST_CMD_CONT);
+                if (rc < 0)
+                        BNX2X_ERR("Failed to send pending mcast commands: %d\n",
+                                  rc);
+        }
+}
+
+static
+void bnx2x_vf_handle_filters_eqe(struct bnx2x *bp,
+                                 struct bnx2x_virtf *vf)
+{
+        smp_mb__before_clear_bit();
+        clear_bit(BNX2X_FILTER_RX_MODE_PENDING, &vf->filter_state);
+        smp_mb__after_clear_bit();
+}
+
+int bnx2x_iov_eq_sp_event(struct bnx2x *bp, union event_ring_elem *elem)
+{
+        struct bnx2x_virtf *vf;
+        int qidx = 0, abs_vfid;
+        u8 opcode;
+        u16 cid = 0xffff;
+
+        if (!IS_SRIOV(bp))
+                return 1;
+
+        /* first get the cid - the only events we handle here are cfc-delete
+         * and set-mac completion
+         */
+        opcode = elem->message.opcode;
+
+        switch (opcode) {
+        case EVENT_RING_OPCODE_CFC_DEL:
+                cid = SW_CID((__force __le32)
+                             elem->message.data.cfc_del_event.cid);
+                DP(BNX2X_MSG_IOV, "checking cfc-del comp cid=%d\n", cid);
+                break;
+        case EVENT_RING_OPCODE_CLASSIFICATION_RULES:
+        case EVENT_RING_OPCODE_MULTICAST_RULES:
+        case EVENT_RING_OPCODE_FILTERS_RULES:
+                cid = (elem->message.data.eth_event.echo &
+                       BNX2X_SWCID_MASK);
+                DP(BNX2X_MSG_IOV, "checking filtering comp cid=%d\n", cid);
+                break;
+        case EVENT_RING_OPCODE_VF_FLR:
+                abs_vfid = elem->message.data.vf_flr_event.vf_id;
+                DP(BNX2X_MSG_IOV, "Got VF FLR notification abs_vfid=%d\n",
+                   abs_vfid);
+                goto get_vf;
+        case EVENT_RING_OPCODE_MALICIOUS_VF:
+                abs_vfid = elem->message.data.malicious_vf_event.vf_id;
+                DP(BNX2X_MSG_IOV, "Got VF MALICIOUS notification abs_vfid=%d\n",
+                   abs_vfid);
+                goto get_vf;
+        default:
+                return 1;
+        }
+
+        /* check if the cid is the VF range */
+        if (!bnx2x_iov_is_vf_cid(bp, cid)) {
+                DP(BNX2X_MSG_IOV, "cid is outside vf range: %d\n", cid);
+                return 1;
+        }
+
+        /* extract vf and rxq index from vf_cid - relies on the following:
+         * 1. vfid on cid reflects the true abs_vfid
+         * 2. the max number of VFs (per path) is 64
+         */
+        qidx = cid & ((1 << BNX2X_VF_CID_WND)-1);
+        abs_vfid = (cid >> BNX2X_VF_CID_WND) & (BNX2X_MAX_NUM_OF_VFS-1);
+get_vf:
+        vf = bnx2x_vf_by_abs_fid(bp, abs_vfid);
+
+        if (!vf) {
+                BNX2X_ERR("EQ completion for unknown VF, cid %d, abs_vfid %d\n",
+                          cid, abs_vfid);
+                return 0;
+        }
+
+        switch (opcode) {
+        case EVENT_RING_OPCODE_CFC_DEL:
+                DP(BNX2X_MSG_IOV, "got VF [%d:%d] cfc delete ramrod\n",
+                   vf->abs_vfid, qidx);
+                vfq_get(vf, qidx)->sp_obj.complete_cmd(bp,
+                                                       &vfq_get(vf,
+                                                                qidx)->sp_obj,
+                                                       BNX2X_Q_CMD_CFC_DEL);
+                break;
+        case EVENT_RING_OPCODE_CLASSIFICATION_RULES:
+                DP(BNX2X_MSG_IOV, "got VF [%d:%d] set mac/vlan ramrod\n",
+                   vf->abs_vfid, qidx);
+                bnx2x_vf_handle_classification_eqe(bp, vfq_get(vf, qidx), elem);
+                break;
+        case EVENT_RING_OPCODE_MULTICAST_RULES:
+                DP(BNX2X_MSG_IOV, "got VF [%d:%d] set mcast ramrod\n",
+                   vf->abs_vfid, qidx);
+                bnx2x_vf_handle_mcast_eqe(bp, vf);
+                break;
+        case EVENT_RING_OPCODE_FILTERS_RULES:
+                DP(BNX2X_MSG_IOV, "got VF [%d:%d] set rx-mode ramrod\n",
+                   vf->abs_vfid, qidx);
+                bnx2x_vf_handle_filters_eqe(bp, vf);
+                break;
+        case EVENT_RING_OPCODE_VF_FLR:
+                DP(BNX2X_MSG_IOV, "got VF [%d] FLR notification\n",
+                   vf->abs_vfid);
+                /* Do nothing for now */
+                break;
+        case EVENT_RING_OPCODE_MALICIOUS_VF:
+                DP(BNX2X_MSG_IOV, "got VF [%d] MALICIOUS notification\n",
+                   vf->abs_vfid);
+                /* Do nothing for now */
+                break;
+        }
+        /* SRIOV: reschedule any 'in_progress' operations */
+        bnx2x_iov_sp_event(bp, cid, false);
+
+        return 0;
+}
+
+static struct bnx2x_virtf *bnx2x_vf_by_cid(struct bnx2x *bp, int vf_cid)
+{
+        /* extract the vf from vf_cid - relies on the following:
+         * 1. vfid on cid reflects the true abs_vfid
+         * 2. the max number of VFs (per path) is 64
+         */
+        int abs_vfid = (vf_cid >> BNX2X_VF_CID_WND) & (BNX2X_MAX_NUM_OF_VFS-1);
+        return bnx2x_vf_by_abs_fid(bp, abs_vfid);
+}
+
+void bnx2x_iov_set_queue_sp_obj(struct bnx2x *bp, int vf_cid,
+                                struct bnx2x_queue_sp_obj **q_obj)
+{
+        struct bnx2x_virtf *vf;
+
         if (!IS_SRIOV(bp))
                 return;
 
-        /* free vf database */
-        __bnx2x_iov_free_vfdb(bp);
+        vf = bnx2x_vf_by_cid(bp, vf_cid);
+
+        if (vf) {
+                /* extract queue index from vf_cid - relies on the following:
+                 * 1. vfid on cid reflects the true abs_vfid
+                 * 2. the max number of VFs (per path) is 64
+                 */
+                int q_index = vf_cid & ((1 << BNX2X_VF_CID_WND)-1);
+                *q_obj = &bnx2x_vfq(vf, q_index, sp_obj);
+        } else {
+                BNX2X_ERR("No vf matching cid %d\n", vf_cid);
+        }
+}
+
+void bnx2x_iov_sp_event(struct bnx2x *bp, int vf_cid, bool queue_work)
+{
+        struct bnx2x_virtf *vf;
+
+        /* check if the cid is the VF range */
+        if (!IS_SRIOV(bp) || !bnx2x_iov_is_vf_cid(bp, vf_cid))
+                return;
+
+        vf = bnx2x_vf_by_cid(bp, vf_cid);
+        if (vf) {
+                /* set in_progress flag */
+                atomic_set(&vf->op_in_progress, 1);
+                if (queue_work)
+                        queue_delayed_work(bnx2x_wq, &bp->sp_task, 0);
+        }
+}
+
+void bnx2x_iov_sp_task(struct bnx2x *bp)
+{
+        int i;
+
+        if (!IS_SRIOV(bp))
+                return;
+        /* Iterate over all VFs and invoke state transition for VFs with
+         * 'in-progress' slow-path operations
+         */
+        DP(BNX2X_MSG_IOV, "searching for pending vf operations\n");
+        for_each_vf(bp, i) {
+                struct bnx2x_virtf *vf = BP_VF(bp, i);
+
+                if (!list_empty(&vf->op_list_head) &&
+                    atomic_read(&vf->op_in_progress)) {
+                        DP(BNX2X_MSG_IOV, "running pending op for vf %d\n", i);
+                        bnx2x_vfop_cur(bp, vf)->transition(bp, vf);
+                }
+        }
 }