phc_reg.c

此為philip 1362 USB DOS下的驅動程式包, 已經共測試並內含有說明文件

/*
   //*************************************************************************
   //
   //                  P H I L I P S   P R O P R I E T A R Y
   //
   //           COPYRIGHT (c)   2000 BY PHILIPS SINGAPORE.
   //                     --  ALL RIGHTS RESERVED  --
   //
   // File Name:        PHC_Reg.c
   // Author:           ZhenYu Zhang
   // Created:			Jun. 8, 2000
   // Modified:
   // Revision:         0.0
   //
   //*************************************************************************
   // Notes:
   //   PHC_xx 		: Philips Host Controller
   // 	SHC_xx 		: Slave Host Controller
   //
   //*************************************************************************
*/
#include <stdio.h>
#include <dos.h>

#include "BasicTyp.h"
#include "common.h"
#include "SysCnfg.h"

#include "hal4sys.h"
#include "hal4ISA.h"
#include "hal4Hc.h"

#include "PHC_Reg.h"

/*
//*************************************************************************
//  Public static data
//*************************************************************************
*/
extern UCHAR bVerbose;
extern UCHAR bIRQL;
/*
//*************************************************************************
//  Private static data
//*************************************************************************
*/
UCHAR			PHC_DnPortsNum = 0 ;
/*
//*************************************************************************
//  Subroutines - PHC_xx
//*************************************************************************
*/
ULONG PHC_GetRevision(void)
{
	return Hal4Hc_RegInDW(SLHREG_REVISION);
}

void PHC_Control(ULONG dwBits)
{
	Hal4Hc_RegOutDW(SLHREG_CONTROL,dwBits);
}

ULONG PHC_GetControlState( void )
{
	return Hal4Hc_RegInDW(SLHREG_CONTROL);
}
void PHC_Command(ULONG dwBits)
{
	Hal4Hc_RegOutDW(SLHREG_COMMAND,dwBits);
}

ULONG PHC_GetCommandState( void )
{
	return Hal4Hc_RegInDW(SLHREG_COMMAND);
}

ULONG PHC_GetInterruptStatus( void )
{
	return Hal4Hc_RegInDW(SLHREG_INT_STS);
}

void PHC_ClearInterrupts(ULONG dwBits )
{
	Hal4Hc_RegOutDW(SLHREG_INT_STS,dwBits);
}

void PHC_DisableInterrupts(ULONG dwBits )
{
	Hal4Hc_RegOutDW(SLHREG_INT_DIS,dwBits);
}

void PHC_EnableInterrupts(ULONG dwBits )
{
	Hal4Hc_RegOutDW(SLHREG_INT_EN,dwBits);
}

ULONG PHC_GetInterruptMask( void )
{
	return Hal4Hc_RegInDW(SLHREG_INT_DIS);
}

void PHC_ConfigFrame(ULONG dwBits)
{
	Hal4Hc_RegOutDW(SLHREG_FRM_INTERVAL,dwBits);
}

ULONG PHC_GetFrameConfig(void)
{
	return Hal4Hc_RegInDW(SLHREG_FRM_INTERVAL);
}

ULONG PHC_GetFrameRem(void)
{
	return Hal4Hc_RegInDW(SLHREG_FRM_REMAIN);
}

ULONG PHC_GetFrameNum(void)
{
	return Hal4Hc_RegInDW(SLHREG_FRM_NUMBER);
}

void PHC_ConfigLSThreashold(ULONG dwBits)
{
	Hal4Hc_RegOutDW(SLHREG_FRM_LS_THRESH,dwBits);
}

ULONG PHC_GetLSThreashold( void )
{
	return Hal4Hc_RegInDW(SLHREG_FRM_LS_THRESH);
}

void PHC_ConfigRootHubDescA(ULONG dwBits)
{
	Hal4Hc_RegOutDW(SLHREG_RH_DESCRIP_A,dwBits);
}

ULONG PHC_GetRootHubDescA( void)
{
	return Hal4Hc_RegInDW(SLHREG_RH_DESCRIP_A);
}

void PHC_ConfigRootHubDescB(ULONG dwBits)
{
	Hal4Hc_RegOutDW(SLHREG_RH_DESCRIP_B,dwBits);
}

