CCS/EK-TM4C123GXL: SSI Communication Issue in Master Mode receive (with Arduino)

My issue is now resolved as I have took care of everything regarding FIFO buffer. Thank you all for your advice. Now I am able to read data from LS7366R quadrature encoder buffer breakout board. I can now access the encoder values easily. Here is the code.

#define SLAVE_SEL_1 GPIO_PIN_6              //PA_3 pin that is of port A
#define SLAVE_SEL_2 GPIO_PIN_7              //PA_6 pin that is of port A
#define SLAVE_SEL_3 GPIO_PIN_4              //PB_4 pin that is of port B
#define SLAVE_SEL_4 GPIO_PIN_5              //PB_5 pin that is of port B
#define PORT_A GPIO_PORTA_BASE
#define PORT_B GPIO_PORTB_BASE
#define PIN_LOW 0x00
#define PIN_HIGH 0xFF

#include <stdbool.h>
#include <stdint.h>
#include "inc/hw_memmap.h"
#include "driverlib/gpio.h"
#include "driverlib/pin_map.h"
#include "driverlib/ssi.h"
#include "driverlib/sysctl.h"
#include "driverlib/uart.h"
#include "utils/uartstdio.h"

/*
 * Function to Configure UART0 For Debugging Purpose
 */
void ConfigureUART(void)
{
    // Enable the GPIO Peripheral used by the UART.
    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);

    // Enable UART0
    SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);

    // Configure GPIO Pins for UART mode.
    GPIOPinConfigure(GPIO_PA0_U0RX);
    GPIOPinConfigure(GPIO_PA1_U0TX);
    GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);

    // Use the internal 16MHz oscillator as the UART clock source.
    UARTClockSourceSet(UART0_BASE, UART_CLOCK_PIOSC);
    UARTStdioConfig(0, 115200, 16000000);
    // Initialize the UART for console I/O.
}
/*
 * This function send the data through spi to specific register and register address module
 */
void sendDataSPI(uint32_t portNo, uint32_t encoderNo, uint32_t registerAddress, uint32_t registerData)
{

    GPIOPinWrite(portNo, encoderNo, PIN_LOW);
    SSIDataPut(SSI0_BASE, registerAddress);
    SSIDataPut(SSI0_BASE, registerData);
    while(SSIBusy(SSI0_BASE)){}
    GPIOPinWrite(portNo, encoderNo, PIN_HIGH);
}

/*
 * This function receive data from a specific register by sending dummy bytes
 */
void receiveDataSPI(uint32_t portNo, uint32_t encoderNo, uint32_t registerAddress, uint32_t frameLength)
{
    GPIOPinWrite(portNo, encoderNo, PIN_LOW);
    SSIDataPut(SSI0_BASE, registerAddress);
    while(frameLength)
    {
        SSIDataPut(SSI0_BASE, 0x00);
        frameLength--;
    }
    while(SSIBusy(SSI0_BASE)){}
    GPIOPinWrite(portNo,encoderNo, PIN_HIGH);
}

