osservices.h

一个Linux下的软猫驱动

#undef OsStrnCat
#define OsStrnCat strncat
#undef OsStrCmp
#define OsStrCmp strcmp
#undef OsStrnCmp
#define OsStrnCmp strncmp
#undef OsStrLen
#define OsStrLen strlen
#else
__shimcall__
PVOID   OsMemSet    (PVOID pBuf, UINT8 c, UINT32 Count);
__shimcall__
PVOID	OsMemCpy    (PVOID pDest, PVOID pSrc, UINT32 Count);
__shimcall__
PVOID	OsMemMove   (PVOID pDest, PVOID pSrc, UINT32 Count);
__shimcall__
int		OsMemCmp    (PVOID pBuff1, PVOID pBuff2, UINT32 Count);
__shimcall__

__shimcall__
PVOID	OsStrCpy    (LPSTR szDest, LPCSTR szSrc);
__shimcall__
PVOID	OsStrnCpy   (LPSTR szDest, LPCSTR szSrc, int MaxSize);
__shimcall__
LPSTR	OsStrCat    (LPSTR szDest, LPCSTR szSrc);
__shimcall__
LPSTR	OsStrnCat   (LPSTR szDest, LPCSTR szSrc, int MaxSize);
__shimcall__
int     OsStrCmp    (LPCSTR szStr1, LPCSTR szStr2);
__shimcall__
int     OsStrnCmp   (LPCSTR szStr1, LPCSTR szStr2, UINT32 Count);
__shimcall__
int	    OsStrLen    (LPCSTR szStr);
#endif
__shimcall__
int	    OsAtoi      (LPCSTR szStr);
__shimcall__
int	    OsToupper   (int c);
__shimcall__
int	    OsTolower   (int c);
__shimcall__
int	    OsIsDigit   (int c);
#ifndef TARGET_HCF_STARFISH_VXWORKS
#include <stdarg.h>
__shimcall__
int     OsSprintf   (LPSTR buffer, LPCSTR format, ...);
__shimcall__
int     OsVSprintf  (LPSTR buffer, LPCSTR format, va_list valist);
#else
#define OsSprintf sprintf
#define OsVSprintf vsprintf
#endif
typedef struct
{
	int dummy;
} *HOSTIMER;




/**********************************************************************************


	Misc utilities


**********************************************************************************/


/**********************************************************************************
Function name :	OsGetSystemTime
Parameters :	None
Return value :	returns timestamp in milliseconds
Functionality	The function returnes a milliseconds timestamp.
Interrupt safe: yes
**********************************************************************************/
__shimcall__
UINT32	OsGetSystemTime(void);


/**********************************************************************************
Function name :	OsSleep
Parameters :	Time in milliseconds to put the thread to sleep
Return value :	None
Functionality	Put the executing thread to sleep
Interrupt safe: no
**********************************************************************************/
__shimcall__
void	OsSleep (UINT32 sleepTime);


/**********************************************************************************
Function name :	OsGetCurrentThread
Parameters :	None
Return value :	Thread ID of the active thread
Functionality:	Returns thread ID of the thread running the code
Interrupt safe: no
**********************************************************************************/
#if ( OS_TYPE == OS_MACOSX )
#define HTHREAD     HANDLE
#else
typedef struct tagHTHREAD
{
	int dummy;

} *HTHREAD;
#endif

__shimcall__
HTHREAD OsGetCurrentThread(void);

/**********************************************************************************
Function name :	OsCallOnMyStack
Parameters :	pFunc			-	function to be called
				lParam			-	parameter to pass for pFunc
				pTopOfStack		-	Pointer to stack
				StackSizeBytes	-	stack size in bytes.
Return value :	None
Functionality :	Temporarily switches a stack to a different locked block of memory.
				This function is intended to be used in an environment with limited
				stack size given to an interrupt service routine. 
Interrupt safe: yes
**********************************************************************************/
#if (OS_TYPE != OS_LINUX)
void	OsCallOnMyStack	(	IN	PCBFUNC	pFunc, 
							IN	UINT32	lParam, 
							IN	PUINT32	pTopOfStack, 
							IN	UINT32	StackSizeBytes);
