UIO interrupt Handling

Hello Guys I am trying to get work with linux UIO driver to communicate over the CAN bus, My issue currently i am working on the on the user space and i could see that I could generate the interrupts while Tx but I am not able to get the Rx working. I confirmed my interrupt with cat /proc/interrupts and I could check that interrupts are only being triggered while transmitting but i am not able to generate interrupt when i want to try RX. How can i make sure that I have received value in my input buffer
The device tree stanza is same as been provided by the BSP. Below is the code where i am mapping the device and using tx and RX functions. While TX is working on the other hand RX is not able to trigger interrupts.I am not sure what i am possibly missing

static void * socketcan_rx_thread(void * arg) 
{
struct can_driver *ctx=arg;
struct mss_can_filter filter;
    uint32_t val;
    uint32_t reenable = 1;


uint32_t int_enb = CAN_INT_ACK_ERR | CAN_INT_TX_MSG | CAN_INT_GLOBAL |
		CAN_INT_RX_MSG | CAN_INT_BUS_OFF | CAN_INT_BIT_ERR |
		CAN_INT_OVR_LOAD | CAN_INT_FORM_ERR | CAN_INT_CRC_ERR |
		CAN_INT_RX_MSG_LOST | CAN_INT_RTR_MSG | CAN_INT_STUCK_AT_0 |
		CAN_INT_STUFF_ERR | CAN_INT_SST_FAILURE | CAN_INT_ARB_LOSS;
                 
    filter.acr = 0;
filter.amr = 0xffffffff;
filter.amcr_d_mask = 0xffff;
filter.amcr_d_code = 0x0;
can_cfg_buf(ctx->dev, &filter);
    can_set_int_enb(ctx->dev, int_enb);
struct pollfd fds = {
	.fd = ctx->uiofd,
 	.events = POLLIN,
};
int ret = poll(&fds, 1,100);
printf("ret=%d\n",ret);


is_valid_fd(ctx->uiofd);
if (ret == -1) {
	fprintf(stderr, "poll error\n");
	exit(-1);
}
if (ret >= 1) {    
printf("DEBUG RX 195 callback\n");

	if (fds.revents & POLLIN) {
	   printf("DEBUG RX 198 callback\n");
		read(ctx->uiofd, &reenable, sizeof(int));
		printf("DEBUG RX 203 callback\n");
		write(ctx->uiofd, &reenable, sizeof(int));
	}
}
}


static int  csp_can_tx_frame(void * driver_data, uint32_t id, const uint8_t * data, uint8_t dlc) \
{

struct can_msg msg;
struct mss_can_filter filter;
for(int i = 0; i < dlc; ++i)
{
	offset -= 4;
	high |= (uint32_t)(*data >> 4)   << offset;
	low  |= (uint32_t)(*data & 0x0f) << offset;
	++data;
}
    filter.acr = 0;
filter.amr = 0xffffffff;
filter.amcr_d_mask = 0xffff;
filter.amcr_d_code = 0x0;
can_cfg_buf(ctx.dev, &filter);

memcpy(&msg.datal, &var1 ,sizeof(var1));
memcpy(&msg.datah, &var ,sizeof(var));
msg.dlc=dlc;
msg.flags = CAN_TX_INT_ENB | CAN_TX_WPNH_ENB | CAN_TX_WPNL_ENB | CAN_TX_EXTENDED | dlc<<16;
ret = can_send_msg(ctx,&msg);

if (ret) {
	fprintf(stderr, "Failed to send message\n");
	exit(-1);
  }
}




int interface(const char * device, const char * ifname, ) {

    index = get_uio_device(device);
if (index < 0) {
	fprintf(stderr, "can't locate uio device for %s\n", device);
	return -1;
}

ctx.uiofd = open(devname, O_RDWR);
ctx.dev = mmap(NULL, mmap_size, PROT_READ|PROT_WRITE, MAP_SHARED,ctx.uiofd, 0);

    can_init(ctx.dev,bitrate_set);
can_set_mode(ctx.dev,CAN_MODE_NORMAL);
can_start(ctx.dev);



/**TX FUNCTION**/
     ctx.ifdata.tx_func = can_tx_frame;

/* Create receive thread */
if (pthread_create(&ctx.rx_thread, NULL, socketcan_rx_thread, &ctx) != 0) {
	csp_print("%s[%s]: pthread_create() failed, error: %s\n", __FUNCTION__, ctx.name, strerror(errno));
}

}