line source
/*
+------------------------------------------------------------------------------
| 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
