bnxt_en: remove DMA mapping for KONG response

The additional response buffer serves no useful purpose. There can
be only one firmware command in flight due to the hwrm_cmd_lock mutex,
which is taken for the entire duration of any command completion,
KONG or otherwise. It is thus safe to share a single DMA buffer.

Removing the code associated with the additional mapping will simplify
matters in the next patch, which allocates response buffers from DMA
pools on a per request basis.

Signed-off-by: Edwin Peer <edwin.peer@broadcom.com>
Signed-off-by: Michael Chan <michael.chan@broadcom.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

diff --git a/drivers/net/ethernet/broadcom/bnxt/bnxt.c b/drivers/net/ethernet/broadcom/bnxt/bnxt.c
index ccf1e47d9e92a3ca450608e4c8bf9d824d43538c..fb75fa9614c58719a6f165030f23c85d41c00213 100644 (file)
--- a/drivers/net/ethernet/broadcom/bnxt/bnxt.c
+++ b/drivers/net/ethernet/broadcom/bnxt/bnxt.c
@@ -3962,30 +3962,6 @@ static void bnxt_free_hwrm_resources(struct bnxt *bp)
                                  bp->hwrm_cmd_resp_dma_addr);
                bp->hwrm_cmd_resp_addr = NULL;
        }
-
-       if (bp->hwrm_cmd_kong_resp_addr) {
-               dma_free_coherent(&pdev->dev, PAGE_SIZE,
-                                 bp->hwrm_cmd_kong_resp_addr,
-                                 bp->hwrm_cmd_kong_resp_dma_addr);
-               bp->hwrm_cmd_kong_resp_addr = NULL;
-       }
-}
-
-static int bnxt_alloc_kong_hwrm_resources(struct bnxt *bp)
-{
-       struct pci_dev *pdev = bp->pdev;
-
-       if (bp->hwrm_cmd_kong_resp_addr)
-               return 0;
-
-       bp->hwrm_cmd_kong_resp_addr =
-               dma_alloc_coherent(&pdev->dev, PAGE_SIZE,
-                                  &bp->hwrm_cmd_kong_resp_dma_addr,
-                                  GFP_KERNEL);
-       if (!bp->hwrm_cmd_kong_resp_addr)
-               return -ENOMEM;
-
-       return 0;
 }
 
 static int bnxt_alloc_hwrm_resources(struct bnxt *bp)
@@ -4581,10 +4557,7 @@ void bnxt_hwrm_cmd_hdr_init(struct bnxt *bp, void *request, u16 req_type,
        req->req_type = cpu_to_le16(req_type);
        req->cmpl_ring = cpu_to_le16(cmpl_ring);
        req->target_id = cpu_to_le16(target_id);
-       if (bnxt_kong_hwrm_message(bp, req))
-               req->resp_addr = cpu_to_le64(bp->hwrm_cmd_kong_resp_dma_addr);
-       else
-               req->resp_addr = cpu_to_le64(bp->hwrm_cmd_resp_dma_addr);
+       req->resp_addr = cpu_to_le64(bp->hwrm_cmd_resp_dma_addr);
 }
 
 static int bnxt_hwrm_to_stderr(u32 hwrm_err)
@@ -4641,11 +4614,10 @@ static int bnxt_hwrm_do_send_msg(struct bnxt *bp, void *msg, u32 msg_len,
                        return -EINVAL;
        }
 
-       if (bnxt_hwrm_kong_chnl(bp, req)) {
+       if (bnxt_kong_hwrm_message(bp, req)) {
                dst = BNXT_HWRM_CHNL_KONG;
                bar_offset = BNXT_GRCPF_REG_KONG_COMM;
                doorbell_offset = BNXT_GRCPF_REG_KONG_COMM_TRIGGER;
-               resp = bp->hwrm_cmd_kong_resp_addr;
        }
 
        memset(resp, 0, PAGE_SIZE);
@@ -11948,12 +11920,6 @@ static int bnxt_fw_init_one_p1(struct bnxt *bp)
                        return rc;
        }
 
