utility.c

一个USB主机核的驱动程序

/****************************************************************
*                      MT View Silicon Tech. Inc.
*
*    Copyright 2005, MT View Silicon Tech. Inc., ShangHai, China
*                    All rights reserved.
*
*
* Filename:      	utility.c
*
* Programmer:    	Grey
*
* Created: 	 		12/xx/2006
*
* Description: 		public functions 
*              
*        
* Change History (most recent first):	2006.12.19
****************************************************************
*
* History:							grey	2007.09.18
*
*		cut not use code
*
****************************************************************
*
* History:							grey	2007.10.30
*
*		add critical area control
*
****************************************************************/
#include <reg51.h>
#include <intrins.h>
#include "type.h"
#include "utility.h"



DWORD	XDATA	gTick;

extern VOID
OpenSysTime(VOID)
{
	gTick = 0;

	TMOD = 0x11;		/* set timer0 16bit counter */
	TL0 = 0xF0;			/* time unit is 10ms */
	TH0 = 0xD8;

	ET0 = 1;
	TR0 = 1;
	
	EA = 1;			
}

extern VOID
SysTimeInt(VOID) interrupt 1 using 3
{
	TL0 = 0xF0;
	TH0 = 0xD8;

//	EnterCritical();
	gTick++;
//	ExitCritical();
//	P1 ^= 0x01;
}


extern DWORD
GetSysTime(VOID)
{
	DWORD	temp;

	EnterCritical();
	temp = gTick;
	ExitCritical();

	return temp;
}

extern VOID
SetSysTime(
	DWORD		time
	)
{
	EnterCritical();
	gTick = time;
	ExitCritical();
}


//
// Wait Ms
//
extern VOID
WaitMs(							//Description: MCU wait ms
	DWORD		ms				//Input:	Wait ms counter value
	)	
{
/*	WORD DATA	i;
	while(ms)
	{
		for(i = 0; i < 80; ++i)			//for x51 80,for i51 800
		{
			_nop_();	
		}
		ms--;
	}
//*/
	DWORD	timeA, timeB;

	EnterCritical();
	timeA = gTick;
	ExitCritical();

	do
	{
		EnterCritical();
		timeB = gTick;
		ExitCritical();
	}
	while(timeA + ms != timeB);	
//*/
}


//
// Wait Us
//
extern VOID
WaitUs(							//Description: MCU wait us
	DWORD		us				//Input: 	Wait us counter value
	)	
{
	WORD DATA	i;

	while(us)
	{
		for (i = 0; i < 1; ++i)
		{
			_nop_();
		}
		us--;
	}
}


//
// Big endian to Little endian 16bit
//
extern WORD						//Return: Return little endian data of input data
LE16ToCPU(						//Description: Change 16bit data between big endian and little endian
	WORD 		val				//Input:	16bit big endian data
	)
{
	WORD DATA		retVal;

	((BYTE *)&retVal)[0] = ((BYTE *)&val)[1];
	((BYTE *)&retVal)[1] = ((BYTE *)&val)[0];

	return retVal;
}


//
// Big endian to Little endian 32bit
//
extern DWORD					//Return: Return little endian data of input data
LE32ToCPU(						//Description: Change 32bit data between big endian and little endian
	DWORD 		val				//Input:	32bit big endian data
	)
{
	DWORD DATA		retVal;

	((BYTE *)&retVal)[3] = ((BYTE *)&val)[0];
	((BYTE *)&retVal)[2] = ((BYTE *)&val)[1];
	((BYTE *)&retVal)[1] = ((BYTE *)&val)[2];
	((BYTE *)&retVal)[0] = ((BYTE *)&val)[3];

	return retVal;
}

#ifdef CUT_CODE
//
// Make one random number
// Note: This function reserved, user modify it
//
extern SWORD					//Return: Random number
GetRandomNum(					//Description: Create one random number -32768 ~ 32767
	SWORD 		seed			//Input:	Seed number for random
	)
{
	return seed;
}
#endif

//
// Interrupt Critical Area Operation
// Description: These operation disable EA and enable EA
//
// Save EA value, because interrupt nesting is not supported, so one flag is enough
//bit	gEAStack = 0;
//
// Enter critical area 
//
extern VOID
EnterCritical(VOID)				//Description: Program enter critical area
{
//	gEAStack = EA;		//save current interrupt enable state
	EA = 0;				//close all interrupt
}


//
// Exit critical area
//
extern VOID
ExitCritical(VOID)				//Description: Program exit critical area
{
//	EA = gEAStack;		//resume interrupt enable state
	EA = 1;
}

//#endif

extern VOID
Reverse16Bit(
	WORD		*pData
	)
{
	WORD	temp1, temp2;
	BYTE	i;

	temp1 = 0x0001;
	temp2 = 0;
	for (i = 0; i < 16; ++i, temp1 <<= 1)
	{
		temp2 <<= 1;
		if ((*pData & temp1) != 0)	
			temp2 |= 0x0001;
	}
	
	*pData = temp2;
}

extern BYTE
SearchMapZero(
	VOID		*map,
	BYTE		size
	)
{
	BYTE	*p = (BYTE *)map;
	BYTE	set = 0;

	while(set < size)
	{
		if ((p[set / 8] & (0x01 << (set % 8))) == 0)
			break;
		set++;
	}
	
	return set;
}

extern VOID
SetMap(
	VOID		*map,
	BYTE		set
	)
{
	BYTE	*p = (BYTE *)map;

	p[set / 8] |= (0x01 << (set % 8));
}

extern VOID
ClearMap(
	VOID		*map,
	BYTE		set
	)
{
	BYTE	*p = (BYTE *)map;

	p[set / 8] &= ~(0x01 << (set % 8));
}