rl_device.c

/****************************************************************************************
 * FileName     : rl_device.c
 *
 * Description  : This file defines the functions required to Control mmwave radar Device.
 *
 ****************************************************************************************
 * (C) Copyright 2014, Texas Instruments Incorporated. - TI web address www.ti.com
 *---------------------------------------------------------------------------------------
 *
 *  Redistribution and use in source and binary forms, with or without modification,
 *  are permitted provided that the following conditions are met:
 *
 *    Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 *
 *    Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 *
 *    Neither the name of Texas Instruments Incorporated nor the names of its
 *    contributors may be used to endorse or promote products derived from this
 *    software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 *  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 *  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT  OWNER OR CONTRIBUTORS
 *  BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 *  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 *  CONTRACT,  STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 *  POSSIBILITY OF SUCH DAMAGE.
 */

 /*
 ****************************************************************************************
 * Revision History   :
 *---------------------------------------------------------------------------------------
 * Version  Date        Author             Defect No               Description
 *---------------------------------------------------------------------------------------
 * 0.1.0    12May2015   Kaushal Kukkar    -               Initial Version
 *
 * 0.5.2    23Sep2016   Kaushal Kukkar    AUTORADAR-541   xWR1642 Support
 *
 * 0.6.0    15Nov2016   Kaushal Kukkar    AUTORADAR-666   Logging Feature
 *                      Kaushal Kukkar    AUTORADAR-716   Cascade API change
 *
 * 0.7.0    11May2017   Kaushal Kukkar    MMWSDK-362      LDRA static analysis Issue Fix
 *
 * 0.8.6    24Jul2017   Jitendra Gupta    MMWL-19         MSS Test pattern, Monitoring APIs
 *                      Kaushal Kukkar    MMWL-23         Big Endian Support
 *                      Jitendra Gupta    MMWL-26         MSS Data path Get APIs
 *
 * 0.9.1       -        Jitendra Gupta    MMWL-5          Code size optimization
 ****************************************************************************************
 */

/******************************************************************************
 * INCLUDE FILES
 ******************************************************************************
 */
#include <stdlib.h>
#include <string.h>
#include <ti/control/mmwavelink/mmwavelink.h>
#include <ti/control/mmwavelink/include/rl_device.h>
#include <ti/control/mmwavelink/include/rl_driver.h>
#include <ti/control/mmwavelink/include/rl_messages.h>
#include <ti/control/mmwavelink/include/rl_controller.h>
#include <ti/control/mmwavelink/include/rl_trace.h>

/******************************************************************************
 * GLOBAL VARIABLES/DATA-TYPES DEFINITIONS
 ******************************************************************************
 */

/******************************************************************************
 * FUNCTION DEFINITIONS
 ******************************************************************************
 */

/* DesignId : MMWL_DesignId_004 */
/* Requirements : AUTORADAR_REQ-707 */
rlReturnVal_t rlDevicePowerOn(rlUInt8_t deviceMap, rlClientCbs_t clientCb)
{
    rlReturnVal_t retVal;
    rlUInt8_t index = 0U;
    /* get rlDriver global structure pointer */
    rlDriverData_t *rlDrvData = rlDriverGetHandle();

    /* if driver is already initialized */
    if ((rlDrvData != NULL) && (rlDrvData->isDriverInitialized == 1U))
    {
        /* DeInitialize Device */
        retVal = rlDevicePowerOff();
    }
    else
    {
        retVal = RL_RET_CODE_OK;
    }

    /* if there is no error found from above conditioning then go ahead and poweron
        mmwavelink & device */
    if (retVal == RL_RET_CODE_OK)
    {
        /* Initialize Host Communication Protocol Driver */
        if (rlDriverInit(deviceMap, clientCb) < 0)
        {
            /* if driver Init failed then set return error code */
            retVal += RL_RET_CODE_RADAR_IF_ERROR;
        }
        else
        {
            /* Power up mmwave Device */
            do
            {
                /* loop for all devices connected to device/Host */
                if ((deviceMap & (1U << index)) != 0U)
                {
                    /* Enable the 12xx device where it will power up the device and read
                        first Async Event */
                    if (clientCb.devCtrlCb.rlDeviceEnable(index) < 0)
                    {
                        /* set return error code */
                        retVal += RL_RET_CODE_RADAR_IF_ERROR;
                        RL_LOGE_ARG0("mmWaveLink: Enabling device failed \n");
                        /* if device enable is failed the de-init mmwavelink driver */
                        (void)rlDriverDeInit();
                        RL_LOGW_ARG0("mmWaveLink Driver DeInit done\n");
                    }
                    /* Reset device Index in DeviceMap for which device has been enabled */
                    deviceMap &= ~(1U << index);
                }
                /* increment device index */
                index++;
            }
            while ((deviceMap != 0U) && (index < RL_DEVICE_CONNECTED_MAX));
        }
    }
    RL_LOGV_ARG0("mmWaveLink Power Up completes\n");

    return retVal;
}

/* DesignId : MMWL_DesignId_021 */
/* Requirements : AUTORADAR_REQ-757 */
rlReturnVal_t rlDeviceAddDevices(rlUInt8_t deviceMap)
{
    rlReturnVal_t retVal;

    RL_LOGV_ARG0("rlDeviceAddDevices starts\n");

    /* add device for requested deviceMap */
    retVal = rlDriverAddDevice(deviceMap);

    RL_LOGV_ARG0("rlDeviceAddDevices completes\n");

    return retVal;
}

/* DesignId : MMWL_DesignId_034 */
/* Requirements : AUTORADAR_REQ-757 */
rlReturnVal_t rlDeviceRemoveDevices(rlUInt8_t deviceMap)
{
    rlReturnVal_t retVal = RL_RET_CODE_OK;
    rlUInt8_t index = 0U;
    /* get rlDriver global structure pointer */
    rlDriverData_t *rlDrvData = rlDriverGetHandle();

    /* if driver is already initialized and deviceDisable API is not NULL */
    if ((rlDrvData != NULL) && (rlDrvData->isDriverInitialized == 1U) && \
        (rlDrvData->clientCtx.devCtrlCb.rlDeviceDisable != RL_NULL_PTR))
    {
        rlUInt8_t lclDeviceMap = deviceMap;
        do
        {
            /* loop for device index connected to device/Host */
            if ((lclDeviceMap & (1U << index)) != 0U)
            {
                /* Enable the 12xx device where it will power up the
                 * device and read first Async Event
                 */
                if (rlDrvData->clientCtx.devCtrlCb.rlDeviceDisable(index)
                   < 0)
                {
                    /* Device Power Off Failed */
                    retVal += RL_RET_CODE_RADAR_IF_ERROR;
                    RL_LOGE_ARG0("mmWave device Power Off failed\n");
                }
                /* Reset device Index in DeviceMap for which device has been disabled */
                lclDeviceMap &= ~(1U << index);
            }
            /* increment device index */
            index++;
        }
        while ((lclDeviceMap != 0U) && (index < RL_DEVICE_CONNECTED_MAX));

        RL_LOGI_ARG0("mmwave device Power Off Successful\n");
        /* Remove the devices from Driver */
        retVal += rlDriverRemoveDevices(deviceMap);
    }
    else
    {
        /* set return error code */
        retVal += RL_RET_CODE_SELF_ERROR;
        RL_LOGD_ARG0("Either rlDrvData is NULL or not initialised\n");
    }

    RL_LOGV_ARG0("rlDeviceRemoveDevices complete...\n");
    return retVal;
}

