465 lines
14 KiB
C
465 lines
14 KiB
C
#ifndef __LWIP_SYSARCH_H__
|
|
#define __LWIP_SYSARCH_H__
|
|
|
|
#include "opt.h"
|
|
#include "err.h"
|
|
#include "cc.h"
|
|
#include "debug.h"
|
|
#include "mem.h"
|
|
#include <stdlib.h>
|
|
|
|
typedef UINT32 sys_prot_t;
|
|
typedef void * sys_mutex_t;
|
|
typedef void * sys_sem_t;
|
|
typedef void * sys_mbox_t;
|
|
typedef void * sys_thread_t;
|
|
typedef void (*printCallback) (char *printstr);
|
|
typedef void (*lwip_thread_fn) (void *pArgs);
|
|
typedef err_t (*lwip_run_entry) (void *pArgs);
|
|
|
|
/*The interface is adapter to AT cmder*/
|
|
struct lwip_thread_msgq_msg_st {
|
|
u32_t msgID;
|
|
void *pArgs;
|
|
printCallback print;
|
|
lwip_run_entry run_entry;
|
|
};
|
|
|
|
extern u8_t lwip_init_flag;
|
|
extern u8_t lwip_urt_debug;
|
|
extern u8_t lwip_rtiline_debug;
|
|
extern u8_t lwip_mifi_flag;
|
|
extern u8_t lwip_hop_limit;
|
|
extern u32_t lwip_rng_num;
|
|
extern u32_t g_server_ip;
|
|
|
|
extern msg_t msg_null;
|
|
extern UINT8 booting_done;
|
|
extern UINT32 uart_initialized;
|
|
|
|
/** Return code for timeouts from sys_arch_mbox_fetch and sys_arch_sem_wait */
|
|
#define SYS_ARCH_TIMEOUT 0xffffffffUL
|
|
|
|
/** sys_mbox_tryfetch() returns SYS_MBOX_EMPTY if appropriate.
|
|
* For now we use the same magic value, but we allow this to change in future.
|
|
*/
|
|
#define SYS_MBOX_EMPTY SYS_ARCH_TIMEOUT
|
|
#define SYS_MBOX_NULL NULL
|
|
#define SYS_SEM_NULL NULL
|
|
|
|
/*Note:should keep the same value as uart.h define*/
|
|
#define UART_INIT_DONE_TEMP_HERE 0xDEAFBEED
|
|
|
|
/*define DNS set pos*/
|
|
#define NETIF_SET_DNS_SERVER (1) /*set dns relay server using netif config*/
|
|
#define WEB_SET_DNS_SERVER (2) /*set dns relay server by webui config*/
|
|
#define API_SET_DNS_SERVER (3) /*set dns relay server by lwip_api function*/
|
|
#define RESET_DEFAULT_DNS_SERVER (0xFF) /*reset dns relay server by default netif*/
|
|
|
|
#define LWIP_PLATFORM_DONGLE_MODE (0)
|
|
#define LWIP_PLATFORM_MIFI_MODE (1)
|
|
#define LWIP_PLATFORM_BRIDGE_MODE (2)
|
|
#define LWIP_PLATFORM_DEFINE_END (3)
|
|
|
|
#define LWIP_TESTMODE_NORMAL (0)
|
|
#define LWIP_TESTMODE_IOT_MODE (1)
|
|
#define LWIP_TESTMODE_MINIDP (2)
|
|
#define LWIP_TESTMODE_DEFINE_END (3)
|
|
|
|
#define LWIP_UPDATE (2)
|
|
#define LWIP_ENABLE (1)
|
|
#define LWIP_DISABLE (0)
|
|
#define LWIP_TASK_PENDING (0)
|
|
#define LWIP_TASK_RUNING (1)
|
|
#define LWIP_TASK_EXITING (2)
|
|
#define NEWLINE "\r\n"
|
|
|
|
#define U32_DIFF(a, b) (((a) >= (b)) ? ((a) - (b)) : (((a) + ((b) ^ 0xFFFFFFFF) + 1)))
|
|
#if 0
|
|
#define MAKE_HASH_KEY(ipaddr, flg, port) ((ipaddr)&0xFF000000|(flg)|(port))
|
|
#define MAKE_HASH_KEY_2(ipaddr, port) ((ipaddr)&0xFFFF0000|(port))
|
|
#endif
|
|
/*ipaddr 8bit; sport 16bit; dport 4bit; flag 4bit*/
|
|
#define MAKE_HASH_KEY_NEW(ipaddr, sport, dport, flg) ((ipaddr)&0xFF000000|(sport)|(dport)|(flg))
|
|
#define LWIP_FLAGS_HOTBIT_CHECK(flags, hotbit) (((flags) & (hotbit)) ? 1 : 0)
|
|
#define LWIP_FLAGS_HOTBIT_CLEAR(flags, hotbit) ((flags) &= ~(hotbit))
|
|
#define LWIP_FLAGS_HOTBIT_SET(flags, hotbit) ((flags) |= (hotbit))
|
|
|
|
|
|
#define IS_LWIP_DONGLE_MODE (LWIP_PLATFORM_DONGLE_MODE == lwip_mifi_flag)
|
|
#define IS_LWIP_MIFI_MODE (LWIP_PLATFORM_MIFI_MODE == lwip_mifi_flag)
|
|
#define IS_LWIP_BRIDGE_MODE (LWIP_PLATFORM_BRIDGE_MODE == lwip_mifi_flag)
|
|
#define IS_NOT_LWIP_MIFI_MODE (LWIP_PLATFORM_MIFI_MODE != lwip_mifi_flag) /*maybe dongle or bridge, bridge mode based on dongle*/
|
|
|
|
/* 169.254.x.x */
|
|
#define IP_169_254_HEADER (0xFEA9)
|
|
#define IS_IP_169_254(addr) (((addr)&0xFFFF) == IP_169_254_HEADER)
|
|
#define IP_169_254_ADDR (0x0100FEA9)
|
|
|
|
/* 127.0.0.1 */
|
|
#define IP_LOOPBACK_ADDRESS (0x100007F)
|
|
|
|
/* 192.168.x.x */
|
|
#define IP_192_168_HEADER (0xA8C0)
|
|
#define IS_IP_192_168(addr) (((addr)&0xFFFF) == IP_192_168_HEADER)
|
|
#define IP_192_168_ADDR (0x0100A8C0)
|
|
|
|
#define IP4_IS_BROADCAST(ip, pc) ((((ip)&0xFFFFFF) == ((pc)&0xFFFFFF))&& (((ip)>>24) == 0xFF))
|
|
/* ip is packet ip address, pc is pc ip address*/
|
|
#define IP4_ROUTER_PC(ip, pc) (IP4_IS_BROADCAST(ip, pc) || ((ip) == (pc)))
|
|
/* addr is in network order */
|
|
#define IS_LOCAL_IP_ADDR(addr) (((addr)&0xFFFFFF) == (htonl(g_server_ip) & 0xFFFFFF))
|
|
#define IS_ROUTER_IP_ADDR(addr) ((addr) == htonl(g_server_ip))
|
|
#define is_for_mifi(addr) (((addr) & 0xFFFFFF) == (dhcpd_router_ip() & 0xFFFFFF))
|
|
#define is_broadcast(addr) ((addr) == 0xFFFFFFFF)
|
|
|
|
/* 1 tick is 5 ms */
|
|
#define SYS_ONE_TICK (5)
|
|
#define SYS_ONE_SECOND (1000/SYS_ONE_TICK)
|
|
|
|
#define LWIP_RAND lwip_sys_rand
|
|
|
|
u32_t rti_get_current_tick(void);
|
|
u8_t InProduction_Mode(void);
|
|
u32_t disableInterrupts(void);
|
|
void restoreInterrupts(u32_t cpsr);
|
|
void RTI_LOG(const char* fmt, ...);
|
|
void LWIP_LOG(const char *fmt, ...);
|
|
void lwipCheckHeapMem( void *pMem );
|
|
|
|
/* modify by shimingrui */
|
|
#if 0
|
|
OSA_STATUS OsaSemaphoreCheck( OsaRefT OsaRef);
|
|
OsaRefT OsaCurrentThreadRef(void);
|
|
u32_t OSATaskGetSysParam1(OSATaskRef OsaRef);
|
|
void OSATaskSetSysParam1(OSATaskRef OsaRef, u32_t value);
|
|
#endif
|
|
|
|
#if LWIP_RECORED_LINE_FLAG
|
|
void lwip_record_line(const char *string, unsigned int line);
|
|
void lwip_dump_rtilog(void);
|
|
#else
|
|
#define lwip_record_line(a, b)
|
|
#define lwip_dump_rtilog()
|
|
#endif
|
|
void lwip_assert_now_callback(void * ctx);
|
|
void lwip_record_assert(const char *string, unsigned int line);
|
|
|
|
#if LWIP_DEBUG
|
|
/*LWIP_DIAG, using diagprintf*/
|
|
/*debug, define on debug.h, macro*/
|
|
/*cat3, using lwip_filename_linenumber format to define.*/
|
|
#define LWIP_DIAG(debug, cat3, fmt, args...) \
|
|
{ \
|
|
if (LWIP_DEBUGF_SWITCH_CHECK(debug)) \
|
|
{ \
|
|
DIAG_FILTER(MIFI, LWIP, cat3, DIAG_INFORMATION) \
|
|
diagPrintf(fmt, ##args); \
|
|
lwip_record_line(__FUNCTION__, __LINE__); \
|
|
} \
|
|
}
|
|
#else
|
|
#define LWIP_DIAG(debug, cat3, fmt, args...)
|
|
#endif
|
|
|
|
/*LWIP_DIAG_S, using diagprintf, but no DEBUG check*/
|
|
/*DEBUG check will only do once at begining */
|
|
/*debug, define on debug.h, macro*/
|
|
/*cat3, using lwip_filename_linenumber format to define.*/
|
|
#define LWIP_DIAG_S(cat3, fmt, args...) \
|
|
{ \
|
|
if(!IS_DIAG_BLOCKED){ \
|
|
DIAG_FILTER(MIFI, LWIP, cat3, DIAG_INFORMATION) \
|
|
diagPrintf(fmt, ##args); \
|
|
lwip_record_line(__FUNCTION__, __LINE__); \
|
|
} \
|
|
}
|
|
|
|
#define LWIP_DIAG_STRUCT(debug, cat3, fmt, buffer, length) \
|
|
{ \
|
|
if(!IS_DIAG_BLOCKED){ \
|
|
DIAG_FILTER(MIFI, LWIP, cat3, DIAG_INFORMATION) \
|
|
diagStructPrintf(fmt, buffer, length); \
|
|
} \
|
|
}
|
|
|
|
#define RETURN(x, cat3) \
|
|
do { \
|
|
LWIP_DIAG(DIAG_ON_DEBUG, cat3, "ERR_RTE in %s, line %d", __FUNCTION__, __LINE__); \
|
|
return (x); \
|
|
} while(0)
|
|
|
|
static inline u8_t lwip_assert_fn(u8_t assertion, const char *function, unsigned int line)
|
|
{
|
|
if (1 == assertion) {
|
|
return 0;
|
|
} else {
|
|
lwip_record_assert(function, line);
|
|
return 1;
|
|
}
|
|
|
|
}
|
|
#define LWIP_ASSERT(assertion) lwip_assert_fn((assertion), __FUNCTION__, __LINE__)
|
|
|
|
/*******************************************************************/
|
|
/********************Global inline function define *****************/
|
|
/*******************************************************************/
|
|
u32_t lwip_sys_rand(void);
|
|
void sys_init(void);
|
|
void sys_msleep(u32_t ms);
|
|
void sys_thread_delete(sys_thread_t thread);
|
|
int sys_thread_check(sys_thread_t thread);
|
|
sys_thread_t sys_thread_new(const char *name, lwip_thread_fn thread,
|
|
void *arg, int stacksize, int prio);
|
|
#if IS_LWIP_PLATFORM_1802_1802S
|
|
sys_thread_t sys_thread_tcpip(const char *name, lwip_thread_fn thread,
|
|
void *arg, int stacksize, int prio);
|
|
#endif
|
|
#if 0
|
|
u32_t sys_disableInterrupts_fn(const char* fun, const int line);
|
|
void sys_restoreInterrupts_fn(u32_t cpsr, const char* fun, const int line);
|
|
#define sys_disableInterrupts() sys_disableInterrupts_fn(__FUNCTION__, __LINE__)
|
|
#define sys_restoreInterrupts(cpsr) sys_restoreInterrupts_fn((cpsr), __FUNCTION__, __LINE__)
|
|
|
|
#if LWIP_SYS_PROTECT_USING_MUTEX
|
|
void sys_arch_protect(sys_prot_t* pval);
|
|
void sys_arch_unprotect(sys_prot_t val);
|
|
#else
|
|
void sys_arch_protect_fn(sys_prot_t* pval, const char* fun, const int line);
|
|
void sys_arch_unprotect_fn(sys_prot_t val, const char* fun, const int line);
|
|
#define sys_arch_protect(pval) sys_arch_protect_fn((pval), __FUNCTION__, __LINE__)
|
|
#define sys_arch_unprotect(val) sys_arch_unprotect_fn((val), __FUNCTION__, __LINE__)
|
|
#endif
|
|
#endif
|
|
|
|
static inline u32_t sys_disableInterrupts_fn(const char* fun, const int line)
|
|
{
|
|
lwip_record_line(fun, line);
|
|
return disableInterrupts();
|
|
}
|
|
static inline void sys_restoreInterrupts_fn(u32_t cpsr, const char* fun, const int line)
|
|
{
|
|
lwip_record_line(fun, line);
|
|
restoreInterrupts(cpsr);
|
|
}
|
|
#define sys_disableInterrupts() sys_disableInterrupts_fn(__FUNCTION__, __LINE__)
|
|
#define sys_restoreInterrupts(cpsr) sys_restoreInterrupts_fn((cpsr), __FUNCTION__, __LINE__)
|
|
|
|
static inline void sys_arch_protect_fn(sys_prot_t* pval, const char* fun, const int line)
|
|
{
|
|
lwip_record_line(fun, line);
|
|
*pval = disableInterrupts();
|
|
}
|
|
static inline void sys_arch_unprotect_fn(sys_prot_t val, const char* fun, const int line)
|
|
{
|
|
lwip_record_line(fun, line);
|
|
restoreInterrupts(val);
|
|
}
|
|
#define sys_arch_protect(pval) sys_arch_protect_fn((pval), __FUNCTION__, __LINE__)
|
|
#define sys_arch_unprotect(val) sys_arch_unprotect_fn((val), __FUNCTION__, __LINE__)
|
|
|
|
/* modify by shimingrui */
|
|
#if 0
|
|
static inline int sys_sem_valid(sys_sem_t *sem)
|
|
{
|
|
if (OS_SUCCESS == OSASemaphoreCheck (*sem)) {
|
|
#if IS_LWIP_PLATFORM_1802_1802S
|
|
lwipCheckHeapMem(*sem);
|
|
#endif
|
|
return 1;
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
static inline err_t sys_sem_new(sys_sem_t *sem, u8_t count)
|
|
{
|
|
OSA_STATUS status;
|
|
|
|
status = OSASemaphoreCreate(sem, count, OS_FIFO);
|
|
ASSERT(OS_SUCCESS == status);
|
|
return ERR_OK;
|
|
}
|
|
|
|
static inline void sys_sem_free(sys_sem_t *sem)
|
|
{
|
|
if (sys_sem_valid(sem)) {
|
|
OSASemaphoreDelete(*sem);
|
|
*sem = SYS_SEM_NULL;
|
|
} else {
|
|
/*for inline function, must use LWIP_DEBUGF*/
|
|
LWIP_DEBUGF(DIAG_ON_DEBUG, ("lwiperr: sys_sem_free, sys_sem_valid failed, sem=%lx", sem));
|
|
}
|
|
}
|
|
|
|
static inline void sys_sem_set_invalid(sys_sem_t *sem)
|
|
{
|
|
*sem = SYS_SEM_NULL;
|
|
}
|
|
|
|
static inline void sys_sem_signal(sys_sem_t *sem)
|
|
{
|
|
if (OS_SUCCESS == OSASemaphoreCheck (*sem)) {
|
|
OSASemaphoreRelease(*sem);
|
|
} else {
|
|
/*for inline function, must use LWIP_DEBUGF*/
|
|
LWIP_DEBUGF(DIAG_ON_DEBUG, ("lwiperr: sys_sem_signal, OSASemaphoreCheck failed, sem=%lx", sem));
|
|
}
|
|
}
|
|
|
|
static inline u32_t sys_arch_sem_wait(sys_sem_t *sem, u32_t timeout)
|
|
{
|
|
OSA_STATUS status;
|
|
int count;
|
|
|
|
if (OS_SUCCESS != OSASemaphoreCheck (*sem))
|
|
{
|
|
/*for inline function, must use LWIP_DEBUGF*/
|
|
LWIP_DEBUGF(DIAG_ON_DEBUG, ("fatal warning! fun: %s, line: %d, semsig: %lx", __FUNCTION__, __LINE__, *sem));
|
|
return SYS_ARCH_TIMEOUT;
|
|
}
|
|
|
|
if (timeout == 0) {
|
|
status = OSASemaphoreAcquire(*sem, OSA_SUSPEND);
|
|
} else {
|
|
count = (timeout+(SYS_ONE_TICK-1))/SYS_ONE_TICK;
|
|
status = OSASemaphoreAcquire(*sem, count);
|
|
}
|
|
|
|
if (OS_SUCCESS == status) {
|
|
return ERR_OK;
|
|
}
|
|
return SYS_ARCH_TIMEOUT;
|
|
}
|
|
|
|
static inline err_t sys_mbox_new(sys_mbox_t *mbox, int size)
|
|
{
|
|
OSA_STATUS status;
|
|
|
|
status = OSAMsgQCreate( mbox,
|
|
#ifdef OSA_QUEUE_NAMES
|
|
"lwipMbox",
|
|
#endif
|
|
MBOX_MAX_SIZE,
|
|
size,
|
|
OS_FIFO);
|
|
ASSERT(OS_SUCCESS == status);
|
|
return ERR_OK;
|
|
}
|
|
|
|
static inline void sys_mbox_poll(sys_mbox_t *mbox, u32_t *count)
|
|
{
|
|
OSAMsgQPoll( *mbox, count);
|
|
}
|
|
|
|
static inline void sys_mbox_post(sys_mbox_t *mbox, msg_t msg)
|
|
{
|
|
msg_t* msg_ptr;
|
|
msg_ptr = (msg != NULL) ? (&msg) : (&msg_null);
|
|
|
|
OSAMsgQSend( *mbox,
|
|
sizeof(void*),
|
|
(UINT8*)msg_ptr,
|
|
OSA_SUSPEND);
|
|
}
|
|
|
|
static inline err_t sys_mbox_trypost(sys_mbox_t *mbox, msg_t msg)
|
|
{
|
|
OSA_STATUS status;
|
|
msg_t* msg_ptr;
|
|
u32_t nums = 0;
|
|
|
|
msg_ptr = (msg != NULL) ? (&msg) : (&msg_null);
|
|
while (nums++ < 5)
|
|
{
|
|
status = OSAMsgQSend( *mbox,
|
|
sizeof(void*),
|
|
(UINT8*)msg_ptr,
|
|
OSA_NO_SUSPEND);
|
|
|
|
if (OS_SUCCESS == status)
|
|
{
|
|
return ERR_OK;
|
|
}
|
|
}
|
|
return ERR_MEM;
|
|
}
|
|
|
|
static inline u32_t sys_arch_mbox_fetch(sys_mbox_t *mbox, msg_t* msg, u32_t timeout)
|
|
{
|
|
OSA_STATUS status;
|
|
int count;
|
|
|
|
if (timeout == 0) {
|
|
status = OSAMsgQRecv( *mbox, (UINT8*)msg, sizeof(void*), OSA_SUSPEND);
|
|
} else {
|
|
count = (timeout+(SYS_ONE_TICK-1))/SYS_ONE_TICK;
|
|
status = OSAMsgQRecv( *mbox, (UINT8*)msg, sizeof(void*), count);
|
|
}
|
|
|
|
if (OS_SUCCESS == status) {
|
|
return ERR_OK;
|
|
}
|
|
|
|
return SYS_ARCH_TIMEOUT;
|
|
}
|
|
|
|
static inline u32_t sys_arch_mbox_tryfetch(sys_mbox_t *mbox, msg_t* msg)
|
|
{
|
|
return sys_arch_mbox_fetch(mbox, msg, 5*SYS_ONE_TICK);
|
|
}
|
|
|
|
static inline u32_t sys_arch_mbox_tryfetch_nosuspend(sys_mbox_t *mbox, msg_t* msg)
|
|
{
|
|
OSA_STATUS status;
|
|
|
|
status = OSAMsgQRecv( *mbox, (UINT8*)msg, sizeof(void*), OSA_NO_SUSPEND);
|
|
|
|
if (OS_SUCCESS == status) {
|
|
return ERR_OK;
|
|
}
|
|
return SYS_ARCH_TIMEOUT;
|
|
}
|
|
|
|
static inline void sys_mbox_free(sys_mbox_t *mbox)
|
|
{
|
|
if (*mbox) {
|
|
OSAMsgQDelete(*mbox);
|
|
*mbox = SYS_MBOX_NULL;
|
|
}
|
|
}
|
|
|
|
static inline int sys_mbox_valid(sys_mbox_t *mbox)
|
|
{
|
|
return SYS_MBOX_NULL != *mbox;
|
|
}
|
|
|
|
static inline void sys_mbox_set_invalid(sys_mbox_t *mbox)
|
|
{
|
|
*mbox = SYS_MBOX_NULL;
|
|
}
|
|
|
|
|
|
static inline u32_t sys_jiffies(void)
|
|
{
|
|
return (OSAGetTicks() * SYS_ONE_TICK);
|
|
}
|
|
|
|
static inline u32_t sys_now(void)
|
|
{
|
|
return (OSAGetTicks() * SYS_ONE_TICK);
|
|
}
|
|
|
|
static inline u32_t sys_now_tick(void)
|
|
{
|
|
return OSAGetTicks();
|
|
}
|
|
|
|
static inline u32_t sys_gen_rand()
|
|
{
|
|
u32_t rng = LWIP_RAND() + lwip_rng_num;
|
|
return rng;
|
|
}
|
|
#endif
|
|
#endif /* __LWIP_SYSARCH_H__ */
|