m2m_wifi.c

Go to the documentation of this file.

#include "driver/include/m2m_wifi.h"
#include "driver/source/m2m_hif.h"
#include "driver/source/nmasic.h"

#include "ISConstants.h"
#define malloc  MALLOC
#define free    FREE

static volatile uint8 gu8ChNum;
static tpfAppWifiCb gpfAppWifiCb = NULL;


#ifdef ETH_MODE
static tpfAppEthCb  gpfAppEthCb  = NULL;
static uint8*           gau8ethRcvBuf=NULL;
static uint16           gu16ethRcvBufSize ;
#endif

//#define CONF_MGMT

#ifdef CONF_MGMT
static tpfAppMonCb  gpfAppMonCb  = NULL;
static struct _tstrMgmtCtrl
{
        uint8* pu8Buf;
        uint16 u16Offset;
        uint16 u16Sz;
}
gstrMgmtCtrl = {NULL, 0 , 0};
#endif

static void m2m_wifi_cb(uint8 u8OpCode, uint16 u16DataSize, uint32 u32Addr)
{
        uint8 rx_buf[8];
        if (u8OpCode == M2M_WIFI_RESP_CON_STATE_CHANGED)
        {
                tstrM2mWifiStateChanged strState;
                if (hif_receive(u32Addr, (uint8*) &strState,sizeof(tstrM2mWifiStateChanged), 0) == M2M_SUCCESS)
                {
                        if (gpfAppWifiCb)
                                gpfAppWifiCb(M2M_WIFI_RESP_CON_STATE_CHANGED, &strState);
                }
        }
        else if (u8OpCode == M2M_WIFI_RESP_GET_SYS_TIME)
        {
                tstrSystemTime strSysTime;
                if (hif_receive(u32Addr, (uint8*) &strSysTime,sizeof(tstrSystemTime), 0) == M2M_SUCCESS)
                {
                        if (gpfAppWifiCb)
                                gpfAppWifiCb(M2M_WIFI_RESP_GET_SYS_TIME, &strSysTime);
                }
        }
        else if(u8OpCode == M2M_WIFI_RESP_CONN_INFO)
        {
                tstrM2MConnInfo         strConnInfo;
                if(hif_receive(u32Addr, (uint8*)&strConnInfo, sizeof(tstrM2MConnInfo), 1) == M2M_SUCCESS)
                {
                        if(gpfAppWifiCb)
                                gpfAppWifiCb(M2M_WIFI_RESP_CONN_INFO, &strConnInfo);
                }
        }
        else if (u8OpCode == M2M_WIFI_RESP_MEMORY_RECOVER)
        {
#if 0
                if (hif_receive(u32Addr, rx_buf, 4, 1) == M2M_SUCCESS)
                {
                        tstrM2mWifiStateChanged strState;
                        m2m_memcpy((uint8*) &strState, rx_buf,sizeof(tstrM2mWifiStateChanged));
                        if (app_wifi_recover_cb)
                                app_wifi_recover_cb(strState.u8CurrState);
                }
#endif
        }
        else if (u8OpCode == M2M_WIFI_REQ_DHCP_CONF)
        {
                tstrM2MIPConfig strIpConfig;
                if (hif_receive(u32Addr, (uint8 *)&strIpConfig, sizeof(tstrM2MIPConfig), 0) == M2M_SUCCESS)
                {
                        if (gpfAppWifiCb)
                                gpfAppWifiCb(M2M_WIFI_REQ_DHCP_CONF, (uint8 *)&strIpConfig);
                }
        }
        else if (u8OpCode == M2M_WIFI_REQ_WPS)
        {
                tstrM2MWPSInfo strWps;
                m2m_memset((uint8*)&strWps,0,sizeof(tstrM2MWPSInfo));
                if(hif_receive(u32Addr, (uint8*)&strWps, sizeof(tstrM2MWPSInfo), 0) == M2M_SUCCESS)
                {
                        if (gpfAppWifiCb)
                                gpfAppWifiCb(M2M_WIFI_REQ_WPS, &strWps);
                }
        }   
        else if (u8OpCode == M2M_WIFI_RESP_IP_CONFLICT)
        {
                uint32  u32ConflictedIP;
                if(hif_receive(u32Addr, (uint8 *)&u32ConflictedIP, sizeof(u32ConflictedIP), 0) == M2M_SUCCESS)
                {
                        M2M_INFO("Conflicted IP \" %u.%u.%u.%u \" \n", 
                                BYTE_0(u32ConflictedIP),BYTE_1(u32ConflictedIP),BYTE_2(u32ConflictedIP),BYTE_3(u32ConflictedIP));
                        if (gpfAppWifiCb)
                                gpfAppWifiCb(M2M_WIFI_RESP_IP_CONFLICT, NULL);

                }
        }
        else if (u8OpCode == M2M_WIFI_RESP_SCAN_DONE)
        {
                tstrM2mScanDone strState;
                if(hif_receive(u32Addr, (uint8*)&strState, sizeof(tstrM2mScanDone), 0) == M2M_SUCCESS)
                {
                        gu8ChNum = strState.u8NumofCh;
                        if (gpfAppWifiCb)
                                gpfAppWifiCb(M2M_WIFI_RESP_SCAN_DONE, &strState);
                }
        }
        else if (u8OpCode == M2M_WIFI_RESP_SCAN_RESULT)
        {
                tstrM2mWifiscanResult strScanResult;
                if(hif_receive(u32Addr, (uint8*)&strScanResult, sizeof(tstrM2mWifiscanResult), 0) == M2M_SUCCESS)
                {
                        if (gpfAppWifiCb)
                                gpfAppWifiCb(M2M_WIFI_RESP_SCAN_RESULT, &strScanResult);
                }
        }
        else if (u8OpCode == M2M_WIFI_RESP_CURRENT_RSSI)
        {
                if (hif_receive(u32Addr, rx_buf, 4, 0) == M2M_SUCCESS)
                {
                        if (gpfAppWifiCb)
                                gpfAppWifiCb(M2M_WIFI_RESP_CURRENT_RSSI, rx_buf);
                }
        }
        else if (u8OpCode == M2M_WIFI_RESP_CLIENT_INFO)
        {
                if (hif_receive(u32Addr, rx_buf, 4, 0) == M2M_SUCCESS)
                {
                        if (gpfAppWifiCb)
                                gpfAppWifiCb(M2M_WIFI_RESP_CLIENT_INFO, rx_buf);
                }
        }
        else if(u8OpCode == M2M_WIFI_RESP_PROVISION_INFO)
        {
                tstrM2MProvisionInfo    strProvInfo;
                if(hif_receive(u32Addr, (uint8*)&strProvInfo, sizeof(tstrM2MProvisionInfo), 1) == M2M_SUCCESS)
                {
                        if(gpfAppWifiCb)
                                gpfAppWifiCb(M2M_WIFI_RESP_PROVISION_INFO, &strProvInfo);
                }
        }
        else if(u8OpCode == M2M_WIFI_RESP_DEFAULT_CONNECT)
        {
                tstrM2MDefaultConnResp  strResp;
                if(hif_receive(u32Addr, (uint8*)&strResp, sizeof(tstrM2MDefaultConnResp), 1) == M2M_SUCCESS)
                {
                        if(gpfAppWifiCb)
                                gpfAppWifiCb(M2M_WIFI_RESP_DEFAULT_CONNECT, &strResp);
                }
        }
        else if (u8OpCode == M2M_WIFI_RESP_BLE_API_RECV)
        {
                //Read the length
                if(hif_receive(u32Addr, rx_buf, 2, 0) == M2M_SUCCESS)
                {
                        uint16 u16BleMsgLen = (rx_buf[1] << 8) + rx_buf[0];                     
                        tstrM2mBleApiMsg* bleRx = (tstrM2mBleApiMsg*)malloc(u16BleMsgLen + sizeof(tstrM2mBleApiMsg));
                        
                        if(bleRx != NULL)
                        {
                                bleRx->u16Len = u16BleMsgLen;
                                
                                //Read the rest of the message
                                if (hif_receive(u32Addr+2, bleRx->data, bleRx->u16Len, 1)== M2M_SUCCESS)
                                {
                                        if(gpfAppWifiCb)
                                                gpfAppWifiCb(M2M_WIFI_RESP_BLE_API_RECV, bleRx);
                                }
                                free(bleRx);
                        }
                }
        }
        else if(u8OpCode == M2M_WIFI_RESP_GET_PRNG)
        {
                tstrPrng strPrng;
                if(hif_receive(u32Addr, (uint8*)&strPrng,sizeof(tstrPrng), 0) == M2M_SUCCESS)
                {
                        if(hif_receive(u32Addr + sizeof(tstrPrng),strPrng.pu8RngBuff,strPrng.u16PrngSize, 1) == M2M_SUCCESS)
                        {
                                if(gpfAppWifiCb) {
                                        gpfAppWifiCb(M2M_WIFI_RESP_GET_PRNG,&strPrng);
                                }
                        }
                }
        }
        else if (u8OpCode == M2M_WIFI_RESP_SET_GAIN_TABLE)
        {
                tstrM2MGainTableRsp strGainRsp;
                if (hif_receive(u32Addr, (uint8*) &strGainRsp,sizeof(tstrM2MGainTableRsp), 0) == M2M_SUCCESS)
                {
                        if (gpfAppWifiCb)
                                gpfAppWifiCb(M2M_WIFI_RESP_SET_GAIN_TABLE, &strGainRsp);
                }
        }
#ifdef ETH_MODE
                else if(u8OpCode == M2M_WIFI_RESP_ETHERNET_RX_PACKET)
                {
                        if(hif_receive(u32Addr, rx_buf ,sizeof(tstrM2mIpRsvdPkt), 0) == M2M_SUCCESS)
                        {
                                tstrM2mIpRsvdPkt * pstrM2MIpRxPkt = (tstrM2mIpRsvdPkt*)rx_buf;
                                tstrM2mIpCtrlBuf  strM2mIpCtrlBuf;
                                uint16 u16Offset = pstrM2MIpRxPkt->u16PktOffset;
                                
                                strM2mIpCtrlBuf.u16RemainigDataSize = pstrM2MIpRxPkt->u16PktSz;
                                if((gpfAppEthCb) &&(gau8ethRcvBuf)&& (gu16ethRcvBufSize > 0))
                                {
                                        while (strM2mIpCtrlBuf.u16RemainigDataSize > 0)
                                        {
                                                if(strM2mIpCtrlBuf.u16RemainigDataSize > gu16ethRcvBufSize)
                                                {
                                                        strM2mIpCtrlBuf.u16DataSize = gu16ethRcvBufSize ;
                                                }
                                                else
                                                {
                                                        strM2mIpCtrlBuf.u16DataSize = strM2mIpCtrlBuf.u16RemainigDataSize;
                                                }
                                                if(hif_receive(u32Addr+u16Offset, gau8ethRcvBuf, strM2mIpCtrlBuf.u16DataSize, 0) == M2M_SUCCESS)
                                                {
                                                        strM2mIpCtrlBuf.u16RemainigDataSize -= strM2mIpCtrlBuf.u16DataSize;
                                                        u16Offset += strM2mIpCtrlBuf.u16DataSize;
                                                        gpfAppEthCb(M2M_WIFI_RESP_ETHERNET_RX_PACKET, gau8ethRcvBuf, &(strM2mIpCtrlBuf));
                                                }
                                                else
                                                {
                                                        break;
                                                }
                                        }
                                }
                        }
                }
#endif  

#ifdef CONF_MGMT
        else if(u8OpCode == M2M_WIFI_RESP_WIFI_RX_PACKET)
        {
                tstrM2MWifiRxPacketInfo         strRxPacketInfo;
                if(u16DataSize >= sizeof(tstrM2MWifiRxPacketInfo)) {
                        if(hif_receive(u32Addr, (uint8*)&strRxPacketInfo, sizeof(tstrM2MWifiRxPacketInfo), 0) == M2M_SUCCESS)
                        {
                                u16DataSize -= sizeof(tstrM2MWifiRxPacketInfo);
                                if(u16DataSize > 0 && gstrMgmtCtrl.pu8Buf != NULL)
                                {
                                        if(u16DataSize > (gstrMgmtCtrl.u16Sz + gstrMgmtCtrl.u16Offset))
                                        {
                                                u16DataSize = gstrMgmtCtrl.u16Sz;
                                        }
                                        u32Addr += sizeof(tstrM2MWifiRxPacketInfo) + gstrMgmtCtrl.u16Offset;
                                        if(hif_receive(u32Addr , gstrMgmtCtrl.pu8Buf, u16DataSize, 1) != M2M_SUCCESS)
                                        {
                                                u16DataSize = 0;
                                        }
                                }
                                if(gpfAppMonCb)
                                        gpfAppMonCb(&strRxPacketInfo, gstrMgmtCtrl.pu8Buf,u16DataSize);
                        }
                } else {
                        M2M_ERR("Incorrect mon data size %u\n", u16DataSize);
                }
        }
#endif
        else
        {
                M2M_ERR("REQ Not defined %d\n",u8OpCode);
        }
}

