/**
* @fn m2m_wifi_cb(uint8 u8OpCode, uint16 u16DataSize, uint32 u32Addr, uint8 grp)
* @brief WiFi call back function
* @param [in] u8OpCode
* HIF Opcode type.
* @param [in] u16DataSize
* HIF data length.
* @param [in] u32Addr
* HIF address.
* @param [in] grp
* HIF group type.
* @author
* @date
* @version 1.0
*/
static void m2m_ota_cb(uint8 u8OpCode, uint16 u16DataSize, uint32 u32Addr)
{
sint8 ret = M2M_SUCCESS;
if(u8OpCode == M2M_OTA_RESP_NOTIF_UPDATE_INFO)
{
tstrOtaUpdateInfo strOtaUpdateInfo;
m2m_memset((uint8*)&strOtaUpdateInfo,0,sizeof(tstrOtaUpdateInfo));
ret = hif_receive(u32Addr,(uint8*)&strOtaUpdateInfo,sizeof(tstrOtaUpdateInfo),0);
if(ret == M2M_SUCCESS)
{
if(gpfOtaNotifCb)
gpfOtaNotifCb(&strOtaUpdateInfo);
}
}
else if (u8OpCode == M2M_OTA_RESP_UPDATE_STATUS)
{
tstrOtaUpdateStatusResp strOtaUpdateStatusResp;
m2m_memset((uint8*)&strOtaUpdateStatusResp,0,sizeof(tstrOtaUpdateStatusResp));
ret = hif_receive(u32Addr, (uint8*) &strOtaUpdateStatusResp,sizeof(tstrOtaUpdateStatusResp), 0);
if(ret == M2M_SUCCESS)
{
if(gpfOtaUpdateCb)
gpfOtaUpdateCb(strOtaUpdateStatusResp.u8OtaUpdateStatusType,strOtaUpdateStatusResp.u8OtaUpdateStatus);
}
}
else
{
M2M_ERR("Invaild OTA resp %d ?\n",u8OpCode);
}
}
NMI_API void Socket_ReadSocketData_Small(void)
{
if((msg_xfer.u16RemainingSize > 0) && (gastrSockets[sock_xfer].pu8UserBuffer != NULL) && (gastrSockets[sock_xfer].u16UserBufferSize > 0) && (gastrSockets[sock_xfer].bIsUsed == 1))
{
uint16 u16Read;
sint16 s16Diff;
uint8 u8SetRxDone;
//do
//{
u8SetRxDone = 1;
u16Read = msg_xfer.u16RemainingSize;
s16Diff = u16Read - gastrSockets[sock_xfer].u16UserBufferSize;
if(s16Diff > 0)
{
/*Has to be subsequent transfer*/
hif_small_xfer = 2;
u8SetRxDone = 0;
u16Read = gastrSockets[sock_xfer].u16UserBufferSize;
}
else
{
/*Last xfer, needed for UDP*/
hif_small_xfer = 3;
}
if(hif_receive(u32Address, gastrSockets[sock_xfer].pu8UserBuffer, u16Read, u8SetRxDone) == M2M_SUCCESS)
{
msg_xfer.pu8Buffer = gastrSockets[sock_xfer].pu8UserBuffer;
msg_xfer.s16BufferSize = u16Read;
msg_xfer.u16RemainingSize -= u16Read;
if (gpfAppSocketCb)
gpfAppSocketCb(sock_xfer,type_xfer, &msg_xfer);
u32Address += u16Read;
}
else
{
M2M_INFO("(ERRR)Current <%d>\n", u16ReadCount);
//break;
}
if (hif_small_xfer == 3)
{
hif_small_xfer = 0;
hif_chip_sleep();
}
//}while(u16ReadCount != 0);
}
}
/*********************************************************************
Function
Socket_ReadSocketData
Description
Callback function used by the NMC1500 driver to deliver messages
for socket layer.
Return
None.
Author
Ahmed Ezzat
Version
1.0
Date
17 July 2012
*********************************************************************/
NMI_API void Socket_ReadSocketData(SOCKET sock, tstrSocketRecvMsg *pstrRecv,uint8 u8SocketMsg,
uint32 u32StartAddress,uint16 u16ReadCount)
{
if(u16ReadCount > 0)
{
uint32 u32Address = u32StartAddress;
uint16 u16Read;
sint16 s16Diff;
uint8 u8SetRxDone;
pstrRecv->u16RemainingSize = u16ReadCount;
do
{
u8SetRxDone = 1;
u16Read = u16ReadCount;
s16Diff = u16Read - gastrSockets[sock].u16UserBufferSize;
if(s16Diff > 0)
{
u8SetRxDone = 0;
if(s16Diff > 3)
{
u16Read = gastrSockets[sock].u16UserBufferSize;
}
else
{
u16Read = gastrSockets[sock].u16UserBufferSize - 4;
}
}
if(hif_receive(u32Address, gastrSockets[sock].pu8UserBuffer, u16Read, u8SetRxDone) == M2M_SUCCESS)
{
pstrRecv->pu8Buffer = gastrSockets[sock].pu8UserBuffer;
pstrRecv->s16BufferSize = u16Read;
pstrRecv->u16RemainingSize -= u16Read;
if (gpfAppSocketCb)
gpfAppSocketCb(sock,u8SocketMsg, pstrRecv);
u16ReadCount -= u16Read;
u32Address += u16Read;
}
else
{
M2M_INFO("(ERRR)Current <%d>\n", u16ReadCount);
break;
}
}while(u16ReadCount != 0);
}
}
NMI_API void Socket_ReadSocketData(SOCKET sock, tstrSocketRecvMsg *pstrRecv,uint8 u8SocketMsg,
uint32 u32StartAddress,uint16 u16ReadCount)
{
if((u16ReadCount > 0) && (gastrSockets[sock].pu8UserBuffer != NULL) && (gastrSockets[sock].u16UserBufferSize > 0) && (gastrSockets[sock].bIsUsed == 1))
{
u32Address = u32StartAddress;
uint16 u16Read;
sint16 s16Diff;
uint8 u8SetRxDone;
m2m_memcpy((uint8 *)&msg_xfer, (uint8 *)pstrRecv, sizeof(tstrSocketRecvMsg));
msg_xfer.u16RemainingSize = u16ReadCount;
//do
//{
u8SetRxDone = 1;
u16Read = u16ReadCount;
s16Diff = u16Read - gastrSockets[sock].u16UserBufferSize;
if(s16Diff > 0)
{
u8SetRxDone = 0;
u16Read = gastrSockets[sock].u16UserBufferSize;
hif_small_xfer = 1;
sock_xfer = sock;
type_xfer = u8SocketMsg;
}
if(hif_receive(u32Address, gastrSockets[sock].pu8UserBuffer, u16Read, u8SetRxDone) == M2M_SUCCESS)
{
msg_xfer.pu8Buffer = gastrSockets[sock].pu8UserBuffer;
msg_xfer.s16BufferSize = u16Read;
msg_xfer.u16RemainingSize -= u16Read;
if (gpfAppSocketCb)
gpfAppSocketCb(sock,u8SocketMsg, &msg_xfer);
u32Address += u16Read;
}
else
{
M2M_INFO("(ERRR)Current <%d>\n", u16ReadCount);
//break;
}
//}while(u16ReadCount != 0);
}
}
/*********************************************************************
Function
m2m_ip_cb
Description
Callback function used by the NMC1000 driver to deliver messages
for socket layer.
Return
None.
Author
Ahmed Ezzat
Version
1.0
Date
17 July 2012
*********************************************************************/
static void m2m_ip_cb(uint8 u8OpCode, uint16 u16BufferSize,uint32 u32Address)
{
if(u8OpCode == SOCKET_CMD_BIND)
{
tstrBindReply strBindReply;
tstrSocketBindMsg strBind;
if(hif_receive(u32Address, (uint8*)&strBindReply, sizeof(tstrBindReply), 0) == M2M_SUCCESS)
{
strBind.status = strBindReply.s8Status;
if(gpfAppSocketCb)
gpfAppSocketCb(strBindReply.sock,SOCKET_MSG_BIND,&strBind);
}
}
else if(u8OpCode == SOCKET_CMD_LISTEN)
{
tstrListenReply strListenReply;
tstrSocketListenMsg strListen;
if(hif_receive(u32Address, (uint8*)&strListenReply, sizeof(tstrListenReply), 0) == M2M_SUCCESS)
{
strListen.status = strListenReply.s8Status;
if(gpfAppSocketCb)
gpfAppSocketCb(strListenReply.sock,SOCKET_MSG_LISTEN, &strListen);
}
}
else if(u8OpCode == SOCKET_CMD_ACCEPT)
{
tstrAcceptReply strAcceptReply;
tstrSocketAcceptMsg strAccept;
if(hif_receive(u32Address, (uint8*)&strAcceptReply, sizeof(tstrAcceptReply), 0) == M2M_SUCCESS)
{
if(strAcceptReply.sConnectedSock >= 0)
{
gastrSockets[strAcceptReply.sConnectedSock].u8SSLFlags = 0;
gastrSockets[strAcceptReply.sConnectedSock].bIsUsed = 1;
/* The session ID is used to distinguish different socket connections
by comparing the assigned session ID to the one reported by the firmware*/
++gu16SessionID;
if(gu16SessionID == 0)
++gu16SessionID;
gastrSockets[strAcceptReply.sConnectedSock].u16SessionID = gu16SessionID;
M2M_DBG("Socket %d session ID = %d\r\n",strAcceptReply.sConnectedSock , gu16SessionID );
}
strAccept.sock = strAcceptReply.sConnectedSock;
strAccept.strAddr.sin_family = AF_INET;
strAccept.strAddr.sin_port = strAcceptReply.strAddr.u16Port;
strAccept.strAddr.sin_addr.s_addr = strAcceptReply.strAddr.u32IPAddr;
if(gpfAppSocketCb)
gpfAppSocketCb(strAcceptReply.sListenSock, SOCKET_MSG_ACCEPT, &strAccept);
}
}
else if((u8OpCode == SOCKET_CMD_CONNECT) || (u8OpCode == SOCKET_CMD_SSL_CONNECT))
{
tstrConnectReply strConnectReply;
tstrSocketConnectMsg strConnMsg;
if(hif_receive(u32Address, (uint8*)&strConnectReply, sizeof(tstrConnectReply), 0) == M2M_SUCCESS)
{
strConnMsg.sock = strConnectReply.sock;
strConnMsg.s8Error = strConnectReply.s8Error;
if(gpfAppSocketCb)
gpfAppSocketCb(strConnectReply.sock,SOCKET_MSG_CONNECT, &strConnMsg);
}
}
else if(u8OpCode == SOCKET_CMD_DNS_RESOLVE)
{
tstrDnsReply strDnsReply;
if(hif_receive(u32Address, (uint8*)&strDnsReply, sizeof(tstrDnsReply), 0) == M2M_SUCCESS)
{
strDnsReply.u32HostIP = strDnsReply.u32HostIP;
if(gpfAppResolveCb)
gpfAppResolveCb((uint8*)strDnsReply.acHostName, strDnsReply.u32HostIP);
}
}
else if((u8OpCode == SOCKET_CMD_RECV) || (u8OpCode == SOCKET_CMD_RECVFROM) || (u8OpCode == SOCKET_CMD_SSL_RECV))
{
SOCKET sock;
sint16 s16RecvStatus;
tstrRecvReply strRecvReply;
uint16 u16ReadSize;
tstrSocketRecvMsg strRecvMsg;
uint8 u8CallbackMsgID = SOCKET_MSG_RECV;
uint16 u16DataOffset;
if(u8OpCode == SOCKET_CMD_RECVFROM)
u8CallbackMsgID = SOCKET_MSG_RECVFROM;
/* Read RECV REPLY data structure.
*/
u16ReadSize = sizeof(tstrRecvReply);
if(hif_receive(u32Address, (uint8*)&strRecvReply, u16ReadSize, 0) == M2M_SUCCESS)
{
uint16 u16SessionID = 0;
sock = strRecvReply.sock;
u16SessionID = strRecvReply.u16SessionID;
M2M_DBG("recv callback session ID = %d\r\n",u16SessionID);
/* Reset the Socket RX Pending Flag.
*/
gastrSockets[sock].bIsRecvPending = 0;
s16RecvStatus = NM_BSP_B_L_16(strRecvReply.s16RecvStatus);
u16DataOffset = NM_BSP_B_L_16(strRecvReply.u16DataOffset);
strRecvMsg.strRemoteAddr.sin_port = strRecvReply.strRemoteAddr.u16Port;
strRecvMsg.strRemoteAddr.sin_addr.s_addr = strRecvReply.strRemoteAddr.u32IPAddr;
if(u16SessionID == gastrSockets[sock].u16SessionID)
{
if((s16RecvStatus > 0) && (s16RecvStatus < u16BufferSize))
{
/* Skip incoming bytes until reaching the Start of Application Data.
*/
u32Address += u16DataOffset;
/* Read the Application data and deliver it to the application callback in
the given application buffer. If the buffer is smaller than the received data,
the data is passed to the application in chunks according to its buffer size.
*/
u16ReadSize = (uint16)s16RecvStatus;
Socket_ReadSocketData(sock, &strRecvMsg, u8CallbackMsgID, u32Address, u16ReadSize);
}
else
{
strRecvMsg.s16BufferSize = s16RecvStatus;
strRecvMsg.pu8Buffer = NULL;
if(gpfAppSocketCb)
gpfAppSocketCb(sock,u8CallbackMsgID, &strRecvMsg);
}
}
else
{
M2M_DBG("Discard recv callback %d %d \r\n",u16SessionID , gastrSockets[sock].u16SessionID);
if(u16ReadSize < u16BufferSize)
hif_receive(0, NULL, 0, 1);
}
}
}
else if((u8OpCode == SOCKET_CMD_SEND) || (u8OpCode == SOCKET_CMD_SENDTO) || (u8OpCode == SOCKET_CMD_SSL_SEND))
{
SOCKET sock;
sint16 s16Rcvd;
tstrSendReply strReply;
uint8 u8CallbackMsgID = SOCKET_MSG_SEND;
if(u8OpCode == SOCKET_CMD_SENDTO)
u8CallbackMsgID = SOCKET_MSG_SENDTO;
if(hif_receive(u32Address, (uint8*)&strReply, sizeof(tstrSendReply), 0) == M2M_SUCCESS)
{
uint16 u16SessionID = 0;
sock = strReply.sock;
u16SessionID = strReply.u16SessionID;
M2M_DBG("send callback session ID = %d\r\n",u16SessionID);
s16Rcvd = NM_BSP_B_L_16(strReply.s16SentBytes);
if(u16SessionID == gastrSockets[sock].u16SessionID)
{
if(gpfAppSocketCb)
gpfAppSocketCb(sock,u8CallbackMsgID, &s16Rcvd);
}
else
{
M2M_DBG("Discard send callback %d %d \r\n",u16SessionID , gastrSockets[sock].u16SessionID);
}
}
}
}
/**
* @fn m2m_crypto_cb(uint8 u8OpCode, uint16 u16DataSize, uint32 u32Addr)
* @brief WiFi call back function
* @param [in] u8OpCode
* HIF Opcode type.
* @param [in] u16DataSize
* HIF data length.
* @param [in] u32Addr
* HIF address.
* @author
* @date
* @version 1.0
*/
static void m2m_crypto_cb(uint8 u8OpCode, uint16 u16DataSize, uint32 u32Addr)
{
sint8 ret = M2M_SUCCESS;
gstrCryptoCtxt.u8CryptoBusy = 0;
if(u8OpCode == M2M_CRYPTO_RESP_SHA256_INIT)
{
tstrM2mSha256Ctxt strCtxt;
if (hif_receive(u32Addr, (uint8*) &strCtxt,sizeof(tstrM2mSha256Ctxt), 0) == M2M_SUCCESS)
{
tstrCyptoResp strResp;
if(hif_receive(u32Addr + sizeof(tstrM2mSha256Ctxt), (uint8*) &strResp,sizeof(tstrCyptoResp), 1) == M2M_SUCCESS)
{
if (gstrCryptoCtxt.pfAppCryptoCb)
gstrCryptoCtxt.pfAppCryptoCb(u8OpCode,&strResp,&strCtxt);
}
}
}
else if(u8OpCode == M2M_CRYPTO_RESP_SHA256_UPDATE)
{
tstrM2mSha256Ctxt strCtxt;
if (hif_receive(u32Addr, (uint8*) &strCtxt,sizeof(tstrM2mSha256Ctxt), 0) == M2M_SUCCESS)
{
tstrCyptoResp strResp;
if (hif_receive(u32Addr + sizeof(tstrM2mSha256Ctxt), (uint8*) &strResp,sizeof(tstrCyptoResp), 1) == M2M_SUCCESS)
{
if (gstrCryptoCtxt.pfAppCryptoCb)
gstrCryptoCtxt.pfAppCryptoCb(u8OpCode,&strResp,&strCtxt);
}
}
}
else if(u8OpCode == M2M_CRYPTO_RESP_SHA256_FINSIH)
{
tstrCyptoResp strResp;
if (hif_receive(u32Addr + sizeof(tstrM2mSha256Ctxt), (uint8*) &strResp,sizeof(tstrCyptoResp), 0) == M2M_SUCCESS)
{
if (hif_receive(u32Addr + sizeof(tstrM2mSha256Ctxt) + sizeof(tstrCyptoResp), (uint8*)gstrCryptoCtxt.pu8Digest,M2M_SHA256_DIGEST_LEN, 1) == M2M_SUCCESS)
{
if (gstrCryptoCtxt.pfAppCryptoCb)
gstrCryptoCtxt.pfAppCryptoCb(u8OpCode,&strResp,gstrCryptoCtxt.pu8Digest);
}
}
}
else if(u8OpCode == M2M_CRYPTO_RESP_RSA_SIGN_GEN)
{
tstrCyptoResp strResp;
if (hif_receive(u32Addr + sizeof(tstrRsaPayload), (uint8*)&strResp,sizeof(tstrCyptoResp), 0) == M2M_SUCCESS)
{
if (hif_receive(u32Addr + sizeof(tstrRsaPayload) + sizeof(tstrCyptoResp), (uint8*)gstrCryptoCtxt.pu8Rsa,M2M_MAX_RSA_LEN, 0) == M2M_SUCCESS)
{
if (gstrCryptoCtxt.pfAppCryptoCb)
gstrCryptoCtxt.pfAppCryptoCb(u8OpCode,&strResp,gstrCryptoCtxt.pu8Rsa);
}
}
}
else if(u8OpCode == M2M_CRYPTO_RESP_RSA_SIGN_VERIFY)
{
tstrCyptoResp strResp;
if (hif_receive(u32Addr + sizeof(tstrRsaPayload), (uint8*)&strResp,sizeof(tstrCyptoResp), 1) == M2M_SUCCESS)
{
if (gstrCryptoCtxt.pfAppCryptoCb)
gstrCryptoCtxt.pfAppCryptoCb(u8OpCode,&strResp,NULL);
}
}
else
{
M2M_ERR("u8Code %d ??\n",u8OpCode);
}
}
/**
* @fn m2m_wifi_cb(uint8 u8OpCode, uint16 u16DataSize, uint32 u32Addr, uint8 grp)
* @brief WiFi call back function
* @param [in] u8OpCode
* HIF Opcode type.
* @param [in] u16DataSize
* HIF data length.
* @param [in] u32Addr
* HIF address.
* @param [in] grp
* HIF group type.
* @author
* @date
* @version 1.0
*/
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_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.u32StaticIP);
}
}
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)
{
tstrM2MIPConfig strIpConfig;
if(hif_receive(u32Addr, (uint8 *)&strIpConfig, sizeof(tstrM2MIPConfig), 0) == M2M_SUCCESS)
{
M2M_DBG("Conflicted IP\"%u.%u.%u.%u\"\n",
((uint8 *)&strIpConfig.u32StaticIP)[0], ((uint8 *)&strIpConfig.u32StaticIP)[1],
((uint8 *)&strIpConfig.u32StaticIP)[2], ((uint8 *)&strIpConfig.u32StaticIP)[3]);
if (gpfAppWifiCb)
gpfAppWifiCb(M2M_WIFI_RESP_IP_CONFLICT, NULL);
}
}
else if (u8OpCode == M2M_WIFI_RESP_SCAN_DONE)
{
tstrM2mScanDone strState;
gu8scanInProgress = 0;
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);
}
}
#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(hif_receive(u32Addr, (uint8*)&strRxPacketInfo, sizeof(tstrM2MWifiRxPacketInfo), 0) == M2M_SUCCESS)
{
u16DataSize -= sizeof(tstrM2MWifiRxPacketInfo);
if(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);
}
}
#endif
else
{
M2M_ERR("REQ Not defined %d\n",u8OpCode);
}
}
/**
* @fn m2m_wifi_cb(uint8 u8OpCode, uint16 u16DataSize, uint32 u32Addr, uint8 grp)
* @brief WiFi call back function
* @param [in] u8OpCode
* HIF Opcode type.
* @param [in] u16DataSize
* HIF data length.
* @param [in] u32Addr
* HIF address.
* @param [in] grp
* HIF group type.
* @author
* @date
* @version 1.0
*/
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;
gu8scanInProgress = 0;
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_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);
}
}
}
#ifdef ETH_MODE
else if(u8OpCode == M2M_WIFI_RESP_ETHERNET_RX_PACKET)
{
uint8 u8SetRxDone;
tstrM2mIpRsvdPkt strM2mRsvd;
if(hif_receive(u32Addr, &strM2mRsvd ,sizeof(tstrM2mIpRsvdPkt), 0) == M2M_SUCCESS)
{
tstrM2mIpCtrlBuf strM2mIpCtrlBuf;
uint16 u16Offset = strM2mRsvd.u16PktOffset;
strM2mIpCtrlBuf.u16RemainigDataSize = strM2mRsvd.u16PktSz;
if((gpfAppEthCb) && (gau8ethRcvBuf) && (gu16ethRcvBufSize > 0))
{
do
{
u8SetRxDone = 1;
if(strM2mIpCtrlBuf.u16RemainigDataSize > gu16ethRcvBufSize)
{
u8SetRxDone = 0;
strM2mIpCtrlBuf.u16DataSize = gu16ethRcvBufSize;
}
else
{
strM2mIpCtrlBuf.u16DataSize = strM2mIpCtrlBuf.u16RemainigDataSize;
}
if(hif_receive(u32Addr + u16Offset, gau8ethRcvBuf, strM2mIpCtrlBuf.u16DataSize, u8SetRxDone) == M2M_SUCCESS)
{
strM2mIpCtrlBuf.u16RemainigDataSize -= strM2mIpCtrlBuf.u16DataSize;
u16Offset += strM2mIpCtrlBuf.u16DataSize;
gpfAppEthCb(M2M_WIFI_RESP_ETHERNET_RX_PACKET, gau8ethRcvBuf, &(strM2mIpCtrlBuf));
}
else
{
break;
}
}while (strM2mIpCtrlBuf.u16RemainigDataSize > 0);
}
}
}
#endif /* ETH_MODE */
#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) return;
}
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);
}
}
