resource_size_t reg_base;
        struct bnxt_qplib_nq_db *nq_db;
        struct pci_dev *pdev;
-       int rc = 0;
 
        pdev = nq->pdev;
        nq_db = &nq->nq_db;
        if (!nq_db->reg.bar_base) {
                dev_err(&pdev->dev, "QPLIB: NQ BAR region %d resc start is 0!",
                        nq_db->reg.bar_id);
-               rc = -ENOMEM;
-               goto fail;
+               return -ENOMEM;
        }
 
        reg_base = nq_db->reg.bar_base + reg_offt;
        if (!nq_db->reg.bar_reg) {
                dev_err(&pdev->dev, "QPLIB: NQ BAR region %d mapping failed",
                        nq_db->reg.bar_id);
-               rc = -ENOMEM;
-               goto fail;
+               return -ENOMEM;
        }
 
        nq_db->dbinfo.db = nq_db->reg.bar_reg;
        nq_db->dbinfo.hwq = &nq->hwq;
        nq_db->dbinfo.xid = nq->ring_id;
-fail:
-       return rc;
+
+       return 0;
 }
 
 int bnxt_qplib_enable_nq(struct pci_dev *pdev, struct bnxt_qplib_nq *nq,
        hwq_attr.type = HWQ_TYPE_QUEUE;
        rc = bnxt_qplib_alloc_init_hwq(&srq->hwq, &hwq_attr);
        if (rc)
-               goto exit;
+               return rc;
 
        srq->swq = kcalloc(srq->hwq.max_elements, sizeof(*srq->swq),
                           GFP_KERNEL);
 fail:
        bnxt_qplib_free_hwq(res, &srq->hwq);
        kfree(srq->swq);
-exit:
+
        return rc;
 }
 
        struct rq_wqe *srqe;
        struct sq_sge *hw_sge;
        u32 sw_prod, sw_cons, count = 0;
-       int i, rc = 0, next;
+       int i, next;
 
        spin_lock(&srq_hwq->lock);
        if (srq->start_idx == srq->last_idx) {
                dev_err(&srq_hwq->pdev->dev,
                        "FP: SRQ (0x%x) is full!\n", srq->id);
-               rc = -EINVAL;
                spin_unlock(&srq_hwq->lock);
-               goto done;
+               return -EINVAL;
        }
        next = srq->start_idx;
        srq->start_idx = srq->swq[next].next_idx;
                srq->arm_req = false;
                bnxt_qplib_srq_arm_db(&srq->dbinfo, srq->threshold);
        }
-done:
-       return rc;
+
+       return 0;
 }
 
 /* QP */
 
 static int bnxt_qplib_alloc_init_swq(struct bnxt_qplib_q *que)
 {
-       int rc = 0;
        int indx;
 
        que->swq = kcalloc(que->max_wqe, sizeof(*que->swq), GFP_KERNEL);
-       if (!que->swq) {
-               rc = -ENOMEM;
-               goto out;
-       }
+       if (!que->swq)
+               return -ENOMEM;
 
        que->swq_start = 0;
        que->swq_last = que->max_wqe - 1;
                que->swq[indx].next_idx = indx + 1;
        que->swq[que->swq_last].next_idx = 0; /* Make it circular */
        que->swq_last = 0;
-out:
-       return rc;
+
+       return 0;
 }
 
 int bnxt_qplib_create_qp1(struct bnxt_qplib_res *res, struct bnxt_qplib_qp *qp)
        hwq_attr.type = HWQ_TYPE_QUEUE;
        rc = bnxt_qplib_alloc_init_hwq(&sq->hwq, &hwq_attr);
        if (rc)
-               goto exit;
+               return rc;
 
        rc = bnxt_qplib_alloc_init_swq(sq);
        if (rc)
        kfree(sq->swq);
 fail_sq:
        bnxt_qplib_free_hwq(res, &sq->hwq);
-exit:
        return rc;
 }
 
        hwq_attr.type = HWQ_TYPE_QUEUE;
        rc = bnxt_qplib_alloc_init_hwq(&sq->hwq, &hwq_attr);
        if (rc)
-               goto exit;
+               return rc;
 
        rc = bnxt_qplib_alloc_init_swq(sq);
        if (rc)
        kfree(sq->swq);
 fail_sq:
        bnxt_qplib_free_hwq(res, &sq->hwq);
-exit:
        return rc;
 }
 
        struct bnxt_qplib_qp *qp;
        struct bnxt_qplib_q *rq;
        u32 wr_id_idx;
-       int rc = 0;
 
        qp = (struct bnxt_qplib_qp *)((unsigned long)
                                      le64_to_cpu(hwcqe->qp_handle));
        if (qp->rq.flushed) {
                dev_dbg(&cq->hwq.pdev->dev,
                        "%s: QP in Flush QP = %p\n", __func__, qp);
-               goto done;
+               return 0;
        }
 
        cqe = *pcqe;
                }
        }
 
-done:
-       return rc;
+       return 0;
 }
 
 static int bnxt_qplib_cq_process_res_ud(struct bnxt_qplib_cq *cq,
        struct bnxt_qplib_qp *qp;
        struct bnxt_qplib_q *rq;
        u32 wr_id_idx;
-       int rc = 0;
 
        qp = (struct bnxt_qplib_qp *)((unsigned long)
                                      le64_to_cpu(hwcqe->qp_handle));
        if (qp->rq.flushed) {
                dev_dbg(&cq->hwq.pdev->dev,
                        "%s: QP in Flush QP = %p\n", __func__, qp);
-               goto done;
+               return 0;
        }
        cqe = *pcqe;
        cqe->opcode = hwcqe->cqe_type_toggle & CQ_BASE_CQE_TYPE_MASK;
                        bnxt_qplib_add_flush_qp(qp);
                }
        }
-done:
-       return rc;
+
+       return 0;
 }
 
 bool bnxt_qplib_is_cq_empty(struct bnxt_qplib_cq *cq)
        struct bnxt_qplib_srq *srq;
        struct bnxt_qplib_cqe *cqe;
        u32 wr_id_idx;
-       int rc = 0;
 
        qp = (struct bnxt_qplib_qp *)((unsigned long)
                                      le64_to_cpu(hwcqe->qp_handle));
        if (qp->rq.flushed) {
                dev_dbg(&cq->hwq.pdev->dev,
                        "%s: QP in Flush QP = %p\n", __func__, qp);
-               goto done;
+               return 0;
        }
        cqe = *pcqe;
        cqe->opcode = hwcqe->cqe_type_toggle & CQ_BASE_CQE_TYPE_MASK;
                }
        }
 
-done:
-       return rc;
+       return 0;
 }
 
 static int bnxt_qplib_cq_process_terminal(struct bnxt_qplib_cq *cq,