/* DesignId :  MMWL_DesignId_005 */
/* Requirements : AUTORADAR_REQ-711 */
rlReturnVal_t rlDevicePowerOff(void)
{
    rlReturnVal_t retVal = RL_RET_CODE_OK;
    rlUInt8_t index = 0U;
    /* get rlDriver global structure pointer */
    rlDriverData_t *rlDrvData = rlDriverGetHandle();

    /* if driver is already initialized and deviceDisable API is not NULL */
    if ((rlDrvData != NULL) && (rlDrvData->isDriverInitialized == 1U) && \
        (rlDrvData->clientCtx.devCtrlCb.rlDeviceDisable != RL_NULL_PTR))
    {
        rlUInt8_t deviceMap = rlDrvData->deviceMap;
        /* disable all connected devices */
        do
        {
            /* if device Index is valid out of deviceMap */
            if ((deviceMap & (1U << index)) != 0U)
            {
                /* Enable the 12xx device where it will power up the
                 * device and read first Async Event
                 */
                if (rlDrvData->clientCtx.devCtrlCb.rlDeviceDisable(index)
                   < 0)
                {
                    /* Device Power Off Failed */
                    retVal += RL_RET_CODE_RADAR_IF_ERROR;
                    RL_LOGE_ARG0("mmWave device Power Off failed\n");
                }
                /* Reset device Index in DeviceMap for which device has been disabled */
                deviceMap &= ~(1U << index);
            }
            /* increment device index */
            index++;
        }
        while ((deviceMap != 0U) || (index < RL_DEVICE_CONNECTED_MAX));

        RL_LOGI_ARG0("Power Off Successful\n");
        /* DeInitialize Host Communication Protocol Driver */
        retVal += rlDriverDeInit();
        RL_LOGV_ARG0("Driver De-initialization complete\n");
    }
    else
    {
        /* set return error code */
        retVal += RL_RET_CODE_SELF_ERROR;
        RL_LOGD_ARG0("Either rlDrvData is NULL or not initialised\n");
    }

    RL_LOGV_ARG0("Device power-off complete...\n");
    return retVal;
}

/* DesignId : MMWL_DesignId_027 */
/* Requirements : AUTORADAR_REQ-761 */
rlReturnVal_t rlDeviceRfStart(rlUInt8_t deviceMap)
{
    rlReturnVal_t retVal;

    RL_LOGV_ARG0("rlDeviceRfStart starts...\n");

    /* check if deviceIndex is out of defined value */
    if (rlDriverIsDeviceMapValid(deviceMap) != RL_RET_CODE_OK)
    {
        /* set return error code */
        retVal = RL_RET_CODE_INVALID_INPUT;
        RL_LOGE_ARG0("Device map id is invalid\n");
    }
    else
    {
        /* Package the command with given data and send it to device */
        retVal = rlDriverExecuteSetApi(deviceMap, RL_DEV_POWERUP_MSG,
                                       RL_SYS_RF_POWERUP_SB, NULL, 0U);
    }

    RL_LOGV_ARG0("rlDeviceRfStart complete...\n");

    return retVal;
}

/* DesignId :  MMWL_DesignId_006 */
/* Requirements : AUTORADAR_REQ-708 */
rlReturnVal_t rlDeviceFileDownload(rlUInt8_t deviceMap, rlFileData_t* data,
                                  rlUInt16_t remChunks)
{
    rlReturnVal_t retVal;

    /* check if deviceIndex is out of defined value */
    if ((rlDriverIsDeviceMapValid(deviceMap) != RL_RET_CODE_OK) || \
        (RL_NULL_PTR == data))
    {
        /* set error code if DeviceMAP is invalid or data pointer is null */
        retVal = RL_RET_CODE_INVALID_INPUT;
        RL_LOGE_ARG0("Invalid input");
    }
    /* This API is valid only when mmWaveLink instance is running on
       External Host Processor */
    else if (RL_PLATFORM_HOST != rlDriverGetPlatformId())
    {
        /* set error code of Platform is not set to HOST */
        retVal = RL_RET_CODE_API_NOT_SUPPORTED;
    }
    else
    {
        /* LDRA waiver   8 D - DD data flow anomalies found- */
        /* Initialize in-message structure to zero */
        rlDriverMsg_t inMsg = {0};
        /* Initialize out-message structure to zero */
        rlDriverMsg_t outMsg = {0};
        /* Initialize in-payload sub-block structure to zero */
        rlPayloadSb_t inPayloadSb = {0};

        /* Construct command packet */
        rlDriverConstructInMsg(RL_DEV_FILE_DOWNLOAD_MSG, &inMsg, &inPayloadSb);

        /* set the remaining chunk in command message */
        inMsg.remChunks = remChunks;
        /* Fill in-message Payload */
        /* AR_CODE_REVIEW MR:R.11.1  <APPROVED> "conversion required." */
        /*LDRA_INSPECTED 95 S */
        rlDriverFillPayload(RL_DEV_FILE_DOWNLOAD_MSG, RL_SYS_FILE_DWLD_SB, &inPayloadSb,\
                            (rlUInt8_t*)&data->fData[0U], (rlUInt16_t)data->chunkLen);

        /* Send Command to mmWave Radar Device */
        /* LDRA waiver 45 D - can't be NULL */
        /* LDRA waiver 45 D - can't be NULL */
        retVal = rlDriverCmdInvoke(deviceMap, inMsg, &outMsg);
    }
    return retVal;
}

rlReturnVal_t rlDeviceGetMssVersion(rlUInt8_t deviceMap, rlFwVersionParam_t *data)
{
    rlReturnVal_t retVal;

    /* check for NULL pointer */
    if (data == RL_NULL_PTR)
    {
        /* set error code if data pointer is passed NULL */
        retVal = RL_RET_CODE_NULL_PTR;
    }
    /* This API is valid only when mmWaveLink instance is running on
       External Host Processor */
    else if (RL_PLATFORM_HOST != rlDriverGetPlatformId())
    {
        /* set error code of Platform is not set to HOST */
        retVal = RL_RET_CODE_API_NOT_SUPPORTED;
    }
    else
    {
        /* Package the command with given data and send it to device */
        retVal = rlDriverExecuteGetApi(deviceMap, RL_DEV_STATUS_GET_MSG,
                                       RL_SYS_VERSION_SB, (rlUInt8_t*)data, 0U);
    }

    return retVal;
}