sint8 m2m_wifi_download_mode()
{
        sint8 ret = M2M_SUCCESS;
        /* Apply device specific initialization. */
        ret = nm_drv_init_download_mode(0);
        if(ret != M2M_SUCCESS)  goto _EXIT0;
        

        
        enable_interrupts();

_EXIT0:
        return ret;
}

static sint8 m2m_validate_ap_parameters(CONST tstrM2MAPConfig* pstrM2MAPConfig)
{
        sint8 s8Ret = M2M_SUCCESS;
        /* Check for incoming pointer */
        if(pstrM2MAPConfig == NULL)
        {
                M2M_ERR("INVALID POINTER\n");
                s8Ret = M2M_ERR_FAIL;
                goto ERR1;
        }
        /* Check for SSID */
        if((m2m_strlen((uint8 *)pstrM2MAPConfig->au8SSID) <= 0) || (m2m_strlen((uint8 *)pstrM2MAPConfig->au8SSID) >= M2M_MAX_SSID_LEN))
        {
                M2M_ERR("INVALID SSID\n");
                s8Ret = M2M_ERR_FAIL;
                goto ERR1;
        }
        /* Check for Channel */
        if(pstrM2MAPConfig->u8ListenChannel > M2M_WIFI_CH_14 || pstrM2MAPConfig->u8ListenChannel < M2M_WIFI_CH_1)
        {
                M2M_ERR("INVALID CH\n");
                s8Ret = M2M_ERR_FAIL;
                goto ERR1;
        }
        /* Check for DHCP Server IP address */
        if(!(pstrM2MAPConfig->au8DHCPServerIP[0] || pstrM2MAPConfig->au8DHCPServerIP[1]))
        {
                if(!(pstrM2MAPConfig->au8DHCPServerIP[2]))
                {
                        M2M_ERR("INVALID DHCP SERVER IP\n");
                        s8Ret = M2M_ERR_FAIL;
                        goto ERR1;
                }
        }
        /* Check for Security */
        if(pstrM2MAPConfig->u8SecType == M2M_WIFI_SEC_OPEN)
        {
                goto ERR1;
        }
        else if(pstrM2MAPConfig->u8SecType == M2M_WIFI_SEC_WEP)
        {
                /* Check for WEP Key index */
                if((pstrM2MAPConfig->u8KeyIndx <= 0) || (pstrM2MAPConfig->u8KeyIndx > WEP_KEY_MAX_INDEX))
                {
                        M2M_ERR("INVALID KEY INDEX\n");
                        s8Ret = M2M_ERR_FAIL;
                        goto ERR1;
                }
                /* Check for WEP Key size */
                if(     (pstrM2MAPConfig->u8KeySz != WEP_40_KEY_STRING_SIZE) &&
                        (pstrM2MAPConfig->u8KeySz != WEP_104_KEY_STRING_SIZE)
                )
                {
                        M2M_ERR("INVALID KEY SIZE\n");
                        s8Ret = M2M_ERR_FAIL;
                        goto ERR1;
                }
                /* Check for WEP Key */
                if((pstrM2MAPConfig->au8WepKey == NULL) || (m2m_strlen((uint8 *)pstrM2MAPConfig->au8WepKey) <= 0) || (m2m_strlen((uint8 *)pstrM2MAPConfig->au8WepKey) > WEP_104_KEY_STRING_SIZE))
                {
                        M2M_ERR("INVALID WEP KEY\n");
                        s8Ret = M2M_ERR_FAIL;
                        goto ERR1;
                }
        }
        else
        {
                M2M_ERR("INVALID AUTHENTICATION MODE\n");
                s8Ret = M2M_ERR_FAIL;
                goto ERR1;
        }
        
ERR1:
        return s8Ret;
}
static sint8 m2m_validate_scan_options(tstrM2MScanOption* ptstrM2MScanOption)
{
        sint8 s8Ret = M2M_SUCCESS;
        /* Check for incoming pointer */
        if(ptstrM2MScanOption == NULL)
        {
                M2M_ERR("INVALID POINTER\n");
                s8Ret = M2M_ERR_FAIL;
        }
        else
        {
                /* Check for valid No of slots */
                 if(ptstrM2MScanOption->u8NumOfSlot == 0)
                {
                        M2M_ERR("INVALID No of scan slots!\n");
                        s8Ret = M2M_ERR_FAIL;
                }       
                /* Check for valid time of slots */
                 if((ptstrM2MScanOption->u8SlotTime < 10) || (ptstrM2MScanOption->u8SlotTime > 250))
                {
                        M2M_ERR("INVALID scan slot time!\n");
                        s8Ret = M2M_ERR_FAIL;
                }       
                /* Check for valid No of probe requests per slot */
                 if((ptstrM2MScanOption->u8ProbesPerSlot == 0) || (ptstrM2MScanOption->u8ProbesPerSlot > M2M_SCAN_DEFAULT_NUM_PROBE))
                {
                        M2M_ERR("INVALID No of probe requests per scan slot\n");
                        s8Ret = M2M_ERR_FAIL;
                }       
                /* Check for valid RSSI threshold */
                 if(ptstrM2MScanOption->s8RssiThresh >= 0)
                {
                        M2M_ERR("INVALID RSSI threshold %d \n",ptstrM2MScanOption->s8RssiThresh);
                        s8Ret = M2M_ERR_FAIL;
                }       
        }
        return s8Ret;
}

