diff --git a/rtthread_patch/os/rtthread_service.c b/rtthread_patch/os/rtthread_service.c index 078cf52..966334d 100644 --- a/rtthread_patch/os/rtthread_service.c +++ b/rtthread_patch/os/rtthread_service.c @@ -1,156 +1,192 @@ /* rtthread includes */ -#include + #include +#include +#ifdef SECTION +#undef SECTION +#endif +#include +#include #include -#include -//#include + +// #define RTTHREAD_SERVICE_DEBUG +#define RTTHREAD_SERVICE_DEBUG_LEVEL 2 /********************* os depended utilities ********************/ +#ifdef RTTHREAD_SERVICE_DEBUG +#define DEBUG_LOG(_level, fmt, args...) if ((_level) >= RTTHREAD_SERVICE_DEBUG_LEVEL) rt_kprintf(fmt, args) +#else +#define DEBUG_LOG(level, fmt, args...) +#endif #ifndef USE_MUTEX_FOR_SPINLOCK #define USE_MUTEX_FOR_SPINLOCK 1 #endif -rt_uint16_t ameba_sem = 0; -rt_uint16_t ameba_mutex = 0; -rt_uint16_t ameba_spin = 0; - -//----- ------------------------------------------------------------------ -// Misc Function -//----- ------------------------------------------------------------------ +extern uint32_t pmu_yield_os_check(void); +extern _LONG_CALL_ void DelayUs(u32 us); +extern _LONG_CALL_ void DelayMs(u32 ms); +extern uint32_t pmu_set_sysactive_time(uint32_t timeout_ms); void save_and_cli(void) { + DEBUG_LOG(1, "L:%d fun:%s runing...\n", __LINE__, __FUNCTION__); rt_enter_critical(); } void restore_flags(void) { + DEBUG_LOG(1, "L:%d fun:%s runing...\n", __LINE__, __FUNCTION__); rt_exit_critical(); } void cli(void) { + DEBUG_LOG(1, "L:%d fun:%s runing...\n", __LINE__, __FUNCTION__); rt_hw_interrupt_disable(); } /* Not needed on 64bit architectures */ static unsigned int __div64_32(u64 *n, unsigned int base) { - u64 rem = *n; - u64 b = base; - u64 res, d = 1; - unsigned int high = rem >> 32; + u64 rem = *n; + u64 b = base; + u64 res, d = 1; + unsigned int high = rem >> 32; - /* Reduce the thing a bit first */ - res = 0; - if (high >= base) { - high /= base; - res = (u64) high << 32; - rem -= (u64) (high * base) << 32; - } + /* Reduce the thing a bit first */ + res = 0; + if (high >= base) { + high /= base; + res = (u64) high << 32; + rem -= (u64) (high * base) << 32; + } - while ((u64)b > 0 && b < rem) { - b = b+b; - d = d+d; - } + while ((u64)b > 0 && b < rem) { + b = b+b; + d = d+d; + } - do { - if (rem >= b) { - rem -= b; - res += d; - } - b >>= 1; - d >>= 1; - } while (d); + do { + if (rem >= b) { + rem -= b; + res += d; + } + b >>= 1; + d >>= 1; + } while (d); - *n = res; - return rem; + *n = res; + return rem; } /********************* os depended service ********************/ u8* _rtthread_malloc(u32 sz) { - u8 *pbuf = (u8 *)rt_malloc(sz); + void *pbuf; + DEBUG_LOG(2, "L:%d fun:%s sz:%d\n", __LINE__, __FUNCTION__, sz); + pbuf = rt_malloc(sz); return pbuf; } u8* _rtthread_zmalloc(u32 sz) { - u8 *pbuf = rt_malloc(sz); + void *pbuf = rt_malloc(sz); + + DEBUG_LOG(2, "L:%d fun:%s sz:%d\n", __LINE__, __FUNCTION__, sz); + if (pbuf != RT_NULL) + memset(pbuf, 0, sz); - if (pbuf != NULL) - memset(pbuf, 0, sz); - - return pbuf; + return pbuf; } void _rtthread_mfree(u8 *pbuf, u32 sz) { + DEBUG_LOG(2, "L:%d fun:%s\n", __LINE__, __FUNCTION__); rt_free(pbuf); } static void _rtthread_memcpy(void* dst, void* src, u32 sz) { - memcpy(dst, src, sz); + DEBUG_LOG(1, "L:%d fun:%s dst:0x%08x src:0x%08x sz:%d\n", __LINE__, __FUNCTION__, dst, src, sz); + memcpy(dst, src, sz); } static int _rtthread_memcmp(void *dst, void *src, u32 sz) { //under Linux/GNU/GLibc, the return value of memcmp for two same mem. chunk is 0 - if (!(memcmp(dst, src, sz))) - return 1; + DEBUG_LOG(1, "L:%d fun:%s dst:0x%08x src:0x%08x sz:%d\n", __LINE__, __FUNCTION__, dst, src, sz); + if (!(memcmp(dst, src, sz))) + return 1; - return 0; + return 0; } static void _rtthread_memset(void *pbuf, int c, u32 sz) { - memset(pbuf, c, sz); + DEBUG_LOG(1, "L:%d fun:%s buf:0x%08x c:%c sz:%d\n", __LINE__, __FUNCTION__, pbuf, c, sz); + memset(pbuf, c, sz); } static void _rtthread_init_sema(_sema *sema, int init_val) { char name[RT_NAME_MAX]; + static int ameba_sem = 0; + DEBUG_LOG(3, "L:%d fun:%s begin val:%d\n", __LINE__, __FUNCTION__, init_val); memset(name, 0, RT_NAME_MAX); - snprintf(name, RT_NAME_MAX, "sem-%04d", ameba_sem ++); - + snprintf(name, RT_NAME_MAX, "sem-%03d", ameba_sem); *sema = rt_sem_create(name, init_val, RT_IPC_FLAG_FIFO); + if (*sema != RT_NULL) + ameba_sem ++; + DEBUG_LOG(3, "L:%d fun:%s end sema:0x%08x num:%d\n", __LINE__, __FUNCTION__, *sema, ameba_sem); } static void _rtthread_free_sema(_sema *sema) { - if(*sema != NULL) - rt_sem_delete(*sema); + RT_ASSERT(*sema != RT_NULL); - *sema = NULL; + DEBUG_LOG(2, "L:%d fun:%s sema:0x%08x\n", __LINE__, __FUNCTION__, *sema); + rt_sem_delete(*sema); + *sema = RT_NULL; } static void _rtthread_up_sema(_sema *sema) { + if (*sema == RT_NULL) + { + rt_kprintf("err!! up sema is NULL\n"); + return; + } + DEBUG_LOG(2, "L:%d fun:%s sema:0x%08x\n", __LINE__, __FUNCTION__, *sema); rt_sem_release(*sema); } static void _rtthread_up_sema_from_isr(_sema *sema) { + if (*sema == RT_NULL) + { + rt_kprintf("err!! up sema from isr is NULL\n"); + return; + } + DEBUG_LOG(2, "L:%d fun:%s sema:0x%08x\n", __LINE__, __FUNCTION__, *sema); rt_sem_release(*sema); } static u32 _rtthread_down_sema(_sema *sema, u32 timeout) { rt_int32_t tick; - - if(timeout >= RT_TICK_MAX / 2) - { - tick = RT_WAITING_FOREVER; - } + + RT_ASSERT(*sema != RT_NULL); + + DEBUG_LOG(2, "L:%d fun:%s sema:0x%08x timeout:%d\n", __LINE__, __FUNCTION__, *sema, timeout); + + if(timeout >= RT_TICK_MAX / 2) + tick = RT_WAITING_FOREVER; else - { - tick = rtw_ms_to_systime(timeout); - } - + tick = rtw_ms_to_systime(timeout); + if(rt_sem_take(*sema, tick) != RT_EOK) return RT_FALSE; @@ -160,74 +196,91 @@ static u32 _rtthread_down_sema(_sema *sema, u32 timeout) static void _rtthread_mutex_init(_mutex *pmutex) { char name[RT_NAME_MAX]; + static int ameba_mutex = 0; + DEBUG_LOG(3, "L:%d fun:%s begin\n", __LINE__, __FUNCTION__); memset(name, 0, RT_NAME_MAX); - - snprintf(name, RT_NAME_MAX, "rmux-%03d", ameba_mutex ++); - + snprintf(name, RT_NAME_MAX, "mux-%03d", ameba_mutex); *pmutex = rt_mutex_create(name, RT_IPC_FLAG_FIFO); + if (*pmutex != RT_NULL) + ameba_mutex ++; + DEBUG_LOG(3, "L:%d fun:%s end pmutex:0x%08x\n", __LINE__, __FUNCTION__, *pmutex); } static void _rtthread_mutex_free(_mutex *pmutex) { - if(*pmutex != NULL) - rt_mutex_delete(*pmutex); + RT_ASSERT(*pmutex != RT_NULL); - *pmutex = NULL; + DEBUG_LOG(2, "L:%d fun:%s pmutex:0x%08x\n", __LINE__, __FUNCTION__, *pmutex); + rt_mutex_delete(*pmutex); + *pmutex = RT_NULL; } static void _rtthread_mutex_get(_lock *plock) { + RT_ASSERT(*plock != RT_NULL); + + DEBUG_LOG(2, "L:%d fun:%s pmutex:0x%08x\n", __LINE__, __FUNCTION__, *plock); rt_mutex_take(*plock, RT_WAITING_FOREVER); } static int _rtthread_mutex_get_timeout(_lock *plock, u32 timeout_ms) { rt_int32_t tick; - - if(timeout_ms >= RT_TICK_MAX / 2) - { - tick = RT_WAITING_FOREVER; - } + + RT_ASSERT(*plock != RT_NULL); + + DEBUG_LOG(2, "L:%d fun:%s plock:0x%08x timeout_ms:%d\n", __LINE__, __FUNCTION__, *plock, timeout_ms); + if(timeout_ms >= RT_TICK_MAX / 2) + tick = RT_WAITING_FOREVER; else - { - tick = rtw_ms_to_systime(timeout_ms); - } + tick = rtw_ms_to_systime(timeout_ms); return rt_mutex_take(*plock, tick); } static void _rtthread_mutex_put(_lock *plock) { + if (*plock == RT_NULL) + { + rt_kprintf("err!! mutex put is null\n"); + return; + } + DEBUG_LOG(2, "L:%d fun:%s pmutex:0x%08x\n", __LINE__, __FUNCTION__, *plock); rt_mutex_release(*plock); } static void _rtthread_enter_critical(_lock *plock, _irqL *pirqL) { + DEBUG_LOG(1, "L:%d fun:%s *pirqL:0x%08x\n", __LINE__, __FUNCTION__, *pirqL); rt_enter_critical(); } static void _rtthread_exit_critical(_lock *plock, _irqL *pirqL) { + DEBUG_LOG(1, "L:%d fun:%s *pirqL:0x%08x\n", __LINE__, __FUNCTION__, *pirqL); rt_exit_critical(); } -static u32 uxSavedInterruptStatus = 0; +// static rt_base_t level; static void _rtthread_enter_critical_from_isr(_lock *plock, _irqL *pirqL) { - rt_enter_critical(); + DEBUG_LOG(1, "L:%d fun:%s *pirqL:0x%08x\n", __LINE__, __FUNCTION__, *pirqL); + *pirqL = rt_hw_interrupt_disable(); } static void _rtthread_exit_critical_from_isr(_lock *plock, _irqL *pirqL) { - rt_exit_critical(); + DEBUG_LOG(1, "L:%d fun:%s *pirqL:0x%08x\n", __LINE__, __FUNCTION__, *pirqL); + rt_hw_interrupt_enable(*pirqL); } static int _rtthread_enter_critical_mutex(_mutex *pmutex, _irqL *pirqL) { - int result = rt_mutex_take(*pmutex, RT_WAITING_FOREVER); + RT_ASSERT(*pmutex != RT_NULL); - if(result != RT_EOK) + DEBUG_LOG(1, "L:%d fun:%s *pirqL:0x%08x\n", __LINE__, __FUNCTION__, *pirqL); + if(rt_mutex_take(*pmutex, RT_WAITING_FOREVER) != RT_EOK) return RT_FALSE; return RT_TRUE; @@ -235,6 +288,12 @@ static int _rtthread_enter_critical_mutex(_mutex *pmutex, _irqL *pirqL) static void _rtthread_exit_critical_mutex(_mutex *pmutex, _irqL *pirqL) { + if (*pmutex == RT_NULL) + { + rt_kprintf("err!! critical mutex is null\n"); + return; + } + DEBUG_LOG(1, "L:%d fun:%s *pirqL:0x%08x\n", __LINE__, __FUNCTION__, *pirqL); rt_mutex_release(*pmutex); } @@ -242,43 +301,63 @@ static void _rtthread_spinlock_init(_lock *plock) { #if USE_MUTEX_FOR_SPINLOCK char name[RT_NAME_MAX]; + static int ameba_spin = 0; + DEBUG_LOG(3, "L:%d fun:%s begin\n", __LINE__, __FUNCTION__); memset(name, 0, RT_NAME_MAX); - - snprintf(name, RT_NAME_MAX, "spin-03d", ameba_spin ++); - - *plock = rt_sem_create(name, 1, RT_IPC_FLAG_FIFO); + snprintf(name, RT_NAME_MAX, "spn-03d", ameba_spin); + *plock = rt_mutex_create(name, RT_IPC_FLAG_FIFO); + if (*plock != RT_NULL) + ameba_spin ++; + DEBUG_LOG(3, "L:%d fun:%s end plock:0x%08x ameba_spin:%d\n", __LINE__, __FUNCTION__, *plock, ameba_spin); #endif } static void _rtthread_spinlock_free(_lock *plock) { #if USE_MUTEX_FOR_SPINLOCK - if(*plock != NULL) - rt_sem_delete(*plock); + // RT_ASSERT(*plock != RT_NULL); + if (*plock == RT_NULL) + return; - *plock = NULL; + DEBUG_LOG(2, "L:%d fun:%s plock:0x%08x\n", __LINE__, __FUNCTION__, *plock); + rt_mutex_delete(*plock); + *plock = NULL; #endif } static void _rtthread_spinlock(_lock *plock) { #if USE_MUTEX_FOR_SPINLOCK - rt_sem_take(*plock, RT_WAITING_FOREVER); + RT_ASSERT(*plock != RT_NULL); + + DEBUG_LOG(2, "L:%d fun:%s plock:0x%08x\n", __LINE__, __FUNCTION__, *plock); + rt_mutex_take(*plock, RT_WAITING_FOREVER); #endif } static void _rtthread_spinunlock(_lock *plock) { #if USE_MUTEX_FOR_SPINLOCK - rt_sem_release(*plock); + if (*plock == RT_NULL) + { + rt_kprintf("err!! spinunlock is null\n"); + return; + } + DEBUG_LOG(2, "L:%d fun:%s plock:0x%08x\n", __LINE__, __FUNCTION__, *plock); + rt_mutex_release(*plock); #endif } static void _rtthread_spinlock_irqsave(_lock *plock, _irqL *irqL) { #if USE_MUTEX_FOR_SPINLOCK - while(rt_sem_take(*plock, 0) != RT_EOK) + if (*plock == RT_NULL) + rt_kprintf("err!! spinlock irqsave null\n"); + + DEBUG_LOG(2, "L:%d fun:%s plock:0x%08x irqL:0x%08x\n", __LINE__, __FUNCTION__, *plock, *irqL); + *irqL = 0xdeadbeff; + while (rt_mutex_take(*plock, 0) != RT_EOK) { rt_kprintf("spinlock_irqsave failed!\n"); } @@ -288,33 +367,71 @@ static void _rtthread_spinlock_irqsave(_lock *plock, _irqL *irqL) static void _rtthread_spinunlock_irqsave(_lock *plock, _irqL *irqL) { #if USE_MUTEX_FOR_SPINLOCK - rt_sem_release(*plock); + if (*plock == RT_NULL) + rt_kprintf("err!! spinunlock irqsave null\n"); + + DEBUG_LOG(2, "L:%d fun:%s plock:0x%08x irqL:0x%08x\n", __LINE__, __FUNCTION__, *plock, *irqL); + rt_mutex_release(*plock); #endif } static int _rtthread_init_xqueue( _xqueue* queue, const char* name, u32 message_size, u32 number_of_messages ) { - return -1; + DEBUG_LOG(3, "L:%d fun:%s begin name:%s size:%d msgs:%d\n", __LINE__, __FUNCTION__, name, message_size, number_of_messages); + + *queue = rt_mq_create(name, message_size, number_of_messages, RT_IPC_FLAG_FIFO); + if (*queue == RT_NULL) + { + rt_kprintf("err!! create xqueue fail\n"); + return -1; + } + DEBUG_LOG(3, "L:%d fun:%s end queue:0x%08x\n", __LINE__, __FUNCTION__, *queue); + return 0; } static int _rtthread_push_to_xqueue( _xqueue* queue, void* message, u32 timeout_ms ) { - return -1; + RT_ASSERT(*queue != RT_NULL); + + DEBUG_LOG(2, "L:%d fun:%s queue:0x%08x timeout_ms:%d\n", __LINE__, __FUNCTION__, *queue, timeout_ms); + if (rt_mq_send(*queue, message, ((rt_mq_t)*queue)->msg_size) != RT_EOK) + { + return -1; + } + return 0; } static int _rtthread_pop_from_xqueue( _xqueue* queue, void* message, u32 timeout_ms ) { - return -1; + rt_uint32_t tick; + + RT_ASSERT(*queue != RT_NULL); + + DEBUG_LOG(2, "L:%d fun:%s queue:0x%08x msg:0x%08x timeout_ms:%d\n", __LINE__, __FUNCTION__, *queue, message, timeout_ms); + if(timeout_ms >= RT_TICK_MAX / 2) + tick = RT_WAITING_FOREVER; + else + tick = rtw_ms_to_systime(timeout_ms); + + if (rt_mq_recv(*queue, message, ((rt_mq_t)*queue)->msg_size, tick) != RT_EOK) + { + return -1; + } + return 0; } static int _rtthread_deinit_xqueue( _xqueue* queue ) { - return -1; + RT_ASSERT(*queue != RT_NULL); + + DEBUG_LOG(2, "L:%d fun:%s queue:0x%08x\n", __LINE__, __FUNCTION__, *queue); + rt_mq_delete(*queue); + return 0; } static u32 _rtthread_get_current_time(void) { - return rt_tick_get(); + return (u32)rt_tick_get(); } static u32 _rtthread_systime_to_ms(u32 systime) @@ -339,28 +456,26 @@ static u32 _rtthread_sec_to_systime(u32 sec) static void _rtthread_msleep_os(int ms) { + DEBUG_LOG(2, "L:%d fun:%s ms:%d\n", __LINE__, __FUNCTION__, ms); #if defined(CONFIG_PLATFORM_8195A) - rt_thread_delay(rt_tick_from_millisecond(ms)); + rt_thread_delay(rt_tick_from_millisecond(ms)); #elif defined(CONFIG_PLATFORM_8711B) - if (pmu_yield_os_check()) { + if (pmu_yield_os_check()) rt_thread_delay(rt_tick_from_millisecond(ms)); - } else { - DelayMs(ms); - } + else + DelayMs(ms); #endif } static void _rtthread_usleep_os(int us) { #if defined(STM32F2XX) || defined(STM32F4XX) || defined(STM32F10X_XL) - // rtthread does not provide us level delay. Use busy wait - WLAN_BSP_UsLoop(us); + // rtthread does not provide us level delay. Use busy wait + WLAN_BSP_UsLoop(us); #elif defined(CONFIG_PLATFORM_8195A) - //DBG_ERR("%s: Please Implement micro-second delay\n", __FUNCTION__); + //DBG_ERR("%s: Please Implement micro-second delay\n", __FUNCTION__); #elif defined(CONFIG_PLATFORM_8711B) - DelayUs(us); -#else - #error "Please implement hardware dependent micro second level sleep here" + DelayUs(us); #endif } @@ -371,15 +486,15 @@ static void _rtthread_mdelay_os(int ms) static void _rtthread_udelay_os(int us) { -#if defined(STM32F2XX) || defined(STM32F4XX) || defined(STM32F10X_XL) - // rtthread does not provide us level delay. Use busy wait - WLAN_BSP_UsLoop(us); +#if defined(STM32F2XX) || defined(STM32F4XX) || defined(STM32F10X_XL) + // rtthread does not provide us level delay. Use busy wait + WLAN_BSP_UsLoop(us); #elif defined(CONFIG_PLATFORM_8195A) - HalDelayUs(us); + HalDelayUs(us); #elif defined(CONFIG_PLATFORM_8711B) - DelayUs(us); + DelayUs(us); #else - #error "Please implement hardware dependent micro second level sleep here" + #error "Please implement hardware dependent micro second level sleep here" #endif } @@ -388,146 +503,145 @@ static void _rtthread_yield_os(void) #if defined(CONFIG_PLATFORM_8195A) rt_thread_yield(); #elif defined(CONFIG_PLATFORM_8711B) - if (pmu_yield_os_check()) { + if (pmu_yield_os_check()) rt_thread_yield(); - } else { - DelayMs(1); - } + else + DelayMs(1); #endif } static void _rtthread_ATOMIC_SET(ATOMIC_T *v, int i) { - atomic_set(v,i); + atomic_set(v,i); } static int _rtthread_ATOMIC_READ(ATOMIC_T *v) { - return atomic_read(v); + return atomic_read(v); } static void _rtthread_ATOMIC_ADD(ATOMIC_T *v, int i) { - save_and_cli(); - v->counter += i; - restore_flags(); + save_and_cli(); + v->counter += i; + restore_flags(); } static void _rtthread_ATOMIC_SUB(ATOMIC_T *v, int i) { - save_and_cli(); - v->counter -= i; - restore_flags(); + save_and_cli(); + v->counter -= i; + restore_flags(); } static void _rtthread_ATOMIC_INC(ATOMIC_T *v) { - _rtthread_ATOMIC_ADD(v, 1); + _rtthread_ATOMIC_ADD(v, 1); } static void _rtthread_ATOMIC_DEC(ATOMIC_T *v) { - _rtthread_ATOMIC_SUB(v, 1); + _rtthread_ATOMIC_SUB(v, 1); } static int _rtthread_ATOMIC_ADD_RETURN(ATOMIC_T *v, int i) { - int temp; + int temp; - save_and_cli(); - temp = v->counter; - temp += i; - v->counter = temp; - restore_flags(); + save_and_cli(); + temp = v->counter; + temp += i; + v->counter = temp; + restore_flags(); - return temp; + return temp; } static int _rtthread_ATOMIC_SUB_RETURN(ATOMIC_T *v, int i) { - int temp; + int temp; - save_and_cli(); - temp = v->counter; - temp -= i; - v->counter = temp; - restore_flags(); + save_and_cli(); + temp = v->counter; + temp -= i; + v->counter = temp; + restore_flags(); - return temp; + return temp; } static int _rtthread_ATOMIC_INC_RETURN(ATOMIC_T *v) { - return _rtthread_ATOMIC_ADD_RETURN(v, 1); + return _rtthread_ATOMIC_ADD_RETURN(v, 1); } static int _rtthread_ATOMIC_DEC_RETURN(ATOMIC_T *v) { - return _rtthread_ATOMIC_SUB_RETURN(v, 1); + return _rtthread_ATOMIC_SUB_RETURN(v, 1); } static u64 _rtthread_modular64(u64 n, u64 base) { - unsigned int __base = (base); - unsigned int __rem; + unsigned int __base = (base); + unsigned int __rem; - if (((n) >> 32) == 0) { - __rem = (unsigned int)(n) % __base; - (n) = (unsigned int)(n) / __base; - } - else - __rem = __div64_32(&(n), __base); - - return __rem; + if (((n) >> 32) == 0) { + __rem = (unsigned int)(n) % __base; + (n) = (unsigned int)(n) / __base; + } + else + __rem = __div64_32(&(n), __base); + + return __rem; } /* Refer to ecos bsd tcpip codes */ static int _rtthread_arc4random(void) { - u32 res = _rtthread_get_current_time(); - static unsigned long seed = 0xDEADB00B; + u32 res = _rtthread_get_current_time(); + static unsigned long seed = 0xDEADB00B; #if CONFIG_PLATFORM_8711B - if(random_seed){ - seed = random_seed; - random_seed = 0; - } + if(random_seed){ + seed = random_seed; + random_seed = 0; + } #endif - - seed = ((seed & 0x007F00FF) << 7) ^ - ((seed & 0x0F80FF00) >> 8) ^ // be sure to stir those low bits - (res << 13) ^ (res >> 9); // using the clock too! - return (int)seed; + + seed = ((seed & 0x007F00FF) << 7) ^ + ((seed & 0x0F80FF00) >> 8) ^ // be sure to stir those low bits + (res << 13) ^ (res >> 9); // using the clock too! + return (int)seed; } -static int _rtthread_get_random_bytes(void *buf, size_t len) +static int _rtthread_get_random_bytes(void *buf, u32 len) { #if 1 //becuase of 4-byte align, we use the follow code style. - unsigned int ranbuf; - unsigned int *lp; - int i, count; - count = len / sizeof(unsigned int); - lp = (unsigned int *) buf; + unsigned int ranbuf; + unsigned int *lp; + int i, count; + count = len / sizeof(unsigned int); + lp = (unsigned int *) buf; - for(i = 0; i < count; i ++) { - lp[i] = _rtthread_arc4random(); - len -= sizeof(unsigned int); - } + for(i = 0; i < count; i ++) { + lp[i] = _rtthread_arc4random(); + len -= sizeof(unsigned int); + } - if(len > 0) { - ranbuf = _rtthread_arc4random(); - _rtthread_memcpy(&lp[i], &ranbuf, len); - } - return 0; + if(len > 0) { + ranbuf = _rtthread_arc4random(); + _rtthread_memcpy(&lp[i], &ranbuf, len); + } + return 0; #else - unsigned long ranbuf, *lp; - lp = (unsigned long *)buf; - while (len > 0) { - ranbuf = _rtthread_arc4random(); - *lp++ = ranbuf; //this op need the pointer is 4Byte-align! - len -= sizeof(ranbuf); - } - return 0; + unsigned long ranbuf, *lp; + lp = (unsigned long *)buf; + while (len > 0) { + ranbuf = _rtthread_arc4random(); + *lp++ = ranbuf; //this op need the pointer is 4Byte-align! + len -= sizeof(ranbuf); + } + return 0; #endif } @@ -539,158 +653,140 @@ static u32 _rtthread_GetFreeHeapSize(void) #ifndef RT_USING_LWIP #define RT_LWIP_TCPTHREAD_PRIORITY 10 #endif -void *tcm_heap_malloc(int size); static int _rtthread_create_task(struct task_struct *ptask, const char *name, - u32 stack_size, u32 priority, thread_func_t func, void *thctx) + u32 stack_size, u32 priority, thread_func_t func, void *thctx) { - rt_err_t result; rt_thread_t tid; - char * stack; - DBG_INFO("create_task %s: ptask 0x%08X, stack %d priority %d \n", name, ptask, stack_size, priority); + DEBUG_LOG(3, "L:%d fun:%s begin name:%s stack_size:%d priority:%d func:0x%08x thctx:0x%08x\n", \ + __LINE__, __FUNCTION__, name, stack_size, priority, func, thctx); + rt_memset(ptask, 0, sizeof(struct task_struct)); ptask->task_name = name; ptask->blocked = 0; ptask->callback_running = 0; - //OSDEP_DBG("&ptask->wakeup_sema: 0x%08X \n", &ptask->wakeup_sema); _rtthread_init_sema(&ptask->wakeup_sema, 0); - - //OSDEP_DBG("&ptask->terminate_sema: 0x%08X \n", &ptask->terminate_sema); + if (ptask->wakeup_sema == RT_NULL) + { + rt_kprintf("L:%d create wakeup sem fail\n"); + goto _thread_err; + } _rtthread_init_sema(&ptask->terminate_sema, 0); - - if(strcmp(name, "rtw_recv_tasklet") == 0) + if (ptask->terminate_sema == RT_NULL) { - stack_size = 3000; - } - else if(strcmp(name, "cmd_thread") == 0) - { - stack_size = 1800; - } - else - { - stack_size = stack_size + 512; + rt_kprintf("L:%d terminate sem fail\n"); + goto _thread_err; } - tid = rt_malloc(RT_ALIGN(sizeof(struct rt_thread), 8) + stack_size); - if(!tid) - { - rt_kprintf("no memory NULL for thread:%s\n", name); - return 0; - } - - stack = (char *)tid + RT_ALIGN(sizeof(struct rt_thread), 8); + stack_size = (stack_size * 3); priority = RT_LWIP_TCPTHREAD_PRIORITY + priority; if(priority >= RT_THREAD_PRIORITY_MAX) - { priority = RT_THREAD_PRIORITY_MAX - 1; - } - result = rt_thread_init(tid, - name, - func, thctx, // fun, parameter - stack, stack_size, // stack, size - priority, //priority - 10 - ); - - if(result == RT_EOK) + tid = rt_thread_create(name, func, thctx, stack_size, priority, 10); + if (tid == RT_NULL) { - ptask->task = tid; - rt_thread_startup(tid); + rt_kprintf("L:%d thread create fail\n"); + goto _thread_err; } + ptask->task = tid; + rt_thread_startup(tid); + + DEBUG_LOG(3, "L:%d fun:%s end stack_size:%d priority:%d wakeup:0x%08x terminate:0x%08x\n", \ + __LINE__, __FUNCTION__, stack_size, priority, ptask->wakeup_sema, ptask->terminate_sema); + return RT_TRUE; + +_thread_err: + if (ptask->wakeup_sema) + _rtthread_free_sema(&ptask->wakeup_sema); + if (ptask->terminate_sema) + _rtthread_free_sema(&ptask->terminate_sema); + rt_memset(ptask, 0, sizeof(struct task_struct)); + return RT_FALSE; } - + static void _rtthread_delete_task(struct task_struct *ptask) { - if (!ptask->task){ - DBG_ERR("_rtthread_delete_task(): ptask is NULL!\n"); - return; - } + if (!ptask->task) + { + rt_kprintf("_rtthread_delete_task(): ptask is NULL!\n"); + return; + } - rt_kprintf("[func]:%s [line]:%d\n", __FUNCTION__, __LINE__); - ptask->blocked = 1; + DEBUG_LOG(2, "L:%d fun:%s name:%s\n", __LINE__, __FUNCTION__, ptask->task_name); + ptask->blocked = 1; - _rtthread_up_sema(&ptask->wakeup_sema); - _rtthread_down_sema(&ptask->terminate_sema, TIMER_MAX_DELAY); - - //rtw_deinit_queue(&wq->work_queue); - _rtthread_free_sema(&ptask->wakeup_sema); - _rtthread_free_sema(&ptask->terminate_sema); + _rtthread_up_sema(&ptask->wakeup_sema); + _rtthread_down_sema(&ptask->terminate_sema, TIMER_MAX_DELAY); - ptask->task = 0; - - DBG_TRACE("Delete Task \"%s\"\n", ptask->task_name); + _rtthread_free_sema(&ptask->wakeup_sema); + _rtthread_free_sema(&ptask->terminate_sema); + + ptask->task = 0; } void _rtthread_wakeup_task(struct task_struct *ptask) { - _rtthread_up_sema(&ptask->wakeup_sema); + DEBUG_LOG(2, "L:%d fun:%s name:%s\n", __LINE__, __FUNCTION__, ptask->task_name); + _rtthread_up_sema(&ptask->wakeup_sema); } static void _rtthread_thread_enter(char *name) { -// rt_kprintf("RTKTHREAD %s\n", name); + DEBUG_LOG(3, "L:%d fun:%s name:%s\n", __LINE__, __FUNCTION__, name); } static void _rtthread_thread_exit(void) { -// rt_kprintf("RTKTHREAD exit %s\n", __FUNCTION__); + DEBUG_LOG(3, "L:%d fun:%s\n", __LINE__, __FUNCTION__); } _timerHandle _rtthread_timerCreate( const signed char *pcTimerName, - osdepTickType xTimerPeriodInTicks, - u32 uxAutoReload, - void * pvTimerID, - TIMER_FUN pxCallbackFunction ) + osdepTickType xTimerPeriodInTicks, + u32 uxAutoReload, + void * pvTimerID, + TIMER_FUN pxCallbackFunction ) { rt_timer_t timer; rt_tick_t time; rt_uint8_t flag; + DEBUG_LOG(3, "L:%d fun:%s begin name:%s reload:%d tick:%d fun:0x%08x ID:0x%08x\n", + __LINE__, __FUNCTION__, pcTimerName, uxAutoReload, xTimerPeriodInTicks, pxCallbackFunction, pvTimerID); + if(uxAutoReload == 1) - { - flag |= RT_TIMER_FLAG_SOFT_TIMER | RT_TIMER_FLAG_PERIODIC; - } + flag = (RT_TIMER_FLAG_SOFT_TIMER | RT_TIMER_FLAG_PERIODIC); else - { - flag |= RT_TIMER_FLAG_SOFT_TIMER | RT_TIMER_FLAG_ONE_SHOT; - } + flag = (RT_TIMER_FLAG_SOFT_TIMER | RT_TIMER_FLAG_ONE_SHOT); if( xTimerPeriodInTicks >= (RT_TICK_MAX / 2) ) - { time = (RT_TICK_MAX / 2) - 1; - } else - { time = xTimerPeriodInTicks; - } - timer = rt_timer_create(pcTimerName, - pxCallbackFunction, - RT_NULL, - time, - flag); - - //OSDEP_DBG("%s: %s 0x%08X tick:%d uxAutoReload:%d, Callback:0x%08X, pvTimerID:0x%08X, \n", __FUNCTION__, pcTimerName, timer, xTimerPeriodInTicks, uxAutoReload, pxCallbackFunction, pvTimerID); - - if(timer) + timer = rt_timer_create(pcTimerName, pxCallbackFunction, RT_NULL, time, flag); + if(timer == RT_NULL) { - timer->parameter = timer; + rt_kprintf("timer create fail\n"); + return RT_NULL; } + timer->parameter = timer; + DEBUG_LOG(3, "L:%d fun:%s end timer:0x%08x\n", __LINE__, __FUNCTION__, timer); return (_timerHandle)timer; } -u32 _rtthread_timerDelete( _timerHandle xTimer, - osdepTickType xBlockTime ) +u32 _rtthread_timerDelete(_timerHandle xTimer, osdepTickType xBlockTime) { - if(rt_timer_delete(xTimer) != RT_EOK) - return RT_FALSE; + DEBUG_LOG(3, "L:%d fun:%s timer:0x%08x\n", __LINE__, __FUNCTION__, xTimer); + RT_ASSERT(xTimer != RT_NULL); + + rt_timer_delete(xTimer); return RT_TRUE; } @@ -698,43 +794,51 @@ u32 _rtthread_timerIsTimerActive( _timerHandle xTimer ) { rt_timer_t pxTimer = (rt_timer_t)xTimer; + DEBUG_LOG(3, "L:%d fun:%s timer:0x%08x\n", __LINE__, __FUNCTION__, xTimer); if(!xTimer) { + rt_kprintf("err!! timer is active null\n"); return 0; } - + return (pxTimer->parent.flag & RT_TIMER_FLAG_ACTIVATED) ? 1 : 0; } -u32 _rtthread_timerStop( _timerHandle xTimer, - osdepTickType xBlockTime ) +u32 _rtthread_timerStop(_timerHandle xTimer, osdepTickType xBlockTime) { - rt_err_t result = rt_timer_stop(xTimer); - if(result != RT_EOK) - return RT_FALSE; + RT_ASSERT(xTimer != RT_NULL); + DEBUG_LOG(3, "L:%d fun:%s timer:0x%08x\n", __LINE__, __FUNCTION__, xTimer); + if (rt_timer_stop(xTimer) != RT_EOK) + { + // rt_kprintf("timer stop fail\n"); + return RT_FALSE; + } return RT_TRUE; } -u32 _rtthread_timerChangePeriod( _timerHandle xTimer, - osdepTickType xNewPeriod, - osdepTickType xBlockTime ) +u32 _rtthread_timerChangePeriod( _timerHandle xTimer, osdepTickType xNewPeriod, osdepTickType xBlockTime ) { - rt_err_t result; int time; - - if(xNewPeriod == 0) - time = 1; + + RT_ASSERT(xTimer != RT_NULL); + + DEBUG_LOG(3, "L:%d fun:%s timer:0x%08x new_tick:%d\n", __LINE__, __FUNCTION__, xTimer, xNewPeriod); + if(xNewPeriod == 0) + time = 1; else if(xNewPeriod >= (RT_TICK_MAX / 2)) time = (RT_TICK_MAX / 2) - 1; else time = xNewPeriod; - - result = rt_timer_stop(xTimer); - result = rt_timer_control(xTimer, RT_TIMER_CTRL_SET_TIME, (void *)&time); + + rt_timer_stop(xTimer); + rt_timer_control(xTimer, RT_TIMER_CTRL_SET_TIME, (void *)&time); if(rt_timer_start(xTimer) != RT_EOK) + { + rt_kprintf("change time and timer start fail\n"); return RT_FALSE; + } return RT_TRUE; } @@ -743,79 +847,129 @@ void *_rtthread_timerGetID( _timerHandle xTimer ) return xTimer; } -u32 _rtthread_timerStart( _timerHandle xTimer, - osdepTickType xBlockTime ) +u32 _rtthread_timerStart( _timerHandle xTimer, osdepTickType xBlockTime ) { + RT_ASSERT(xTimer != RT_NULL); + + DEBUG_LOG(3, "L:%d fun:%s timer:0x%08x\n", __LINE__, __FUNCTION__, xTimer); if(rt_timer_start(xTimer) != RT_EOK) + { + rt_kprintf("change time and timer start fail\n"); return RT_FALSE; + } return RT_TRUE; } -u32 _rtthread_timerStartFromISR( _timerHandle xTimer, - osdepBASE_TYPE *pxHigherPriorityTaskWoken ) +u32 _rtthread_timerStartFromISR( _timerHandle xTimer, osdepBASE_TYPE *pxHigherPriorityTaskWoken ) { - if(rt_timer_start(xTimer) != RT_EOK) + DEBUG_LOG(1, "L:%d fun:%s timer:0x%08x\n", __LINE__, __FUNCTION__, xTimer); + + if (xTimer == RT_NULL) + { + rt_kprintf("timer start from isr null\n"); return RT_FALSE; + } + + if(rt_timer_start(xTimer) != RT_EOK) + { + rt_kprintf("timer start from isr fail\n"); + return RT_FALSE; + } return RT_TRUE; } -u32 _rtthread_timerStopFromISR( _timerHandle xTimer, - osdepBASE_TYPE *pxHigherPriorityTaskWoken ) -{ - if(rt_timer_stop(xTimer) != RT_EOK) +u32 _rtthread_timerStopFromISR( _timerHandle xTimer, osdepBASE_TYPE *pxHigherPriorityTaskWoken ) +{ + DEBUG_LOG(1, "L:%d fun:%s timer:0x%08x\n", __LINE__, __FUNCTION__, xTimer); + + if (xTimer == RT_NULL) + { + rt_kprintf("timer start from isr null\n"); return RT_FALSE; + } + + if(rt_timer_stop(xTimer) != RT_EOK) + { + rt_kprintf("timer stop from isr fail\n"); + return RT_FALSE; + } return RT_TRUE; } -u32 _rtthread_timerResetFromISR( _timerHandle xTimer, - osdepBASE_TYPE *pxHigherPriorityTaskWoken ) +u32 _rtthread_timerResetFromISR( _timerHandle xTimer, osdepBASE_TYPE *pxHigherPriorityTaskWoken ) { + DEBUG_LOG(1, "L:%d fun:%s timer:0x%08x\n", __LINE__, __FUNCTION__, xTimer); + + if (xTimer == RT_NULL) + { + rt_kprintf("timer Reset from isr null\n"); + return RT_FALSE; + } + if(rt_timer_stop(xTimer) != RT_EOK) + { + rt_kprintf("timer Reset from isr stop fail\n"); return RT_FALSE; - + } + if(rt_timer_start(xTimer) != RT_EOK) + { + rt_kprintf("timer Reset from isr start fail\n"); return RT_FALSE; - + } + return RT_TRUE; } u32 _rtthread_timerChangePeriodFromISR( _timerHandle xTimer, - osdepTickType xNewPeriod, - osdepBASE_TYPE *pxHigherPriorityTaskWoken ) + osdepTickType xNewPeriod, + osdepBASE_TYPE *pxHigherPriorityTaskWoken ) { - rt_err_t result; int time; - - if(xNewPeriod == 0) - time = 1; + + DEBUG_LOG(1, "L:%d fun:%s timer:0x%08x\n", __LINE__, __FUNCTION__, xTimer); + + if (xTimer == RT_NULL) + { + rt_kprintf("timer Change Period from isr null\n"); + return RT_FALSE; + } + + if(xNewPeriod == 0) + time = 1; else if(xNewPeriod >= (RT_TICK_MAX / 2)) time = (RT_TICK_MAX / 2) - 1; else time = xNewPeriod; - - result = rt_timer_stop(xTimer); - result = rt_timer_control(xTimer, RT_TIMER_CTRL_SET_TIME, (void *)&time); + + rt_timer_stop(xTimer); + rt_timer_control(xTimer, RT_TIMER_CTRL_SET_TIME, (void *)&time); if(rt_timer_start(xTimer) != RT_EOK) + { + rt_kprintf("timer Change Period from isr start fail\n"); return RT_FALSE; + } return RT_TRUE; } u32 _rtthread_timerReset( _timerHandle xTimer, - osdepTickType xBlockTime ) + osdepTickType xBlockTime ) { - rt_err_t result = rt_timer_stop(xTimer); + RT_ASSERT(xTimer != RT_NULL); - if(result != RT_EOK) - return RT_FALSE; + DEBUG_LOG(2, "L:%d fun:%s timer:0x%08x\n", __LINE__, __FUNCTION__, xTimer); - result = rt_timer_start(xTimer); - if(result != RT_EOK) + rt_timer_stop(xTimer); + if(rt_timer_start(xTimer) != RT_EOK) + { + rt_kprintf("timer reset fail\n"); return RT_FALSE; + } return RT_TRUE; } @@ -825,14 +979,14 @@ void _rtthread_acquire_wakelock(void) #if defined(CONFIG_PLATFORM_8195A) #if defined(configUSE_WAKELOCK_PMU) && (configUSE_WAKELOCK_PMU == 1) - pmu_acquire_wakelock(PMU_WLAN_DEVICE); + pmu_acquire_wakelock(PMU_WLAN_DEVICE); #endif - + #elif defined(CONFIG_PLATFORM_8711B) #if defined(configUSE_WAKELOCK_PMU) && (configUSE_WAKELOCK_PMU == 1) - if (pmu_yield_os_check()) - pmu_acquire_wakelock(PMU_WLAN_DEVICE); + if (pmu_yield_os_check()) + pmu_acquire_wakelock(PMU_WLAN_DEVICE); #endif #endif @@ -845,12 +999,12 @@ void _rtthread_release_wakelock(void) #if defined(configUSE_WAKELOCK_PMU) && (configUSE_WAKELOCK_PMU == 1) pmu_release_wakelock(PMU_WLAN_DEVICE); #endif - + #elif defined(CONFIG_PLATFORM_8711B) #if defined(configUSE_WAKELOCK_PMU) && (configUSE_WAKELOCK_PMU == 1) - if (pmu_yield_os_check()) - pmu_release_wakelock(PMU_WLAN_DEVICE); + if (pmu_yield_os_check()) + pmu_release_wakelock(PMU_WLAN_DEVICE); #endif #endif @@ -859,127 +1013,126 @@ void _rtthread_release_wakelock(void) void _rtthread_wakelock_timeout(uint32_t timeout) { #if defined(CONFIG_PLATFORM_8195A) - + #elif defined(CONFIG_PLATFORM_8711B) - if (pmu_yield_os_check()) - pmu_set_sysactive_time(PMU_WLAN_DEVICE, timeout); - else - printf("can't aquire wake during suspend flow!!\n"); + if (pmu_yield_os_check()) + pmu_set_sysactive_time(/*PMU_WLAN_DEVICE, */timeout); + else + printf("can't aquire wake during suspend flow!!\n"); #endif } u8 _rtthread_get_scheduler_state(void) { rt_thread_t thread = rt_thread_self(); - u8 state = thread->stat; - switch(state){ - case RT_THREAD_INIT: state = OS_SCHEDULER_NOT_STARTED; break; - case RT_THREAD_RUNNING: state = OS_SCHEDULER_RUNNING; break; - case RT_THREAD_SUSPEND: state = OS_SCHEDULER_SUSPENDED; break; - } + u8 state = thread->stat; + switch(state){ + case RT_THREAD_INIT: state = OS_SCHEDULER_NOT_STARTED; break; + case RT_THREAD_RUNNING: state = OS_SCHEDULER_RUNNING; break; + case RT_THREAD_SUSPEND: state = OS_SCHEDULER_SUSPENDED; break; + } rt_kprintf("[func]:%s [line]:%d state:%d\n", __FUNCTION__, __LINE__, state); - return state; + return state; } - const struct osdep_service_ops osdep_service = { - _rtthread_malloc, //rtw_vmalloc - _rtthread_zmalloc, //rtw_zvmalloc - _rtthread_mfree, //rtw_vmfree - _rtthread_malloc, //rtw_malloc - _rtthread_zmalloc, //rtw_zmalloc - _rtthread_mfree, //rtw_mfree - _rtthread_memcpy, //rtw_memcpy - _rtthread_memcmp, //rtw_memcmp - _rtthread_memset, //rtw_memset - _rtthread_init_sema, //rtw_init_sema - _rtthread_free_sema, //rtw_free_sema - _rtthread_up_sema, //rtw_up_sema - _rtthread_up_sema_from_isr, //rtw_up_sema_from_isr - _rtthread_down_sema, //rtw_down_sema - _rtthread_mutex_init, //rtw_mutex_init - _rtthread_mutex_free, //rtw_mutex_free - _rtthread_mutex_get, //rtw_mutex_get - _rtthread_mutex_get_timeout,//rtw_mutex_get_timeout - _rtthread_mutex_put, //rtw_mutex_put - _rtthread_enter_critical, //rtw_enter_critical - _rtthread_exit_critical, //rtw_exit_critical - _rtthread_enter_critical_from_isr, //rtw_enter_critical_from_isr - _rtthread_exit_critical_from_isr, //rtw_exit_critical_from_isr - NULL, //rtw_enter_critical_bh - NULL, //rtw_exit_critical_bh - _rtthread_enter_critical_mutex, //rtw_enter_critical_mutex - _rtthread_exit_critical_mutex, //rtw_exit_critical_mutex - _rtthread_spinlock_init, //rtw_spinlock_init - _rtthread_spinlock_free, //rtw_spinlock_free - _rtthread_spinlock, //rtw_spin_lock - _rtthread_spinunlock, //rtw_spin_unlock - _rtthread_spinlock_irqsave, //rtw_spinlock_irqsave - _rtthread_spinunlock_irqsave, //rtw_spinunlock_irqsave - _rtthread_init_xqueue, //rtw_init_xqueue - _rtthread_push_to_xqueue, //rtw_push_to_xqueue - _rtthread_pop_from_xqueue, //rtw_pop_from_xqueue - _rtthread_deinit_xqueue, //rtw_deinit_xqueue - _rtthread_get_current_time, //rtw_get_current_time - _rtthread_systime_to_ms, //rtw_systime_to_ms - _rtthread_systime_to_sec, //rtw_systime_to_sec - _rtthread_ms_to_systime, //rtw_ms_to_systime - _rtthread_sec_to_systime, //rtw_sec_to_systime - _rtthread_msleep_os, //rtw_msleep_os - _rtthread_usleep_os, //rtw_usleep_os - _rtthread_mdelay_os, //rtw_mdelay_os - _rtthread_udelay_os, //rtw_udelay_os - _rtthread_yield_os, //rtw_yield_os - - _rtthread_ATOMIC_SET, //ATOMIC_SET - _rtthread_ATOMIC_READ, //ATOMIC_READ - _rtthread_ATOMIC_ADD, //ATOMIC_ADD - _rtthread_ATOMIC_SUB, //ATOMIC_SUB - _rtthread_ATOMIC_INC, //ATOMIC_INC - _rtthread_ATOMIC_DEC, //ATOMIC_DEC - _rtthread_ATOMIC_ADD_RETURN, //ATOMIC_ADD_RETURN - _rtthread_ATOMIC_SUB_RETURN, //ATOMIC_SUB_RETURN - _rtthread_ATOMIC_INC_RETURN, //ATOMIC_INC_RETURN - _rtthread_ATOMIC_DEC_RETURN, //ATOMIC_DEC_RETURN + _rtthread_malloc, //rtw_vmalloc + _rtthread_zmalloc, //rtw_zvmalloc + _rtthread_mfree, //rtw_vmfree + _rtthread_malloc, //rtw_malloc + _rtthread_zmalloc, //rtw_zmalloc + _rtthread_mfree, //rtw_mfree + _rtthread_memcpy, //rtw_memcpy + _rtthread_memcmp, //rtw_memcmp + _rtthread_memset, //rtw_memset + _rtthread_init_sema, //rtw_init_sema + _rtthread_free_sema, //rtw_free_sema + _rtthread_up_sema, //rtw_up_sema + _rtthread_up_sema_from_isr, //rtw_up_sema_from_isr + _rtthread_down_sema, //rtw_down_sema + _rtthread_mutex_init, //rtw_mutex_init + _rtthread_mutex_free, //rtw_mutex_free + _rtthread_mutex_get, //rtw_mutex_get + _rtthread_mutex_get_timeout,//rtw_mutex_get_timeout + _rtthread_mutex_put, //rtw_mutex_put + _rtthread_enter_critical, //rtw_enter_critical + _rtthread_exit_critical, //rtw_exit_critical + _rtthread_enter_critical_from_isr, //rtw_enter_critical_from_isr + _rtthread_exit_critical_from_isr, //rtw_exit_critical_from_isr + NULL, //rtw_enter_critical_bh + NULL, //rtw_exit_critical_bh + _rtthread_enter_critical_mutex, //rtw_enter_critical_mutex + _rtthread_exit_critical_mutex, //rtw_exit_critical_mutex + _rtthread_spinlock_init, //rtw_spinlock_init + _rtthread_spinlock_free, //rtw_spinlock_free + _rtthread_spinlock, //rtw_spin_lock + _rtthread_spinunlock, //rtw_spin_unlock + _rtthread_spinlock_irqsave, //rtw_spinlock_irqsave + _rtthread_spinunlock_irqsave, //rtw_spinunlock_irqsave + _rtthread_init_xqueue, //rtw_init_xqueue + _rtthread_push_to_xqueue, //rtw_push_to_xqueue + _rtthread_pop_from_xqueue, //rtw_pop_from_xqueue + _rtthread_deinit_xqueue, //rtw_deinit_xqueue + _rtthread_get_current_time, //rtw_get_current_time + _rtthread_systime_to_ms, //rtw_systime_to_ms + _rtthread_systime_to_sec, //rtw_systime_to_sec + _rtthread_ms_to_systime, //rtw_ms_to_systime + _rtthread_sec_to_systime, //rtw_sec_to_systime + _rtthread_msleep_os, //rtw_msleep_os + _rtthread_usleep_os, //rtw_usleep_os + _rtthread_mdelay_os, //rtw_mdelay_os + _rtthread_udelay_os, //rtw_udelay_os + _rtthread_yield_os, //rtw_yield_os + + _rtthread_ATOMIC_SET, //ATOMIC_SET + _rtthread_ATOMIC_READ, //ATOMIC_READ + _rtthread_ATOMIC_ADD, //ATOMIC_ADD + _rtthread_ATOMIC_SUB, //ATOMIC_SUB + _rtthread_ATOMIC_INC, //ATOMIC_INC + _rtthread_ATOMIC_DEC, //ATOMIC_DEC + _rtthread_ATOMIC_ADD_RETURN, //ATOMIC_ADD_RETURN + _rtthread_ATOMIC_SUB_RETURN, //ATOMIC_SUB_RETURN + _rtthread_ATOMIC_INC_RETURN, //ATOMIC_INC_RETURN + _rtthread_ATOMIC_DEC_RETURN, //ATOMIC_DEC_RETURN - _rtthread_modular64, //rtw_modular64 - _rtthread_get_random_bytes, //rtw_get_random_bytes - _rtthread_GetFreeHeapSize, //rtw_getFreeHeapSize + _rtthread_modular64, //rtw_modular64 + _rtthread_get_random_bytes, //rtw_get_random_bytes + _rtthread_GetFreeHeapSize, //rtw_getFreeHeapSize - _rtthread_create_task, //rtw_create_task - _rtthread_delete_task, //rtw_delete_task - _rtthread_wakeup_task, //rtw_wakeup_task + _rtthread_create_task, //rtw_create_task + _rtthread_delete_task, //rtw_delete_task + _rtthread_wakeup_task, //rtw_wakeup_task - _rtthread_thread_enter, //rtw_thread_enter - _rtthread_thread_exit, //rtw_thread_exit + _rtthread_thread_enter, //rtw_thread_enter + _rtthread_thread_exit, //rtw_thread_exit - _rtthread_timerCreate, //rtw_timerCreate, - _rtthread_timerDelete, //rtw_timerDelete, - _rtthread_timerIsTimerActive, //rtw_timerIsTimerActive, - _rtthread_timerStop, //rtw_timerStop, - _rtthread_timerChangePeriod, //rtw_timerChangePeriod - _rtthread_timerGetID, //rtw_timerGetID - _rtthread_timerStart, //rtw_timerStart - _rtthread_timerStartFromISR, //rtw_timerStartFromISR - _rtthread_timerStopFromISR, //rtw_timerStopFromISR - _rtthread_timerResetFromISR, //rtw_timerResetFromISR - _rtthread_timerChangePeriodFromISR, //rtw_timerChangePeriodFromISR - _rtthread_timerReset, //rtw_timerReset + _rtthread_timerCreate, //rtw_timerCreate, + _rtthread_timerDelete, //rtw_timerDelete, + _rtthread_timerIsTimerActive, //rtw_timerIsTimerActive, + _rtthread_timerStop, //rtw_timerStop, + _rtthread_timerChangePeriod, //rtw_timerChangePeriod + _rtthread_timerGetID, //rtw_timerGetID + _rtthread_timerStart, //rtw_timerStart + _rtthread_timerStartFromISR, //rtw_timerStartFromISR + _rtthread_timerStopFromISR, //rtw_timerStopFromISR + _rtthread_timerResetFromISR, //rtw_timerResetFromISR + _rtthread_timerChangePeriodFromISR, //rtw_timerChangePeriodFromISR + _rtthread_timerReset, //rtw_timerReset - _rtthread_acquire_wakelock, //rtw_acquire_wakelock - _rtthread_release_wakelock, //rtw_release_wakelock - _rtthread_wakelock_timeout, //rtw_wakelock_timeout - _rtthread_get_scheduler_state //rtw_get_scheduler_state + _rtthread_acquire_wakelock, //rtw_acquire_wakelock + _rtthread_release_wakelock, //rtw_release_wakelock + _rtthread_wakelock_timeout, //rtw_wakelock_timeout + _rtthread_get_scheduler_state //rtw_get_scheduler_state }; void vTaskDelay( const rt_uint32_t xTicksToDelay ) { - rt_thread_delay(xTicksToDelay); + rt_thread_delay(xTicksToDelay); } void *pvPortMalloc( size_t xWantedSize ) { - return rt_malloc(xWantedSize); + return rt_malloc(xWantedSize); } void vPortFree( void *pv ) @@ -992,4 +1145,3 @@ uint32_t xTaskGetTickCount( void ) return rt_tick_get(); } - diff --git a/rtthread_patch/realtek/8711b/app_start.c b/rtthread_patch/realtek/8711b/app_start.c index 1688a49..07658f1 100644 --- a/rtthread_patch/realtek/8711b/app_start.c +++ b/rtthread_patch/realtek/8711b/app_start.c @@ -11,6 +11,8 @@ #include "build_info.h" #include "rtconfig.h" +extern int rtthread_startup(void); + void APP_Start(void) { #if CONFIG_SOC_PS_MODULE diff --git a/rtthread_patch/realtek/8711b/include/platform_autoconf.h b/rtthread_patch/realtek/8711b/include/platform_autoconf.h index 3f95890..7d9cd4b 100644 --- a/rtthread_patch/realtek/8711b/include/platform_autoconf.h +++ b/rtthread_patch/realtek/8711b/include/platform_autoconf.h @@ -53,7 +53,7 @@ /* * < CONFIG OS */ -#define CONFIG_KERNEL 1 +// #define CONFIG_KERNEL 0 #define PLATFORM_FREERTOS 1 #undef PLATFORM_UCOSII #undef PLATFORM_ECOS diff --git a/sdk-ameba-v4.0b_without_NDA_GCC_V1.0.0/component/soc/realtek/8711b/app/monitor/ram/rtl_consol.c b/sdk-ameba-v4.0b_without_NDA_GCC_V1.0.0/component/soc/realtek/8711b/app/monitor/ram/rtl_consol.c index edbdebf..38dc0d6 100644 --- a/sdk-ameba-v4.0b_without_NDA_GCC_V1.0.0/component/soc/realtek/8711b/app/monitor/ram/rtl_consol.c +++ b/sdk-ameba-v4.0b_without_NDA_GCC_V1.0.0/component/soc/realtek/8711b/app/monitor/ram/rtl_consol.c @@ -297,6 +297,7 @@ UartLogCmdExecuteRam( return FALSE; } +#ifdef CONFIG_KERNEL VOID RtlConsolTaskRam( @@ -361,6 +362,7 @@ RtlConsolTaskRam( } }while(1); } +#endif /** * @brief Set UartLog Baud Rate use baudrate val.