void rom_test()
{
uint8 *pu8TextSec;
FILE *fp;
uint32 u32CodeSize = 0;
nm_bsp_sleep(1000);
/* Read text section.
*/
fp = fopen(ROM_FIRMWARE_FILE,"rb");
if(fp)
{
/* Get the code size.
*/
fseek(fp, 0L, SEEK_END);
u32CodeSize = ftell(fp);
fseek(fp, 0L, SEEK_SET);
pu8TextSec = (uint8*)malloc(u32CodeSize);
if(pu8TextSec != NULL)
{
M2M_INFO("Code Size %f\n",u32CodeSize / 1024.0);
fread(pu8TextSec, u32CodeSize, 1, fp);
nm_write_block(CODE_BASE, pu8TextSec, (uint16)u32CodeSize);
//nm_read_block(CODE_BASE, tmpv, sz);
fclose(fp);
free(pu8TextSec);
}
}
#if 0
uint8 *pu8DataSec;
uint32 u32DataSize = 0;
/* Read data section.
*/
fp = fopen(ROM_DATA_FILE,"rb");
if(fp)
{
/* Get the data size.
*/
fseek(fp, 0L, SEEK_END);
u32DataSize = ftell(fp);
fseek(fp, 0L, SEEK_SET);
pu8DataSec = (uint8*)malloc(u32DataSize);
if(pu8DataSec != NULL)
{
M2M_INFO("Data Size %f\n",u32DataSize / 1024.0);
fread(pu8DataSec, u32DataSize, 1, fp);
nm_write_block(DATA_BASE, pu8DataSec, (uint16)u32DataSize);
fclose(fp);
}
free(pu8DataSec);
}
#endif
nm_write_reg(0x108c, 0xdddd);
}
sint8 m2m_wifi_init(tstrWifiInitParam * param)
{
tstrM2mRev strtmp;
sint8 ret = M2M_SUCCESS;
uint8 u8WifiMode = M2M_WIFI_MODE_NORMAL;
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;
u8WifiMode = param->strEthInitParam.u8EthernetEnable;
#endif /* ETH_MODE */
#ifdef CONF_MGMT
gpfAppMonCb = param->pfAppMonCb;
#endif
gu8scanInProgress = 0;
/* Apply device specific initialization. */
ret = nm_drv_init(&u8WifiMode);
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);
ret = nm_get_firmware_info(&strtmp);
M2M_INFO("Firmware ver : %u.%u.%u\n", strtmp.u8FirmwareMajor, strtmp.u8FirmwareMinor, strtmp.u8FirmwarePatch);
M2M_INFO("Min driver ver : %u.%u.%u\n", strtmp.u8DriverMajor, strtmp.u8DriverMinor, strtmp.u8DriverPatch);
M2M_INFO("Curr driver ver: %u.%u.%u\n", M2M_DRIVER_VERSION_MAJOR_NO, M2M_DRIVER_VERSION_MINOR_NO, M2M_DRIVER_VERSION_PATCH_NO);
if(M2M_ERR_FW_VER_MISMATCH == ret)
{
M2M_ERR("Mismatch Firmawre Version\n");
}
goto _EXIT0;
_EXIT1:
nm_drv_deinit(NULL);
_EXIT0:
return ret;
}
/*********************************************************************
Function
close
Description
Return
None.
Author
Ahmed Ezzat
Version
1.0
Date
4 June 2012
*********************************************************************/
sint8 close(SOCKET sock)
{
sint8 s8Ret = SOCK_ERR_INVALID_ARG;
M2M_INFO("Sock to delete <%d>\n", sock);
if(sock >= 0 && (gastrSockets[sock].bIsUsed == 1))
{
uint8 u8Cmd = SOCKET_CMD_CLOSE;
tstrCloseCmd strclose;
strclose.sock = sock;
strclose.u16SessionID = gastrSockets[sock].u16SessionID;
gastrSockets[sock].bIsUsed = 0;
gastrSockets[sock].u16SessionID =0;
if(gastrSockets[sock].u8SSLFlags & SSL_FLAGS_ACTIVE)
{
u8Cmd = SOCKET_CMD_SSL_CLOSE;
}
s8Ret = SOCKET_REQUEST(u8Cmd, (uint8*)&strclose, sizeof(tstrCloseCmd), NULL,0, 0);
if(s8Ret != SOCK_ERR_NO_ERROR)
{
s8Ret = SOCK_ERR_INVALID;
}
m2m_memset((uint8*)&gastrSockets[sock], 0, sizeof(tstrSocket));
}
return s8Ret;
}
/*
* @fn nm_uart_sync_cmd
* @brief Check COM Port
* @return M2M_SUCCESS in case of success and M2M_ERR_BUS_FAIL in case of failure
* @author Dina El Sissy
* @date 13 AUG 2012
* @version 1.0
*/
sint8 nm_uart_sync_cmd(void)
{
tstrNmUartDefault strUart;
sint8 s8Ret = -1;
uint8 b [HDR_SZ+1];
uint8 rsz;
uint8 onchip = 0;
/*read reg*/
b[0] = 0x12;
rsz = 1;
strUart.pu8Buf = b;
strUart.u16Sz = 1;
if(M2M_SUCCESS == nm_bus_ioctl(NM_BUS_IOCTL_W, &strUart))
{
strUart.u16Sz = rsz;
if(M2M_SUCCESS != nm_bus_ioctl(NM_BUS_IOCTL_R, &strUart))
{
s8Ret = M2M_ERR_BUS_FAIL;
}
}
else
{
M2M_ERR("failed to send cfg bytes\n");
s8Ret = M2M_ERR_BUS_FAIL;
}
if (b[0] == 0x5a)
{
s8Ret = 0;
onchip = 1;
M2M_INFO("Built-in WINC1500 UART Found\n");
}
else if(b[0] == 0x5b)
{
s8Ret = 0;
onchip = 0;
M2M_INFO("WINC1500 Serial Bridge Found\n");
}
/*TODO: this should be the way we read the register since the cortus is little endian*/
/**pu32RetVal = b[0] | ((uint32)b[1] << 8) | ((uint32)b[2] << 16) | ((uint32)b[3] << 24);*/
if(s8Ret == M2M_SUCCESS)
s8Ret = (sint8)onchip;
return s8Ret;
}
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_GRP_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;
}
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
Description
Creates a socket.
Return
- Negative value for error.
- ZERO or positive value as a socket ID if successful.
Author
Ahmed Ezzat
Version
1.0
Date
4 June 2012
*********************************************************************/
SOCKET socket(uint16 u16Domain, uint8 u8Type, uint8 u8Flags)
{
SOCKET sock = -1;
uint8 u8Count,u8SocketCount = MAX_SOCKET;
/* The only supported family is the AF_INET for UDP and TCP transport layer protocols. */
if(u16Domain == AF_INET)
{
if(u8Type == SOCK_STREAM)
{
u8SocketCount = TCP_SOCK_MAX;
u8Count = 0;
}
else if(u8Type == SOCK_DGRAM)
{
/*--- UDP SOCKET ---*/
u8SocketCount = MAX_SOCKET;
u8Count = TCP_SOCK_MAX;
}
else
return sock;
for(;u8Count < u8SocketCount; u8Count ++)
{
if(gastrSockets[u8Count].bIsUsed == 0)
{
gastrSockets[u8Count].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[u8Count].u16SessionID = gu16SessionID;
M2M_INFO("1 Socket %d session ID = %d\r\n",u8Count, gu16SessionID );
sock = (SOCKET)u8Count;
if(u8Flags & SOCKET_FLAGS_SSL)
{
tstrSSLSocketCreateCmd strSSLCreate;
strSSLCreate.sslSock = sock;
gastrSockets[u8Count].u8SSLFlags = SSL_FLAGS_ACTIVE;
SOCKET_REQUEST(SOCKET_CMD_SSL_CREATE, (uint8*)&strSSLCreate, sizeof(tstrSSLSocketCreateCmd), 0, 0, 0);
}
break;
}
}
}
return sock;
}
/*********************************************************************
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);
}
}
uint32 spi_flash_get_size(void)
{
sint8 ret = M2M_SUCCESS;
uint32 u32FlashId = 0, u32FlashPwr = 0;
if(!gu32InernalFlashSize)
{
ret = spi_flash_probe(&u32FlashId);
if((u32FlashId != 0xffffffff)&&(ret == M2M_SUCCESS))
{
/*flash size is the third byte from the FLASH RDID*/
u32FlashPwr = ((u32FlashId>>16)&0xff) - 0x11; /*2MBIT is the min*/
/*That number power 2 to get the flash size*/
gu32InernalFlashSize = 1<<u32FlashPwr;
M2M_INFO("Flash Size %d MBit\n",gu32InernalFlashSize);
}
/**
* @fn spi_flash_get_size
* @brief Get size of SPI Flash
* @return Size of Flash
*/
uint32 spi_flash_get_size(void)
{
uint32 u32FlashId = 0, u32FlashPwr = 0;
static uint32 gu32InernalFlashSize= 0;
if(!gu32InernalFlashSize)
{
u32FlashId = spi_flash_rdid();//spi_flash_probe();
if(u32FlashId != 0xffffffff)
{
/*flash size is the third byte from the FLASH RDID*/
u32FlashPwr = ((u32FlashId>>16)&0xff) - 0x11; /*2MBIT is the min*/
/*That number power 2 to get the flash size*/
gu32InernalFlashSize = 1<<u32FlashPwr;
M2M_INFO("Flash Size %lu Mb\n",gu32InernalFlashSize);
}
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);
}
}
/*
* @fn nm_drv_init_download_mode
* @brief Initialize NMC1000 driver
* @return M2M_SUCCESS in case of success and Negative error code in case of failure
* @param [in] arg
* Generic argument
* @author Viswanathan Murugesan
* @date 10 Oct 2014
* @version 1.0
*/
sint8 nm_drv_init_download_mode()
{
sint8 ret = M2M_SUCCESS;
ret = nm_bus_iface_init(NULL);
if (M2M_SUCCESS != ret) {
M2M_ERR("[nmi start]: fail init bus\n");
goto ERR1;
}
#ifdef CONF_WINC_USE_SPI
/* Must do this after global reset to set SPI data packet size. */
nm_spi_init();
#endif
M2M_INFO("Chip ID %lx\n", nmi_get_chipid());
/*disable all interrupt in ROM (to disable uart) in 2b0 chip*/
nm_write_reg(0x20300,0);
ERR1:
return ret;
}
sint8 hif_send(uint8 u8Gid,uint8 u8Opcode,uint8 *pu8CtrlBuf,uint16 u16CtrlBufSize,
uint8 *pu8DataBuf,uint16 u16DataSize, uint16 u16DataOffset)
{
sint8 ret = M2M_ERR_SEND;
volatile tstrHifHdr strHif;
strHif.u8Opcode = u8Opcode&(~NBIT7);
strHif.u8Gid = u8Gid;
strHif.u16Length = M2M_HIF_HDR_OFFSET;
if(pu8DataBuf != NULL)
{
strHif.u16Length += u16DataOffset + u16DataSize;
}
else
{
strHif.u16Length += u16CtrlBufSize;
}
ret = hif_chip_wake();
if(ret == M2M_SUCCESS)
{
volatile uint32 reg, dma_addr = 0;
volatile uint16 cnt = 0;
//#define OPTIMIZE_BUS
/*please define in firmware also*/
#ifndef OPTIMIZE_BUS
reg = 0UL;
reg |= (uint32)u8Gid;
reg |= ((uint32)u8Opcode<<8);
reg |= ((uint32)strHif.u16Length<<16);
ret = nm_write_reg(NMI_STATE_REG,reg);
if(M2M_SUCCESS != ret) goto ERR1;
reg = 0UL;
reg |= NBIT1;
ret = nm_write_reg(WIFI_HOST_RCV_CTRL_2, reg);
if(M2M_SUCCESS != ret) goto ERR1;
#else
reg = 0UL;
reg |= NBIT1;
reg |= ((u8Opcode & NBIT7) ? (NBIT2):(0)); /*Data = 1 or config*/
reg |= (u8Gid == M2M_REQ_GROUP_IP) ? (NBIT3):(0); /*IP = 1 or non IP*/
reg |= ((uint32)strHif.u16Length << 4); /*length of pkt max = 4096*/
ret = nm_write_reg(WIFI_HOST_RCV_CTRL_2, reg);
if(M2M_SUCCESS != ret) goto ERR1;
#endif
dma_addr = 0;
for(cnt = 0; cnt < 1000; cnt ++)
{
ret = nm_read_reg_with_ret(WIFI_HOST_RCV_CTRL_2,(uint32 *)®);
if(ret != M2M_SUCCESS) break;
/*
* If it takes too long to get a response, the slow down to
* avoid back-to-back register read operations.
*/
if(cnt >= 500) {
if(cnt < 501) {
M2M_INFO("Slowing down...\n");
}
nm_bsp_sleep(1);
}
if (!(reg & NBIT1))
{
ret = nm_read_reg_with_ret(WIFI_HOST_RCV_CTRL_4,(uint32 *)&dma_addr);
if(ret != M2M_SUCCESS) {
/*in case of read error clear the DMA address and return error*/
dma_addr = 0;
goto ERR1;
}
/*in case of success break */
break;
}
}
if (dma_addr != 0)
{
volatile uint32 u32CurrAddr;
u32CurrAddr = dma_addr;
strHif.u16Length=NM_BSP_B_L_16(strHif.u16Length);
ret = nm_write_block(u32CurrAddr, (uint8*)&strHif, M2M_HIF_HDR_OFFSET);
if(M2M_SUCCESS != ret) goto ERR1;
u32CurrAddr += M2M_HIF_HDR_OFFSET;
if(pu8CtrlBuf != NULL)
{
ret = nm_write_block(u32CurrAddr, pu8CtrlBuf, u16CtrlBufSize);
if(M2M_SUCCESS != ret) goto ERR1;
u32CurrAddr += u16CtrlBufSize;
}
if(pu8DataBuf != NULL)
{
u32CurrAddr += (u16DataOffset - u16CtrlBufSize);
ret = nm_write_block(u32CurrAddr, pu8DataBuf, u16DataSize);
if(M2M_SUCCESS != ret) goto ERR1;
u32CurrAddr += u16DataSize;
}
reg = dma_addr << 2;
reg |= NBIT1;
ret = nm_write_reg(WIFI_HOST_RCV_CTRL_3, reg);
if(M2M_SUCCESS != ret) goto ERR1;
}
else
{
ret = hif_chip_sleep();
M2M_DBG("Failed to alloc rx size %d\r",ret);
ret = M2M_ERR_MEM_ALLOC;
goto ERR2;
}
}
else
{
M2M_ERR("(HIF)Fail to wakup the chip\n");
goto ERR2;
}
/*actual sleep ret = M2M_SUCCESS*/
ret = hif_chip_sleep();
return ret;
ERR1:
/*reset the count but no actual sleep as it already bus error*/
hif_chip_sleep_sc();
ERR2:
/*logical error*/
return ret;
}
/*
* @fn nm_drv_init
* @brief Initialize NMC1000 driver
* @return M2M_SUCCESS in case of success and Negative error code in case of failure
* @param [in] arg
* Generic argument
* @author M. Abdelmawla
* @date 15 July 2012
* @version 1.0
*/
sint8 nm_drv_init(void * arg)
{
tstrM2mRev strtmp;
sint8 ret = M2M_SUCCESS;
uint8 u8Mode = M2M_WIFI_MODE_NORMAL;
if(NULL != arg) {
if(M2M_WIFI_MODE_CONFIG == *((uint8 *)arg)) {
u8Mode = M2M_WIFI_MODE_CONFIG;
} else {
/*continue running*/
}
} else {
/*continue running*/
}
ret = nm_bus_iface_init(NULL);
if (M2M_SUCCESS != ret) {
M2M_ERR("[nmi start]: fail init bus\n");
goto ERR1;
}
#ifdef BUS_ONLY
return;
#endif
#ifdef NO_HW_CHIP_EN
ret = chip_wake();
nm_bsp_sleep(10);
if (M2M_SUCCESS != ret) {
M2M_ERR("[nmi start]: fail chip_wakeup\n");
goto ERR2;
}
/**
Go...
**/
ret = chip_reset();
if (M2M_SUCCESS != ret) {
goto ERR2;
}
#endif
M2M_INFO("Chip ID %lx\n", nmi_get_chipid());
#ifdef CONF_WINC_USE_SPI
/* Must do this after global reset to set SPI data packet size. */
nm_spi_init();
#endif
#ifdef NO_HW_CHIP_EN
/*return power save to default value*/
chip_idle();
ret = cpu_start();
if (M2M_SUCCESS != ret) {
goto ERR2;
}
#endif
ret = wait_for_bootrom(u8Mode);
if (M2M_SUCCESS != ret) {
goto ERR2;
}
ret = wait_for_firmware_start(u8Mode);
if (M2M_SUCCESS != ret) {
goto ERR2;
}
if(M2M_WIFI_MODE_CONFIG == u8Mode) {
goto ERR1;
} else {
/*continue running*/
}
ret = enable_interrupts();
if (M2M_SUCCESS != ret) {
M2M_ERR("failed to enable interrupts..\n");
goto ERR2;
}
ret = nm_get_firmware_info(&strtmp);
M2M_INFO("Firmware ver : %u.%u.%u\n", strtmp.u8FirmwareMajor, strtmp.u8FirmwareMinor, strtmp.u8FirmwarePatch);
M2M_INFO("Min driver ver : %u.%u.%u\n", strtmp.u8DriverMajor, strtmp.u8DriverMinor, strtmp.u8DriverPatch);
M2M_INFO("Curr driver ver: %u.%u.%u\n", M2M_DRIVER_VERSION_MAJOR_NO, M2M_DRIVER_VERSION_MINOR_NO, M2M_DRIVER_VERSION_PATCH_NO);
if(strtmp.u8FirmwareMajor != M2M_DRIVER_VERSION_MAJOR_NO
|| strtmp.u8FirmwareMinor != M2M_DRIVER_VERSION_MINOR_NO)
{
ret = M2M_ERR_FW_VER_MISMATCH;
M2M_ERR("Firmware version mismatch!\n");
}
return ret;
ERR2:
nm_bus_iface_deinit();
ERR1:
return ret;
}
/**
* @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);
}
}
#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);
}
}