rlReturnVal_t rlDeviceGetRfVersion(rlUInt8_t deviceMap, rlFwVersionParam_t *data)
{
    rlReturnVal_t retVal;

    /* check for NULL pointer */
    if (data == RL_NULL_PTR)
    {
        /* set error code if data pointer is passed NULL */
        retVal = RL_RET_CODE_NULL_PTR;
    }
    else
    {
        /* Package the command with given data and send it to device */
        retVal = rlDriverExecuteGetApi(deviceMap, RL_RF_STATUS_GET_MSG,
                                        RL_RF_RFVERSION_SB, (rlUInt8_t*)data, 0U);
    }

    return retVal;
}

/* DesignId : MMWL_DesignId_007 */
/* Requirements : AUTORADAR_REQ-709 */
rlReturnVal_t rlDeviceGetVersion(rlUInt8_t deviceMap, rlVersion_t* data)
{
    rlReturnVal_t retVal;

    RL_LOGV_ARG0("rlDeviceGetVersion starts...\n");

    /* check if deviceIndex is out of defined value */
    if ((rlDriverIsDeviceMapValid(deviceMap) != RL_RET_CODE_OK) || \
       (RL_NULL_PTR == data))
    {
        /* set error code */
        retVal = RL_RET_CODE_INVALID_INPUT;
        RL_LOGE_ARG0("Invalid inputs");
    }
    else
    {
        /* If mmWaveLink is runing on ext host */
        if (RL_PLATFORM_HOST == rlDriverGetPlatformId())
        {
            /* get mmwave MSS ROM or Application version */
            retVal = rlDeviceGetMssVersion(deviceMap, &data->master);
        }
        else
        {
            /* if mmwavelink is not running on Host then no need to get MSS version */
            retVal = RL_RET_CODE_OK;
            RL_LOGD_ARG0(" rlPlatform is not host \n");
        }

        if (retVal == RL_RET_CODE_OK)
        {
            /* get RF (RadarSS) version */
            retVal += rlDeviceGetRfVersion(deviceMap, &data->rf);
        }

        if (retVal == RL_RET_CODE_OK)
        {
            /* get mmwavelink library version */
            retVal += rlDeviceGetMmWaveLinkVersion(&data->mmWaveLink);
        }
    }

    RL_LOGV_ARG0("rlDeviceGetVersion complete...\n");

    return retVal;
}
/* DesignId : MMWL_DesignId_008 */
/* Requirements : AUTORADAR_REQ-709 */
rlReturnVal_t rlDeviceGetMmWaveLinkVersion(rlSwVersionParam_t* data)
{
    rlReturnVal_t retVal;

    RL_LOGV_ARG0("rlDeviceGetMmWaveLinkVersion starts...\n");

    if (RL_NULL_PTR != data)
    {
        /* mmWaveLink Version */
        /* mmWaveLink SW Major verison */
        data->major = RL_MMWAVELINK_VERSION_MAJOR;
        /* mmWaveLink SW Minor verison */
        data->minor = RL_MMWAVELINK_VERSION_MINOR;
        /* mmWaveLink SW Build verison */
        data->build = RL_MMWAVELINK_VERSION_BUILD;
        /* mmWaveLink SW Debug verison */
        data->debug = RL_MMWAVELINK_VERSION_DEBUG;
        /* mmWaveLink SW Release Year */
        data->year  = RL_MMWAVELINK_VERSION_YEAR;
        /* mmWaveLink SW Release Month */
        data->month = RL_MMWAVELINK_VERSION_MONTH;
        /* mmWaveLink SW Release date */
        data->day   = RL_MMWAVELINK_VERSION_DAY;
        /* Set error code */
        retVal      = RL_RET_CODE_OK;
        RL_LOGD_ARG0("Extracted MmWavelink version\n");
    }
    else
    {
        /* set error code */
        retVal = RL_RET_CODE_INVALID_INPUT;
        RL_LOGE_ARG0("rlDeviceGetMmWaveLinkVersion, Output param is NULL \n");
    }

    RL_LOGV_ARG0("rlDeviceGetMmWaveLinkVersion complete...\n");

    return retVal;
}

/* DesignId : MMWL_DesignId_104 */
/* Requirements : AUTORADAR_REQ-762 */
rlReturnVal_t rlDeviceSetDataFmtConfig(rlUInt8_t deviceMap, rlDevDataFmtCfg_t* data)
{
    rlReturnVal_t retVal;

    RL_LOGV_ARG0("rlDeviceSetDataFmtConfig starts...\n");

    /* check if deviceIndex is out of defined value */
    if ((rlDriverIsDeviceMapValid(deviceMap) != RL_RET_CODE_OK) || \
        (RL_NULL_PTR == data))
    {
        /* set error code if DeviceMAP is invalid or data pointer is null */
        retVal = RL_RET_CODE_INVALID_INPUT;
        RL_LOGE_ARG0("Invalid device mapping\n");
    }
    /* This API is valid only when mmWaveLink instance is running on
       External Host Processor */
    else if (RL_PLATFORM_HOST != rlDriverGetPlatformId())
    {
        /* set error code of Platform is not set to HOST */
        retVal = RL_RET_CODE_API_NOT_SUPPORTED;
    }
    else
    {
        /* Package the command with given data and send it to device */
        retVal = rlDriverExecuteSetApi(deviceMap, RL_DEV_CONFIG_SET_MSG,
                               RL_DEV_RX_DATA_FORMAT_CONF_SET_SB, (rlUInt8_t*)data,
                               (rlUInt16_t)sizeof(rlDevDataFmtCfg_t));
    }

    RL_LOGV_ARG0("rlDeviceSetDataFmtConfig complete...\n");

    return retVal;
}

/* DesignId : MMWL_DesignId_112 */
/* Requirements : AUTORADAR_REQ-762 */
rlReturnVal_t rlDeviceGetDataFmtConfig(rlUInt8_t deviceMap, rlDevDataFmtCfg_t* data)
{
    rlReturnVal_t retVal;

    RL_LOGV_ARG0("rlDeviceGetDataFmtConfig starts...\n");

    /* check if deviceIndex is out of defined value */
    if ((rlDriverIsDeviceMapValid(deviceMap) != RL_RET_CODE_OK) || \
        (RL_NULL_PTR == data))
    {
        /* set error code if DeviceMAP is invalid or data pointer is null */
        retVal = RL_RET_CODE_INVALID_INPUT;
        RL_LOGE_ARG0("rlDeviceGetDataFmtConfig, Invalid device map\n");
    }
    /* This API is valid only when mmWaveLink instance is running on
       External Host Processor */
    else if (RL_PLATFORM_HOST != rlDriverGetPlatformId())
    {
        /* set error code of Platform is not set to HOST */
        retVal = RL_RET_CODE_API_NOT_SUPPORTED;
    }
    else
    {
        /* Package the command with given data and send it to device */
        retVal = rlDriverExecuteGetApi(deviceMap, RL_DEV_CONFIG_GET_MSG,
                                        RL_DEV_RX_DATA_FORMAT_CONF_SET_SB,
                                        (rlUInt8_t*)data, 0U);
    }

    RL_LOGV_ARG0("rlDeviceGetDataFmtConfig ends...\n");
    return retVal;
}

