FreeCalypso > hg > fc-tourmaline
view src/cs/drivers/drv_app/uart/serialswitch_dp.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 | 4e78acac3d88 |
| children |
line wrap: on
line source
/******************************************************************************* * * SERIALSWITCH.C * * Board-specific switch for Perseus * * (C) Texas Instruments 2000 * ******************************************************************************/ #ifndef __SERIALSWITCH_C__ #define __SERIALSWITCH_C__ #include "main/sys_types.h" #include "memif/mem.h" #include "nucleus.h" #include "csmi/csmi.h" #include "uart/serialswitch.h" #include "uart/uart.h" #include "uart/uartfax.h" #include "csmi/csmi_uart.h" #include "csmi/csmi_uartfax.h" #include "inth/iq.h" static int serial_config; #define NUMBER_OF_UART 2 // Constant used to avoid calling uart interrupt handler when using CSMI #define DISABLE_UART_INTERRUPT_HANDLER 0x0 // Internal UART constants & macros - used by interrupt handler #define IIR (0x02) /* UART interrupt ident. register - Read only */ #define SCR (0x10) /* UART suppl. control register - Read/Write */ #define SSR (0x11) /* UART suppl. status register - Read only */ #define IIR_BITS_USED (0x07) #define IT_NOT_PENDING (0x01) /* * Supplementary Control Register */ #define RX_CTS_WAKE_UP_ENABLE_BIT (4) /* * Supplementary Status Register */ #define RX_CTS_WAKE_UP_STS (0x02) /* Wake-up interrupt occurred */ /* * This macro allows to read an UART register. */ #define READ_UART_REGISTER(UART,REG) \ *((volatile SYS_UWORD8 *) ((UART)->base_address + (REG))) /* * This macro allows to disable the UART's wake-up interrupt. */ #define DISABLE_WAKE_UP_INTERRUPT(UART) \ *((volatile SYS_UWORD8 *) ((UART)->base_address + SCR)) &= \ ~(1 << (RX_CTS_WAKE_UP_ENABLE_BIT)); /* * Wake-up time duration in seconds and in number of TDMAs. * 1 TDMA = (6 / 1300) s = 0.004615 s (= 4.615 ms). */ #define WAKE_UP_TIME_DURATION (10) /* 7200 seconds = 120 min. = 2 hours*/ #define WAKE_UP_TIME_IN_TDMA (WAKE_UP_TIME_DURATION * 1300 / 6) char ser_cfg_info[NUMBER_OF_TR_UART] = {0, 0}; /* * Types of flows supported. */ typedef enum { TRACE_FLOW, FAX_DATA_FLOW } t_flow_type; static const unsigned long uart_base_address[NUMBER_OF_UART] = { MEM_UART_IRDA, MEM_UART_MODEM }; static NU_TIMER uart_wake_up_duration_timer; static unsigned char uart_waked_up_by_interrupt; #if ((CHIPSET == 2) || (CHIPSET == 3)) static unsigned long uart_spurious_interrupts; #elif ((CHIPSET == 4) || (CHIPSET == 5) || (CHIPSET == 6) || (CHIPSET == 7)) static unsigned long uart_modem_spurious_interrupts; static unsigned long uart_irda_spurious_interrupts; #endif // Structures representing the arrays typedef struct { void (*tr_Init) (T_tr_UartId device, int baudrate, void (callback_function (void))); unsigned long (*tr_ReadNChars) (T_tr_UartId device, char *buffer, unsigned long chars_to_read); unsigned long (*tr_ReadNBytes) (T_tr_UartId device, char *buffer, unsigned long chars_to_read, unsigned char *eof_detected); unsigned long (*tr_WriteNChars) (T_tr_UartId device, char *buffer, unsigned long chars_to_write); unsigned long (*tr_EncapsulateNChars) (T_tr_UartId device, char *buffer, unsigned long chars_to_write); unsigned long (*tr_WriteNBytes) (T_tr_UartId device, unsigned char *buffer, unsigned long chars_to_write); void (*tr_WriteChar) (T_tr_UartId device, char character); void (*tr_WriteString) (T_tr_UartId device, char *buffer); unsigned char (*tr_EnterSleep) (T_tr_UartId device); void (*tr_WakeUp) (T_tr_UartId device); } TR_DRV; /* * Set of function pointers for fax & data functions. */ typedef struct { T_FDRET (*fd_Init) (T_fd_UartId uartNo); T_FDRET (*fd_Enable) (T_fd_UartId uartNo, unsigned char enable); T_FDRET (*fd_SetComPar) (T_fd_UartId uartNo, T_baudrate baudrate, T_bitsPerCharacter bpc, T_stopBits sb, T_parity parity); T_FDRET (*fd_SetBuffer) (T_fd_UartId uartNo, unsigned short bufSize, unsigned short rxThreshold, unsigned short txThreshold); T_FDRET (*fd_SetFlowCtrl) (T_fd_UartId uartNo, T_flowCtrlMode fcMode, unsigned char XON, unsigned char XOFF); T_FDRET (*fd_SetEscape) (T_fd_UartId uartNo, unsigned char escChar, unsigned short guardPeriod); T_FDRET (*fd_InpAvail) (T_fd_UartId uartNo); T_FDRET (*fd_OutpAvail) (T_fd_UartId uartNo); T_FDRET (*fd_EnterSleep) (T_fd_UartId uartNo); T_FDRET (*fd_WakeUp) (T_fd_UartId uartNo); T_FDRET (*fd_ReadData) (T_fd_UartId uartNo, T_suspendMode suspend, void (readOutFunc (unsigned char cldFromIrq, T_reInstMode *reInstall, unsigned char nsource, unsigned char *source[], unsigned short size[], unsigned long state))); T_FDRET (*fd_WriteData) (T_fd_UartId uartNo, T_suspendMode suspend, void (writeInFunc (unsigned char cldFromIrq, T_reInstMode *reInstall, unsigned char ndest, unsigned char *dest[], unsigned short size[]))); T_FDRET (*fd_StopRec) (T_fd_UartId uartNo); T_FDRET (*fd_StartRec) (T_fd_UartId uartNo); T_FDRET (*fd_GetLineState) (T_fd_UartId uartNo, unsigned long *state); T_FDRET (*fd_SetLineState) (T_fd_UartId uartNo, unsigned long state, unsigned long mask); T_FDRET (*fd_CheckXEmpty) (T_fd_UartId uartNo); } FD_DRV; /* * UART structure used for UARTs. */ typedef struct { SYS_UWORD32 base_address; SYS_BOOL device_used; SYS_BOOL deep_sleep_set_up; t_flow_type flow_type; SYS_WORD16 flow_id; void (*interrupt_handler) (int uart_id, SYS_UWORD8 interrupt_status); } T_UART; /* * Internal variables and prototypes of stubs */ static unsigned short fd_bufSize; static unsigned char fd_buffer[FD_MAX_BUFFER_SIZE]; static unsigned char fd_driver_enabled; static void dummy_tr_Init (int device, int baudrate, void (callback_function (void))); static unsigned long dummy_tr_ReadNChars (int device, char *buffer, unsigned long chars_to_read); static unsigned long dummy_tr_ReadNBytes (T_tr_UartId device, char *buffer, unsigned long chars_to_read, unsigned char *eof_detected); static unsigned long dummy_tr_WriteNChars (int device, char *buffer, unsigned long chars_to_write); static unsigned long dummy_tr_EncapsulateNChars (T_tr_UartId device, char *buffer, unsigned long chars_to_write); static unsigned long dummy_tr_WriteNBytes (T_tr_UartId device, unsigned char *buffer, unsigned long chars_to_write); static void dummy_tr_WriteChar (int device, char character); static void dummy_tr_WriteString (int device, char *buffer); static unsigned char dummy_tr_EnterSleep (T_tr_UartId device); static void dummy_tr_WakeUp (T_tr_UartId device); static T_FDRET dummy_fd_Init (T_fd_UartId uartNo); static T_FDRET dummy_fd_Enable (T_fd_UartId uartNo, unsigned char enable); static T_FDRET dummy_fd_SetComPar (T_fd_UartId uartNo, T_baudrate baudrate, T_bitsPerCharacter bpc, T_stopBits sb, T_parity parity); static T_FDRET dummy_fd_SetBuffer (T_fd_UartId uartNo, unsigned short bufSize, unsigned short rxThreshold, unsigned short txThreshold); static T_FDRET dummy_fd_SetFlowCtrl (T_fd_UartId uartNo, T_flowCtrlMode fcMode, unsigned char XON, unsigned char XOFF); static T_FDRET dummy_fd_SetEscape (T_fd_UartId uartNo, unsigned char escChar, unsigned short guardPeriod); static T_FDRET dummy_fd_InpAvail (T_fd_UartId uartNo); static T_FDRET dummy_fd_OutpAvail (T_fd_UartId uartNo); static T_FDRET dummy_fd_EnterSleep (T_fd_UartId uartNo); static T_FDRET dummy_fd_WakeUp (T_fd_UartId uartNo); static T_FDRET dummy_fd_ReadData (T_fd_UartId uartNo, T_suspendMode suspend, void (readOutFunc (unsigned char cldFromIrq, T_reInstMode *reInstall, unsigned char nsource, unsigned char *source[], unsigned short size[], unsigned long state))); static T_FDRET dummy_fd_WriteData (T_fd_UartId uartNo, T_suspendMode suspend, void (writeInFunc (unsigned char cldFromIrq, T_reInstMode *reInstall, unsigned char ndest, unsigned char *dest[], unsigned short size[]))); static T_FDRET dummy_fd_StopRec (T_fd_UartId uartNo); static T_FDRET dummy_fd_StartRec (T_fd_UartId uartNo); static T_FDRET dummy_fd_GetLineState (T_fd_UartId uartNo, unsigned long *state); static T_FDRET dummy_fd_SetLineState (T_fd_UartId uartNo, unsigned long state, unsigned long mask); static T_FDRET dummy_fd_CheckXEmpty (T_fd_UartId uartNo); // Arrays of pointers to functions const TR_DRV TR_Uart = { UA_Init, UA_ReadNChars, UA_ReadNBytes, UA_WriteNChars, UA_EncapsulateNChars, UA_WriteNBytes, UA_WriteChar, UA_WriteString, UA_EnterSleep, UA_WakeUp }; const TR_DRV TR_Dummy = { dummy_tr_Init, dummy_tr_ReadNChars, dummy_tr_ReadNBytes, dummy_tr_WriteNChars, dummy_tr_EncapsulateNChars, dummy_tr_WriteNBytes, dummy_tr_WriteChar, dummy_tr_WriteString, dummy_tr_EnterSleep, dummy_tr_WakeUp }; const TR_DRV TR_Csmi = { CU_Init, CU_ReadNChars, CU_ReadNBytes, CU_WriteNChars, CU_EncapsulateNChars, CU_WriteNBytes, CU_WriteChar, CU_WriteString, CU_EnterSleep, CU_WakeUp }; const FD_DRV FD_Uart = { UAF_Init, UAF_Enable, UAF_SetComPar, UAF_SetBuffer, UAF_SetFlowCtrl, UAF_SetEscape, UAF_InpAvail, UAF_OutpAvail, UAF_EnterSleep, UAF_WakeUp, UAF_ReadData, UAF_WriteData, UAF_StopRec, UAF_StartRec, UAF_GetLineState, UAF_SetLineState, UAF_CheckXEmpty }; const FD_DRV FD_Csmi = { CF_Init, CF_Enable, CF_SetComPar, CF_SetBuffer, CF_SetFlowCtrl, CF_SetEscape, CF_InpAvail, CF_OutpAvail, dummy_fd_EnterSleep, dummy_fd_WakeUp, CF_ReadData, CF_WriteData, CF_StopRec, CF_StartRec, CF_GetLineState, CF_SetLineState, dummy_fd_CheckXEmpty }; const FD_DRV FD_Dummy = { dummy_fd_Init, dummy_fd_Enable, dummy_fd_SetComPar, dummy_fd_SetBuffer, dummy_fd_SetFlowCtrl, dummy_fd_SetEscape, dummy_fd_InpAvail, dummy_fd_OutpAvail, dummy_fd_EnterSleep, dummy_fd_WakeUp, dummy_fd_ReadData, dummy_fd_WriteData, dummy_fd_StopRec, dummy_fd_StartRec, dummy_fd_GetLineState, dummy_fd_SetLineState, dummy_fd_CheckXEmpty }; #define MAX_TRACE_STREAMS 4 #define MAX_FD_STREAMS 2 /* * The board's serial configuration includes : * an array of trace drivers, each with its associated UART identifier * a data driver, also with its UART identifier * */ typedef struct { const TR_DRV *trDrv; int trId; } T_TRACE_CONFIG; typedef struct { const FD_DRV *fdDrv; int fdId; } T_DATA_CONFIG; typedef struct { T_TRACE_CONFIG trCfg[MAX_TRACE_STREAMS]; T_DATA_CONFIG fdCfg[MAX_FD_STREAMS]; } T_SERIAL_CONFIG; /* * All possible serial configurations are described in this table */ const T_SERIAL_CONFIG serialConfigs[] = { // serial config 0 : TEST & DEBUG configuration // - Riviera trace (1) on serial port 1 (gsm uart modem) // - fax & data Dummy { { { &TR_Dummy, -1 }, { &TR_Uart, 1 }, { &TR_Dummy, -1 }, { &TR_Dummy, -1 }, }, { { &FD_Dummy, -1 }, { &FD_Dummy, -1 } }, }, // serial config 1 : TEST & DEBUG configuration // - trace (0) Dummy // - fax & data on serial port 1 (gsm uart modem) { { { &TR_Dummy, -1 }, { &TR_Dummy, -1 }, { &TR_Dummy, -1 }, { &TR_Dummy, -1 }, }, { { &FD_Uart, 1 }, { &FD_Dummy, -1 } }, }, // serial config 2 : PRODUCTION configuration // - Riviera trace (Dummy for debug) // - fax & data on CSMI port 5 (Fax Data #0) { { { &TR_Dummy, -1 }, { &TR_Dummy, -1 }, { &TR_Dummy, -1 }, { &TR_Dummy, -1 }, }, { { &FD_Csmi, 0 }, { &FD_Dummy, -1 } }, }, // serial config 3 : PRODUCTION configuration (FaxData with dual port) // - Riviera trace (Dummy for debug) // - fax & data on CSMI port 5 and 6 (Fax Data #0 and #1) { { { &TR_Dummy, -1 }, { &TR_Dummy, -1 }, { &TR_Dummy, -1 }, { &TR_Dummy, -1 }, }, { { &FD_Csmi, 0 }, { &FD_Csmi, 1 } }, }, // serial config 4 : TEST & DEBUG configuration (for ANITE dial up networking) // - trace (0) dummy // - fax & data on serial port 1 (gsm uart modem) { { { &TR_Dummy, -1 }, { &TR_Dummy, -1 }, { &TR_Dummy, -1 }, { &TR_Dummy, -1 }, }, { { &FD_Uart, 1 }, { &FD_Dummy, -1 } }, }, // serial config 5 : TEST & DEBUG configuration // - trace (1) dummy // - fax & data on serial port 1 (gsm uart modem) { { { &TR_Dummy, -1 }, { &TR_Dummy, -1 }, { &TR_Dummy, -1 }, { &TR_Dummy, -1 }, }, { { &FD_Uart, 1 }, { &FD_Dummy, -1 } }, }, // serial config 6 : TEST & DEBUG configuration (CSMI debug) // - Riviera trace (1) on serial port 1 (gsm uart modem) // - fax & data on CSMI { { { &TR_Dummy, -1 }, { &TR_Uart, 1 }, { &TR_Dummy, -1 }, { &TR_Dummy, -1 }, }, { { &FD_Csmi, 0 }, { &FD_Csmi, 1 } }, }, // serial config 7 : TEST & DEBUG configuration (stand-alone) // - Riviera trace (1) on csmi trace port // - fax & data on CSMI { { { &TR_Dummy, -1 }, { &TR_Csmi, 0 }, { &TR_Dummy, -1 }, { &TR_Dummy, -1 }, }, { { &FD_Csmi, 0 }, { &FD_Csmi, 1 } }, }, // serial config 8 : TEST & DEBUG configuration for PGT // - trace (0) on serial port 1 (gsm uart modem) // - fax & data Dummy { { { &TR_Uart, 1 }, { &TR_Dummy, -1 }, { &TR_Dummy, -1 }, { &TR_Dummy, -1 }, }, { { &FD_Dummy, -1 }, { &FD_Dummy, -1 } }, } }; const T_SERIAL_CONFIG *serialConfigP; // Physical UART data structures static T_UART int_uart[2]; static SYS_UWORD32 uart_spurious_interrupts; /******************************************************************************* * * analyze_uart_wake_up_timer_expiration * * Purpose : The wake-up time duration has just expired. If requested, UARTs * can again be set up to enter Deep Sleep. * * Arguments: In : id: parameter not used. * Out: none * * Returns : none * ******************************************************************************/ void analyze_uart_wake_up_timer_expiration (UNSIGNED id) { /* * Wake-up time duration has expired. * UARTs can again be set up for Deep Sleep. */ (void) NU_Control_Timer (&uart_wake_up_duration_timer, NU_DISABLE_TIMER); uart_waked_up_by_interrupt = 0; } /******************************************************************************* * * start_uart_wake_up_timer * * Purpose : Starts the wake-up duration timer once UARTs have been waked-up * by an interrupt. * * Arguments: In : none * Out: none * * Returns : none * ******************************************************************************/ void start_uart_wake_up_timer (void) { /* * Wake-up duration timer is started. * UARTs can't no more be set up for Deep Sleep until the timer expires. */ (void) NU_Reset_Timer (&uart_wake_up_duration_timer, &analyze_uart_wake_up_timer_expiration, WAKE_UP_TIME_IN_TDMA, 0, /* The timer expires once. */ NU_DISABLE_TIMER); (void) NU_Control_Timer (&uart_wake_up_duration_timer, NU_ENABLE_TIMER); } /******************************************************************************* * * SER_WriteConfig * * Purpose: TBD * * Parameters: In : new_config: TBD * write_to_flash: TBD * Out: none * * Return: 0 (FALSE) : In case of error while trying to write file in FFS * >= 1 (TRUE) : Successful operation. * ******************************************************************************/ SYS_BOOL SER_WriteConfig (char *new_config, SYS_BOOL write_to_flash) { // Dummy function to make the linker happy. (SER_WriteConfig is called by cst) SYS_BOOL status = 0; return (status); } /******************************************************************************* * * SER_ImmediateSwitch * * Purpose: TBD * * Parameters: In : none * Out: none * * Return: 0 (FALSE) : In case of error. * >= 1 (TRUE) : Successful operation. * ******************************************************************************/ SYS_BOOL SER_ImmediateSwitch (void) { // Dummy function to make the linker happy. (SER_ImmediateSwitch is called by cst) SYS_BOOL status = 0; return (status); } /* * SER_InitSerialConfig * * */ void SER_InitSerialConfig (int cfg) { int uart_id; SYS_BOOL uart_used; /* * Basic UARTs initializations. */ for (uart_id = 0; uart_id < NUMBER_OF_UART; uart_id++) { int_uart[uart_id].base_address = uart_base_address[uart_id]; int_uart[uart_id].device_used = 0; int_uart[uart_id].deep_sleep_set_up = 0; } uart_spurious_interrupts = 0; uart_waked_up_by_interrupt = 0; // Install the 2 interrupt handlers for each serial config switch (cfg) { case 0: int_uart[0].interrupt_handler = DISABLE_UART_INTERRUPT_HANDLER; int_uart[1].interrupt_handler = UA_InterruptHandler; break; case 1: int_uart[0].device_used = 0; int_uart[0].interrupt_handler = DISABLE_UART_INTERRUPT_HANDLER; int_uart[1].device_used = 1; int_uart[1].flow_id = 1; int_uart[1].flow_type = FAX_DATA_FLOW; int_uart[1].interrupt_handler = UAF_InterruptHandler; break; case 2: int_uart[0].interrupt_handler = DISABLE_UART_INTERRUPT_HANDLER; int_uart[1].interrupt_handler = DISABLE_UART_INTERRUPT_HANDLER; break; case 3: int_uart[0].interrupt_handler = DISABLE_UART_INTERRUPT_HANDLER; int_uart[1].interrupt_handler = DISABLE_UART_INTERRUPT_HANDLER; break; case 4: int_uart[0].interrupt_handler = DISABLE_UART_INTERRUPT_HANDLER; int_uart[1].interrupt_handler = UAF_InterruptHandler; break; case 5: int_uart[0].interrupt_handler = DISABLE_UART_INTERRUPT_HANDLER; int_uart[1].interrupt_handler = UAF_InterruptHandler; break; case 6: int_uart[0].device_used = 0; int_uart[0].interrupt_handler = DISABLE_UART_INTERRUPT_HANDLER; int_uart[1].device_used = 1; int_uart[1].flow_id = 1; int_uart[1].flow_type = TRACE_FLOW; int_uart[1].interrupt_handler = UA_InterruptHandler; break; case 7: int_uart[0].interrupt_handler = DISABLE_UART_INTERRUPT_HANDLER; int_uart[1].interrupt_handler = DISABLE_UART_INTERRUPT_HANDLER; break; case 8: int_uart[0].interrupt_handler = DISABLE_UART_INTERRUPT_HANDLER; int_uart[1].interrupt_handler = UA_InterruptHandler; break; default : cfg=0; int_uart[0].interrupt_handler = DISABLE_UART_INTERRUPT_HANDLER; int_uart[1].interrupt_handler = UA_InterruptHandler; break; } serialConfigP = &serialConfigs[cfg]; /* * Checks if both UARTs are used. * If not, performs minimum initialization including Sleep Mode. */ uart_used = 0; for (uart_id = 0; uart_id < NUMBER_OF_UART; uart_id++) { if (!(int_uart[uart_id].device_used)) initialize_uart_sleep (uart_id); else /* if (int_uart[uart_id].device_used) */ uart_used = 1; /* At least one UART is used */ } /* * If at least one uart is used, create a timer to control the wake-up * time duration. */ if (uart_used) (void) NU_Create_Timer ( &uart_wake_up_duration_timer, "Wake Up", &analyze_uart_wake_up_timer_expiration, 0, /* Parameter supplied to the routine: not used. */ WAKE_UP_TIME_IN_TDMA, 0, /* The timer expires once. */ NU_DISABLE_TIMER); } void SER_tr_Init (int id, int baudrate, void (callback_function (void))) { const TR_DRV *trDrv; int trId; trDrv = serialConfigP->trCfg[id].trDrv; trId = serialConfigP->trCfg[id].trId; (trDrv->tr_Init)(trId, baudrate, callback_function); } unsigned long SER_tr_ReadNChars (int id, char *buffer, unsigned long chars_to_read) { const TR_DRV *trDrv; int trId; trDrv = serialConfigP->trCfg[id].trDrv; trId = serialConfigP->trCfg[id].trId; return ((trDrv->tr_ReadNChars)(trId, buffer, chars_to_read)); } unsigned long SER_tr_ReadNBytes (int id, char *buffer, unsigned long chars_to_read, unsigned char *eof_detected) { const TR_DRV *trDrv; int trId; trDrv = serialConfigP->trCfg[id].trDrv; trId = serialConfigP->trCfg[id].trId; return ((trDrv->tr_ReadNBytes) (trId, buffer, chars_to_read, eof_detected)); } unsigned long SER_tr_WriteNChars (int id, char *buffer, unsigned long chars_to_write) { const TR_DRV *trDrv; int trId; trDrv = serialConfigP->trCfg[id].trDrv; trId = serialConfigP->trCfg[id].trId; return ((trDrv->tr_WriteNChars)(trId, buffer, chars_to_write)); } unsigned long SER_tr_EncapsulateNChars (int id, char *buffer, unsigned long chars_to_write) { const TR_DRV *trDrv; int trId; trDrv = serialConfigP->trCfg[id].trDrv; trId = serialConfigP->trCfg[id].trId; return ((trDrv->tr_EncapsulateNChars) (trId, buffer, chars_to_write)); } unsigned long SER_tr_WriteNBytes (int id, unsigned char *buffer, unsigned long chars_to_write) { const TR_DRV *trDrv; int trId; trDrv = serialConfigP->trCfg[id].trDrv; trId = serialConfigP->trCfg[id].trId; return ((trDrv->tr_WriteNBytes) (trId, buffer, chars_to_write)); } void SER_tr_WriteChar (int id, char character) { const TR_DRV *trDrv; int trId; trDrv = serialConfigP->trCfg[id].trDrv; trId = serialConfigP->trCfg[id].trId; (trDrv->tr_WriteChar)(trId, character); } void SER_tr_WriteString (int id, char *buffer) { const TR_DRV *trDrv; int trId; trDrv = serialConfigP->trCfg[id].trDrv; trId = serialConfigP->trCfg[id].trId; (trDrv->tr_WriteString)(trId, buffer); } unsigned char SER_tr_EnterSleep (int id) { const TR_DRV *trDrv; int trId; trDrv = serialConfigP->trCfg[id].trDrv; trId = serialConfigP->trCfg[id].trId; return ((trDrv->tr_EnterSleep) (trId)); } void SER_tr_WakeUp (int id) { const TR_DRV *trDrv; int trId; trDrv = serialConfigP->trCfg[id].trDrv; trId = serialConfigP->trCfg[id].trId; (trDrv->tr_WakeUp) (trId); } /* * SER_fd_xx : Fax/data functions * */ T_FDRET SER_fd_Init(void) { return UF_Init (0); } T_FDRET SER_fd_Enable (unsigned char enable) { return UF_Enable (0, enable); } T_FDRET SER_fd_SetComPar (T_baudrate baudrate, T_bitsPerCharacter bpc, T_stopBits sb, T_parity parity) { return UF_SetComPar (0, baudrate, bpc, sb, parity); } T_FDRET SER_fd_SetBuffer (unsigned short bufSize, unsigned short rxThreshold, unsigned short txThreshold) { return UF_SetBuffer (0, bufSize, rxThreshold, txThreshold); } T_FDRET SER_fd_SetFlowCtrl (T_flowCtrlMode fcMode, unsigned char XON, unsigned char XOFF) { return UF_SetFlowCtrl (0, fcMode, XON, XOFF); } T_FDRET SER_fd_SetEscape (char escChar, unsigned short guardPeriod) { return UF_SetEscape (0, escChar, guardPeriod); } T_FDRET SER_fd_InpAvail (void) { return UF_InpAvail (0); } T_FDRET SER_fd_OutpAvail (void) { return UF_OutpAvail (0); } T_FDRET SER_fd_EnterSleep (void) { return UF_EnterSleep (0); } T_FDRET SER_fd_WakeUp (void) { UF_WakeUp (0); } T_FDRET SER_fd_ReadData (T_suspendMode suspend, void (readOutFunc (unsigned char cldFromIrq, T_reInstMode *reInstall, unsigned char nsource, unsigned char *source[], unsigned short size[], unsigned long state))) { return UF_ReadData (0, suspend, readOutFunc); } T_FDRET SER_fd_WriteData (T_suspendMode suspend, void (writeInFunc (unsigned char cldFromIrq, T_reInstMode *reInstall, unsigned char ndest, unsigned char *dest[], unsigned short size[]))) { return UF_WriteData (0, suspend, writeInFunc); } T_FDRET SER_fd_StopRec (void) { return UF_StopRec(0); } T_FDRET SER_fd_StartRec (void) { return UF_StartRec(0); } T_FDRET SER_fd_GetLineState (unsigned long *state) { return UF_GetLineState(0, state); } T_FDRET SER_fd_SetLineState (unsigned long state, unsigned long mask) { return UF_SetLineState(0, state, mask); } T_FDRET SER_fd_CheckXEmpty (void) { return UF_CheckXEmpty(0); } /* * * SER_int_uart_handlerx * * Internal UART interrupt handler. * * Perseus has 2 internal UARTs, each with its own interrupt vector * */ void SER_uart_irda_handler (void) { SYS_UWORD8 interrupt_status; T_UART *uart; int uart_id; uart_id = 0; uart = &(int_uart[0]); // clear UART interrupt interrupt_status = READ_UART_REGISTER (uart, IIR) & IIR_BITS_USED; // call interrupt handler if necessary if(uart->interrupt_handler != DISABLE_UART_INTERRUPT_HANDLER) (*(uart->interrupt_handler)) (uart_id, interrupt_status); } void SER_uart_modem_handler (void) { SYS_UWORD8 interrupt_status; T_UART *uart; SYS_BOOL it_wakeup_identified; int uart_id; uart_id = 1; it_wakeup_identified = 0; uart = &(int_uart[1]); /* * Check first for a wake-up interrupt. */ interrupt_status = READ_UART_REGISTER (uart, SSR); if (interrupt_status & RX_CTS_WAKE_UP_STS) { /* Wake-up IT has occurred */ it_wakeup_identified = 1; uart_waked_up_by_interrupt = 1; DISABLE_WAKE_UP_INTERRUPT (uart); } /* * If no wake-up interrupt has been detected, check UART for other * interrupt causes. */ if (!it_wakeup_identified) { // clear UART interrupt interrupt_status = READ_UART_REGISTER (uart, IIR) & IIR_BITS_USED; if (!(interrupt_status & IT_NOT_PENDING)) (*(uart->interrupt_handler)) (uart_id, interrupt_status); else uart_modem_spurious_interrupts++; } } T_FDRET UF_Init (int uartNo) { const FD_DRV *fdDrv; int fdId; fdDrv = serialConfigP->fdCfg[uartNo].fdDrv; fdId = serialConfigP->fdCfg[uartNo].fdId; return ((fdDrv->fd_Init)(fdId)); } T_FDRET UF_Enable (int uartNo, SYS_BOOL enable) { const FD_DRV *fdDrv; int fdId; fdId = serialConfigP->fdCfg[uartNo].fdId; fdDrv = serialConfigP->fdCfg[uartNo].fdDrv; return((fdDrv->fd_Enable)(fdId, enable)); } short UF_SetComPar (int uartNo, T_baudrate baudrate, T_bitsPerCharacter bpc, T_stopBits sb, T_parity parity) { const FD_DRV *fdDrv; int fdId; fdId = serialConfigP->fdCfg[uartNo].fdId; fdDrv = serialConfigP->fdCfg[uartNo].fdDrv; return((fdDrv->fd_SetComPar)(fdId, baudrate, bpc, sb, parity)); } short UF_SetBuffer (int uartNo, unsigned short bufSize, unsigned short rxThreshold, unsigned short txThreshold) { const FD_DRV *fdDrv; int fdId; fdId = serialConfigP->fdCfg[uartNo].fdId; fdDrv = serialConfigP->fdCfg[uartNo].fdDrv; return((fdDrv->fd_SetBuffer)(fdId, bufSize, rxThreshold, txThreshold)); } short UF_SetFlowCtrl (int uartNo, T_flowCtrlMode fcMode, unsigned char XON, unsigned char XOFF) { const FD_DRV *fdDrv; int fdId; fdId = serialConfigP->fdCfg[uartNo].fdId; fdDrv = serialConfigP->fdCfg[uartNo].fdDrv; return((fdDrv->fd_SetFlowCtrl)(fdId, fcMode, XON, XOFF)); } short UF_SetEscape (int uartNo, char escChar, unsigned short guardPeriod) { const FD_DRV *fdDrv; int fdId; fdId = serialConfigP->fdCfg[uartNo].fdId; fdDrv = serialConfigP->fdCfg[uartNo].fdDrv; return ((fdDrv->fd_SetEscape) (fdId, escChar, guardPeriod)); } T_FDRET UF_InpAvail (int uartNo) { const FD_DRV *fdDrv; int fdId; fdId = serialConfigP->fdCfg[uartNo].fdId; fdDrv = serialConfigP->fdCfg[uartNo].fdDrv; return ((fdDrv->fd_InpAvail) (fdId)); } T_FDRET UF_OutpAvail (int uartNo) { const FD_DRV *fdDrv; int fdId; fdId = serialConfigP->fdCfg[uartNo].fdId; fdDrv = serialConfigP->fdCfg[uartNo].fdDrv; return ((fdDrv->fd_OutpAvail) (fdId)); } short UF_EnterSleep (int uartNo) { const FD_DRV *fdDrv; int fdId; fdId = serialConfigP->fdCfg[uartNo].fdId; fdDrv = serialConfigP->fdCfg[uartNo].fdDrv; return ((fdDrv->fd_EnterSleep) (fdId)); } short UF_WakeUp (int uartNo) { const FD_DRV *fdDrv; int fdId; fdId = serialConfigP->fdCfg[uartNo].fdId; fdDrv = serialConfigP->fdCfg[uartNo].fdDrv; return ((fdDrv->fd_WakeUp) (fdId)); } short UF_ReadData (int uartNo, T_suspendMode suspend, void (readOutFunc (unsigned char cldFromIrq, T_reInstMode *reInstall, unsigned char nsource, unsigned char *source[], unsigned short size[], unsigned long state))) { const FD_DRV *fdDrv; int fdId; fdId = serialConfigP->fdCfg[uartNo].fdId; fdDrv = serialConfigP->fdCfg[uartNo].fdDrv; return ((fdDrv->fd_ReadData) (fdId, suspend, readOutFunc)); } short UF_WriteData (int uartNo, T_suspendMode suspend, void (writeInFunc (unsigned char cldFromIrq, T_reInstMode *reInstall, unsigned char ndest, unsigned char *dest[], unsigned short size[]))) { const FD_DRV *fdDrv; int fdId; fdId = serialConfigP->fdCfg[uartNo].fdId; fdDrv = serialConfigP->fdCfg[uartNo].fdDrv; return ((fdDrv->fd_WriteData) (fdId, suspend, writeInFunc)); } short UF_StopRec (int uartNo) { const FD_DRV *fdDrv; int fdId; fdId = serialConfigP->fdCfg[uartNo].fdId; fdDrv = serialConfigP->fdCfg[uartNo].fdDrv; return ((fdDrv->fd_StopRec) (fdId)); } short UF_StartRec (int uartNo) { const FD_DRV *fdDrv; int fdId; fdId = serialConfigP->fdCfg[uartNo].fdId; fdDrv = serialConfigP->fdCfg[uartNo].fdDrv; return ((fdDrv->fd_StartRec) (fdId)); } short UF_GetLineState (int uartNo, unsigned long *state) { const FD_DRV *fdDrv; int fdId; fdId = serialConfigP->fdCfg[uartNo].fdId; fdDrv = serialConfigP->fdCfg[uartNo].fdDrv; return ((fdDrv->fd_GetLineState) (fdId, state)); } short UF_SetLineState (int uartNo, unsigned long state, unsigned long mask) { const FD_DRV *fdDrv; int fdId; fdId = serialConfigP->fdCfg[uartNo].fdId; fdDrv = serialConfigP->fdCfg[uartNo].fdDrv; return ((fdDrv->fd_SetLineState) (fdId, state, mask)); } short UF_CheckXEmpty (int uartNo) { const FD_DRV *fdDrv; int fdId; fdId = serialConfigP->fdCfg[uartNo].fdId; fdDrv = serialConfigP->fdCfg[uartNo].fdDrv; return ((fdDrv->fd_CheckXEmpty) (fdId)); } /******************************************************************************* * * dummy_tr_Init * * Purpose: No action. * * Parameters: See SER_tr_Init. * * Return: none * ******************************************************************************/ static void dummy_tr_Init (int device, int baudrate, void (callback_function (void))) { /* * No action. */ } /******************************************************************************* * * dummy_tr_ReadNChars * * Purpose: No action. * * Parameters: See SER_tr_ReadNChars. * * Return: 0 * ******************************************************************************/ static unsigned long dummy_tr_ReadNChars (int device, char *buffer, unsigned long chars_to_read) { return (0); } /******************************************************************************* * * dummy_tr_ReadNBytes * * Purpose: No action. * * Parameters: See SER_tr_ReadNBytes. * * Return: 0 * ******************************************************************************/ static unsigned long dummy_tr_ReadNBytes (T_tr_UartId device, char *buffer, unsigned long chars_to_read, unsigned char *eof_detected) { return (0); } /******************************************************************************* * * dummy_tr_WriteNChars * * Purpose: No action. * * Parameters: See SER_tr_WriteNChars. * * Return: The number of character to write. * ******************************************************************************/ static unsigned long dummy_tr_WriteNChars (int device, char *buffer, unsigned long chars_to_write) { return (chars_to_write); } /******************************************************************************* * * dummy_tr_EncapsulateNChars * * Purpose: No action. * * Parameters: See SER_tr_EncapsulateNChars. * * Return: The number of character to write. * ******************************************************************************/ static unsigned long dummy_tr_EncapsulateNChars (T_tr_UartId device, char *buffer, unsigned long chars_to_write) { return (chars_to_write); } /******************************************************************************* * * dummy_tr_WriteNBytes * * Purpose: No action. * * Parameters: See SER_tr_WriteNBytes. * * Return: The number of byte to write. * ******************************************************************************/ static unsigned long dummy_tr_WriteNBytes (T_tr_UartId device, unsigned char *buffer, unsigned long chars_to_write) { return (chars_to_write); } /******************************************************************************* * * dummy_tr_WriteChar * * Purpose: No action. * * Parameters: See SER_tr_WriteChar. * * Return: none * ******************************************************************************/ static void dummy_tr_WriteChar (int device, char character) { /* * No action. */ } /******************************************************************************* * * dummy_tr_WriteString * * Purpose: No action. * * Parameters: See SER_tr_WriteString. * * Return: none * ******************************************************************************/ static void dummy_tr_WriteString (int device, char *buffer) { /* * No action. */ } /******************************************************************************* * * dummy_tr_EnterSleep * * Purpose: No action. * * Parameters: See SER_tr_EnterSleep. * * Return: 1 * ******************************************************************************/ static unsigned char dummy_tr_EnterSleep (T_tr_UartId device) { return (1); } /******************************************************************************* * * dummy_tr_WakeUp * * Purpose: No action. * * Parameters: See SER_tr_WakeUp. * * Return: none * ******************************************************************************/ static void dummy_tr_WakeUp (T_tr_UartId device) { /* * No action. */ } /******************************************************************************* * * dummy_fd_Init * * Purpose: Sets the size of the circular buffer to the maximum value and the * state of the driver to 'disabled'. * * Parameters: See SER_fd_Init. * * Return: FD_OK: Successful operation. * ******************************************************************************/ static T_FDRET dummy_fd_Init (T_fd_UartId uartNo) { fd_bufSize = FD_MAX_BUFFER_SIZE; fd_driver_enabled = 0; return (FD_OK); } /******************************************************************************* * * dummy_fd_Enable * * Purpose: Stores the state of the driver. * * Parameters: See SER_fd_Enable. * * Return: FD_OK: Successful operation. * ******************************************************************************/ static T_FDRET dummy_fd_Enable (T_fd_UartId uartNo, unsigned char enable) { fd_driver_enabled = enable; return (FD_OK); } /******************************************************************************* * * dummy_fd_SetComPar * * Purpose: No action. * * Parameters: See SER_fd_SetComPar. * * Return: FD_OK: Successful operation. * ******************************************************************************/ static T_FDRET dummy_fd_SetComPar (T_fd_UartId uartNo, T_baudrate baudrate, T_bitsPerCharacter bpc, T_stopBits sb, T_parity parity) { return (FD_OK); } /******************************************************************************* * * dummy_fd_SetBuffer * * Purpose: Stores the size of the circular buffer. * * Parameters: See SER_fd_SetBuffer. * * Return: FD_OK: Successful operation. * ******************************************************************************/ static T_FDRET dummy_fd_SetBuffer (T_fd_UartId uartNo, unsigned short bufSize, unsigned short rxThreshold, unsigned short txThreshold) { fd_bufSize = bufSize; return (FD_OK); } /******************************************************************************* * * dummy_fd_SetFlowCtrl * * Purpose: No action. * * Parameters: See SER_fd_SetFlowCtrl. * * Return: FD_OK: Successful operation. * ******************************************************************************/ static T_FDRET dummy_fd_SetFlowCtrl (T_fd_UartId uartNo, T_flowCtrlMode fcMode, unsigned char XON, unsigned char XOFF) { return (FD_OK); } /******************************************************************************* * * dummy_fd_SetEscape * * Purpose: No action. * * Parameters: See SER_fd_SetEscape. * * Return: FD_OK: Successful operation. * ******************************************************************************/ static T_FDRET dummy_fd_SetEscape (T_fd_UartId uartNo, unsigned char escChar, unsigned short guardPeriod) { return (FD_OK); } /******************************************************************************* * * dummy_fd_InpAvail * * Purpose: No action. * * Parameters: See SER_fd_InpAvail. * * Return: The size of the circular buffer. * ******************************************************************************/ static T_FDRET dummy_fd_InpAvail (T_fd_UartId uartNo) { return (fd_bufSize); } /******************************************************************************* * * dummy_fd_OutpAvail * * Purpose: No action. * * Parameters: See SER_fd_OutpAvail. * * Return: The size of the circular buffer. * ******************************************************************************/ static T_FDRET dummy_fd_OutpAvail (T_fd_UartId uartNo) { return (fd_bufSize); } /******************************************************************************* * * dummy_fd_EnterSleep * * Purpose: No action. * * Parameters: See SER_tr_EnterSleep. * * Return: 1 * ******************************************************************************/ static T_FDRET dummy_fd_EnterSleep (T_fd_UartId uartNo) { return (1); } /******************************************************************************* * * dummy_fd_WakeUp * * Purpose: No action. * * Parameters: See SER_tr_WakeUp. * * Return: FD_OK: Successful operation. * ******************************************************************************/ static T_FDRET dummy_fd_WakeUp (T_fd_UartId uartNo) { return (FD_OK); } /******************************************************************************* * * dummy_fd_ReadData * * Purpose: No action. * * Parameters: See SER_fd_ReadData. * * Return: 0 if the suspend parameter is set to 'sm_noSuspend'. * FD_SUSPENDED if the suspend parameter is set to 'sm_suspend'. * ******************************************************************************/ static T_FDRET dummy_fd_ReadData (T_fd_UartId uartNo, T_suspendMode suspend, void (readOutFunc (unsigned char cldFromIrq, T_reInstMode *reInstall, unsigned char nsource, unsigned char *source[], unsigned short size[], unsigned long state))) { T_FDRET result; if (suspend == sm_noSuspend) result = 0; else result = FD_SUSPENDED; return (result); } /******************************************************************************* * * dummy_fd_WriteData * * Purpose: The user's function is called with: * - cldFromIrq = 0 * - ndest = 1 * - dest[0] is a unsigned char pointer on the beginning address of a local * buffer * - size[0] is set to fd_bufSize. * * Parameters: See SER_fd_WriteData. * * Return: The number of bytes written in the local buffer. * ******************************************************************************/ static T_FDRET dummy_fd_WriteData (T_fd_UartId uartNo, T_suspendMode suspend, void (writeInFunc (unsigned char cldFromIrq, T_reInstMode *reInstall, unsigned char ndest, unsigned char *dest[], unsigned short size[]))) { T_reInstMode dummyInstall; unsigned char *destination[2]; unsigned short buffer_size[2]; destination[0] = &(fd_buffer[0]); buffer_size[0] = fd_bufSize; (*writeInFunc) (0, &dummyInstall, 1, &(destination[0]), &(buffer_size[0])); return ((T_FDRET) (fd_bufSize - buffer_size[0])); } /******************************************************************************* * * dummy_fd_StopRec * * Purpose: No action. * * Parameters: See SER_fd_StopRec. * * Return: FD_OK: Successful operation. * ******************************************************************************/ static T_FDRET dummy_fd_StopRec (T_fd_UartId uartNo) { return (FD_OK); } /******************************************************************************* * * dummy_fd_StartRec * * Purpose: No action. * * Parameters: See SER_fd_StartRec. * * Return: FD_OK: Successful operation. * ******************************************************************************/ static T_FDRET dummy_fd_StartRec (T_fd_UartId uartNo) { return (FD_OK); } /******************************************************************************* * * dummy_fd_GetLineState * * Purpose: Sets the RXBLEV field to the bufSize value. * * Parameters: See SER_fd_GetLineState. * * Return: FD_OK: Successful operation. * ******************************************************************************/ static T_FDRET dummy_fd_GetLineState (T_fd_UartId uartNo, unsigned long *state) { *state = fd_bufSize << RXBLEV; return (FD_OK); } /******************************************************************************* * * dummy_fd_SetLineState * * Purpose: No action. * * Parameters: See SER_fd_SetLineState. * * Return: FD_OK: Successful operation. * ******************************************************************************/ static T_FDRET dummy_fd_SetLineState (T_fd_UartId uartNo, unsigned long state, unsigned long mask) { return (FD_OK); } /******************************************************************************* * * dummy_fd_CheckXEmpty * * Purpose: No action. * * Parameters: See SER_fd_CheckXEmpty. * * Return: FD_OK: Successful operation. * ******************************************************************************/ static T_FDRET dummy_fd_CheckXEmpty (T_fd_UartId uartNo) { return (FD_OK); } /******************************************************************************* * * SER_UartSleepStatus * * Purpose: This function checks if both UARTs are ready to enter Deep Sleep. * * Parameters: In : none * Out: none * * Return: 0 : Deep Sleep is not possible. * >= 1 : Deep Sleep is possible. * ******************************************************************************/ unsigned char SER_UartSleepStatus (void) { T_UART *uart; int uart_id; SYS_BOOL status; /* * Check first if wake-up time duration is active. * A return is used to simplify the code. */ /* Wake-up duration timer has not yet expired. */ if (uart_waked_up_by_interrupt) return (0); /* * Check if both UARTs are ready to enter Deep Sleep. */ status = 1; uart_id = 0; while ((uart_id < NUMBER_OF_UART) && (status)) { uart = &(int_uart[uart_id]); /* * Check if the specified UART is actually used. */ if (uart->device_used) { /* * Check if the specified UART is used by a Trace or * by a Fax & Data flow. */ if (uart->flow_type == TRACE_FLOW) status = SER_tr_EnterSleep (uart->flow_id); else if (uart->flow_type == FAX_DATA_FLOW) status = (SYS_BOOL) SER_fd_EnterSleep (); else status = 0; if (status) { /* * The specified UART is now set up for Deep Sleep. */ uart->deep_sleep_set_up = 1; } } uart_id++; } /* * Check if Deep Sleep is finally possible. * If not revert eventual Deep Sleep settings. */ if (!status) { for (uart_id = 0; uart_id < NUMBER_OF_UART; uart_id++) { uart = &(int_uart[uart_id]); /* * If the specified used UART has already been set up for * Deep Sleep, revert these settings. */ if ((uart->device_used) && (uart->deep_sleep_set_up)) { /* * Check if the specified UART is used by a Trace or * by a Fax & Data flow. */ if (uart->flow_type == TRACE_FLOW) SER_tr_WakeUp (uart->flow_id); else /* if (uart->flow_type == FAX_DATA_FLOW) */ SER_fd_WakeUp (); uart->deep_sleep_set_up = 0; } } } return (status); } /******************************************************************************* * * SER_WakeUpUarts * * Purpose: This function wakes up used UARTs after Deep Sleep. * * Parameters: In : none * Out: none * * Return: none * ******************************************************************************/ void SER_WakeUpUarts (void) { T_UART *uart; int uart_id; if (uart_waked_up_by_interrupt) start_uart_wake_up_timer (); for (uart_id = 0; uart_id < NUMBER_OF_UART; uart_id++) { uart = &(int_uart[uart_id]); /* * Check if the specified UART is actually used, and has not yet * been waked up. */ if ((uart->device_used) && (uart->deep_sleep_set_up)) { /* * Check if the specified UART is used by a Trace or * by a Fax & Data flow. * Bluetooth HCI can not yet handled Deep Sleep Mode. */ if (uart->flow_type == TRACE_FLOW) SER_tr_WakeUp (uart->flow_id); else SER_fd_WakeUp (); /* * The specified UART is no more set up for Deep Sleep. */ uart->deep_sleep_set_up = 0; } } } #endif // end __SERIALSWITCH_C__