MSP430FR5969: USCIB0 SPI driver issue

Hiiyyaa Forum experts,
I was writing a basic SPI driver for LDC1101. So just for test I'm trying to write into one register and read from that. But the issue I faced that it was unable to make CS pin high and the cursor is stucked there. If you resolve my issue I would be thankful for that. By the way I'm using MSP430FR5969 Development board and LDC1101. so Here is my code:
I'm using USCIB0 for SPI
////////////////////////////
#define SLAVE_CS_OUT    P1OUT
#define SLAVE_CS_DIR    P1DIR
#define SLAVE_CS_PIN    BIT3

#define ENABLE_SPI_TX_INT()      { UCB0IE |= UCTXIE;}
/* Enable receive interrupt */
#define ENABLE_SPI_RX_INT()      { UCB0IE |= UCRXIE;}

/* Disable receive interrupt */
#define DISABLE_SPI_RX_INT()     { UCB0IE &= ~UCRXIE;}


void initClockTo8MHz()
{
    // Configure one FRAM waitstate as required by the device datasheet for MCLK
    // operation beyond 8MHz _before_ configuring the clock system.
    FRCTL0 = FRCTLPW | NWAITS_1;

    // Clock System Setup
    CSCTL0_H = CSKEY >> 8;                    // Unlock CS registers
    CSCTL1 = DCORSEL | DCOFSEL_4;             // Set DCO to 16MHz
    CSCTL2 = SELA__VLOCLK | SELS__DCOCLK | SELM__DCOCLK;
    CSCTL3 = DIVA__2 | DIVS__2 | DIVM__2;     // Set all dividers

    CSCTL0_H = 0;                             // Lock CS registerss
}
void initGPIO()
{
    //LEDs
    P1OUT = 0x00;                             // P1 setup for LED & reset output
    P1DIR |= BIT0 + BIT4;

    P4DIR |= BIT6;
    P4OUT &= ~(BIT6);
    
    P3DIR |= BIT4;
    P3SEL1 |= BIT4;                           // Output SMCLK

    // Configure SPI pins
    P2SEL1 |= BIT2;                           //clk    
    P1SEL1 |= BIT6 | BIT7;                  // Configure MISO/MOSI pins    

    SLAVE_CS_DIR |= SLAVE_CS_PIN;             // STE Pin
    SLAVE_CS_OUT |= SLAVE_CS_PIN;             // STE pin enable

    // Disable the GPIO power-on default high-impedance mode to activate
    // previously configured port settings
    PM5CTL0 &= ~LOCKLPM5;
}

void WriteUCB0Data(uint8_t val)
{
    while (!(UCB0IFG & UCTXIFG));              // USCI_B0 RX buffer ready?
    UCB0TXBUF = val;
}
SPI_Mode SPI_Master_WriteReg(uint8_t reg_addr, uint8_t reg_data, uint8_t count)
{
    TransmitRegAddr = reg_addr;
    TransmitBuffer = reg_data;
    UCB0_TxComplete = true;
    //Copy register data to TransmitBuffer
    //memcpy((void *)TransmitBuffer, (const void *) reg_data, sizeof(reg_data));

    TXByteCtr = count;

    ENABLE_CHIPSELECT();
    ENABLE_SPI_TX_INT();
    WriteUCB0Data(TransmitRegAddr);

    __bis_SR_register(LPM0_bits + GIE);              // Enter LPM0 w/ interrupts
    
    while( UCB0_TxComplete != true )                   //My program stucks here please help me to resolve the issue
      DISABLE_CHIPSELECT();
    return MasterMode;
}

SPI_Mode SPI_Master_ReadReg(uint8_t reg_addr, uint8_t count)
{
    TransmitRegAddr = reg_addr;
    RXByteCtr = count;
    TXByteCtr = 0;
    ReceiveIndex = 0;
    TransmitIndex = 0;

    SLAVE_CS_OUT &= ~(SLAVE_CS_PIN);
    WriteUCB0Data(TransmitRegAddr);

    __bis_SR_register(CPUOFF + GIE);              // Enter LPM0 w/ interrupts

    SLAVE_CS_OUT |= SLAVE_CS_PIN;
    return MasterMode;
}


/////////////////////////////////////////////
int main(void) {
    WDTCTL = WDTPW | WDTHOLD;   // Stop watchdog timer

    initClockTo8MHz();
    initGPIO();
    initSPI();
    
    SPI_Master_WriteReg(RP_SET, 0x45, WRITE_COUNT);
    SPI_Master_ReadReg(RP_SET, READ_COUNT);
    __bis_SR_register(LPM0_bits + GIE);       // CPU off, enable interrupts
    /*
    
    
    Logic must be added here for Inductive sensing
    
    
    
    */
    //while(1)
      __no_operation();

    return 0;
}    


//////SPI Interrupt /////////
#if defined(__TI_COMPILER_VERSION__) || defined(__IAR_SYSTEMS_ICC__)
#pragma vector=USCI_B0_VECTOR
__interrupt void USCI_B0_ISR(void)
#elif defined(__GNUC__)
void __attribute__ ((interrupt(USCI_B0_VECTOR))) USCI_B0_ISR (void)
#else
#error Compiler not supported!
#endif
{
    uint8_t ucb0_rx_val = 0;
  if ((UCB0IE & UCTXIE) && (UCB0IFG & UCTXIFG))
  {
    if (TXByteCtr)
    {
      //WriteUCB0Data(TransmitBuffer[TransmitIndex++]);
      WriteUCB0Data(TransmitBuffer);
      TXByteCtr--;
    }
    else
    {
      //Done with transmission
      MasterMode = IDLE_MODE;
      __bic_SR_register_on_exit(CPUOFF);      // Exit LPM0
    }
    UCB0IFG &= ~UCTXIFG;        /* Clear transmit interrupt flag */
    UCB0_TxComplete = false;
  }

  if ((UCB0IE & UCRXIE) && (UCB0IFG & UCRXIFG))         //it comes here checks and it stucks
  {
    if (RXByteCtr)
    {
      ReceiveBuffer[ReceiveIndex++] = ucb0_rx_val;
      //Transmit a dummy
      RXByteCtr--;
    }
    if (RXByteCtr == 0)
    {
      MasterMode = IDLE_MODE;
      __bic_SR_register_on_exit(CPUOFF);      // Exit LPM0
    }
    else
    {
      WriteUCB0Data(DUMMY);
                    }
    /* Clear receive interrupt flag */
    UCB0IFG &= ~UCRXIFG;
  }
 }