-       if (bp->fw_cap & BNXT_FW_CAP_KONG_MB_CHNL) {
-               rc = bnxt_alloc_kong_hwrm_resources(bp);
-               if (rc)
-                       bp->fw_cap &= ~BNXT_FW_CAP_KONG_MB_CHNL;
-       }
-
        if ((bp->fw_cap & BNXT_FW_CAP_SHORT_CMD) ||
            bp->hwrm_max_ext_req_len > BNXT_HWRM_MAX_REQ_LEN) {
                rc = bnxt_alloc_hwrm_short_cmd_req(bp);
@@ -12136,8 +12102,8 @@ static void bnxt_reset_all(struct bnxt *bp)
        } else if (fw_health->flags & ERROR_RECOVERY_QCFG_RESP_FLAGS_CO_CPU) {
                struct hwrm_fw_reset_input req = {0};
 
-               bnxt_hwrm_cmd_hdr_init(bp, &req, HWRM_FW_RESET, -1, -1);
-               req.resp_addr = cpu_to_le64(bp->hwrm_cmd_kong_resp_dma_addr);
+               bnxt_hwrm_cmd_hdr_init(bp, &req, HWRM_FW_RESET, -1,
+                                      HWRM_TARGET_ID_KONG);
                req.embedded_proc_type = FW_RESET_REQ_EMBEDDED_PROC_TYPE_CHIP;
                req.selfrst_status = FW_RESET_REQ_SELFRST_STATUS_SELFRSTASAP;
                req.flags = FW_RESET_REQ_FLAGS_RESET_GRACEFUL;

diff --git a/drivers/net/ethernet/broadcom/bnxt/bnxt.h b/drivers/net/ethernet/broadcom/bnxt/bnxt.h
index dc96dd6957c95315ec04791d8c6da2bb3adfb3f7..a4fb1aa12b2493e1c1c2d859bc9cabdc0992d4c9 100644 (file)
--- a/drivers/net/ethernet/broadcom/bnxt/bnxt.h
+++ b/drivers/net/ethernet/broadcom/bnxt/bnxt.h
@@ -1915,8 +1915,6 @@ struct bnxt {
        dma_addr_t              hwrm_short_cmd_req_dma_addr;
        void                    *hwrm_cmd_resp_addr;
        dma_addr_t              hwrm_cmd_resp_dma_addr;
-       void                    *hwrm_cmd_kong_resp_addr;
-       dma_addr_t              hwrm_cmd_kong_resp_dma_addr;
 
        struct rtnl_link_stats64        net_stats_prev;
        struct bnxt_stats_mem   port_stats;
@@ -2216,21 +2214,13 @@ static inline bool bnxt_cfa_hwrm_message(u16 req_type)
 static inline bool bnxt_kong_hwrm_message(struct bnxt *bp, struct input *req)
 {
        return (bp->fw_cap & BNXT_FW_CAP_KONG_MB_CHNL &&
-               bnxt_cfa_hwrm_message(le16_to_cpu(req->req_type)));
-}
-
-static inline bool bnxt_hwrm_kong_chnl(struct bnxt *bp, struct input *req)
-{
-       return (bp->fw_cap & BNXT_FW_CAP_KONG_MB_CHNL &&
-               req->resp_addr == cpu_to_le64(bp->hwrm_cmd_kong_resp_dma_addr));
+               (bnxt_cfa_hwrm_message(le16_to_cpu(req->req_type)) ||
+                le16_to_cpu(req->target_id) == HWRM_TARGET_ID_KONG));
 }
 
 static inline void *bnxt_get_hwrm_resp_addr(struct bnxt *bp, void *req)
 {
-       if (bnxt_hwrm_kong_chnl(bp, (struct input *)req))
-               return bp->hwrm_cmd_kong_resp_addr;
-       else
-               return bp->hwrm_cmd_resp_addr;
+       return bp->hwrm_cmd_resp_addr;
 }
 
 static inline u16 bnxt_get_hwrm_seq_id(struct bnxt *bp, u16 dst)