dma_pool_free(hr_dev->cmd.pool, mailbox->buf, mailbox->dma);
        kfree(mailbox);
 }
+
+int hns_roce_create_hw_ctx(struct hns_roce_dev *dev,
+                          struct hns_roce_cmd_mailbox *mailbox,
+                          u8 cmd, unsigned long idx)
+{
+       return hns_roce_cmd_mbox(dev, mailbox->dma, 0, cmd, idx);
+}
+
+int hns_roce_destroy_hw_ctx(struct hns_roce_dev *dev, u8 cmd, unsigned long idx)
+{
+       return hns_roce_cmd_mbox(dev, 0, 0, cmd, idx);
+}
 
 hns_roce_alloc_cmd_mailbox(struct hns_roce_dev *hr_dev);
 void hns_roce_free_cmd_mailbox(struct hns_roce_dev *hr_dev,
                               struct hns_roce_cmd_mailbox *mailbox);
+int hns_roce_create_hw_ctx(struct hns_roce_dev *dev,
+                          struct hns_roce_cmd_mailbox *mailbox,
+                          u8 cmd, unsigned long idx);
+int hns_roce_destroy_hw_ctx(struct hns_roce_dev *dev, u8 cmd,
+                           unsigned long idx);
 
 #endif /* _HNS_ROCE_CMD_H */
 
 
        hr_dev->hw->write_cqc(hr_dev, hr_cq, mailbox->buf, mtts, dma_handle);
 