void initEncoders(){
    uint32_t grbCollect;
    SysCtlPeripheralEnable(SYSCTL_PERIPH_SSI0);                             // Enable SSI Peripheral
    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);                            // SSI0 is PortA
    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);                            // SSI0 is PortA
    GPIOPinConfigure(GPIO_PA2_SSI0CLK);                                     // Clock is PA_2
    GPIOPinTypeGPIOOutput(GPIO_PORTA_BASE, SLAVE_SEL_1);                    // PA_3 is manually clocked
    GPIOPinTypeGPIOOutput(GPIO_PORTA_BASE, SLAVE_SEL_2);
    GPIOPinTypeGPIOOutput(GPIO_PORTB_BASE, SLAVE_SEL_3);
    GPIOPinTypeGPIOOutput(GPIO_PORTB_BASE, SLAVE_SEL_4);

    GPIOPinConfigure(GPIO_PA4_SSI0RX);                                      // MISO is PA_4
    GPIOPinConfigure(GPIO_PA5_SSI0TX);                                      // MOSI is PA_5
    GPIOPinTypeSSI(GPIO_PORTA_BASE, GPIO_PIN_5 | GPIO_PIN_4 | GPIO_PIN_2);

    SSIConfigSetExpClk(SSI0_BASE, SysCtlClockGet(), SSI_FRF_MOTO_MODE_0, SSI_MODE_MASTER, 8000000, 8);
    SysCtlDelay(5);
    SSIEnable(SSI0_BASE);
    while(SSIDataGetNonBlocking(SSI0_BASE,  &grbCollect)){}        //Read Garbage Data From SSI buffer if any
    //Encoder1 initialize
    sendDataSPI(PORT_A,SLAVE_SEL_1,0x88, 0x03);                       //0x88 -> Write to MDR0     0x03 -> Configure 4 byte mode for buffer
    receiveDataSPI(PORT_A,SLAVE_SEL_1, 0x98, 4);                      //0x98 -> Write to DTR      4 Times it will send 0x00 to reset the counter of buffer
    while(SSIDataGetNonBlocking(SSI0_BASE, &grbCollect)){}
    GPIOPinWrite(PORT_A, SLAVE_SEL_1, PIN_LOW);                       // Begin SPI conversation
    SSIDataPut(SSI0_BASE, 0xe0);                                      //0xE0 -> Set encoder1's current data register to center
    while(SSIBusy(SSI0_BASE)){}
    GPIOPinWrite(PORT_A, SLAVE_SEL_1, PIN_HIGH);                      //End SPI conversation

    //Encoder2 initialize
    sendDataSPI(PORT_A,SLAVE_SEL_2,0x88, 0x03);                       //0x88 -> Write to MDR0     0x03 -> Configure 4 byte mode for buffer
    receiveDataSPI(PORT_A,SLAVE_SEL_2, 0x98, 4);                      //0x98 -> Write to DTR      4 Times it will send 0x00 to reset the counter of buffer
    while(SSIDataGetNonBlocking(SSI0_BASE, &grbCollect)){}
    GPIOPinWrite(PORT_A, SLAVE_SEL_2, PIN_LOW);                       // Begin SPI conversation
    SSIDataPut(SSI0_BASE, 0xe0);                                      //0xE0 -> Set encoder2's current data register to center
    while(SSIBusy(SSI0_BASE)){}
    GPIOPinWrite(PORT_A, SLAVE_SEL_2, PIN_HIGH);                      //End SPI conversation

    //Encoder3 initialize
    sendDataSPI(PORT_B,SLAVE_SEL_3,0x88, 0x03);                       //0x88 -> Write to MDR0     0x03 -> Configure 4 byte mode for buffer
    receiveDataSPI(PORT_B,SLAVE_SEL_3, 0x98, 4);                      //0x98 -> Write to DTR      4 Times it will send 0x00 to reset the counter of buffer
    while(SSIDataGetNonBlocking(SSI0_BASE, &grbCollect)){}
    GPIOPinWrite(PORT_B, SLAVE_SEL_3, PIN_LOW);                       // Begin SPI conversation
    SSIDataPut(SSI0_BASE, 0xe0);                                      //0xE0 -> Set encoder3's current data register to center
    while(SSIBusy(SSI0_BASE)){}
    GPIOPinWrite(PORT_B, SLAVE_SEL_3, PIN_HIGH);                      //End SPI conversation
    //Encoder4 initialize

    sendDataSPI(PORT_B,SLAVE_SEL_4,0x88, 0x03);                       //0x88 -> Write to MDR0     0x03 -> Configure 4 byte mode for buffer
    receiveDataSPI(PORT_B,SLAVE_SEL_4, 0x98, 4);                      //0x98 -> Write to DTR      4 Times it will send 0x00 to reset the counter of buffer
    while(SSIDataGetNonBlocking(SSI0_BASE,  &grbCollect)){}
    GPIOPinWrite(PORT_B, SLAVE_SEL_4, PIN_LOW);                       // Begin SPI conversation
    SSIDataPut(SSI0_BASE, 0xe0);                                      //0xE0 -> Set encoder4's current data register to center
    while(SSIBusy(SSI0_BASE)){}
    GPIOPinWrite(PORT_B, SLAVE_SEL_4, PIN_HIGH);                      //End SPI conversation
}