NMI_API sint8 m2m_wifi_ble_set_gain_table(uint8 table_idx)
{
        sint8 s8Ret = M2M_ERR_FAIL;
        tstrM2MGainTable strGainTable = {0};
        
        strGainTable.u8GainTable = table_idx;
        
        s8Ret = hif_send(M2M_REQ_GROUP_WIFI, M2M_WIFI_REQ_SET_GAIN_TABLE, (uint8 *)&strGainTable, sizeof(tstrM2MGainTable), NULL, 0, 0);
        return s8Ret;
}


sint8 m2m_wifi_init_hold(void)
{
        sint8 ret = M2M_ERR_FAIL;

        /* Apply device specific initialization. */
        ret = nm_drv_init_hold(0);

        return ret;
}
sint8 m2m_wifi_init_start(tstrWifiInitParam * param)
{
        tstrM2mRev strtmp;
        sint8 ret = M2M_SUCCESS;
        
        if(param == NULL) {
                ret = M2M_ERR_FAIL;
                goto _EXIT0;
        }
        
        gpfAppWifiCb = param->pfAppWifiCb;
                
#ifdef ETH_MODE
        gpfAppEthCb         = param->strEthInitParam.pfAppEthCb;
        gau8ethRcvBuf       = param->strEthInitParam.au8ethRcvBuf;
        gu16ethRcvBufSize       = param->strEthInitParam.u16ethRcvBufSize;
#endif

#ifdef CONF_MGMT
        gpfAppMonCb  = param->pfAppMonCb;
#endif

        /* Apply device specific initialization. */
        ret = nm_drv_init_start(NULL);
        if(ret != M2M_SUCCESS)  goto _EXIT0;
        /* Initialize host interface module */
        ret = hif_init(NULL);
        if(ret != M2M_SUCCESS)  goto _EXIT1;

        hif_register_cb(M2M_REQ_GROUP_WIFI,m2m_wifi_cb);

        M2M_INFO("Curr driver ver: %u.%u.%u\n", M2M_DRIVER_VERSION_MAJOR_NO, M2M_DRIVER_VERSION_MINOR_NO, M2M_DRIVER_VERSION_PATCH_NO);
        M2M_INFO("Curr driver HIF Level: (%u) %u.%u\n", M2M_HIF_BLOCK_VALUE, M2M_HIF_MAJOR_VALUE, M2M_HIF_MINOR_VALUE);
        ret = m2m_wifi_get_firmware_version(&strtmp);
        m2m_ota_get_firmware_version(&strtmp);

        if(ret == M2M_SUCCESS)
        {
                ret = hif_enable_access();
                if(ret == M2M_SUCCESS)
                {
                        m2m_wifi_ble_set_gain_table(param->GainTableIndex);
                }
        }
        goto _EXIT0;

_EXIT1:
        nm_drv_deinit(NULL);
_EXIT0:
        return ret;
}
sint8 m2m_wifi_init(tstrWifiInitParam * param)
{
        sint8 ret = M2M_SUCCESS;

        ret = m2m_wifi_init_hold();
        if (ret == M2M_SUCCESS)
        {
                ret = m2m_wifi_init_start(param);
        }
        return ret;
}
sint8  m2m_wifi_deinit(void * arg)
{

        hif_deinit(NULL);

        nm_drv_deinit(NULL);

        return M2M_SUCCESS;
}
sint8 m2m_wifi_reinit_hold(void)
{
        m2m_wifi_deinit(NULL);
        return m2m_wifi_init_hold();
}
sint8 m2m_wifi_reinit_start(tstrWifiInitParam * param)
{
        return m2m_wifi_init_start(param);
}
sint8 m2m_wifi_reinit(tstrWifiInitParam * param)
{
        sint8 ret = M2M_ERR_FAIL;
        ret = m2m_wifi_reinit_hold();
        if(ret == M2M_SUCCESS) {
                ret = m2m_wifi_reinit_start(param);
        }
        return ret;
}

