Robert, I think this is consistent with what I have experienced recently. Please see my previous post:
UART_DRV_ReadDataBlocking seems to allow FIFO data to be lost
Are you calling UART_DRV_ReadDataBlocking for 1 byte at a time? What I had seen before was that there would be data in the FIFO, but calling this method would never return any data. In other words, it was as if the method thought the FIFO was empty. Down in the code, there's a pointer that gets indexed so it knows where to put the next incoming byte, and what I would see is that if I then sent more data, I could see the previous "invisible" byte in memory.
I ran my modbus tests again, but instead the next time around read multiple bytes at a time, and the problem went away. But of course my modbus implementation was flawed, so it didn't really matter. 
Here is my code to disable the FIFO using the HAL functions:
void DisableFifo( uint32_t instance)
{
UART_Type *base = g_uartBase[instance];
UART_HAL_DisableReceiver( base);
UART_HAL_FlushRxFifo( base);
UART_PFIFO_REG( base) &= ~UART_PFIFO_RXFE_MASK;
UART_HAL_FlushRxFifo( base);
UART_HAL_EnableReceiver( base);
}
To be clear, I rely on using Processor Expert and the KSDK to implement everything. I haven't done anything manual in my projects except slight massaging around components like the FlexTimer. I have to support 3 different Kinetis processors that interface to a very similar pool of peripherals, so I leverage PE and the C++ wrappers I wrote around each device. Therefore, to implement the RX callback as you have inquired about, I just have to check the box to use the RX callback function, generate the code, and then fill in the blanks.
Under the hood, PE generates code like this:
/*! Device instance number */
#define FSL_RS485_COMP UART1_IDX
/*! Driver state structure without DMA */
extern uart_state_t rs485_comp_State;
/*! @brief UART configuration declaration */
extern const uart_user_config_t rs485_comp_InitConfig0;
/*! Interrupt service routine (ISR) prototype */
void rs485_comp_IRQHandler(void);
/*! rs485_comp configuration structure */
const uart_user_config_t rs485_comp_InitConfig0 = {
.baudRate = 115200U,
.parityMode = kUartParityDisabled,
.stopBitCount = kUartOneStopBit,
.bitCountPerChar = kUart8BitsPerChar,
};
OSA_InstallIntHandler(UART1_RX_TX_IRQn, rs485_comp_IRQHandler);
UART_DRV_Init(FSL_RS485_COMP,&rs485_comp_State,&rs485_comp_InitConfig0);
UART_DRV_InstallRxCallback(FSL_RS485_COMP, rs485_comp_RxCallback, rx_callback_buff, NULL, true);
void rs485_comp_RxCallback(uint32_t instance, void * uartState)
{
/* Write your code here ... */
UtaskerModbusImpl( instance, uartState);
}
Because the FIFO was disabled, the callback function gets called for every byte. So far, I see very reliable communication at 115.2kbps. I tried to bump it up to 230.4kbps, but the reliability dropped off significantly. 38400baud was also fine.
Hopefully this helps!