/* DesignId : MMWL_DesignId_105 */
/* Requirements : AUTORADAR_REQ-763 */
rlReturnVal_t rlDeviceSetDataPathConfig(rlUInt8_t deviceMap, rlDevDataPathCfg_t* data)
{
    rlReturnVal_t retVal;

    RL_LOGV_ARG0("rlDeviceSetDataPathConfig starts...\n");

    /* check if deviceIndex is out of defined value */
    if ((rlDriverIsDeviceMapValid(deviceMap) != RL_RET_CODE_OK) || \
       (RL_NULL_PTR == data))
    {
        /* set error code if DeviceMAP is invalid or data pointer is null */
        retVal = RL_RET_CODE_INVALID_INPUT;
        RL_LOGE_ARG0("Invalid input");
    }
    /* This API is valid only when mmWaveLink instance is running on
       External Host Processor */
    else if (RL_PLATFORM_HOST != rlDriverGetPlatformId())
    {
        /* set error code of Platform is not set to HOST */
        retVal = RL_RET_CODE_API_NOT_SUPPORTED;
    }
    else
    {
        /* Package the command with given data and send it to device */
        retVal = rlDriverExecuteSetApi(deviceMap, RL_DEV_CONFIG_SET_MSG,
                               RL_DEV_RX_DATA_PATH_CONF_SET_SB, (rlUInt8_t*)data,
                               (rlUInt16_t)sizeof(rlDevDataPathCfg_t));
    }

    RL_LOGV_ARG0("rlDeviceSetDataPathConfig ends...\n");
    return retVal;
}

/* DesignId : MMWL_DesignId_113 */
/* Requirements : AUTORADAR_REQ-763 */
rlReturnVal_t rlDeviceGetDataPathConfig(rlUInt8_t deviceMap,
                                                       rlDevDataPathCfg_t* data)
{
    rlReturnVal_t retVal;

    RL_LOGV_ARG0("rlDeviceGetDataPathConfig starts...\n");

    /* check if deviceIndex is out of defined value */
    if ((rlDriverIsDeviceMapValid(deviceMap) != RL_RET_CODE_OK) || \
        (RL_NULL_PTR == data))
    {
        /* set error code if DeviceMAP is invalid or data pointer is null */
        retVal = RL_RET_CODE_INVALID_INPUT;
        RL_LOGE_ARG0("rlDeviceGetDataPathConfig, Invalid device map\n");
    }
    /* This API is valid only when mmWaveLink instance is running on
       External Host Processor */
    else if (RL_PLATFORM_HOST != rlDriverGetPlatformId())
    {
        /* set error code of Platform is not set to HOST */
        retVal = RL_RET_CODE_API_NOT_SUPPORTED;
    }
    else
    {
        /* Package the command with given data and send it to device */
        retVal = rlDriverExecuteGetApi(deviceMap, RL_DEV_CONFIG_GET_MSG,
                                        RL_DEV_RX_DATA_PATH_CONF_SET_SB,
                                        (rlUInt8_t*)data, 0U);
    }

    RL_LOGV_ARG0("rlDeviceGetDataPathConfig ends...\n");
    return retVal;
}

/* DesignId : MMWL_DesignId_033 */
/* Requirements : AUTORADAR_REQ-756, AUTORADAR_REQ-764 */
rlReturnVal_t rlDeviceSetLaneConfig(rlUInt8_t deviceMap, rlDevLaneEnable_t* data)
{
    rlReturnVal_t retVal;

    RL_LOGV_ARG0("rlDeviceSetLaneConfig starts...\n");

    /* check if deviceIndex is out of defined value */
    if ((rlDriverIsDeviceMapValid(deviceMap) != RL_RET_CODE_OK) || \
       (RL_NULL_PTR == data))
    {
        /* set error code if DeviceMAP is invalid or data pointer is null */
        retVal = RL_RET_CODE_INVALID_INPUT;
        RL_LOGE_ARG0("Invalid input\n");
    }
    /* This API is valid only when mmWaveLink instance is running on
       External Host Processor */
    else if (RL_PLATFORM_HOST != rlDriverGetPlatformId())
    {
        /* set error code of Platform is not set to HOST */
        retVal = RL_RET_CODE_API_NOT_SUPPORTED;
    }
    else
    {
        /* Package the command with given data and send it to device */
        retVal = rlDriverExecuteSetApi(deviceMap, RL_DEV_CONFIG_SET_MSG,
                               RL_DEV_DATA_PATH_LANEEN_SET_SB, (rlUInt8_t*)data,
                               (rlUInt16_t)sizeof(rlDevLaneEnable_t));
    }
    RL_LOGV_ARG0("rlDeviceSetLaneConfig ends...\n");

    return retVal;
}

/* DesignId : MMWL_DesignId_115 */
/* Requirements : AUTORADAR_REQ-765, AUTORADAR_REQ-764 */
rlReturnVal_t rlDeviceGetLaneConfig(rlUInt8_t deviceMap, rlDevLaneEnable_t* data)
{
    rlReturnVal_t retVal;

    RL_LOGV_ARG0("rlDeviceGetLaneConfig starts...\n");

    /* check if deviceIndex is out of defined value */
    if ((rlDriverIsDeviceMapValid(deviceMap) != RL_RET_CODE_OK) || \
        (RL_NULL_PTR == data))
    {
        /* set error code if DeviceMAP is invalid or data pointer is null */
        retVal = RL_RET_CODE_INVALID_INPUT;
        RL_LOGE_ARG0("rlDeviceGetLaneConfig, Invalid device map\n");
    }
    /* This API is valid only when mmWaveLink instance is running on
       External Host Processor */
    else if (RL_PLATFORM_HOST != rlDriverGetPlatformId())
    {
        /* set error code of Platform is not set to HOST */
        retVal = RL_RET_CODE_API_NOT_SUPPORTED;
    }
    else
    {
        /* Package the command with given data and send it to device */
        retVal = rlDriverExecuteGetApi(deviceMap, RL_DEV_CONFIG_GET_MSG,
                                        RL_DEV_DATA_PATH_LANEEN_SET_SB,
                                        (rlUInt8_t*)data, 0U);
    }

    RL_LOGV_ARG0("rlDeviceGetLaneConfig ends...\n");
    return retVal;
}