void m2m_wifi_yield(void)
{
        hif_yield();
}

sint8 m2m_wifi_handle_events(void * arg)
{
        return hif_handle_isr();
}

sint8 m2m_wifi_default_connect(void)
{
        return hif_send(M2M_REQ_GROUP_WIFI, M2M_WIFI_REQ_DEFAULT_CONNECT, NULL, 0,NULL, 0,0);
}

sint8 m2m_wifi_connect(char *pcSsid, uint8 u8SsidLen, uint8 u8SecType, void *pvAuthInfo, uint16 u16Ch)
{
        return m2m_wifi_connect_sc(pcSsid, u8SsidLen, u8SecType, pvAuthInfo,  u16Ch,0);
}
sint8 m2m_wifi_connect_sc(char *pcSsid, uint8 u8SsidLen, uint8 u8SecType, void *pvAuthInfo, uint16 u16Ch, uint8 u8NoSaveCred)
{
        sint8                           ret = M2M_SUCCESS;
        tstrM2mWifiConnect      strConnect;
        tstrM2MWifiSecInfo      *pstrAuthInfo;

        if(u8SecType != M2M_WIFI_SEC_OPEN)
        {
                if(pvAuthInfo == NULL)
                {
                        M2M_ERR("Key is not valid\n");
                        ret = M2M_ERR_FAIL;
                        goto ERR1;
                }
                if((u8SecType == M2M_WIFI_SEC_WPA_PSK) && (m2m_strlen(pvAuthInfo) == (M2M_MAX_PSK_LEN-1)))
                {
                        uint8 i = 0;
                        uint8* pu8Psk = (uint8*)pvAuthInfo;
                        while(i < (M2M_MAX_PSK_LEN-1))
                        {
                                if(pu8Psk[i]<'0' || (pu8Psk[i]>'9' && pu8Psk[i] < 'A')|| (pu8Psk[i]>'F' && pu8Psk[i] < 'a') || pu8Psk[i] > 'f')
                                {
                                        M2M_ERR("Invalid Key\n");
                                        ret = M2M_ERR_FAIL;
                                        goto ERR1;
                                }
                                i++;
                        }
                }
        }
        if((u8SsidLen<=0)||(u8SsidLen>=M2M_MAX_SSID_LEN))
        {
                M2M_ERR("SSID LEN INVALID\n");
                ret = M2M_ERR_FAIL;
                goto ERR1;
        }

        if(u16Ch < M2M_WIFI_CH_1 || u16Ch > M2M_WIFI_CH_14)
        {
                if(u16Ch!=M2M_WIFI_CH_ALL)
                {
                        M2M_ERR("CH INVALID\n");
                        ret = M2M_ERR_FAIL;
                        goto ERR1;
                }
        }

        m2m_memcpy(strConnect.au8SSID, (uint8*)pcSsid, u8SsidLen);
        strConnect.au8SSID[u8SsidLen]   = 0;
        strConnect.u16Ch                                = NM_BSP_B_L_16(u16Ch);
        /* Credentials will be Not be saved if u8NoSaveCred is set */ 
        strConnect.u8NoSaveCred                         = u8NoSaveCred ? 1:0;
        pstrAuthInfo = &strConnect.strSec;
        pstrAuthInfo->u8SecType         = u8SecType;

        if(u8SecType == M2M_WIFI_SEC_WEP)
        {
                tstrM2mWifiWepParams    * pstrWepParams = (tstrM2mWifiWepParams*)pvAuthInfo;
                tstrM2mWifiWepParams    *pstrWep = &pstrAuthInfo->uniAuth.strWepInfo;
                pstrWep->u8KeyIndx =pstrWepParams->u8KeyIndx-1;

                if(pstrWep->u8KeyIndx >= WEP_KEY_MAX_INDEX)
                {
                        M2M_ERR("Invalid Wep key index %d\n", pstrWep->u8KeyIndx);
                        ret = M2M_ERR_FAIL;
                        goto ERR1;
                }
                pstrWep->u8KeySz = pstrWepParams->u8KeySz-1;
                if ((pstrWep->u8KeySz != WEP_40_KEY_STRING_SIZE)&& (pstrWep->u8KeySz != WEP_104_KEY_STRING_SIZE))
                {
                        M2M_ERR("Invalid Wep key length %d\n", pstrWep->u8KeySz);
                        ret = M2M_ERR_FAIL;
                        goto ERR1;
                }
                m2m_memcpy((uint8*)pstrWep->au8WepKey,(uint8*)pstrWepParams->au8WepKey, pstrWepParams->u8KeySz);
                pstrWep->au8WepKey[pstrWepParams->u8KeySz] = 0;

        }


        else if(u8SecType == M2M_WIFI_SEC_WPA_PSK)
        {
                uint16  u16KeyLen = m2m_strlen((uint8*)pvAuthInfo);
                if((u16KeyLen <= 0)||(u16KeyLen >= M2M_MAX_PSK_LEN))
                {
                        M2M_ERR("Incorrect PSK key length\n");
                        ret = M2M_ERR_FAIL;
                        goto ERR1;
        }
                m2m_memcpy(pstrAuthInfo->uniAuth.au8PSK, (uint8*)pvAuthInfo, u16KeyLen + 1);
        }
        else if(u8SecType == M2M_WIFI_SEC_802_1X)
        {
                m2m_memcpy((uint8*)&pstrAuthInfo->uniAuth.strCred1x, (uint8*)pvAuthInfo, sizeof(tstr1xAuthCredentials));
        }
        else if(u8SecType == M2M_WIFI_SEC_OPEN)
        {

        }
        else
        {
                M2M_ERR("undefined sec type\n");
                ret = M2M_ERR_FAIL;
                goto ERR1;
        }

        ret = hif_send(M2M_REQ_GROUP_WIFI, M2M_WIFI_REQ_CONNECT, (uint8*)&strConnect, sizeof(tstrM2mWifiConnect),NULL, 0,0);

ERR1:
        return ret;
}