#else
#define OsCallOnMyStack(pFunc, lParam, pTopOfStack, StackSizeBytes) (pFunc)((PVOID)(lParam))
#endif





/****************************************************************************************


	Timer


****************************************************************************************/


/**********************************************************************************
Function name :	OsCreatePeriodicTimeOut
Parameters :	InitialTimeOut		- initial interval in milliseconds 
									  between 2 timeout callbacks
				pTimeOutCallBack	- Pointer to a fucntion that will be called at 
									  the specified interval
				pRefData			- Reference Data to be passed to callback 
									  function
Return value :	Returns a handle to the periodic timeout. This handle is to be
				passed to OS functions acting on periodic timeout. Returns NULL
				on failure.
Functionality :	Creates a periodic timeout of InitialTimeOut interval. 
				pTimeOutCallBack function will be called on each timer interval. 
Interrupt safe: no
**********************************************************************************/
__shimcall__
HOSTIMER	OsCreatePeriodicTimer	(	IN	UINT32			InitialTimeOut,
										IN	PCBFUNC			pTimeOutCallBack,
										IN	PALLOC_FUNC		pFuncAlloc,
										IN	PFREE_FUNC		pFuncFree,
										IN	PVOID			pRefData,
										OUT	HTHREAD*		pThreadId);


/**********************************************************************************
Function name :	OsDestroyPeriodicTimeOut
Parameters :	hTimeOut -	Handle to the periodic time out returned by 
							OsCreatePeriodicTimeOut.
Return value :	none
Functionality : destroys a periodic timeout resource.
Interrupt safe: no
**********************************************************************************/
__shimcall__
void	OsDestroyPeriodicTimer	(IN	HOSTIMER	hTimeOut);


/**********************************************************************************
Function name :	OsSetPeriodicTimeOut
Parameters :	hTimeOut	-	Handle to the periodic timeout
				NewTimeOut	-	New timeout interval
Return value :	returns TRUE when the timeout interval was successfully changed to 
				NewTimeOut
Functionality : resets the timeout inteval to a new value.
Interrupt safe: no
**********************************************************************************/
__shimcall__
BOOL	OsSetPeriodicTimer	(	IN	HOSTIMER	hTimeOut,
								IN	UINT32		NewTimeOut);


/**********************************************************************************
Function name :	OsImmediateTimeOut
Parameters :	hTimeOut	-	Handle to the periodic timeout
Return value :	none
Functionality : Schedules call of the callback function as soon as non-interrupt
				context becomes available.
Interrupt safe: yes
**********************************************************************************/
__shimcall__
void    OsImmediateTimeOut	(IN	HOSTIMER	hTimeOut);



/**********************************************************************************


	Debug utilities


**********************************************************************************/


__shimcall__
void    OsRawVPrintf       (LPCSTR szFormat, PVOID args, BOOL addnl);

__shimcall__
void    OsRawNLPrintf       (LPCSTR szFormat, ...)
#ifdef __GNUC__
	__attribute__ ((format (printf, 1, 2)))
#endif
	;

__shimcall__
void    OsRawPrintf       (LPCSTR szFormat, ...)
#ifdef __GNUC__
	__attribute__ ((format (printf, 1, 2)))
#endif
	;

__shimcall__
void    OsErrorVPrintf       (LPCSTR szFormat, PVOID args);

__shimcall__
void    OsErrorPrintf       (LPCSTR szFormat, ...)
#ifdef __GNUC__
	__attribute__ ((format (printf, 1, 2)))
#endif
	;

__shimcall__
void    OsDebugVPrintf       (LPCSTR szFormat, PVOID args);