/* DesignId : MMWL_DesignId_106 */
/* Requirements : AUTORADAR_REQ-764 */
rlReturnVal_t rlDeviceSetDataPathClkConfig(rlUInt8_t deviceMap,
                                                  rlDevDataPathClkCfg_t* data )
{
    rlReturnVal_t retVal;

    RL_LOGV_ARG0("rlDeviceSetDataPathClkConfig starts...\n");

    /* check if deviceIndex is out of defined value */
    if ((rlDriverIsDeviceMapValid(deviceMap) != RL_RET_CODE_OK) || (RL_NULL_PTR == data))
    {
        /* set error code if DeviceMAP is invalid or data pointer is null */
        retVal = RL_RET_CODE_INVALID_INPUT;
        RL_LOGE_ARG0("Invalid input\n");
    }
    /* This API is valid only when mmWaveLink instance is running on
       External Host Processor */
    else if (RL_PLATFORM_HOST != rlDriverGetPlatformId())
    {
        /* set error code of Platform is not set to HOST */
        retVal = RL_RET_CODE_API_NOT_SUPPORTED;
    }
    else
    {
        /* Package the command with given data and send it to device */
        retVal = rlDriverExecuteSetApi(deviceMap, RL_DEV_CONFIG_SET_MSG,
                               RL_DEV_DATA_PATH_CLOCK_SET_SB, (rlUInt8_t*)data,
                               (rlUInt16_t)sizeof(rlDevDataPathClkCfg_t));
    }
    RL_LOGV_ARG0("rlDeviceSetDataPathClkConfig ends...\n");

    return retVal;
}

/* DesignId : MMWL_DesignId_114 */
/* Requirements : AUTORADAR_REQ-764 */
rlReturnVal_t rlDeviceGetDataPathClkConfig(rlUInt8_t deviceMap, rlDevDataPathClkCfg_t* data)
{
    rlReturnVal_t retVal;

    RL_LOGV_ARG0("rlDeviceGetDataPathClkConfig starts...\n");

    /* check if deviceIndex is out of defined value */
    if ((rlDriverIsDeviceMapValid(deviceMap) != RL_RET_CODE_OK) || \
        (RL_NULL_PTR == data))
    {
        /* set error code if DeviceMAP is invalid or data pointer is null */
        retVal = RL_RET_CODE_INVALID_INPUT;
        RL_LOGE_ARG0("rlDeviceGetDataPathClkConfig, Invalid device map\n");
    }
    /* This API is valid only when mmWaveLink instance is running on
       External Host Processor */
    else if (RL_PLATFORM_HOST != rlDriverGetPlatformId())
    {
        /* set error code of Platform is not set to HOST */
        retVal = RL_RET_CODE_API_NOT_SUPPORTED;
    }
    else
    {
        /* Package the command with given data and send it to device */
        retVal = rlDriverExecuteGetApi(deviceMap, RL_DEV_CONFIG_GET_MSG,
                                        RL_DEV_DATA_PATH_CLOCK_SET_SB,
                                        (rlUInt8_t*)data, 0U);
    }

    RL_LOGV_ARG0("rlDeviceGetDataPathClkConfig ends...\n");
    return retVal;
}

/* DesignId : MMWL_DesignId_030 */
/* Requirements : AUTORADAR_REQ-767 */
rlReturnVal_t rlDeviceSetLvdsLaneConfig(rlUInt8_t deviceMap, rlDevLvdsLaneCfg_t* data)
{
    rlReturnVal_t retVal;

    RL_LOGV_ARG0("rlDeviceSetLvdsLaneConfig starts...\n");

    /* check if deviceIndex is out of defined value */
    if ((rlDriverIsDeviceMapValid(deviceMap) != RL_RET_CODE_OK) || \
       (RL_NULL_PTR == data))
    {
        /* set error code if DeviceMAP is invalid or data pointer is null */
        retVal = RL_RET_CODE_INVALID_INPUT;
        RL_LOGE_ARG0("Invalid input\n");
    }
    /* This API is valid only when mmWaveLink instance is running on
       External Host Processor */
    else if (RL_PLATFORM_HOST != rlDriverGetPlatformId())
    {
        /* set error code of Platform is not set to HOST */
        retVal = RL_RET_CODE_API_NOT_SUPPORTED;
    }
    else
    {
        /* Package the command with given data and send it to device */
        retVal = rlDriverExecuteSetApi(deviceMap, RL_DEV_CONFIG_SET_MSG,
                               RL_DEV_DATA_PATH_CFG_SET_SB, (rlUInt8_t*)data,
                               (rlUInt16_t)sizeof(rlDevLvdsLaneCfg_t));
    }

    RL_LOGV_ARG0("rlDeviceSetLvdsLaneConfig ends...\n");

    return retVal;
}

/* DesignId : MMWL_DesignId_116 */
/* Requirements : AUTORADAR_REQ-767 */
rlReturnVal_t rlDeviceGetLvdsLaneConfig(rlUInt8_t deviceMap, rlDevLvdsLaneCfg_t* data)
{
    rlReturnVal_t retVal;

    RL_LOGV_ARG0("rlDeviceGetLvdsLaneConfig starts...\n");

    /* check if deviceIndex is out of defined value */
    if ((rlDriverIsDeviceMapValid(deviceMap) != RL_RET_CODE_OK) || \
        (RL_NULL_PTR == data))
    {
        /* set error code if DeviceMAP is invalid or data pointer is null */
        retVal = RL_RET_CODE_INVALID_INPUT;
        RL_LOGE_ARG0("rlDeviceGetLvdsLaneConfig, Invalid device map\n");
    }
    /* This API is valid only when mmWaveLink instance is running on
       External Host Processor */
    else if (RL_PLATFORM_HOST != rlDriverGetPlatformId())
    {
        /* set error code of Platform is not set to HOST */
        retVal = RL_RET_CODE_API_NOT_SUPPORTED;
    }
    else
    {
        /* Package the command with given data and send it to device */
        retVal = rlDriverExecuteGetApi(deviceMap, RL_DEV_CONFIG_GET_MSG,
                                        RL_DEV_DATA_PATH_CFG_SET_SB,
                                        (rlUInt8_t*)data, 0U);
    }

    RL_LOGV_ARG0("rlDeviceGetLvdsLaneConfig ends...\n");
    return retVal;
}