int32_t readEncoder(uint32_t encoderNo){
    uint32_t pui32DataRx[4]={};
    uint32_t grbCollect;
    long countVal=0;
    // Clear the SSI0 Rx FIFO
    while(SSIDataGetNonBlocking(SSI0_BASE, &grbCollect)){}
    // Wait for SSI0 to be finished
    while(SSIBusy(SSI0_BASE)){}

    switch(encoderNo){
    case 1:
        // Read the values from the Encoder Buffer sensor
        receiveDataSPI(PORT_A,SLAVE_SEL_1, 0x60, 4);     //0x60 -> Request Counter data 4 here is the bytes which we have configured
        SSIDataGet(SSI0_BASE, &grbCollect);              //CLear the SSI0 Rx FIFO
        SSIDataGet(SSI0_BASE, &pui32DataRx[0]);          //Read highest order byte
        SSIDataGet(SSI0_BASE, &pui32DataRx[1]);
        SSIDataGet(SSI0_BASE, &pui32DataRx[2]);
        SSIDataGet(SSI0_BASE, &pui32DataRx[3]);          //Read lowest order byte
        break;

    case 2:
        // Read the values from the Encoder Buffer sensor
        receiveDataSPI(PORT_A,SLAVE_SEL_2, 0x60, 4);     //0x60 -> Request Counter data 4 here is the bytes which we have configured
        SSIDataGet(SSI0_BASE, &grbCollect);              //CLear the SSI0 Rx FIFO
        SSIDataGet(SSI0_BASE, &pui32DataRx[0]);          //Read highest order byte
        SSIDataGet(SSI0_BASE, &pui32DataRx[1]);
        SSIDataGet(SSI0_BASE, &pui32DataRx[2]);
        SSIDataGet(SSI0_BASE, &pui32DataRx[3]);          //Read lowest order byte
        break;
    case 3:
        // Read the values from the Encoder Buffer sensor
        receiveDataSPI(PORT_B,SLAVE_SEL_3, 0x60, 4);     //0x60 -> Request Counter data 4 here is the bytes which we have configured
        SSIDataGet(SSI0_BASE, &grbCollect);              //CLear the SSI0 Rx FIFO
        SSIDataGet(SSI0_BASE, &pui32DataRx[0]);          //Read highest order byte
        SSIDataGet(SSI0_BASE, &pui32DataRx[1]);
        SSIDataGet(SSI0_BASE, &pui32DataRx[2]);
        SSIDataGet(SSI0_BASE, &pui32DataRx[3]);          //Read lowest order byte
        break;

    case 4:
        // Read the values from the Encoder Buffer sensor
        receiveDataSPI(PORT_B,SLAVE_SEL_4, 0x60, 4);     //0x60 -> Request Counter data 4 here is the bytes which we have configured
        SSIDataGet(SSI0_BASE, &grbCollect);              //CLear the SSI0 Rx FIFO
        SSIDataGet(SSI0_BASE, &pui32DataRx[0]);          //Read highest order byte
        SSIDataGet(SSI0_BASE, &pui32DataRx[1]);
        SSIDataGet(SSI0_BASE, &pui32DataRx[2]);
        SSIDataGet(SSI0_BASE, &pui32DataRx[3]);          //Read lowest order byte
        break;
    }

    countVal = (pui32DataRx[0]<<24)+(pui32DataRx[1]<<16)+(pui32DataRx[2]<<8)+(pui32DataRx[3]);
    return countVal;
}
void main(){
    ConfigureUART();
    initEncoders();
    UARTprintf("******LOGS*******");

    while(1){

        UARTprintf("\n Ticks Final: ");
        UARTprintf("%i", readEncoder(1));
        // SysCtlDelay(500000);
    }
}