ULONG PHC_GetRootHubDescB( void)
{
	return Hal4Hc_RegInDW(SLHREG_RH_DESCRIP_B);
}

void PHC_SetRootHub( ULONG dwBits)
{
	Hal4Hc_RegOutDW(SLHREG_RH_STATUS,dwBits);
}

ULONG PHC_GetRootHubStatus( void )
{
	return Hal4Hc_RegInDW(SLHREG_RH_STATUS);
}

void PHC_SetRootHubPort( UCHAR DnPort, ULONG dwBits)
{
	USHORT wComData;
	wComData = SLHREG_RH_PORTSTATUS1 + (DnPort-1);
	Hal4Hc_RegOutDW(wComData,dwBits);
}

ULONG PHC_GetRootHubPortStatus(UCHAR DnPort)
{
	USHORT wComData;
	wComData = SLHREG_RH_PORTSTATUS1 + (DnPort-1);
	return Hal4Hc_RegInDW(wComData);
}

void PHC_DisablePort(UCHAR DnPort)
{
	SLH_REG_ULONG	SlhReg;

	//Disable Port
	SlhReg.SlhRootHubPortStatusWr.Bits.ClearPortEnable = TRUE;
	SlhReg.SlhRootHubPortStatusWr.Bits.SetPortEnable = FALSE;
	SlhReg.SlhRootHubPortStatusWr.Bits.SetPortSuspend= FALSE;
	SlhReg.SlhRootHubPortStatusWr.Bits.ClearPortSuspend = TRUE;
	SlhReg.SlhRootHubPortStatusWr.Bits.SetPortReset = FALSE;
	SlhReg.SlhRootHubPortStatusWr.Bits.SetPortPower = TRUE;
	SlhReg.SlhRootHubPortStatusWr.Bits.ClearPortPower= FALSE;
	SlhReg.SlhRootHubPortStatusWr.Bits.ClearConnectStatusChange = FALSE;
	SlhReg.SlhRootHubPortStatusWr.Bits.ClearPortStatusChange = FALSE;
	SlhReg.SlhRootHubPortStatusWr.Bits.ClearPortSuspendStatusChange = FALSE;
	SlhReg.SlhRootHubPortStatusWr.Bits.ClearPortOvrCurIndicatorChange = FALSE;
	SlhReg.SlhRootHubPortStatusWr.Bits.ClearPortResetStatusChange = FALSE;
	PHC_SetRootHubPort( DnPort, SlhReg.FlexLong);
}

void PHC_EnablePort(UCHAR DnPort)
{
	SLH_REG_ULONG	SlhReg;

	//Enable Port
	SlhReg.SlhRootHubPortStatusWr.Bits.ClearPortEnable = FALSE;
	SlhReg.SlhRootHubPortStatusWr.Bits.SetPortEnable = TRUE;
	SlhReg.SlhRootHubPortStatusWr.Bits.SetPortSuspend= FALSE;
	SlhReg.SlhRootHubPortStatusWr.Bits.ClearPortSuspend = TRUE;
	SlhReg.SlhRootHubPortStatusWr.Bits.SetPortReset = FALSE;
	SlhReg.SlhRootHubPortStatusWr.Bits.SetPortPower = TRUE;
	SlhReg.SlhRootHubPortStatusWr.Bits.ClearPortPower= FALSE;
	SlhReg.SlhRootHubPortStatusWr.Bits.ClearConnectStatusChange = FALSE;
	SlhReg.SlhRootHubPortStatusWr.Bits.ClearPortStatusChange = FALSE;
	SlhReg.SlhRootHubPortStatusWr.Bits.ClearPortSuspendStatusChange = FALSE;
	SlhReg.SlhRootHubPortStatusWr.Bits.ClearPortOvrCurIndicatorChange = FALSE;
	SlhReg.SlhRootHubPortStatusWr.Bits.ClearPortResetStatusChange = FALSE;
	PHC_SetRootHubPort( DnPort, SlhReg.FlexLong);

}

