--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/gpf3/frame/vsi_drv.c	Sun Sep 25 23:52:50 2016 +0000
@@ -0,0 +1,688 @@
+/* 
++------------------------------------------------------------------------------
+|  File:       vsi_drv.c
++------------------------------------------------------------------------------
+|  Copyright 2002 Texas Instruments Berlin, AG 
+|                 All rights reserved. 
+| 
+|                 This file is confidential and a trade secret of Texas 
+|                 Instruments Berlin, AG 
+|                 The receipt of or possession of this file does not convey 
+|                 any rights to reproduce or disclose its contents or to 
+|                 manufacture, use, or sell anything it may describe, in 
+|                 whole, or in part, without the specific written consent of 
+|                 Texas Instruments Berlin, AG. 
++----------------------------------------------------------------------------- 
+|  Purpose :  This Module defines the virtual system interface part
+|             for driver access.
++----------------------------------------------------------------------------- 
+*/ 
+
+#ifndef __VSI_DRV_C__
+#define __VSI_DRV_C__
+#endif
+
+/*==== INCLUDES ===================================================*/
+
+#include "string.h"
+#include "stdio.h"
+#include "typedefs.h"
+
+#include "vsi.h"
+#include "gdi.h"
+#include "os.h"
+#ifdef _TOOLS_
+ #include "drvconf.h"
+#endif
+#include "frm_defs.h"
+#include "frm_types.h"
+#include "frm_glob.h"
+#include "frame.h"
+
+/*==== TYPES ======================================================*/
+
+
+#ifdef _TOOLS_
+typedef struct
+{
+  char Name[RESOURCE_NAMELEN];
+  char Process[RESOURCE_NAMELEN];
+  char DrvConfig[80];
+} _T_DRV_LIST_ENTRY;
+
+typedef struct
+{
+  _T_DRV_LIST_ENTRY DrvEntry [ 5 ];
+} _T_DRV_LIST;
+
+#endif
+
+/*==== CONSTANTS ==================================================*/
+
+
+/*==== EXTERNALS ==================================================*/
+
+/* -------------- S H A R E D - BEGIN ---------------- */
+#ifdef _TOOLS_
+#pragma data_seg("FRAME_SHARED") 
+#endif
+
+extern T_DRV_TABLE_ENTRY DrvTable [];
+
+/*==== VARIABLES ==================================================*/
+
+#undef EXTR_SEND_CONTROL
+#ifndef RUN_INT_RAM
+T_DRV_LIST *DriverConfigList;    /* pointer to start of driver cinfiguration list */
+static T_DRV_LIST *DriverList;   /* pointer to selected driver list */
+#ifdef EXTR_SEND_CONTROL
+FILE *fp;
+#endif
+#endif
+
+#ifdef _TOOLS_
+_T_DRV_LIST _DrvList={0};
+T_DRV_LIST DrvList={0};
+#endif
+
+#ifdef _TOOLS_
+#pragma data_seg()
+#endif /* _TOOLS_ */
+/* -------------- S H A R E D - END ---------------- */
+
+
+/*==== FUNCTIONS ==================================================*/
+
+void ClearDriverTable ( void );
+
+#ifndef RUN_INT_RAM
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-Frame (8415)           MODULE  : VSI_DRV             |
+| STATE   : code                       ROUTINE : vsi_d_create        |
++--------------------------------------------------------------------+
+
+  PURPOSE : enter a new driver in the driver list
+
+*/
+int vsi_d_create ( T_HANDLE caller, T_TST_DRV_ENTRY *drv_info )
+{
+T_HANDLE drv_handle;
+
+  drv_handle = drv_info->drv_pos;
+  vsi_d_exit ( caller, 0 );
+  DriverList->DrvEntry[drv_handle].drv_Init = drv_info->entry.drv_Init;
+  DriverList->DrvEntry[drv_handle].Name = drv_info->entry.Name;
+  DriverList->DrvEntry[drv_handle].Process = drv_info->entry.Process;
+  DriverList->DrvEntry[drv_handle].DrvConfig = drv_info->entry.DrvConfig;
+
+  ClearDriverTable();
+  vsi_d_init ( caller );
+  vsi_d_setsignal ( caller, 0, DRV_SIGTYPE_READ|DRV_SIGTYPE_CONNECT|DRV_SIGTYPE_DISCONNECT); 
+  vsi_d_setconfig ( caller, 0, NULL ); 
+  return VSI_OK;
+}
+#endif
+
+#ifndef RUN_INT_RAM
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-Frame (8415)           MODULE  : VSI_DRV             |
+| STATE   : code                       ROUTINE : vsi_d_callback      |
++--------------------------------------------------------------------+
+
+  PURPOSE : callback from a driver
+
+*/
+void vsi_d_callback ( T_DRV_SIGNAL *Signal )
+{
+T_HANDLE Caller;
+T_HANDLE DrvHandle;
+int sts;
+#ifdef EXTR_SEND_CONTROL
+OS_TIME time;
+T_PRIM_HEADER *p;
+static int cnt = 0;
+int bytes;
+#endif
+
+  Caller = Signal->DrvHandle;
+  DrvHandle = DrvTable[Caller].UpperDrv;
+  if ( DrvHandle )
+  {
+    if ( DrvTable[DrvHandle].DrvInfo->DrvFunc.drv_Callback != NULL )
+    {
+#if defined _TARGET_ && defined _NUCLEUS_
+      if ( DrvTable[Caller].DrvInfo->Flags & CALLED_FROM_ISR )
+        os_ExecuteCallback ( Caller, DrvTable[DrvHandle].DrvInfo->DrvFunc.drv_Callback, Signal ); 
+      else
+#endif
+        (DrvTable[DrvHandle].DrvInfo->DrvFunc.drv_Callback)( Signal );
+    }
+  }
+  else
+  {
+    if ( DrvTable[Caller].ProcessHandle )
+    {
+      OS_QDATA Msg;
+      OS_TIME time;
+      Msg.data16 = MSG_SIGNAL;
+      Msg.data32 = Signal->SignalType;
+      Msg.ptr = Signal->UserData;
+      os_GetTime ( 0, &time );
+      Msg.time = (ULONG)time;
+      Msg.e_id = DrvTable[Caller].ProcessHandle;
+#ifdef EXTR_SEND_CONTROL
+      if ( Msg.ptr )
+      {
+        os_GetTime(0,&time);
+        fp = fopen("test.txt", "a");
+        p = (T_PRIM_HEADER*)((T_PRIM_X*)Msg.ptr)->prim_ptr;
+        if ( p->opc == 0x8000 )
+        {
+          printf("EXTR: Start sending %s, time %d, %d\n", (char*)P2D(p),time, cnt & 1023  );
+          bytes = fprintf(fp, "EXTR: Start sending %s, time %d, %d\n", (char*)P2D(p),time, cnt & 1023  );
+        }
+        else
+        {
+          printf("EXTR: Start sending primitive, time %d, %d\n", time, cnt & 1023);
+          bytes = fprintf(fp, "EXTR: Start sending primitive, time %d, %d\n", time, cnt & 1023);
+        }
+        fclose(fp);
+      }
+#endif
+#ifdef _TOOLS_
+      sts = os_SendToQueue (NO_TASK, DrvTable[Caller].ProcessHandle, OS_NORMAL, OS_SUSPEND, &Msg );
+#else
+      sts = os_SendToQueue (NO_TASK, pf_TaskTable[DrvTable[Caller].ProcessHandle].QueueHandle, OS_NORMAL, OS_SUSPEND, &Msg );
+#endif
+#ifdef EXTR_SEND_CONTROL
+      os_GetTime(0,&time);
+      fp = fopen("test.txt", "a");
+      printf("EXTR: Complete sending, time %d %d\n", time, cnt & 1023);
+      bytes = fprintf(fp,"EXTR: Complete sending, time %d %d\n", time, cnt++ & 1023);
+      fclose(fp);
+#endif
+      /*
+       * This is a dirty patch, but due to the missing return value there is no other choice
+       */
+      if ( sts == OS_TIMEOUT || sts == OS_ERROR )
+      {
+        T_PRIM_X *sys_prim;
+
+        sys_prim = (T_PRIM_X*)Signal->UserData;
+        PFREE(P2D(sys_prim->prim_ptr));
+        PFREE(P2D(sys_prim));
+      }
+    }
+  }
+}
+#endif
+
+#ifndef RUN_INT_RAM
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-Frame (8415)           MODULE  : VSI_DRV             |
+| STATE   : code                       ROUTINE : vsi_d_init          |
++--------------------------------------------------------------------+
+
+  PURPOSE : initialize drivers
+
+*/
+/*lint -esym(644,DrvInfo) */
+int vsi_d_init ( T_HANDLE Caller )
+{
+T_DRV_EXPORT const *DrvInfo;
+USHORT i;
+SHORT sts;
+
+#ifdef EXTR_SEND_CONTROL
+   fp = fopen("test.txt", "a");
+   fprintf(fp,"=========================================================\n");
+   fclose (fp);
+#endif
+   for ( i = 1; i < MAX_TST_DRV; i++ )
+   {
+     sts = DRV_NOTCONFIGURED;
+#ifdef _TOOLS_
+     if ( DrvTable[i].DrvInfo )
+       sts = (SHORT)(DrvTable[i].DrvInfo->DrvFunc.drv_Init)(i,vsi_d_callback,&DrvInfo);
+     else
+#endif
+       if ( DriverList->DrvEntry[i].drv_Init )
+         sts = (SHORT)(DriverList->DrvEntry[i].drv_Init)(i,vsi_d_callback,&DrvInfo);
+     if ( sts == DRV_OK )
+     {
+       if ( DriverList->DrvEntry[i].Process )
+         DrvTable[i].ProcessHandle = vsi_c_open ( Caller, (char*)DriverList->DrvEntry[i].Process );
+       DrvTable[i].UpperDrv = i-1;
+       DrvTable[i-1].LowerDrv = i;
+       DrvTable[i].DrvInfo = DrvInfo;
+#if defined _TARGET_ && defined _NUCLEUS_
+       if ( DrvTable[i].DrvInfo->Flags & CALLED_FROM_ISR )
+         if ( os_CreateCallback() == OS_ERROR )
+           return VSI_ERROR;
+#endif
+     }
+     else
+     {
+       if ( sts != DRV_NOTCONFIGURED )
+       {
+         return VSI_ERROR;
+       }
+     }
+   }
+   return VSI_OK;
+}
+#endif
+
+#ifndef RUN_INT_RAM
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-Frame (8415)           MODULE  : VSI_DRV             |
+| STATE   : code                       ROUTINE : vsi_d_exit          |
++--------------------------------------------------------------------+
+
+  PURPOSE : exit drivers
+
+*/
+int vsi_d_exit ( T_HANDLE Caller, T_HANDLE DrvHandle )
+{
+T_HANDLE Handle;
+T_HANDLE min, max;
+
+  if ( DrvHandle )
+  {
+    min = DrvHandle;
+    max = DrvHandle+1;
+  }
+  else
+  {
+    min = 1;
+    max = MAX_TST_DRV;
+  }
+
+  for ( Handle = min; Handle < max; Handle++ )
+  {
+    if ( DrvTable[Handle].DrvInfo )
+    {
+      if ( DrvTable[Handle].DrvInfo->DrvFunc.drv_Exit != NULL )
+        (DrvTable[Handle].DrvInfo->DrvFunc.drv_Exit)();
+    }
+  }
+  return VSI_OK;
+}
+#endif
+
+#ifndef RUN_INT_RAM
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-Frame (8415)           MODULE  : VSI_DRV             |
+| STATE   : code                       ROUTINE : vsi_d_open          |
++--------------------------------------------------------------------+
+
+  PURPOSE : open a drivers
+
+*/
+int vsi_d_open ( T_HANDLE Caller, char *Name )
+{
+int i;
+
+  for ( i = 1; i <= MAX_TST_DRV; i++ )
+  {
+    if ( DrvTable[i].DrvInfo && DrvTable[i].DrvInfo->Name )
+      if ( !strcmp ( DrvTable[i].DrvInfo->Name, Name ) )
+        return (i);
+  }
+  return VSI_ERROR;
+}
+#endif
+
+#ifndef RUN_INT_RAM
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-Frame (8415)           MODULE  : VSI_DRV             |
+| STATE   : code                       ROUTINE : vsi_d_close         |
++--------------------------------------------------------------------+
+
+  PURPOSE : close a driver
+
+*/
+/*lint -esym(715,DrvHandle) suppress Info -- Symbol 'DrvHandle' not referenced */
+int vsi_d_close ( T_HANDLE Caller, T_HANDLE DrvHandle )
+{
+  
+  return VSI_OK;
+}
+#endif
+
+#ifndef RUN_INT_RAM
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-Frame (8415)           MODULE  : VSI_DRV             |
+| STATE   : code                       ROUTINE : vsi_d_read          |
++--------------------------------------------------------------------+
+
+  PURPOSE : read data from a driver
+
+*/
+int vsi_d_read ( T_HANDLE Caller, T_HANDLE DrvHandle, void *Buffer, ULONG *Size )
+{
+T_HANDLE Handle;
+
+  if ( DrvHandle )
+    Handle = DrvHandle;                  /* Caller TST: opened driver with vsi_d_open() */
+  else
+    Handle = DrvTable[Caller].LowerDrv;  /* Caller drv: handle defined by ConfigSring */
+
+  if ( DrvTable[Handle].DrvInfo->DrvFunc.drv_Read != NULL )
+    if ( (DrvTable[Handle].DrvInfo->DrvFunc.drv_Read)( (void*)Buffer, Size ) == DRV_OK )
+      return VSI_OK;
+  
+  return VSI_ERROR;
+}
+#endif
+
+#ifndef RUN_FLASH
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-Frame (8415)           MODULE  : VSI_DRV             |
+| STATE   : code                       ROUTINE : vsi_d_write         |
++--------------------------------------------------------------------+
+
+  PURPOSE : write data to a driver
+
+*/
+int vsi_d_write ( T_HANDLE Caller, T_HANDLE DrvHandle, void *Buffer, ULONG Size )
+{
+T_HANDLE Handle;
+ULONG TotalBytesToWrite = Size;
+ULONG BytesToWrite = Size;
+ULONG TotalBytesWritten = 0;
+ULONG BytesWritten = 0;
+char *ptr = (char*)Buffer;
+
+  if ( DrvHandle )
+    Handle = DrvHandle;                  /* Caller TST: opened driver with vsi_d_open() */
+  else
+    Handle = DrvTable[Caller].LowerDrv;  /* Caller drv: handle defined by ConfigSring */
+
+  if ( DrvTable[Handle].DrvInfo->DrvFunc.drv_Write != NULL )
+  {
+    while ( TotalBytesWritten < TotalBytesToWrite )
+    {
+      BytesWritten = BytesToWrite;
+      if ( (DrvTable[Handle].DrvInfo->DrvFunc.drv_Write)( (void*)ptr, &BytesWritten ) != DRV_OK )
+        return VSI_ERROR;
+      ptr += BytesWritten;
+      TotalBytesWritten += BytesWritten;
+      BytesToWrite = TotalBytesToWrite - TotalBytesWritten; 
+    }
+  }
+  return VSI_OK;
+}
+#endif
+
+#ifndef RUN_INT_RAM
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-Frame (8415)           MODULE  : VSI_DRV             |
+| STATE   : code                       ROUTINE : vsi_d_flush         |
++--------------------------------------------------------------------+
+
+  PURPOSE : flush the internal buffers of a driver
+
+*/
+int vsi_d_flush ( T_HANDLE Caller, T_HANDLE DrvHandle )
+{
+T_HANDLE Handle;
+T_HANDLE min, max;
+
+  if ( DrvHandle )
+  {
+    min = DrvHandle;
+    max = DrvHandle+1;
+  }
+  else
+  {
+    min = 1;
+    max = MAX_TST_DRV;
+  }
+
+  for ( Handle = min; Handle < max; Handle++ )
+  {
+    if ( DrvTable[Handle].DrvInfo )
+      if ( DrvTable[Handle].DrvInfo->DrvFunc.drv_Flush != NULL )
+        if ( (DrvTable[Handle].DrvInfo->DrvFunc.drv_Flush)() != DRV_OK )
+          return VSI_ERROR;
+  }
+  return VSI_OK;
+}
+#endif
+
+#ifndef RUN_INT_RAM
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-Frame (8415)           MODULE  : VSI_DRV             |
+| STATE   : code                       ROUTINE : vsi_d_setsignal     |
++--------------------------------------------------------------------+
+
+  PURPOSE : enable a signal in a driver
+
+*/
+int vsi_d_setsignal ( T_HANDLE Caller, T_HANDLE DrvHandle, USHORT SignalType )
+{
+T_HANDLE Handle;
+T_HANDLE min, max;
+
+  if ( DrvHandle )
+  {
+    min = DrvHandle;
+    max = DrvHandle+1;
+  }
+  else
+  {
+    min = 1;
+    max = MAX_TST_DRV;
+  }
+
+  for ( Handle = min; Handle < max; Handle++ )
+  {
+    if ( DrvTable[Handle].DrvInfo )
+      if ( DrvTable[Handle].DrvInfo->DrvFunc.drv_SetSignal != NULL )
+        if ( (DrvTable[Handle].DrvInfo->DrvFunc.drv_SetSignal)( SignalType  ) != DRV_OK )
+          return VSI_ERROR;
+  }
+  return VSI_OK;
+}
+#endif
+
+#ifndef RUN_INT_RAM
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-Frame (8415)           MODULE  : VSI_DRV             |
+| STATE   : code                       ROUTINE : vsi_d_resetsignal   |
++--------------------------------------------------------------------+
+
+  PURPOSE : disable a signal in a driver
+
+*/
+int vsi_d_resetsignal ( T_HANDLE Caller, T_HANDLE DrvHandle, USHORT SignalType )
+{
+T_HANDLE Handle;
+T_HANDLE min, max;
+
+  if ( DrvHandle )
+  {
+    min = DrvHandle;
+    max = DrvHandle+1;
+  }
+  else
+  {
+    min = 1;
+    max = MAX_TST_DRV;
+  }
+
+  for ( Handle = min; Handle < max; Handle++ )
+  {
+    if ( DrvTable[Handle].DrvInfo )
+      if ( DrvTable[Handle].DrvInfo->DrvFunc.drv_ResetSignal != NULL )
+        if ( (DrvTable[Handle].DrvInfo->DrvFunc.drv_ResetSignal)( SignalType  ) != DRV_OK )
+          return VSI_ERROR;
+  }
+  return VSI_OK;
+}
+#endif
+
+#ifndef RUN_INT_RAM
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-Frame (8415)           MODULE  : VSI_DRV             |
+| STATE   : code                       ROUTINE : vsi_d_setconfig     |
++--------------------------------------------------------------------+
+
+  PURPOSE : configure  a driver
+
+*/
+int vsi_d_setconfig ( T_HANDLE Caller, T_HANDLE DrvHandle, char *Config )
+{
+T_HANDLE Handle;
+
+  if ( Config && DrvHandle != 0)
+  {
+    if ( DrvTable[DrvHandle].DrvInfo->DrvFunc.drv_SetConfig != NULL )
+      if ( (DrvTable[DrvHandle].DrvInfo->DrvFunc.drv_SetConfig)( Config  ) != DRV_OK )
+        return VSI_ERROR;
+  }
+  else
+  {
+    T_HANDLE min, max;
+
+    if ( DrvHandle )
+    {
+      min = DrvHandle;
+      max = DrvHandle+1;
+    }
+    else
+    {
+      min = 1;
+      max = MAX_TST_DRV;
+    }
+
+    for ( Handle = min; Handle < max; Handle++ )
+    {
+      if ( DriverList->DrvEntry[Handle].DrvConfig )
+      {
+        if ( DrvTable[Handle].DrvInfo->DrvFunc.drv_SetConfig != NULL )
+          if ( (DrvTable[Handle].DrvInfo->DrvFunc.drv_SetConfig)( (char*)DriverList->DrvEntry[Handle].DrvConfig  ) != DRV_OK )
+            return VSI_ERROR;
+      }
+    }
+  }
+  return VSI_OK;
+}
+#endif
+
+#ifndef RUN_INT_RAM
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-Frame (8415)           MODULE  : VSI_DRV             |
+| STATE   : code                       ROUTINE : vsi_d_getconfig     |
++--------------------------------------------------------------------+
+
+  PURPOSE : read configuration data from a driver
+
+*/
+
+int vsi_d_getconfig ( T_HANDLE Caller, T_HANDLE DrvHandle, char *Config )
+{
+T_HANDLE Handle;
+char Buffer[40];
+char *ptr = Config;
+
+  Handle = DrvHandle;
+  while ( Handle )
+  {
+    if ( DrvTable[Handle].DrvInfo )
+      if ( DrvTable[Handle].DrvInfo->DrvFunc.drv_GetConfig != NULL )
+        if ( (DrvTable[Handle].DrvInfo->DrvFunc.drv_GetConfig)( Buffer ) != DRV_OK )
+          return VSI_ERROR;
+
+    sprintf ( ptr, "%s:%s;",DrvTable[Handle].DrvInfo->Name,Buffer );
+    ptr = ptr + strlen(DrvTable[Handle].DrvInfo->Name) + strlen(Buffer) + 2;
+    Handle = DrvTable[Handle].LowerDrv;
+  }
+  return VSI_OK;
+}
+#endif
+
+#ifndef RUN_INT_RAM
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-Frame (8415)         MODULE  : VSI_DRV               |
+| STATE   : code                     ROUTINE : InitializeDriverTable |
++--------------------------------------------------------------------+
+
+  PURPOSE : Initialize the driver table
+
+*/
+void InitializeDriverConfig ( void )
+{
+#ifdef _TOOLS_
+USHORT j;
+
+  for ( j = 1; j < MAX_TST_DRV ; j++ )
+  {
+    if ( DriverConfigList->DrvEntry[j].Name )
+    {
+      strcpy ( _DrvList.DrvEntry[j].Name, DriverConfigList->DrvEntry[j].Name );
+      DrvList.DrvEntry[j].Name = _DrvList.DrvEntry[j].Name;
+    }
+    
+    if ( DriverConfigList->DrvEntry[j].drv_Init )
+    {
+      DrvList.DrvEntry[j].drv_Init = DriverConfigList->DrvEntry[j].drv_Init;
+    }
+
+    if ( DriverConfigList->DrvEntry[j].Process )
+    {
+      strcpy ( _DrvList.DrvEntry[j].Process, DriverConfigList->DrvEntry[j].Process );
+      DrvList.DrvEntry[j].Process = _DrvList.DrvEntry[j].Process;
+    }
+
+    if ( DriverConfigList->DrvEntry[j].DrvConfig )
+    {
+      strcpy ( _DrvList.DrvEntry[j].DrvConfig, DriverConfigList->DrvEntry[j].DrvConfig );
+      DrvList.DrvEntry[j].DrvConfig = _DrvList.DrvEntry[j].DrvConfig;
+    }
+  }
+
+  DriverList = &DrvList;
+#else
+  DriverList = DriverConfigList;
+#endif /* _TOOLS_ */
+  ClearDriverTable();
+}
+#endif
+
+#ifndef RUN_INT_RAM
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-Frame (8415)         MODULE  : VSI_DRV               |
+| STATE   : code                     ROUTINE : ClearDriverTable      |
++--------------------------------------------------------------------+
+
+  PURPOSE : Clear the driver table
+
+*/
+void ClearDriverTable ( void )
+{
+char i;
+
+  for ( i = 1; i <= MAX_TST_DRV; i++ )
+  {
+    memset ( &DrvTable[i], 0, sizeof(T_DRV_TABLE_ENTRY) );
+  }
+
+}
+#endif