📄 phc_hcs.c

📁 此為philip 1362 USB DOS下的驅動程式包, 已經共測試並內含有說明文件
💻 C
📖 第 1 页 / 共 3 页
字号:
12 3 下一页
/*
   //*************************************************************************
   //
   //                  P H I L I P S   P R O P R I E T A R Y
   //
   //           COPYRIGHT (c)   2000-2002 BY PHILIPS SINGAPORE.
   //                     --  ALL RIGHTS RESERVED  --
   //
   // File Name:	PHC_HcS.C
   // Created:		Jun. 8, 2000
   // Modified:		May 30, 2002 by wang.zhong.wei@philips.com
   // Revision:		1.0
   //
   //*************************************************************************
   // Abstract:
   //
 //*************************************************************************
*/

#include <stdio.h>
#include <string.h>
#include <dos.h>

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

#include "usb100.h"

#include "Hal4sys.h"
#include "Hal4ISA.h"
#include "Hal4IKit.h"
#include "Hal4Hc.h"
#include "PHC_Reg.h"

#include "PHC_HcS.h"
#include "UsbStd.h"

#include "Usb_Serv.h"

#include "Hal4OTG.h"
#include "OTGSvc.h"

/*
//*************************************************************************
//  Public static data
//*************************************************************************
*/
extern UCHAR 	bVerbose ;
extern UCHAR 	bVerboseHCS ;
extern UCHAR 	bIRQL ;

extern OTG_TCB 	OtgTcb;
extern BOOLEAN  ISP1362_ISAKIT;

/***********************************************/
/*	Private Vars for PHC_HcS		*/
/***********************************************/

SETUP_XACTION	HcS_UsbSetupStage;
DATA_XFER		HcS_UsbDataOutStage;
DATA_XFER		HcS_UsbDataInStage;

PHC_INFO		HcS_CtrlBlock;
/***********************************************************/
/******** Functions - Xfer for ATL/ITL Buffer **************/
/***********************************************************/
void HcS_DumpATL(PUSHORT ptr2Structure, USHORT XferLengthInByte)
{
	USHORT	i;

	PHC_SetXferCounter(XferLengthInByte);

	// Begin of Critical Section
	if(bIRQL == 0)
		RaiseIRQL();

	Hal4Hc_CommandOutW(REG_ATL_BUFF_IO|0x80);
	Hal4Hc_Wait4DataPhase();

	for(i = 0; i < (XferLengthInByte+1)/2; i++)
	{
		Hal4Hc_DataOutW(*ptr2Structure);
		ptr2Structure ++ ;
//        Hal4Sys_WaitinUS(2);
	}

	//add for 1362
	Hal4Hc_RegOutW(REG_BUFF_STS,0x08);
	//end

	if(bIRQL == 0)
		LowerIRQL();
	// End of Critical Section
}

void HcS_RetrieveATL(PUSHORT ptr2Structure, USHORT XferLengthInByte)
{
	USHORT	i;

	PHC_SetXferCounter(XferLengthInByte);

	if(bIRQL == 0)
		RaiseIRQL();

	Hal4Hc_CommandOutW(REG_ATL_BUFF_IO);
	Hal4Hc_Wait4DataPhase();
	for(i = 0; i < (XferLengthInByte+1)/2; i++)
	{
		*ptr2Structure = Hal4Hc_DataInW();
		ptr2Structure ++ ;
	}

	if(bIRQL == 0)
		LowerIRQL();
}

void HcS_DumpITL(PUSHORT ptr2Structure, USHORT XferLengthInByte)
{
	USHORT	i;

	PHC_SetXferCounter(XferLengthInByte);

	// Begin of Critical Section
	if(bIRQL == 0)
		RaiseIRQL();

	Hal4Hc_CommandOutW(REG_ISTL0_BUFF_IO|0x80);
	Hal4Hc_Wait4DataPhase();

	for(i = 0; i < (XferLengthInByte+1)/2; i++)
	{
		Hal4Hc_DataOutW(*ptr2Structure);
		ptr2Structure ++ ;
	}

	if(bIRQL == 0)
		LowerIRQL();
	// End of Critical Section
}