void PHC_ResetPort(UCHAR DnPort)
{
	SLH_REG_ULONG	SlhReg;

	// Port Reset
	SlhReg.SlhRootHubPortStatusWr.Bits.ClearPortEnable = FALSE;
	SlhReg.SlhRootHubPortStatusWr.Bits.SetPortEnable = TRUE;
	SlhReg.SlhRootHubPortStatusWr.Bits.SetPortSuspend= FALSE;
	SlhReg.SlhRootHubPortStatusWr.Bits.ClearPortSuspend = TRUE;
	SlhReg.SlhRootHubPortStatusWr.Bits.SetPortReset = TRUE;
	SlhReg.SlhRootHubPortStatusWr.Bits.SetPortPower = TRUE;
	SlhReg.SlhRootHubPortStatusWr.Bits.ClearPortPower= FALSE;
	SlhReg.SlhRootHubPortStatusWr.Bits.ClearConnectStatusChange = FALSE;
	SlhReg.SlhRootHubPortStatusWr.Bits.ClearPortStatusChange = FALSE;
	SlhReg.SlhRootHubPortStatusWr.Bits.ClearPortSuspendStatusChange = FALSE;
	SlhReg.SlhRootHubPortStatusWr.Bits.ClearPortOvrCurIndicatorChange = FALSE;
	SlhReg.SlhRootHubPortStatusWr.Bits.ClearPortResetStatusChange = FALSE;
	PHC_SetRootHubPort( DnPort, SlhReg.FlexLong);

	Hal4Sys_WaitinMS(20); // USB1.1 reset PULSE width > 10ms

/*	SlhReg.SlhRootHubPortStatusWr.Bits.ClearPortEnable = FALSE;
	SlhReg.SlhRootHubPortStatusWr.Bits.SetPortEnable = TRUE;
	SlhReg.SlhRootHubPortStatusWr.Bits.SetPortSuspend= FALSE;
	SlhReg.SlhRootHubPortStatusWr.Bits.ClearPortSuspend = TRUE;
	SlhReg.SlhRootHubPortStatusWr.Bits.SetPortReset = FALSE;
	SlhReg.SlhRootHubPortStatusWr.Bits.SetPortPower = TRUE;
	SlhReg.SlhRootHubPortStatusWr.Bits.ClearPortPower= FALSE;
	SlhReg.SlhRootHubPortStatusWr.Bits.ClearConnectStatusChange = FALSE;
	SlhReg.SlhRootHubPortStatusWr.Bits.ClearPortStatusChange = FALSE;
	SlhReg.SlhRootHubPortStatusWr.Bits.ClearPortSuspendStatusChange = FALSE;
	SlhReg.SlhRootHubPortStatusWr.Bits.ClearPortOvrCurIndicatorChange = FALSE;
	SlhReg.SlhRootHubPortStatusWr.Bits.ClearPortResetStatusChange = FALSE;
	PHC_SetRootHubPort( DnPort, SlhReg.FlexLong);

	Hal4Sys_WaitinMS(15); // USB1.1 reset Recovery Time >10ms
*/}

void PHC_SetXferCounter( USHORT XferLengthInByte)
{
	Hal4Hc_RegOutW(REG_XFER_CNTR,XferLengthInByte);
}

USHORT PHC_GetBufferStatus(void)
{
	return Hal4Hc_RegInW(REG_BUFF_STS);
}


#ifdef CHOOSE_HC_OPR
void PHC_Wait4ATLDone(void)
{
	SLH_REG_ULONG	SlhReg;

	//Wait until ATL done;
	do{
		SlhReg.FlexLong = PHC_GetInterruptStatus();
	}while(SlhReg.SlhIntStatus.Bits.ATLisDone != 1);

	// Clear ATL flag
	SlhReg.FlexLong = 0;
	SlhReg.SlhIntStatus.Bits.ATLisDone = 1;
	PHC_ClearInterrupts(SlhReg.FlexLong);
}
#else
void	PHC_Wait4ATLDone(void)
{
	USHORT	BufferStatus;
	USHORT	loop=0;

	//begin 1362
/*	do {
		BufferStatus = PHC_GetBufferStatus();
	}while((BufferStatus&RBS_ATL_DONE)==0 && i++ < 9999);
	Hal4Hc_RegOutW(REG_BUFF_STS,0);*/

	do {
		BufferStatus = PHC_GetATLPTDDoneMap();
		Hal4Sys_WaitinUS(1);
	}while((BufferStatus&0x0001)==0 && (loop++ < 9999));

	//end 1362

}
#endif

