TDA2SX: Why can't I use a specific UART baud rate on TDA2SX?

static void PSVT_MMWRadarUART_Init(void)
{
    Uart_ChanParams vChanParams;
    Error_Block vEB;
    GIO_Params vIO_Params;
    static char vUART_Name[16]; //Device name must be global or static variable
    static DEV_Struct vUART_DevObj;
    static GIO_Struct vUART_TX_Obj;
    static GIO_Struct vUART_RX_Obj;
    static SyncSem_Struct vUART_TX_SyncSemObj;
    static SyncSem_Struct vUART_RX_SyncSemObj;
    static Semaphore_Struct vUART_TX_SemObj;
    static Semaphore_Struct vUART_RX_SemObj;
    static IOM_Packet vUART_TX_IOM_Obj[UART_ASYNC_IOM_PACKET_MAX];
    static IOM_Packet vUART_RX_IOM_Obj[UART_ASYNC_IOM_PACKET_MAX];
    DEV_Params vDevParams;
    Uart_Params vUART_Params;
    SyncSem_Params vSyncSemParams;
    Semaphore_Params vSemParams;

    UInt32 vCookie = 0;

    //Enable UART module
    PMHALModuleModeSet(MMWRADAR_UART_MODULE, PMHAL_PRCM_MODULE_MODE_ENABLED,
                       PM_TIMEOUT_INFINITE);

    //Disable interrupt
    vCookie = BspOsal_disableInterrupt();

    //Connect IRQ and UART interrupt
    BspOsal_irqXbarConnect(MMWRADAR_UART_USE_XBAR_IPU, MMWRADAR_UART_USE_XBAR_INT);
    //Restore interrutp
    BspOsal_restoreInterrupt(vCookie);

    //Struct init
    Error_init(&vEB);

    //Initialize channel attributes.
    GIO_Params_init(&vIO_Params);

    //Do not do it again, because System_uartInit() had already do Uart_init()
    //Uart_init();

    //Set an identifying name
    strcpy(vUART_Name, MMWRADAR_UART_NAME);

    //Set pin MUX of Radar TX pin
    HW_WR_REG32(MMWRADAR_TX_PIN_PHYSICAL_ADDRESS, UART_OUTPUT_SETTING);

    //Set pin MUX of Radar RX pin
    HW_WR_REG32(MMWRADAR_RX_PIN_PHYSICAL_ADDRESS, UART_INPUT_SETTING);

    Vps_printf("~~~ PSVT_MMWRadarUART_Init() devId = %d ~~~\n", MMWRADAR_UART_ID);
    vUART_Params = Uart_PARAMS;
    vUART_Params.opMode = UART_OPMODE_INTERRUPT;
    vUART_Params.hwiNumber = 8;
    vUART_Params.rxThreshold = UART_RXTRIGLVL_8;
    vUART_Params.txThreshold = UART_TXTRIGLVL_56;
    vUART_Params.baudRate = MMWRADAR_UART_USE_BAUDRATE;
    vUART_Params.prcmDevId = 0;

    if (vUART_Params.opMode == UART_OPMODE_POLLED)
    {
        Vps_printf("~~~ PSVT_MMWRadarUART_Init() Polled mode is selected ~~~\n");
    }
    else if (vUART_Params.opMode == UART_OPMODE_INTERRUPT)
    {
        Vps_printf("~~~ PSVT_MMWRadarUART_Init() Interrupt mode is selected ~~~\n");
    }

    vUART_Params.enableCache = (Bool)FALSE;

    //Initialise the edma library and get the EDMA handle
    vChanParams.hEdma = NULL;

    //If cross bar events are being used then make isCrossBarIntEn = TRUE and choose
    //appropriate interrupt number to be mapped (assign it to intNumToBeMapped)
    vChanParams.crossBarEvtParam.isCrossBarIntEn = (Bool)FALSE;

    vChanParams.crossBarEvtParam.intNumToBeMapped = 0xFFU;

    vIO_Params.chanParams = (Ptr)&vChanParams;

    DEV_Params_init(&vDevParams);
    vDevParams.deviceParams = &vUART_Params;
    vDevParams.initFxn = NULL;
    vDevParams.devid = MMWRADAR_UART_ID;

    DEV_construct(&vUART_DevObj, vUART_Name, (Ptr)&Uart_IOMFXNS, &vDevParams, &vEB);

    //Radar TX init
    SyncSem_Params_init(&vSyncSemParams);

    Semaphore_Params_init(&vSemParams);

    vSemParams.mode = Semaphore_Mode_BINARY;

    Semaphore_construct(&vUART_TX_SemObj, 0, &vSemParams);

    vSyncSemParams.sem = Semaphore_handle(&vUART_TX_SemObj);

    SyncSem_construct(&vUART_TX_SyncSemObj, &vSyncSemParams, &vEB);

    vIO_Params.sync = SyncSem_Handle_upCast(SyncSem_handle(&vUART_TX_SyncSemObj));

    if (vIO_Params.numPackets > UART_ASYNC_IOM_PACKET_MAX)
    {
        UTILS_assert(vIO_Params.numPackets <= UART_ASYNC_IOM_PACKET_MAX);
    }

    memset(&vUART_TX_IOM_Obj[0], 0, vIO_Params.numPackets * sizeof(IOM_Packet));
    vIO_Params.packets = &vUART_TX_IOM_Obj[0];

    //Create the required channels TX for the Radar
    GIO_construct(&vUART_TX_Obj, vUART_Name, (UInt32)GIO_OUTPUT, &vIO_Params, &vEB);

    //Radar RX init
    SyncSem_Params_init(&vSyncSemParams);

    Semaphore_Params_init(&vSemParams);
    vSemParams.mode = Semaphore_Mode_BINARY;

    Semaphore_construct(&vUART_RX_SemObj, 0, &vSemParams);

    vSyncSemParams.sem = Semaphore_handle(&vUART_RX_SemObj);

    SyncSem_construct(&vUART_RX_SyncSemObj, &vSyncSemParams, &vEB);

    vIO_Params.sync = SyncSem_Handle_upCast(SyncSem_handle(&vUART_RX_SyncSemObj));

    memset(&vUART_RX_IOM_Obj[0], 0, vIO_Params.numPackets * sizeof(IOM_Packet));
    vIO_Params.packets = &vUART_RX_IOM_Obj[0];

    //Create the required channels RX for the Radar
    GIO_construct(&vUART_RX_Obj, vUART_Name, (UInt32)GIO_INPUT, &vIO_Params, &vEB);

    vUART_TX_Handle = GIO_handle(&vUART_TX_Obj);
    vUART_RX_Handle = GIO_handle(&vUART_RX_Obj);

    if ((vUART_RX_Handle == NULL) || (vUART_TX_Handle == NULL))
    {
        Vps_printf("~~~ PSVT_MMWRadarUART_Init() GIO_create(%s) failed ~~~\n",
                   vUART_Name);
    }
    else
    {
        vInitDone = (Bool)TRUE;
    }

    Vps_printf("~~~ PSVT_MMWRadarUART_Init() Done. ~~~\n");
}