FreeCalypso > hg > fc-magnetite
view src/g23m-aci/uart/uart_rxp.c @ 357:38c284cd102b
gsmcomp.c: TIF pool enlarged like in Citrine
author | Mychaela Falconia <falcon@freecalypso.org> |
---|---|
date | Mon, 25 Dec 2017 02:55:34 +0000 |
parents | 53929b40109c |
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 primitives as described in | the SDL-documentation (RX-statemachine) +----------------------------------------------------------------------------- */ #ifndef UART_RXP_C #define UART_RXP_C #endif /* !UART_RXP_C */ #define ENTITY_UART #ifndef FF_MULTI_PORT /*==== INCLUDES =============================================================*/ #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 interfac */ #ifdef _TARGET_ #include "uart/serialswitch.h" #include "uart/traceswitch.h" #else /* _TARGET_ */ #include "serial_dat.h" /* to get definitions of serial driver */ #endif /* _TARGET_ */ #include "uart.h" /* to get the global entity definitions */ #include "uart_rxf.h" /* to get rx functions */ #include "uart_kers.h" /* to get ker signals */ #include "uart_dtxs.h" /* to get dtx signals */ #ifdef _SIMULATION_ #include <stdio.h> /* to get sprintf */ #include "uart_rxp.h" /* to get rx_readdata */ #endif /* _SIMULATION_ */ /*==== CONST ================================================================*/ /*==== LOCAL VARS ===========================================================*/ /*==== PRIVATE FUNCTIONS ====================================================*/ /*==== PUBLIC FUNCTIONS =====================================================*/ /* +------------------------------------------------------------------------------ | Function : rx_uart_driver_received_ind +------------------------------------------------------------------------------ | Description : Handles the primitive UART_DRIVER_RECEIVED_IND | | Parameters : *uart_device - affected device database | +------------------------------------------------------------------------------ */ GLOBAL void rx_uart_driver_received_ind ( T_UART_DATA* uart_device ) { USHORT i; BOOL continuous; T_DLC* dlc; T_desc2* temp_desc = NULL; ULONG line_states; TRACE_EVENT( "rx_uart_driver_received_ind()" ); /* * set affected instance */ uart_data = uart_device; /* * inform about new line states */ if(uart_data->rx.lines NEQ uart_data->rx.prev_lines) { /* * convert line states and send it */ line_states = 0; if(uart_data->rx.lines & X_MASK) { line_states|= UART_X_RX_MASK; if(!(uart_data->rx.prev_lines & X_MASK)) { TRACE_EVENT("RX Flow Control: stop"); } } else if(uart_data->rx.prev_lines & X_MASK) { TRACE_EVENT("RX Flow Control: start"); } if(uart_data->rx.lines & SA_MASK) { line_states|= UART_SA_RX_MASK; if(!(uart_data->rx.prev_lines & SA_MASK)) { TRACE_EVENT("DTR: drop"); } } else if(uart_data->rx.prev_lines & SA_MASK) { TRACE_EVENT("DTR: on"); } if(uart_data->rx.lines & SB_MASK) { line_states|= UART_SB_RX_MASK; if(!(uart_data->rx.prev_lines & SB_MASK)) { TRACE_EVENT("RTS: off"); } } else if(uart_data->rx.prev_lines & SB_MASK) { TRACE_EVENT("RTS: on"); } if(uart_data->rx.lines & ESC_MASK) { line_states|= UART_ESC_RX_MASK; TRACE_EVENT("Escape Sequence detected"); } if(uart_data->rx.lines & BRK_MASK) { line_states|= UART_BRK_RX_MASK; line_states|= (((uart_data->rx.lines & BRK_LEN_MASK) >> BRKLEN) << UART_BRKLEN_RX_POS); TRACE_EVENT("Break detected"); } /* * store new line states */ uart_data->rx.lines&= ~(ESC_MASK | BRK_MASK | BRK_LEN_MASK); uart_data->rx.prev_lines = uart_data->rx.lines; /* * inform MMI */ sig_rx_ker_line_states_ind(line_states); } switch( GET_STATE( UART_SERVICE_RX ) ) { case RX_READY: dlc = &uart_data->dlc_table[UART_CONTROL_INSTANCE]; if(uart_data->rx.dlc_instance NEQ UART_EMPTY_INSTANCE) { uart_data->rx.dlc_instance = UART_EMPTY_INSTANCE; uart_data->rx.analyze_state = UART_RX_ERROR; /* * if ISR has read out some data * inform all channels about data reception */ if(uart_data->rx.read_permission) { for(i = 0; i <= UART_MAX_NUMBER_OF_CHANNELS; i++) { switch(uart_data->dlc_table[i].receive_process) { case UART_RX_PROCESS_READY: case UART_RX_PROCESS_COMPLETE: /* * inform all channels about data reception */ uart_data->dlc_table[i].receive_process = UART_RX_PROCESS_STOP; temp_desc = uart_data->dlc_table[i].receive_data; uart_data->dlc_table[i].receive_data = NULL; if(i EQ UART_CONTROL_INSTANCE) { /* * Control channel */ sig_rx_ker_data_received_ind( temp_desc, uart_data->dlc_table[i].receive_pos); } else { /* * Data channel */ uart_data->dtx = uart_data->dlc_table[i].dtx; sig_rx_dtx_data_received_ind( temp_desc, uart_data->dlc_table[i].receive_pos); } /* fall through */ case UART_RX_PROCESS_STOP: /* * add new channels which want to receive */ if(uart_data->dlc_table[i].receive_data) uart_data->dlc_table[i].receive_process = UART_RX_PROCESS_READY; break; default: TRACE_EVENT_P2("Unexpected DLC process state: %d | uart_rxp.c(%d)", dlc->receive_process, __LINE__); break; } } } } else { switch(dlc->receive_process) { case UART_RX_PROCESS_READY: case UART_RX_PROCESS_COMPLETE: /* * if ISR has read out some data * inform channel about data reception */ if(uart_data->rx.read_permission) { /* * inform channel about data reception */ dlc->receive_process = UART_RX_PROCESS_STOP; temp_desc = dlc->receive_data; dlc->receive_data = NULL; uart_data->dtx = dlc->dtx; sig_rx_dtx_data_received_ind(temp_desc, dlc->receive_pos); } /* fall through */ case UART_RX_PROCESS_STOP: /* * add new channel which want to receive */ if(dlc->receive_data) dlc->receive_process = UART_RX_PROCESS_READY; break; default: TRACE_EVENT_P2("Unexpected DLC process state: %d | uart_rxp.c(%d)", dlc->receive_process, __LINE__); break; } } if(dlc->receive_process EQ UART_RX_PROCESS_STOP) { uart_data->rx.receive_state = UART_RX_NOT_RECEIVING; break; } #ifdef _SIMULATION_ if(rx_inpavail(uart_data->device) > 0) #else /* _SIMULATION_ */ if(UF_InpAvail (uart_data->device) > 0) #endif /* _SIMULATION_ */ { /* * inform channel about reading */ uart_data->rx.read_permission = TRUE; uart_data->dtx = dlc->dtx; sig_rx_dtx_receiving_ind(); } else uart_data->rx.read_permission = FALSE; if(uart_data EQ (&(uart_data_base[0]))) { TRACE_EVENT("UF_ReadData()"); #ifdef _SIMULATION_ rx_readdata(0); #else /* _SIMULATION_ */ UF_ReadData (uart_data->device, sm_suspend, rx_readOutFunc_0); #endif /* else _SIMULATION_ */ } #ifdef FF_TWO_UART_PORTS else if(uart_data EQ (&(uart_data_base[1]))) { TRACE_EVENT("UF_ReadData()"); #ifdef _SIMULATION_ rx_readdata(1); #else /* _SIMULATION_ */ UF_ReadData (uart_data->device, sm_suspend, rx_readOutFunc_1); #endif /* else _SIMULATION_ */ } #endif /* FF_TWO_UART_PORTS */ else { TRACE_ERROR("wrong value of uart_data"); } break; case RX_MUX: if(uart_data->rx.dlc_instance EQ UART_EMPTY_INSTANCE) { uart_data->rx.dlc_instance = UART_CONTROL_INSTANCE; uart_data->rx.analyze_state = UART_RX_ERROR; } continuous = FALSE; for(i = 0; i <= UART_MAX_NUMBER_OF_CHANNELS; i++) { dlc = &uart_data->dlc_table[i]; switch(dlc->receive_process) { case UART_RX_PROCESS_READY: case UART_RX_PROCESS_COMPLETE: /* * if ISR has read out some data * inform all channels about data reception */ if(uart_data->rx.read_permission) { dlc->receive_process = UART_RX_PROCESS_STOP; temp_desc = dlc->receive_data; dlc->receive_data = NULL; if(i EQ UART_CONTROL_INSTANCE) { /* * Control channel */ sig_rx_ker_data_received_ind(temp_desc, dlc->receive_pos); } else { /* * Data channel */ uart_data->dtx = dlc->dtx; sig_rx_dtx_data_received_ind(temp_desc, dlc->receive_pos); } } /* fall through */ case UART_RX_PROCESS_STOP: /* * add new channels which want to receive */ if(dlc->receive_data) dlc->receive_process = UART_RX_PROCESS_READY; break; default: TRACE_EVENT_P2("Unexpected DLC process state: %d, uart_rxp.c(%d)", dlc->receive_process, __LINE__); break; } if(dlc->receive_process NEQ UART_RX_PROCESS_STOP) continuous = TRUE; } /* * check whether there is a channel to receive */ if(continuous NEQ TRUE) { uart_data->rx.receive_state = UART_RX_NOT_RECEIVING; break; } #ifdef _SIMULATION_ if(rx_inpavail(uart_data->device) > 0) #else /* _SIMULATION_ */ if(UF_InpAvail (uart_data->device) > 0) #endif /* _SIMULATION_ */ { /* * inform each channel about reading */ uart_data->rx.read_permission = TRUE; for(i = 0; i <= UART_MAX_NUMBER_OF_CHANNELS; i++) { if(uart_data->dlc_table[i].receive_process EQ UART_RX_PROCESS_READY) { if(i EQ UART_CONTROL_INSTANCE) { /* * Control channel */ sig_rx_ker_receiving_ind(); } else { /* * Data channel */ uart_data->dtx = uart_data->dlc_table[i].dtx; sig_rx_dtx_receiving_ind(); } } } } else uart_data->rx.read_permission = FALSE; if(uart_data EQ (&(uart_data_base[0]))) { TRACE_EVENT("UF_ReadData()"); #ifdef _SIMULATION_ rx_readdata(0); #else /* _SIMULATION_ */ UF_ReadData (uart_data->device, sm_suspend, rx_readOutFunc_0); #endif /* else _SIMULATION_ */ } #ifdef FF_TWO_UART_PORTS else if(uart_data EQ (&(uart_data_base[1]))) { TRACE_EVENT("UF_ReadData()"); #ifdef _SIMULATION_ rx_readdata(1); #else /* _SIMULATION_ */ UF_ReadData (uart_data->device, sm_suspend, rx_readOutFunc_1); #endif /* else _SIMULATION_ */ } #endif /* FF_TWO_UART_PORTS */ else { TRACE_ERROR("wrong value of uart_data"); } break; default: TRACE_ERROR( "UART_DRIVER_RECEIVED_IND unexpected" ); break; } } /* rx_uart_driver_received_ind() */ #ifdef _SIMULATION_ /* +------------------------------------------------------------------------------ | Function : rx_dti_data_test_ind +------------------------------------------------------------------------------ | Description : Handles the primitive DTI_DATA_TEST_IND | | Parameters : *dti_data_test_ind - Ptr to primitive payload | +------------------------------------------------------------------------------ */ GLOBAL void rx_dti_data_test_ind ( T_DTI2_DATA_TEST_IND *dti_data_test_ind ) { char buf[100]; T_reInstMode reInstall; USHORT size[2]; USHORT pos; USHORT i; T_UART_DATA* uart_device; TRACE_FUNCTION( "rx_dti_data_test_ind" ); /* * set UART instance */ uart_device = &(uart_data_base[UART_TEST_C_ID_1]); /* * copy data to simulation buffer */ MFREE_DESC2(uart_device->rx.sim_buffer); MALLOC(uart_device->rx.sim_buffer, (USHORT)(sizeof(T_desc2) - 1 + (dti_data_test_ind->sdu.l_buf >> 3))); memcpy(uart_device->rx.sim_buffer->buffer, &dti_data_test_ind->sdu.buf[dti_data_test_ind->sdu.o_buf >> 3], dti_data_test_ind->sdu.l_buf >> 3); uart_device->rx.sim_buffer->len = dti_data_test_ind->sdu.l_buf >> 3; uart_device->rx.sim_buffer->next = (ULONG)NULL; uart_device->rx.sim_pos = 0; /* * trace output */ sprintf(buf, "UART device %d:", dti_data_test_ind->link_id); TRACE_FUNCTION( buf ); i = 0; pos = uart_device->rx.sim_pos; while(pos < uart_device->rx.sim_buffer->len) { i+= sprintf(&buf[i], "0x%02x, ", uart_device->rx.sim_buffer->buffer[pos]); pos++; if(i > 80) { TRACE_FUNCTION( buf ); i = 0; } else if(pos >= uart_device->rx.sim_buffer->len) { TRACE_FUNCTION( buf ); } } /* * set values for ISR */ uart_device->rx.source[0] = &uart_device->rx.sim_buffer->buffer[ uart_device->rx.sim_pos]; uart_device->rx.source[1] = NULL; size[0] = uart_device->rx.sim_buffer->len - uart_device->rx.sim_pos; size[1] = 0; /* * call actual function */ rx_readOutFunc_0 (FALSE, &reInstall, 1, uart_device->rx.source, size, 0); /* * store return values */ if(size[0] EQ 0) { MFREE_DESC2(uart_device->rx.sim_buffer); uart_device->rx.sim_buffer = NULL; } else uart_device->rx.sim_pos = uart_device->rx.sim_buffer->len - size[0]; /* * free the primitive */ PFREE(dti_data_test_ind); } /* rx_dti_data_test_ind() */ /* +------------------------------------------------------------------------------ | Function : rx_readdata +------------------------------------------------------------------------------ | Description : Simulates a UF_ReadData() call. | | Parameters : caller - calling UART instance | +------------------------------------------------------------------------------ */ GLOBAL void rx_readdata (UBYTE caller) { T_reInstMode reInstall; USHORT size[2]; T_UART_DATA* uart_device; TRACE_FUNCTION( "rx_readdata" ); /* * set UART instance */ uart_device = &(uart_data_base[caller]); if(uart_device->rx.sim_buffer EQ NULL) { /* * send DTI_GETDATA_REQ */ PALLOC (dti_getdata_req, DTI2_GETDATA_REQ); dti_getdata_req->link_id = LINK_READDATA_PORT_1; /* for usual read_data */ PSEND (hCommMMI, dti_getdata_req); } else { /* * set values for ISR */ uart_device->rx.source[0] = NULL; uart_device->rx.source[1] = &uart_device->rx.sim_buffer->buffer[ uart_device->rx.sim_pos]; size[0] = 0; size[1] = uart_device->rx.sim_buffer->len - uart_device->rx.sim_pos; /* * call actual function */ if(caller EQ 0) { rx_readOutFunc_0 (FALSE, &reInstall, 2, uart_device->rx.source, size, 0); } #ifdef FF_TWO_UART_PORTS else if(caller EQ 1) { rx_readOutFunc_1 (FALSE, &reInstall, 2, uart_device->rx.source, size, 0); } #endif /* FF_TWO_UART_PORTS */ else { TRACE_ERROR("wrong caller value"); } /* * store return values */ if(size[1] EQ 0) { MFREE_DESC2(uart_device->rx.sim_buffer); uart_device->rx.sim_buffer = NULL; } else uart_device->rx.sim_pos = uart_device->rx.sim_buffer->len - size[1]; } } /* rx_readdata() */ /* +------------------------------------------------------------------------------ | Function : rx_inpavail +------------------------------------------------------------------------------ | Description : Simulates a UF_InpAvail() call. | | Parameters : caller - calling UART instance | | Return : number of octets in Input Queue | +------------------------------------------------------------------------------ */ GLOBAL USHORT rx_inpavail (UBYTE caller) { T_UART_DATA* uart_device; TRACE_FUNCTION( "rx_inpavail" ); /* * set UART instance */ uart_device = &(uart_data_base[caller]); if(uart_device->rx.sim_buffer) return uart_device->rx.sim_buffer->len - uart_device->rx.sim_pos; else return 0; } /* rx_inpavail() */ #endif /* _SIMULATION_ */ #endif /* !FF_MULTI_PORT */