void HcS_RetrieveITL(PUSHORT ptr2Structure, USHORT XferLengthInByte)
{
	USHORT	i;

	PHC_SetXferCounter(XferLengthInByte);

	if(bIRQL == 0)
		RaiseIRQL();

	Hal4Hc_CommandOutW(REG_ISTL0_BUFF_IO);
	Hal4Hc_Wait4DataPhase();
	for(i = 0; i < (XferLengthInByte+1)/2; i++)
	{
		*ptr2Structure = Hal4Hc_DataInW();
		ptr2Structure ++ ;
	}

	if(bIRQL == 0)
		LowerIRQL();
}

void HcS_Wait4ATLDone(void)
{
	PHC_Wait4ATLDone();
}

void HcS_Wait4ITLDone(void)
{
	PHC_Wait4ITLDone();
}

void HcS_Wait4NextSOF(void)
{

	ULONG CurFrmNo = PHC_GetFrameNum();
	while(PHC_GetFrameNum() == CurFrmNo);
	return;
}
/***********************************************************/
/******** Functions - Build up ATL/ITL Buffer **************/
/***********************************************************/
void HcS_BuildUSBDataOut(
	PVOID pBuff,
	UCHAR DevAddr,
	UCHAR Endp,
	UCHAR Speed,
	UCHAR IsISO,
	UCHAR Last,
	UCHAR DataToggle,
	USHORT PktSize,
	USHORT XferLength,

	PUCHAR pPayload
	)
{
	USHORT i;
	PDATA_XFER		pHcS_UsbDataOutStage = (PDATA_XFER)pBuff;

	pHcS_UsbDataOutStage->PTD.ActualBytes = 0;
	pHcS_UsbDataOutStage->PTD.CompletionCode = PTD_RETCODE_NOTOUCH;
	pHcS_UsbDataOutStage->PTD.Toggle = DataToggle;
	pHcS_UsbDataOutStage->PTD.Active = PTD_ACTIVE;
	pHcS_UsbDataOutStage->PTD.FunctionAddress = DevAddr;
	pHcS_UsbDataOutStage->PTD.Format = IsISO;
	pHcS_UsbDataOutStage->PTD.EndpointNumber = Endp;
	pHcS_UsbDataOutStage->PTD.DirectionPID = PTD_TOKEN_OUT;
	pHcS_UsbDataOutStage->PTD.Speed = Speed;
	pHcS_UsbDataOutStage->PTD.Last = Last;
	pHcS_UsbDataOutStage->PTD.MaxPacketSize = PktSize;
	pHcS_UsbDataOutStage->PTD.Reserved1 = 0x00;
	pHcS_UsbDataOutStage->PTD.TotalBytes = XferLength;
	pHcS_UsbDataOutStage->PTD.Reserved2 = 0x00;

	if(NULL != pPayload)
	{
		for( i = 0 ; i < XferLength; i ++)
		{
			pHcS_UsbDataOutStage->Payload[i] = *pPayload;
			pPayload ++;
		}
	}
	else
	{
		for( i = 0 ; i < XferLength; i ++)
		{
			pHcS_UsbDataOutStage->Payload[i] = i;
		}
	}
}

void HcS_BuildUSBDataIn(
	PVOID pBuff,
	UCHAR DevAddr,
	UCHAR Endp,
	UCHAR Speed,
	UCHAR IsISO,
	UCHAR Last,
	UCHAR DataToggle,
	USHORT PktSize,
	USHORT XferLength
	)
{
	USHORT i;
	PDATA_XFER		pHcS_UsbDataInStage = (PDATA_XFER)pBuff;

	pHcS_UsbDataInStage->PTD.ActualBytes = 0;
	pHcS_UsbDataInStage->PTD.CompletionCode = PTD_RETCODE_NOTOUCH;
	pHcS_UsbDataInStage->PTD.Toggle = DataToggle;
	pHcS_UsbDataInStage->PTD.Active = PTD_ACTIVE;
	pHcS_UsbDataInStage->PTD.FunctionAddress = DevAddr;
	pHcS_UsbDataInStage->PTD.Format = IsISO;
	pHcS_UsbDataInStage->PTD.EndpointNumber = Endp;
	pHcS_UsbDataInStage->PTD.DirectionPID = PTD_TOKEN_IN;
	pHcS_UsbDataInStage->PTD.Speed = Speed;
	pHcS_UsbDataInStage->PTD.Last = Last;
	pHcS_UsbDataInStage->PTD.MaxPacketSize = PktSize;
	pHcS_UsbDataInStage->PTD.Reserved1 = 0x00;
	pHcS_UsbDataInStage->PTD.TotalBytes = XferLength;
	pHcS_UsbDataInStage->PTD.Reserved2 = 0x00;
	for( i = 0 ; i < XferLength; i ++)
	{
		pHcS_UsbDataInStage->Payload[i] = 0xFF;
	}
}

