u64_stats_t tx_bytes;
        u64_stats_t tx_errors;
        u64_stats_t tx_dropped;
-       atomic_t rx_queued;
        struct u64_stats_sync tx_syncp;
        struct u64_stats_sync rx_syncp;
 };
 {
        struct mhi_net_dev *mhi_netdev = dev_get_drvdata(&mhi_dev->dev);
        struct sk_buff *skb = mhi_res->buf_addr;
-       int remaining;
+       int free_desc_count;
 
-       remaining = atomic_dec_return(&mhi_netdev->stats.rx_queued);
+       free_desc_count = mhi_get_free_desc_count(mhi_dev, DMA_FROM_DEVICE);
 
        if (unlikely(mhi_res->transaction_status)) {
                dev_kfree_skb_any(skb);
        }
 
        /* Refill if RX buffers queue becomes low */
-       if (remaining <= mhi_netdev->rx_queue_sz / 2)
+       if (free_desc_count >= mhi_netdev->rx_queue_sz / 2)
                schedule_delayed_work(&mhi_netdev->rx_refill, 0);
 }
 
        struct sk_buff *skb;
        int err;
 
-       while (atomic_read(&mhi_netdev->stats.rx_queued) < mhi_netdev->rx_queue_sz) {
+       while (!mhi_queue_is_full(mdev, DMA_FROM_DEVICE)) {
                skb = netdev_alloc_skb(ndev, size);
                if (unlikely(!skb))
                        break;
                        break;
                }
 
-               atomic_inc(&mhi_netdev->stats.rx_queued);
-
                /* Do not hog the CPU if rx buffers are consumed faster than
                 * queued (unlikely).
                 */
        }
 
        /* If we're still starved of rx buffers, reschedule later */
-       if (unlikely(!atomic_read(&mhi_netdev->stats.rx_queued)))
+       if (mhi_get_free_desc_count(mdev, DMA_FROM_DEVICE) == mhi_netdev->rx_queue_sz)
                schedule_delayed_work(&mhi_netdev->rx_refill, HZ / 2);
 }