sint8 m2m_wifi_disconnect(void)
{
        return hif_send(M2M_REQ_GROUP_WIFI, M2M_WIFI_REQ_DISCONNECT, NULL, 0, NULL, 0,0);
}
sint8 m2m_wifi_set_mac_address(uint8 au8MacAddress[6])
{
        tstrM2mSetMacAddress strTmp;
        m2m_memcpy((uint8*) strTmp.au8Mac, (uint8*) au8MacAddress, 6);
        return hif_send(M2M_REQ_GROUP_WIFI, M2M_WIFI_REQ_SET_MAC_ADDRESS,
                (uint8*) &strTmp, sizeof(tstrM2mSetMacAddress), NULL, 0,0);
}

sint8 m2m_wifi_set_static_ip(tstrM2MIPConfig * pstrStaticIPConf)
{
        pstrStaticIPConf->u32DNS = NM_BSP_B_L_32(pstrStaticIPConf->u32DNS);
        pstrStaticIPConf->u32Gateway = NM_BSP_B_L_32(pstrStaticIPConf->u32Gateway);
        pstrStaticIPConf->u32StaticIP = NM_BSP_B_L_32(
                pstrStaticIPConf->u32StaticIP);
        pstrStaticIPConf->u32SubnetMask = NM_BSP_B_L_32(
                pstrStaticIPConf->u32SubnetMask);
        return hif_send(M2M_REQ_GROUP_IP, M2M_IP_REQ_STATIC_IP_CONF,
                (uint8*) pstrStaticIPConf, sizeof(tstrM2MIPConfig), NULL, 0,0);
}

sint8 m2m_wifi_request_dhcp_client(void)
{
        /*legacy API should be removed */
        return 0;
}
sint8 m2m_wifi_request_dhcp_server(uint8* addr)
{
    /*legacy API should be removed */
        return 0;
}
sint8 m2m_wifi_enable_dhcp(uint8  u8DhcpEn )
{

        uint8   u8Req;
        u8Req = u8DhcpEn ? M2M_IP_REQ_ENABLE_DHCP : M2M_IP_REQ_DISABLE_DHCP;
        return hif_send(M2M_REQ_GROUP_IP, u8Req, NULL, 0, NULL, 0, 0);


}

sint8 m2m_wifi_set_lsn_int(tstrM2mLsnInt* pstrM2mLsnInt)
{
        return hif_send(M2M_REQ_GROUP_WIFI, M2M_WIFI_REQ_LSN_INT, (uint8*)pstrM2mLsnInt, sizeof(tstrM2mLsnInt), NULL, 0, 0);
}

sint8 m2m_wifi_set_cust_InfoElement(uint8* pau8M2mCustInfoElement)
{
        return hif_send(M2M_REQ_GROUP_WIFI, M2M_WIFI_REQ_CUST_INFO_ELEMENT, (uint8*)pau8M2mCustInfoElement, pau8M2mCustInfoElement[0]+1, NULL, 0, 0);
}

sint8 m2m_wifi_set_scan_options(tstrM2MScanOption* ptstrM2MScanOption)
{
        sint8   s8Ret = M2M_ERR_FAIL;
        if(m2m_validate_scan_options (ptstrM2MScanOption) == M2M_SUCCESS)
        {
                s8Ret =  hif_send(M2M_REQ_GROUP_WIFI, M2M_WIFI_REQ_SET_SCAN_OPTION, (uint8*)ptstrM2MScanOption, sizeof(tstrM2MScanOption),NULL, 0,0);
        }
        return s8Ret;
}
sint8 m2m_wifi_set_scan_region(uint16  ScanRegion)
{
        sint8   s8Ret = M2M_ERR_FAIL;
        tstrM2MScanRegion strScanRegion;
        strScanRegion.u16ScanRegion = ScanRegion;
        s8Ret = hif_send(M2M_REQ_GROUP_WIFI, M2M_WIFI_REQ_SET_SCAN_REGION, (uint8*)&strScanRegion, sizeof(tstrM2MScanRegion),NULL, 0,0);
        return s8Ret;
}
sint8 m2m_wifi_request_scan(uint8 ch)
{
        sint8   s8Ret = M2M_SUCCESS;

        if(((ch >= M2M_WIFI_CH_1) && (ch <= M2M_WIFI_CH_14)) || (ch == M2M_WIFI_CH_ALL))
        {
                tstrM2MScan strtmp;
                strtmp.u8ChNum = ch;
                s8Ret = hif_send(M2M_REQ_GROUP_WIFI, M2M_WIFI_REQ_SCAN, (uint8*)&strtmp, sizeof(tstrM2MScan),NULL, 0,0);
        }
        else
        {
                s8Ret = M2M_ERR_INVALID_ARG;
        }
        return s8Ret;
}

sint8 m2m_wifi_request_scan_passive(uint8 ch)
{
        sint8   s8Ret = M2M_SUCCESS;

        if(((ch >= M2M_WIFI_CH_1) && (ch <= M2M_WIFI_CH_14)) || (ch == M2M_WIFI_CH_ALL))
        {
                tstrM2MScan strtmp;
                strtmp.u8ChNum = ch;

                s8Ret = hif_send(M2M_REQ_GROUP_WIFI, M2M_WIFI_REQ_PASSIVE_SCAN, (uint8*)&strtmp, sizeof(tstrM2MScan),NULL, 0,0);
        }
        else
        {
                s8Ret = M2M_ERR_INVALID_ARG;
        }
        return s8Ret;
}
sint8 m2m_wifi_wps(uint8 u8TriggerType,const char  *pcPinNumber)
{
        tstrM2MWPSConnect strtmp;

        strtmp.u8TriggerType = u8TriggerType;
        /*If WPS is using PIN METHOD*/
        if (u8TriggerType == WPS_PIN_TRIGGER)
                m2m_memcpy ((uint8*)strtmp.acPinNumber,(uint8*) pcPinNumber,8);
        return hif_send(M2M_REQ_GROUP_WIFI, M2M_WIFI_REQ_WPS, (uint8*)&strtmp,sizeof(tstrM2MWPSConnect), NULL, 0,0);
}