#ifdef CHOOSE_HC_OPR
void PHC_Wait4ITLDone(void)
{
	SLH_REG_ULONG	SlhReg;

	//Wait until ITL done;
	do{
		SlhReg.FlexLong = PHC_GetInterruptStatus();
	}while(SlhReg.SlhIntStatus.Bits.SOF != 1);

	// Clear ITL flag
	SlhReg.FlexLong = 0;
	SlhReg.SlhIntStatus.Bits.SOF = 1;
	PHC_ClearInterrupts(SlhReg.FlexLong);
}
#else
void	PHC_Wait4ITLDone(void)
{
	USHORT	BufferStatus;
	do {
		BufferStatus = PHC_GetBufferStatus();
	}while((BufferStatus&(RBS_ISOA_DONE|RBS_ISOB_DONE))==0);
}
#endif


ULONG PHC_PollInterruptStatus(void)
{
	SLH_REG_ULONG	SlhReg;

	SlhReg.FlexLong = PHC_GetInterruptStatus();
	printf("SlhIntStatus=0x%lx\n",SlhReg.FlexLong);
	if(bVerbose)
	{
		printf("SlhIntStatus.ScheduleOverrun=0x%x\n",SlhReg.SlhIntStatus.Bits.ScheduleOverrun);
		printf("SlhIntStatus.ATLisDone=0x%x\n",SlhReg.SlhIntStatus.Bits.ATLisDone);
		printf("SlhIntStatus.SOF=0x%x\n",SlhReg.SlhIntStatus.Bits.SOF);
		printf("SlhIntStatus.ResumeDeteced=0x%x\n",SlhReg.SlhIntStatus.Bits.ResumeDeteced);
		printf("SlhIntStatus.FatalError=0x%x\n",SlhReg.SlhIntStatus.Bits.FatalError);
		printf("SlhIntStatus.FrameNumOverflow=0x%x\n",SlhReg.SlhIntStatus.Bits.FrameNumOverflow);
		printf("SlhIntStatus.RootHubStatusChange=0x%x\n",SlhReg.SlhIntStatus.Bits.RootHubStatusChange);
#ifdef DBG_MODE
		Hal4Sys_Pause();
#endif
	}
	return  SlhReg.FlexLong;
}

ULONG PHC_PollRootHub(void)
{
	SLH_REG_ULONG	SlhReg;

	SlhReg.FlexLong = PHC_GetRootHubStatus();
	printf("RootHubStatus=0x%lx\n",SlhReg.FlexLong);
	if(bVerbose)
	{
		printf("SlhRootHubStatus.LocalPowerStatus=0x%x\n",SlhReg.SlhRootHubStatus.Bits.LocalPowerStatus);
		printf("SlhRootHubStatus.OvrCurIndicator=0x%x\n",SlhReg.SlhRootHubStatus.Bits.OvrCurIndicator);
		printf("SlhRootHubStatus.DeviceRemoteWakupEnable=0x%x\n",SlhReg.SlhRootHubStatus.Bits.DeviceRemoteWakupEnable);
		printf("SlhRootHubStatus.LocalPowerStatusChange=0x%x\n",SlhReg.SlhRootHubStatus.Bits.LocalPowerStatusChange);
		printf("SlhRootHubStatus.OvrCurIndicatorChange=0x%x\n",SlhReg.SlhRootHubStatus.Bits.OvrCurIndicatorChange);
		printf("SlhRootHubStatus.ClearRemoteWakeupEnable=0x%x\n",SlhReg.SlhRootHubStatus.Bits.ClearRemoteWakeupEnable);
#ifdef DBG_MODE
		Hal4Sys_Pause();
#endif
	}
	return  SlhReg.FlexLong;
}

ULONG PHC_PollRootHubPort(UCHAR PortNum)
{
	SLH_REG_ULONG	SlhReg;
	SLH_REG_ULONG	SlhReg1;

	SlhReg.FlexLong = PHC_GetRootHubPortStatus(PortNum);
//	printf("RootHubPortStatus%d=0x%lx\n",PortNum,SlhReg.FlexLong);
	if(bVerbose)
	{
		printf("SlhRootHubPortStatus%d.CurrentConnectStatus=0x%x\n",PortNum,SlhReg.SlhRootHubPortStatus.Bits.CurrentConnectStatus);
		printf("SlhRootHubPortStatus%d.PortEnableStatus=0x%x\n",PortNum,SlhReg.SlhRootHubPortStatus.Bits.PortEnableStatus);
		printf("SlhRootHubPortStatus%d.PortSuspendStatus=0x%x\n",PortNum,SlhReg.SlhRootHubPortStatus.Bits.PortSuspendStatus);
		printf("SlhRootHubPortStatus%d.PortOvrCurIndicator=0x%x\n",PortNum,SlhReg.SlhRootHubPortStatus.Bits.PortOvrCurIndicator);
		printf("SlhRootHubPortStatus%d.PortResetStatus=0x%x\n",PortNum,SlhReg.SlhRootHubPortStatus.Bits.PortResetStatus);
		printf("SlhRootHubPortStatus%d.PortPowerStatus=0x%x\n",PortNum,SlhReg.SlhRootHubPortStatus.Bits.PortPowerStatus);
		printf("SlhRootHubPortStatus%d.LSDeviceAttached=0x%x\n",PortNum,SlhReg.SlhRootHubPortStatus.Bits.LSDeviceAttached);
		printf("SlhRootHubPortStatus%d.CurrentConnectStatusChange=0x%x\n",PortNum,SlhReg.SlhRootHubPortStatus.Bits.CurrentConnectStatusChange);
		printf("SlhRootHubPortStatus%d.PortEnableStatusChange=0x%x\n",PortNum,SlhReg.SlhRootHubPortStatus.Bits.PortEnableStatusChange);
		printf("SlhRootHubPortStatus%d.PortSuspendStatusChange=0x%x\n",PortNum,SlhReg.SlhRootHubPortStatus.Bits.PortSuspendStatusChange);
		printf("SlhRootHubPortStatus%d.PortOvrCurIndicatorChange=0x%x\n",PortNum,SlhReg.SlhRootHubPortStatus.Bits.PortOvrCurIndicatorChange);
		printf("SlhRootHubPortStatus%d.PortResetStatusChange=0x%x\n",PortNum,SlhReg.SlhRootHubPortStatus.Bits.PortResetStatusChange);
#ifdef DBG_MODE
		Hal4Sys_Pause();
#endif
	}

	// Clear PortStatus Change
	if(SlhReg.SlhRootHubPortStatus.Bits.CurrentConnectStatusChange)
	{
		SlhReg1.SlhRootHubPortStatusWr.Bits.ClearPortEnable = FALSE;
		SlhReg1.SlhRootHubPortStatusWr.Bits.SetPortEnable = FALSE;
		SlhReg1.SlhRootHubPortStatusWr.Bits.SetPortSuspend= FALSE;
		SlhReg1.SlhRootHubPortStatusWr.Bits.ClearPortSuspend = FALSE;
		SlhReg1.SlhRootHubPortStatusWr.Bits.SetPortReset = FALSE;
		SlhReg1.SlhRootHubPortStatusWr.Bits.SetPortPower = FALSE;
		SlhReg1.SlhRootHubPortStatusWr.Bits.ClearPortPower= FALSE;
		SlhReg1.SlhRootHubPortStatusWr.Bits.ClearConnectStatusChange = TRUE;
		SlhReg1.SlhRootHubPortStatusWr.Bits.ClearPortStatusChange = FALSE;
		SlhReg1.SlhRootHubPortStatusWr.Bits.ClearPortSuspendStatusChange = FALSE;
		SlhReg1.SlhRootHubPortStatusWr.Bits.ClearPortOvrCurIndicatorChange = FALSE;
		SlhReg1.SlhRootHubPortStatusWr.Bits.ClearPortResetStatusChange = FALSE;
		PHC_SetRootHubPort(PortNum,SlhReg1.FlexLong);
	}

	return  SlhReg.FlexLong;

}

USHORT PHC_GetATLPTDDoneMap(void)
{
	return Hal4Hc_RegInW(REG_ATL_PTD_DONE_MAP);
}