FreeCalypso > hg > fc-magnetite
view src/gpf3/frame/vsi_com.c @ 493:2e73bbc0648e
OSL: os_mem_fl.c compiles
author | Mychaela Falconia <falcon@freecalypso.org> |
---|---|
date | Sun, 24 Jun 2018 18:59:22 +0000 |
parents | c41a534f33c6 |
children |
line wrap: on
line source
/* +------------------------------------------------------------------------------ | File: vsi_com.c +------------------------------------------------------------------------------ | Copyright 2002 Texas Instruments Berlin, AG | All rights reserved. | | This file is confidential and a trade secret of Texas | Instruments Berlin, AG | The receipt of or possession of this file does not convey | any rights to reproduce or disclose its contents or to | manufacture, use, or sell anything it may describe, in | whole, or in part, without the specific written consent of | Texas Instruments Berlin, AG. +----------------------------------------------------------------------------- | Purpose : This Module defines the virtual system interface part | about communication via primitives and signals. +----------------------------------------------------------------------------- */ #undef TEST_PCHECK #ifndef __VSI_COM_C__ #define __VSI_COM_C__ #endif /*==== INCLUDES ===================================================*/ #include "typedefs.h" #include "string.h" #include "os.h" #include "vsi.h" #include "frame.h" #include "vsi.h" #include "frm_defs.h" #include "frm_types.h" #include "frm_glob.h" #include "route.h" #ifdef MEMORY_SUPERVISION #include "tools.h" #endif #ifdef _TOOLS_ #include "stdlib.h" #endif /*==== CONSTANTS ==================================================*/ #ifndef RUN_INT_RAM char const *waited_queue_str= "Waited for space in queue"; char const *freed_sent_str = "Freed partition sent"; char const *disc_str = "Signal discarded"; char const *freed_str = "Partition already freed"; char const *trunc_str = "Allocation request truncated"; char const *guard_str = "Partition guard pattern destroyed"; char const *unknown_str = "unknown"; #else extern char const *waited_queue_str; extern char const *freed_sent_str; extern char const *disc_str; extern char const *freed_str; extern char const *trunc_str; extern char const *guard_str; extern char const *unknown_str; #endif #if !defined _TARGET_ && !defined _TOOLS_ char const *pcheck_str = "pcon_check() returned error"; #define PCHECK_INITIALIZED 0xaffedead #endif #define MAX_DRP_BOUND 12 /*==== TYPES ======================================================*/ #if !defined _TARGET_ && !defined _TOOLS_ typedef struct { unsigned int magic_nr; ULONG ret_ok; ULONG (*pcheck)(ULONG opc, void * decoded_prim); } T_PCHECK; #endif /*==== EXTERNALS ==================================================*/ /* -------------- S H A R E D - BEGIN ---------------- */ #ifdef _TOOLS_ #pragma data_seg("FRAME_SHARED") #endif #ifdef _TOOLS_ extern char FRM_TST_NAME[]; __declspec (dllimport) T_HANDLE TST_Handle; #else extern T_HANDLE TST_Handle; #endif extern T_HANDLE vsi_m_sem_handle; extern char TaskName []; //extern OS_HANDLE ext_data_pool_handle; #if defined _NUCLEUS_ && defined NU_DEBUG extern char check_desclist; #endif /*==== VARIABLES ==================================================*/ #if !defined _TARGET_ && !defined _TOOLS_ T_PCHECK pcheck_func; #endif /* _TARGET_ */ #ifndef RUN_INT_RAM char QueueName [ RESOURCE_NAMELEN ]; //char *pf_com_matrix = NULL; #else extern char QueueName []; #endif #ifdef _TOOLS_ #pragma data_seg() #endif /* -------------- S H A R E D - END ---------------- */ /*==== PROTOTYPES =================================================*/ #if !defined _TARGET_ && !defined _TOOLS_ #ifdef TEST_PCHECK ULONG test_pcheck ( ULONG opc, void * decoded_prim ); #endif #endif /* _TARGET_ */ #if defined _NUCLEUS_ && defined NU_DEBUG int check_descriptor_list ( T_HANDLE caller, T_PRIM_HEADER *prim FILE_LINE_TYPE ); #endif int int_vsi_c_pattach (T_VOID_STRUCT *prim FILE_LINE_TYPE); /*==== FUNCTIONS ==================================================*/ #if 0 not needed -> temporarily removed #ifndef RUN_INT_RAM /* +--------------------------------------------------------------------+ | PROJECT : GSM-Frame (8415) MODULE : VSI_COM | | STATE : code ROUTINE : vsi_c_open | +--------------------------------------------------------------------+ PURPOSE : get the handle of a queue */ char * vsi_c_init_com_matrix ( int max_entities ) { int size; size = (max_entities+1)*(max_entities+1); if ( os_AllocateMemory ( NO_TASK, (T_VOID_STRUCT**)&pf_com_matrix, size, OS_NO_SUSPEND, ext_data_pool_handle ) != OS_OK ) { vsi_o_assert ( NO_TASK, OS_SYST_ERR_NO_MEMORY, __FILE__, __LINE__, "No memory available for com matrix"); } return pf_com_matrix; } #endif #ifndef RUN_INT_RAM /* +--------------------------------------------------------------------------+ | PROJECT : GSM-Frame (8415) MODULE : VSI_COM | | STATE : code ROUTINE : vsi_c_get_com_matrix_entry| +--------------------------------------------------------------------------+ PURPOSE : get an entry of the com matrix */ int vsi_c_get_com_matrix_entry ( int entry, char *dst ) { T_HANDLE snd, rcv; static int cnt; int size_of_matrix = (MaxEntities+1)*(MaxEntities+1); int snd_len; if ( entry == FIRST_ENTRY ) { cnt = 0; } while ( cnt <= size_of_matrix ) { if ( pf_com_matrix[cnt] != 0 ) { snd = cnt/(MaxEntities+1); vsi_e_name (NO_TASK, snd, &dst[0]); snd_len = strlen(&dst[0]); dst[snd_len]=' '; rcv = cnt%(MaxEntities+1); vsi_e_name (NO_TASK, rcv, &dst[snd_len+1]); cnt++; return VSI_OK; } cnt++; } return VSI_ERROR; } #endif #ifndef RUN_INT_RAM /* +--------------------------------------------------------------------------+ | PROJECT : GSM-Frame (8415) MODULE : VSI_COM | | STATE : code ROUTINE : vsi_c_get_entity_com_entry| +--------------------------------------------------------------------------+ PURPOSE : get a entity handle the is used by an entity to send primitives */ int vsi_c_get_entity_com_entry ( int entry, T_HANDLE rcv, T_HANDLE *snd ) { static int cnt; int size_of_matrix = (MaxEntities+1)*(MaxEntities+1); if ( entry == FIRST_ENTRY ) { cnt = rcv; } while ( cnt <= size_of_matrix ) { if ( pf_com_matrix[cnt] != 0 ) { *snd = cnt / (MaxEntities + 1); cnt = cnt + MaxEntities + 1; return VSI_OK; } cnt = cnt + MaxEntities + 1; } return VSI_ERROR; } #endif #endif #ifndef RUN_INT_RAM /* +--------------------------------------------------------------------+ | PROJECT : GSM-Frame (8415) MODULE : VSI_COM | | STATE : code ROUTINE : vsi_c_open | +--------------------------------------------------------------------+ PURPOSE : get the handle of a queue */ T_HANDLE vsi_c_open (T_HANDLE Caller, char *Name) { #ifdef _TOOLS_ OS_HANDLE ComHandle; if ( os_OpenQueue ( Caller, Name, &ComHandle ) != OS_ERROR ) return ComHandle; #else T_HANDLE e_handle; for ( e_handle = MaxEntities; e_handle > 0; e_handle-- ) { if ( pf_TaskTable[e_handle].Name[0] != 0 && pf_TaskTable[e_handle].QueueHandle != 0 && !strncmp (pf_TaskTable[e_handle].Name, Name, RESOURCE_NAMELEN-1) ) { /* not needed -> temporarily removed pf_com_matrix[Caller*(MaxEntities+1)+e_handle] = 1; */ return e_handle; } } #endif return VSI_ERROR; } #endif #ifndef RUN_INT_RAM /* +--------------------------------------------------------------------+ | PROJECT : GSM-Frame (8415) MODULE : VSI_COM | | STATE : code ROUTINE : vsi_c_close | +--------------------------------------------------------------------+ PURPOSE : return the handle of a queue */ int vsi_c_close (T_HANDLE Caller, T_HANDLE ComHandle) { if ( os_CloseQueue ( Caller, ComHandle ) != OS_ERROR ) return VSI_OK; return VSI_ERROR; } #endif #ifndef RUN_INT_RAM /* +--------------------------------------------------------------------+ | PROJECT : GSM-Frame (8415) MODULE : VSI_COM | | STATE : code ROUTINE : vsi_c_clear | +--------------------------------------------------------------------+ PURPOSE : read all messages from a queue */ int vsi_c_clear (T_HANDLE Caller, T_HANDLE ComHandle) { OS_QDATA Msg; while ( os_ReceiveFromQueue ( NO_TASK, ComHandle, &Msg, OS_NO_SUSPEND ) == OS_OK ) { ; } return VSI_OK; } #endif #ifndef RUN_FLASH /* +--------------------------------------------------------------------+ | PROJECT : GSM-Frame (8415) MODULE : VSI_COM | | STATE : code ROUTINE : vsi_c_send | +--------------------------------------------------------------------+ PURPOSE : write a message to a queue */ int vsi_c_send (T_HANDLE Caller, T_HANDLE ComHandle, T_QMSG *Msg FILE_LINE_TYPE) { OS_QDATA OS_Msg = { 0 }; LONG Status; USHORT Prio; #ifdef NU_DEBUG T_PRIM_HEADER *prim; #ifdef _TARGET_ T_HANDLE t_handle; #endif #endif OS_Msg.data16 = Msg->MsgType; OS_Msg.e_id = ComHandle; switch ( Msg->MsgType ) { case MSG_PRIMITIVE: OS_Msg.ptr = Msg->Msg.Primitive.Prim; OS_Msg.data32 = P_OPC(Msg->Msg.Primitive.Prim); #ifdef _TOOLS_ OS_Msg.len = Msg->Msg.Primitive.PrimLen; #endif os_GetTime ( 0, &OS_Msg.time ); Prio = MSG_PRIMITIVE_PRIO; break; case MSG_SIGNAL: OS_Msg.ptr = Msg->Msg.Signal.SigBuffer; OS_Msg.data32 = Msg->Msg.Signal.SigOPC; #ifdef _TOOLS_ OS_Msg.len = Msg->Msg.Signal.SigLen; #endif os_GetTime ( 0, &OS_Msg.time ); Prio = MSG_SIGNAL_PRIO; break; default: return VSI_ERROR; /*lint -e527 suppress Warning -- Unreachable */ break; /*lint +e527 */ } #ifdef _NUCLEUS_ #ifdef NU_DEBUG /* PARTITION GUARD PATTERN CHECK */ if ( Msg->MsgType == MSG_PRIMITIVE ) { prim = (T_PRIM_HEADER*)Msg->Msg.Primitive.Prim; if ( (Status = os_PartitionCheck ( (T_VOID_STRUCT*)prim )) == OS_OK ) { if ( check_desclist == TRUE && prim->dph_offset != 0 ) { check_descriptor_list ( Caller, prim FILE_LINE ); } } else { switch ( Status ) { case OS_PARTITION_FREE: vsi_o_assert ( Caller, OS_SYST_ERR FILE_LINE_MACRO_PASSED, "%s (PSEND),entity %s, partition 0x%x, opc 0x%x", freed_sent_str, pf_TaskTable[Caller].Name, prim, prim->opc ); break; case OS_PARTITION_GUARD_PATTERN_DESTROYED: vsi_o_assert ( Caller, OS_SYST_ERR_PCB_PATTERN FILE_LINE_MACRO_PASSED, "%s (PSEND), entity %s, partition 0x%x, opc 0x%x", guard_str, pf_TaskTable[Caller].Name, prim, prim->opc ); break; default: break; } } #ifdef MEMORY_SUPERVISION vsi_ppm_send ( Caller, ComHandle, (T_PRIM_HEADER*)Msg->Msg.Primitive.Prim, file, line ); #endif /* MEMORY_SUPERVISION */ } #ifdef _TARGET_ if ( (t_handle = os_MyHandle()) != 0 ) { int opc; switch ( os_CheckTaskStack ( t_handle ) ) { case OS_ERROR: if ( Msg->MsgType == MSG_PRIMITIVE ) { opc = ((T_PRIM_HEADER*)Msg->Msg.Primitive.Prim)->opc; } else { opc = Msg->Msg.Signal.SigOPC; } vsi_o_assert ( Caller, OS_SYST_ERR_STACK_OVERFLOW FILE_LINE_MACRO_PASSED, "%s Stack overflow, 0x%x", pf_TaskTable[Caller].Name, opc ); break; default: break; } } #endif /* _TARGET_ */ #endif /* NU_DEBUG */ #endif /* _NUCLEUS_ */ Status = rt_Route ( Caller, ComHandle, Prio, OS_SUSPEND, &OS_Msg ); switch ( Status ) { case OS_WAITED: #ifdef NU_DEBUG pf_handle_warning ( OS_SYST_WRN_WAIT_QUEUE, "%s %s, entity %s, queue %s, %s(%d)", syst_wrn, waited_queue_str, pf_TaskTable[Caller].Name, pf_TaskTable[ComHandle].Name FILE_LINE_MACRO_PASSED ); #endif return VSI_OK; /*lint -e527 suppress Warning -- Unreachable */ break; /*lint +e527 */ case OS_TIMEOUT: case OS_ERROR: case OS_INVALID_QUEUE: Caller = e_running[os_MyHandle()]; if ( Msg->MsgType == MSG_SIGNAL ) { #ifdef NU_DEBUG pf_handle_warning ( OS_SYST_WRN_WAIT_QUEUE, "%s %s from %s to %s, opc 0x%x, %s(%d)", syst_wrn, disc_str, pf_TaskTable[Caller].Name, pf_TaskTable[ComHandle].Name, Msg->Msg.Signal.SigOPC FILE_LINE_MACRO_PASSED ); #endif return VSI_OK; } else { char const *p_queue_name; if ( Status == OS_INVALID_QUEUE ) { p_queue_name = unknown_str; } else { #ifdef _TOOLS_ os_GetQueueName ( Caller, ComHandle, QueueName ); p_queue_name = QueueName; #else p_queue_name = pf_TaskTable[ComHandle].Name; #endif } vsi_o_assert ( Caller, OS_SYST_ERR_QUEUE_FULL FILE_LINE_MACRO_PASSED, "%s write attempt to %s queue failed", pf_TaskTable[Caller].Name, p_queue_name ); #ifdef MEMORY_SUPERVISION vsi_ppm_free ( Caller, (T_PRIM_HEADER*)(OS_Msg.ptr-PPM_OFFSET), file, line); #endif os_DeallocatePartition (Caller, OS_Msg.ptr-PPM_OFFSET ); return VSI_ERROR; } /*lint -e527 suppress Warning -- Unreachable */ break; /*lint +e527 */ case OS_OK: return VSI_OK; /*lint -e527 suppress Warning -- Unreachable */ break; /*lint +e527 */ default: return VSI_ERROR; /*lint -e527 suppress Warning -- Unreachable */ break; /*lint +e527 */ } } #endif #ifndef RUN_FLASH /* +--------------------------------------------------------------------+ | PROJECT : GSM-Frame (8415) MODULE : VSI_COM | | STATE : code ROUTINE : vsi_c_psend | +--------------------------------------------------------------------+ PURPOSE : wrapper for vsi_c_send to avoid code wasting macro */ int vsi_c_psend_caller ( T_HANDLE Caller, T_HANDLE ComHandle, T_VOID_STRUCT *ptr FILE_LINE_TYPE ) { T_QMSG QMsg; T_VOID_STRUCT *snd_ptr = (T_VOID_STRUCT*)D2P(ptr); QMsg.Msg.Primitive.Prim = snd_ptr; #ifdef _TOOLS_ if ( ((T_PRIM_HEADER*)snd_ptr)->sh_offset != 0 ) QMsg.Msg.Primitive.PrimLen = ALIGN(PSIZE(ptr)) + sizeof(T_S_HEADER); else #endif QMsg.Msg.Primitive.PrimLen = PSIZE(ptr); QMsg.MsgType = MSG_PRIMITIVE; if ( Caller != TST_Handle && !(P_OPC(QMsg.Msg.Primitive.Prim) & SYS_MASK ) ) vsi_o_ptrace (Caller, P_OPC(QMsg.Msg.Primitive.Prim), 1); #if !defined _TARGET_ && !defined _TOOLS_ if ( (pcheck_active[Caller] == 1) && (pcheck_func.pcheck != NULL) ) { ULONG ret; if ( (ret = pcheck_func.pcheck ( D_OPC(ptr), ptr )) != pcheck_func.ret_ok ) { pf_handle_warning ( OS_SYST_WRN, "%s %s %d in %s, opc 0x%x, %s(%d)", syst_wrn, pcheck_str, ret, pf_TaskTable[Caller].Name, D_OPC(ptr) FILE_LINE_MACRO_PASSED ); } } #endif return ( vsi_c_send ( Caller, ComHandle, &QMsg FILE_LINE) ); } #endif #ifndef RUN_FLASH /* +--------------------------------------------------------------------+ | PROJECT : GSM-Frame (8415) MODULE : VSI_COM | | STATE : code ROUTINE : vsi_c_psend | +--------------------------------------------------------------------+ PURPOSE : wrapper for vsi_c_send to avoid code wasting macro */ int vsi_c_psend ( T_HANDLE ComHandle, T_VOID_STRUCT *ptr FILE_LINE_TYPE ) { T_HANDLE Caller; Caller = e_running[os_MyHandle()]; return ( vsi_c_psend_caller ( Caller, ComHandle, ptr FILE_LINE) ); } #endif #ifndef RUN_FLASH /* +--------------------------------------------------------------------+ | PROJECT : GSM-Frame (8415) MODULE : VSI_COM | | STATE : code ROUTINE : vsi_c_ssend | +--------------------------------------------------------------------+ PURPOSE : wrapper for vsi_c_send to avoid code wasting macro */ int vsi_c_ssend ( T_HANDLE ComHandle, ULONG opc, T_VOID_STRUCT *ptr, ULONG MsgLen FILE_LINE_TYPE ) { T_QMSG QMsg; T_HANDLE Caller; Caller = e_running[os_MyHandle()]; QMsg.Msg.Signal.SigBuffer = (T_VOID_STRUCT*)ptr; QMsg.Msg.Signal.SigOPC = opc; QMsg.Msg.Signal.SigLen = MsgLen; QMsg.MsgType = MSG_SIGNAL; return ( vsi_c_send ( Caller, ComHandle, &QMsg FILE_LINE ) ); } #endif #ifndef RUN_FLASH /* +--------------------------------------------------------------------+ | PROJECT : GSM-Frame (8415) MODULE : VSI_COM | | STATE : code ROUTINE : vsi_c_new | +--------------------------------------------------------------------+ PURPOSE : allocate a partition to send a primitive */ T_VOID_STRUCT * vsi_c_new (T_HANDLE Caller, ULONG Size, ULONG opc FILE_LINE_TYPE) { T_VOID_STRUCT *prim; ULONG flags; /* VSI_MEM_NON_BLOCKING not set, blocking allocation for backwards compatibility */ flags = PrimGroupHandle; prim = (T_VOID_STRUCT*)D2P(vsi_c_pnew_generic (Caller, Size, opc, flags FILE_LINE)); return prim; } #endif #ifndef RUN_FLASH /* +--------------------------------------------------------------------+ | PROJECT : GSM-Frame (8415) MODULE : VSI_COM | | STATE : code ROUTINE : vsi_c_new | +--------------------------------------------------------------------+ PURPOSE : allocate a partition to send a primitive */ T_VOID_STRUCT * vsi_c_pnew_generic (T_HANDLE Caller, ULONG Size, ULONG opc, ULONG flags FILE_LINE_TYPE) { T_VOID_STRUCT *prim; if ( Size < sizeof(T_PRIM_HEADER) ) Size = sizeof(T_PRIM_HEADER); if ( (prim = vsi_m_new ( Size, flags FILE_LINE )) != NULL ) { P_OPC(prim) = opc; P_LEN(prim) = Size; P_SDU(prim) = NULL; P_CNT(prim) = 1; P_SHO(prim) = 0; P_DPHO(prim) = 0; #ifdef MEMORY_SUPERVISION Caller = e_running[os_MyHandle()]; vsi_ppm_new ( Caller, Size, (T_PRIM_HEADER*)prim, file, line ); #endif #ifndef _TOOLS_ if (opc & MEMHANDLE_OPC) { P_MEMHANDLE_SDU(prim)=0x00000000; } #endif return (T_VOID_STRUCT*)P2D(prim); } return NULL; } #endif #ifndef RUN_FLASH /* +--------------------------------------------------------------------+ | PROJECT : GSM-Frame (8415) MODULE : VSI_COM | | STATE : code ROUTINE : vsi_c_pnew | +--------------------------------------------------------------------+ PURPOSE : allocate a partition to send a primitive */ T_VOID_STRUCT * vsi_c_pnew (ULONG Size, ULONG opc FILE_LINE_TYPE) { T_HANDLE Caller; Caller = 0; Size += sizeof(T_PRIM_HEADER); return ( (T_VOID_STRUCT*)vsi_c_pnew_generic ( Caller, Size, opc, PrimGroupHandle FILE_LINE )); } #endif #ifndef RUN_FLASH /* +--------------------------------------------------------------------+ | PROJECT : GSM-Frame (8415) MODULE : VSI_COM | | STATE : code ROUTINE : vsi_c_pnew | +--------------------------------------------------------------------+ PURPOSE : allocate a partition to send a primitive */ T_VOID_STRUCT * vsi_c_pnew_nb (ULONG Size, ULONG opc FILE_LINE_TYPE) { T_HANDLE Caller; Caller = 0; Size += sizeof(T_PRIM_HEADER); return ( (T_VOID_STRUCT*)vsi_c_pnew_generic ( Caller, Size, opc, VSI_MEM_NON_BLOCKING|PrimGroupHandle FILE_LINE )); } #endif #ifndef RUN_FLASH /* +---------------------------------------------------------------------+ | PROJECT : GSM-Frame (8415) MODULE : VSI_COM | | STATE : code ROUTINE : vsi_c_new_sdu_generic| +---------------------------------------------------------------------+ PURPOSE : allow pool selection and flags for blocking bahavior */ T_VOID_STRUCT * vsi_c_new_sdu_generic (ULONG Size, ULONG opc, USHORT sdu_len, USHORT sdu_offset, USHORT encode_offset, ULONG flags FILE_LINE_TYPE ) { T_PRIM_HEADER *prim; ULONG alloc_size; T_HANDLE Caller; Caller = 0; alloc_size = Size + sizeof(T_PRIM_HEADER) + BYTELEN((SHORT)sdu_len + (SHORT)encode_offset); if ( (prim = (T_PRIM_HEADER*)vsi_c_pnew_generic (Caller, alloc_size, opc, flags FILE_LINE)) != NULL ) { D_SDU(prim) = (T_sdu*)(((char*)prim) + sdu_offset); D_SDU_LEN(prim) = sdu_len; D_SDU_OFF(prim) = encode_offset; return ( (T_VOID_STRUCT*)prim ); } else { return NULL; } } #endif #ifndef RUN_FLASH /* +--------------------------------------------------------------------+ | PROJECT : GSM-Frame (8415) MODULE : VSI_COM | | STATE : code ROUTINE : vsi_c_new_sdu | +--------------------------------------------------------------------+ PURPOSE : wrapper for vsi_c_new to avoid code wasting macro */ T_VOID_STRUCT * vsi_c_new_sdu (ULONG Size, ULONG opc, USHORT sdu_len, USHORT sdu_offset, USHORT encode_offset FILE_LINE_TYPE ) { ULONG flags; flags = PrimGroupHandle; return vsi_c_new_sdu_generic (Size, opc, sdu_len, sdu_offset, encode_offset, flags FILE_LINE); } #endif #ifndef RUN_INT_RAM /* +--------------------------------------------------------------------+ | PROJECT : GSM-Frame (8415) MODULE : VSI_COM | | STATE : code ROUTINE : vsi_c_ppass | +--------------------------------------------------------------------+ PURPOSE : pass a partition from one primitive to another */ T_VOID_STRUCT * vsi_c_ppass (T_VOID_STRUCT *prim, ULONG opc FILE_LINE_TYPE ) { T_VOID_STRUCT *ptr; ULONG len; T_HANDLE Caller; Caller = e_running[os_MyHandle()]; if ( D_CNT(prim) > 1 ) { /* * This does not work for dynamic primitive containing pointers, PDUP needed !!!! * The sdu pointer is currently not set correctly because it is never used !!! */ len = D_LEN(prim); ptr = vsi_c_pnew ( len, opc FILE_LINE ); memcpy ( ptr, prim, len - sizeof(T_PRIM_HEADER) ); #ifdef PRIM_AUTO_FREE if ( !(pf_TaskTable[Caller].Flags & PARTITION_AUTO_FREE) ) #endif vsi_c_pfree ( &prim FILE_LINE ); return ptr; } else { D_OPC(prim) = opc; #ifdef PRIM_AUTO_FREE if ( pf_TaskTable[Caller].Flags & PARTITION_AUTO_FREE ) { D_CNT(prim)++; } #endif #ifdef MEMORY_SUPERVISION vsi_ppm_reuse ( Caller, D2P(prim), file, line); #endif return prim; } } #endif #ifndef RUN_INT_RAM /* +--------------------------------------------------------------------+ | PROJECT : GSM-Frame (8415) MODULE : VSI_COM | | STATE : code ROUTINE : vsi_c_pstore | +--------------------------------------------------------------------+ PURPOSE : store a partition (increment the reference counter) consider PARTITION_AUTO_FREE */ void vsi_c_pstore ( T_VOID_STRUCT *prim FILE_LINE_TYPE ) { #ifdef PRIM_AUTO_FREE T_PRIM_HEADER *ptr; T_DP_HEADER *dp_hdr; T_HANDLE Caller; Caller = e_running[os_MyHandle()]; if ( pf_TaskTable[Caller].Flags & PARTITION_AUTO_FREE ) { ptr = D2P(prim); /* take control -> enable entity to free the prim */ processed_prim[Caller] = NULL; /* increment reference counter */ D_CNT(prim)++; #ifdef MEMORY_SUPERVISION vsi_ppm_store ( Caller, ptr, file, line ); #endif if ( P_DPHO(ptr) != 0 ) { dp_hdr = (T_DP_HEADER*)((ULONG*)ptr + ptr->dph_offset); dp_hdr = (T_DP_HEADER*)dp_hdr->next; while ( (ptr = (T_PRIM_HEADER*)dp_hdr) != NULL ) { #ifdef MEMORY_SUPERVISION vsi_ppm_store ( Caller, ptr, file, line ); #endif P_CNT(ptr)++; if ( dp_hdr->magic_nr != GUARD_PATTERN ) { vsi_o_assert ( Caller, OS_SYST_ERR FILE_LINE_MACRO_PASSED, "Magic number in dp_header destroyed (PSTORE) %s , opc: 0x%lx, partition 0x%lx", pf_TaskTable[Caller].Name, ptr->opc, ptr ); } dp_hdr = (T_DP_HEADER*)dp_hdr->next; } } } #endif /* PRIM_AUTO_FREE */ } #endif #ifndef RUN_INT_RAM /* +--------------------------------------------------------------------+ | PROJECT : GSM-Frame (8415) MODULE : VSI_COM | | STATE : code ROUTINE : vsi_c_pattach | +--------------------------------------------------------------------+ PURPOSE : call internal function to store a partition (increment the reference counter) */ int vsi_c_pattach ( T_VOID_STRUCT *prim FILE_LINE_TYPE ) { T_HANDLE Caller = 0; LONG sts; int ret; sts = os_ObtainSemaphore (Caller, vsi_m_sem_handle, OS_SUSPEND); if ( sts == OS_ERROR || sts == OS_TIMEOUT ) { /* Semaphore invalid or overrun */ Caller = e_running[os_MyHandle()]; vsi_o_assert ( NO_TASK, OS_SYST_ERR FILE_LINE_MACRO_PASSED, "Ref Cnt Semaphore overrun, entity %s", pf_TaskTable[Caller].Name ); } ret=int_vsi_c_pattach(prim FILE_LINE_MACRO); os_ReleaseSemaphore (Caller, vsi_m_sem_handle); return ret; } /* +--------------------------------------------------------------------+ | PROJECT : GSM-Frame (8415) MODULE : VSI_COM | | STATE : code ROUTINE : int_vsi_c_pattach | +--------------------------------------------------------------------+ PURPOSE : actually store a partition (increment the reference counter) */ int int_vsi_c_pattach ( T_VOID_STRUCT *prim FILE_LINE_TYPE) { T_PRIM_HEADER *ptr; T_DP_HEADER *dp_hdr; T_HANDLE Caller = 0; int pos; ptr = D2P(prim); #ifdef NU_DEBUG if ( os_is_valid_partition ((T_VOID_STRUCT*)ptr) ) { /* attach to non-partition memory */ Caller = e_running[os_MyHandle()]; vsi_o_assert ( NO_TASK, OS_SYST_ERR FILE_LINE_MACRO_PASSED, "PATTACH to non-partition memory, entity %s, ptr 0x%x", pf_TaskTable[Caller].Name, ptr ); } #endif if ( ptr->use_cnt <= 0 ) { /* attach to non allocated memory */ Caller = e_running[os_MyHandle()]; vsi_o_assert ( NO_TASK, OS_SYST_ERR FILE_LINE_MACRO_PASSED, "PATTACH to free memory, entity %s, ptr 0x%x", pf_TaskTable[Caller].Name, ptr ); } dp_hdr=NULL; /* check if we have a primitive pointer */ if ( ((T_DP_HEADER*)ptr)->magic_nr != GUARD_PATTERN ) { /* increment reference counter */ P_CNT(ptr)++; #ifdef MEMORY_SUPERVISION vsi_ppm_store ( Caller, ptr, file, line ); #endif /* look for dynamic partition header */ if ( P_DPHO(ptr) != 0 ) { dp_hdr = (T_DP_HEADER*)((ULONG*)ptr + ptr->dph_offset); if (dp_hdr->drp_bound_list) { /* call attach for bound root pointers */ pos=0; while(pos<MAX_DRP_BOUND && dp_hdr->drp_bound_list[pos]) { int_vsi_c_pattach(dp_hdr->drp_bound_list[pos] FILE_LINE_MACRO); pos++; } } dp_hdr = (T_DP_HEADER*)dp_hdr->next; } } else { dp_hdr=(T_DP_HEADER*)ptr; } if ( dp_hdr ) { if ( dp_hdr->magic_nr != GUARD_PATTERN ) { /* primitive with T_desc_list element, use MATTACH */ os_ReleaseSemaphore (Caller, vsi_m_sem_handle); return VSI_OK; } else { while ( (ptr = (T_PRIM_HEADER*)dp_hdr) != NULL ) { #ifdef MEMORY_SUPERVISION vsi_ppm_store ( Caller, ptr, file, line ); #endif P_CNT(ptr)++; if ( dp_hdr->magic_nr != GUARD_PATTERN ) { vsi_o_assert ( Caller, OS_SYST_ERR FILE_LINE_MACRO_PASSED, "Magic number in dp_header destroyed (PATTACH), %s, opc: 0x%lx, partition 0x%lx", pf_TaskTable[Caller].Name, ptr->opc, ptr ); } if (dp_hdr->drp_bound_list) { /* call attach for bound root pointers */ pos=0; while(pos<MAX_DRP_BOUND && dp_hdr->drp_bound_list[pos]) { int_vsi_c_pattach(dp_hdr->drp_bound_list[pos] FILE_LINE_MACRO); pos++; } } dp_hdr = (T_DP_HEADER*)dp_hdr->next; } } } return VSI_OK; } #endif #ifndef RUN_INT_RAM /* +--------------------------------------------------------------------+ | PROJECT : GSM-Frame (8415) MODULE : VSI_COM | | STATE : code ROUTINE : vsi_c_reuse | +--------------------------------------------------------------------+ PURPOSE : function to avoid code wasting macro */ T_VOID_STRUCT *vsi_c_reuse ( T_PRIM_HEADER *ptr, ULONG Size, ULONG opc, USHORT sdu_len, USHORT sdu_offset, USHORT encode_offset FILE_LINE_TYPE ) { T_HANDLE Caller; D_OPC(ptr) = opc; D_LEN(ptr) = Size; if ( sdu_offset != NO_SDU ) { D_SDU(ptr) = (T_sdu*)((char*)(ptr) + sdu_offset); D_SDU_LEN(ptr) = sdu_len; D_SDU_OFF(ptr) = encode_offset; } else D_SDU(ptr) = NULL; Caller = e_running[os_MyHandle()]; #ifdef MEMORY_SUPERVISION vsi_ppm_reuse ( Caller, D2P(ptr), file, line); #endif #ifdef PRIM_AUTO_FREE if ( pf_TaskTable[Caller].Flags & PARTITION_AUTO_FREE ) { D_CNT(ptr)++; } #endif return ( (T_VOID_STRUCT*)ptr ); } #endif #ifndef RUN_FLASH /* +--------------------------------------------------------------------+ | PROJECT : GSM-Frame (8415) MODULE : VSI_COM | | STATE : code ROUTINE : vsi_c_free | +--------------------------------------------------------------------+ PURPOSE : deallocate a partition that was used to send a primitive */ int vsi_c_free (T_HANDLE Caller, T_VOID_STRUCT **Msg FILE_LINE_TYPE) { static T_VOID_STRUCT *protected_prim_to_free = NULL; #if defined (NU_DEBUG) || defined (OSL_DEBUG) LONG count; #endif //LONG sts; #if 0 sts = os_ObtainSemaphore (Caller, vsi_m_sem_handle, OS_SUSPEND); if ( sts == OS_ERROR || sts == OS_TIMEOUT ) { /* Semaphore invalid or overrun */ if ( *Msg == protected_prim_to_free ) { /* fatal error only if semaphore overrun on same primitive */ Caller = e_running[os_MyHandle()]; vsi_o_assert ( NO_TASK, OS_SYST_ERR FILE_LINE_MACRO_PASSED, "Ref Cnt Semaphore overrun, entity %s", pf_TaskTable[Caller].Name ); return VSI_ERROR; } } else #endif { protected_prim_to_free = *Msg; } #if defined (NU_DEBUG) || defined (OSL_DEBUG) count = (LONG)((T_PRIM_HEADER*)*Msg)->use_cnt; if ( count <= 0 ) { pf_handle_warning ( OS_SYST_WRN_MULTIPLE_FREE, "%s %s in %s, 0x%x, %s(%d)", syst_wrn, freed_str, pf_TaskTable[Caller].Name, P_OPC(*Msg) FILE_LINE_MACRO_PASSED ); protected_prim_to_free = NULL; // os_ReleaseSemaphore (Caller, vsi_m_sem_handle); return VSI_OK; } #endif if ( --((T_PRIM_HEADER*)*Msg)->use_cnt == 0 ) { #ifdef PRIM_AUTO_FREE if ( pf_TaskTable[Caller].Flags & PARTITION_AUTO_FREE ) freed_prim[Caller] = *Msg; #endif #ifdef _NUCLEUS_ #ifdef NU_DEBUG if ( os_PartitionCheck( (ULONG*)*Msg ) == OS_PARTITION_GUARD_PATTERN_DESTROYED ) { // os_ReleaseSemaphore (Caller, vsi_m_sem_handle); vsi_o_assert ( Caller, OS_SYST_ERR_PCB_PATTERN FILE_LINE_MACRO_PASSED, "%s (PFREE), entity %s,Partition 0x%x", guard_str, pf_TaskTable[Caller].Name, *Msg ); return VSI_ERROR; } #endif #endif protected_prim_to_free = NULL; // os_ReleaseSemaphore (Caller, vsi_m_sem_handle); return ( vsi_m_free ( Msg FILE_LINE ) ); } protected_prim_to_free = NULL; // os_ReleaseSemaphore (Caller, vsi_m_sem_handle); return VSI_OK; } #endif #ifndef RUN_FLASH /* +--------------------------------------------------------------------+ | PROJECT : GSM-Frame (8415) MODULE : VSI_COM | | STATE : code ROUTINE : vsi_c_pfree | +--------------------------------------------------------------------+ PURPOSE : deallocate a partition that was used to send a primitive */ int vsi_c_pfree (T_VOID_STRUCT **Msg FILE_LINE_TYPE) { T_VOID_STRUCT *free_ptr; T_HANDLE Caller; /* * PFREE is disabled if the primitive to be freed is the currently * processed one and the auto free is enabled for the calling entity */ Caller = e_running[os_MyHandle()]; free_ptr = (T_VOID_STRUCT*)D2P(*Msg); #ifdef NU_DEBUG if ( os_is_valid_partition ((T_VOID_STRUCT*)free_ptr) ) { /* free to non-partition memory */ vsi_o_assert ( NO_TASK, OS_SYST_ERR FILE_LINE_MACRO_PASSED, "PFREE to non-partition memory, entity %s, prim 0x%x", pf_TaskTable[Caller].Name, *Msg ); } #endif #ifdef PRIM_AUTO_FREE if ( free_ptr == processed_prim[Caller] && pf_TaskTable[Caller].Flags & PARTITION_AUTO_FREE ) { return VSI_OK; } #endif /* PRIM_AUTO_FREE */ return ( vsi_c_free ( Caller, &free_ptr FILE_LINE ) ); } #endif #ifndef RUN_FLASH /* +--------------------------------------------------------------------+ | PROJECT : GSM-Frame (8415) MODULE : VSI_COM | | STATE : code ROUTINE : vsi_c_await | +--------------------------------------------------------------------+ PURPOSE : receive a primitive */ int vsi_c_await (T_HANDLE Caller, T_HANDLE ComHandle, T_QMSG *Msg, ULONG Timeout) { OS_QDATA OS_Msg; LONG ret; OS_HANDLE q_handle; #ifdef _TOOLS_ q_handle = ComHandle; #else q_handle = pf_TaskTable[ComHandle].QueueHandle; #endif e_running[os_MyHandle()] = 0; if ( (ret = os_ReceiveFromQueue ( Caller, q_handle, &OS_Msg, Timeout)) == OS_OK ) { Msg->MsgType = OS_Msg.data16; switch ( Msg->MsgType ) { case MSG_PRIMITIVE: Msg->Msg.Primitive.Prim = OS_Msg.ptr; #ifdef _TOOLS_ Msg->Msg.Primitive.PrimLen = OS_Msg.len; #endif vsi_o_ptrace (Caller, ((T_PRIM_HEADER*)Msg->Msg.Primitive.Prim)->opc, 0); break; case MSG_SIGNAL: Msg->Msg.Signal.SigBuffer = OS_Msg.ptr; Msg->Msg.Signal.SigOPC = OS_Msg.data32; #ifdef _TOOLS_ Msg->Msg.Signal.SigLen = OS_Msg.len; #endif break; case MSG_TIMEOUT: if ( *(pf_TaskTable[Caller].FirstTimerEntry + OS_Msg.data32) & TIMEOUT_OCCURRED ) { if ( !(*(pf_TaskTable[Caller].FirstTimerEntry + OS_Msg.data32) & PERIODIC_TIMER) ) { os_DestroyTimer ( Caller, (OS_HANDLE)(*(pf_TaskTable[Caller].FirstTimerEntry + OS_Msg.data32) & TIMER_HANDLE_MASK) ); *(pf_TaskTable[Caller].FirstTimerEntry + OS_Msg.data32) = 0; } else { *(pf_TaskTable[Caller].FirstTimerEntry + OS_Msg.data32) &= ~TIMEOUT_OCCURRED; } Msg->Msg.Timer.Index = OS_Msg.data32; } break; default: return VSI_ERROR; /*lint -e527 suppress Warning -- Unreachable */ break; /*lint +e527 */ } e_running[os_MyHandle()] = Caller; prf_log_entity_activate ((void*)Caller); return VSI_OK; } else { if ( ret == OS_TIMEOUT ) { e_running[os_MyHandle()] = Caller; return VSI_TIMEOUT; } } return VSI_ERROR; } #endif #ifndef RUN_INT_RAM /* +--------------------------------------------------------------------+ | PROJECT : GSM-Frame (8415) MODULE : VSI_COM | | STATE : code ROUTINE : vsi_c_primitive | +--------------------------------------------------------------------+ PURPOSE : send a non GSM primitive to the frame */ int vsi_c_primitive (T_HANDLE Caller, void *Msg) { /* * the following line of code causes a warning on tms470 compiler, that cannot be avoided * without changing all entities PEI modules. Warning will not cause a problem */ pf_ProcessSystemPrim ( Caller, Msg ); return VSI_OK; } #endif #ifndef RUN_INT_RAM /* +--------------------------------------------------------------------+ | PROJECT : GSM-Frame (8415) MODULE : VSI_COM | | STATE : code ROUTINE : vsi_c_awake | +--------------------------------------------------------------------+ PURPOSE : send NULL primitive to itself */ GLOBAL int vsi_c_awake ( T_HANDLE caller ) { OS_QDATA QMsg = { 0 }; QMsg.data16 = MSG_PRIMITIVE; QMsg.ptr = NULL; os_SendToQueue ( caller, caller, OS_URGENT, OS_NO_SUSPEND, &QMsg ); return VSI_OK; } #endif #ifndef RUN_INT_RAM /* +--------------------------------------------------------------------+ | PROJECT : GSM-Frame (8415) MODULE : VSI_COM | | STATE : code ROUTINE : vsi_c_status | +--------------------------------------------------------------------+ PURPOSE : allocate root of dynamic sized primitive */ int vsi_c_status (T_HANDLE handle, unsigned int *used, unsigned int *free) { #ifdef _NUCLEUS_ int status; if ( (status = os_GetQueueState (0, pf_TaskTable[handle].QueueHandle, (ULONG*)used, (ULONG*)free)) == OS_OK ) return OS_OK; else #endif return OS_ERROR; } #endif #ifndef RUN_INT_RAM /* +--------------------------------------------------------------------+ | PROJECT : GSM-Frame (8415) MODULE : VSI_COM | | STATE : code ROUTINE : vsi_drpo_new | +--------------------------------------------------------------------+ PURPOSE : allocate root of dynamic sized primitive */ GLOBAL T_VOID_STRUCT *vsi_drpo_new ( ULONG size, ULONG opc, ULONG guess FILE_LINE_TYPE ) { T_PRIM_HEADER *prim; T_DP_HEADER *dp_hdr; T_S_HEADER *s_hdr; ULONG alloc_size; ULONG partition_size; ULONG header_size; T_HANDLE caller; caller = e_running[os_MyHandle()]; header_size = sizeof(T_PRIM_HEADER) + sizeof(T_DP_HEADER); if ( ALIGN(header_size + size) > MaxPrimPartSize ) { os_GetTaskName ( caller, caller, TaskName ); vsi_o_assert ( NO_TASK, OS_SYST_ERR_BIG_PARTITION FILE_LINE_MACRO_PASSED, "No Partition available, entity %s, size %d", pf_TaskTable[caller].Name, size ); return NULL; } if ( guess == DP_NO_FRAME_GUESS ) alloc_size = ALIGN(header_size + size); else if ( guess == DP_FRAME_GUESS ) alloc_size = ALIGN(header_size + size * 3); else alloc_size = ALIGN(header_size + guess + size); if ( caller != 0 && caller == TST_Handle ) { /* if called by PCON in the test interface while decoding we need to reserve space for the S_HEADER */ alloc_size += sizeof(T_S_HEADER); } if ( alloc_size > MaxPrimPartSize ) { #ifdef NU_DEBUG pf_handle_warning ( OS_SYST_WRN_REQ_TRUNCATED, "%s %s (%d->%d), entity %s, opc 0x%x, %s(%d)", syst_wrn, trunc_str, alloc_size, MaxPrimPartSize, pf_TaskTable[caller].Name, opc FILE_LINE_MACRO_PASSED ); #endif alloc_size = MaxPrimPartSize; } if ( ( prim = (T_PRIM_HEADER*)vsi_m_new_size ( alloc_size, PrimGroupHandle, &partition_size FILE_LINE ) ) != NULL ) { #ifdef MEMORY_SUPERVISION vsi_ppm_new ( caller, alloc_size, (T_PRIM_HEADER*)prim, file, line ); #endif prim->len = partition_size; /* complete partition because header is at the end */ prim->opc = opc; prim->sdu = NULL; prim->use_cnt = 1; prim->sh_offset = 0; prim->dph_offset = D_HDR_OFFSET(partition_size); dp_hdr = (T_DP_HEADER*)((ULONG*)prim + prim->dph_offset); dp_hdr->magic_nr = GUARD_PATTERN; dp_hdr->drp_bound_list = NULL; dp_hdr->next = NULL; dp_hdr->offset = sizeof(T_PRIM_HEADER) + ALIGN(size); dp_hdr->size = partition_size - sizeof(T_DP_HEADER); if ( dp_hdr->offset > dp_hdr->size ) { dp_hdr->offset = dp_hdr->size; } /* * The following code does not work since the 'caller' parameter has been removed from the function * prototype. The code was needed for the case where the function was called by PCON when decoding a * received primitive in the test interface. The caller in this case is 0 because it is either the * RCV_HISR on the target or the EXTR task in the simulation which is not running in the context of * the frame. Currently the sh_offset is set in the TIF driver tif.c although the guard pattern is not * set there. This is working fine so there is no reason to modify the code here. This comment * is just the result of some brainstorming and can be used for future modifications */ if ( caller != 0 && caller == TST_Handle ) /* called by PCON */ { prim->sh_offset = prim->dph_offset - sizeof(T_S_HEADER); dp_hdr->size = dp_hdr->size - sizeof(T_S_HEADER); s_hdr = (T_S_HEADER*)((ULONG*)prim + prim->sh_offset); s_hdr->magic_nr = GUARD_PATTERN; } else prim->sh_offset = 0; return ((T_VOID_STRUCT*)P2D(prim)); } return NULL; } #endif #ifndef RUN_INT_RAM /* +--------------------------------------------------------------------+ | PROJECT : GSM-Frame (8415) MODULE : VSI_COM | | STATE : code ROUTINE : vsi_drpo_new_sdu | +--------------------------------------------------------------------+ PURPOSE : allocate dynamic sized partition root */ T_VOID_STRUCT * vsi_drpo_new_sdu (ULONG Size, ULONG opc, USHORT sdu_len, USHORT sdu_offset, USHORT encode_offset, ULONG guess FILE_LINE_TYPE ) { T_VOID_STRUCT *ptr; ULONG alloc_size; T_HANDLE Caller; Caller = 0; alloc_size = Size + BYTELEN((SHORT)sdu_len + (SHORT)encode_offset); ptr = vsi_drpo_new ( alloc_size, opc, guess FILE_LINE ); /* * the following line of code causes a warning on tms470 compiler, * that cannot be avoided. Warning will not cause a problem because due to the * arm7 alignment it is guaranteed that the sdu will start at an address divisable * by 4. */ D_SDU(ptr) = (T_sdu*)((char*)ptr + sdu_offset); D_SDU_LEN(ptr) = sdu_len; D_SDU_OFF(ptr) = encode_offset; return ( (T_VOID_STRUCT*)ptr ); } #endif #ifndef RUN_INT_RAM /* +--------------------------------------------------------------------+ | PROJECT : GSM-Frame (8415) MODULE : VSI_COM | | STATE : code ROUTINE : vsi_drp_bind | +--------------------------------------------------------------------+ PURPOSE : bind child root pointer to a given parent root pointer */ GLOBAL int vsi_drp_bind (T_VOID_STRUCT *child, T_VOID_STRUCT *parent FILE_LINE_TYPE) { T_PRIM_HEADER *prim; T_DP_HEADER *dp_hdr; T_VOID_STRUCT **new_drp_bound_list; ULONG alloc_size; T_HANDLE caller; int pos; caller = e_running[os_MyHandle()]; prim = D2P(parent); if ( ((T_DP_HEADER*)prim)->magic_nr == GUARD_PATTERN ) { dp_hdr = (T_DP_HEADER*)prim; } else { dp_hdr = (T_DP_HEADER*)((ULONG*)prim + prim->dph_offset); } if (dp_hdr->drp_bound_list == NULL) { /* no partitions bound so far */ alloc_size=MAX_DRP_BOUND*sizeof(T_DP_HEADER*); if ( ( new_drp_bound_list = (T_VOID_STRUCT**)M_ALLOC (alloc_size) ) == NULL ) { /* no more memory */ return VSI_ERROR; } memset(new_drp_bound_list,0x00,alloc_size); dp_hdr->drp_bound_list=new_drp_bound_list; } /* find free bind pointer */ pos=0; while(pos<MAX_DRP_BOUND && dp_hdr->drp_bound_list[pos]) { pos++; } if (pos == MAX_DRP_BOUND) { /* no more free bound pointers */ return VSI_ERROR; } /* actually bind */ P_ATTACH(child); dp_hdr->drp_bound_list[pos]=child; return VSI_OK; } /* +--------------------------------------------------------------------+ | PROJECT : GSM-Frame (8415) MODULE : VSI_COM | | STATE : code ROUTINE : vsi_dp_new | +--------------------------------------------------------------------+ PURPOSE : allocate dynamic sized partition root */ GLOBAL T_VOID_STRUCT *vsi_dp_new ( ULONG size, T_VOID_STRUCT *addr, ULONG guess FILE_LINE_TYPE ) { T_PRIM_HEADER *prim; T_PRIM_HEADER *last_in_chain; T_PRIM_HEADER *dyn_ptr; T_DP_HEADER *dp_hdr; T_DP_HEADER *new_prim; T_VOID_STRUCT *ptr; ULONG partition_size; ULONG alloc_size; //ULONG estimated_size; T_HANDLE caller; char is_opc_root; if ( size + sizeof(T_DP_HEADER) > MaxPrimPartSize ) { caller = e_running[os_MyHandle()]; vsi_o_assert ( NO_TASK, OS_SYST_ERR_BIG_PARTITION FILE_LINE_MACRO_PASSED, "No Partition available, entity %s, size %d", pf_TaskTable[caller].Name, size ); return NULL; } prim = D2P(addr); dyn_ptr = prim; if ( ((T_DP_HEADER*)prim)->magic_nr == GUARD_PATTERN ) { dp_hdr = (T_DP_HEADER*)prim; is_opc_root = 0; } else { dp_hdr = (T_DP_HEADER*)((ULONG*)prim + prim->dph_offset); is_opc_root = 1; } if ( guess == DP_NO_FRAME_GUESS ) alloc_size = size + sizeof(T_DP_HEADER); else if ( guess == DP_FRAME_GUESS ) alloc_size = size * 3 + sizeof(T_DP_HEADER); else alloc_size = size + guess + sizeof(T_DP_HEADER); #if 0 /* * update estimated size */ estimated_size = dp_hdr->est_size; if ( guess != DP_NO_FRAME_GUESS && guess != DP_FRAME_GUESS ) { estimated_size = size + guess; alloc_size = estimated_size + sizeof(T_DP_HEADER); estimated_size -= size; } else { if ( size > estimated_size ) { if ( guess == DP_FRAME_GUESS ) estimated_size = size * 3; else estimated_size = size; } estimated_size -= size; if ( size > estimated_size ) estimated_size = size * 2; alloc_size = estimated_size + sizeof(T_DP_HEADER); } if ( estimated_size > MaxPrimPartSize ) estimated_size = MaxPrimPartSize; dp_hdr->est_size = estimated_size; #endif /* * check if free space in already allocated blocks (first fit) */ do { if ( dp_hdr->magic_nr != GUARD_PATTERN ) { caller = e_running[os_MyHandle()]; vsi_o_assert ( caller, OS_SYST_ERR FILE_LINE_MACRO_PASSED, "Magic number in dp_header destroyed (DP_ALLOC), %s opc: 0x%lx, partition 0x%lx", pf_TaskTable[caller].Name, ((T_PRIM_HEADER*)prim)->opc, prim ); } if ( dp_hdr->size - dp_hdr->offset > size ) { /* * if root was allocated with drpo_alloc then dp header is at the end, * the dph offset is not 0 and a primitive header is present. */ if ( is_opc_root && dyn_ptr == prim ) ptr = (T_VOID_STRUCT*)(((ULONG*)prim) + (dp_hdr->offset>>2)); else ptr = (T_VOID_STRUCT*)(((ULONG*)dp_hdr) + (dp_hdr->offset>>2)); dp_hdr->offset += ALIGN(size); return ( ptr ); } if ( is_opc_root && dyn_ptr == prim ) last_in_chain = prim; else last_in_chain = (T_PRIM_HEADER*)dp_hdr; dp_hdr = (T_DP_HEADER*)dp_hdr->next; dyn_ptr = (T_PRIM_HEADER*)dp_hdr; } while ( dp_hdr ); /* * not enough free space -> additional allocation needed */ if ( alloc_size > MaxPrimPartSize ) { #ifdef NU_DEBUG caller = e_running[os_MyHandle()]; pf_handle_warning ( OS_SYST_WRN_REQ_TRUNCATED, "%s %s (%d->%d), entity %s, %s(%d)", syst_wrn, trunc_str, alloc_size, MaxPrimPartSize, pf_TaskTable[caller].Name FILE_LINE_MACRO_PASSED ); #endif alloc_size = MaxPrimPartSize; } if ( ( new_prim = (T_DP_HEADER*)vsi_m_new_size ( alloc_size, PrimGroupHandle, &partition_size FILE_LINE ) ) != NULL ) { #ifdef MEMORY_SUPERVISION caller = e_running[os_MyHandle()]; vsi_ppm_new ( caller, alloc_size, (T_PRIM_HEADER*)new_prim, file, line ); #endif if ( ((T_DP_HEADER*)last_in_chain)->magic_nr == GUARD_PATTERN ) dp_hdr = (T_DP_HEADER*)last_in_chain; else dp_hdr = (T_DP_HEADER*)((ULONG*)last_in_chain + last_in_chain->dph_offset); dp_hdr->next = new_prim; new_prim->magic_nr = GUARD_PATTERN; new_prim->drp_bound_list = NULL; new_prim->use_cnt = 1; new_prim->next = NULL; new_prim->size = partition_size; new_prim->offset = sizeof(T_DP_HEADER) + ALIGN(size); if ( new_prim->offset > new_prim->size ) { new_prim->offset = new_prim->size; } return (T_VOID_STRUCT*)(new_prim + 1); } return NULL; } #endif #ifndef RUN_INT_RAM /* +--------------------------------------------------------------------+ | PROJECT : GSM-Frame (8415) MODULE : VSI_COM | | STATE : code ROUTINE : vsi_c_drp_new | +--------------------------------------------------------------------+ PURPOSE : allocate dynamic sized partition except root */ GLOBAL T_VOID_STRUCT *vsi_drp_new ( ULONG size, ULONG guess FILE_LINE_TYPE ) { T_PRIM_HEADER *prim; T_DP_HEADER *dp_hdr; ULONG alloc_size; ULONG header_size; ULONG partition_size; T_HANDLE caller; header_size = sizeof(T_DP_HEADER); if ( ALIGN(header_size + size) > MaxPrimPartSize ) { caller = e_running[os_MyHandle()]; os_GetTaskName ( caller, caller, TaskName ); vsi_o_assert ( NO_TASK, OS_SYST_ERR_BIG_PARTITION FILE_LINE_MACRO_PASSED, "No Partition available, entity %s, size %d", pf_TaskTable[caller].Name, size ); return NULL; } if ( guess == DP_NO_FRAME_GUESS ) alloc_size = header_size + size; else if ( guess == DP_FRAME_GUESS ) alloc_size = header_size + size * 3; else alloc_size = header_size + guess + size; if ( alloc_size > MaxPrimPartSize ) { #ifdef NU_DEBUG caller = e_running[os_MyHandle()]; pf_handle_warning ( OS_SYST_WRN_REQ_TRUNCATED, "%s %s (%d->%d), entity %s, %s(%d)", syst_wrn, trunc_str, alloc_size, MaxPrimPartSize, pf_TaskTable[caller].Name FILE_LINE_MACRO_PASSED ); #endif alloc_size = MaxPrimPartSize; } if ( ( prim = (T_PRIM_HEADER*)vsi_m_new_size ( alloc_size, PrimGroupHandle, &partition_size FILE_LINE ) ) != NULL ) { #ifdef MEMORY_SUPERVISION caller = e_running[os_MyHandle()]; vsi_ppm_new ( caller, alloc_size, (T_PRIM_HEADER*)prim, file, line ); #endif dp_hdr = (T_DP_HEADER*)prim; dp_hdr->next = NULL; dp_hdr->magic_nr = GUARD_PATTERN; dp_hdr->drp_bound_list = NULL; dp_hdr->use_cnt = 1; dp_hdr->offset = sizeof(T_DP_HEADER) + ALIGN(size); dp_hdr->size = partition_size; if ( dp_hdr->offset > dp_hdr->size ) { dp_hdr->offset = dp_hdr->size; } return (T_VOID_STRUCT*)(dp_hdr+1); } return NULL; } #endif #ifndef RUN_INT_RAM /* +--------------------------------------------------------------------+ | PROJECT : GSM-Frame (8415) MODULE : VSI_COM | | STATE : code ROUTINE : vsi_free | +--------------------------------------------------------------------+ PURPOSE : deallocate a chain of linked partitions */ int vsi_free ( T_VOID_STRUCT **Msg FILE_LINE_TYPE ) { T_PRIM_HEADER *prim; T_DP_HEADER *dp_hdr; T_VOID_STRUCT** drp_bound_list; T_HANDLE Caller = 0; int pos; /* * PFREE is disabled if the primitive to be freed is the currently * processed one and the auto free is enabled for the calling entity */ Caller = e_running[os_MyHandle()]; prim = D2P(*Msg); #ifdef NU_DEBUG if ( os_is_valid_partition ((T_VOID_STRUCT*)prim) ) { /* free to non-partition memory */ Caller = e_running[os_MyHandle()]; vsi_o_assert ( NO_TASK, OS_SYST_ERR FILE_LINE_MACRO_PASSED, "FREE to non-partition memory, entity %s, prim 0x%x", pf_TaskTable[Caller].Name, *Msg ); } #endif #ifdef PRIM_AUTO_FREE if ( prim == (T_PRIM_HEADER*)processed_prim[Caller] && pf_TaskTable[Caller].Flags & PARTITION_AUTO_FREE ) { return VSI_OK; } #endif /* PRIM_AUTO_FREE */ /* check if we have dynamic partition or primitive */ if ( ((T_DP_HEADER*)prim)->magic_nr == GUARD_PATTERN ) { dp_hdr = (T_DP_HEADER*)prim; } else if ( prim->dph_offset != 0 ) { dp_hdr = (T_DP_HEADER*)((ULONG*)prim + prim->dph_offset); } else { return ( vsi_c_free ( Caller, (T_VOID_STRUCT**)&prim FILE_LINE ) ); } if ( dp_hdr->magic_nr != GUARD_PATTERN ) { /* primitive with T_desc_list element */ vsi_c_free ( Caller, (T_VOID_STRUCT**)&prim FILE_LINE ); return VSI_OK; } else { do { drp_bound_list=dp_hdr->drp_bound_list; if (drp_bound_list) { /* call free for bound root pointers */ pos=0; while(pos<MAX_DRP_BOUND && drp_bound_list[pos]) { FREE(drp_bound_list[pos]); pos++; } } /* free linked memory */ dp_hdr = (T_DP_HEADER*)dp_hdr->next; vsi_c_free ( Caller, (T_VOID_STRUCT**)&prim FILE_LINE ); if (prim == NULL && drp_bound_list) { /* free drp_bound_list */ M_FREE(drp_bound_list); } } while ( (prim = (T_PRIM_HEADER*)dp_hdr) != NULL ); } return VSI_OK; } #endif #ifndef RUN_INT_RAM /* +--------------------------------------------------------------------+ | PROJECT : GSM-Frame (8415) MODULE : VSI_COM | | STATE : code ROUTINE : vsi_d_sum | +--------------------------------------------------------------------+ PURPOSE : get number of bytes in dynamic sized primitive */ GLOBAL int vsi_dp_sum ( T_VOID_STRUCT *addr, ULONG *bytes ) { T_PRIM_HEADER *prim; T_DP_HEADER *dp_hdr; ULONG size; T_HANDLE caller; prim = D2P(addr); if ( ((T_DP_HEADER*)prim)->magic_nr == GUARD_PATTERN ) dp_hdr = (T_DP_HEADER*)prim; else if ( prim->dph_offset != 0 ) dp_hdr = (T_DP_HEADER*)((ULONG*)prim + prim->dph_offset); else { caller = e_running[os_MyHandle()]; vsi_o_ttrace ( NO_TASK, TC_SYSTEM, "SYSTEM WARNING: No root of linked memory in %s", pf_TaskTable[caller].Name ); return VSI_ERROR; } size = 0; do { if ( dp_hdr->magic_nr != GUARD_PATTERN ) { caller = e_running[os_MyHandle()]; vsi_o_assert ( caller, OS_SYST_ERR, __FILE__, __LINE__, "Magic number in dp_header destroyed, opc: 0x%lx, partition 0x%lx", prim->opc, prim ); } size += (dp_hdr->offset-sizeof(T_DP_HEADER)); dp_hdr = (T_DP_HEADER*)dp_hdr->next; } while ( (prim = (T_PRIM_HEADER*)dp_hdr) != NULL ); *bytes = size; return VSI_OK; } #endif #ifndef RUN_INT_RAM /* +--------------------------------------------------------------------+ | PROJECT : GSM-Frame (8415) MODULE : VSI_COM | | STATE : code ROUTINE : vsi_dp_max_size | +--------------------------------------------------------------------+ PURPOSE : get maximum number of bytes available for user data in dynamic primitive */ GLOBAL int vsi_dp_max_size ( void ) { return ( (int)(MaxPrimPartSize - sizeof(T_PRIM_HEADER) - sizeof(T_DP_HEADER)) ); } #endif #ifndef RUN_INT_RAM /* +--------------------------------------------------------------------+ | PROJECT : GSM-Frame (8415) MODULE : VSI_COM | | STATE : code ROUTINE : vsi_c_pmax_size | +--------------------------------------------------------------------+ PURPOSE : get maximum number of bytes available for user data in dynamic primitive */ GLOBAL int vsi_c_pmax_size ( void ) { return ( (int)(MaxPrimPartSize - sizeof(T_DP_HEADER)) ); } #endif #ifdef _TOOLS_ /* +--------------------------------------------------------------------+ | PROJECT : GSM-Frame (8415) MODULE : VSI_COM | | STATE : code ROUTINE : vsi_c_sync | +--------------------------------------------------------------------+ PURPOSE : check if PS already started */ GLOBAL int vsi_c_sync ( T_HANDLE caller, T_TIME timeout ) { T_VOID_STRUCT *prim; T_QMSG Msg; T_HANDLE tst_q_handle; char sync_req_name[RESOURCE_NAMELEN]; char sync_req_time[8]; static int sync_active = 0; if ( sync_active == FALSE ) { sync_active = TRUE; os_GetTaskName(caller, caller, sync_req_name); itoa(timeout, sync_req_time,10); prim = vsi_c_pnew ( sizeof(T_PRIM_HEADER)+strlen(SYSPRIM_CONFIG_TOKEN)+1 +strlen(SYSPRIM_TST_SYNC_REQ)+1 +strlen(sync_req_name)+1 +strlen(sync_req_time)+1, 0x8000 FILE_LINE ); strcpy ( (char*)prim, SYSPRIM_CONFIG_TOKEN ); strcat ( (char*)prim, " " ); strcat ( (char*)prim, SYSPRIM_TST_SYNC_REQ ); strcat ( (char*)prim, " " ); strcat ( (char*)prim, sync_req_name ); strcat ( (char*)prim, " " ); strcat ( (char*)prim, sync_req_time ); tst_q_handle = vsi_c_open ( caller, FRM_TST_NAME ); vsi_c_psend ( tst_q_handle, prim ); if ( vsi_c_await ( caller, pf_TaskTable[caller].QueueHandle, &Msg, timeout ) == VSI_TIMEOUT ) { vsi_o_ttrace (caller, TC_SYSTEM, "timeout - Synchronization with Stack failed" ); sync_active = FALSE; return VSI_ERROR; } else { sync_active = FALSE; if ( strcmp ((char*)P2D(Msg.Msg.Primitive.Prim), SYSPRIM_TST_SYNC_CNF ) == 0 ) { vsi_o_ttrace (caller, TC_SYSTEM, "TST_SYNC_CNF - Synchronization with Stack succeeded" ); vsi_c_free (caller, &Msg.Msg.Primitive.Prim); return VSI_OK; } else { vsi_o_ttrace (caller, TC_SYSTEM, "TST_SYNC_REJ - Synchronization with Stack failed" ); vsi_c_free (caller, &Msg.Msg.Primitive.Prim); return VSI_ERROR; } } } return VSI_OK; } #endif #ifdef _TOOLS_ /* +--------------------------------------------------------------------+ | PROJECT : GSM-Frame (8415) MODULE : VSI_COM | | STATE : code ROUTINE : vsi_c_generic_send | +--------------------------------------------------------------------+ PURPOSE : check if PS already started */ int vsi_c_alloc_send ( T_HANDLE com_handle, char* dst, char* src, void *prim, char *string ) { int alloc_size; T_PRIM_HEADER *ptr; T_S_HEADER *s_hdr; unsigned int i; unsigned int size; int opc; int s_header_added = 0; int sh_offset; if ( string != NULL ) { size = strlen(string); alloc_size = size + sizeof(T_PRIM_HEADER); if ( dst != NULL || src != NULL ) { sh_offset = ALIGN(alloc_size) / (int)sizeof(ULONG); alloc_size = ALIGN(alloc_size) + sizeof(T_S_HEADER); if ( dst != 0 ) opc = 0; /* to stack -> set to SYS_MASK in tst_pei_primitive() when sh_offset != 0 */ else opc = SYS_MASK; /* to tools */ s_header_added = 1; } else { opc = SYS_MASK; sh_offset = 0; } ptr = (T_PRIM_HEADER*)vsi_c_new ( 0, alloc_size, opc ); memcpy ( (char*)P2D(ptr), string, size ); if ( s_header_added == 1 ) { ptr->sh_offset = sh_offset; s_hdr = (T_S_HEADER*)((int*)ptr+ptr->sh_offset); ptr->len = size + sizeof(T_PRIM_HEADER); /* exclude S_HEADER */ } } else { ptr = D2P(prim); /* work on passed primitive */ } if ( dst != NULL ) { if ( s_header_added == 0 ) { alloc_size = ALIGN(ptr->len) + sizeof(T_S_HEADER); ptr = (T_PRIM_HEADER*)vsi_c_new ( 0, alloc_size, 0 ); memcpy((char*)ptr, (char*)D2P(prim), D_LEN(prim)); ptr->sh_offset = ALIGN(D_LEN(prim)) / sizeof(ULONG); s_hdr = (T_S_HEADER*)((int*)ptr+ptr->sh_offset); FREE(prim); } else { s_hdr = (T_S_HEADER*)((int*)ptr+ptr->sh_offset); } /* set org_rcv and rcv */ for (i = 0; dst[i] && i < sizeof (s_hdr->rcv) && dst[i]!= ';'; i++) s_hdr->org_rcv[i] = s_hdr->rcv[i] = dst[i]; if (i < sizeof s_hdr->rcv) s_hdr->org_rcv[i] = s_hdr->rcv[i] = 0; s_hdr->time = 0; s_header_added = 1; } if ( src != NULL ) { if ( s_header_added == 0 ) { alloc_size = ALIGN(ptr->len) + sizeof(T_S_HEADER); ptr = (T_PRIM_HEADER*)vsi_c_new ( 0, alloc_size, 0 ); memcpy((char*)ptr, (char*)D2P(prim), D_LEN(prim)); ptr->sh_offset = ALIGN(D_LEN(prim)) / sizeof(ULONG); s_hdr = (T_S_HEADER*)((int*)ptr+ptr->sh_offset); FREE(prim); } else { s_hdr = (T_S_HEADER*)((int*)ptr+ptr->sh_offset); } s_hdr->time = 0; /* set snd */ for (i = 0; src[i] && i < sizeof (s_hdr->snd) && src[i]!= ';'; i++) s_hdr->snd[i] = src[i]; if (i < sizeof s_hdr->snd) s_hdr->snd[i] = 0; } return ( vsi_c_psend (com_handle, (T_VOID_STRUCT*)P2D(ptr)) ); } #endif #ifdef NU_DEBUG #ifndef RUN_FLASH /* +----------------------------------------------------------------------+ | PROJECT : GSM-Frame (8415) MODULE : VSI_COM | | STATE : code ROUTINE : check_descriptor_list | +----------------------------------------------------------------------+ PURPOSE : check partitions in descriptor list */ int check_descriptor_list ( T_HANDLE caller, T_PRIM_HEADER *prim FILE_LINE_TYPE ) { T_DP_HEADER *dp_hdr; T_M_HEADER *mem; T_desc *desc; LONG Status; dp_hdr = (T_DP_HEADER*)((ULONG*)prim + prim->dph_offset); /* the presence of the guard pattern at dph_offset is used to distinguish between dynamic primitives and primitives with descriptor list. If the guard pattern is destroyed, the primitive looks like having a descriptor list and the frame will probably crash during checking the integrity of the partitions in the list. This bahavior is prefered to non checking the partitions */ if ( *((ULONG*)dp_hdr) == GUARD_PATTERN ) { dp_hdr = (T_DP_HEADER*)dp_hdr->next; while (dp_hdr != NULL) { if ( dp_hdr->magic_nr != GUARD_PATTERN ) { prim = (T_PRIM_HEADER*)dp_hdr; vsi_o_assert ( caller, OS_SYST_ERR FILE_LINE_MACRO_PASSED, "Magic number in dp_header destroyed (PSEND) %s , opc: 0x%lx, partition 0x%lx", pf_TaskTable[caller].Name, prim->opc, prim ); } if ( (Status = os_PartitionCheck ( (T_VOID_STRUCT*)dp_hdr)) == OS_PARTITION_GUARD_PATTERN_DESTROYED ) { vsi_o_assert ( caller, OS_SYST_ERR_PCB_PATTERN FILE_LINE_MACRO_PASSED, "%s in dynamic primitive (PSEND),entity %s, prim 0x%x, opc 0x%x, bad partition 0x%x", guard_str, pf_TaskTable[caller].Name, prim, prim->opc, dp_hdr ); break; } dp_hdr = (T_DP_HEADER*)dp_hdr->next; } } else { if ( caller != TST_Handle ) { /* do not check and update the states of the primitives in descriptor lists when called by TST, because descriptor lists are not routed to TST and will result in the warning generated below */ desc = (T_desc*)(((T_desc_list*)dp_hdr)->first); while (desc != NULL) { mem = (T_M_HEADER*)(((char*)desc)-sizeof(T_M_HEADER)); if ( os_is_valid_partition ((T_VOID_STRUCT*)mem) ) { vsi_o_assert ( NO_TASK, OS_SYST_ERR FILE_LINE_MACRO_PASSED, "pointer to non-partition memory in desc list(PSEND), entity %s, prim 0x%x, opc 0x%x", pf_TaskTable[caller].Name, prim, prim->opc ); return VSI_ERROR; } if ( (Status = os_PartitionCheck ( (T_VOID_STRUCT*)mem)) != OS_OK ) { switch ( Status ) { case OS_PARTITION_GUARD_PATTERN_DESTROYED: vsi_o_assert ( caller, OS_SYST_ERR_PCB_PATTERN FILE_LINE_MACRO_PASSED, "%s in desclist (PSEND), entity %s, prim 0x%x, opc 0x%x, bad partition 0x%x", guard_str, pf_TaskTable[caller].Name, prim, prim->opc, mem ); break; case OS_PARTITION_FREE: vsi_o_assert ( caller, OS_SYST_ERR FILE_LINE_MACRO_PASSED, "%s in desclist (PSEND), entity %s, prim 0x%x, opc 0x%x, freed partition 0x%x", freed_sent_str, pf_TaskTable[caller].Name, prim, prim->opc, mem ); break; default: break; } } if ( mem->desc_type == (VSI_DESC_TYPE3 >> 16) ) { mem = ((T_M_HEADER*)(((T_desc3*)desc)->buffer)) - 1; if ( os_is_valid_partition ( (T_VOID_STRUCT*)mem ) ) { vsi_o_assert ( NO_TASK, OS_SYST_ERR FILE_LINE_MACRO_PASSED, "pointer to non-partition memory in desc list type 3 (PSEND), entity %s, prim 0x%x, opc 0x%x, invalid partition 0x%x", pf_TaskTable[caller].Name, prim, prim->opc, mem ); return VSI_ERROR; } if ( (Status = os_PartitionCheck ( (T_VOID_STRUCT*)mem )) != OS_OK ) { switch ( Status ) { case OS_PARTITION_GUARD_PATTERN_DESTROYED: vsi_o_assert ( caller, OS_SYST_ERR_PCB_PATTERN FILE_LINE_MACRO_PASSED, "%s in desclist type 3 (PSEND), entity %s, prim 0x%x, opc 0x%x, bad partition 0x%x", guard_str, pf_TaskTable[caller].Name, prim, prim->opc, mem ); break; case OS_PARTITION_FREE: vsi_o_assert ( caller, OS_SYST_ERR FILE_LINE_MACRO_PASSED, "%s in desclist type 3 (PSEND), entity %s, prim 0x%x, opc 0x%x, freed partition 0x%x", freed_sent_str, pf_TaskTable[caller].Name, prim, prim->opc, mem ); break; default: break; } } } desc = (T_desc *)desc->next; } } } return VSI_OK; } #endif #endif #if !defined _TARGET_ && !defined _TOOLS_ /* ------------------------------------------------------------------------- check functions ----------------------------------------------------------------------------*/ #ifdef TEST_PCHECK #ifndef RUN_INT_RAM ULONG test_pcheck ( ULONG opc, void * decoded_prim ) { vsi_o_ttrace ( NO_TASK, TC_SYSTEM, "test_pcheck() called for opc %8x", D_OPC(decoded_prim) ); return pcheck_func.ret_ok+1; } #endif #endif /* TEST_PCHECK */ #ifndef RUN_INT_RAM /* +------------------------------------------------------------------------------ | Function : pcheck_register +------------------------------------------------------------------------------ | Description : register the pcheck function. | | Parameters : func - pointer to API function pointer table | | Return : void +------------------------------------------------------------------------------ */ void vsi_pcheck_register ( ULONG (*func)(ULONG, void*), ULONG ret_ok ) { pcheck_func.ret_ok = ret_ok; pcheck_func.pcheck = func; pcheck_func.magic_nr = PCHECK_INITIALIZED; } #endif #ifndef RUN_INT_RAM /* +------------------------------------------------------------------------------ | Function : ext_trace_init +------------------------------------------------------------------------------ | Description : initialize external trace function pointer table. | | Parameters : void | | Return : void +------------------------------------------------------------------------------ */ void vsi_pcheck_init ( void ) { #ifdef TEST_PCHECK vsi_pcheck_register ( test_pcheck, 0 ); #endif if ( pcheck_func.magic_nr != PCHECK_INITIALIZED ) { pcheck_func.ret_ok = 0; pcheck_func.pcheck = NULL; pcheck_func.magic_nr = 0; } } #endif #endif /* !_TARGET_ && !_TOOLS_*/