/* DesignId : MMWL_DesignId_040 */
/* Requirements : AUTORADAR_REQ-829 */
rlReturnVal_t rlDeviceSetContStreamingModeConfig(rlUInt8_t deviceMap,
                                                 rlDevContStreamingModeCfg_t* data)
{
    rlReturnVal_t retVal;

    RL_LOGV_ARG0("rlDeviceSetContStreamingModeConfig ends...\n");

    /* check if deviceIndex is out of defined value */
    if ((rlDriverIsDeviceMapValid(deviceMap) != RL_RET_CODE_OK) || \
        (RL_NULL_PTR == data))
    {
        /* set error code if DeviceMAP is invalid or data pointer is null */
        retVal = RL_RET_CODE_INVALID_INPUT;
        RL_LOGE_ARG0("Invalid input");
    }
    /* This API is valid only when mmWaveLink instance is running on
       External Host Processor */
    else if (RL_PLATFORM_HOST != rlDriverGetPlatformId())
    {
        /* set error code of Platform is not set to HOST */
        retVal = RL_RET_CODE_API_NOT_SUPPORTED;
    }
    else
    {
        /* Package the command with given data and send it to device */
        retVal = rlDriverExecuteSetApi(deviceMap, RL_DEV_CONFIG_SET_MSG,
                               RL_DEV_RX_CONTSTREAMING_MODE_CONF_SET_SB,
                               (rlUInt8_t*)data,
                               (rlUInt16_t)sizeof(rlDevContStreamingModeCfg_t));
    }

    RL_LOGV_ARG0("rlDeviceSetContStreamingModeConfig ends...\n");

    return retVal;

}

/* DesignId : MMWL_DesignId_121 */
/* Requirements : AUTORADAR_REQ-829 */
rlReturnVal_t rlDeviceGetContStreamingModeConfig(
                        rlUInt8_t deviceMap, rlDevContStreamingModeCfg_t* data)
{
    rlReturnVal_t retVal;

    RL_LOGV_ARG0("rlDeviceGetContStreamingModeConfig starts...\n");

    /* check if deviceIndex is out of defined value */
    if ((rlDriverIsDeviceMapValid(deviceMap) != RL_RET_CODE_OK) || \
        (RL_NULL_PTR == data))
    {
        /* set error code if DeviceMAP is invalid or data pointer is null */
        retVal = RL_RET_CODE_INVALID_INPUT;
        RL_LOGE_ARG0("rlDeviceGetContStreamingModeConfig, Invalid device map\n");
    }
    /* This API is valid only when mmWaveLink instance is running on
       External Host Processor */
    else if (RL_PLATFORM_HOST != rlDriverGetPlatformId())
    {
        /* set error code of Platform is not set to HOST */
        retVal = RL_RET_CODE_API_NOT_SUPPORTED;
    }
    else
    {
        /* Package the command with given data and send it to device */
        retVal = rlDriverExecuteGetApi(deviceMap, RL_DEV_CONFIG_GET_MSG,
                                        RL_DEV_RX_CONTSTREAMING_MODE_CONF_SET_SB,
                                        (rlUInt8_t*)data, 0U);
    }

    RL_LOGV_ARG0("rlDeviceGetContStreamingModeConfig ends...\n");
    return retVal;
}

/* DesignId : MMWL_DesignId_048 */
/* Requirements : AUTORADAR_REQ-756, AUTORADAR_REQ-766 */
rlReturnVal_t rlDeviceSetCsi2Config(rlUInt8_t deviceMap, rlDevCsi2Cfg_t* data)
{
    rlReturnVal_t retVal;

    RL_LOGV_ARG0("rlDeviceSetCsi2Config starts...\n");

    /* check if deviceIndex is out of defined value */
    if ((rlDriverIsDeviceMapValid(deviceMap) != RL_RET_CODE_OK) || \
        (RL_NULL_PTR == data))
    {
        /* set error code if DeviceMAP is invalid or data pointer is null */
        retVal = RL_RET_CODE_INVALID_INPUT;
        RL_LOGE_ARG0("Invalid input");
    }
    /* This API is valid only when mmWaveLink instance is running on
       External Host Processor */
    else if (RL_PLATFORM_HOST != rlDriverGetPlatformId())
    {
        /* set error code of Platform is not set to HOST */
        retVal = RL_RET_CODE_API_NOT_SUPPORTED;
    }
    else
    {
        /* Package the command with given data and send it to device */
        retVal = rlDriverExecuteSetApi(deviceMap, RL_DEV_CONFIG_SET_MSG,
                               RL_DEV_CSI2_CFG_SET_SB, (rlUInt8_t*)data,
                               (rlUInt16_t)sizeof(rlDevCsi2Cfg_t));
    }
    RL_LOGV_ARG0("rlDeviceSetCsi2Config ends...\n");

    return retVal;
}

/* DesignId : MMWL_DesignId_111 */
/* Requirements : AUTORADAR_REQ-756, AUTORADAR_REQ-766 */
rlReturnVal_t rlDeviceGetCsi2Config(rlUInt8_t deviceMap, rlDevCsi2Cfg_t* data)
{
    rlReturnVal_t retVal;

    RL_LOGV_ARG0("rlDeviceGetCsi2Config starts...\n");

    /* check if deviceIndex is out of defined value */
    if ((rlDriverIsDeviceMapValid(deviceMap) != RL_RET_CODE_OK) || \
        (RL_NULL_PTR == data))
    {
        /* set error code if DeviceMAP is invalid or data pointer is null */
        retVal = RL_RET_CODE_INVALID_INPUT;
        RL_LOGE_ARG0("rlDeviceGetCsi2Config, Invalid device map\n");
    }
    /* This API is valid only when mmWaveLink instance is running on
       External Host Processor */
    else if (RL_PLATFORM_HOST != rlDriverGetPlatformId())
    {
        /* set error code of Platform is not set to HOST */
        retVal = RL_RET_CODE_API_NOT_SUPPORTED;
    }
    else
    {
        /* Package the command with given data and send it to device */
        retVal = rlDriverExecuteGetApi(deviceMap, RL_DEV_CONFIG_GET_MSG,
                                        RL_DEV_CSI2_CFG_SET_SB,
                                        (rlUInt8_t*)data, 0U);
    }

    RL_LOGV_ARG0("rlDeviceGetCsi2Config ends...\n");
    return retVal;
}

