FreeCalypso > hg > fc-tourmaline
view src/g23m-aci/uart/uart_txs.c @ 7:d6f8d6efdf5b
scripts/config-headers.sh: import from Magnetite
author | Mychaela Falconia <falcon@freecalypso.org> |
---|---|
date | Fri, 16 Oct 2020 06:52:37 +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 (TX-statemachine) +----------------------------------------------------------------------------- */ #ifndef UART_TXS_C #define UART_TXS_C #endif /* !UART_TXS_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 */ #ifdef DTILIB #include "dti.h" /* to get dti lib */ #endif /* DTILIB */ #include "pei.h" /* to get PEI interface */ #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_txf.h" /* to get tx functions */ #include "uart_kers.h" /* to get ker signals */ #include "uart_drxs.h" /* to get drx signals */ #ifdef _SIMULATION_ #include <stdio.h> /* to get sprintf */ #include "uart_txp.h" /* to get tx_writedata */ #endif /* _SIMULATION_ */ /*==== CONST ================================================================*/ /*==== LOCAL VARS ===========================================================*/ /*==== PRIVATE FUNCTIONS ====================================================*/ /*==== PUBLIC FUNCTIONS =====================================================*/ /* +------------------------------------------------------------------------------ | Function : sig_ker_tx_dead_mode_req +------------------------------------------------------------------------------ | Description : Handles the internal signal SIG_KER_TX_DEAD_MODE_REQ. If this | signal is called the service expectes an disabled UART to work | correctly. | | Parameters : no parameters | +------------------------------------------------------------------------------ */ GLOBAL void sig_ker_tx_dead_mode_req () { TRACE_ISIG( "sig_ker_tx_dead_mode_req" ); uart_data->tx.lines = 0x80000000; /* invalid */ uart_data->tx.dlc_instance = UART_EMPTY_INSTANCE; uart_data->tx.p_zero = 0; uart_data->tx.send_state = UART_TX_NOT_SENDING; switch( GET_STATE( UART_SERVICE_TX ) ) { case TX_READY: case TX_MUX: SET_STATE( UART_SERVICE_TX, TX_DEAD ); break; case TX_DEAD: break; default: TRACE_ERROR( "SIG_KER_TX_DEAD_MODE_REQ unexpected" ); break; } } /* sig_ker_tx_dead_mode_req() */ /* +------------------------------------------------------------------------------ | Function : sig_ker_tx_ready_mode_req +------------------------------------------------------------------------------ | Description : Handles the internal signal SIG_KER_TX_READY_MODE_REQ. | | Parameters : no parameters | +------------------------------------------------------------------------------ */ GLOBAL void sig_ker_tx_ready_mode_req () { TRACE_ISIG( "sig_ker_tx_ready_mode_req" ); switch( GET_STATE( UART_SERVICE_TX ) ) { case TX_DEAD: SET_STATE( UART_SERVICE_TX, TX_READY ); uart_data->tx.dlc_instance = UART_EMPTY_INSTANCE; uart_data->tx.send_state = UART_TX_NOT_SENDING; break; case TX_MUX: SET_STATE( UART_SERVICE_TX, TX_READY ); if(uart_data->tx.send_state EQ UART_TX_NOT_SENDING) uart_data->tx.dlc_instance = UART_EMPTY_INSTANCE; break; case TX_READY: break; default: TRACE_ERROR( "SIG_KER_TX_READY_MODE_REQ unexpected" ); break; } } /* sig_ker_tx_ready_mode_req() */ /* +------------------------------------------------------------------------------ | Function : sig_ker_tx_mux_mode_req +------------------------------------------------------------------------------ | Description : Handles the internal signal SIG_KER_TX_MUX_MODE_REQ | | Parameters : no parameters | +------------------------------------------------------------------------------ */ GLOBAL void sig_ker_tx_mux_mode_req () { TRACE_ISIG( "sig_ker_tx_mux_mode_req" ); switch( GET_STATE( UART_SERVICE_TX ) ) { case TX_DEAD: SET_STATE( UART_SERVICE_TX, TX_MUX ); uart_data->tx.send_state = UART_TX_NOT_SENDING; break; case TX_READY: SET_STATE( UART_SERVICE_TX, TX_MUX ); break; case TX_MUX: break; default: TRACE_ERROR( "SIG_KER_TX_MUX_MODE_REQ unexpected" ); break; } } /* sig_ker_tx_mux_mode_req() */ /* +------------------------------------------------------------------------------ | Function : sig_drx_tx_data_available_ind +------------------------------------------------------------------------------ | Description : Handles the internal signal SIG_DRX_TX_DATA_AVAILABLE_IND | | Parameters : dlc_instance - dlc instance wich belongs to calling DRX | transmit_data - descriptors to transmit | transmit_pos - position to start tranmission in first desc | +------------------------------------------------------------------------------ */ GLOBAL void sig_drx_tx_data_available_ind (UBYTE dlc_instance, T_desc2* transmit_data, USHORT transmit_pos) { T_DLC* dlc; TRACE_ISIG( "sig_drx_tx_data_available_ind" ); dlc = &uart_data->dlc_table[dlc_instance]; dlc->transmit_data = transmit_data; dlc->transmit_pos = transmit_pos; dlc->p_counter = dlc->priority + uart_data->tx.p_zero; switch( GET_STATE( UART_SERVICE_TX ) ) { case TX_READY: if(uart_data->tx.send_state EQ UART_TX_NOT_SENDING) { uart_data->tx.dlc_instance = UART_EMPTY_INSTANCE; /* * inform dlc about sending */ if(dlc->transmit_data EQ NULL) { /* * no more data */ break; } uart_data->tx.send_state = UART_TX_SENDING; uart_data->drx = dlc->drx; sig_tx_drx_sending_req(); /* * transmit data */ if(uart_data EQ (&(uart_data_base[0]))) { TRACE_EVENT("UF_WriteData()"); #ifdef _SIMULATION_ tx_writedata(0); #else /* _SIMULATION_ */ UF_WriteData (uart_data->device, sm_suspend, tx_writeInFunc_0); #endif /* else _SIMULATION_ */ } #ifdef FF_TWO_UART_PORTS else if(uart_data EQ (&(uart_data_base[1]))) { TRACE_EVENT("UF_WriteData()"); #ifdef _SIMULATION_ tx_writedata(1); #else /* _SIMULATION_ */ UF_WriteData (uart_data->device, sm_suspend, tx_writeInFunc_1); #endif /* else _SIMULATION_ */ } #endif /* FF_TWO_UART_PORTS */ else { TRACE_ERROR("wrong value of uart_data"); } } break; case TX_MUX: if(uart_data->tx.send_state EQ UART_TX_NOT_SENDING) { /* * determine next dlc allow to send */ tx_next_send_allowed(); /* * inform dlc about sending */ if(uart_data->tx.dlc_instance EQ UART_EMPTY_INSTANCE) { /* * queue empty */ break; } dlc = &uart_data->dlc_table[uart_data->tx.dlc_instance]; uart_data->tx.send_state = UART_TX_SENDING; if(uart_data->tx.dlc_instance EQ UART_CONTROL_INSTANCE) { /* * Control channel */ sig_tx_ker_sending_ind(); } else { /* * Data channel */ uart_data->drx = dlc->drx; sig_tx_drx_sending_req(); } /* * transmit data */ #ifndef _SIMULATION_ tx_flushUart(); #endif /* !_SIMULATION_ */ if(uart_data EQ (&(uart_data_base[0]))) { TRACE_EVENT("UF_WriteData()"); #ifdef _SIMULATION_ tx_writedata(0); #else /* _SIMULATION_ */ UF_WriteData (uart_data->device, sm_suspend, tx_writeInFunc_0); #endif /* else _SIMULATION_ */ } #ifdef FF_TWO_UART_PORTS else if(uart_data EQ (&(uart_data_base[1]))) { TRACE_EVENT("UF_WriteData()"); #ifdef _SIMULATION_ tx_writedata(1); #else /* _SIMULATION_ */ UF_WriteData (uart_data->device, sm_suspend, tx_writeInFunc_1); #endif /* else _SIMULATION_ */ } #endif /* FF_TWO_UART_PORTS */ else { TRACE_ERROR("wrong value of uart_data"); } } break; default: TRACE_ERROR( "SIG_DRX_TX_DATA_AVAILABLE_IND unexpected" ); break; } } /* sig_drx_tx_data_available_ind() */ /* +------------------------------------------------------------------------------ | Function : sig_ker_tx_data_available_req +------------------------------------------------------------------------------ | Description : Handles the internal signal SIG_KER_TX_DATA_AVAILABLE_REQ | | Parameters : transmit_data - descriptors to transmit | transmit_pos - position to start tranmission in first desc | +------------------------------------------------------------------------------ */ GLOBAL void sig_ker_tx_data_available_req (T_desc2* transmit_data, USHORT transmit_pos) { T_DLC* dlc; TRACE_ISIG( "sig_ker_tx_data_available_req" ); dlc = &uart_data->dlc_table[UART_CONTROL_INSTANCE]; dlc->transmit_data = transmit_data; dlc->transmit_pos = transmit_pos; dlc->p_counter = dlc->priority + uart_data->tx.p_zero; #ifdef _SIMULATION_ if(transmit_data->len) { USHORT i; USHORT pos; char buf[90]; /* * trace output */ TRACE_EVENT("====== OUT"); i = 0; pos = 0; while(pos < transmit_data->len) { i+= sprintf(&buf[i], "0x%02x, ", transmit_data->buffer[pos]); pos++; if(i > 80) { TRACE_EVENT( buf ); i = 0; } else if(pos >= transmit_data->len) { TRACE_EVENT( buf ); } } } #endif /* _SIMULATION_ */ switch( GET_STATE( UART_SERVICE_TX ) ) { case TX_MUX: if(uart_data->tx.send_state EQ UART_TX_NOT_SENDING) { /* * determine next dlc allow to send */ tx_next_send_allowed(); /* * inform dlc about sending */ if(uart_data->tx.dlc_instance == UART_EMPTY_INSTANCE) { /* * queue empty */ break; } uart_data->tx.send_state = UART_TX_SENDING; dlc = &uart_data->dlc_table[uart_data->tx.dlc_instance]; if(uart_data->tx.dlc_instance EQ UART_CONTROL_INSTANCE) { /* * Control channel */ sig_tx_ker_sending_ind(); } else { /* * Data channel */ uart_data->drx = dlc->drx; sig_tx_drx_sending_req(); } /* * transmit data */ #ifndef _SIMULATION_ tx_flushUart(); #endif /* !_SIMULATION_ */ if(uart_data EQ (&(uart_data_base[0]))) { TRACE_EVENT("UF_WriteData()"); #ifdef _SIMULATION_ tx_writedata(0); #else /* _SIMULATION_ */ UF_WriteData (uart_data->device, sm_suspend, tx_writeInFunc_0); #endif /* else _SIMULATION_ */ } #ifdef FF_TWO_UART_PORTS else if(uart_data EQ (&(uart_data_base[1]))) { TRACE_EVENT("UF_WriteData()"); #ifdef _SIMULATION_ tx_writedata(1); #else /* _SIMULATION_ */ UF_WriteData (uart_data->device, sm_suspend, tx_writeInFunc_1); #endif /* else _SIMULATION_ */ } #endif /* FF_TWO_UART_PORTS */ else { TRACE_ERROR("wrong value of uart_data"); } } break; default: TRACE_ERROR( "SIG_KER_TX_DATA_AVAILABLE_REQ unexpected" ); break; } } /* sig_ker_tx_data_available_req() */ /* +------------------------------------------------------------------------------ | Function : sig_drx_tx_data_not_available_ind +------------------------------------------------------------------------------ | Description : Handles the internal signal SIG_DRX_TX_DATA_NOT_AVAILABLE_IND | | Parameters : dlc_instance - dlc instance wich belongs to calling DRX | +------------------------------------------------------------------------------ */ GLOBAL void sig_drx_tx_data_not_available_ind (UBYTE dlc_instance) { TRACE_ISIG( "sig_drx_tx_data_not_available_ind" ); uart_data->dlc_table[dlc_instance].transmit_data = NULL; } /* sig_drx_tx_data_not_available_ind() */ /* +------------------------------------------------------------------------------ | Function : sig_ker_tx_data_not_available_req +------------------------------------------------------------------------------ | Description : Handles the internal signal SIG_KER_TX_DATA_NOT_AVAILABLE_REQ | | Parameters : no parameters | +------------------------------------------------------------------------------ */ GLOBAL void sig_ker_tx_data_not_available_req () { TRACE_ISIG( "sig_ker_tx_data_not_available_req" ); uart_data->dlc_table[UART_CONTROL_INSTANCE].transmit_data = NULL; } /* sig_ker_tx_data_not_available_req() */ /* +------------------------------------------------------------------------------ | Function : sig_ker_tx_line_states_req +------------------------------------------------------------------------------ | Description : Handles the internal signal SIG_KER_TX_LINE_STATES_REQ | | Parameters : dlc_instance - DLC which contains new line states | +------------------------------------------------------------------------------ */ GLOBAL void sig_ker_tx_line_states_req (UBYTE dlc_instance) { T_DLC* dlc; SHORT ret = 0; /* Error returned from a function */ TRACE_ISIG( "sig_ker_tx_line_states_req" ); /* * set DLC */ dlc = &uart_data->dlc_table[dlc_instance]; /* * UART number has to be checked. * UART IrDA (UAF_UART_0) can't be used for F&D on Ulysse because hardware * flow control is not supported. * DCD and DTR are not supported on UART Irda on C & D-Sample. */ if((uart_data->tx.lines != dlc->lines)) { /* * FreeCalypso addition: trace the dlc->lines value that is * causing UF_SetLineState() calls to the physical UART driver. */ TRACE_USER_CLASS_P1(TC_EVENT|TC_USER1, "sig_ker_tx_line_states_req: dlc->lines = %x", dlc->lines); /* * set new line states separatly because * if one line is not supported by the driver * we can still set the other lines */ if(dlc->lines & UART_SA_TX_MASK) { if(((ret = UF_SetLineState(uart_data->device, (ULONG)(SA_MASK), (ULONG)(SA_MASK))) != UF_OK) && (uart_data->device != 0)) { TRACE_ERROR_P2("UF driver: SetLineState failed, [%d], uart_txs.c(%d)", ret, __LINE__); } } else { if(((ret = UF_SetLineState(uart_data->device, 0, (ULONG)(SA_MASK))) != UF_OK) && (uart_data->device != 0)) { TRACE_ERROR_P2("UF driver: SetLineState failed, [%d], uart_txs.c(%d)", ret, __LINE__); } } if(dlc->lines & UART_SB_TX_MASK) /* also DCD */ { if(((ret = UF_SetLineState(uart_data->device, 0, (ULONG)(SB_MASK))) != UF_OK) && (uart_data->device != 0)) { TRACE_ERROR_P2("UF driver: SetLineState failed, [%d], uart_txs.c(%d)", ret, __LINE__); } } else { if(((ret = UF_SetLineState(uart_data->device, (ULONG)(SB_MASK), (ULONG)(SB_MASK))) != UF_OK) && (uart_data->device != 0)) { TRACE_ERROR_P2("UF driver: SetLineState failed, [%d], uart_txs.c(%d)", ret, __LINE__); } } if(dlc->lines & UART_X_TX_MASK) { if(((ret = UF_SetLineState(uart_data->device, (ULONG)(X_MASK), (ULONG)(X_MASK))) != UF_OK) && (uart_data->device != 0)) { TRACE_ERROR_P2("UF driver: SetLineState failed, [%d], uart_txs.c(%d)", ret, __LINE__); } } else { if(((ret = UF_SetLineState(uart_data->device, 0, (ULONG)(X_MASK))) != UF_OK) && (uart_data->device != 0)) { TRACE_ERROR_P2("UF driver: SetLineState failed, [%d], uart_txs.c(%d)", ret, __LINE__); } } if(dlc->lines & UART_RI_MASK) { if(((ret = UF_SetLineState(uart_data->device, (ULONG)(RI_MASK), (ULONG)(RI_MASK))) != UF_OK) && (uart_data->device != 0)) { TRACE_ERROR_P2("UF driver: SetLineState failed, [%d], uart_txs.c(%d)", ret, __LINE__); } } else { if(((ret = UF_SetLineState(uart_data->device, 0, (ULONG)(RI_MASK))) != UF_OK) && (uart_data->device != 0)) { TRACE_ERROR_P2("UF driver: SetLineState failed, [%d], uart_txs.c(%d)", ret, __LINE__); } } if(dlc->lines & UART_BRK_TX_MASK) { /* * send break */ if(((ret = UF_SetLineState(uart_data->device, (ULONG)((1UL<<BRK) | (((dlc->lines & UART_BRKLEN_TX_MASK) >> UART_BRKLEN_TX_POS) << BRKLEN)), (ULONG)(BRK_MASK | BRK_LEN_MASK))) != UF_OK) && (uart_data->device != 0)) { TRACE_ERROR_P2("UF driver: SetLineState failed, [%d], uart_txs.c(%d)", ret, __LINE__); } /* * break sent, so clear break flag */ dlc->lines&= ~UART_BRK_TX_MASK; } uart_data->tx.lines = dlc->lines; } } /* sig_ker_tx_line_states_req() */ /* +------------------------------------------------------------------------------ | Function : sig_ker_tx_flush_req +------------------------------------------------------------------------------ | Description : Handles the internal signal SIG_KER_TX_FLUSH_REQ | | Parameters : no parameters | +------------------------------------------------------------------------------ */ GLOBAL void sig_ker_tx_flush_req () { TRACE_ISIG( "sig_ker_tx_flush_req" ); switch( GET_STATE( UART_SERVICE_TX ) ) { case TX_READY: case TX_MUX: #ifndef _SIMULATION_ tx_flushUart(); #endif /* !_SIMULATION_ */ sig_tx_ker_flushed_ind(); break; default: TRACE_ERROR( "SIG_KER_TX_FLUSH_REQ unexpected" ); break; } } /* sig_ker_tx_flush_req() */ /* +------------------------------------------------------------------------------ | Function : sig_ker_tx_restart_write_req +------------------------------------------------------------------------------ | Description : Handles the internal signal SIG_KER_TX_RESTART_WRITE_REQ | | Parameters : no parameters | +------------------------------------------------------------------------------ */ GLOBAL void sig_ker_tx_restart_write_req () { TRACE_ISIG( "sig_ker_tx_restart_write_req" ); switch( GET_STATE( UART_SERVICE_TX ) ) { case TX_READY: case TX_MUX: if(uart_data->tx.send_state EQ UART_TX_SENDING) { /* * restart writeInFunc */ #ifndef _SIMULATION_ tx_flushUart(); #endif /* !_SIMULATION_ */ if(uart_data EQ (&(uart_data_base[0]))) { TRACE_EVENT("UF_WriteData()"); #ifdef _SIMULATION_ tx_writedata(0); #else /* _SIMULATION_ */ UF_WriteData (uart_data->device, sm_suspend, tx_writeInFunc_0); #endif /* else _SIMULATION_ */ } #ifdef FF_TWO_UART_PORTS else if(uart_data EQ (&(uart_data_base[1]))) { TRACE_EVENT("UF_WriteData()"); #ifdef _SIMULATION_ tx_writedata(1); #else /* _SIMULATION_ */ UF_WriteData (uart_data->device, sm_suspend, tx_writeInFunc_1); #endif /* else _SIMULATION_ */ } #endif /* FF_TWO_UART_PORTS */ else { TRACE_ERROR("wrong value of uart_data"); } } break; default: TRACE_ERROR( "SIG_KER_TX_RESTART_WRITE_REQ unexpected" ); break; } } /* sig_ker_tx_restart_write_req() */ #endif /* !FF_MULTI_PORT */