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); } }