void HcS_BuildUSBRequest(
	PVOID pBuff,
	UCHAR DevAddr,
	UCHAR Speed,
	UCHAR PktSize,

	UCHAR bmRequestType,
	UCHAR bRequest,
	USHORT wValue,
	USHORT wIndex,
	USHORT wLength
	)
{
	PSETUP_XACTION	pHcS_UsbSetupStage = (PSETUP_XACTION)pBuff;
	pHcS_UsbSetupStage->PTD.ActualBytes = 0;
	pHcS_UsbSetupStage->PTD.Toggle = PTD_TOGGLE_DATA0;
	pHcS_UsbSetupStage->PTD.Active = PTD_ACTIVE;
	pHcS_UsbSetupStage->PTD.CompletionCode = PTD_RETCODE_NOTOUCH;

	pHcS_UsbSetupStage->PTD.MaxPacketSize = PktSize;
	pHcS_UsbSetupStage->PTD.Speed = Speed;
	pHcS_UsbSetupStage->PTD.Last = 0; //use HcATLLastPTD register
//	pHcS_UsbSetupStage->PTD.Last = 1; //!!!only one ATL in process.!!!
	pHcS_UsbSetupStage->PTD.EndpointNumber = 0;

	pHcS_UsbSetupStage->PTD.TotalBytes = 0x08;
	pHcS_UsbSetupStage->PTD.DirectionPID = PTD_TOKEN_SETUP;
	pHcS_UsbSetupStage->PTD.Reserved1 = 0x00;

	pHcS_UsbSetupStage->PTD.FunctionAddress = DevAddr;
	pHcS_UsbSetupStage->PTD.Format = PTD_FORMAT_NONISO;
	pHcS_UsbSetupStage->PTD.Reserved2 = 0x00;

	pHcS_UsbSetupStage->UsbReq.bmRequestType = bmRequestType;
	pHcS_UsbSetupStage->UsbReq.bRequest = bRequest;
	pHcS_UsbSetupStage->UsbReq.wValue = wValue;
	pHcS_UsbSetupStage->UsbReq.wIndex = wIndex;
	pHcS_UsbSetupStage->UsbReq.wLength = wLength;
}

void HcS_BuildUSBDataOutDefault(
	UCHAR DevAddr,
	UCHAR Endp,
	UCHAR Speed,
	UCHAR IsISO,
	UCHAR Last,
	UCHAR DataToggle,
	USHORT PktSize,
	USHORT XferLength,

	PUCHAR pPayload
	)
{
	HcS_BuildUSBDataOut(
		& HcS_UsbDataOutStage,
		DevAddr,
		Endp,
		Speed,
		IsISO,
		Last,
		DataToggle,
		PktSize,
		XferLength,
		pPayload
	);
}

void HcS_BuildUSBDataInDefault(
	UCHAR DevAddr,
	UCHAR Endp,
	UCHAR Speed,
	UCHAR IsISO,
	UCHAR Last,
	UCHAR DataToggle,
	USHORT PktSize,
	USHORT XferLength
)
{
	HcS_BuildUSBDataIn(
		& HcS_UsbDataInStage,

		DevAddr,
		Endp,
		Speed,
		IsISO,
		Last,
		DataToggle,
		PktSize,
		XferLength
	);

}

void HcS_BuildUSBRequestDefault(
	UCHAR DevAddr,
	UCHAR Speed,
	UCHAR PktSize,

	UCHAR bmRequestType,
	UCHAR bRequest,
	USHORT wValue,
	USHORT wIndex,
	USHORT wLength
	)
{
	HcS_BuildUSBRequest(
		& HcS_UsbSetupStage,

		DevAddr,
		Speed,
		PktSize,

		bmRequestType,
		bRequest,
		wValue,
		wIndex,
		wLength
	);
}