-       ret = hns_roce_cmd_mbox(hr_dev, mailbox->dma, 0,
-                               HNS_ROCE_CMD_CREATE_CQC, hr_cq->cqn);
+       ret = hns_roce_create_hw_ctx(hr_dev, mailbox, HNS_ROCE_CMD_CREATE_CQC,
+                                    hr_cq->cqn);
        hns_roce_free_cmd_mailbox(hr_dev, mailbox);
        if (ret) {
                ibdev_err(ibdev,
        struct device *dev = hr_dev->dev;
        int ret;
 
-       ret = hns_roce_cmd_mbox(hr_dev, 0, 0, HNS_ROCE_CMD_DESTROY_CQC,
-                               hr_cq->cqn);
+       ret = hns_roce_destroy_hw_ctx(hr_dev, HNS_ROCE_CMD_DESTROY_CQC,
+                                     hr_cq->cqn);
        if (ret)
                dev_err(dev, "DESTROY_CQ failed (%d) for CQN %06lx\n", ret,
                        hr_cq->cqn);
 
 int hns_roce_map_mr_sg(struct ib_mr *ibmr, struct scatterlist *sg, int sg_nents,
                       unsigned int *sg_offset);
 int hns_roce_dereg_mr(struct ib_mr *ibmr, struct ib_udata *udata);
-int hns_roce_hw_destroy_mpt(struct hns_roce_dev *hr_dev,
-                           unsigned long mpt_index);
 unsigned long key_to_hw_index(u32 key);
 
 int hns_roce_alloc_mw(struct ib_mw *mw, struct ib_udata *udata);
 
        else
                cmd = HNS_ROCE_CMD_DESTROY_AEQC;
 
-       ret = hns_roce_cmd_mbox(hr_dev, 0, 0, cmd, eqn & HNS_ROCE_V2_EQN_M);
+       ret = hns_roce_destroy_hw_ctx(hr_dev, cmd, eqn & HNS_ROCE_V2_EQN_M);
        if (ret)
                dev_err(dev, "[mailbox cmd] destroy eqc(%u) failed.\n", eqn);
 }
        if (ret)
                goto err_cmd_mbox;
 
-       ret = hns_roce_cmd_mbox(hr_dev, mailbox->dma, 0, eq_cmd, eq->eqn);
+       ret = hns_roce_create_hw_ctx(hr_dev, mailbox, eq_cmd, eq->eqn);
        if (ret) {
                dev_err(hr_dev->dev, "[mailbox cmd] create eqc failed.\n");
                goto err_cmd_mbox;
 
        return (key << 24) | (key >> 8);
 }
 
-static int hns_roce_hw_create_mpt(struct hns_roce_dev *hr_dev,
-                                 struct hns_roce_cmd_mailbox *mailbox,
-                                 unsigned long mpt_index)
-{
-       return hns_roce_cmd_mbox(hr_dev, mailbox->dma, 0,
-                                HNS_ROCE_CMD_CREATE_MPT, mpt_index);
-}
-
-int hns_roce_hw_destroy_mpt(struct hns_roce_dev *hr_dev,
-                           unsigned long mpt_index)
-{
-       return hns_roce_cmd_mbox(hr_dev, 0, 0, HNS_ROCE_CMD_DESTROY_MPT,
-                                mpt_index);
-}
-
 static int alloc_mr_key(struct hns_roce_dev *hr_dev, struct hns_roce_mr *mr)
 {
        struct hns_roce_ida *mtpt_ida = &hr_dev->mr_table.mtpt_ida;
        int ret;
 
        if (mr->enabled) {
-               ret = hns_roce_hw_destroy_mpt(hr_dev,
+               ret = hns_roce_destroy_hw_ctx(hr_dev, HNS_ROCE_CMD_DESTROY_MPT,
                                              key_to_hw_index(mr->key) &
                                              (hr_dev->caps.num_mtpts - 1));
                if (ret)
                goto err_page;
        }
 
-       ret = hns_roce_hw_create_mpt(hr_dev, mailbox,
+       ret = hns_roce_create_hw_ctx(hr_dev, mailbox, HNS_ROCE_CMD_CREATE_MPT,
                                     mtpt_idx & (hr_dev->caps.num_mtpts - 1));
        if (ret) {
                dev_err(dev, "failed to create mpt, ret = %d.\n", ret);
        if (ret)
                goto free_cmd_mbox;
 
-       ret = hns_roce_hw_destroy_mpt(hr_dev, mtpt_idx);
+       ret = hns_roce_destroy_hw_ctx(hr_dev, HNS_ROCE_CMD_DESTROY_MPT,
+                                     mtpt_idx);
        if (ret)
                ibdev_warn(ib_dev, "failed to destroy MPT, ret = %d.\n", ret);
 
                goto free_cmd_mbox;
        }
 
-       ret = hns_roce_hw_create_mpt(hr_dev, mailbox, mtpt_idx);
+       ret = hns_roce_create_hw_ctx(hr_dev, mailbox, HNS_ROCE_CMD_CREATE_MPT,
+                                    mtpt_idx);
        if (ret) {
                ibdev_err(ib_dev, "failed to create MPT, ret = %d.\n", ret);
                goto free_cmd_mbox;
        int ret;
 
        if (mw->enabled) {
-               ret = hns_roce_hw_destroy_mpt(hr_dev,
+               ret = hns_roce_destroy_hw_ctx(hr_dev, HNS_ROCE_CMD_DESTROY_MPT,
                                              key_to_hw_index(mw->rkey) &
                                              (hr_dev->caps.num_mtpts - 1));
                if (ret)
                goto err_page;
        }
 
-       ret = hns_roce_hw_create_mpt(hr_dev, mailbox,
+       ret = hns_roce_create_hw_ctx(hr_dev, mailbox, HNS_ROCE_CMD_CREATE_MPT,
                                     mtpt_idx & (hr_dev->caps.num_mtpts - 1));
        if (ret) {
                dev_err(dev, "MW CREATE_MPT failed (%d)\n", ret);
 
        }
 }
 
-static int hns_roce_hw_create_srq(struct hns_roce_dev *dev,
-                                 struct hns_roce_cmd_mailbox *mailbox,
-                                 unsigned long srq_num)
-{
-       return hns_roce_cmd_mbox(dev, mailbox->dma, 0, HNS_ROCE_CMD_CREATE_SRQ,
-                                srq_num);
-}
-
-static int hns_roce_hw_destroy_srq(struct hns_roce_dev *dev,
-                                  unsigned long srq_num)
-{
-       return hns_roce_cmd_mbox(dev, 0, 0, HNS_ROCE_CMD_DESTROY_SRQ, srq_num);
-}
-
 static int alloc_srqc(struct hns_roce_dev *hr_dev, struct hns_roce_srq *srq)
 {
        struct hns_roce_srq_table *srq_table = &hr_dev->srq_table;
                goto err_mbox;
        }
 
-       ret = hns_roce_hw_create_srq(hr_dev, mailbox, srq->srqn);
+       ret = hns_roce_create_hw_ctx(hr_dev, mailbox, HNS_ROCE_CMD_CREATE_SRQ,
+                                    srq->srqn);
        if (ret) {
                ibdev_err(ibdev, "failed to config SRQC, ret = %d.\n", ret);
                goto err_mbox;
        struct hns_roce_srq_table *srq_table = &hr_dev->srq_table;
        int ret;
 
-       ret = hns_roce_hw_destroy_srq(hr_dev, srq->srqn);
+       ret = hns_roce_destroy_hw_ctx(hr_dev, HNS_ROCE_CMD_DESTROY_SRQ,
+                                     srq->srqn);
        if (ret)
                dev_err(hr_dev->dev, "DESTROY_SRQ failed (%d) for SRQN %06lx\n",
                        ret, srq->srqn);