sint8 m2m_wifi_wps_disable(void)
{
        sint8 ret = M2M_SUCCESS;
        ret = hif_send(M2M_REQ_GROUP_WIFI, M2M_WIFI_REQ_DISABLE_WPS, NULL,0, NULL, 0, 0);
        return ret;
}

#if 0
/*
 * These two functions m2m_wifi_req_client_ctrl and m2m_wifi_req_server_init are for a mode in which two WINC ICs
 * communicate with each other via probe request and probe response frames. This mode is not supported in WINC fw.
 */
sint8 m2m_wifi_req_client_ctrl(uint8 u8Cmd)
{

        sint8 ret = M2M_SUCCESS;
#ifdef _PS_SERVER_
        tstrM2Mservercmd        strCmd;
        strCmd.u8cmd = u8Cmd;
        ret = hif_send(M2M_REQ_GROUP_WIFI, M2M_WIFI_REQ_CLIENT_CTRL, (uint8*)&strCmd, sizeof(tstrM2Mservercmd), NULL, 0, 0);
#else
        M2M_ERR("_PS_SERVER_ is not defined\n");
#endif
        return ret;
}
sint8 m2m_wifi_req_server_init(uint8 ch)
{
        sint8 ret = M2M_SUCCESS;
#ifdef _PS_SERVER_
        tstrM2mServerInit strServer;
        strServer.u8Channel = ch;
        ret = hif_send(M2M_REQ_GROUP_WIFI,M2M_WIFI_REQ_SERVER_INIT, (uint8*)&strServer, sizeof(tstrM2mServerInit), NULL, 0, 0);
#else
        M2M_ERR("_PS_SERVER_ is not defined\n");
#endif
        return ret;
}
#endif

sint8 m2m_wifi_p2p(uint8 u8Channel)
{
        sint8 ret = M2M_SUCCESS;
        if((u8Channel == M2M_WIFI_CH_1) || (u8Channel == M2M_WIFI_CH_6) || (u8Channel == M2M_WIFI_CH_11))
        {
                tstrM2MP2PConnect strtmp;
                strtmp.u8ListenChannel = u8Channel;
                ret = hif_send(M2M_REQ_GROUP_WIFI, M2M_WIFI_REQ_ENABLE_P2P, (uint8*)&strtmp, sizeof(tstrM2MP2PConnect), NULL, 0,0);
        }
        else
        {
                M2M_ERR("Listen channel should only be 1, 6 or 11\n");
                ret = M2M_ERR_FAIL;
        }
        return ret;
}
sint8 m2m_wifi_p2p_disconnect(void)
{
        sint8 ret = M2M_SUCCESS;
        ret = hif_send(M2M_REQ_GROUP_WIFI, M2M_WIFI_REQ_DISABLE_P2P, NULL, 0, NULL, 0, 0);
        return ret;
}
sint8 m2m_wifi_enable_ap(CONST tstrM2MAPConfig* pstrM2MAPConfig)
{
        sint8 ret = M2M_ERR_FAIL;
        if(M2M_SUCCESS == m2m_validate_ap_parameters(pstrM2MAPConfig))
        {
                ret = hif_send(M2M_REQ_GROUP_WIFI, M2M_WIFI_REQ_ENABLE_AP, (uint8 *)pstrM2MAPConfig, sizeof(tstrM2MAPConfig), NULL, 0, 0);      
        }
        return ret;
}
sint8 m2m_wifi_disable_ap(void)
{
        sint8 ret = M2M_SUCCESS;
        ret = hif_send(M2M_REQ_GROUP_WIFI, M2M_WIFI_REQ_DISABLE_AP, NULL, 0, NULL, 0, 0);
        return ret;
}
sint8 m2m_wifi_req_curr_rssi(void)
{
        sint8 ret = M2M_SUCCESS;
        ret = hif_send(M2M_REQ_GROUP_WIFI, M2M_WIFI_REQ_CURRENT_RSSI, NULL, 0, NULL,0, 0);
        return ret;
}

sint8 m2m_wifi_req_restrict_ble(void)
{
        sint8 ret = M2M_SUCCESS;
        ret = hif_send(M2M_REQ_GROUP_WIFI, M2M_WIFI_REQ_RESTRICT_BLE,NULL, 0, NULL, 0, 0);
        return ret;
}

sint8 m2m_wifi_req_unrestrict_ble(void)
{
        sint8 ret = M2M_SUCCESS;
        ret = hif_send(M2M_REQ_GROUP_WIFI, M2M_WIFI_REQ_UNRESTRICT_BLE,NULL, 0, NULL, 0, 0);
        return ret;
}

