FreeCalypso > hg > freecalypso-sw
view gsm-fw/gpf/tst_drv/mux_pei.c @ 336:922efdd65dce
g23sh written, compiles
author | Michael Spacefalcon <msokolov@ivan.Harhan.ORG> |
---|---|
date | Tue, 22 Apr 2014 07:21:04 +0000 |
parents | 5d1e22505446 |
children |
line wrap: on
line source
/* +------------------------------------------------------------------------------ | File: mux_pei.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 implements the process body interface | for the entity mux (used by tst for multiplexer driver). +----------------------------------------------------------------------------- */ #ifndef MUX_PEI_C #define MUX_PEI_C #endif #ifndef ENTITY_MUX #define ENTITY_MUX #endif #define ENTITY_UART /* test only */ /*==== INCLUDES =============================================================*/ #include "stdlib.h" #include <stdio.h> #include "string.h" #include "typedefs.h" #include "tools.h" #include "os.h" #include "gdi.h" #include "vsi.h" #include "glob_defs.h" #include "frame.h" #include "prim.h" /* to get the definitions of used SAP and directions */ #include "gsm.h" #include "pei.h" #include "route.h" #include "dti.h" /* functionality of the dti library */ #include "mux.h" /* to get the global entity definitions */ /*==== CONSTS ================================================================*/ #undef VSI_CALLER #define VSI_CALLER m_handle, /* * Wait as long as possible. This is the time in ms that is waited for a * message in the input queue in the active variant. * It can be decreased by the customer. */ #define MUX_TIMEOUT 0xffffffff /*==== TYPES =================================================================*/ typedef struct { char *version; } T_MONITOR; /*==== GLOBAL VARIABLES ======================================================*/ /*==== LOCALS ================================================================*/ static int m_first = 1; static T_MONITOR m_mon; static int m_uart_ready = 0; static T_desc2 * m_send_data=NULL; static USHORT m_send_len=0; T_HANDLE m_handle; T_DRV_SIGNAL m_signal; GLOBAL DTI_HANDLE mtst_hDTI; /* handle for DTI library */ T_QMSG QueueMsg; /*==== EXTERNAL DEFINED FUNCTIONS ==========================================*/ /*==== PRIMITIVE HANDLER FUNCTIONS ==========================================*/ static void primitive_not_supported (T_PRIM_HEADER *data); static void dti_data_req (T_DTI2_DATA_REQ *ptr); /* * Jumptables to primitive handler functions. One table per SAP. * * Use MAK_FUNC_0 for primitives which contains no SDU. * Use MAK_FUNC_S for primitives which contains a SDU. */ LOCAL const T_FUNC dti_ul_table[] = { MAK_FUNC_0( primitive_not_supported , DTI2_CONNECT_REQ ), /* 3700x */ MAK_FUNC_0( primitive_not_supported , DTI2_CONNECT_RES ), /* 3701x */ MAK_FUNC_0( primitive_not_supported , DTI2_DISCONNECT_REQ ), /* 3702x */ MAK_FUNC_0( primitive_not_supported , DTI2_GETDATA_REQ ), /* 3703x */ MAK_FUNC_0( dti_data_req , DTI2_DATA_REQ ) /* 3704x */ #if defined (_SIMULATION_) , MAK_FUNC_S( primitive_not_supported , DTI2_DATA_TEST_REQ ) #endif /* _SIMULATION_ */ }; LOCAL const T_FUNC dti_dl_table[] = { MAK_FUNC_0( pei_dti_dti_connect_ind , DTI2_CONNECT_IND ), /* 7700x */ MAK_FUNC_0( pei_dti_dti_connect_cnf , DTI2_CONNECT_CNF ), /* 7701x */ MAK_FUNC_0( pei_dti_dti_disconnect_ind , DTI2_DISCONNECT_IND ), /* 7702x */ MAK_FUNC_0( pei_dti_dti_ready_ind , DTI2_READY_IND ), /* 7703x */ MAK_FUNC_0( pei_dti_dti_data_ind , DTI2_DATA_IND ) /* 7704x */ #if defined (_SIMULATION_) , MAK_FUNC_S( pei_dti_dti_data_test_ind , DTI2_DATA_TEST_IND ) #endif /* _SIMULATION_ */ }; /*==== PRIVATE FUNCTIONS ====================================================*/ /* +------------------------------------------------------------------------------ | Function : primitive_not_supported +------------------------------------------------------------------------------ | Description : This function handles unsupported primitives. | | Parameters : data - not used | | Return : void +------------------------------------------------------------------------------ */ static void primitive_not_supported (T_PRIM_HEADER *data) { //TRACE_FUNCTION ("primitive_not_supported"); PFREE (data); } /* +------------------------------------------------------------------------------ | Function : pei_primitive +------------------------------------------------------------------------------ | Description : Process protocol specific primitive. | | Parameters : prim - pointer to the received primitive | | Return : PEI_OK - function succeeded | PEI_ERROR - function failed +------------------------------------------------------------------------------ | | TST UART UPLINK | | +------v-----------v-------+ | | | MUX | | | +-------------^------------+ | UART DOWNLINK | */ static short pei_primitive (void *ptr) { /* * the following line of code causes a warning on tms470 compiler, that cannot be avoided * without changing the PEI interface. Warning will not cause a problem */ T_PRIM * prim=(T_PRIM*)ptr; //TRACE_FUNCTION ("pei_primitive"); if (prim != NULL) { unsigned short opc = (unsigned short)prim->custom.opc; unsigned short n; const T_FUNC *table; /* * This must be called for Partition Pool supervision. Will be replaced * by another macro some time. */ VSI_PPM_REC (&prim->custom, __FILE__, __LINE__); //PTRACE_IN (opc); switch (opc & OPC_MASK) { case DTI_DL: /* defined in prim.h */ table = dti_dl_table; n = TAB_SIZE (dti_dl_table); /* * to be able to distinguish DTI1/DTI2 opcodes, * the ones for DTI2 start at 0x50 */ opc -= 0x50; break; case DTI_UL: /* defined in prim.h */ table = dti_ul_table; n = TAB_SIZE (dti_ul_table); /* * to be able to distinguish DTI1/DTI2 opcodes, * the ones for DTI2 start at 0x50 */ opc -= 0x50; break; default: table = NULL; n = 0; break; } if (table != NULL) { if ((opc & PRM_MASK) < n) { table += opc & PRM_MASK; P_SDU(prim) = table->soff ? (T_sdu*) (((char*)&prim->data) + table->soff) : 0; P_LEN(prim) = table->size + sizeof (T_PRIM_HEADER); JUMP (table->func) (P2D(prim)); } else { primitive_not_supported (P2D(prim)); } return PEI_OK; } /* * primitive is not a GSM primitive - forward it to the environment */ if (opc & SYS_MASK) vsi_c_primitive (VSI_CALLER prim); else { PFREE (P2D(prim)); return PEI_ERROR; } } return PEI_OK; } /* +------------------------------------------------------------------------------ | Function : pei_init +------------------------------------------------------------------------------ | Description : Initialize Protocol Stack Entity | | Parameters : handle - task handle | | Return : PEI_OK - entity initialised | PEI_ERROR - entity not (yet) initialised +------------------------------------------------------------------------------ */ static short pei_init (T_HANDLE handle) { /* Initialize task handle */ m_handle = handle; mux_data.dti_state = CLOSED; /* * initialize dtilib for this entity */ mtst_hDTI = dti_init( 1, /* max simultaneous connections */ handle, DTI_NO_TRACE, pei_sig_callback ); if(!mtst_hDTI) return PEI_ERROR; /* set no suspend for us and TST */ vsi_trcsuspend ( VSI_CALLER vsi_c_open (0,"MTST"), 0); vsi_trcsuspend ( VSI_CALLER vsi_c_open (0,"TST"), 0); return (PEI_OK); } /* +------------------------------------------------------------------------------ | Function : pei_timeout +------------------------------------------------------------------------------ | Description : Process timeout. | | Parameters : index - timer index | | Return : PEI_OK - timeout processed | PEI_ERROR - timeout not processed +------------------------------------------------------------------------------ */ static short pei_timeout (unsigned short index) { //TRACE_FUNCTION ("pei_timeout"); /* Process timeout */ switch (index) { case 0: /* Call of timeout routine */ break; default: //TRACE_ERROR("Unknown Timeout"); return PEI_ERROR; } return PEI_OK; } /* +------------------------------------------------------------------------------ | Function : pei_signal +------------------------------------------------------------------------------ | Description : Process signal. | | Parameters : opc - signal operation code | data - pointer to primitive | | Return : PEI_OK - signal processed | PEI_ERROR - signal not processed +------------------------------------------------------------------------------ */ static short pei_signal (unsigned long opc, void* data) { //TRACE_FUNCTION ("pei_signal"); /* Process signal */ switch (opc) { default: //TRACE_ERROR("Unknown Signal OPC"); return PEI_ERROR; } return PEI_OK; } /* +------------------------------------------------------------------------------ | Function : pei_exit +------------------------------------------------------------------------------ | Description : Close Resources and terminate. | | Parameters : - | | Return : PEI_OK - exit sucessful +------------------------------------------------------------------------------ */ static short pei_exit (void) { //TRACE_FUNCTION ("pei_exit"); /* * Close communication channels */ if (mux_data.dti_state NEQ CLOSED) { dti_close ( mtst_hDTI, MTST_DTI_DN_INSTANCE, MTST_DTI_DN_INTERFACE, MTST_DTI_DN_CHANNEL, FALSE ); mux_data.dti_state = CLOSED; } /* * Shut down dtilib */ dti_deinit(mtst_hDTI); return PEI_OK; } /* for test only - begin */ #define MTST_TRACE 0x4f20 typedef struct { char str[80]; } T_MTST_TRACE; void trace_aci(const char* str) { PALLOC(ptr,MTST_TRACE); strcpy(ptr->str,str); PSEND(vsi_c_open(VSI_CALLER "MMI"), ptr); } /* for test only - end */ /* +------------------------------------------------------------------------------ | Function : pei_config +------------------------------------------------------------------------------ | Description : Dynamic Configuration. | | Parameters : Buffer - configuration string ( | to start: "<DTI-partner> <tui> <c_id>" | to stop: "STOP") | | Return : PEI_OK - sucessful | PEI_ERROR - not successful +------------------------------------------------------------------------------ */ static short pei_config (char *Buffer) { char token [10]; char peer_name [10]; USHORT len; ULONG link_id; //TRACE_FUNCTION ("pei_config"); //TRACE_FUNCTION (Buffer); if ( ConfigTimer ( VSI_CALLER Buffer, NULL ) == VSI_OK ) return PEI_OK; /* * further dynamic configuration */ /* interprete configuration string */ if (!(len = GetNextToken (Buffer, token, " #"))) { return DRV_INVALID_PARAMS; } else { Buffer += (len+1); } if (strcmp(token,"STOP")==0) { dti_close ( mtst_hDTI, MTST_DTI_DN_INSTANCE, MTST_DTI_DN_INTERFACE, MTST_DTI_DN_CHANNEL, FALSE ); mux_data.dti_state=CLOSED; mux_data.h_comm_mtst=VSI_ERROR; m_uart_ready=0; if (mux_data.send_data_buf_count>0) { /* clear send_buffer */ T_desc2 *d_new; T_desc2 *d=m_send_data; while (d) { d_new=(T_desc2 *)d->next; MFREE(d); d=d_new; } mux_data.send_data_buf_count=0; } return PEI_OK; } strcpy(peer_name, token); if (!(len = GetNextToken (Buffer, token, " #"))) { return DRV_INVALID_PARAMS; } else { Buffer += (len+1); } link_id=atoi(token); if( dti_open ( mtst_hDTI, MTST_DTI_DN_INSTANCE, MTST_DTI_DN_INTERFACE, MTST_DTI_DN_CHANNEL, 0, DTI_CHANNEL_TO_LOWER_LAYER, DTI_QUEUE_UNUSED, DTI_VERSION_10, (U8*)peer_name, link_id ) EQ FALSE) return DRV_INVALID_PARAMS; /* reset send_data_buf counter */ mux_data.send_data_buf_count=0; /* set internal communication handle */ while ( (mux_data.h_comm_mtst=vsi_c_open (0, "MTST")) == VSI_ERROR) { vsi_t_sleep(0,100); }; /* inform UART that we are ready to receive next data package */ { dti_start ( mtst_hDTI, MTST_DTI_DN_INSTANCE, MTST_DTI_DN_INTERFACE, MTST_DTI_DN_CHANNEL ); } return PEI_OK; } /* +------------------------------------------------------------------------------ | Function : pei_monitor +------------------------------------------------------------------------------ | Description : Monitoring of physical Parameters. | | Parameters : out_monitor - return the address of the data to be monitored | | Return : PEI_OK - sucessful (address in out_monitor is valid) | PEI_ERROR - not successful +------------------------------------------------------------------------------ */ static short pei_monitor (void ** out_monitor) { //TRACE_FUNCTION ("pei_monitor"); /* * Version = "0.S" (S = Step). */ m_mon.version = "MTST 1.0"; *out_monitor = &m_mon; return PEI_OK; } /*==== PUBLIC FUNCTIONS =====================================================*/ /* +------------------------------------------------------------------------------ | Function : pei_create +------------------------------------------------------------------------------ | Description : Create the Protocol Stack Entity. | | Parameters : info - Pointer to the structure of entity parameters | | Return : PEI_OK - entity created successfully | +------------------------------------------------------------------------------ */ SHORT pei_create (T_PEI_INFO const **info) { static T_PEI_INFO pei_info = { "MTST", /* name */ { /* pei-table */ pei_init, pei_exit, pei_primitive, pei_timeout, pei_signal, 0, pei_config, pei_monitor }, 1024, /* stack size */ 10, /* queue entries */ 100, /* priority (1->low, 255->high) */ 0, /* number of timers */ PASSIVE_BODY|COPY_BY_REF|TRC_NO_SUSPEND /* flags: bit 0 active(0) body/passive(1) */ }; /* bit 1 com by copy(0)/reference(1) */ //TRACE_FUNCTION ("pei_create"); /* * Close Resources if open */ if (!m_first) { pei_exit(); } m_first=0; /* * Export startup configuration data */ *info = &pei_info; return PEI_OK; } /***********+++++-----------------+++++++*******++----++**********/ /* +------------------------------------------------------------------------------ | Function : sig_dti_pei_tx_buffer_ready_ind +------------------------------------------------------------------------------ | Description : sent from UART to indicate that it is ready to | receive new data via DTI_DATA_REQ | | Parameters : | | Return : | +------------------------------------------------------------------------------ */ GLOBAL const void sig_dti_pei_tx_buffer_ready_ind () { m_uart_ready++; } /***********+++++-----------------+++++++*******++----++**********/ /* +------------------------------------------------------------------------------ | Function : dti_data_req +------------------------------------------------------------------------------ | Description : sent from TST to deliver new data to MTST | | Parameters : ptr - Pointer to the structure of the primitive | | Return : | +------------------------------------------------------------------------------ */ static void dti_data_req (T_DTI2_DATA_REQ *ptr) { T_desc2 *d=0; /* PPASS without traces */ T_DTI2_DATA_IND *prim = (T_DTI2_DATA_IND*)ptr; D_OPC(prim) = (DTI2_DATA_IND); if (!m_uart_ready) { if (mux_data.send_data_buf_count > MAX_SEND_BUF_COUNT-2) { /* free data */ T_desc2 *d_new; T_desc2 *d=(T_desc2 *)prim->desc_list2.first; while (d) { d_new=(T_desc2 *)d->next; MFREE(d); d=d_new; } if (mux_data.send_data_buf_count == MAX_SEND_BUF_COUNT) { /* buffer full -> free prim and exit */ PFREE(prim); return; } else { /* buffer almost full -> send SYST information */ char infostr[]="\x02T0036001FMTSTPCO ERROR: SEND-BUFFER FULL\x0a"; USHORT len=sizeof(infostr)-1; MALLOC(d,(USHORT)(sizeof(T_desc2)+len-1)); prim->desc_list2.first=(ULONG)d; prim->desc_list2.list_len=len; d->next = 0; d->len = len; d->size = len; d->offset = 0; memcpy(d->buffer,infostr,len); } } if (m_send_data) { /* find last send_data descriptor */ d=m_send_data; while (d->next) { d=(T_desc2 *)d->next; } /* concat new data */ d->next=prim->desc_list2.first; m_send_len+=prim->desc_list2.list_len; } else { m_send_data=(T_desc2 *)prim->desc_list2.first; d=m_send_data; while (d) { m_send_len+=d->len; d=(T_desc2 *)d->next; } } mux_data.send_data_buf_count++; /* free prim */ PFREE(prim); return; } m_uart_ready--; mux_data.send_data_buf_count=0; if (m_send_data) { /* find last data descriptor in stored data */ d=m_send_data; while (d->next) { d=(T_desc2 *)d->next; } /* concat new data to stored data */ d->next=prim->desc_list2.first; prim->desc_list2.first=(ULONG)m_send_data; prim->desc_list2.list_len+=m_send_len; /* clear send_data */ m_send_data=(T_desc2 *)0; m_send_len=0; } /* send prim */ dti_send_data ( mtst_hDTI, MTST_DTI_DN_INSTANCE, MTST_DTI_DN_INTERFACE, MTST_DTI_DN_CHANNEL, prim ); } /***********+++++-----------------+++++++*******++----++**********/ /* +------------------------------------------------------------------------------ | Function : sig_dti_pei_data_received_ind +------------------------------------------------------------------------------ | Description : sent from UART to deliver new data | | Parameters : ptr - Pointer to the structure of the primitive | | Return : | +------------------------------------------------------------------------------ */ GLOBAL const void sig_dti_pei_data_received_ind (T_DTI2_DATA_IND *ptr) { T_DTI2_DATA_IND *prim = ptr; /* prevent dtilib from automatically sending flow control primitives */ dti_stop ( mtst_hDTI, MTST_DTI_DN_INSTANCE, MTST_DTI_DN_INTERFACE, MTST_DTI_DN_CHANNEL ); if ( mux_data.EnabledSignalType & DRV_SIGTYPE_READ ) { m_signal.SignalType = DRV_SIGTYPE_READ; m_signal.DrvHandle = mux_data.Handle; mux_data.recv_data=(T_desc2 *)prim->desc_list2.first; (mux_data.Callback)( &m_signal ); } PFREE(prim); } /***********+++++-----------------+++++++*******++----++**********/ /* * dtilib wrapping and support functions */ /* +------------------------------------------------------------------------------ | Function : pei_dti_dti_connect_req +------------------------------------------------------------------------------ | PURPOSE : Call the process function dti_dti_connect_req +------------------------------------------------------------------------------ */ GLOBAL const void pei_dti_dti_connect_req ( T_DTI2_CONNECT_REQ *dti_connect_req ) { dti_dti_connect_req (mtst_hDTI, dti_connect_req); } /* +------------------------------------------------------------------------------ | Function : pei_dti_dti_connect_cnf +------------------------------------------------------------------------------ | PURPOSE : Call the process function dti_dti_connect_cnf +------------------------------------------------------------------------------ */ GLOBAL const void pei_dti_dti_connect_cnf ( T_DTI2_CONNECT_CNF *dti_connect_cnf ) { dti_dti_connect_cnf(mtst_hDTI, dti_connect_cnf); } /* +------------------------------------------------------------------------------ | Function : pei_dti_dti_connect_ind +------------------------------------------------------------------------------ | PURPOSE : Call the process function dti_dti_connect_ind +------------------------------------------------------------------------------ */ GLOBAL const void pei_dti_dti_connect_ind ( T_DTI2_CONNECT_IND *dti_connect_ind ) { dti_dti_connect_ind(mtst_hDTI, dti_connect_ind); } /* +------------------------------------------------------------------------------ | Function : pei_dti_dti_connect_res +------------------------------------------------------------------------------ | PURPOSE : Call the process function dti_dti_connect_res +------------------------------------------------------------------------------ */ GLOBAL const void pei_dti_dti_connect_res ( T_DTI2_CONNECT_RES *dti_connect_res ) { dti_dti_connect_res(mtst_hDTI, dti_connect_res); } /* +------------------------------------------------------------------------------ | Function : pei_dti_dti_disconnect_req +------------------------------------------------------------------------------ | PURPOSE : Call the process function dti_dti_disconnect_req +------------------------------------------------------------------------------ */ GLOBAL const void pei_dti_dti_disconnect_req ( T_DTI2_DISCONNECT_REQ *dti_disconnect_req ) { dti_dti_disconnect_req (mtst_hDTI, dti_disconnect_req); } /* +------------------------------------------------------------------------------ | Function : pei_dti_dti_disconnect_ind +------------------------------------------------------------------------------ | PURPOSE : Call the process function dti_dti_disconnect_ind +------------------------------------------------------------------------------ */ GLOBAL const void pei_dti_dti_disconnect_ind ( T_DTI2_DISCONNECT_IND *dti_disconnect_ind ) { dti_dti_disconnect_ind (mtst_hDTI, dti_disconnect_ind); } /* +------------------------------------------------------------------------------ | Function : pei_dti_dti_data_req +------------------------------------------------------------------------------ | PURPOSE : Call the process function dti_dti_data_req +------------------------------------------------------------------------------ */ GLOBAL const void pei_dti_dti_data_req ( T_DTI2_DATA_REQ *dti_data_req ) { dti_dti_data_req (mtst_hDTI, dti_data_req); } /* +------------------------------------------------------------------------------ | Function : pei_dti_dti_getdata_req +------------------------------------------------------------------------------ | PURPOSE : Call the process function dti_dti_data_req +------------------------------------------------------------------------------ */ GLOBAL const void pei_dti_dti_getdata_req ( T_DTI2_GETDATA_REQ *dti_getdata_req ) { dti_dti_getdata_req (mtst_hDTI, dti_getdata_req); } /* +------------------------------------------------------------------------------ | Function : pei_dti_dti_data_ind +------------------------------------------------------------------------------ | PURPOSE : Call the process function dti_dti_data_ind +------------------------------------------------------------------------------ */ GLOBAL const void pei_dti_dti_data_ind ( T_DTI2_DATA_IND *dti_data_ind ) { dti_dti_data_ind (mtst_hDTI, dti_data_ind); } /* +------------------------------------------------------------------------------ | Function : pei_dti_dti_ready_ind +------------------------------------------------------------------------------ | PURPOSE : Call the process function dti_dti_ready_ind +------------------------------------------------------------------------------ */ GLOBAL const void pei_dti_dti_ready_ind ( T_DTI2_READY_IND *dti_ready_ind ) { dti_dti_ready_ind (mtst_hDTI, dti_ready_ind); } #ifdef _SIMULATION_ /* +------------------------------------------------------------------------------ | Function : pei_dti_dti_data_test_req +------------------------------------------------------------------------------ | PURPOSE : Call the process function dti_dti_data_test_req +------------------------------------------------------------------------------ */ GLOBAL const void pei_dti_dti_data_test_req ( T_DTI2_DATA_TEST_REQ *dti_data_test_req ) { dti_dti_data_test_req (mtst_hDTI, dti_data_test_req); } /* +------------------------------------------------------------------------------ | Function : pei_dti_dti_data_test_ind +------------------------------------------------------------------------------ | PURPOSE : Call the process function dti_dti_data_test_ind +------------------------------------------------------------------------------ */ GLOBAL const void pei_dti_dti_data_test_ind ( T_DTI2_DATA_TEST_IND *dti_data_test_ind ) { dti_dti_data_test_ind (mtst_hDTI, dti_data_test_ind); } #endif /* _SIMULATION_ */ /* +------------------------------------------------------------------------------ | Function: pei_sig_callback +------------------------------------------------------------------------------ | PURPOSE : Callback function for DTILIB +------------------------------------------------------------------------------ */ GLOBAL void pei_sig_callback(U8 instance, U8 interfac, U8 channel, U8 reason, T_DTI2_DATA_IND *dti_data_ind) { TRACE_FUNCTION("pei_sig_callback"); #ifdef _SIMULATION_ if(instance NEQ MTST_DTI_UP_INSTANCE || interfac NEQ MTST_DTI_UP_INTERFACE || channel NEQ MTST_DTI_UP_CHANNEL) { TRACE_ERROR("[PEI_SIG_CALLBACK] invalid parameters!"); return; /* error, not found */ } #endif /* _SIMULATION_ */ if (mtst_hDTI NEQ D_NO_DATA_BASE) { switch (reason) { case DTI_REASON_CONNECTION_OPENED: sig_dti_pei_connection_opened_ind(); break; case DTI_REASON_CONNECTION_CLOSED: sig_dti_pei_connection_closed_ind(); break; case DTI_REASON_DATA_RECEIVED: /* * DTI2_DATA_IND is interpreted as DTI2_DATA_REQ */ PACCESS (dti_data_ind); sig_dti_pei_data_received_ind(dti_data_ind); break; case DTI_REASON_TX_BUFFER_FULL: sig_dti_pei_tx_buffer_full_ind(); break; case DTI_REASON_TX_BUFFER_READY: sig_dti_pei_tx_buffer_ready_ind(); break; default: TRACE_ERROR("unknown DTILIB reason parameter"); break; } /* end switch */ } /* end if */ else { TRACE_ERROR("Pointer to DTILIB database not existing"); } } /* pei_sig_callback() */ /*==== END OF FILE ==========================================================*/