/********************************************************/
/******** Functions - PTD Error Handler ****/
/********************************************************/
void HcS_PTD_ErrorHandler(UCHAR Stage, UCHAR CompletionCode)
{
	switch (Stage)
	{
		case CTRLXFER_SETUP_STAGE:
			printf(" ControlXfer -- Setup Stage: ");
			break;
		case CTRLXFER_DATA_IN_STAGE:
			printf(" ControlXfer -- DataIn Stage: ");
			break;
		case CTRLXFER_DATA_OUT_STAGE:
			printf(" ControlXfer -- DataOut Stage: ");
			break;
		case BULKXFER_DATA_IN_STAGE:
			printf(" BulkXfer -- DataIn Stage: ");
			break;
		case BULKXFER_DATA_OUT_STAGE:
			printf(" BulkXfer -- DataOut Stage: ");
			break;
		case ISOXFER_DATA_IN_STAGE:
			printf(" IsoXfer -- DataIn Stage: ");
			break;
		case ISOXFER_DATA_OUT_STAGE:
			printf(" IsoXfer -- DataOut Stage: ");
			break;
		case INTXFER_DATA_IN_STAGE:
			printf(" InterruptXfer -- DataIn Stage: ");
			break;
		case INTXFER_DATA_OUT_STAGE:
			printf(" InterruptXfer -- DataOut Stage: ");
			break;
		case CTRLXFER_STATUS_IN_STAGE:
			printf(" ControlXfer -- StatusIn Stage: ");
			break;
		case CTRLXFER_STATUS_OUT_STAGE:
			printf(" ControlXfer -- StatusOut Stage: ");
			break;
		default:
			break;
	}

	switch (CompletionCode)
	{
		case  PTD_RETCODE_OK:
			printf(" OK\n");
			break;
		case  PTD_RETCODE_CRC:
			printf(" CRC Error\n");
			break;
		case  PTD_RETCODE_BITSTUFF:
			printf(" BitStuff Error\n");
			break;
		case  PTD_RETCODE_DATATOGGLE:
			printf(" DataToggle Error\n");
			break;
		case  PTD_RETCODE_STALL:
			printf(" Stall Error\n");
			break;
		case  PTD_RETCODE_NORESP:
			printf(" NoResponse Error\n");
			break;
		case  PTD_RETCODE_PID:
			printf(" PID Error\n");
			break;
		case  PTD_RETCODE_PIDUNKNOWN:
			printf(" Unkonwn PID Error\n");
			break;
		case  PTD_RETCODE_DATAOVRUN:
			printf(" DataOverRun Error\n");
			break;
		case  PTD_RETCODE_DATAUNDERUN:
			printf(" DataUnderRun Error\n");
			break;
		case  PTD_RETCODE_BUFOVRUN:
			printf(" BufferOverRun Error\n");
			break;
		case  PTD_RETCODE_BUFUNDERUN:
			printf(" BufferUnderRun Error\n");
			break;
		case PTD_RETCODE_NOTOUCH:
			printf(" Device keeps Naking\n");
			break;
		default:
			printf(" TimeOut or Retry Abort\n");
			break;
	}
	Hal4Sys_Pause();
}

/********************************************************/
/******** Functions - ControlXfer for ATL/ITL Buffer ****/
/********************************************************/
BOOLEAN HcS_USBCtrlSetupStage(void)
{
	UCHAR CompletionCode;
//	UCHAR Active;
	USHORT RetryCnt = MAX_RETRY - 1;

	//SetupStage
	while(TRUE)
	{
		// Xfer ATL
		HcS_UsbSetupStage.PTD.Active = 1;
		HcS_UsbSetupStage.PTD.CompletionCode = PTD_RETCODE_NOTOUCH;
		HcS_DumpATL((PUSHORT) &HcS_UsbSetupStage, sizeof(SETUP_XACTION) );
		HcS_Wait4ATLDone();
		HcS_RetrieveATL((PUSHORT) &HcS_UsbSetupStage, sizeof(PTD_32bitAlign));

		// Analyze ATL
		CompletionCode = HcS_UsbSetupStage.PTD.CompletionCode;
//		Active = HcS_UsbSetupStage.PTD.Active;
		if(CompletionCode != PTD_RETCODE_OK && RetryCnt > 0)
		{
			RetryCnt --;
		}
		else
		{
			break;
		}
	}

	if(bVerboseHCS)
		printf("Setup Stage: Face Error  %u times\n",MAX_RETRY-1-RetryCnt);
	if(CompletionCode != PTD_RETCODE_OK)
	{
		HcS_PTD_ErrorHandler(CTRLXFER_SETUP_STAGE,CompletionCode);
		return FALSE;
	}
	else
		return TRUE;
}