sint8 m2m_wifi_send_ethernet_pkt(uint8* pu8Packet,uint16 u16PacketSize)
{
        sint8   s8Ret = -1;
        if((pu8Packet != NULL)&&(u16PacketSize>0))
        {
                tstrM2MWifiTxPacketInfo         strTxPkt;

                strTxPkt.u16PacketSize          = u16PacketSize;
                strTxPkt.u16HeaderLength        = M2M_ETHERNET_HDR_LEN;
                s8Ret = hif_send(M2M_REQ_GROUP_WIFI, M2M_WIFI_REQ_SEND_ETHERNET_PACKET | M2M_REQ_DATA_PKT,
                (uint8*)&strTxPkt, sizeof(tstrM2MWifiTxPacketInfo), pu8Packet, u16PacketSize,  M2M_ETHERNET_HDR_OFFSET - M2M_HIF_HDR_OFFSET);
        }
        return s8Ret;
}
sint8 m2m_wifi_get_otp_mac_address(uint8 *pu8MacAddr, uint8* pu8IsValid)
{
        sint8 ret = M2M_SUCCESS;
        ret = hif_chip_wake();
        if(ret == M2M_SUCCESS)
        {
                ret = nmi_get_otp_mac_address(pu8MacAddr, pu8IsValid);
                if(ret == M2M_SUCCESS)
                {
                        ret = hif_chip_sleep();
                }
        }
        return ret;
}
sint8 m2m_wifi_get_mac_address(uint8 *pu8MacAddr)
{
        sint8 ret = M2M_SUCCESS;
        ret = hif_chip_wake();
        if(ret == M2M_SUCCESS)
        {
                ret = nmi_get_mac_address(pu8MacAddr);
                if(ret == M2M_SUCCESS)
                {
                        ret = hif_chip_sleep();
                }
        }

        return ret;
}
sint8 m2m_wifi_req_scan_result(uint8 index)
{
        sint8 ret = M2M_SUCCESS;
        tstrM2mReqScanResult strReqScanRlt;
        strReqScanRlt.u8Index = index;
        ret = hif_send(M2M_REQ_GROUP_WIFI, M2M_WIFI_REQ_SCAN_RESULT, (uint8*) &strReqScanRlt, sizeof(tstrM2mReqScanResult), NULL, 0, 0);
        return ret;
}
uint8 m2m_wifi_get_num_ap_found(void)
{
        return gu8ChNum;
}
uint8 m2m_wifi_get_sleep_mode(void)
{
        return hif_get_sleep_mode();
}
sint8 m2m_wifi_set_sleep_mode(uint8 PsTyp, uint8 BcastEn)
{
        sint8 ret = M2M_SUCCESS;
        tstrM2mPsType strPs;
        strPs.u8PsType = PsTyp;
        strPs.u8BcastEn = BcastEn;
        ret = hif_send(M2M_REQ_GROUP_WIFI, M2M_WIFI_REQ_SLEEP, (uint8*) &strPs,sizeof(tstrM2mPsType), NULL, 0, 0);
        M2M_INFO("POWER SAVE %d\n",PsTyp);
        hif_set_sleep_mode(PsTyp);
        return ret;
}
sint8 m2m_wifi_request_sleep(uint32 u32SlpReqTime)
{
        sint8 ret = M2M_SUCCESS;
        uint8 psType;
        psType = hif_get_sleep_mode();
        if(psType == M2M_PS_MANUAL)
        {
                tstrM2mSlpReqTime strPs;
                strPs.u32SleepTime = u32SlpReqTime;
                ret = hif_send(M2M_REQ_GROUP_WIFI, M2M_WIFI_REQ_DOZE, (uint8*) &strPs,sizeof(tstrM2mSlpReqTime), NULL, 0, 0);
        }
        return ret;
}
sint8 m2m_wifi_set_device_name(uint8 *pu8DeviceName, uint8 u8DeviceNameLength)
{
        tstrM2MDeviceNameConfig strDeviceName;
        if(u8DeviceNameLength >= M2M_DEVICE_NAME_MAX)
        {
                u8DeviceNameLength = M2M_DEVICE_NAME_MAX;
        }
        //pu8DeviceName[u8DeviceNameLength] = '\0';
        u8DeviceNameLength ++;
        m2m_memcpy(strDeviceName.au8DeviceName, pu8DeviceName, u8DeviceNameLength);
        return hif_send(M2M_REQ_GROUP_WIFI, M2M_WIFI_REQ_SET_DEVICE_NAME,
                (uint8*)&strDeviceName, sizeof(tstrM2MDeviceNameConfig), NULL, 0,0);
}
uint32 m2m_wifi_get_chipId(void)
{
        return nmi_get_chipid();
}
sint8 m2m_wifi_get_firmware_version(tstrM2mRev *pstrRev)
{
        sint8 ret = M2M_SUCCESS;
        ret = hif_chip_wake();
        if(ret == M2M_SUCCESS)
        {
                ret = nm_get_firmware_full_info(pstrRev);
                hif_chip_sleep();
        }
        return ret;
}
sint8 m2m_wifi_check_ota_rb(void)
{
        sint8 ret = M2M_SUCCESS;
        uint16 ota_hif_info = 0;

        ret = nm_get_hif_info(NULL, &ota_hif_info);
        if(ret == M2M_SUCCESS)
        {
                ret = hif_check_compatibility(ota_hif_info);
        }
        return ret;
}
NMI_API sint8 m2m_ota_get_firmware_version(tstrM2mRev * pstrRev)
{
        sint8 ret = M2M_SUCCESS;
        ret = hif_chip_wake();
        if(ret == M2M_SUCCESS)
        {
                ret = nm_get_ota_firmware_info(pstrRev);
                hif_chip_sleep();
        }
        return ret;
}
#ifdef CONF_MGMT
sint8 m2m_wifi_enable_monitoring_mode(tstrM2MWifiMonitorModeCtrl *pstrMtrCtrl, uint8 *pu8PayloadBuffer,
                                                                   uint16 u16BufferSize, uint16 u16DataOffset)
{
        sint8   s8Ret = -1;
        if((pstrMtrCtrl->u8ChannelID >= M2M_WIFI_CH_1) && (pstrMtrCtrl->u8ChannelID <= M2M_WIFI_CH_14))
        {
                gstrMgmtCtrl.pu8Buf             = pu8PayloadBuffer;
                gstrMgmtCtrl.u16Sz              = u16BufferSize;
                gstrMgmtCtrl.u16Offset  = u16DataOffset;
                s8Ret = hif_send(M2M_REQ_GROUP_WIFI, M2M_WIFI_REQ_ENABLE_MONITORING,
                        (uint8*)pstrMtrCtrl, sizeof(tstrM2MWifiMonitorModeCtrl), NULL, 0,0);
        }
        return s8Ret;
}
sint8 m2m_wifi_disable_monitoring_mode(void)
{
        return hif_send(M2M_REQ_GROUP_WIFI, M2M_WIFI_REQ_DISABLE_MONITORING, NULL, 0, NULL, 0,0);
}

sint8 m2m_wifi_send_wlan_pkt(uint8 *pu8WlanPacket, uint16 u16WlanHeaderLength, uint16 u16WlanPktSize)
{
        sint8   s8Ret = -1;
        if(pu8WlanPacket != NULL)
        {
                tstrM2MWifiTxPacketInfo         strTxPkt;

                strTxPkt.u16PacketSize          = u16WlanPktSize;
                strTxPkt.u16HeaderLength        = u16WlanHeaderLength;
                s8Ret = hif_send(M2M_REQ_GROUP_WIFI, M2M_WIFI_REQ_SEND_WIFI_PACKET | M2M_REQ_DATA_PKT,
                (uint8*)&strTxPkt, sizeof(tstrM2MWifiTxPacketInfo), pu8WlanPacket, u16WlanPktSize, sizeof(tstrM2MWifiTxPacketInfo));
        }
        return s8Ret;
}
#endif

sint8 m2m_wifi_start_provision_mode(tstrM2MAPConfig *pstrAPConfig, char *pcHttpServerDomainName, uint8 bEnableHttpRedirect)
{
        sint8   s8Ret = M2M_ERR_FAIL;

        if((pstrAPConfig != NULL))
        {
                tstrM2MProvisionModeConfig      strProvConfig;
                if(M2M_SUCCESS == m2m_validate_ap_parameters(pstrAPConfig))
                {
                        m2m_memcpy((uint8*)&strProvConfig.strApConfig, (uint8*)pstrAPConfig, sizeof(tstrM2MAPConfig));
                        if((m2m_strlen((uint8 *)pcHttpServerDomainName) <= 0) || (NULL == pcHttpServerDomainName))
                        {
                                M2M_ERR("INVALID DOMAIN NAME\n");
                                goto ERR1;
                        }
                        m2m_memcpy((uint8*)strProvConfig.acHttpServerDomainName, (uint8*)pcHttpServerDomainName, 64);
                        strProvConfig.u8EnableRedirect = bEnableHttpRedirect;

                        s8Ret = hif_send(M2M_REQ_GROUP_WIFI, M2M_WIFI_REQ_START_PROVISION_MODE | M2M_REQ_DATA_PKT, 
                                                (uint8*)&strProvConfig, sizeof(tstrM2MProvisionModeConfig), NULL, 0, 0);
                }
                else
                {
                        /*goto ERR1;*/
                }
        }
ERR1:
        return s8Ret;
}