__shimcall__
void    OsDebugPrintf       (LPCSTR szFormat, ...)
#ifdef __GNUC__
	__attribute__ ((format (printf, 1, 2)))
#endif
	;

__shimcall__
void    OsDebugBreakpoint   (LPCSTR szMsg );

/*void    OsDebugDumpData(PUINT8 data, UINT32 len);*/


#define OsSwapUINT16(x) ((((x) & 0xFF00) >> 8) | (((x) & 0x00FF) << 8))
#define OsSwapUINT32(x) ((OsSwapUINT16(x) << 16) | (OsSwapUINT16((x) >> 16)))

//Event handling functions
typedef struct tagHOSEVENT
{
    void *dummy;
} OSEVENT, *HOSEVENT;

typedef enum OSEVENT_WAIT_RESULT_ENUM
{
    OSEVENT_WAIT_OK,
    OSEVENT_WAIT_TIMEOUT,
    OSEVENT_WAIT_ERROR
} OSEVENT_WAIT_RESULT;


__shimcall__ HOSEVENT OsEventCreate(void);
__shimcall__ void OsEventDestroy(HOSEVENT hEvent);
__shimcall__ void OsEventInit(HOSEVENT hEvent);
__shimcall__ long OsEventSet(HOSEVENT hEvent);
__shimcall__ long OsEventClear(HOSEVENT hEvent);
__shimcall__ long OsEventState(HOSEVENT hEvent);
__shimcall__ void OsEventWait(HOSEVENT hEvent);
__shimcall__ OSEVENT_WAIT_RESULT OsEventWaitTime(HOSEVENT hEvent, UINT32 timeout);

__shimcall__
void    OsErrorPrintf       ( LPCSTR szFormat, ...);


/**********************************************************************************
Function name :	OsFloatPrefix
Parameters :	None
Return value :	None
functionality :	Treats the FPU in order to enable float operations.
**********************************************************************************/
__shimcall__
GLOBAL	int  OsFloatPrefix(void);

/**********************************************************************************
Function name :	OsFloatPrefix
Parameters :	None
Return value :	None
functionality :	Restores the FPU after float operations.
**********************************************************************************/
__shimcall__
GLOBAL	BOOL  OsFloatSuffix(int Id);



__shimcall__
HANDLE OsCreateTimer(UINT32 msec, PVOID pCBFunc, PVOID pRefData);
__shimcall__
void OsSetTimer(PVOID pTimer);
__shimcall__
void OsCancelTimer(PVOID Timer);
__shimcall__
void OsChangeTimerTimeOut(PVOID Timer, UINT32 msec);
__shimcall__
void OsDestroyTimer(PVOID pTimer);

#if (OS_TYPE == OS_LINUX)
__shimcall__
GLOBAL	DWORD  OsGetProcessorFreq(void);
#define GlobalProcessorFreq OsGetProcessorFreq()

__shimcall__
UINT32 OsReadCpuCnt(void);

typedef struct _OSTHRD OSTHRD, *POSTHRD;

__shimcall__
POSTHRD OsThreadCreate(const char *name, BOOLEAN highestprio, int *pid);

__shimcall__
void OsThreadDestroy(POSTHRD osthrd);

typedef struct tagHOSSCHED
{
	unsigned char dummy[8*sizeof(PVOID)];

} OSSCHED, *HOSSCHED;

__shimcall__
void OsThreadScheduleInit(HOSSCHED hWorkStorage, __kernelcall__ void (*func)(void *), void * data);

__shimcall__
int OsThreadSchedule(POSTHRD osthrd, HOSSCHED hWorkStorage);

__shimcall__
void
OsThreadScheduleDone(void);

__shimcall__
int
OsForkWait(char *program_path, char *argv[], char *envp[]);

__shimcall__
BOOL
OsKernelUsesRegParm(void);

extern POSTHRD OsMdmThread;

#endif

#ifdef __cplusplus
}
#endif

#endif      /* #ifndef __OSSERVICES_H__ */