line source
/****************************************************************************/
/* */
/* Name rvf_api.h */
/* */
/* Function this file contains rvf public definitions. */
/* */
/* Version 0.1 */
/* */
/* Date Modification */
/* ------------------------------------ */
/* 3/12/99 Create */
/* 11/15/99 remove useless functions, */
/* change tasks priority and time_slicing */
/* 11/15/1999 compliant to RV coding guidelines */
/* 12/23/1999 change buffer management, add memory bank handling */
/* */
/* Author David Lamy-Charrier (dlamy@tif.ti.com) */
/* */
/* (C) Copyright 1999 by Texas Instruments Incorporated, All Rights Reserved*/
/****************************************************************************/
#ifndef _RVF_API_H
#define _RVF_API_H
#include "rv/general.h"
#include "rv/rv_general.h"
#include "rvf/rvf_target.h"
#ifndef _WINDOWS
#include "config/swconfig.cfg"
#endif
#ifdef __cplusplus
extern "C" {
#endif
/* macros used to trace messages */
// WCP patch: default config is no RV trace for WCP
#if (OP_WCP == 0)
#define DEBUG_ENABLE 1
#endif
#ifndef DEBUG_ENABLE
#define rvf_send_trace
#else
void rvf_send_trace1(char * msg, UINT8 msg_length, UINT32 val, UINT8 trace_level, UINT32 swe_use_id);
#define rvf_send_trace rvf_send_trace1
#endif
#define T_RVF_GD_ID UINT8
/* return parameters definition */
typedef T_RV_RET T_RVF_RET;
#define RVF_OK RV_OK
#define RVF_NOT_SUPPORTED RV_NOT_SUPPORTED
#define RVF_NOT_READY RV_NOT_READY
#define RVF_MEMORY_ERR RV_MEMORY_ERR
#define RVF_INTERNAL_ERR RV_INTERNAL_ERR
#define RVF_INVALID_PARAMETER RV_INVALID_PARAMETER
/* memeory bank state definition */
typedef enum{
RVF_GREEN,
RVF_YELLOW,
RVF_RED
}T_RVF_MB_STATUS;
/* task state */
typedef enum { SUSPEND, RUNNING} T_RVF_TASK_STATE;
/************************************************************************
** Mailbox definitions. Each task has 4 mailboxes that are used to
** send buffers to the task.
*/
#define RVF_TASK_MBOX_0 0
#define RVF_TASK_MBOX_1 1
#define RVF_TASK_MBOX_2 2
#define RVF_TASK_MBOX_3 3
#define RVF_NUM_TASK_MBOX 4
#define RVF_TASK_MBOX_0_EVT_MASK 0x0001
#define RVF_TASK_MBOX_1_EVT_MASK 0x0002
#define RVF_TASK_MBOX_2_EVT_MASK 0x0004
#define RVF_TASK_MBOX_3_EVT_MASK 0x0008
/************************************************************************
** Event definitions.
**
** There are 4 reserved events used to signal messages rcvd in task mailboxes.
** There are 4 reserved events used to signal timeout events.
** There are 8 general purpose events available for applications.
*/
#define RVF_MAX_EVENTS 16
#define RVF_NUM_TASK_TIMERS 4
#define RVF_TIMER_0 0
#define RVF_TIMER_1 1
#define RVF_TIMER_2 2
#define RVF_TIMER_3 3
#define RVF_TIMER_0_EVT_MASK 0x0010
#define RVF_TIMER_1_EVT_MASK 0x0020
#define RVF_TIMER_2_EVT_MASK 0x0040
#define RVF_TIMER_3_EVT_MASK 0x0080
#define RVF_APPL_EVT_0 8
#define RVF_APPL_EVT_1 9
#define RVF_APPL_EVT_2 10
#define RVF_APPL_EVT_3 11
#define RVF_APPL_EVT_4 12
#define RVF_APPL_EVT_5 13
#define RVF_APPL_EVT_6 14
#define RVF_APPL_EVT_7 15
#define EVENT_MASK(evt) ((UINT16)0x0001 << evt)
#define MAX_HOSTING_TASKS 10
#define MAX_PARASITES 10
/* define memory bank related types */
typedef UINT16 T_RVF_MB_ID;
//typedef UINT8 T_RVF_MB_NAME[RVF_MAX_MB_LEN];
typedef char T_RVF_MB_NAME[RVF_MAX_MB_LEN];
#define T_RVF_BUFFER void
typedef void (*CALLBACK_FUNC)(void *);
typedef void (*MB_CALLBACK_FUNC)(T_RVF_MB_ID);
typedef struct{
UINT32 size;
UINT32 watermark;
} T_RVF_MB_PARAM;
/* Define a timer list entry
*/
typedef struct _tle
{
T_RV_HDR hdr;
struct _tle *p_next;
struct _tle *p_prev;
UINT32 ticks;
UINT16 event; /* event & param must be revised possibily */
UINT32 param; /* sub struct pointed to by p_data if required */
UINT32 t_init;
void* p_data;
} T_RVF_TIMER_LIST_ENT;
typedef T_RVF_TIMER_LIST_ENT* P_NODE;
/* Define a timer list queue ?? QUEUE or LIST ??
*/
typedef struct
{
T_RVF_TIMER_LIST_ENT *p_first;
T_RVF_TIMER_LIST_ENT *p_last;
UINT32 last_ticks;
UINT16 timerCnt;
} T_RVF_TIMER_LIST_Q;
/***********************************************************************
** This queue is a general purpose buffer queue, for application use.
*/
typedef struct
{ void *p_first;
void *p_last;
UINT16 count;
} T_RVF_BUFFER_Q;
#define RVF_IS_QUEUE_EMPTY(p_q) (p_q.count == 0)
/*******************************************************
* Message parameter of "handle_timer()"
********************************************************/
#define T_RVF_TIMER_ID UINT32
typedef struct {
T_RV_HDR hdr;
T_RVF_TIMER_ID tm_id;
UINT8 cont;
void* action;
} T_RVF_TMS_MSG;
/* define a mutex structure */
typedef struct
{ UINT32 words[11];
}T_RVF_MUTEX;
/***********************************************************************
** Define the basic message header that RVF expects on all inter-computer
** communications. Applications should use this in their own definitions
** and add on their own message contents.
*/
/*typedef struct {
UINT16 prim; // Message Type
UINT16 len; // Message Length (including header)
} msg_hdr_t;
typedef struct {
msg_hdr_t hdr;
UINT8 data[1];
} msg_type1;
*/
/* Task constants
*/
#ifndef TASKPTR
typedef void (*TASKPTR)(UINT32);
#endif
#define RVF_INVALID_TASK (0xFF)
#define RVF_INVALID_MB_ID (0xFFFF)
#define RVF_INVALID_MAILBOX (0xFF)
#define RVF_INVALID_ADDR_ID (0xFF)
/* Define the value that create pool will return if it fails
*/
/************************************************************************/
/* Function prototypes */
/* Task management*/
void rvf_init(void);
T_RVF_RET rvf_create_legacy_task (TASKPTR task_entry, UINT8 task_id, char *taskname, UINT8 *stack, UINT16 stacksize, UINT8 priority, UINT8 time_slicing, T_RVF_TASK_STATE is_suspend) ;
T_RVF_RET rvf_create_task (TASKPTR task_entry, T_RVF_G_ADDR_ID task_id, char *taskname, UINT8 *stack, UINT16 stacksize, UINT8 priority, UINT8 tcode, UINT8 time_slicing, T_RVF_TASK_STATE is_suspend);
T_RVF_RET rvf_resume_task( T_RVF_G_ADDR_ID taskid);
void rvf_exit_task(T_RVF_G_ADDR_ID vtask);
T_RVF_RET rvf_suspend_task(T_RVF_G_ADDR_ID vtask);
T_RVF_G_ADDR_ID rvf_get_taskid(void);
char * rvf_get_taskname(void);
T_RVF_G_ADDR_ID rvf_get_context();
/* Message Handling */
typedef T_RV_HDR T_RVF_MSG ;
typedef UINT32 T_RVF_MSG_ID;
T_RVF_RET rvf_send_msg (T_RVF_G_ADDR_ID addr_id, void * p_msg);
T_RVF_MB_STATUS rvf_get_msg_buf (T_RVF_MB_ID mb_id,
UINT32 message_size,
T_RVF_MSG_ID msg_id,
T_RVF_MSG ** pp_msg);
T_RVF_RET rvf_free_msg (T_RVF_MSG * p_msg);
T_RVF_RET rvf_free_timer_msg (T_RVF_MSG *p_msg);
/* To send buffers and events between tasks*/
void * rvf_read_mbox (UINT8 mbox);
void * rvf_read_addr_mbox (T_RVF_G_ADDR_ID task_id, UINT8 mbox);
UINT8 rvf_send_event (T_RVF_G_ADDR_ID task_id, UINT16 event);
/* task synchronization */
T_RVF_RET rvf_initialize_mutex( T_RVF_MUTEX * mutex);
T_RVF_RET rvf_lock_mutex( T_RVF_MUTEX * mutex);
T_RVF_RET rvf_unlock_mutex( T_RVF_MUTEX * mutex);
T_RVF_RET rvf_delete_mutex( T_RVF_MUTEX * mutex);
/* To manage memory */
T_RVF_RET rvf_create_mb(T_RVF_MB_NAME mb_name, T_RVF_MB_PARAM mb_param, T_RVF_MB_ID *mb_id);
T_RVF_RET rvf_delete_mb(T_RVF_MB_NAME mb_name);
T_RVF_RET rvf_get_mb_id(T_RVF_MB_NAME mb_name, T_RVF_MB_ID *mb_id);
T_RVF_MB_STATUS rvf_get_mb_status(T_RVF_MB_ID mb_id);
T_RVF_RET rvf_mb_is_used(T_RVF_MB_NAME mb_name, UINT8* isUsed) ;
T_RVF_MB_STATUS rvf_get_buf(T_RVF_MB_ID mb_id, UINT32 buffer_size, T_RVF_BUFFER** p_buffer);
T_RVF_MB_STATUS rvf_count_buf(T_RVF_MB_ID mb_id, T_RVF_BUFFER * p_buffer);
T_RVF_RET rvf_free_buf( T_RVF_BUFFER * p_buffer);
T_RVF_RET rvf_set_callback_func(T_RVF_MB_ID mb_id, MB_CALLBACK_FUNC func);
T_RVF_RET rvf_change_callback_func(T_RVF_MB_ID mb_id, MB_CALLBACK_FUNC func);
void rvf_get_protected_buf(T_RVF_MB_ID mb_id, UINT32 buffer_size, T_RVF_BUFFER** p_buffer);
UINT32 rvf_get_buf_size (void *bptr);
/* get the parameters of a specific memory bank */
T_RVF_RET rvf_get_mb_param( T_RVF_MB_NAME mb_name, T_RVF_MB_PARAM * param);
/* change the parameters of a specific memory bank */
T_RVF_RET rvf_set_mb_param( T_RVF_MB_NAME mb_name, T_RVF_MB_PARAM * param);
/* User buffer queue management*/
T_RVF_RET rvf_enqueue (T_RVF_BUFFER_Q *p_q, void *p_buf);
T_RVF_RET rvf_enqueue_head (T_RVF_BUFFER_Q *p_q, void *p_buf);
void * rvf_dequeue (T_RVF_BUFFER_Q *p_q);
T_RVF_BUFFER * rvf_scan_next (T_RVF_BUFFER_Q * p_q, T_RVF_BUFFER * p_buf);
T_RVF_RET rvf_remove_from_queue (T_RVF_BUFFER_Q * p_q, T_RVF_BUFFER * p_buf);
/* Timer management*/
UINT16 rvf_wait(UINT16 flag, UINT32 ticks);
UINT16 rvf_evt_wait(T_RVF_G_ADDR_ID rtask, UINT16 flag, UINT32 timeout) ;
void rvf_delay(UINT32 ticks);
void rvf_start_timer(UINT8 tnum, UINT32 ticks, BOOLEAN is_continuous);
void rvf_stop_timer (UINT8 tnum);
char * rvf_get_time_stamp(char *tbuf);
UINT32 rvf_get_tick_count(void);
void rvf_init_timer_list (T_RVF_TIMER_LIST_Q *p_timer_listq);
void rvf_init_timer_list_entry (T_RVF_TIMER_LIST_ENT *p_tle);
UINT16 rvf_update_timer_list (T_RVF_TIMER_LIST_Q *p_timer_listq);
void rvf_add_to_timer_list (T_RVF_TIMER_LIST_Q *p_timer_listq, T_RVF_TIMER_LIST_ENT *p_tle);
void rvf_remove_from_timer_list (T_RVF_TIMER_LIST_Q *p_timer_listq, T_RVF_TIMER_LIST_ENT *p_tle);
T_RVF_TIMER_LIST_ENT* rvf_get_expired_entry (T_RVF_TIMER_LIST_Q *p_timer_listq);
#define T_RV_TM_ID UINT32
/*************************************************************************/
/* :) USER FRIENDLY TIMER MANAGEMENT API consisting of add, delete and modify timer */
/*************************************************************************/
/* Returns 0 on failure */
T_RVF_TIMER_ID rvf_create_timer( T_RVF_G_ADDR_ID g_addrId,
UINT32 timerDuration,
BOOLEAN isContinuous,
void* p_action);
void rvf_del_timer ( T_RV_TM_ID tm_id) ;
void rvf_reset_timer ( T_RV_TM_ID tm_id, UINT32 new_duration,
BOOLEAN isContinuous);
/* Disable Interrupts, Enable Interrupts*/
void rvf_enable(void);
void rvf_disable(UINT8 who);
/* Trace for debug purposes*/
void rvf_dump_mem();
void rvf_dump_tasks();
void rvf_dump_pool();
/* specific function */
T_RVF_BUFFER * rvf_wait_for_specific_msg(UINT16 msg_code, UINT8 mbox, UINT32 timeout);
/* Trace definitions */
#define NULL_PARAM 4294967295 /* this value will not be displayed in rvf_send_trace function */
#define TRACE_MB_ID (RVF_MAX_REAL_MB -1)
#ifdef __cplusplus
}
#endif
#endif /* _RVF_API_H */