FreeCalypso > hg > freecalypso-sw
view gsm-fw/gpf/tst_drv/tr2.c @ 513:383abdbc5d35
gsm-fw/bsp/armio.c: Compal configuration added
author | Michael Spacefalcon <msokolov@ivan.Harhan.ORG> |
---|---|
date | Wed, 02 Jul 2014 03:40:42 +0000 |
parents | ffb0442ffccf |
children |
line wrap: on
line source
/* +------------------------------------------------------------------------------ | File: tr.c +------------------------------------------------------------------------------ | Copyright 2004 Texas Instruments Deutschland, 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 Deutschland, AG. +----------------------------------------------------------------------------- | Purpose : This Modul contains the TR driver +----------------------------------------------------------------------------- */ #ifndef __TR_C__ #define __TR_C__ #endif #include <string.h> #include "gpfconf.h" #include "typedefs.h" #include "gdi.h" #include "vsi.h" #include "os.h" #ifdef _TOOLS_ #include <stdio.h> #include "glob_defs.h" #include "tstdriver.h" #include "frame.h" #include "frame_const.h" #include "printtofile.h" #endif /* _TOOLS_ */ #include "tstheader.h" #include "tst_mux.h" /*==== TYPES ======================================================*/ typedef struct { T_VOID_STRUCT *RcvBuffer; USHORT Handle; USHORT EnabledSignalType; T_DRV_CB_FUNC Callback; USHORT config; UBYTE rcv_state; UBYTE idle_state; } T_TR_DATA; /*==== CONSTANTS ==================================================*/ #define ALLOWED_TR_SIGNALS (DRV_SIGTYPE_READ|DRV_SIGTYPE_CONNECT|DRV_SIGTYPE_DISCONNECT) #define STX 0x02 #define TI_RIV_ID 0x11 #define TI_L1_ID 0x12 #define TI_L23_ID 0x13 #define TI_STX 0x02 #define TI_ESC 0x10 #define CHAR_ABORT 'A' #define DATA_SEGMENT_SIZE 223 #define WAIT_FOR_STX 0 #define WAIT_FOR_IDENT 1 #define WAIT_FOR_TIMESTAMP 2 #define WAIT_FOR_LENGTH 3 #define WAIT_FOR_SND 4 #define WAIT_FOR_RCV 5 #define WAIT_FOR_DATA 6 #define WAIT_FOR_CR 7 #define WAIT_FOR_TI_ID 8 #define WAIT_FOR_TI_LEN_0 9 #define WAIT_FOR_TI_LEN_1 10 #define WAIT_FOR_TI_LEN_2 11 #define WAIT_FOR_LENGTH1 12 #define WAIT_FOR_LENGTH2 13 #define WAIT_FOR_RAW_TI_S 14 #define WAIT_FOR_RAW_TI_ID 15 #define WAIT_FOR_RAW_TI_E 16 #define WAIT_FOR_MUX_START_STX 1 #define WAIT_FOR_MUX_CHAN_ID 2 #define WAIT_FOR_MUX_END_STX 3 #define STX_LF_MODE 0x0001 #define TI_TRC_MODE 0x0002 #define TI_RAW_TRC_MODE 0x0004 /*==== EXTERNALS ==================================================*/ extern ULONG TR_RcvBufferSize; extern ULONG TR_MaxInd; extern USHORT ext_data_pool_handle; extern T_TST_MUX_CHANNEL tst_mux_chan_struct[]; /*==== VARIABLES ==================================================*/ #ifndef RUN_INT_RAM #ifndef _TARGET_ long int accessNum = 0; #endif T_TR_DATA TR_Data; static char *TR_RcvBuffer; static ULONG TR_EndInd; static ULONG TR_WrInd; static ULONG TR_RdInd; static ULONG MessageLength; static union { unsigned short int val; char part[2]; }tst_trailer_size; #else extern T_TR_DATA TR_Data; #endif #ifdef _TOOLS_ static int ti_id_not_found; static int ti_esc_skipped; extern int tst_message_received; #else extern ULONG MaxPrimPartSize; #endif /*==== FUNCTIONS ==================================================*/ #ifndef RUN_INT_RAM USHORT TR_Write ( void *Buffer, ULONG *BytesToWrite ); #endif #ifndef RUN_INT_RAM /* +--------------------------------------------------------------------+ | PROJECT : GSM-Frame (8415) MODULE : TR | | STATE : code ROUTINE : TR_Exit | +--------------------------------------------------------------------+ PURPOSE : exit a driver */ LOCAL void TR_Exit ( void ) { os_DeallocateMemory ( 0, TR_Data.RcvBuffer ); } #endif #ifndef RUN_INT_RAM /* +--------------------------------------------------------------------+ | PROJECT : GSM-Frame (8415) MODULE : TR | | STATE : code ROUTINE : TR_Read | +--------------------------------------------------------------------+ PURPOSE : read data from driver */ LOCAL USHORT TR_Read ( void *Buffer, ULONG *BytesToRead ) { ULONG Space = TR_EndInd - (TR_RdInd & TR_MaxInd); static ULONG bytes_read; if ( *BytesToRead == 0 ) { *BytesToRead = MessageLength; bytes_read = 0; } else { if ( Space > *BytesToRead ) { memcpy ( Buffer, &TR_RcvBuffer[TR_RdInd&TR_MaxInd], *BytesToRead ); bytes_read += *BytesToRead; } else { memcpy ( Buffer, &TR_RcvBuffer[TR_RdInd&TR_MaxInd], (unsigned int)Space ); *BytesToRead = Space; bytes_read += Space; } TR_RdInd += *BytesToRead; if ( TR_Data.config & STX_LF_MODE ) if ( bytes_read == MessageLength ) TR_RdInd++; /* skip th LF, its not read by the TIF driver */ } return DRV_OK; } #endif #ifndef RUN_INT_RAM /* +--------------------------------------------------------------------+ | PROJECT : GSM-Frame (8415) MODULE : TR | | STATE : code ROUTINE : TR_Write | +--------------------------------------------------------------------+ PURPOSE : write data to driver */ USHORT TR_Write ( void *Buffer, ULONG *BytesToWrite ) { char *snd_ptr = (char*)Buffer; ULONG btw; char ti_mode_header[2]; ti_mode_header[0] = TI_STX; ti_mode_header[1] = TI_L23_ID; #ifdef _TOOLS_ btw=(*BytesToWrite) & ~PRIM_FLAG_MASK; #else btw=(*BytesToWrite); #endif #ifdef _TOOLS_ if (TR_Data.config & TI_RAW_TRC_MODE) { ULONG full_btw, segment_size; /*lint -e813, suppress Info 813: auto variable 'osver' has size '148' */ char segment[DATA_SEGMENT_SIZE*2+3]; /*lint +e813 */ ULONG q; full_btw=btw; while (full_btw) { btw= (full_btw>DATA_SEGMENT_SIZE) ? DATA_SEGMENT_SIZE : full_btw; /* fill in leading bytes */ segment_size=0; segment[segment_size++]=TI_STX; segment[segment_size++]=TI_L23_ID; /* fill in payload bytes */ for (q=0; q<btw; q++) { /* evtl insert TI_ESC characters */ if (snd_ptr[q]==TI_STX || snd_ptr[q]==TI_ESC) { segment[segment_size++]=TI_ESC; } segment[segment_size++]=snd_ptr[q]; } /* fill in trailing bytes */ segment[segment_size++]=TI_STX; /* write segment */ if ( vsi_d_write ( TR_Data.Handle, 0, (void*)segment, segment_size) != VSI_OK ) { return DRV_INTERNAL_ERROR; } full_btw=full_btw-btw; if (full_btw) { snd_ptr=snd_ptr+btw; /* let the ti driver on target handle the byte-block */ vsi_t_sleep ( 0, 100 ); } } return DRV_OK; } #endif /* _TOOLS_ */ /* * To avoid reallocation and memcpy() the STX is written in front of the passed * data. This works as long as the sizeof(T_SYST_HEADER) is bigger than the header * sent via the test interface. */ if ( TR_Data.config & STX_LF_MODE ) { btw=(*BytesToWrite) & ~PRIM_FLAG_MASK; /* not really generic, but we need to mask here */ /* we assume that the TITRC driver is not below */ if ( *BytesToWrite & PRIM_DATA_FLAG ) /* primitive data -> LF at the end */ { *(snd_ptr+btw) = '\n'; btw = btw + 1; } else if ( *BytesToWrite & PRIM_HEADER_FLAG ) /* primitive header -> add STX in front */ { snd_ptr--; /* it is posible to add STX because the first */ *snd_ptr = STX; /* byte of TST_SMALL_HEADER/TST_BIG_HEADER in unused */ btw = btw + 1; } else /* trace -> STX in front, LF at the end */ { *(snd_ptr+btw) = '\n'; snd_ptr--; *snd_ptr = STX; btw = btw + 2; } } /* Add mux STX and channel id if not already in */ if (TR_Data.config & TI_RAW_TRC_MODE && *snd_ptr != TI_STX ) { if ( vsi_d_write ( TR_Data.Handle, 0, (void*)ti_mode_header, 2) != VSI_OK ) { return DRV_INTERNAL_ERROR; } } if ( vsi_d_write ( TR_Data.Handle, 0, (void*)snd_ptr, btw) != VSI_OK ) { return DRV_INTERNAL_ERROR; } return DRV_OK; } #endif #ifndef RUN_INT_RAM /* +--------------------------------------------------------------------+ | PROJECT : GSM-Frame (8415) MODULE : TR | | STATE : code ROUTINE : TR_SetSignal | +--------------------------------------------------------------------+ PURPOSE : enable signal for the driver */ LOCAL USHORT TR_SetSignal ( USHORT SignalType ) { if ( !(SignalType & ALLOWED_TR_SIGNALS) ) return DRV_INVALID_PARAMS; else TR_Data.EnabledSignalType |= SignalType; return DRV_OK; } #endif #ifndef RUN_INT_RAM /* +--------------------------------------------------------------------+ | PROJECT : GSM-Frame (8415) MODULE : TR | | STATE : code ROUTINE : TR_ResetSignal | +--------------------------------------------------------------------+ PURPOSE : disable signal for the driver */ LOCAL USHORT TR_ResetSignal ( USHORT SignalType ) { if ( !(SignalType & ALLOWED_TR_SIGNALS) ) return DRV_INVALID_PARAMS; else TR_Data.EnabledSignalType &= ~SignalType; return DRV_OK; } #endif #ifndef RUN_INT_RAM /* +--------------------------------------------------------------------+ | PROJECT : GSM-Frame (8415) MODULE : TR | | STATE : code ROUTINE : TR_SetConfig | +--------------------------------------------------------------------+ PURPOSE : set configuration for the driver */ LOCAL USHORT TR_SetConfig ( char *Buffer ) { if ( !strcmp ( TR_STX_LF, Buffer ) ) { TR_Data.config = STX_LF_MODE; TR_Data.rcv_state = WAIT_FOR_STX; TR_Data.idle_state = WAIT_FOR_STX; #ifdef _TOOLS_ printf ("TR: STX mode enabled\n"); #endif /* _TOOLS_ */ return DRV_OK; } #ifdef _TOOLS_ else if ( !strcmp ( DRV_TI_MODE, Buffer ) ) { TR_Data.config = TI_TRC_MODE; TR_Data.rcv_state = WAIT_FOR_TI_ID; TR_Data.idle_state = WAIT_FOR_TI_ID; printf ("TR: TI mode enabled\n"); return DRV_OK; } #endif /* _TOOLS_ */ else if ( !strcmp ( DRV_RAW_TI_MODE, Buffer ) ) { TR_Data.config = TI_RAW_TRC_MODE; TR_Data.rcv_state = WAIT_FOR_RAW_TI_S; TR_Data.idle_state = WAIT_FOR_RAW_TI_S; #ifdef _TOOLS_ printf ("TR: raw TI mode enabled\n"); #endif return DRV_OK; } else if ( !strcmp ( DRV_DEFAULT, Buffer ) ) { TR_Data.config = 0; TR_Data.rcv_state = WAIT_FOR_IDENT; TR_Data.idle_state = WAIT_FOR_IDENT; #ifdef _TOOLS_ accessNum++; PrintToFile("TR: default mode selected __________________________ (%d)\n", accessNum); #endif /* _TOOLS_ */ return DRV_OK; } else return DRV_INVALID_PARAMS; } #endif #ifndef RUN_INT_RAM /* +--------------------------------------------------------------------+ | PROJECT : GSM-Frame (8415) MODULE : TR | | STATE : code ROUTINE : Callback | +--------------------------------------------------------------------+ PURPOSE : callback function of the driver */ /*lint -esym(644,infoByteAddr) suppress warning -- Symbol 'infoByteAddr' may not have been initialized */ LOCAL void TR_Callback ( T_DRV_SIGNAL *Signal ) { static T_DRV_SIGNAL TR_Signal; static USHORT counter = 0; static char* infoByteAddr; int tr_abort_discard; int tr_abort; unsigned char c; ULONG i; ULONG BytesToRead; ULONG BytesRead = 0; ULONG TR_WorkInd; ULONG Bytes = 0; USHORT continue_read; //#ifdef _TOOLS_ static unsigned int ti_len = 0; static char ti_id = 0; static int sigtype = 0; static int lf_found; static int crlf_found; static U8 mux_chan_id; static U8 mux_chan = 0; static U8 mux_status = WAIT_FOR_MUX_CHAN_ID; static int stuffed_byte; //#endif tr_abort_discard = 0; tr_abort = 0; TR_Signal.SignalType = 0; switch ( Signal->SignalType ) { case DRV_SIGTYPE_READ: BytesToRead = TR_EndInd - TR_WrInd; TR_WorkInd = TR_WrInd; do { Bytes = 0; do { continue_read = 0; /* * write counter must not overtake the read counter. If more bytes to be read * than space available, then process the bytes in the buffer first and then * continue to store new data in the TR_RcvBuffer. */ if ( TR_WrInd >= (TR_RdInd&TR_MaxInd) ) BytesToRead = TR_EndInd - TR_WrInd; else BytesToRead = (TR_RdInd&TR_MaxInd) - TR_WrInd; BytesRead = BytesToRead; vsi_d_read ( TR_Data.Handle, 0, (void*)&TR_RcvBuffer[TR_WrInd], &BytesRead ); Bytes += BytesRead; if ( BytesRead < BytesToRead ) { TR_WrInd += BytesRead; } else { if ( TR_WrInd >= (TR_RdInd&TR_MaxInd) ) TR_WrInd = 0; else { TR_WrInd += BytesRead; continue_read = 1; break; } } } while ( BytesRead != TR_RcvBufferSize && BytesRead == BytesToRead ); if ( Bytes ) { UBYTE cMasked; i=0; while (i++ < Bytes) { c = TR_RcvBuffer[(TR_WorkInd++) & TR_MaxInd]; #ifdef _TOOLS_ if (TR_Data.config & TI_RAW_TRC_MODE) /* we are receiving rawly in TI mode */ { if (!ti_esc_skipped && c==TI_ESC) { /* the TI driver has inserted an TI_ESC -> skip it */ ULONG q; for (q=TR_WorkInd-1; q>TR_RdInd; q--) { TR_RcvBuffer[q & TR_MaxInd]=TR_RcvBuffer[(q-1) & TR_MaxInd]; } TR_RdInd++; ti_esc_skipped=1; continue; } ti_esc_skipped=0; } #endif /* _TOOLS_ */ if ( tr_abort_discard == 1 ) { TR_RdInd++; continue; } switch (TR_Data.rcv_state) { case WAIT_FOR_STX: if (c == STX) { #ifdef _TOOLS_ ti_len=0; #endif TR_Data.rcv_state = WAIT_FOR_IDENT; TR_RdInd = TR_WorkInd; /* do not pass the STX to TIF */ } else TR_RdInd++; break; //#ifdef _TOOLS_ case WAIT_FOR_RAW_TI_S: if (c==TI_STX) { TR_Data.rcv_state=WAIT_FOR_RAW_TI_ID; TR_RdInd = TR_WorkInd; /* do not read TI_STX */ } break; case WAIT_FOR_RAW_TI_ID: if (c==TI_STX) { // last TI_STX was end ID -> ignore this start ID } else if (c==TI_L23_ID) { ti_len = 0; ti_id = c; TR_Data.rcv_state=WAIT_FOR_IDENT; } else if (c == TI_L1_ID || c == TI_RIV_ID) { ti_len = 0; ti_id = c; if (ti_id == TI_L1_ID) sigtype = DRV_SIGTYPE_READ_L1; if (ti_id == TI_RIV_ID) sigtype = DRV_SIGTYPE_READ_RIV; counter = 0; TR_RdInd = TR_WorkInd; /* do not read ti_id */ crlf_found = 0; lf_found = 0; TR_Data.rcv_state=WAIT_FOR_RAW_TI_E; } else { mux_chan_id = c; if ( mux_status == WAIT_FOR_MUX_CHAN_ID ) { for ( mux_chan = 0; mux_chan < MAX_TST_CHANNEL; mux_chan++ ) { if ( tst_mux_chan_struct[mux_chan].channel_id == c ) { mux_status = WAIT_FOR_MUX_END_STX; tst_mux_chan_struct[mux_chan].rcv_data_ptr = &TR_RcvBuffer[(TR_WorkInd) & TR_MaxInd]; tst_mux_chan_struct[mux_chan].rcv_data_size = 0; stuffed_byte = 0; TR_RdInd = TR_WorkInd; /* do not read id */ TR_Data.rcv_state=WAIT_FOR_RAW_TI_E; break; } } } } break; #ifdef _TOOLS_ case WAIT_FOR_TI_ID: /* skip TI ID byte */ if (c == TI_L23_ID || c == TI_L1_ID || c == TI_RIV_ID) { ti_len = 0; ti_id = c; TR_Data.rcv_state = WAIT_FOR_TI_LEN_0; } else { ti_id_not_found = 1; } break; case WAIT_FOR_TI_LEN_0: /* * skip length * if length byte == 0 then the next 2 bytes are the length * (patch to handle messages longer than 255 bytes) */ if ( c != 0 ) { if (ti_id == TI_L23_ID) TR_Data.rcv_state = WAIT_FOR_IDENT; if (ti_id == TI_L1_ID || ti_id == TI_RIV_ID) { if (ti_id == TI_L1_ID) sigtype = DRV_SIGTYPE_READ_L1; if (ti_id == TI_RIV_ID) sigtype = DRV_SIGTYPE_READ_RIV; TR_Data.rcv_state = WAIT_FOR_DATA; counter = 0; TR_RdInd += 2; /* do not read ti_id and length */ crlf_found = 0; lf_found = 0; } ti_len = c & 0xff; } else TR_Data.rcv_state = WAIT_FOR_TI_LEN_1; break; case WAIT_FOR_TI_LEN_1: ti_len = c ; TR_Data.rcv_state = WAIT_FOR_TI_LEN_2; break; case WAIT_FOR_TI_LEN_2: ti_len |= c << 8; TR_Data.rcv_state = WAIT_FOR_IDENT; break; #endif /* ifdef _TOOLS_ */ case WAIT_FOR_IDENT: infoByteAddr = &TR_RcvBuffer[(TR_WorkInd - 1) & TR_MaxInd]; /* analyze INFO Byte */ cMasked = (c & HDR_VERSION_MASK); #ifdef _TOOLS_ if (cMasked == HDR_VALID_VERSION_0) { i--; TR_WorkInd--; printf ("TR: changed to OLD header format automatically\n"); // tst_drv_write ( NO_TASK, SYS_MASK, FRM_TST_NAME, (char*)SYSPRIM_GET_STACK_TIME ); break; } /* check for lost bytes on interface */ if (TR_Data.config & TI_TRC_MODE || TR_Data.config & TI_RAW_TRC_MODE) /* we are receiving from a arm 7 TARGET */ { /* TR_WorkInd refs position of first size byte now */ if (ti_id_not_found) { *infoByteAddr = (( *infoByteAddr & ~HDR_IDENT_MASK) | IDENT_ABORT); /* mark as bad */ } } #endif /* ifdef _TOOLS_ */ cMasked = (c & HDR_IDENT_MASK); if (((cMasked == IDENT_PS_PRIM) || (cMasked == IDENT_SYS_PRIM) || (cMasked == IDENT_ABORT) || (cMasked == IDENT_TRACE)) && ((c != PROT_PRIM_ID) && (c != PROT_PRIM_ID_32BIT) && (c != SYS_PRIM_ID) && (c != TRACE_ID)) ) { /* Hey fine, everything went OK! */ TR_Data.rcv_state = WAIT_FOR_LENGTH1; } else { /* we have to fake a length for abort trace */ tst_trailer_size.part[0] = TST_HEADER_LEADING_FIELDS; tst_trailer_size.part[1] = 0; MessageLength = tst_trailer_size.val + TST_HEADER_TRAILING_FIELDS; *infoByteAddr = (( *infoByteAddr & ~HDR_IDENT_MASK) | IDENT_ABORT); /* mark as bad */ counter = tst_trailer_size.val; /* don't let us read all the following bytes before let TIF tracing ABORT */ TR_Data.rcv_state = WAIT_FOR_DATA; tr_abort = 1; } TR_RdInd = TR_WorkInd - 1; /* skip all preceeding interface sync bytes before triggering TIF */ break; case WAIT_FOR_LENGTH1: /* the use of the union does rely on identical byte sex! */ #ifdef _SOLARIS_ /* temporary hack */ tst_trailer_size.part[1] = c; #else tst_trailer_size.part[0] = c; #endif TR_Data.rcv_state = WAIT_FOR_LENGTH2; break; case WAIT_FOR_LENGTH2: #ifdef _SOLARIS_ /* temporary hack */ tst_trailer_size.part[0] = c; #else tst_trailer_size.part[1] = c; #endif /* Bytes after size + bytes till size (inclusive) */ MessageLength = tst_trailer_size.val + TST_HEADER_LEADING_FIELDS; #ifdef _TOOLS_ /* In case of a lost character the two length information elements mismatch. */ if ( (ti_len != 0) && (tst_trailer_size.val != (ti_len - 3)) ) { tst_trailer_size.val = ti_len - 3; } ti_len = 0; if ((tst_trailer_size.val - TST_HEADER_TRAILING_FIELDS) > (unsigned short int)(MAX_PRIM_PARTITION_SIZE - sizeof(T_PRIM_HEADER) - sizeof(T_S_HEADER))) { *infoByteAddr = (( *infoByteAddr & ~HDR_IDENT_MASK) | IDENT_ABORT); /* mark as bad */ tst_trailer_size.val = (MAX_PRIM_PARTITION_SIZE - sizeof(T_PRIM_HEADER) - sizeof(T_S_HEADER) -TST_HEADER_TRAILING_FIELDS); counter = tst_trailer_size.val; /* don't let us read all the following bytes before let TIF tracing ABORT */ tr_abort = 1; } #else if ((tst_trailer_size.val - TST_HEADER_TRAILING_FIELDS) > (unsigned short int)(MaxPrimPartSize - sizeof(T_PRIM_HEADER) - sizeof(T_S_HEADER))) { *infoByteAddr = (( *infoByteAddr & ~HDR_IDENT_MASK) | IDENT_ABORT); /* mark as bad */ tst_trailer_size.val = (USHORT)(MaxPrimPartSize - sizeof(T_PRIM_HEADER) - sizeof(T_S_HEADER) -TST_HEADER_TRAILING_FIELDS); counter = tst_trailer_size.val; /* don't let us read all the following bytes before let TIF tracing ABORT */ tr_abort = 1; } #endif TR_Data.rcv_state = WAIT_FOR_DATA; counter = 0; break; case WAIT_FOR_RAW_TI_E: if ( mux_status == WAIT_FOR_MUX_END_STX ) { if ( stuffed_byte ) { stuffed_byte = 0; tst_mux_chan_struct[mux_chan].rcv_data_size++; } else { if ( c != TI_STX ) { if ( c == 0x10 ) { stuffed_byte = 1; } tst_mux_chan_struct[mux_chan].rcv_data_size++; } else { tst_mux_callback (mux_chan,tst_mux_chan_struct[mux_chan].rcv_data_ptr, tst_mux_chan_struct[mux_chan].rcv_data_size); mux_status = WAIT_FOR_MUX_CHAN_ID; MessageLength = tst_mux_chan_struct[mux_chan].rcv_data_size; TR_Data.rcv_state = WAIT_FOR_RAW_TI_S; } } } #ifdef _TOOLS_ if (c!=TI_STX) { if ( counter == 0 && c == 0x0a ) { lf_found = 1; } if ( lf_found && counter == 1 && c == 0x0d) { crlf_found = 1; } counter++; } else { if ( TR_Data.EnabledSignalType & DRV_SIGTYPE_READ ) { ti_len=counter; if ( crlf_found == 1 ) { ti_len -= 2; TR_RdInd += 2; /* do not read CR and LF at the beginning */ } MessageLength = ti_len; TR_Signal.SignalType = sigtype; TR_Signal.DrvHandle = TR_Data.Handle; (TR_Data.Callback)( &TR_Signal ); } TR_Data.rcv_state = TR_Data.idle_state; } #endif break; case WAIT_FOR_DATA: #ifdef _TOOLS_ if ( ti_len ) { if ( counter == 0 && c == 0x0a ) { lf_found = 1; } if ( lf_found && counter == 1 && c == 0x0d) { crlf_found = 1; } if ( ++counter >= ti_len ) { if ( TR_Data.EnabledSignalType & DRV_SIGTYPE_READ ) { if ( crlf_found == 1 ) { ti_len -= 2; TR_RdInd += 2; /* do not read CR and LF at the beginning */ } MessageLength = ti_len; TR_Signal.SignalType = sigtype; TR_Signal.DrvHandle = TR_Data.Handle; (TR_Data.Callback)( &TR_Signal ); } TR_Data.rcv_state = TR_Data.idle_state; } break; } #endif if (++counter >= tst_trailer_size.val) /* If all went OK up to now we have to read all remaining bytes from the buffer each for each */ { if (TR_Data.config & STX_LF_MODE ) { TR_Data.rcv_state = WAIT_FOR_CR; break; } else { if ( TR_Data.EnabledSignalType & DRV_SIGTYPE_READ ) { #ifdef _TOOLS_ tst_message_received = 1; #endif TR_Signal.SignalType = DRV_SIGTYPE_READ; TR_Signal.DrvHandle = TR_Data.Handle; (TR_Data.Callback)( &TR_Signal ); } TR_Data.rcv_state = TR_Data.idle_state; tst_trailer_size.val = 0; if ( tr_abort == 1 ) /* marked as bad */ tr_abort_discard = 1; #ifdef _TOOLS_ ti_id_not_found = 0; #endif } } break; case WAIT_FOR_CR: #ifdef _TOOLS_ /* check for lost bytes on interface */ if (TR_Data.config & STX_LF_MODE ) /* we are receiving from a arm 9 TARGET or Windows stack configured stx */ { if (c != '\n') { *infoByteAddr = (( *infoByteAddr & ~HDR_IDENT_MASK) | IDENT_ABORT); /* mark as bad */ } } #endif /* _TOOLS_ check for lost bytes on interface */ if ( TR_Data.EnabledSignalType & DRV_SIGTYPE_READ ) { #ifdef _TOOLS_ tst_message_received = 1; #endif TR_Signal.SignalType = DRV_SIGTYPE_READ; TR_Signal.DrvHandle = TR_Data.Handle; (TR_Data.Callback)( &TR_Signal ); } TR_Data.rcv_state = TR_Data.idle_state; tst_trailer_size.val = 0; if ( tr_abort == 1 ) /* marked as bad */ tr_abort_discard = 1; break; default: break; } } /* while (i++ < Bytes) */ } /* if Bytes loop */ } while ( continue_read == 1 ); break; case DRV_SIGTYPE_CONNECT: case DRV_SIGTYPE_DISCONNECT: if ( TR_Data.EnabledSignalType & Signal->SignalType ) { TR_Signal.SignalType = Signal->SignalType; TR_Signal.DrvHandle = TR_Data.Handle; (TR_Data.Callback)( &TR_Signal ); } break; default: break; } } #endif #ifndef RUN_INT_RAM /* +--------------------------------------------------------------------+ | PROJECT : GSM-Frame (8415) MODULE : TR | | STATE : code ROUTINE : TR_Init | +--------------------------------------------------------------------+ PURPOSE : initialize driver */ USHORT TR_Init ( USHORT DrvHandle, T_DRV_CB_FUNC CallbackFunc, T_DRV_EXPORT const **DrvInfo ) { USHORT j; ULONG size = 0; static const T_DRV_EXPORT TR_Info = { "TR", 0, { #ifdef _TOOLS_ TR_Init, #endif TR_Exit, TR_Read, TR_Write, NULL, NULL, NULL, TR_SetSignal, TR_ResetSignal, TR_SetConfig, NULL, TR_Callback, } }; TR_Data.Handle = DrvHandle; TR_Data.EnabledSignalType = 0; TR_Data.config = 0; TR_Data.rcv_state = WAIT_FOR_IDENT; TR_Data.idle_state = WAIT_FOR_IDENT; TR_Data.Callback = CallbackFunc; *DrvInfo = &TR_Info; /* * TR_RcvBufferSize must be a power of 2 for proper wrap-around */ #ifndef _TOOLS_ TR_RcvBufferSize = MaxPrimPartSize; #endif j = 0; do { if ( (ULONG)(1 << j) >= TR_RcvBufferSize ) /* Size must be a power of 2 */ { size = 1 << j; break; } else j++; } while ( size < 0xffff ); TR_RcvBufferSize = size; TR_MaxInd = TR_RcvBufferSize - 1; if ( os_AllocateMemory ( NO_TASK, &TR_Data.RcvBuffer, (ULONG)TR_RcvBufferSize, OS_NO_SUSPEND, ext_data_pool_handle ) != OS_OK ) { vsi_o_assert ( NO_TASK, OS_SYST_ERR_NO_MEMORY, __FILE__, __LINE__, "No memory available in TR driver, TR_RcvBufferSize = %d", TR_RcvBufferSize ); return DRV_INITFAILURE; } TR_RcvBuffer = (char*)TR_Data.RcvBuffer; TR_EndInd = TR_RcvBufferSize; TR_WrInd = 0; TR_RdInd = 0; tst_trailer_size.val = 0; #ifdef _TOOLS_ ti_id_not_found = 0; ti_esc_skipped = 0; #endif return DRV_OK; } #endif