--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/chipsetsw/drivers/drv_app/uart/serialswitch_dp.c	Mon Jun 01 03:24:05 2015 +0000
@@ -0,0 +1,1962 @@
+/*******************************************************************************
+ *
+ * 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__
+