#include <linux/skbuff.h>
 #include <linux/dma-mapping.h>
 #include <linux/prefetch.h>
+#include <linux/cpumask.h>
 #include <asm/barrier.h>
 
 #include "hinic_common.h"
        struct hinic_sge sge;
        dma_addr_t dma_addr;
        struct sk_buff *skb;
-       int i, alloc_more;
        u16 prod_idx;
+       int i;
 
        free_wqebbs = hinic_get_rq_free_wqebbs(rxq->rq);
-       alloc_more = 0;
 
        /* Limit the allocation chunks */
        if (free_wqebbs > nic_dev->rx_weight)
                skb = rx_alloc_skb(rxq, &dma_addr);
                if (!skb) {
                        netdev_err(rxq->netdev, "Failed to alloc Rx skb\n");
-                       alloc_more = 1;
                        goto skb_out;
                }
 
                                          &prod_idx);
                if (!rq_wqe) {
                        rx_free_skb(rxq, skb, dma_addr);
-                       alloc_more = 1;
                        goto skb_out;
                }
 
                hinic_rq_update(rxq->rq, prod_idx);
        }
 
-       if (alloc_more)
-               tasklet_schedule(&rxq->rx_task);
-
+       tasklet_schedule(&rxq->rx_task);
        return i;
 }
 
        }
 
        if (pkts)
-               tasklet_schedule(&rxq->rx_task); /* hinic_rx_alloc_pkts */
+               tasklet_schedule(&rxq->rx_task); /* rx_alloc_pkts */
 
        u64_stats_update_begin(&rxq->rxq_stats.syncp);
        rxq->rxq_stats.pkts += pkts;
        struct hinic_dev *nic_dev = netdev_priv(rxq->netdev);
        struct hinic_hwdev *hwdev = nic_dev->hwdev;
        struct hinic_rq *rq = rxq->rq;
+       struct hinic_qp *qp;
+       struct cpumask mask;
        int err;
 
        rx_add_napi(rxq);
                return err;
        }
 
-       return 0;
+       qp = container_of(rq, struct hinic_qp, rq);
+       cpumask_set_cpu(qp->q_id % num_online_cpus(), &mask);
+       return irq_set_affinity_hint(rq->irq, &mask);
 }
 
 static void rx_free_irq(struct hinic_rxq *rxq)