/* DesignId : MMWL_DesignId_020 */
/* Requirements : AUTORADAR_REQ-756 */
rlReturnVal_t rlDeviceSetHsiConfig(rlUInt8_t deviceMap,
                                              rlDevHsiCfg_t* data )
{
    rlReturnVal_t retVal;
    /* Initialize Command and Response Sub Blocks */
    rlDriverMsg_t inMsg;
    rlDriverMsg_t outMsg = {0};
    rlUInt16_t sbcCnt = 0U;

    /* Initialize Command and Response Sub Blocks */
    rlPayloadSb_t inPayloadSb[3U] = {0};

    RL_LOGV_ARG0("rlDeviceSetHsiConfig starts...\n");

    /* check if deviceIndex is out of defined value */
    if ((rlDriverIsDeviceMapValid(deviceMap) != RL_RET_CODE_OK) || \
       (RL_NULL_PTR == data) )
    {
        /* set error code if DeviceMAP is invalid or data pointer is null */
        retVal = RL_RET_CODE_INVALID_INPUT;
        RL_LOGE_ARG0("rlDeviceSetHsiConfig, Invalid input \n");
    }
    else
    {
        /* Data Format config SubBlock */
        if (RL_NULL_PTR != data->datafmt)
        {
            /* Fill in-message Payload */
            rlDriverFillPayload(RL_DEV_CONFIG_SET_MSG,
                                RL_DEV_RX_DATA_FORMAT_CONF_SET_SB,
                                &inPayloadSb[sbcCnt],
                                (rlUInt8_t* )data->datafmt,
                                (rlUInt16_t)sizeof(rlDevDataFmtCfg_t));
            /* increament Sub-block count */
            sbcCnt++;
        }

        /* Data Path Config SubBlock */
        if (RL_NULL_PTR != data->dataPath)
        {
            /* Fill in-message Payload */
            rlDriverFillPayload(RL_DEV_CONFIG_SET_MSG,
                        RL_DEV_RX_DATA_PATH_CONF_SET_SB,
                        &inPayloadSb[sbcCnt],
                        (rlUInt8_t* )data->dataPath,
                        (rlUInt16_t)sizeof(rlDevDataPathCfg_t));
            /* increament Sub-block count */
            sbcCnt++;
        }

        /* Data Path clock Config SubBlock */
        if (RL_NULL_PTR != data->dataPathClk)
        {
            /* Fill in-message Payload */
            rlDriverFillPayload(RL_DEV_CONFIG_SET_MSG,
                        RL_DEV_DATA_PATH_CLOCK_SET_SB,
                        &inPayloadSb[sbcCnt],
                        (rlUInt8_t* )data->dataPathClk,
                        (rlUInt16_t)sizeof(rlDevDataPathClkCfg_t));
            /* increament Sub-block count */
            sbcCnt++;
        }

        /* Construct command packet */
        rlDriverConstructInMsg(RL_DEV_CONFIG_SET_MSG, &inMsg, &inPayloadSb[0U]);

        if (sbcCnt > 0U)
        {
            /* setting num of sub-block to inMsg */
            inMsg.opcode.nsbc = sbcCnt;

            /* Send Command to mmWave Radar Device */
            retVal = rlDriverCmdInvoke(deviceMap, inMsg, &outMsg);
        }
        else
        {
            /* set error code if application doesn't pass any subBlock data */
            retVal = RL_RET_CODE_INVALID_INPUT;
            RL_LOGE_ARG0("sub block is NULL\n");
        }
    }

    RL_LOGV_ARG0("rlDeviceSetHsiConfig ends...\n");

    return retVal;
}

/* DesignId : MMWL_DesignId_101 */
/* Requirements : AUTORADAR_REQ-765 */
rlReturnVal_t rlDeviceSetHsiClk(rlUInt8_t deviceMap, rlDevHsiClk_t* data)
{
    rlReturnVal_t retVal;

    RL_LOGV_ARG0("rlDeviceSetHsiClk starts...\n");

    /* check if deviceIndex is out of defined value */
    if ((rlDriverIsDeviceMapValid(deviceMap) != RL_RET_CODE_OK) || \
       (RL_NULL_PTR == data))
    {
        /* set error code if DeviceMAP is invalid or data pointer is null */
        retVal = RL_RET_CODE_INVALID_INPUT;
        RL_LOGE_ARG0("Invalid input\n");
    }
    else
    {
            /* Package the command with given data and send it to device */
        retVal = rlDriverExecuteSetApi(deviceMap, RL_RF_STATIC_CONF_SET_MSG,
                               RL_RF_HIGHSPEEDINTFCLK_CONF_SET_SB,
                               (rlUInt8_t*)data,
                               (rlUInt16_t)sizeof(rlDevHsiClk_t));
    }
    RL_LOGV_ARG0("rlDeviceSetHsiClk ends...\n");

    return retVal;
}

/* DesignId : MMWL_DesignId_069 */
/* Requirements : AUTORADAR_REQ-713 */
rlReturnVal_t rlDeviceMcuClkConfig(rlUInt8_t deviceMap, rlMcuClkCfg_t * data)
{
    rlReturnVal_t retVal;

    RL_LOGV_ARG0("rlDeviceMcuClkConfig starts...\n");

    /* check if deviceIndex is out of defined value */
    if ((rlDriverIsDeviceMapValid(deviceMap) != RL_RET_CODE_OK) || \
        (RL_NULL_PTR == data))
    {
        /* set error code if DeviceMAP is invalid or data pointer is null */
        retVal = RL_RET_CODE_INVALID_INPUT;
        RL_LOGE_ARG0("Invalid input");
    }
    /* This API is valid only when mmWaveLink instance is running on
    External Host Processor */
    else if (RL_PLATFORM_HOST != rlDriverGetPlatformId())
    {
        /* set error code of Platform is not set to HOST */
        retVal = RL_RET_CODE_API_NOT_SUPPORTED;
    }
    else
    {
        /* Package the command with given data and send it to device */
        retVal = rlDriverExecuteSetApi(deviceMap, RL_DEV_CONFIG_SET_MSG,
            RL_DEV_MCUCLOCK_CONF_SET_SB, (rlUInt8_t*)data,
            (rlUInt16_t)sizeof(rlMcuClkCfg_t));
    }
    RL_LOGV_ARG0("rlDeviceMcuClkConfig ends...\n");

    return retVal;
}

/* DesignId : MMWL_DesignId_070 */
/* Requirements : AUTORADAR_REQ-907 */
rlReturnVal_t rlDevicePmicClkConfig(rlUInt8_t deviceMap, rlPmicClkCfg_t * data)
{
    rlReturnVal_t retVal;

    RL_LOGV_ARG0("rlDevicePmicClkConfig starts...\n");

    /* check if deviceIndex is out of defined value */
    if ((rlDriverIsDeviceMapValid(deviceMap) != RL_RET_CODE_OK) || \
        (RL_NULL_PTR == data))
    {
        /* set error code if DeviceMAP is invalid or data pointer is null */
        retVal = RL_RET_CODE_INVALID_INPUT;
        RL_LOGE_ARG0("Invalid input");
    }
    /* This API is valid only when mmWaveLink instance is running on
    External Host Processor */
    else if (RL_PLATFORM_HOST != rlDriverGetPlatformId())
    {
        /* set error code of Platform is not set to HOST */
        retVal = RL_RET_CODE_API_NOT_SUPPORTED;
    }
    else
    {
        /* Package the command with given data and send it to device */
        retVal = rlDriverExecuteSetApi(deviceMap, RL_DEV_CONFIG_SET_MSG,
            RL_DEV_PMICCLOCK_CONF_SET_SB, (rlUInt8_t*)data,
            (rlUInt16_t)sizeof(rlPmicClkCfg_t));
    }
    RL_LOGV_ARG0("rlDevicePmicClkConfig ends...\n");

    return retVal;
}

