line source
/*
+------------------------------------------------------------------------------
| File: thif_link.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 Modul contains the serial driver adaptation
+-----------------------------------------------------------------------------
*/
#ifndef __THIF_LINK_C__
#define __THIF_LINK_C__
#endif
/* these types are used in thif_socket.h */
#define Char char
#define Bool8 char
#define Int8 signed char
#define Uint8 unsigned char
#define UInt16 unsigned short int
#define Uint16 unsigned short int
#define Uint32 unsigned long int
#define Int32 long int
#ifdef _TARGET_
#include "thif_link.h"
#include "\global_af\thif\thif_socket.h"
#include "string.h"
#else
#include <windows.h>
#include <stdio.h>
#include "usart.h"
#include "stdlib.h"
#include "string.h"
#include "tools.h"
#endif
#include "vsi.h"
#include "drvconf.h"
#include "tstheader.h"
#include "os.h"
/*==== TYPES ======================================================*/
typedef struct
{
USHORT Handle;
USHORT EnabledSignalType;
T_DRV_CB_FUNC Callback;
char Connected;
Int8 thif_link;
} T_THIF_LINK_DATA;
typedef union {
USHORT scalar;
Uint8 array[2];
} SWAPPER;
/*==== CONSTANTS ==================================================*/
#define ALLOWED_THIF_LINK_SIGNALS (DRV_SIGTYPE_READ|DRV_SIGTYPE_CONNECT)
#define MAX_CONFIGSTR_LEN 50
#define NO_GOTDATA_CALLBACK 0
#define rxBufSz 0x800
#define txBufSz 0x800
#define WAIT_FOR_RECONNECT 500
/*==== EXTERNALS ==================================================*/
/*==== VARIABLES ==================================================*/
T_THIF_LINK_DATA THIF_LINK_Data;
static T_DRV_SIGNAL Signal;
Uint8 rxBuffer[rxBufSz];
Uint8 txBuffer[txBufSz];
Uint8 *prxBuffer = &rxBuffer[0];
Uint8 *ptxBuffer = &txBuffer[0];
GLOBAL OS_TIME WT;
GLOBAL OS_TIME RT;
/* static unsigned long int foolishSizeArgument = 0; */
/*==== FUNCTIONS ==================================================*/
#ifndef MIN
# define MIN(a,b) (((a) < (b)) ? (a) : (b))
#endif
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-Frame (8415) MODULE : thif_link |
| STATE : code ROUTINE : swapUSHORT |
+--------------------------------------------------------------------+
PURPOSE : byte sex handling
*/
void swapUSHORT(USHORT* candidate)
{
SWAPPER source;
SWAPPER dest;
source.scalar = *candidate;
dest.array[0] = source.array[1];
dest.array[1] = source.array[0];
*candidate = dest.scalar;
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-Frame (8415) MODULE : thif_link |
| STATE : code ROUTINE : beSureToBeConnected |
+--------------------------------------------------------------------+
PURPOSE : callback function of the driver
*/
void beSureToBeConnected()
{
if (THIF_LINK_Data.thif_link < 0)
{
thif_link_Open();
}
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-Frame (8415) MODULE : thif_link |
| STATE : code ROUTINE : thif_binding_Callback |
+--------------------------------------------------------------------+
PURPOSE : callback function of the driver
*/
void thif_binding_Callback (Int8 sockId) /* this is a bridge to connect the THIF binding callback to the TR-defined callback (see thif_link_Open) */
{
if ( THIF_LINK_Data.EnabledSignalType & DRV_SIGTYPE_READ )
{
Signal.SignalType = DRV_SIGTYPE_READ;
Signal.DrvHandle = THIF_LINK_Data.Handle;
(THIF_LINK_Data.Callback)( &Signal );
}
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-Frame (8415) MODULE : thif_link |
| STATE : code ROUTINE : thif_link_Exit |
+--------------------------------------------------------------------+
PURPOSE : exit a driver
*/
void thif_link_Exit ( void )
{
thif_link_Close();
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-Frame (8415) MODULE : thif_link |
| STATE : code ROUTINE : thif_link_Open |
+--------------------------------------------------------------------+
PURPOSE : open connection to driver
*/
USHORT thif_link_Open(void)
{
LONG result = -1;
while (result < 0)
{
result = thif_socket_open(THIF_LINK_NAME, thif_binding_Callback, prxBuffer, rxBufSz, ptxBuffer, txBufSz );
if (result < 0)
{
//os_SuspendTask ( 0, WAIT_FOR_RECONNECT);
}
}
THIF_LINK_Data.thif_link = result;
THIF_LINK_Data.EnabledSignalType = DRV_SIGTYPE_READ;
Signal.SignalType = DRV_SIGTYPE_CONNECT;
Signal.DrvHandle = THIF_LINK_Data.Handle;
Signal.UserData = NULL;
(THIF_LINK_Data.Callback)( &Signal );
THIF_LINK_Data.Connected = TRUE;
return DRV_OK;
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-Frame (8415) MODULE : thif_link |
| STATE : code ROUTINE : thif_link_Close |
+--------------------------------------------------------------------+
PURPOSE : exit a driver
*/
USHORT thif_link_Close(void )
{
if (thif_socket_close(THIF_LINK_Data.thif_link) < 0)
{
return DRV_INTERNAL_ERROR;
}
THIF_LINK_Data.thif_link = -1;
THIF_LINK_Data.EnabledSignalType = DRV_SIGTYPE_DISCONNECT;
Signal.DrvHandle = THIF_LINK_Data.Handle;
Signal.UserData = NULL;
(THIF_LINK_Data.Callback)( &Signal );
THIF_LINK_Data.Connected = FALSE;
return DRV_OK;
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-Frame (8415) MODULE : thif_link |
| STATE : code ROUTINE : thif_link_Read |
+--------------------------------------------------------------------+
PURPOSE : read data from driver
*/
USHORT thif_link_Read ( void *Buffer, ULONG *SizeInBytes)
{
OS_TIME timeBefore;
OS_TIME timeAfter;
T_HANDLE caller;
USHORT retVal;
/*
ULONG to_read = *SizeInBytes;
Uint8* buff = (Uint8*) Buffer;
beSureToBeConnected();
caller = os_MyHandle();
if (foolishSizeArgument == 0)
{
to_read = thif_socket_read(THIF_LINK_Data.thif_link, buff, 2);
foolishSizeArgument = buff[0]*0xff + buff[1];
}
to_read= foolishSizeArgument;
//os_GetTime (caller, &timeBefore);
to_read = MIN(to_read, *SizeInBytes);
*SizeInBytes = thif_socket_read(THIF_LINK_Data.thif_link, buff, to_read);
if (*SizeInBytes <= foolishSizeArgument)
{
foolishSizeArgument -= *SizeInBytes;
retVal = DRV_OK;
}
else
{
foolishSizeArgument = 0;
retVal = DRV_INTERNAL_ERROR;
}
//os_GetTime (caller, &timeAfter);
//RT= timeAfter - timeBefore;
return retVal;
*/
*SizeInBytes = thif_socket_read( THIF_LINK_Data.thif_link, Buffer, *SizeInBytes );
return DRV_OK;
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-Frame (8415) MODULE : thif_link |
| STATE : code ROUTINE : thif_link_Write_to_socket |
+--------------------------------------------------------------------+
PURPOSE : write data to driver
*/
void thif_link_Write_to_socket (void *Buffer, ULONG sizeInBytes )
{
T_HANDLE caller;
Uint8* buff;
OS_TIME timeBefore;
OS_TIME timeAfter;
ULONG to_write;
LONG written = -1;
buff = (Uint8*) Buffer;
to_write = sizeInBytes;
caller = os_MyHandle();
while (to_write > 0)
{
//os_GetTime (caller, &timeBefore);
written = thif_socket_write(THIF_LINK_Data.thif_link, buff, to_write);
//os_GetTime (caller, &timeAfter);
//WT = timeAfter - timeBefore;
if (written < 0)
{
//os_SuspendTask (caller, WAIT_FOR_RECONNECT);
}
else if (written == 0)
{
os_SuspendTask (caller, 2000);
//break;
}
else
{
to_write -= written;
buff += written;
}
}
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-Frame (8415) MODULE : thif_link |
| STATE : code ROUTINE : thif_link_Write |
+--------------------------------------------------------------------+
PURPOSE : relay 2 byte header & data to thif_link_Write_to_socket
*/
USHORT thif_link_Write ( void *Buffer, ULONG *SizeInBytes )
{
USHORT TSTSocketMarker;
Uint8* buff;
beSureToBeConnected();
/* TST's socket interface expects a 2-byte header containing the length of the real message to receive
in funtion socket_Read. We just send that header, converting it to little endian in advance
TSTSocketMarker = (USHORT) *SizeInBytes;
swapUSHORT(&TSTSocketMarker);
buff = (Uint8*) &TSTSocketMarker;
thif_link_Write_to_socket( buff, 2);
*/
buff = (Uint8*) Buffer;
thif_link_Write_to_socket(buff, *SizeInBytes);
//thif_socket_flush(THIF_LINK_Data.thif_link);
return DRV_OK;
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-Frame (8415) MODULE : thif_link |
| STATE : code ROUTINE : thif_link_Flush |
+--------------------------------------------------------------------+
PURPOSE : flush data to driver
*/
USHORT thif_link_Flush (void)
{
beSureToBeConnected();
return thif_socket_flush(THIF_LINK_Data.thif_link);
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-Frame (8415) MODULE : thif_link |
| STATE : code ROUTINE : thif_link_SetSignal |
+--------------------------------------------------------------------+
PURPOSE : enable signal for the driver
*/
USHORT thif_link_SetSignal ( USHORT SignalType )
{
if ( !(SignalType & ALLOWED_THIF_LINK_SIGNALS) )
{
return DRV_INVALID_PARAMS;
}
else
{
THIF_LINK_Data.EnabledSignalType |= SignalType;
}
return DRV_OK;
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-Frame (8415) MODULE : thif_link |
| STATE : code ROUTINE : thif_link_ResetSignal |
+--------------------------------------------------------------------+
PURPOSE : disable signal for the driver
*/
USHORT thif_link_ResetSignal ( USHORT SignalType )
{
if ( !(SignalType & ALLOWED_THIF_LINK_SIGNALS) )
{
return DRV_INVALID_PARAMS;
}
else
{
THIF_LINK_Data.EnabledSignalType &= ~SignalType;
}
return DRV_OK;
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-Frame (8415) MODULE : thif_link |
| STATE : code ROUTINE : thif_link_SetConfig |
+--------------------------------------------------------------------+
PURPOSE : set configuration for the driver
*/
USHORT thif_link_SetConfig ( char *buffer )
{
char token [64];
unsigned int len;
USHORT result;
result = DRV_OK;
if ( (len = GetNextToken (buffer, token, " #")) == 0)
{
result = thif_link_Open();
}
else
{
buffer += (len+1);
}
if ( !strcmp ( "OPEN", token ) )
{
result = thif_link_Open();
}
else if ( !strcmp ( "CLOSE", token ) )
{
result = thif_link_Close();
}
else if ( !strcmp ( "EXIT", token ) )
{
thif_link_Exit();
}
else
{
result = DRV_INVALID_PARAMS;
}
if ((result != DRV_OK) && (result != DRV_INVALID_PARAMS))
{
result = DRV_NOTCONFIGURED;
}
return result;
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-Frame (8415) MODULE : thif_link |
| STATE : code ROUTINE : thif_link_Init |
+--------------------------------------------------------------------+
PURPOSE : initialize driver
*/
USHORT thif_link_Init ( USHORT DrvHandle, T_DRV_CB_FUNC CallbackFunc, T_DRV_EXPORT const **DrvInfo )
{
static const T_DRV_EXPORT thif_link_Info =
{
THIF_LINK_NAME,
0,
{
#ifdef _WIN32_
thif_link_Init,
#endif
thif_link_Exit,
thif_link_Read,
thif_link_Write,
NULL, /* Look */
NULL, /* Clear */
thif_link_Flush,
thif_link_SetSignal,
thif_link_ResetSignal,
thif_link_SetConfig,
NULL,
NULL,
}
};
THIF_LINK_Data.Handle = DrvHandle;
THIF_LINK_Data.EnabledSignalType = 0;
THIF_LINK_Data.Callback = CallbackFunc;
THIF_LINK_Data.Connected = FALSE;
*DrvInfo = &thif_link_Info;
return DRV_OK;
}
