//----------------------------------------------------------------------------//
/**
******************************************************************************
* @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 <stdio.h>
#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, u32 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_
//----------------------------------------------------------------------------//