/* DesignId : MMWL_DesignId_071 */
/* Requirements : AUTORADAR_REQ-908 */
rlReturnVal_t rlDeviceLatentFaultTests(rlUInt8_t deviceMap, rllatentFault_t * data)
{
    rlReturnVal_t retVal;

    RL_LOGV_ARG0("rlDeviceLatentFaultTests starts...\n");

    /* check if deviceIndex is out of defined value */
    if ((rlDriverIsDeviceMapValid(deviceMap) != RL_RET_CODE_OK) || \
        (RL_NULL_PTR == data))
    {
        /* set error code if DeviceMAP is invalid or data pointer is null */
        retVal = RL_RET_CODE_INVALID_INPUT;
        RL_LOGE_ARG0("Invalid input");
    }
    /* This API is valid only when mmWaveLink instance is running on
    External Host Processor */
    else if (RL_PLATFORM_HOST != rlDriverGetPlatformId())
    {
        /* set error code of Platform is not set to HOST */
        retVal = RL_RET_CODE_API_NOT_SUPPORTED;
    }
    else
    {
        /* Package the command with given data and send it to device */
        retVal = rlDriverExecuteSetApi(deviceMap, RL_DEV_CONFIG_SET_MSG,
            RL_DEV_LATENTFAULT_TEST_CONF_SB, (rlUInt8_t*)data,
            (rlUInt16_t)sizeof(rllatentFault_t));
    }
    RL_LOGV_ARG0("rlDeviceLatentFaultTests ends...\n");

    return retVal;
}

/* DesignId : MMWL_DesignId_072 */
/* Requirements : AUTORADAR_REQ-909 */
rlReturnVal_t rlDeviceEnablePeriodicTests(rlUInt8_t deviceMap, rlperiodicTest_t * data)
{
    rlReturnVal_t retVal;

    RL_LOGV_ARG0("rlDeviceEnablePeriodicTests starts...\n");

    /* check if deviceIndex is out of defined value */
    if ((rlDriverIsDeviceMapValid(deviceMap) != RL_RET_CODE_OK) || \
        (RL_NULL_PTR == data))
    {
        /* set error code if DeviceMAP is invalid or data pointer is null */
        retVal = RL_RET_CODE_INVALID_INPUT;
        RL_LOGE_ARG0("Invalid input");
    }
    /* This API is valid only when mmWaveLink instance is running on
    External Host Processor */
    else if (RL_PLATFORM_HOST != rlDriverGetPlatformId())
    {
        /* set error code of Platform is not set to HOST */
        retVal = RL_RET_CODE_API_NOT_SUPPORTED;
    }
    else
    {
        /* Package the command with given data and send it to device */
        retVal = rlDriverExecuteSetApi(deviceMap, RL_DEV_CONFIG_SET_MSG,
            RL_DEV_PERIODICTESTS_CONF_SB, (rlUInt8_t*)data,
            (rlUInt16_t)sizeof(rlperiodicTest_t));
    }
    RL_LOGV_ARG0("rlDeviceEnablePeriodicTests ends...\n");

    return retVal;
}

/* DesignId : MMWL_DesignId_103 */
/* Requirements : AUTORADAR_REQ-910 */
rlReturnVal_t rlDeviceSetTestPatternConfig(rlUInt8_t deviceMap, rltestPattern_t * data)
{
    rlReturnVal_t retVal;

    RL_LOGV_ARG0("rlDeviceSetTestPatternConfig starts...\n");

    /* check if deviceIndex is out of defined value */
    if ((rlDriverIsDeviceMapValid(deviceMap) != RL_RET_CODE_OK) || \
        (RL_NULL_PTR == data))
    {
        /* set error code if DeviceMAP is invalid or data pointer is null */
        retVal = RL_RET_CODE_INVALID_INPUT;
        RL_LOGE_ARG0("Invalid input");
    }
    /* This API is valid only when mmWaveLink instance is running on
    External Host Processor */
    else if (RL_PLATFORM_HOST != rlDriverGetPlatformId())
    {
        /* set error code of Platform is not set to HOST */
        retVal = RL_RET_CODE_API_NOT_SUPPORTED;
    }
    else
    {
        /* Package the command with given data and send it to device */
        retVal = rlDriverExecuteSetApi(deviceMap, RL_DEV_CONFIG_SET_MSG,
                                        RL_DEV_TESTPATTERN_GEN_SET_SB, (rlUInt8_t*)data,
                                        (rlUInt16_t)sizeof(rltestPattern_t));
    }
    RL_LOGV_ARG0("rlDeviceSetTestPatternConfig ends...\n");

    return retVal;
}

/* DesignId : MMWL_DesignId_117 */
/* Requirements : AUTORADAR_REQ-886 */
rlReturnVal_t rlDeviceSetMiscConfig(rlUInt8_t deviceMap, rlDevMiscCfg_t *data)
{
    rlReturnVal_t retVal;

    RL_LOGV_ARG0("rlDeviceSetMiscConfig starts...\n");

    /* check if deviceIndex is out of defined value */
    if ((rlDriverIsDeviceMapValid(deviceMap) != RL_RET_CODE_OK) || \
        (RL_NULL_PTR == data))
    {
        /* set error code if DeviceMAP is invalid or data pointer is null */
        retVal = RL_RET_CODE_INVALID_INPUT;
        RL_LOGE_ARG0("Invalid input");
    }
    /* This API is valid only when mmWaveLink instance is running on
    External Host Processor */
    else if (RL_PLATFORM_HOST != rlDriverGetPlatformId())
    {
        /* set error code of Platform is not set to HOST */
        retVal = RL_RET_CODE_API_NOT_SUPPORTED;
    }
    else
    {
        /* Package the command with given data and send it to device */
        retVal = rlDriverExecuteSetApi(deviceMap, RL_DEV_CONFIG_SET_MSG,
                                       RL_DEV_MISC_CFG_SET_SB, (rlUInt8_t*)data,
                                       (rlUInt16_t)sizeof(rlDevMiscCfg_t));
    }
    RL_LOGV_ARG0("rlDeviceSetMiscConfig ends...\n");

    return retVal;
}

/* DesignId : MMWL_DesignId_028 */
/* Requirements : AUTORADAR_REQ-710 */
rlReturnVal_t rlDeviceConfigureCrc(rlCrcType_t crcType)
{
    /* set CRC Type passed by application to rlDriver */
    return rlDriverConfigureCrc(crcType);
}

/* DesignId : MMWL_DesignId_028 */
/* Requirements : AUTORADAR_REQ_710 */
rlReturnVal_t rlDeviceConfigureAckTimeout(rlUInt32_t ackTimeout)
{
    /* Set Ack Timeout value passed by applicatio to rlDriver */
    return rlDriverConfigureAckTimeout(ackTimeout);
}

/*
 * END OF rl_device.c FILE
 */