BOOLEAN HcS_USBCtrlDataInStage(void)
{
	UCHAR 	CompletionCode;
	UCHAR 	Active;
#ifdef	USB_SPEC_REQ
	USHORT 	TimeOut = TIMEOUT_500MS;
#endif
	USHORT 	RetryCnt = MAX_RETRY - 1;

	while(TRUE)
	{
		// Xfer ATL
		HcS_UsbDataInStage.PTD.Active = 1;
		HcS_UsbDataInStage.PTD.CompletionCode = PTD_RETCODE_NOTOUCH;
		HcS_DumpATL((PUSHORT) &HcS_UsbDataInStage, sizeof(PTD_32bitAlign) );
		HcS_Wait4ATLDone();
		HcS_RetrieveATL((PUSHORT) &HcS_UsbDataInStage, sizeof(PTD_32bitAlign)+MAX_PAYLOAD);

		// Analyze ATL
		CompletionCode = HcS_UsbDataInStage.PTD.CompletionCode;
		Active = HcS_UsbDataInStage.PTD.Active;
		if(	CompletionCode == PTD_RETCODE_STALL ||
			CompletionCode == PTD_RETCODE_DATAUNDERUN ||
			RetryCnt == 0 ||
#ifdef	USB_SPEC_REQ
			TimeOut == 0 ||
#endif
			(CompletionCode == PTD_RETCODE_OK && Active == 0)
		)
		{
			break;
		}
		else if(Active == 1 &&
			CompletionCode == PTD_RETCODE_NOTOUCH || // First Xaction is Naking
			CompletionCode == PTD_RETCODE_OK      	 // Rest Xactions are Naking
		)
		{
			// Device Keep NAKing
			// Host Retry Forever;
#ifdef	USB_SPEC_REQ
			TimeOut --;
#endif
			RetryCnt = MAX_RETRY-1;
		}
		else
		{
//			HcS_PTD_ErrorHandler(CTRLXFER_DATA_IN_STAGE,CompletionCode);
			RetryCnt -- ;
		}
	}

	if(bVerboseHCS)
		printf("DataIn Stage: Face Error  %u times\n",MAX_RETRY-1-RetryCnt);

	if((CompletionCode == PTD_RETCODE_OK && Active == 0)|| CompletionCode == PTD_RETCODE_DATAUNDERUN)
	{
		return TRUE;
	}
	else
	{
		HcS_PTD_ErrorHandler(CTRLXFER_DATA_IN_STAGE,CompletionCode);
		return FALSE;
	}
}

BOOLEAN HcS_USBCtrlDataOutStage(void)
{
	UCHAR 	CompletionCode;
	UCHAR 	Active;
#ifdef	USB_SPEC_REQ
	USHORT 	TimeOut = TIMEOUT_500MS;
#endif
	USHORT 	RetryCnt = MAX_RETRY-1;

	while(TRUE)
	{
		//Xfer ATL
		HcS_UsbDataOutStage.PTD.Active = 1;
		HcS_UsbDataOutStage.PTD.CompletionCode = PTD_RETCODE_NOTOUCH;
		HcS_DumpATL((PUSHORT) &HcS_UsbDataOutStage, sizeof(PTD_32bitAlign)+MAX_PAYLOAD);
		HcS_Wait4ATLDone();
		HcS_RetrieveATL((PUSHORT) &HcS_UsbDataOutStage, sizeof(PTD_32bitAlign));

		//Analyze ATL
		CompletionCode = HcS_UsbDataOutStage.PTD.CompletionCode;
		Active = HcS_UsbDataOutStage.PTD.Active;
		if(	CompletionCode == PTD_RETCODE_STALL ||
			RetryCnt == 0 ||
#ifdef	USB_SPEC_REQ
			TimeOut == 0 ||
#endif
			(CompletionCode == PTD_RETCODE_OK && Active == 0)
		)
		{
			break;
		}
12 3 下一页
⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -