/* this should be called with "poll_sem" */
 static int __hns_roce_cmd_mbox_poll(struct hns_roce_dev *hr_dev, u64 in_param,
                                    u64 out_param, unsigned long in_modifier,
-                                   u16 op, unsigned int timeout)
+                                   u16 op)
 {
        int ret;
 
                return ret;
        }
 
-       return hr_dev->hw->poll_mbox_done(hr_dev, timeout);
+       return hr_dev->hw->poll_mbox_done(hr_dev);
 }
 
 static int hns_roce_cmd_mbox_poll(struct hns_roce_dev *hr_dev, u64 in_param,
                                  u64 out_param, unsigned long in_modifier,
-                                 u16 op, unsigned int timeout)
+                                 u16 op)
 {
        int ret;
 
        down(&hr_dev->cmd.poll_sem);
        ret = __hns_roce_cmd_mbox_poll(hr_dev, in_param, out_param, in_modifier,
-                                      op, timeout);
+                                      op);
        up(&hr_dev->cmd.poll_sem);
 
        return ret;
 
 static int __hns_roce_cmd_mbox_wait(struct hns_roce_dev *hr_dev, u64 in_param,
                                    u64 out_param, unsigned long in_modifier,
-                                   u16 op, unsigned int timeout)
+                                   u16 op)
 {
        struct hns_roce_cmdq *cmd = &hr_dev->cmd;
        struct hns_roce_cmd_context *context;
        }
 
        if (!wait_for_completion_timeout(&context->done,
-                                        msecs_to_jiffies(timeout))) {
+                               msecs_to_jiffies(HNS_ROCE_CMD_TIMEOUT_MSECS))) {
                dev_err_ratelimited(dev, "[cmd] token 0x%x mailbox 0x%x timeout.\n",
                                    context->token, op);
                ret = -EBUSY;
 
 static int hns_roce_cmd_mbox_wait(struct hns_roce_dev *hr_dev, u64 in_param,
                                  u64 out_param, unsigned long in_modifier,
-                                 u16 op, unsigned int timeout)
+                                 u16 op)
 {
        int ret;
 
        down(&hr_dev->cmd.event_sem);
        ret = __hns_roce_cmd_mbox_wait(hr_dev, in_param, out_param, in_modifier,
-                                      op, timeout);
+                                      op);
        up(&hr_dev->cmd.event_sem);
 
        return ret;
 }
 
 int hns_roce_cmd_mbox(struct hns_roce_dev *hr_dev, u64 in_param, u64 out_param,
-                     unsigned long in_modifier, u16 op, unsigned int timeout)
+                     unsigned long in_modifier, u16 op)
 {
        bool is_busy;
 
 
        if (hr_dev->cmd.use_events)
                return hns_roce_cmd_mbox_wait(hr_dev, in_param, out_param,
-                                             in_modifier, op, timeout);
+                                             in_modifier, op);
        else
                return hns_roce_cmd_mbox_poll(hr_dev, in_param, out_param,
-                                             in_modifier, op, timeout);
+                                             in_modifier, op);
 }
 
 int hns_roce_cmd_init(struct hns_roce_dev *hr_dev)
 
 };
 
 int hns_roce_cmd_mbox(struct hns_roce_dev *hr_dev, u64 in_param, u64 out_param,
-                     unsigned long in_modifier, u16 op, unsigned int timeout);
+                     unsigned long in_modifier, u16 op);
 
 struct hns_roce_cmd_mailbox *
 hns_roce_alloc_cmd_mailbox(struct hns_roce_dev *hr_dev);
 
 
        /* Send mailbox to hw */
        ret = hns_roce_cmd_mbox(hr_dev, mailbox->dma, 0, hr_cq->cqn,
-                       HNS_ROCE_CMD_CREATE_CQC, HNS_ROCE_CMD_TIMEOUT_MSECS);
+                               HNS_ROCE_CMD_CREATE_CQC);
        hns_roce_free_cmd_mailbox(hr_dev, mailbox);
        if (ret) {
                ibdev_err(ibdev,
        int ret;
 
        ret = hns_roce_cmd_mbox(hr_dev, 0, 0, hr_cq->cqn,
-                               HNS_ROCE_CMD_DESTROY_CQC,
-                               HNS_ROCE_CMD_TIMEOUT_MSECS);
+                               HNS_ROCE_CMD_DESTROY_CQC);
        if (ret)
                dev_err(dev, "DESTROY_CQ failed (%d) for CQN %06lx\n", ret,
                        hr_cq->cqn);
 
        int (*post_mbox)(struct hns_roce_dev *hr_dev, u64 in_param,
                         u64 out_param, u32 in_modifier, u16 op,
                         u16 token, int event);
-       int (*poll_mbox_done)(struct hns_roce_dev *hr_dev,
-                             unsigned int timeout);
+       int (*poll_mbox_done)(struct hns_roce_dev *hr_dev);
        bool (*chk_mbox_avail)(struct hns_roce_dev *hr_dev, bool *is_busy);
        int (*set_gid)(struct hns_roce_dev *hr_dev, int gid_index,
                       const union ib_gid *gid, const struct ib_gid_attr *attr);
 
        if (IS_ERR(mbox))
                return PTR_ERR(mbox);
 
-       ret = hns_roce_cmd_mbox(hr_dev, base_addr, mbox->dma, obj, op,
-                               HNS_ROCE_CMD_TIMEOUT_MSECS);
+       ret = hns_roce_cmd_mbox(hr_dev, base_addr, mbox->dma, obj, op);
        hns_roce_free_cmd_mailbox(hr_dev, mbox);
        return ret;
 }
        return ret;
 }
 
-static int v2_poll_mbox_done(struct hns_roce_dev *hr_dev, unsigned int timeout)
+static int v2_poll_mbox_done(struct hns_roce_dev *hr_dev)
 {
        u8 status = 0;
        int ret;
 
-       ret = v2_wait_mbox_complete(hr_dev, timeout, &status);
+       ret = v2_wait_mbox_complete(hr_dev, HNS_ROCE_CMD_TIMEOUT_MSECS,
+                                   &status);
        if (!ret) {
                if (status != MB_ST_COMPLETE_SUCC)
                        return -EBUSY;
                return PTR_ERR(mailbox);
 
        /* configure the tag and op */
-       ret = hns_roce_cmd_mbox(hr_dev, 0, mailbox->dma, obj, op,
-                               HNS_ROCE_CMD_TIMEOUT_MSECS);
+       ret = hns_roce_cmd_mbox(hr_dev, 0, mailbox->dma, obj, op);
 
        hns_roce_free_cmd_mailbox(hr_dev, mailbox);
        return ret;
        memcpy(mailbox->buf + qpc_size, qpc_mask, qpc_size);
 
        ret = hns_roce_cmd_mbox(hr_dev, mailbox->dma, 0, hr_qp->qpn,
-                               HNS_ROCE_CMD_MODIFY_QPC,
-                               HNS_ROCE_CMD_TIMEOUT_MSECS);
+                               HNS_ROCE_CMD_MODIFY_QPC);
 
        hns_roce_free_cmd_mailbox(hr_dev, mailbox);
 
                return PTR_ERR(mailbox);
 
        ret = hns_roce_cmd_mbox(hr_dev, 0, mailbox->dma, hr_qp->qpn,
-                               HNS_ROCE_CMD_QUERY_QPC,
-                               HNS_ROCE_CMD_TIMEOUT_MSECS);
+                               HNS_ROCE_CMD_QUERY_QPC);
        if (ret)
                goto out;
 
                hr_reg_clear(srqc_mask, SRQC_LIMIT_WL);
 
                ret = hns_roce_cmd_mbox(hr_dev, mailbox->dma, 0, srq->srqn,
-                                       HNS_ROCE_CMD_MODIFY_SRQC,
-                                       HNS_ROCE_CMD_TIMEOUT_MSECS);
+                                       HNS_ROCE_CMD_MODIFY_SRQC);
                hns_roce_free_cmd_mailbox(hr_dev, mailbox);
                if (ret) {
                        ibdev_err(&hr_dev->ib_dev,
 
        srq_context = mailbox->buf;
        ret = hns_roce_cmd_mbox(hr_dev, 0, mailbox->dma, srq->srqn,
-                               HNS_ROCE_CMD_QUERY_SRQC,
-                               HNS_ROCE_CMD_TIMEOUT_MSECS);
+                               HNS_ROCE_CMD_QUERY_SRQC);
        if (ret) {
                ibdev_err(&hr_dev->ib_dev,
                          "failed to process cmd of querying SRQ, ret = %d.\n",
        hr_reg_clear(cqc_mask, CQC_CQ_PERIOD);
 
        ret = hns_roce_cmd_mbox(hr_dev, mailbox->dma, 0, hr_cq->cqn,
-                               HNS_ROCE_CMD_MODIFY_CQC,
-                               HNS_ROCE_CMD_TIMEOUT_MSECS);
+                               HNS_ROCE_CMD_MODIFY_CQC);
        hns_roce_free_cmd_mailbox(hr_dev, mailbox);
        if (ret)
                ibdev_err(&hr_dev->ib_dev,
 
        if (eqn < hr_dev->caps.num_comp_vectors)
                ret = hns_roce_cmd_mbox(hr_dev, 0, 0, eqn & HNS_ROCE_V2_EQN_M,
-                                       HNS_ROCE_CMD_DESTROY_CEQC,
-                                       HNS_ROCE_CMD_TIMEOUT_MSECS);
+                                       HNS_ROCE_CMD_DESTROY_CEQC);
        else
                ret = hns_roce_cmd_mbox(hr_dev, 0, 0, eqn & HNS_ROCE_V2_EQN_M,
-                                       HNS_ROCE_CMD_DESTROY_AEQC,
-                                       HNS_ROCE_CMD_TIMEOUT_MSECS);
+                                       HNS_ROCE_CMD_DESTROY_AEQC);
        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->eqn,
-                               eq_cmd, HNS_ROCE_CMD_TIMEOUT_MSECS);
+       ret = hns_roce_cmd_mbox(hr_dev, mailbox->dma, 0, eq->eqn, eq_cmd);
        if (ret) {
                dev_err(hr_dev->dev, "[mailbox cmd] create eqc failed.\n");
                goto err_cmd_mbox;
 
 
        cq_context = mailbox->buf;
        ret = hns_roce_cmd_mbox(hr_dev, 0, mailbox->dma, cqn,
-                               HNS_ROCE_CMD_QUERY_CQC,
-                               HNS_ROCE_CMD_TIMEOUT_MSECS);
+                               HNS_ROCE_CMD_QUERY_CQC);
        if (ret) {
                dev_err(hr_dev->dev, "QUERY cqc cmd process error\n");
                goto err_mailbox;
 
                                  unsigned long mpt_index)
 {
        return hns_roce_cmd_mbox(hr_dev, mailbox->dma, 0, mpt_index,
-                                HNS_ROCE_CMD_CREATE_MPT,
-                                HNS_ROCE_CMD_TIMEOUT_MSECS);
+                                HNS_ROCE_CMD_CREATE_MPT);
 }
 
 int hns_roce_hw_destroy_mpt(struct hns_roce_dev *hr_dev,
                            unsigned long mpt_index)
 {
        return hns_roce_cmd_mbox(hr_dev, 0, mailbox ? mailbox->dma : 0,
-                                mpt_index, HNS_ROCE_CMD_DESTROY_MPT,
-                                HNS_ROCE_CMD_TIMEOUT_MSECS);
+                                mpt_index, HNS_ROCE_CMD_DESTROY_MPT);
 }
 
 static int alloc_mr_key(struct hns_roce_dev *hr_dev, struct hns_roce_mr *mr)
 
        mtpt_idx = key_to_hw_index(mr->key) & (hr_dev->caps.num_mtpts - 1);
        ret = hns_roce_cmd_mbox(hr_dev, 0, mailbox->dma, mtpt_idx,
-                               HNS_ROCE_CMD_QUERY_MPT,
-                               HNS_ROCE_CMD_TIMEOUT_MSECS);
+                               HNS_ROCE_CMD_QUERY_MPT);
        if (ret)
                goto free_cmd_mbox;
 
 
                                  unsigned long srq_num)
 {
        return hns_roce_cmd_mbox(dev, mailbox->dma, 0, srq_num,
-                                HNS_ROCE_CMD_CREATE_SRQ,
-                                HNS_ROCE_CMD_TIMEOUT_MSECS);
+                                HNS_ROCE_CMD_CREATE_SRQ);
 }
 
 static int hns_roce_hw_destroy_srq(struct hns_roce_dev *dev,
                                   unsigned long srq_num)
 {
        return hns_roce_cmd_mbox(dev, 0, mailbox ? mailbox->dma : 0, srq_num,
-                                HNS_ROCE_CMD_DESTROY_SRQ,
-                                HNS_ROCE_CMD_TIMEOUT_MSECS);
+                                HNS_ROCE_CMD_DESTROY_SRQ);
 }
 
 static int alloc_srqc(struct hns_roce_dev *hr_dev, struct hns_roce_srq *srq)