return cp - bp->cp_nr_rings;
 }
 
+unsigned int bnxt_get_avail_stat_ctxs_for_en(struct bnxt *bp)
+{
+       unsigned int stat;
+
+       stat = bnxt_get_max_func_stat_ctxs(bp) - bnxt_get_ulp_stat_ctxs(bp);
+       stat -= bp->cp_nr_rings;
+       return stat;
+}
+
 int bnxt_get_avail_msix(struct bnxt *bp, int num)
 {
        int max_cp = bnxt_get_max_func_cp_rings(bp);
                bp->tx_nr_rings_per_tc = bp->tx_nr_rings;
                return -ENOMEM;
        }
-       bp->num_stat_ctxs = bp->cp_nr_rings;
        return 0;
 }
 
        bp->tx_nr_rings += bp->tx_nr_rings_xdp;
        bp->cp_nr_rings = sh ? max_t(int, bp->tx_nr_rings, bp->rx_nr_rings) :
                               bp->tx_nr_rings + bp->rx_nr_rings;
-       bp->num_stat_ctxs = bp->cp_nr_rings;
 
        if (netif_running(bp->dev))
                return bnxt_open_nic(bp, true, false);
        *max_cp = bnxt_get_max_func_cp_rings_for_en(bp);
        max_irq = min_t(int, bnxt_get_max_func_irqs(bp) -
                        bnxt_get_ulp_msix_num(bp),
-                       bnxt_get_max_func_stat_ctxs(bp));
+                       hw_resc->max_stat_ctxs - bnxt_get_ulp_stat_ctxs(bp));
        if (!(bp->flags & BNXT_FLAG_CHIP_P5))
                *max_cp = min_t(int, *max_cp, max_irq);
        max_ring_grps = hw_resc->max_hw_ring_grps;
                        netdev_warn(bp->dev, "2nd rings reservation failed.\n");
                bp->tx_nr_rings_per_tc = bp->tx_nr_rings;
        }
-       bp->num_stat_ctxs = bp->cp_nr_rings;
        if (BNXT_CHIP_TYPE_NITRO_A0(bp)) {
                bp->rx_nr_rings++;
                bp->cp_nr_rings++;
 
        int                     cp_nr_pages;
        int                     cp_nr_rings;
 
-       int                     num_stat_ctxs;
-
        /* grp_info indexed by completion ring index */
        struct bnxt_ring_grp_info       *grp_info;
        struct bnxt_vnic_info   *vnic_info;
 int bnxt_hwrm_set_coal(struct bnxt *);
 unsigned int bnxt_get_max_func_stat_ctxs(struct bnxt *bp);
 void bnxt_set_max_func_stat_ctxs(struct bnxt *bp, unsigned int max);
+unsigned int bnxt_get_avail_stat_ctxs_for_en(struct bnxt *bp);
 unsigned int bnxt_get_max_func_cp_rings(struct bnxt *bp);
 unsigned int bnxt_get_avail_cp_rings_for_en(struct bnxt *bp);
 int bnxt_get_avail_msix(struct bnxt *bp, int num);
 
        bp->cp_nr_rings = sh ? max_t(int, bp->tx_nr_rings, bp->rx_nr_rings) :
                               bp->tx_nr_rings + bp->rx_nr_rings;
 
-       bp->num_stat_ctxs = bp->cp_nr_rings;
-
        /* After changing number of rx channels, update NTUPLE feature. */
        netdev_update_features(dev);
        if (netif_running(dev)) {
 
        bnxt_hwrm_cmd_hdr_init(bp, &req, HWRM_FUNC_VF_RESOURCE_CFG, -1, -1);
 
        vf_cp_rings = bnxt_get_avail_cp_rings_for_en(bp);
-       vf_stat_ctx = hw_resc->max_stat_ctxs - bp->num_stat_ctxs;
+       vf_stat_ctx = bnxt_get_avail_stat_ctxs_for_en(bp);
        if (bp->flags & BNXT_FLAG_AGG_RINGS)
                vf_rx_rings = hw_resc->max_rx_rings - bp->rx_nr_rings * 2;
        else
        u32 rc = 0, mtu, i;
        u16 vf_tx_rings, vf_rx_rings, vf_cp_rings, vf_stat_ctx, vf_vnics;
        struct bnxt_hw_resc *hw_resc = &bp->hw_resc;
-       u16 vf_ring_grps, max_stat_ctxs;
        struct hwrm_func_cfg_input req = {0};
        struct bnxt_pf_info *pf = &bp->pf;
        int total_vf_tx_rings = 0;
+       u16 vf_ring_grps;
 
        bnxt_hwrm_cmd_hdr_init(bp, &req, HWRM_FUNC_CFG, -1, -1);
 
-       max_stat_ctxs = hw_resc->max_stat_ctxs;
-
        /* Remaining rings are distributed equally amongs VF's for now */
        vf_cp_rings = bnxt_get_avail_cp_rings_for_en(bp) / num_vfs;
-       vf_stat_ctx = (max_stat_ctxs - bp->num_stat_ctxs) / num_vfs;
+       vf_stat_ctx = bnxt_get_avail_stat_ctxs_for_en(bp) / num_vfs;
        if (bp->flags & BNXT_FLAG_AGG_RINGS)
                vf_rx_rings = (hw_resc->max_rx_rings - bp->rx_nr_rings * 2) /
                              num_vfs;
        vfs_supported = *num_vfs;
 
        avail_cp = bnxt_get_avail_cp_rings_for_en(bp);
-       avail_stat = hw_resc->max_stat_ctxs - bp->num_stat_ctxs;
+       avail_stat = bnxt_get_avail_stat_ctxs_for_en(bp);
        avail_cp = min_t(int, avail_cp, avail_stat);
 
        while (vfs_supported) {
 
 
                max_stat_ctxs = bnxt_get_max_func_stat_ctxs(bp);
                if (max_stat_ctxs <= BNXT_MIN_ROCE_STAT_CTXS ||
-                   bp->num_stat_ctxs == max_stat_ctxs)
+                   bp->cp_nr_rings == max_stat_ctxs)
                        return -ENOMEM;
                bnxt_set_max_func_stat_ctxs(bp, max_stat_ctxs -
                                            BNXT_MIN_ROCE_STAT_CTXS);
        return 0;
 }
 
+int bnxt_get_ulp_stat_ctxs(struct bnxt *bp)
+{
+       if (bnxt_ulp_registered(bp->edev, BNXT_ROCE_ULP))
+               return BNXT_MIN_ROCE_STAT_CTXS;
+
+       return 0;
+}
+
 static int bnxt_send_msg(struct bnxt_en_dev *edev, int ulp_id,
                         struct bnxt_fw_msg *fw_msg)
 {
 
 
 int bnxt_get_ulp_msix_num(struct bnxt *bp);
 int bnxt_get_ulp_msix_base(struct bnxt *bp);
+int bnxt_get_ulp_stat_ctxs(struct bnxt *bp);
 void bnxt_ulp_stop(struct bnxt *bp);
 void bnxt_ulp_start(struct bnxt *bp);
 void bnxt_ulp_sriov_cfg(struct bnxt *bp, int num_vfs);
 
        bp->tx_nr_rings_xdp = tx_xdp;
        bp->tx_nr_rings = bp->tx_nr_rings_per_tc * tc + tx_xdp;
        bp->cp_nr_rings = max_t(int, bp->tx_nr_rings, bp->rx_nr_rings);
-       bp->num_stat_ctxs = bp->cp_nr_rings;
        bnxt_set_tpa_flags(bp);
        bnxt_set_ring_params(bp);