Sometimes uart_cb does notifys fewer bytes than it has received.

Question

Hi, 
 I have written a custom code to read and process data. Sometimes uart_cb is not called at all. 
 However, when timeout happens, and I call uart_rx_disable data suddenly appears. Any idea why even though data is received uart_cb never gets called? 
 # Enable the UART driver
CONFIG_UART_ASYNC_API=y
CONFIG_NRFX_UARTE0=y
CONFIG_SERIAL=y

Here is the uart_cb code 
 static void uart_cb(const struct device *dev, struct uart_event *evt, void *user_data)
{
	ARG_UNUSED(dev);

	static size_t aborted_len;
	struct uart_data_t *buf;
	static uint8_t *aborted_buf;
	static bool disable_req;
	/*** Fydl Changes **/
	static enum fydl_enum_packet_state packet_state = FINDING_7E;
	static int packet_length = 0;
	static int packet_counter = 0;
	/*** Fydl Changes **/
	switch (evt->type)
	{
	case UART_TX_DONE:
 LOG_DBG("UART_TX_DONE");
 if ((evt->data.tx.len == 0) ||
 (!evt->data.tx.buf))
 {
 return;
 }

 if (aborted_buf)
 {
 buf = CONTAINER_OF(aborted_buf, struct uart_data_t,
 data);
 aborted_buf = NULL;
 aborted_len = 0;
 }
 else
 {
 buf = CONTAINER_OF(evt->data.tx.buf, struct uart_data_t,
 data);
 }

 k_free(buf);

 buf = k_fifo_get(&fifo_uart_tx_data, K_NO_WAIT);
 if (!buf)
 {
 return;
 }

 if (uart_tx(uart, buf->data, buf->len, SYS_FOREVER_MS))
 {
 LOG_WRN("Failed to send data over UART");
 }

 break;

	case UART_RX_RDY:
 buf = CONTAINER_OF(evt->data.rx.buf, struct uart_data_t, data);
	//	LOG_INF("Len %x, buf %x",evt->data.rx.len,buf->data[packet_length]);
 ring_buf_put(&my_ring_buf, (buf->data + buf->len),evt->data.rx.len);
 buf->len += evt->data.rx.len;
 k_sem_give(&uart_data_available);
 break;

	case UART_RX_DISABLED:
 LOG_INF("UART_RX_DISABLED");
 disable_req = false;
 /** Reset the packet counter on each new buffer allocation **/
 packet_counter = 0;
 buf = k_malloc(sizeof(*buf));
 if (buf)
 {
 buf->len = 0;
 }
 else
 {
 LOG_WRN("Not able to allocate UART receive buffer");
 k_work_reschedule(&uart_work, UART_WAIT_FOR_BUF_DELAY);
 return;
 }


 uart_rx_enable(uart, buf->data, sizeof(buf->data),
 UART_WAIT_FOR_RX);
 break;

	case UART_RX_BUF_REQUEST:
 LOG_INF("UART_RX_BUF_REQUEST");
 buf = k_malloc(sizeof(*buf));
 if (buf)
 {
 buf->len = 0;
 uart_rx_buf_rsp(uart, buf->data, sizeof(buf->data));
 }
 else
 {
 LOG_WRN("Not able to allocate UART receive buffer");
 }
 break;

	case UART_RX_BUF_RELEASED:
 //LOG_INF("UART_RX_BUF_RELEASED");
 buf = CONTAINER_OF(evt->data.rx_buf.buf, struct uart_data_t,
 data);

 if (buf->len > 0)
 {
 LOG_INF("UART_RX_BUF_RELEASED %x",buf->len);
 k_free(buf);
 }
 else
 {
 LOG_INF("UART_RX_BUF_RELEASED 0");
 k_free(buf);
 }

 break;

	case UART_TX_ABORTED:
 LOG_DBG("UART_TX_ABORTED");
 if (!aborted_buf)
 {
 aborted_buf = (uint8_t *)evt->data.tx.buf;
 }

 aborted_len += evt->data.tx.len;
 buf = CONTAINER_OF(aborted_buf, struct uart_data_t,
 data);

 uart_tx(uart, &buf->data[aborted_len],
 buf->len - aborted_len, SYS_FOREVER_MS);

 break;

	default:
 break;
	}
}