FreeCalypso > hg > fc-tourmaline
view src/g23m-aci/uart/uart_dtxs.c @ 223:740a8e8fc9d7
startup sync logic rework for the new PWON button boot scheme
Previously we added logic to the MMI task to hold off PEI init until
R2D is running, and then extended that condition to wait for FCHG
init too. However, the dependencies of MMI upon R2D and FCHG don't
start until mmiInit(), and that call is driven by Switch_ON() code,
hence the wait for R2D and FCHG init can be made in that code path
instead of the MMI task. Furthermore, with our new way of signaling
PWON button boot to MMI, we need a new wait to ensure that the MMI
task is up - previously this assurance was provided by the wait for
Kp pointers to be set.
Solution: revert our previous PEI init hold-off additions to MMI,
add a new flag indicating MMI task init done, and put the combined
wait for all needed conditions into our new PWON button boot code
in power.c.
| author | Mychaela Falconia <falcon@freecalypso.org> |
|---|---|
| date | Tue, 27 Apr 2021 06:24:52 +0000 |
| parents | fa8dc04885d8 |
| children |
line wrap: on
line source
/* +----------------------------------------------------------------------------- | Project : | Modul : +----------------------------------------------------------------------------- | 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 modul is part of the entity UART and implements all | functions to handles the incoming process internal signals as | described in the SDL-documentation (DTX-statemachine) +----------------------------------------------------------------------------- */ #ifndef UART_DTXS_C #define UART_DTXS_C #endif /* !UART_DTXS_C */ #define ENTITY_UART /*==== INCLUDES =============================================================*/ #ifdef _SIMULATION_ #include <stdio.h> #endif #ifdef WIN32 #include "nucleus.h" #endif /* WIN32 */ #include "typedefs.h" /* to get Condat data types */ #include "vsi.h" /* to get a lot of macros */ #include "macdef.h" /* to get a lot of macros */ #include "custom.h" #include "gsm.h" /* to get a lot of macros */ #include "cnf_uart.h" /* to get cnf-definitions */ #include "mon_uart.h" /* to get mon-definitions */ #include "prim.h" /* to get the definitions of used SAP and directions */ #include "dti.h" /* to get dti lib */ #include "pei.h" /* to get PEI interface */ #ifdef FF_MULTI_PORT #include "gsi.h" /* to get definitions of serial driver */ #else /* FF_MULTI_PORT */ #ifdef _TARGET_ #include "uart/serialswitch.h" #include "uart/traceswitch.h" #else /* _TARGET_ */ #include "serial_dat.h" /* to get definitions of serial driver */ #endif /* _TARGET_ */ #endif /* FF_MULTI_PORT */ #include "uart.h" /* to get the global entity definitions */ #include "uart_dtxf.h" /* to get DTX function definitions */ #include "uart_dtxp.h" /* to get DTX primitive definitions */ #include "uart_kers.h" /* to get KER signal definitions */ #include "uart_rts.h" /* to get RT signal definitions */ #ifdef FF_MULTI_PORT #include "uart_prxs.h" /* to get signal definitions for service TX */ #else /* FF_MULTI_PORT */ #include "uart_rxs.h" /* to get TX signal definitions */ #endif /* FF_MULTI_PORT */ #include <string.h> /* JK, delete warnings: to get memmove, memcpy */ /*==== CONST ================================================================*/ /*==== LOCAL VARS ===========================================================*/ /*==== PRIVATE FUNCTIONS ====================================================*/ /*==== PUBLIC FUNCTIONS =====================================================*/ /* +------------------------------------------------------------------------------ | Function : sig_ker_dtx_ready_mode_req +------------------------------------------------------------------------------ | Description : Handles the internal signal SIG_KER_DTX_READY_MODE_REQ | | Parameters : dlc_instance - dlc instance wich belongs to this DTX instance | +------------------------------------------------------------------------------ */ GLOBAL void sig_ker_dtx_ready_mode_req (UBYTE dlc_instance) { TRACE_ISIG( "sig_ker_dtx_ready_mode_req" ); uart_data->dtx->dlc_instance = dlc_instance; switch( GET_STATE( UART_SERVICE_DTX ) ) { case DTX_DEAD: SET_STATE( UART_SERVICE_DTX, DTX_NOT_READY ); /* * reset line states */ uart_data->dtx->st_flow = DTI_FLOW_ON; uart_data->dtx->st_line_sa = DTI_SA_ON; uart_data->dtx->st_line_sb = DTI_SB_ON; uart_data->dtx->st_break_len = DTI_BREAK_OFF; uart_data->dtx->detect_escape = TRUE; uart_data->dtx->data_flow = UART_FLOW_ENABLED; if(uart_data->dtx->receiving_state EQ UART_DTX_NOT_RECEIVING) { /* * reset escape sequence detection */ dtx_set_esd_state( UART_ESD_NULL ); uart_data->dtx->detect_escape = TRUE; if(vsi_t_time (VSI_CALLER &(uart_data->dtx->esd_guard_time)) NEQ VSI_OK) { TRACE_ERROR_P1("VSI entity: Can't restart timer, uart_dtxs.c(%d)", __LINE__); } uart_data->dtx->esd_pos = 0; /* * start reception */ dtx_allocate_resources(); sig_dtx_rx_ready_to_receive_req( uart_data->dtx->dlc_instance, uart_data->dtx->to_send_data, uart_data->dtx->write_pos, uart_data->dtx->cur_desc_size ); } break; case DTX_READY: case DTX_NOT_READY: break; default: TRACE_ERROR( "SIG_KER_DTX_READY_MODE_REQ unexpected" ); break; } } /* sig_ker_dtx_ready_mode_req() */ /* +------------------------------------------------------------------------------ | Function : sig_ker_dtx_dead_mode_req +------------------------------------------------------------------------------ | Description : Handles the internal signal SIG_KER_DTX_DEAD_MODE_REQ | | Parameters : none | +------------------------------------------------------------------------------ */ GLOBAL void sig_ker_dtx_dead_mode_req () { TRACE_ISIG( "sig_ker_dtx_dead_mode_req" ); switch( GET_STATE( UART_SERVICE_DTX ) ) { case DTX_READY: case DTX_NOT_READY: SET_STATE( UART_SERVICE_DTX, DTX_DEAD ); /* * reset hComm_DTX_UPLINK and size_multiplier */ uart_data->dtx->dti_dtx_state = DTI_CLOSED; uart_data->dtx->size_multiplier = 3; if(uart_data->dtx->receiving_state EQ UART_DTX_NOT_RECEIVING) { /* * free recources and stop receiving */ sig_dtx_rx_not_ready_to_receive_req(uart_data->dtx->dlc_instance); dtx_free_resources(); } else uart_data->dtx->receiving_state = UART_DTX_INVALID; break; case DTX_DEAD: break; default: TRACE_ERROR( "SIG_KER_DTX_DEAD_MODE_REQ unexpected" ); break; } } /* sig_ker_dtx_dead_mode_req() */ /* +------------------------------------------------------------------------------ | Function : sig_rx_dtx_receiving_ind +------------------------------------------------------------------------------ | Description : Handles the internal signal SIG_RX_DTX_RECEIVING_IND | | Parameters : none | +------------------------------------------------------------------------------ */ GLOBAL void sig_rx_dtx_receiving_ind () { TRACE_ISIG( "sig_rx_dtx_receiving_ind" ); uart_data->dtx->receiving_state = UART_DTX_RECEIVING; switch( GET_STATE( UART_SERVICE_DTX ) ) { case DTX_READY: case DTX_NOT_READY: break; default: TRACE_ERROR( "SIG_RX_DTX_RECEIVING_IND unexpected" ); break; } } /* sig_ker_dtx_receiving_ind() */ /* +------------------------------------------------------------------------------ | Function : sig_rx_dtx_data_received_ind +------------------------------------------------------------------------------ | Description : Handles the internal signal SIG_RX_DTX_DATA_RECEIVED_IND | | Parameters : none | +------------------------------------------------------------------------------ */ GLOBAL void sig_rx_dtx_data_received_ind (T_desc2* received_data, USHORT write_pos) { T_DATA_FLOW_STATE old_data_flow; T_desc2* temp_desc; USHORT esd_pos; T_TIME cur_time; TRACE_ISIG( "sig_rx_dtx_data_received_ind" ); #ifdef UART_RANGE_CHECK if(received_data EQ NULL) { TRACE_EVENT("ERROR: received_data is NULL"); } else if((*((ULONG*)((UBYTE*)received_data - 8))) NEQ 0) { TRACE_EVENT_P1("ERROR: received_data=%08x is not allocated", received_data); } if(uart_data->dtx->to_send_data NEQ received_data) { TRACE_EVENT_P2("ERROR: to_send_data=%08x NEQ received_data=%08x", uart_data->dtx->to_send_data, received_data); } if(uart_data->dtx->to_send_data->len > uart_data->dtx->cur_desc_size) { TRACE_EVENT_P2("ERROR: to_send_data->len=%d > cur_desc_size=%d", uart_data->dtx->to_send_data->len, uart_data->dtx->cur_desc_size); } if(write_pos > uart_data->dtx->cur_desc_size) { TRACE_EVENT_P2("ERROR: write_pos=%d > cur_desc_size=%d", write_pos, uart_data->dtx->cur_desc_size); } if(uart_data->dtx->to_send_data->len > write_pos) { TRACE_EVENT_P2("ERROR: to_send_data->len=%d > write_pos=%d", uart_data->dtx->to_send_data->len, write_pos); } if(uart_data->dtx->esd_pos > write_pos) { TRACE_EVENT_P2("ERROR: esd_pos=%d > write_pos=%d", uart_data->dtx->esd_pos, write_pos); } switch(dtx_get_esd_state()) { case UART_ESD_DETECTED: if(uart_data->dtx->esd_pos < 3) { TRACE_EVENT_P1("ERROR: esd_pos=%d < 3 in UART_ESD_DETECTED state", uart_data->dtx->esd_pos); } break; case UART_ESD_CHAR_1: if(uart_data->dtx->esd_pos < 1) { TRACE_EVENT_P1("ERROR: esd_pos=%d < 1 in UART_ESD_CHAR_1 state", uart_data->dtx->esd_pos); } break; case UART_ESD_CHAR_2: if(uart_data->dtx->esd_pos < 2) { TRACE_EVENT_P1("ERROR: esd_pos=%d < 2 in UART_ESD_CHAR_2 state", uart_data->dtx->esd_pos); } break; case UART_ESD_CHAR_3: if(uart_data->dtx->esd_pos < 3) { TRACE_EVENT_P1("ERROR: esd_pos=%d < 3 in UART_ESD_CHAR_3 state", uart_data->dtx->esd_pos); } break; } #endif /* UART_RANGE_CHECK */ /* * store new write position, * current data_flow state and * current data descriptor */ uart_data->dtx->write_pos = write_pos; old_data_flow = uart_data->dtx->data_flow; temp_desc = received_data; /* * Introduce local variable here in order to prevent * the target compiler from doing wrong calculations ... */ esd_pos = uart_data->dtx->esd_pos; /* * escape sequence detection */ if(uart_data->dtx->receiving_state EQ UART_DTX_RECEIVING && uart_data->dtx->detect_escape EQ TRUE) { if (vsi_t_time (VSI_CALLER &cur_time) EQ VSI_OK) { switch(dtx_get_esd_state()) { case UART_ESD_DETECTED: /* * remove escape characters because escape sequence was detected */ if(uart_data->dtx->write_pos > esd_pos) { memmove(&temp_desc->buffer[esd_pos - 3], &temp_desc->buffer[esd_pos], uart_data->dtx->write_pos - esd_pos); } uart_data->dtx->write_pos-= 3; esd_pos -= 3; uart_data->dtx->esd_pos = esd_pos; dtx_set_esd_state( UART_ESD_NULL ); /* fall through */ case UART_ESD_NULL: #ifdef _SIMULATION_ TRACE_EVENT_P2("uart_data->act_gp: %d, silence: %d", uart_data->act_gp, (cur_time - uart_data->dtx->esd_guard_time)); #endif /* _SIMULATION_ */ if(esd_pos >= temp_desc->len) break; if(((cur_time - uart_data->dtx->esd_guard_time) < uart_data->act_gp) || (temp_desc-> buffer[esd_pos] NEQ uart_data->act_ec)) { /* * set new reference time and * update esd_pos */ esd_pos = temp_desc->len; uart_data->dtx->esd_pos = esd_pos; uart_data->dtx->esd_guard_time = cur_time; break; } /* * first guard period complete and * first escape character detected */ #ifdef _SIMULATION_ TRACE_EVENT("+ + + first guard period complete + + +"); #endif /* _SIMULATION_ */ dtx_set_esd_state( UART_ESD_CHAR_1 ); esd_pos++; uart_data->dtx->esd_pos = esd_pos; uart_data->dtx->esd_guard_time = cur_time; sig_dtx_rt_start_tesd_req (uart_data->act_gp); /* fall trough */ case UART_ESD_CHAR_1: if(esd_pos >= temp_desc->len) { /* * hide 1 character */ temp_desc->len = esd_pos - 1; temp_desc->size = temp_desc->len; break; } if(temp_desc-> buffer[esd_pos] NEQ uart_data->act_ec) { /* * second character is not an escape character */ dtx_set_esd_state( UART_ESD_NULL ); esd_pos = temp_desc->len; uart_data->dtx->esd_pos = esd_pos; uart_data->dtx->esd_guard_time = cur_time; break; } /* * second escape character received */ dtx_set_esd_state( UART_ESD_CHAR_2 ); esd_pos++; uart_data->dtx->esd_pos = esd_pos; /* fall trough */ case UART_ESD_CHAR_2: if(esd_pos >= temp_desc->len) { /* * hide 2 characters */ temp_desc->len = esd_pos - 2; temp_desc->size = temp_desc->len; break; } /* * set new reference time */ uart_data->dtx->esd_guard_time = cur_time; if(temp_desc-> buffer[esd_pos] NEQ uart_data->act_ec) { /* * third character is not an escape character */ dtx_set_esd_state( UART_ESD_NULL ); esd_pos = temp_desc->len; uart_data->dtx->esd_pos = esd_pos; break; } /* * third escape character received */ dtx_set_esd_state( UART_ESD_CHAR_3 ); esd_pos++; uart_data->dtx->esd_pos = esd_pos; sig_dtx_rt_start_tesd_req (uart_data->act_gp); /* fall trough */ case UART_ESD_CHAR_3: if(esd_pos >= temp_desc->len) { /* * hide 3 characters */ temp_desc->len = esd_pos - 3; temp_desc->size = temp_desc->len; break; } /* * fourth character received */ dtx_set_esd_state( UART_ESD_NULL ); esd_pos = temp_desc->len; uart_data->dtx->esd_pos = esd_pos; uart_data->dtx->esd_guard_time = cur_time; break; default: TRACE_ERROR("wrong esd state"); break; } } else { TRACE_ERROR_P1("VSI entity: Can't restart timer, uart_dtxs.c(%d)", __LINE__); } } switch( GET_STATE( UART_SERVICE_DTX ) ) { case DTX_DEAD: dtx_free_resources(); uart_data->dtx->receiving_state = UART_DTX_NOT_RECEIVING; break; case DTX_READY: /* * enable data flow if necessary */ if(old_data_flow NEQ UART_FLOW_ENABLED) { uart_data->dtx->data_flow = UART_FLOW_ENABLED; sig_dtx_ker_enable_ind(uart_data->dtx->dlc_instance); } if(uart_data->dtx->receiving_state EQ UART_DTX_RECEIVING) { /* * if data to send available or * line states changed */ if((temp_desc->len) || (uart_data->dtx->lines_changed)) { PALLOC_DESC2 (dti_data_ind, DTI2_DATA_IND); SET_STATE( UART_SERVICE_DTX, DTX_NOT_READY ); if(temp_desc->len) { /* * mark entity descriptor as invalid, since data will be forwarded */ uart_data->dtx->to_send_data = NULL; dti_data_ind->desc_list2.first = (ULONG)temp_desc; dti_data_ind->desc_list2.list_len = temp_desc->len; /* * calculate new size multiplier according to fillrate of buffer */ dtx_calculate_size_multiplier (temp_desc, old_data_flow); /* * allocate a new descriptor with size according to new size_multiplier */ dtx_allocate_resources(); /* * Check for data which has not yet been validated, i.e. because * the frame containing the data has not yet been received completely. * In this case, the not yet validated data is copied to the newly * allocated descriptor. */ if(uart_data->dtx->write_pos > temp_desc->len) { memcpy(uart_data->dtx->to_send_data->buffer, &temp_desc->buffer[temp_desc->len], uart_data->dtx->write_pos - temp_desc->len); uart_data->dtx->write_pos-= temp_desc->len; } esd_pos-= temp_desc->len; uart_data->dtx->esd_pos = esd_pos; } else { /* * just line states has been changed */ dti_data_ind->desc_list2.first = (ULONG)NULL; dti_data_ind->desc_list2.list_len = 0; } /* * set line states and * mark line states as unchanged; */ dti_data_ind->parameters.st_lines.st_flow = uart_data->dtx->st_flow; dti_data_ind->parameters.st_lines.st_line_sa = uart_data->dtx->st_line_sa; dti_data_ind->parameters.st_lines.st_line_sb = uart_data->dtx->st_line_sb; dti_data_ind->parameters.st_lines.st_break_len = uart_data->dtx->st_break_len; uart_data->dtx->lines_changed = FALSE; uart_data->dtx->st_break_len = DTI_BREAK_OFF; dti_send_data( uart_hDTI, uart_data->device, UART_DTI_UP_INTERFACE, uart_data->dtx->dlc_instance, dti_data_ind ); } } else { /* * invalid data * free recources and allocate a new descriptor because * size_multiplier may have changed */ dtx_free_resources(); dtx_allocate_resources(); /* * reset escape sequence detection */ dtx_set_esd_state( UART_ESD_NULL ); if(vsi_t_time (VSI_CALLER &(uart_data->dtx->esd_guard_time)) NEQ VSI_OK) { TRACE_ERROR_P1("VSI entity: Can't restart timer, uart_dtxs.c(%d)", __LINE__); } esd_pos = 0; uart_data->dtx->esd_pos = esd_pos; } /* * signal availability to receive to RX service */ uart_data->dtx->receiving_state = UART_DTX_NOT_RECEIVING; sig_dtx_rx_ready_to_receive_req( uart_data->dtx->dlc_instance, uart_data->dtx->to_send_data, uart_data->dtx->write_pos, uart_data->dtx->cur_desc_size ); break; case DTX_NOT_READY: if(uart_data->dtx->receiving_state EQ UART_DTX_RECEIVING) { uart_data->dtx->receiving_state = UART_DTX_NOT_RECEIVING; if((old_data_flow NEQ UART_FLOW_DISABLED) && ((uart_data->dtx->cur_desc_size - temp_desc->len) < ((USHORT)uart_data->n1 << 1))) { /* * the service DTX is receiving but there is not enough space left * therefore it is necessary to disable the data flow */ uart_data->dtx->data_flow = UART_FLOW_DISABLED; sig_dtx_ker_disable_ind(uart_data->dtx->dlc_instance); } if((uart_data->dtx->cur_desc_size - esd_pos) >= uart_data->n1) { /* * there is still enough space left to continue reception */ sig_dtx_rx_ready_to_receive_req(uart_data->dtx->dlc_instance, uart_data->dtx->to_send_data, uart_data->dtx->write_pos, uart_data->dtx->cur_desc_size); } } else { /* * invalid data * free recources and allocate a new descriptor * because size_multiplier may have changed */ dtx_free_resources(); dtx_allocate_resources(); /* * reset escape sequence detection */ dtx_set_esd_state( UART_ESD_NULL ); if(vsi_t_time (VSI_CALLER &(uart_data->dtx->esd_guard_time)) NEQ VSI_OK) { TRACE_ERROR_P1("VSI entity: Can't restart timer, uart_dtxs.c(%d)", __LINE__); } esd_pos = 0; uart_data->dtx->esd_pos = esd_pos; /* * enable flow control if necessary */ if(old_data_flow NEQ UART_FLOW_ENABLED) { uart_data->dtx->data_flow = UART_FLOW_ENABLED; sig_dtx_ker_enable_ind(uart_data->dtx->dlc_instance); } /* * signal availability to receive to RX service */ uart_data->dtx->receiving_state = UART_DTX_NOT_RECEIVING; sig_dtx_rx_ready_to_receive_req( uart_data->dtx->dlc_instance, uart_data->dtx->to_send_data, uart_data->dtx->write_pos, uart_data->dtx->cur_desc_size ); } break; default: TRACE_ERROR( "SIG_RX_DTX_DATA_RECEIVED_IND unexpected" ); break; } } /* sig_rx_dtx_data_received_ind() */ /* +------------------------------------------------------------------------------ | Function : sig_ker_dtx_line_states_req +------------------------------------------------------------------------------ | Description : Handles the internal signal SIG_KER_DTX_LINE_STATES_REQ | which indicates that one or more line status signals have | changed | | Parameters : st_flow - flow control state (X bit) | st_line_sa - line state SA | st_line_sa - line state SB | st_break_len - break length | +------------------------------------------------------------------------------ */ GLOBAL void sig_ker_dtx_line_states_req(UBYTE st_flow, UBYTE st_line_sa, UBYTE st_line_sb, UBYTE st_break_len) { TRACE_ISIG( "sig_ker_dtx_line_states_req" ); switch( GET_STATE( UART_SERVICE_DTX ) ) { case DTX_READY: if((st_flow NEQ uart_data->dtx->st_flow) || (st_line_sa NEQ uart_data->dtx->st_line_sa) || (st_line_sb NEQ uart_data->dtx->st_line_sb) || (st_break_len NEQ uart_data->dtx->st_break_len)) { /* * send line states to DTI peer */ PALLOC_DESC2 (dti_data_ind, DTI2_DATA_IND); SET_STATE( UART_SERVICE_DTX, DTX_NOT_READY ); /* * store new line states */ uart_data->dtx->st_flow = st_flow; uart_data->dtx->st_line_sa = st_line_sa; uart_data->dtx->st_line_sb = st_line_sb; uart_data->dtx->st_break_len = st_break_len; /* * just line states has been changed */ dti_data_ind->desc_list2.first = (ULONG)NULL; dti_data_ind->desc_list2.list_len = 0; /* * set line states and * mark line states as unchanged; */ dti_data_ind->parameters.st_lines.st_flow = uart_data->dtx->st_flow; dti_data_ind->parameters.st_lines.st_line_sa = uart_data->dtx->st_line_sa; dti_data_ind->parameters.st_lines.st_line_sb = uart_data->dtx->st_line_sb; dti_data_ind->parameters.st_lines.st_line_sb = uart_data->dtx->st_line_sb; dti_data_ind->parameters.st_lines.st_break_len = uart_data->dtx->st_break_len; uart_data->dtx->lines_changed = FALSE; uart_data->dtx->st_break_len = DTI_BREAK_OFF; dti_send_data( uart_hDTI, uart_data->device, UART_DTI_UP_INTERFACE, uart_data->dtx->dlc_instance, dti_data_ind ); } break; case DTX_NOT_READY: if((st_flow NEQ uart_data->dtx->st_flow) || (st_line_sa NEQ uart_data->dtx->st_line_sa) || (st_line_sb NEQ uart_data->dtx->st_line_sb) || (st_break_len NEQ uart_data->dtx->st_break_len)) { /* * If previously break detected keep information in * uart_data->dtx->st_break_len */ if(uart_data->dtx->st_break_len EQ DTI_BREAK_OFF) uart_data->dtx->st_break_len = st_break_len; /* * store new line states */ uart_data->dtx->st_flow = st_flow; uart_data->dtx->st_line_sa = st_line_sa; uart_data->dtx->st_line_sb = st_line_sb; /* * mark line states as changed */ uart_data->dtx->lines_changed = TRUE; } break; default: TRACE_ERROR( "SIG_KER_DTX_LINE_STATES_REQ unexpected" ); break; } } /* sig_ker_dtx_line_states_req */ /* +------------------------------------------------------------------------------ | Function : sig_ker_dtx_detect_escape_req +------------------------------------------------------------------------------ | Description : Handles the internal signal SIG_KER_DTX_DETECT_ESCAPE_REQ | which enables escape sequence detection | | Parameters : detect_escape - TRUE/FALSE | +------------------------------------------------------------------------------ */ GLOBAL void sig_ker_dtx_detect_escape_req (UBYTE detect_escape) { TRACE_ISIG( "sig_ker_dtx_detect_req" ); uart_data->dtx->detect_escape = detect_escape; } /* sig_ker_dtx_detect_req() */ /* +------------------------------------------------------------------------------ | Function : sig_ker_dtx_disconnected_mode_req +------------------------------------------------------------------------------ | Description : Handles the internal signal SIG_KER_DTX_DISCONNECTED_MODE_REQ | | Parameters : none | +------------------------------------------------------------------------------ */ GLOBAL void sig_ker_dtx_disconnected_mode_req () { TRACE_ISIG( "sig_ker_dtx_disconnected_mode_req" ); uart_data->dtx->dti_dtx_state = DTI_CLOSED; switch(GET_STATE( UART_SERVICE_DTX) ) { case DTX_READY: SET_STATE( UART_SERVICE_DTX, DTX_NOT_READY ); break; case DTX_NOT_READY: break; default: TRACE_ERROR( "SIG_KER_DTX_DISCONNECTED_MODE_REQ unexpected" ); break; } } /* sig_ker_dtx_disconnected_mode_req() */ /* +------------------------------------------------------------------------------ | Function : sig_ker_dtx_set_dtilib_peer_req +------------------------------------------------------------------------------ | Description : Handles the internal signal SIG_KER_DTX_SET_DTI_PEER_REQ | which is used to inform the service DTX that from now on it | needs to communicate with a (new) peer | | Parameters : - | +------------------------------------------------------------------------------ */ GLOBAL void sig_ker_dtx_set_dtilib_peer_req () { TRACE_ISIG( "sig_ker_dtx_set_dtilib_peer_req" ); /* * set dtilib parameters */ uart_data->dtx->dti_dtx_state = DTI_IDLE; /* * reset size_multiplier */ uart_data->dtx->size_multiplier = 3; /* * switch to new DTX state depending on current state */ switch( GET_STATE( UART_SERVICE_DTX ) ) { case DTX_READY: SET_STATE( UART_SERVICE_DTX, DTX_NOT_READY ); /* fall through */ case DTX_NOT_READY: { if(uart_data->dtx->receiving_state EQ UART_DTX_NOT_RECEIVING) { /* * reset received data */ dtx_free_resources(); dtx_allocate_resources(); /* * reset escape sequence detection */ dtx_set_esd_state( UART_ESD_NULL ); if(vsi_t_time (VSI_CALLER &(uart_data->dtx->esd_guard_time)) NEQ VSI_OK) { TRACE_ERROR_P1("VSI entity: Can't restart timer, uart_dtxs.c(%d)", __LINE__); } uart_data->dtx->esd_pos = 0; /* * enable flow control if necessary */ if(uart_data->dtx->data_flow NEQ UART_FLOW_ENABLED) { uart_data->dtx->data_flow = UART_FLOW_ENABLED; sig_dtx_ker_enable_ind(uart_data->dtx->dlc_instance); } /* * signal availability to receive to RX service */ sig_dtx_rx_ready_to_receive_req( uart_data->dtx->dlc_instance, uart_data->dtx->to_send_data, uart_data->dtx->write_pos, uart_data->dtx->cur_desc_size ); } else uart_data->dtx->receiving_state = UART_DTX_INVALID; } break; case DTX_DEAD: break; default: TRACE_ERROR( "SIG_KER_DTX_SET_DTI_PEER_REQ unexpected" ); break; } } /* sig_ker_dtx_set_dtilib_peer_req() */ /* +------------------------------------------------------------------------------ | Function : sig_ker_dtx_timeout_tesd_req +------------------------------------------------------------------------------ | Description : Handles the internal signal SIG_KER_DTX_TIMEOUT_TESD_REQ | which is used to inform the service DTX that the Escape | Sequence Guard Period timer has expired. | | Parameters : none | +------------------------------------------------------------------------------ */ GLOBAL void sig_ker_dtx_timeout_tesd_req() { T_DATA_FLOW_STATE old_data_flow; T_TIME cur_time; T_TIME elapsed; T_desc2* temp_desc; TRACE_ISIG( "sig_ker_dtx_timeout_tesd_req" ); switch( GET_STATE( UART_SERVICE_DTX ) ) { case DTX_READY: if (vsi_t_time (VSI_CALLER &cur_time) EQ VSI_OK) { elapsed = cur_time - uart_data->dtx->esd_guard_time; switch (dtx_get_esd_state()) { case UART_ESD_DETECTED: case UART_ESD_NULL: break; case UART_ESD_CHAR_1: case UART_ESD_CHAR_2: if(elapsed < uart_data->act_gp) { /* * escape sequence guard period not complete: start timer * with remaining time value */ sig_dtx_rt_start_tesd_req (uart_data->act_gp - elapsed); } else { /* * Guard Period complete * reset detection because detected characters do not belong to * an escape sequence */ dtx_set_esd_state( UART_ESD_NULL ); /* * if possible send the escape character */ if(uart_data->dtx->receiving_state EQ UART_DTX_NOT_RECEIVING) { /* * Guard Period complete * send one escape character to DTI peer and reset detection */ PALLOC_DESC2 (dti_data_ind, DTI2_DATA_IND); SET_STATE( UART_SERVICE_DTX, DTX_NOT_READY ); /* * enable data flow if necessary */ old_data_flow = uart_data->dtx->data_flow; if(uart_data->dtx->data_flow NEQ UART_FLOW_ENABLED) { uart_data->dtx->data_flow = UART_FLOW_ENABLED; sig_dtx_ker_enable_ind(uart_data->dtx->dlc_instance); } /* * mark entity descriptor as invalid, since data will be * forwarded */ temp_desc = uart_data->dtx->to_send_data; uart_data->dtx->to_send_data = NULL; /* * make escape character valid to send and insert values in * primitive */ temp_desc->len = uart_data->dtx->esd_pos; temp_desc->size = temp_desc->len; dti_data_ind->desc_list2.first = (ULONG)temp_desc; dti_data_ind->desc_list2.list_len = temp_desc->len; /* * calculate new size multiplier according to fillrate of buffer */ dtx_calculate_size_multiplier (temp_desc, old_data_flow); /* * allocate a new descriptor with size according to new size_multiplier */ dtx_allocate_resources(); /* * Check for data which has not yet been validated, i.e. because * the frame containing the data has not yet been received completely. * In this case, the not yet validated data is copied to the newly * allocated descriptor. */ if(uart_data->dtx->write_pos > temp_desc->len) { memcpy(uart_data->dtx->to_send_data->buffer, &temp_desc->buffer[temp_desc->len], uart_data->dtx->write_pos - temp_desc->len); uart_data->dtx->write_pos-= temp_desc->len; } uart_data->dtx->esd_pos = 0; sig_dtx_rx_ready_to_receive_req(uart_data->dtx->dlc_instance, uart_data->dtx->to_send_data, uart_data->dtx->write_pos, uart_data->dtx->cur_desc_size); /* * set line states */ dti_data_ind->parameters.st_lines.st_flow = uart_data->dtx->st_flow; dti_data_ind->parameters.st_lines.st_line_sa = uart_data->dtx->st_line_sa; dti_data_ind->parameters.st_lines.st_line_sb = uart_data->dtx->st_line_sb; dti_data_ind->parameters.st_lines.st_break_len = uart_data->dtx->st_break_len; uart_data->dtx->lines_changed = FALSE; uart_data->dtx->st_break_len = DTI_BREAK_OFF; #ifdef _SIMULATION_ dti_data_ind->parameters.p_id = DTI_PID_UOS; #endif /* _SIMULATION_ */ dti_send_data( uart_hDTI, uart_data->device, UART_DTI_UP_INTERFACE, uart_data->dtx->dlc_instance, dti_data_ind ); } } break; case UART_ESD_CHAR_3: if(elapsed < uart_data->act_gp) { /* * escape sequence guard period not complete: start timer * with remaining time value */ sig_dtx_rt_start_tesd_req (uart_data->act_gp - elapsed); } else { /* * Guard Period complete * Escape Sequence detected */ /* * remove escape characters from data stream */ if(uart_data->dtx->receiving_state EQ UART_DTX_NOT_RECEIVING) { if(uart_data->dtx->write_pos > 3) { memmove(uart_data->dtx->to_send_data->buffer, &uart_data->dtx->to_send_data->buffer[3], uart_data->dtx->write_pos - 3) ; /*lint !e416 creation of out-of-bounds pointer */ uart_data->dtx->write_pos-= 3; } else uart_data->dtx->write_pos = 0; uart_data->dtx->esd_pos = 0; sig_dtx_rx_ready_to_receive_req(uart_data->dtx->dlc_instance, uart_data->dtx->to_send_data, uart_data->dtx->write_pos, uart_data->dtx->cur_desc_size); /* * Reset the state of the Escape Sequence Detection */ dtx_set_esd_state( UART_ESD_NULL ); } else { /* * escape characters are not removeable * so we will do this later */ #ifdef _SIMULATION_ TRACE_EVENT("ESD: escape characters are not removeable"); #endif /* _SIMULATION_ */ dtx_set_esd_state( UART_ESD_DETECTED ); } #ifdef _SIMULATION_ TRACE_EVENT_P3("+ + + dlc_instance: %d, silence %d \ (from %d) Escape Sequence Detected + + + ", uart_data->dtx->dlc_instance, elapsed, uart_data->dtx->esd_guard_time); #endif /* _SIMULATION_ */ /* * send detected escape sequence to MMI */ sig_dtx_ker_escape_detected_ind(uart_data->dtx->dlc_instance); } break; default: { TRACE_ERROR_P1("Error: wrong ESD state, uart_dtxs.c(%d)", __LINE__); } break; } } else { TRACE_ERROR_P1("VSI entity: Cannot restart timer, uart_dtxs.c(%d)", __LINE__); } break; case DTX_NOT_READY: if (vsi_t_time (VSI_CALLER &cur_time) EQ VSI_OK) { elapsed = cur_time - uart_data->dtx->esd_guard_time; switch (dtx_get_esd_state()) { case UART_ESD_DETECTED: case UART_ESD_NULL: break; case UART_ESD_CHAR_1: case UART_ESD_CHAR_2: if(elapsed < uart_data->act_gp) { /* * escape sequence guard period not complete: start timer * with remaining time value */ sig_dtx_rt_start_tesd_req (uart_data->act_gp - elapsed); } else { /* * Guard Period complete * reset detection because detected characters do not belong to * an escape sequence */ dtx_set_esd_state( UART_ESD_NULL ); /* * if possible insert escape characters to usual data stream */ if(uart_data->dtx->receiving_state EQ UART_DTX_NOT_RECEIVING) { /* * make escape character valid to send and insert values in * primitive */ uart_data->dtx->to_send_data->len = uart_data->dtx->esd_pos; uart_data->dtx->to_send_data->size = uart_data->dtx->esd_pos; uart_data->dtx->to_send_data->offset = 0; if((uart_data->dtx->cur_desc_size - uart_data->dtx->esd_pos) >= uart_data->n1) { /* * there is still enough space left to continue reception */ sig_dtx_rx_ready_to_receive_req( uart_data->dtx->dlc_instance, uart_data->dtx->to_send_data, uart_data->dtx->write_pos, uart_data->dtx->cur_desc_size); } } } break; case UART_ESD_CHAR_3: if(elapsed < uart_data->act_gp) { /* * escape sequence guard period not complete: start timer * with remaining time value */ sig_dtx_rt_start_tesd_req (uart_data->act_gp - elapsed); } else { /* * Guard Period complete * Escape Sequence detected * store the occurence of the Escape Sequence */ #ifdef _SIMULATION_ TRACE_EVENT_P3("+ + + dlc_instance: %d, silence %d \ (from %d) Escape Sequence Detected + + + ", uart_data->dtx->dlc_instance, elapsed, uart_data->dtx->esd_guard_time); #endif /* _SIMULATION_ */ /* * remove escape characters from data stream */ if(uart_data->dtx->receiving_state EQ UART_DTX_NOT_RECEIVING) { if(uart_data->dtx->write_pos > uart_data->dtx->esd_pos) { memmove( &uart_data->dtx->to_send_data->buffer[ uart_data->dtx->esd_pos - 3], &uart_data->dtx->to_send_data->buffer[ uart_data->dtx->esd_pos], uart_data->dtx->write_pos - uart_data->dtx->esd_pos); } uart_data->dtx->write_pos-= 3; uart_data->dtx->esd_pos -= 3; /* * Reset the state of the Escape Sequence Detection */ dtx_set_esd_state( UART_ESD_NULL ); if((uart_data->dtx->cur_desc_size - uart_data->dtx->esd_pos) >= uart_data->n1) { /* * there is still enough space left to continue reception */ sig_dtx_rx_ready_to_receive_req( uart_data->dtx->dlc_instance, uart_data->dtx->to_send_data, uart_data->dtx->write_pos, uart_data->dtx->cur_desc_size); } } else { /* * escape characters are not removeable * so we will do this later */ #ifdef _SIMULATION_ TRACE_EVENT("ESD: escape characters are not removeable"); #endif /* _SIMULATION_ */ dtx_set_esd_state( UART_ESD_DETECTED ); } /* * send detected escape sequence to MMI */ sig_dtx_ker_escape_detected_ind(uart_data->dtx->dlc_instance); } break; default: TRACE_ERROR("wrong esd state"); break; } } break; case DTX_DEAD: break; default: TRACE_ERROR( "SIG_KER_DTX_TIMEOUT_TESD_REQ unexpected" ); break; } } /* sig_ker_dtx_timeout_tesd_req() */