sint8 m2m_wifi_stop_provision_mode(void)
{
        return hif_send(M2M_REQ_GROUP_WIFI, M2M_WIFI_REQ_STOP_PROVISION_MODE, NULL, 0, NULL, 0, 0);
}

sint8 m2m_wifi_get_connection_info(void)
{
        return hif_send(M2M_REQ_GROUP_WIFI, M2M_WIFI_REQ_GET_CONN_INFO, NULL, 0, NULL, 0, 0);
}

sint8 m2m_wifi_set_sytem_time(uint32 u32UTCSeconds)
{
        return hif_send(M2M_REQ_GROUP_WIFI, M2M_WIFI_REQ_SET_SYS_TIME, (uint8*)&u32UTCSeconds, sizeof(tstrSystemTime), NULL, 0, 0);
}
sint8 m2m_wifi_get_sytem_time(void)
{
        return hif_send(M2M_REQ_GROUP_WIFI, M2M_WIFI_REQ_GET_SYS_TIME, NULL,0, NULL, 0, 0);
}

sint8 m2m_wifi_enable_sntp(uint8 bEnable)
{
        uint8   u8Req;

        u8Req = bEnable ? M2M_WIFI_REQ_ENABLE_SNTP_CLIENT : M2M_WIFI_REQ_DISABLE_SNTP_CLIENT;
        return hif_send(M2M_REQ_GROUP_WIFI, u8Req, NULL, 0, NULL, 0, 0);
}
sint8 m2m_wifi_set_power_profile(uint8 u8PwrMode)
{
        sint8 ret = M2M_SUCCESS;
        tstrM2mPwrMode strM2mPwrMode;
        strM2mPwrMode.u8PwrMode = u8PwrMode;
        ret = hif_send(M2M_REQ_GROUP_WIFI, M2M_WIFI_REQ_SET_POWER_PROFILE, (uint8*)&strM2mPwrMode,sizeof(tstrM2mPwrMode), NULL, 0, 0);
        return ret;
}
sint8 m2m_wifi_set_tx_power(uint8 u8TxPwrLevel)
{
        sint8 ret = M2M_SUCCESS;
        tstrM2mTxPwrLevel strM2mTxPwrLevel;
        strM2mTxPwrLevel.u8TxPwrLevel = u8TxPwrLevel;
        ret = hif_send(M2M_REQ_GROUP_WIFI, M2M_WIFI_REQ_SET_TX_POWER, (uint8*)&strM2mTxPwrLevel,sizeof(tstrM2mTxPwrLevel), NULL, 0, 0);
        return ret;
}

sint8 m2m_wifi_enable_firmware_logs(uint8 u8Enable)
{
        sint8 ret = M2M_SUCCESS;
        tstrM2mEnableLogs strM2mEnableLogs;
        strM2mEnableLogs.u8Enable = u8Enable;
        ret = hif_send(M2M_REQ_GROUP_WIFI, M2M_WIFI_REQ_SET_ENABLE_LOGS, (uint8*)&strM2mEnableLogs,sizeof(tstrM2mEnableLogs), NULL, 0, 0);
        return ret;
}

sint8 m2m_wifi_set_battery_voltage(uint16 u16BattVoltx100)
{
        sint8 ret = M2M_SUCCESS;
        tstrM2mBatteryVoltage strM2mBattVol = {0};
        strM2mBattVol.u16BattVolt = u16BattVoltx100;
        ret = hif_send(M2M_REQ_GROUP_WIFI, M2M_WIFI_REQ_SET_BATTERY_VOLTAGE, (uint8*)&strM2mBattVol,sizeof(tstrM2mBatteryVoltage), NULL, 0, 0);
        return ret;
}
sint8 m2m_wifi_prng_get_random_bytes(uint8 * pu8PrngBuff,uint16 u16PrngSize)
{
        sint8 ret = M2M_ERR_FAIL;
        tstrPrng   strRng = {0};
        if((u16PrngSize < (M2M_BUFFER_MAX_SIZE - sizeof(tstrPrng)))&&(pu8PrngBuff != NULL))
        {
                strRng.u16PrngSize = u16PrngSize;
                strRng.pu8RngBuff  = pu8PrngBuff;
                ret = hif_send(M2M_REQ_GROUP_WIFI, M2M_WIFI_REQ_GET_PRNG|M2M_REQ_DATA_PKT,(uint8 *)&strRng, sizeof(tstrPrng),NULL,0, 0);
        }
        else
        {
                M2M_ERR("PRNG Buffer exceeded maximum size %d or NULL Buffer\n",u16PrngSize);
        }
        return ret;
}
#ifdef ETH_MODE

NMI_API sint8 m2m_wifi_enable_mac_mcast(uint8* pu8MulticastMacAddress, uint8 u8AddRemove)
{
        sint8 s8ret = M2M_ERR_FAIL;
        tstrM2MMulticastMac  strMulticastMac;

        if(pu8MulticastMacAddress != NULL )
        {
                strMulticastMac.u8AddRemove = u8AddRemove;
                m2m_memcpy(strMulticastMac.au8macaddress,pu8MulticastMacAddress,M2M_MAC_ADDRES_LEN);
                M2M_DBG("mac multicast: %x:%x:%x:%x:%x:%x\r\n",strMulticastMac.au8macaddress[0],strMulticastMac.au8macaddress[1],strMulticastMac.au8macaddress[2],strMulticastMac.au8macaddress[3],strMulticastMac.au8macaddress[4],strMulticastMac.au8macaddress[5]);
                s8ret = hif_send(M2M_REQ_GROUP_WIFI, M2M_WIFI_REQ_SET_MAC_MCAST, (uint8 *)&strMulticastMac,sizeof(tstrM2MMulticastMac),NULL,0,0);
        }

        return s8ret;

}

NMI_API sint8  m2m_wifi_set_receive_buffer(void* pvBuffer,uint16 u16BufferLen)
{
        sint8 s8ret = M2M_SUCCESS;
        if(pvBuffer != NULL)
        {
                gau8ethRcvBuf = pvBuffer;
                gu16ethRcvBufSize= u16BufferLen;
        }
        else
        {
                s8ret = M2M_ERR_FAIL;
                M2M_ERR("Buffer NULL pointer\r\n");
        }
        return s8ret;
}
#endif

NMI_API sint8 m2m_wifi_ble_api_send(uint8* msg,  uint32 len)
{
        tstrM2mBleApiMsg bleTx;
        bleTx.u16Len = len;
        return hif_send(M2M_REQ_GROUP_WIFI, M2M_WIFI_REQ_BLE_API_SEND | M2M_REQ_DATA_PKT,
                (uint8*)&bleTx, sizeof(tstrM2mBleApiMsg), msg, len, sizeof(tstrM2mBleApiMsg));
}