//----------------------------------------------------------------------------// /** ****************************************************************************** * @file osdep_service.h * @author * @version * @brief This file provides the OS dependent API. ****************************************************************************** * @attention * * This module is a confidential and proprietary property of RealTek and * possession or use of this module requires written permission of RealTek. * * Copyright(c) 2016, Realtek Semiconductor Corporation. All rights reserved. ****************************************************************************** */ #ifndef __OSDEP_SERVICE_H_ #define __OSDEP_SERVICE_H_ /** @addtogroup RTOS * @{ */ /*************************** OS dep feature enable *******************************/ /****************************************************** * Macros ******************************************************/ #define CONFIG_LITTLE_ENDIAN #if defined(CONFIG_PLATFORM_8195A) || defined(CONFIG_PLATFORM_8711B) #define CONFIG_PLATFORM_AMEBA_X #endif #if defined(CONFIG_PLATFORM_8195A) #define CONFIG_USE_TCM_HEAP 1 /* USE TCM HEAP */ #define USE_MUTEX_FOR_SPINLOCK 1 #endif #if defined(CONFIG_PLATFORM_AMEBA_X) #define CONFIG_MEM_MONITOR MEM_MONITOR_SIMPLE #else #define CONFIG_MEM_MONITOR MEM_MONITOR_LEAK #endif /* Define compilor specific symbol */ /*************************** inline functions *******************************/ #if defined ( __ICCARM__ ) #define __inline__ inline #define __inline inline #define __inline_definition //In dialect C99, inline means that a function's definition is provided //only for inlining, and that there is another definition //(without inline) somewhere else in the program. //That means that this program is incomplete, because if //add isn't inlined (for example, when compiling without optimization), //then main will have an unresolved reference to that other definition. // Do not inline function is the function body is defined .c file and this // function will be called somewhere else, otherwise there is compile error #elif defined ( __CC_ARM ) #define __inline__ __inline //__linine__ is not supported in keil compilor, use __inline instead #define inline __inline #define __inline_definition // for dialect C99 #elif defined ( __GNUC__ ) #define __inline__ inline #define __inline inline #define __inline_definition inline #endif #include #if defined(CONFIG_PLATFORM_8195A) || defined(CONFIG_PLATFORM_8711B) #include "platform_autoconf.h" #else //for 8189FM/8189FTV add by frankie_li 20160408 #ifndef SUCCESS #define SUCCESS 0 #endif #ifndef FAIL #define FAIL (-1) #endif #ifndef _SUCCESS #define _SUCCESS 1 #endif #ifndef _FAIL #define _FAIL 0 #endif #ifndef FALSE #define FALSE 0 #endif #ifndef TRUE #define TRUE (!FALSE) #endif #define _TRUE TRUE #define _FALSE FALSE #endif #if defined( PLATFORM_FREERTOS) #include "freertos_service.h" #elif defined( PLATFORM_ECOS) #include "ecos/ecos_service.h" #endif #define RTW_MAX_DELAY 0xFFFFFFFF #define RTW_WAIT_FOREVER 0xFFFFFFFF /****************************************************** * Constants ******************************************************/ /** * @brief Definitions returned by xTaskGetSchedulerState(). */ #define OS_SCHEDULER_NOT_STARTED 0 #define OS_SCHEDULER_RUNNING 1 #define OS_SCHEDULER_SUSPENDED 2 /****************************************************** * Structures ******************************************************/ struct timer_list { _timerHandle timer_hdl; unsigned long data; void (*function)(void *); }; /****************************************************** * Type Definitions ******************************************************/ typedef thread_return (*thread_func_t)(thread_context context); typedef void (*TIMER_FUN)(void *context); typedef int (*event_handler_t)(char *buf, int buf_len, int flags, void *user_data); #define CONFIG_THREAD_COMM_SEMA struct task_struct { const char *task_name; _thread_hdl_ task; /* I: workqueue thread */ #ifdef CONFIG_THREAD_COMM_SIGNAL const char *name; /* I: workqueue thread name */ u32 queue_num; /* total signal num */ u32 cur_queue_num; /* cur signal num should < queue_num */ #elif defined(CONFIG_THREAD_COMM_SEMA) _sema wakeup_sema; _sema terminate_sema; // _queue work_queue; //TODO #endif u32 blocked; u32 callback_running; }; typedef struct { _xqueue event_queue; struct task_struct thread; }rtw_worker_thread_t; typedef struct { event_handler_t function; char *buf; int buf_len; int flags; void *user_data; } rtw_event_message_t; struct worker_timer_entry { struct list_head list; _timerHandle timer_hdl; rtw_event_message_t message; rtw_worker_thread_t *worker_thread; u32 timeout; }; #ifdef CONFIG_THREAD_COMM_SIGNAL struct work_struct; typedef void (*work_func_t)(void *context); struct work_struct { _list list; u32 data; work_func_t func; void *context; struct task_struct *used_wq; }; struct delayed_work { struct work_struct work; struct timer_list timer; }; #endif #ifdef CONFIG_MEM_MONITOR /*************************** Memory Monitor *******************************/ #define MEM_MONITOR_SIMPLE 0x1 #define MEM_MONITOR_LEAK 0x2 #define MEM_MONITOR_FLAG_WIFI_DRV 0x1 #define MEM_MONITOR_FLAG_WPAS 0x2 #if CONFIG_MEM_MONITOR & MEM_MONITOR_LEAK struct mem_entry { struct list_head list; int size; void *ptr; }; #endif /** * @brief This function initializes a memory table. * @param[in] pmem_table: The pointer to the memory table. * @param[in] used_num: The number of mem_entry kept in monitor which will be set to 0. * @return None */ void init_mem_monitor(_list *pmem_table, int *used_num); /** * @brief This function deinitializes a memory table. * @param[in] pmem_table: The pointer to the memory table. * @param[in] used_num: The number of mem_entry kept in monitor. * @return None */ void deinit_mem_monitor(_list *pmem_table, int *used_num); /** * @brief This function alloc mem_entry to the memory table. * @param[in] pmem_table: The pointer to the memory table to be added. * @param[in] ptr: The pointer to the position to be added. * @param[in] size: The size of added memory. * @param[in] used_num: The number of mem_entry kept in monitor which will add 1 after. * @param[in] flag: MEM_MONITOR_FLAG_WPAS/MEM_MONITOR_FLAG_WIFI_DRV * @return None */ void add_mem_usage(_list *pmem_table, void *ptr, int size, int *used_num, int flag); /** * @brief This function frees memory from the memory table. * @param[in] pmem_table: The pointer to the memory table * @param[in] ptr: The pointer to the position to be free. * @param[in] used_num: The number of mem_entry kept in monitor. * @param[in] flag: MEM_MONITOR_FLAG_WPAS/MEM_MONITOR_FLAG_WIFI_DRV * @return None */ void del_mem_usage(_list *pmem_table, void *ptr, int *used_num, int flag); /** * @brief This function get the memory usage of a memory table. * @param[in] pmem_table: The pointer to the memory table. * @return The size of the memory used */ int get_mem_usage(_list *pmem_table); /*************************** End Memory Monitor *******************************/ #endif /*************************** Memory Management *******************************/ u8* _rtw_vmalloc(u32 sz); u8* _rtw_zvmalloc(u32 sz); void _rtw_vmfree(u8 *pbuf, u32 sz); u8* _rtw_zmalloc(u32 sz); u8* _rtw_malloc(u32 sz); void _rtw_mfree(u8 *pbuf, u32 sz); #ifdef CONFIG_MEM_MONITOR /** * @brief This function allocates the virtually contiguous memory. * @param[in] sz: The size of memory to be allocated. * @return The pointer to the beginning of the memory */ u8* rtw_vmalloc(u32 sz); /** * @brief This function allocates the virtually contiguous memory * and the values of the memory are setted to 0. * @param[in] sz: The size of memory to be allocated. * @return The pointer to the beginning of the memory */ u8* rtw_zvmalloc(u32 sz); /** * @brief This function frees the virtually contiguous memory. * @param[in] pbuf: The pointer to the beginning of the memory to be free * @param[in] sz: The size of memory allocated. * @return None */ void rtw_vmfree(u8 *pbuf, u32 sz); /** * @brief This function allocates the memory * and the values of the memory are setted to 0. * @param[in] sz: The size of memory to be allocated. * @return The pointer to the beginning of the memory */ u8* rtw_zmalloc(u32 sz); /** * @brief This function allocates the memory. * @param[in] sz: The size of memory to be allocated. * @return The pointer to the beginning of the memory */ u8* rtw_malloc(u32 sz); /** * @brief This function frees the virtually contiguous memory. * @param[in] pbuf: The pointer to the beginning of the memory to be free * @param[in] sz: The size of memory allocated. * @return None */ void rtw_mfree(u8 *pbuf, u32 sz); #else #define rtw_vmalloc _rtw_vmalloc #define rtw_zvmalloc _rtw_zvmalloc #define rtw_vmfree _rtw_vmfree #define rtw_zmalloc _rtw_zmalloc #define rtw_malloc _rtw_malloc #define rtw_mfree _rtw_mfree #endif #define rtw_free(buf) rtw_mfree((u8 *)buf, 0) /** * @brief This function allocates a 2 dimensional array memory. * @param[in] h: The height of the 2D array. * @param[in] w: The width of the 2D array. * @param[in] size: The size of the each charactor in array. * @return the pointer to the beginning of the block */ void* rtw_malloc2d(int h, int w, int size); /** * @brief This function deallocates the block of memory previously allocated to make it available again. * @param[in] pbuf: Pointer to a memory block previously allocated. * @param[in] h: The height of the 2D array. * @param[in] w: The width of the 2D array. * @param[in] size: The size of the each charactor in array. * @return None */ void rtw_mfree2d(void *pbuf, int h, int w, int size); /** * @brief This function copies the values of "sz" bytes from the location pointed to by "src" * directly to the memory block pointed to by "des". * @param[in] dst: Pointer to the destination array where the content is to be copied, type-casted to a pointer of type void*. * @param[in] src: Pointer to the source of data to be copied, type-casted to a pointer of type void*. * @param[in] sz: Size of memory to copy. * @return None */ void rtw_memcpy(void* dst, void* src, u32 sz); /** * @brief This function compares the first "sz" bytes of the block of memory pointed by "dst" * to the first "sz" bytes pointed by "src". * @param[in] dst: Pointer to block of memory to be compared. * @param[in] src: pointer to block of memory to compare. * @param[in] sz: Size of memory to compare. * @return <0: The first byte that does not match in both memory blocks has a lower value in dst than in src. * @return 0: The contents of both memory blocks are equal. * @return <0: The first byte that does not match in both memory blocks has a greater value in dst than in src. */ int rtw_memcmp(void *dst, void *src, u32 sz); /** * @brief This function sets the first "sz" bytes of the block of memory pointed by "pbuf" to the specified "c". * @param[in] pbuf: Pointer to the block of memory to fill. * @param[in] c: Value to be set. * @param[in] sz: Size of memory to be set to the value "c". * @return None */ void rtw_memset(void *pbuf, int c, u32 sz); /*************************** End Memory Management *******************************/ /*************************** List *******************************/ /** * @brief This function initializes the head of the list. * @param[in] list: Pointer to the list to be initialized. * @return None */ void rtw_init_listhead(_list *list); /** * @brief This function tests whether a list is empty. * @param[in] phead: Pointer to the list to test. * @return _TRUE/_FALSE */ u32 rtw_is_list_empty(_list *phead); /** * @brief This function adds a new entry after "phead" for the list. * @param[in] plist: Pointer to the list to be added. * @param[in] phead: List head to add it after. * @return None */ void rtw_list_insert_head(_list *plist, _list *phead); /** * @brief This function adds a new entry before "phead" for the list. * @param[in] plist: Pointer to the list to be added. * @param[in] phead: List head to add it before. * @return None */ void rtw_list_insert_tail(_list *plist, _list *phead); /** * @brief This function deletes entry from list and reinitialize it. * @param[in] plist: The element to delete from the list. * @return None * @note Caller must check if the list is empty before calling rtw_list_delete */ void rtw_list_delete(_list *plist); /*************************** End List *******************************/ /*************************** Semaphores *******************************/ /** * @brief This function initializes the unnamed semaphore referred to by "sema" to the value "init_val". * @param[in] sema: Pointer to the semaphore handle to be initialized. * @param[in] init_val: Initial value for semaphore. * @return None */ void rtw_init_sema(_sema *sema, int init_val); /** * @brief This function deletes the semaphore. * @param[in] sema: The semaphore to be deleted. * @return None */ void rtw_free_sema(_sema *sema); /** * @brief This function releases the semaphore. * This macro must not be used from an ISR. * @param[in] sema: The semaphore to be released. * @return None */ void rtw_up_sema(_sema *sema); /** * @brief This function releases the semaphore. * This macro can be used from an ISR. * @param[in] sema: The semaphore to be released. * @return None */ void rtw_up_sema_from_isr(_sema *sema); /** * @brief This function acquires the semaphore. If no more tasks are allowed to acquire the semaphore, * calling this function will put the task to sleep until the semaphore is up. * @param[in] sema: The semaphore to be acquired. * @return pdTRUE: The semaphore was obtained. * @return pdFALSE: Obtain the semaphore failed. */ u32 rtw_down_sema(_sema *sema); /** * @brief This function acquires the semaphore. If no more tasks are allowed to acquire the semaphore, * calling this function will put the task to sleep until the semaphore is up. * @param[in] sema: The semaphore to be acquired. * @param[in] timeout: The time in ms to wait for the semaphore to become available. * @return pdTRUE: The semaphore was obtained. * @return pdFALSE: Timeout without the semaphore becoming available. */ u32 rtw_down_timeout_sema(_sema *sema, u32 timeout); /*************************** End Semaphores *******************************/ /*************************** Mutexes *******************************/ /** * @brief This function implements a mutex semaphore by using the existing queue mechanism. * @param[in] pmutex: Pointer to the created mutex semaphore. * @return None */ void rtw_mutex_init(_mutex *pmutex); /** * @brief This function deletes the mutex semaphore. * @param[in] pmutex: Pointer to the mutex semaphore to be deleted. * @return None */ void rtw_mutex_free(_mutex *pmutex); /** * @brief This function releases a mutex semaphore. * @param[in] pmutex: Pointer to the mutex semaphore to be released. * @return None */ void rtw_mutex_put(_mutex *pmutex); /** * @brief This function obtains a mutex semaphore. * @param[in] pmutex: Pointer to the mutex semaphore being taken - obtained when * the mutex semaphore was created. * @return None */ void rtw_mutex_get(_mutex *pmutex); /** * @brief This function obtains a mutex semaphore with a timeout setting. * @param[in] pmutex: Pointer to the mutex semaphore being taken - obtained when * the mutex semaphore was created. * @param[in] timeout: The time in ms to wait for the semaphore to become available. * @return 0: The semaphore was obtained. * @return -1: Timeout without the semaphore becoming available. */ int rtw_mutex_get_timeout(_mutex *pmutex, u32 timeout_ms); /*************************** End Mutexes *******************************/ /*************************** SchedulerControl *******************************/ /** * @brief This function marks the start of a critical code region. * Preemptive context switches cannot occur when in a critical region. * @param[in] plock: Pointer to the spin lock semaphore. * @param[in] pirqL: Pointer to the IRQ. * @return None * @note: This may alter the stack (depending on the portable implementation) * so must be used with care! */ void rtw_enter_critical(_lock *plock, _irqL *pirqL); /** * @brief This function marks end of a critical code region. Preemptive context * switches cannot occur when in a critical region. * @param[in] plock: Pointer to the spin lock semaphore. * @param[in] pirqL: Pointer to the IRQ. * @return None * @note: This may alter the stack (depending on the portable implementation) * so must be used with care! */ void rtw_exit_critical(_lock *plock, _irqL *pirqL); /** * @brief This function marks the start of a critical code region from isr. * @param[in] plock: Pointer to the spin lock semaphore. * @param[in] pirqL: Pointer to the IRQ. * @return None */ void rtw_enter_critical_from_isr(_lock *plock, _irqL *pirqL); /** * @brief This function marks the end of a critical code region from isr. * @param[in] plock: Pointer to the spin lock semaphore. * @param[in] pirqL: Pointer to the IRQ. * @return None */ void rtw_exit_critical_from_isr(_lock *plock, _irqL *pirqL); /** * @brief This function obtains a spin lock semaphore. * @param[in] plock: Pointer to the spin lock semaphore being taken - obtained when * the mutex semaphore was created. * @param[in] pirqL: Pointer to the IRQ. * @return None */ void rtw_enter_critical_bh(_lock *plock, _irqL *pirqL); /** * @brief This function releases a spin lock semaphore. * @param[in] plock: Pointer to the spin lock semaphore to be released. * @param[in] pirqL: Pointer to the IRQ. * @return None */ void rtw_exit_critical_bh(_lock *plock, _irqL *pirqL); /** * @brief This function obtains a semaphore. * @param[in] pmutex: The handle to the mutex semaphore to be obtained. * @param[in] pirqL: Pointer to the IRQ. * @return None */ int rtw_enter_critical_mutex(_mutex *pmutex, _irqL *pirqL); /** * @brief This function releases a semaphore. * @param[in] pmutex: The handle to the mutex semaphore to be released. * @param[in] pirqL: Pointer to the IRQ. * @return None */ void rtw_exit_critical_mutex(_mutex *pmutex, _irqL *pirqL); /*************************** End SchedulerControl *******************************/ /*************************** Semaphores *******************************/ /** * @brief This function implements a spin lock semaphore by using the existing queue mechanism. * @param[in] plock: Pointer to the created spin lock semaphore. * @return None */ void rtw_spinlock_init(_lock *plock); /** * @brief This function deletes the spin lock semaphore. * @param[in] pmutex: Pointer to the spin lock semaphore to be deleted. * @return None */ void rtw_spinlock_free(_lock *plock); /** * @brief This function obtains a spin lock semaphore. * @param[in] plock: Pointer to the spin lock semaphore being taken - obtained when * the mutex semaphore was created. * @return None */ void rtw_spin_lock(_lock *plock); /** * @brief This function releases a spin lock semaphore. * @param[in] plock: Pointer to the spin lock semaphore to be released. * @return None */ void rtw_spin_unlock(_lock *plock); /** * @brief This function marks the start of a critical code region and * obtains a spin lock semaphore. * @param[in] plock: Pointer to the spin lock semaphore being taken - obtained when * the mutex semaphore was created. * @param[in] irqL: Pointer to the IRQ. * @return None */ void rtw_spinlock_irqsave(_lock *plock, _irqL *irqL); /** * @brief This function releases a spin lock semaphore and marks the end of a critical code region. * @param[in] plock: Pointer to the spin lock semaphore to be released. * @param[in] irqL: Pointer to the IRQ. * @return None */ void rtw_spinunlock_irqsave(_lock *plock, _irqL *irqL); /*************************** End Semaphores *******************************/ /*************************** Queues *******************************/ /** * @brief This function creates a new queue instance. * @param[in] queue: The handle to the newly created queue. * @param[in] name: The name of the queue * @param[in] message_size: The number of bytes each message in the queue will require. * @param[in] number_of_messages: The maximum number of messages that kthe queue can contain. * @return 0: Creating queue success * @return -1: Creating queue fail */ int rtw_init_xqueue( _xqueue* queue, const char* name, u32 message_size, u32 number_of_messages ); /** * @brief This function posts a message to the back of a queue. * The message is queued by copy, not by reference. * @param[in] queue: The handle to the queue on which the message is to be posted. * @param[in] message: The pointer to the message that is to be placed on the queue. * @param[in] timeout_ms: The maximum amout of time the task should block waiting for the space to become available on the queue, should it already be full. The time is defined in ms. * @return 0: The message was successfully posted. * @return -1: The message was not posted. */ int rtw_push_to_xqueue( _xqueue* queue, void* message, u32 timeout_ms ); /** * @brief This function receives a message from a queue. * The message is recieved by copy so a buffer adequate size must be provided. * @param[in] queue: The handle to the queue from which the message is to be received. * @param[in] message: The pointer to the buffer into which the received message will be copied. * @param[in] timeout_ms: The maximum amout of time the task should block waiting for a message to * receive should the queue be empty at the time of the call. The time is defined in ms. * @return 0: A message was successfully received from the queue. * @return -1: No message was received from the queue. */ int rtw_pop_from_xqueue( _xqueue* queue, void* message, u32 timeout_ms ); /** * @brief Delete a queue - freeing all the memory allocated for storing of messages placed on the queue. * @param[in] queue: The handle to the queue to be deleted. * @return 0: The queue was successfully deleted. * @return -1: The queue was not empty so cannot be deleted. */ int rtw_deinit_xqueue( _xqueue* queue ); /** * @brief This function creates a new queue instance. * @param[in] pqueue: The handle to the newly created queue. * @return None */ void rtw_init_queue(_queue *pqueue); void rtw_deinit_queue(_queue *pqueue); u32 rtw_is_queue_empty(_queue *pqueue); /** * @brief This function tests whether the queue is empty. * @param[in] pqueue: The handle to the queue to be tested. * @return None */ u32 rtw_queue_empty(_queue *pqueue); /** * @brief This function tests whether the "pelement" is at the "queue". * @param[in] queue: The pointer to the queue that to be tested. * @param[in] pelement: The element that to be tested. * @return _TRUE/_FALSE */ u32 rtw_end_of_queue_search(_list *queue, _list *pelement); _list* rtw_get_queue_head(_queue *queue); /*************************** End Queues *******************************/ /*************************** Time Management *******************************/ /** * @brief Get the count of ticks since the vTaskStartScheduler was called. * @return The count of ticks since the vTaskStartScheduler was called. */ u32 rtw_get_current_time(void); /** * @brief Convert system time to milliseconds. * @param[in] systime: The system time to be converted. * @return : The milliseconds that converted by the system time. */ u32 rtw_systime_to_ms(u32 systime); /** * @brief Convert system time to seconds. * @param[in] systime: The system time to be converted. * @return : The seconds that converted by the system time. */ u32 rtw_systime_to_sec(u32 systime); /** * @brief Convert milliseconds to system time. * @param[in] systime: The milliseconds to be converted. * @return : The system time that converted by the milliseconds. */ u32 rtw_ms_to_systime(u32 ms); /** * @brief Convert seconds to system time. * @param[in] systime: The seconds to be converted. * @return : The system time that converted by the seconds. */ u32 rtw_sec_to_systime(u32 sec); /** * @brief Get the passing time from the "start" in milliseconds. * @param[in] start: The start time which is in system time format. * @return : The passing time from "start" in milliseconds. */ s32 rtw_get_passing_time_ms(u32 start); /** * @brief Get the interval time from the "start" to "end" in milliseconds. * @param[in] start: The start time which is in system time format. * @param[in] end: The end time which is in system time format. * @return : The interval time from "start" to "end" in milliseconds. */ s32 rtw_get_time_interval_ms(u32 start, u32 end); /*************************** End Time Management *******************************/ /** * @brief This function suspends execution of the calling thread for "ms" milliseconds. * @param[in] ms: The time that the function sleep in milliseconds * @return None */ void rtw_msleep_os(int ms); /** * @brief This function suspends execution of the calling thread for "us" microseconds. * @param[in] ms: The time that the function sleep in microseconds * @return None */ void rtw_usleep_os(int us); /** * @brief This function converts the initial portion of the string to integer. * @param[in] s: The pointer to the string to be converted. * @return The converted value. */ u32 rtw_atoi(u8* s); /** * @brief This function delays a task for the giving time in milliseconds. * @param[in] ms: The amount of time, in milliseconds, that the calling task should block. * @return None */ void rtw_mdelay_os(int ms); /** * @brief This function delays a task for the giving time in microseconds. * @param[in] ms: The amount of time, in microseconds, that the calling task should block. * @return None */ void rtw_udelay_os(int us); /** * @brief This function for forcing a context switch. * @return None */ void rtw_yield_os(void); /*************************** ATOMIC Integer *******************************/ /** * @brief This function atomically sets the value of the variable. * @param[in] v: Pointer of type atomic_t that to be set value. * @param[in] i: Required value. * @return None * @note The guaranteed useful range of an atomic_t is only 24 bits. */ void ATOMIC_SET(ATOMIC_T *v, int i); /** * @brief This function atomically reads the value of the variable. * @param[in] v: Pointer of type atomic_t that to be read. * @return The value of the variable. * @note The guaranteed useful range of an atomic_t is only 24 bits. */ int ATOMIC_READ(ATOMIC_T *v); /** * @brief This function adds "i" to the contained "v". * @param[in] v: Pointer of type atomic_t. * @param[in] i: value to add. * @return None */ void ATOMIC_ADD(ATOMIC_T *v, int i); /** * @brief This function subtracts "i" from th econtained "v". * @param[in] v: Pointer of type atomic_t. * @param[in] i: value to subtract. * @return None */ void ATOMIC_SUB(ATOMIC_T *v, int i); /** * @brief This function adds 1 to the contained "v". * @param[in] v: Pointer of type atomic_t. * @return None */ void ATOMIC_INC(ATOMIC_T *v); /** * @brief This function subtracts 1 from th econtained "v". * @param[in] v: Pointer of type atomic_t. * @return None */ void ATOMIC_DEC(ATOMIC_T *v); /** * @brief This function adds "i" to the contained "v" and returns the result. * @param[in] v: Pointer of type atomic_t. * @param[in] i: value to add. * @return None */ int ATOMIC_ADD_RETURN(ATOMIC_T *v, int i); /** * @brief This function subtracts "i" from th econtained "v" and returns the result. * @param[in] v: Pointer of type atomic_t. * @param[in] i: value to subtract. * @return None */ int ATOMIC_SUB_RETURN(ATOMIC_T *v, int i); /** * @brief This function adds 1 to the contained "v" and returns the result. * @param[in] v: Pointer of type atomic_t. * @return None */ int ATOMIC_INC_RETURN(ATOMIC_T *v); /** * @brief This function subtracts 1 from th econtained "v" and returns the result. * @param[in] v: Pointer of type atomic_t. * @return None */ int ATOMIC_DEC_RETURN(ATOMIC_T *v); /** * @brief This function subtracts 1 from th econtained "v" and test if the result equals 0. * @param[in] v: Pointer of type atomic_t. * @return 0: The result after subtracting 1 is 0 * @return -1: The result after subtracting 1 is not 0 */ int ATOMIC_DEC_AND_TEST(ATOMIC_T *v); /*************************** End ATOMIC *******************************/ u64 rtw_modular64(u64 x, u64 y); /** * @brief This function generates random bytes. * @param[in] dst: The pointer to the buffer to store the random bytes. * @param[in] size: The size of the random bytes. * @return 0 */ int rtw_get_random_bytes(void* dst, u32 size); /** * @brief This function gets the available heap size. * @return The value of the available heap size. */ u32 rtw_getFreeHeapSize(void); void flush_signals_thread(void); /** * @brief This function indicates that the WLAN needs to stay on which means cannot go into power saving mode. * @return None * @note Defining configUSE_WAKELOCK_PMU 1 in "FreeRTOSConfig.h" needs to be done before compiling, * or this API won't be effective. */ void rtw_acquire_wakelock(void); /** * @brief This function indicates that the WLAN does not need to stay on which means can go into power saving mode. * @return None * @note Defining configUSE_WAKELOCK_PMU 1 in "FreeRTOSConfig.h" needs to be done before compiling, * or this API won't be effective. */ void rtw_release_wakelock(void); void rtw_wakelock_timeout(u32 timeout); /*********************************** Thread related *****************************************/ /** * @brief This function creates a new task and adds it to the list of tasks that are ready to run. * @param[in] task: The task stucture which will store the task related infomation. * @param[in] name: A descriptive name for the task. * @param[in] stack_size: The size of the task stack specified as the variables the stack can hold. * @param[in] priority: The priority at which the task should run. * @param[in] func: The task entry function. * @param[in] thctx: The pointer that will be used as the parameter for the task being created. * @return pdPASS: The task was successfully created and added to a ready list. * @return other error code defined in the file errors.h. * @note For the task name, please do not use "rtw_little_wifi_mcu_thread", "rtw_check_in_req_state_thread", "rtw_TDMA_change_state_thread", "xmit_thread", "recv_thread", "rtw_recv_tasklet", "rtw_xmit_tasklet", "rtw_interrupt_thread", "cmd_thread", "usb_init", "MSC_BULK_CMD" and "MSC_BULK_DATA". */ int rtw_create_task(struct task_struct *task, const char *name, u32 stack_size, u32 priority, thread_func_t func, void *thctx); /** * @brief This function deletes a task. * @param[in] task: The task stucture which will be deleted. * @return None */ void rtw_delete_task(struct task_struct * task); /** * @brief This function wake up a task. * @param[in] task: The task stucture which will be waked up. * @return None */ void rtw_wakeup_task(struct task_struct *task); /** * @brief This function creates a new worker thread. * @param[in] worker_thread: The pointer to the worker thread stucture. * @param[in] priority: The priority of the thread. * @param[in] stack_size: The size of the thread stack specified as the variables the stack can hold. * @param[in] event_queue_size: The queue size of events. * @return SUCCESS/FAIL. */ int rtw_create_worker_thread( rtw_worker_thread_t* worker_thread, u8 priority, u32 stack_size, u32 event_queue_size ); /** * @brief This function deletes a worker thread. * @param[in] worker_thread: The pointer to the worker thread stucture to be deleted. * @return SUCCESS/FAIL. */ int rtw_delete_worker_thread( rtw_worker_thread_t* worker_thread ); #if 0 //TODO void rtw_init_delayed_work(struct delayed_work *dwork, work_func_t func, const char *name); void rtw_deinit_delayed_work(struct delayed_work *dwork); int rtw_queue_delayed_work(struct workqueue_struct *wq, struct delayed_work *dwork, u32 delay, void* context); BOOLEAN rtw_cancel_delayed_work(struct delayed_work *dwork); #endif /** * @brief This function prints the name of the thread in DBG_INFO. * @param[in] name: The name of the thread. * @return None */ void rtw_thread_enter(char *name); /** * @brief This function exits the calling thread. * @return None */ void rtw_thread_exit(void); /** * @brief This function gets the scheduler state of the calling thread. * @return OS_SCHEDULER_NOT_STARTED * @return OS_SCHEDULER_RUNNING * @return OS_SCHEDULER_SUSPENDED */ u8 rtw_get_scheduler_state(void); /*************************** End Threads *******************************/ #ifdef PLATFORM_LINUX #define rtw_warn_on(condition) WARN_ON(condition) #else #define rtw_warn_on(condition) do {} while (0) #endif /*************************** Timers *******************************/ /** * @brief This function creates a new software timer instance. * @param[in] pcTimerName: A text name that is assigned to the timer. * @param[in] xTimerPeriodInTicks: The timer period which is defined in tick periods. * @param[in] uxAutoReload: If uxAutoReload is set to pdTRUE then the timer will * expire repeatedly with a frequency set by the xTimerPeriodInTicks parameter. If * uxAutoReload is set to pdFALSE then the timer will be a one-shot timer and * enter the dormant state after it expires. * @param[in] pvTimerID: An identifier that is assigned to the timer being created. * @param[in] pxCallbackFunction: The function to call when the timer expires. * @return If the timer is successfully create then a handle to the newly * created timer is returned. If the timer cannot be created, then 0 is returned. */ _timerHandle rtw_timerCreate( const signed char *pcTimerName, osdepTickType xTimerPeriodInTicks, u32 uxAutoReload, void * pvTimerID, TIMER_FUN pxCallbackFunction ); /** * @brief This function deletes a timer that was previously created using rtw_timerCreate. * @param[in] xTimer: The handle of the timer being deleted. * @param[in] xBlockTime: Specifies th etime, in ticks, that the calling task should be held in the Blocked * State to wait for the delete command to be successfully sent to the timer command queue, * should the queue already be full when rtw_timerDelete was called. * @return pdFAIL will be returned if the delete command could not be sent to * the timer command queue even after xTicksToWait ticks had passed. pdPASS will * be returned if the command was successfully sent to the timer command queue. * When the command is actually processed will depend on the priority of the * timer service/daemon task relative to other tasks in the system. */ u32 rtw_timerDelete( _timerHandle xTimer, osdepTickType xBlockTime ); /** * @brief This function queries a timer to see if it is active or dormant. * @param[in] xTimer: The timer being queried. * @return pdFALSE will be returned if the timer is dormant. A value other than * pdFALSE will be returned if the timer is active. * @note A timer will be dormant if: * 1) It has been created but not started, or * 2) It is an expired one-shot timer that has not been restarted. */ u32 rtw_timerIsTimerActive( _timerHandle xTimer ); /** * @brief This function stops a timer that was previously started. * @param[in] xTimer: The handle of the timer being stopped. * @param[in] xBlockTime: Specifies the time, in ticks, that the calling task should * be held in the Blocked state to wait for the stop command to be successfully * sent to the timer command queue, should the queue already be full when * rtw_timerStop() was called. * @return pdFAIL will be returned if the stop command could not be sent to * the timer command queue even after xTicksToWait ticks had passed. pdPASS will * be returned if the command was successfully sent to the timer command queue. * When the command is actually processed will depend on the priority of the * timer service/daemon task relative to other tasks in the system. */ u32 rtw_timerStop( _timerHandle xTimer, osdepTickType xBlockTime ); /** * @brief This function changes the period of a timer that was previously created. * @param[in] xTimer: The handle of the timer that is having its period changed. * @param[in] xNewPeriod: The new period for xTimer. * @param[in] xBlockTime: Specifies the time, in ticks, that the calling task should * be held in the Blocked state to wait for the change period command to be * successfully sent to the timer command queue, should the queue already be * full when rtw_timerChangePeriod() was called. * @return pdFAIL will be returned if the change period command could not be * sent to the timer command queue even after xTicksToWait ticks had passed. * pdPASS will be returned if the command was successfully sent to the timer * command queue. When the command is actually processed will depend on the * priority of the timer service/daemon task relative to other tasks in the * system. */ u32 rtw_timerChangePeriod( _timerHandle xTimer, osdepTickType xNewPeriod, osdepTickType xBlockTime ); void *rtw_timerGetID( _timerHandle xTimer ); u32 rtw_timerStart( _timerHandle xTimer, osdepTickType xBlockTime ); u32 rtw_timerStartFromISR( _timerHandle xTimer, osdepBASE_TYPE *pxHigherPriorityTaskWoken ); u32 rtw_timerStopFromISR( _timerHandle xTimer, osdepBASE_TYPE *pxHigherPriorityTaskWoken ); u32 rtw_timerResetFromISR( _timerHandle xTimer, osdepBASE_TYPE *pxHigherPriorityTaskWoken ); u32 rtw_timerChangePeriodFromISR( _timerHandle xTimer, osdepTickType xNewPeriod, osdepBASE_TYPE *pxHigherPriorityTaskWoken ); u32 rtw_timerReset( _timerHandle xTimer, osdepTickType xBlockTime ); /*************************** End Timers *******************************/ #define LIST_CONTAINOR(ptr, type, member) \ ((type *)((char *)(ptr)-(SIZE_T)((char *)&((type *)ptr)->member - (char *)ptr))) #define time_after(a,b) ((long)(b) - (long)(a) < 0) #define time_before(a,b) time_after(b,a) #define time_after_eq(a,b) ((long)(a) - (long)(b) >= 0) #define time_before_eq(a,b) time_after_eq(b,a) #define _RND(sz, r) ((((sz)+((r)-1))/(r))*(r)) #define RND4(x) (((x >> 2) + (((x & 3) == 0) ? 0: 1)) << 2) __inline static u32 _RND4(u32 sz) { u32 val; val = ((sz >> 2) + ((sz & 3) ? 1: 0)) << 2; return val; } __inline static u32 _RND8(u32 sz) { u32 val; val = ((sz >> 3) + ((sz & 7) ? 1: 0)) << 3; return val; } __inline static u32 _RND128(u32 sz) { u32 val; val = ((sz >> 7) + ((sz & 127) ? 1: 0)) << 7; return val; } __inline static u32 _RND256(u32 sz) { u32 val; val = ((sz >> 8) + ((sz & 255) ? 1: 0)) << 8; return val; } __inline static u32 _RND512(u32 sz) { u32 val; val = ((sz >> 9) + ((sz & 511) ? 1: 0)) << 9; return val; } __inline static u32 bitshift(u32 bitmask) { u32 i; for (i = 0; i <= 31; i++) if (((bitmask>>i) & 0x1) == 1) break; return i; } /* Macros for handling unaligned memory accesses */ #define RTW_GET_BE16(a) ((u16) (((a)[0] << 8) | (a)[1])) #define RTW_PUT_BE16(a, val) \ do { \ (a)[0] = ((u16) (val)) >> 8; \ (a)[1] = ((u16) (val)) & 0xff; \ } while (0) #define RTW_GET_LE16(a) ((u16) (((a)[1] << 8) | (a)[0])) #define RTW_PUT_LE16(a, val) \ do { \ (a)[1] = ((u16) (val)) >> 8; \ (a)[0] = ((u16) (val)) & 0xff; \ } while (0) #define RTW_GET_BE24(a) ((((u32) (a)[0]) << 16) | (((u32) (a)[1]) << 8) | \ ((u32) (a)[2])) #define RTW_PUT_BE24(a, val) \ do { \ (a)[0] = (u8) ((((u32) (val)) >> 16) & 0xff); \ (a)[1] = (u8) ((((u32) (val)) >> 8) & 0xff); \ (a)[2] = (u8) (((u32) (val)) & 0xff); \ } while (0) #define RTW_GET_BE32(a) ((((u32) (a)[0]) << 24) | (((u32) (a)[1]) << 16) | \ (((u32) (a)[2]) << 8) | ((u32) (a)[3])) #define RTW_PUT_BE32(a, val) \ do { \ (a)[0] = (u8) ((((u32) (val)) >> 24) & 0xff); \ (a)[1] = (u8) ((((u32) (val)) >> 16) & 0xff); \ (a)[2] = (u8) ((((u32) (val)) >> 8) & 0xff); \ (a)[3] = (u8) (((u32) (val)) & 0xff); \ } while (0) #define RTW_GET_LE32(a) ((((u32) (a)[3]) << 24) | (((u32) (a)[2]) << 16) | \ (((u32) (a)[1]) << 8) | ((u32) (a)[0])) #define RTW_PUT_LE32(a, val) \ do { \ (a)[3] = (u8) ((((u32) (val)) >> 24) & 0xff); \ (a)[2] = (u8) ((((u32) (val)) >> 16) & 0xff); \ (a)[1] = (u8) ((((u32) (val)) >> 8) & 0xff); \ (a)[0] = (u8) (((u32) (val)) & 0xff); \ } while (0) #define RTW_GET_BE64(a) ((((u64) (a)[0]) << 56) | (((u64) (a)[1]) << 48) | \ (((u64) (a)[2]) << 40) | (((u64) (a)[3]) << 32) | \ (((u64) (a)[4]) << 24) | (((u64) (a)[5]) << 16) | \ (((u64) (a)[6]) << 8) | ((u64) (a)[7])) #define RTW_PUT_BE64(a, val) \ do { \ (a)[0] = (u8) (((u64) (val)) >> 56); \ (a)[1] = (u8) (((u64) (val)) >> 48); \ (a)[2] = (u8) (((u64) (val)) >> 40); \ (a)[3] = (u8) (((u64) (val)) >> 32); \ (a)[4] = (u8) (((u64) (val)) >> 24); \ (a)[5] = (u8) (((u64) (val)) >> 16); \ (a)[6] = (u8) (((u64) (val)) >> 8); \ (a)[7] = (u8) (((u64) (val)) & 0xff); \ } while (0) #define RTW_GET_LE64(a) ((((u64) (a)[7]) << 56) | (((u64) (a)[6]) << 48) | \ (((u64) (a)[5]) << 40) | (((u64) (a)[4]) << 32) | \ (((u64) (a)[3]) << 24) | (((u64) (a)[2]) << 16) | \ (((u64) (a)[1]) << 8) | ((u64) (a)[0])) struct osdep_service_ops { u8* (*rtw_vmalloc)(u32 sz); u8* (*rtw_zvmalloc)(u32 sz); void (*rtw_vmfree)(u8 *pbuf, u32 sz); u8* (*rtw_malloc)(u32 sz); u8* (*rtw_zmalloc)(u32 sz); void (*rtw_mfree)(u8 *pbuf, u32 sz); void (*rtw_memcpy)(void* dst, void* src, u32 sz); int (*rtw_memcmp)(void *dst, void *src, u32 sz); void (*rtw_memset)(void *pbuf, int c, u32 sz); void (*rtw_init_sema)(_sema *sema, int init_val); void (*rtw_free_sema)(_sema *sema); void (*rtw_up_sema)(_sema *sema); void (*rtw_up_sema_from_isr)(_sema *sema); u32 (*rtw_down_timeout_sema)(_sema *sema, u32 timeout); void (*rtw_mutex_init)(_mutex *pmutex); void (*rtw_mutex_free)(_mutex *pmutex); void (*rtw_mutex_get)(_mutex *pmutex); int (*rtw_mutex_get_timeout)(_mutex *pmutex, u32 timeout_ms); void (*rtw_mutex_put)(_mutex *pmutex); void (*rtw_enter_critical)(_lock *plock, _irqL *pirqL); void (*rtw_exit_critical)(_lock *plock, _irqL *pirqL); void (*rtw_enter_critical_from_isr)(_lock *plock, _irqL *pirqL); void (*rtw_exit_critical_from_isr)(_lock *plock, _irqL *pirqL); void (*rtw_enter_critical_bh)(_lock *plock, _irqL *pirqL); void (*rtw_exit_critical_bh)(_lock *plock, _irqL *pirqL); int (*rtw_enter_critical_mutex)(_mutex *pmutex, _irqL *pirqL); void (*rtw_exit_critical_mutex)(_mutex *pmutex, _irqL *pirqL); void (*rtw_spinlock_init)(_lock *plock); void (*rtw_spinlock_free)(_lock *plock); void (*rtw_spin_lock)(_lock *plock); void (*rtw_spin_unlock)(_lock *plock); void (*rtw_spinlock_irqsave)(_lock *plock, _irqL *irqL); void (*rtw_spinunlock_irqsave)(_lock *plock, _irqL *irqL); int (*rtw_init_xqueue)( _xqueue* queue, const char* name, u32 message_size, u32 number_of_messages ); int (*rtw_push_to_xqueue)( _xqueue* queue, void* message, u32 timeout_ms ); int (*rtw_pop_from_xqueue)( _xqueue* queue, void* message, u32 timeout_ms ); int (*rtw_deinit_xqueue)( _xqueue* queue ); u32 (*rtw_get_current_time)(void); u32 (*rtw_systime_to_ms)(u32 systime); u32 (*rtw_systime_to_sec)(u32 systime); u32 (*rtw_ms_to_systime)(u32 ms); u32 (*rtw_sec_to_systime)(u32 sec); void (*rtw_msleep_os)(int ms); void (*rtw_usleep_os)(int us); void (*rtw_mdelay_os)(int ms); void (*rtw_udelay_os)(int us); void (*rtw_yield_os)(void); void (*ATOMIC_SET)(ATOMIC_T *v, int i); int (*ATOMIC_READ)(ATOMIC_T *v); void (*ATOMIC_ADD)(ATOMIC_T *v, int i); void (*ATOMIC_SUB)(ATOMIC_T *v, int i); void (*ATOMIC_INC)(ATOMIC_T *v); void (*ATOMIC_DEC)(ATOMIC_T *v); int (*ATOMIC_ADD_RETURN)(ATOMIC_T *v, int i); int (*ATOMIC_SUB_RETURN)(ATOMIC_T *v, int i); int (*ATOMIC_INC_RETURN)(ATOMIC_T *v); int (*ATOMIC_DEC_RETURN)(ATOMIC_T *v); u64 (*rtw_modular64)(u64 x, u64 y); int (*rtw_get_random_bytes)(void* dst, size_t size); u32 (*rtw_getFreeHeapSize)(void); int (*rtw_create_task)(struct task_struct *task, const char *name, u32 stack_size, u32 priority, thread_func_t func, void *thctx); void (*rtw_delete_task)(struct task_struct *task); void (*rtw_wakeup_task)(struct task_struct *task); #if 0 //TODO void (*rtw_init_delayed_work)(struct delayed_work *dwork, work_func_t func, const char *name); void (*rtw_deinit_delayed_work)(struct delayed_work *dwork); int (*rtw_queue_delayed_work)(struct workqueue_struct *wq, struct delayed_work *dwork, unsigned long delay, void* context); BOOLEAN (*rtw_cancel_delayed_work)(struct delayed_work *dwork); #endif void (*rtw_thread_enter)(char *name); void (*rtw_thread_exit)(void); _timerHandle (*rtw_timerCreate)( const signed char *pcTimerName, osdepTickType xTimerPeriodInTicks, u32 uxAutoReload, void * pvTimerID, TIMER_FUN pxCallbackFunction ); u32 (*rtw_timerDelete)( _timerHandle xTimer, osdepTickType xBlockTime ); u32 (*rtw_timerIsTimerActive)( _timerHandle xTimer ); u32 (*rtw_timerStop)( _timerHandle xTimer, osdepTickType xBlockTime ); u32 (*rtw_timerChangePeriod)( _timerHandle xTimer, osdepTickType xNewPeriod, osdepTickType xBlockTime ); void* (*rtw_timerGetID)( _timerHandle xTimer ); u32 (*rtw_timerStart)( _timerHandle xTimer, osdepTickType xBlockTime ); u32 (*rtw_timerStartFromISR)( _timerHandle xTimer, osdepBASE_TYPE *pxHigherPriorityTaskWoken ); u32 (*rtw_timerStopFromISR)( _timerHandle xTimer, osdepBASE_TYPE *pxHigherPriorityTaskWoken ); u32 (*rtw_timerResetFromISR)( _timerHandle xTimer, osdepBASE_TYPE *pxHigherPriorityTaskWoken ); u32 (*rtw_timerChangePeriodFromISR)( _timerHandle xTimer, osdepTickType xNewPeriod, osdepBASE_TYPE *pxHigherPriorityTaskWoken ); u32 (*rtw_timerReset)( _timerHandle xTimer, osdepTickType xBlockTime ); void (*rtw_acquire_wakelock)(void); void (*rtw_release_wakelock)(void); void (*rtw_wakelock_timeout)(u32 timeoutMs); u8 (*rtw_get_scheduler_state)(void); }; /*\@}*/ #endif //#ifndef __OSDEP_SERVICE_H_ //----------------------------------------------------------------------------//