scsiblk.bak

RDC R2886 USB Ehci ohc测试源码,paradigm c++上运行测试

// USB Host Controller OHCI test pattern file
// 09/04/2003    Jeff

#include <systypes.h>					/* Paradigm C++ standard types */
#include <stdio.h>
#include <dos.h>
#include <alloc.h>
#include <embedded.h>
#include <string.h>
#include <conio.h>
#include "..\Include\USBHost.h"
#include "..\Include\SCSIBLK.H"

/* +++++++++++++++++++++ USBHCD.c +++++++++++++++++++++++++ */
BOOL Set_Configuration(int num);

/* +++++++++++++++++++++ USBLib.c +++++++++++++++++++++++++ */
unsigned int UpperAddr (void far *p);
unsigned int LowerAddr (void far *p);
void DWordWrite(void far *p, u32 data);
void DWordWriteHL(void far *p, u16 dataH, u16 dataL);
u32 DWordRead(void far *p);
void mdelay(u16 ms);

/* +++++++++++++++++++++ USBUART.c +++++++++++++++++++++++++ */
char* Num_ASCII_W(char *p, int Data, BOOL AddPoint);
void UART_SendData(char* buf, int size);

struct scsi_blk scsiblk;
ehci_qh __far *ehci_Ep1;
ehci_qh __far *ehci_Ep2;

ehci_qtd __far *ehci_CBW_TD;
ehci_qtd __far *ehci_CSW_TD;
ehci_qtd __far *ehci_DataOut_TD;
ehci_qtd __far *ehci_DataIn_TD;

struct INQUIRY_DATA inquiry_data;

extern std_dev_des __far *dev_des;
extern std_cfg_des __far *cfg_des;

extern ehci_qh __far *ehci_Ep0;
extern int Do_TD_Complete;
extern int SCSICnt;

// ============================================================================
void InitEndPoint1_2(void)
{
	char __far *Host_memory_ptr;

	//Allocate QH format structure
	Host_memory_ptr = (char *)malloc(sizeof(ehci_qh)+32);	//sizeof QH + 32
	Host_memory_ptr = (char *) (((unsigned long)Host_memory_ptr + 0x1F) & ~0x1F);

	ehci_Ep1 = (ehci_qh *) Host_memory_ptr;
	
	ehci_Ep1->hw_next = (UpperAddr(ehci_Ep1)<<16)|LowerAddr(ehci_Ep1)|QH_Typ_QH;
	ehci_Ep1->hw_info1 = QH_RL|0x02000000L|QH_DTC_QH|QH_EPS|QH_EndPt_1|QH_DAddr;	//MaxPckLen
	ehci_Ep1->hw_info2 = QH_Mult;
	ehci_Ep1->hw_current = 0;
	ehci_Ep1->hw_qtd_next = 0x01;
	ehci_Ep1->hw_alt_next = 0x01;
	ehci_Ep1->hw_token = QH_IOC;
	ehci_Ep1->hw_buf[0] = 0;
	ehci_Ep1->hw_buf[1] = 0;
	ehci_Ep1->hw_buf[2] = 0;
	ehci_Ep1->hw_buf[3] = 0;
	ehci_Ep1->hw_buf[4] = 0;

	//Allocate QH format structure
	Host_memory_ptr = (char *)malloc(sizeof(ehci_qh)+32);	//sizeof QH + 32
	Host_memory_ptr = (char *) (((unsigned long)Host_memory_ptr + 0x1F) & ~0x1F);

	ehci_Ep2 = (ehci_qh *) Host_memory_ptr;
	
	ehci_Ep2->hw_next = (UpperAddr(ehci_Ep2)<<16)|LowerAddr(ehci_Ep2)|QH_Typ_QH;
	ehci_Ep2->hw_info1 = QH_RL|0x02000000L|QH_DTC_QH|QH_EPS|QH_EndPt_2|QH_DAddr;	//MaxPckLen
	ehci_Ep2->hw_info2 = QH_Mult;
	ehci_Ep2->hw_current = 0;
	ehci_Ep2->hw_qtd_next = 0x01;
	ehci_Ep2->hw_alt_next = 0x01;
	ehci_Ep2->hw_token = QH_IOC;
	ehci_Ep2->hw_buf[0] = 0;
	ehci_Ep2->hw_buf[1] = 0;
	ehci_Ep2->hw_buf[2] = 0;
	ehci_Ep2->hw_buf[3] = 0;
	ehci_Ep2->hw_buf[4] = 0;
	
	ehci_Ep1->hw_next = ehci_Ep0->hw_next;
	ehci_Ep2->hw_next = (UpperAddr(ehci_Ep1)<<16)|LowerAddr(ehci_Ep1)|QH_Typ_QH;	
	ehci_Ep0->hw_next = (UpperAddr(ehci_Ep2)<<16)|LowerAddr(ehci_Ep2)|QH_Typ_QH;
}

void InitBulk4TD(void)
{
	char __far *Host_memory_ptr;

	//Allocate TD format structure
	Host_memory_ptr = (char *)malloc(sizeof(ehci_qtd)+32);	//sizeof ehci_qtd + 32
	Host_memory_ptr = (char *) (((unsigned long)Host_memory_ptr + 0x1F) & ~0x1F);
	ehci_CBW_TD = (ehci_qtd *) Host_memory_ptr;
	
	//Allocate TD format structure
	Host_memory_ptr = (char *)malloc(sizeof(ehci_qtd)+32);	//sizeof ehci_qtd + 32
	Host_memory_ptr = (char *) (((unsigned long)Host_memory_ptr + 0x1F) & ~0x1F);
	ehci_CSW_TD = (ehci_qtd *) Host_memory_ptr;

	//Allocate TD format structure
	Host_memory_ptr = (char *)malloc(sizeof(ehci_qtd)+32);	//sizeof ehci_qtd + 32
	Host_memory_ptr = (char *) (((unsigned long)Host_memory_ptr + 0x1F) & ~0x1F);
	ehci_DataOut_TD = (ehci_qtd *) Host_memory_ptr;

	//Allocate TD format structure
	Host_memory_ptr = (char *)malloc(sizeof(ehci_qtd)+32);	//sizeof ehci_qtd + 32
	Host_memory_ptr = (char *) (((unsigned long)Host_memory_ptr + 0x1F) & ~0x1F);
	ehci_DataIn_TD = (ehci_qtd *) Host_memory_ptr;
	
	//Set Default value
	ehci_DataOut_TD->hw_token = 0;
}

void Init_scsiblk()
{
	InitEndPoint1_2();
	InitBulk4TD();
	
	scsiblk.phase=Ready;
	scsiblk.data_len=0;
	scsiblk.cur_pos=0;
	scsiblk.start_log_blk=0;
	
	scsiblk.command.dCBWSignature[0]='U';
	scsiblk.command.dCBWSignature[1]='S';
	scsiblk.command.dCBWSignature[2]='B';
	scsiblk.command.dCBWSignature[3]='C';	
	scsiblk.command.dCBWTag = 0x81715C68L;
}

// ============================================================================
void InitCBW(void)
{
	int i;
	char *p;
	
	p=(void far*)&scsiblk.command.CDB[0];
	
	for(i=0;i<16;i++)
		*p++ = 0;
}

BOOL Scsi_Command_Process(void far *p)
{
	u32 temp;
	
	//EP2, Out endpoint ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	//CBW
	ehci_CBW_TD->hw_next = 0x01;
	ehci_CBW_TD->hw_alt_next = 0x01;
	ehci_CBW_TD->hw_buf[0] = (UpperAddr(&scsiblk.command) << 16) + LowerAddr(&scsiblk.command);
	temp = (u32)sizeof(scsiblk.command) << 16;
	ehci_CBW_TD->hw_token = temp|QTD_CERR_3|QTD_PID_OUT|QTD_STS_ACTIVE;
	
	//Data_Out
	if((scsiblk.command.dCBWDataTransferLength > 0) && (scsiblk.command.bmCBWFlags == CBW_DataOUT))
	{
		ehci_DataOut_TD->hw_next = 0x01;
		ehci_DataOut_TD->hw_alt_next = 0x01;
		ehci_DataOut_TD->hw_buf[0] = (UpperAddr(p) << 16) + LowerAddr(p);
		temp = scsiblk.command.dCBWDataTransferLength << 16;
		ehci_DataOut_TD->hw_token = temp|QTD_CERR_3|QTD_PID_OUT|QTD_STS_ACTIVE;
		
		//Link Data Out to CBW
		ehci_CBW_TD->hw_next = (UpperAddr(ehci_DataOut_TD) << 16) + LowerAddr(ehci_DataOut_TD);
	}
	
	//Write TD to QH, valid CBW TD
	ehci_Ep2->hw_qtd_next = (UpperAddr(ehci_CBW_TD) << 16) + LowerAddr(ehci_CBW_TD);
	//End EP2 ----------------------------------------------------------------------------

	//Ep1, In endpoint +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	//Data_In
	if((scsiblk.command.dCBWDataTransferLength > 0) && (scsiblk.command.bmCBWFlags == CBW_DataIN))
	{
		ehci_DataIn_TD->hw_next = 0x01;
		ehci_DataIn_TD->hw_alt_next = 0x01;
		ehci_DataIn_TD->hw_buf[0] = (UpperAddr(p) << 16) + LowerAddr(p);
		temp = scsiblk.command.dCBWDataTransferLength << 16;
		ehci_DataIn_TD->hw_token = temp|QTD_CERR_3|QTD_PID_IN|QTD_STS_ACTIVE;
	}
	
	//CSW
	ehci_CSW_TD->hw_next = 0x01;
	ehci_CSW_TD->hw_alt_next = 0x01;
	ehci_CSW_TD->hw_buf[0] = (UpperAddr(&scsiblk.status) << 16) + LowerAddr(&scsiblk.status);
	temp = (u32)sizeof(scsiblk.status) << 16;
	ehci_CSW_TD->hw_token = temp|QTD_IOC|QTD_CERR_3|QTD_PID_IN|QTD_STS_ACTIVE;
	if((scsiblk.command.dCBWDataTransferLength > 0) && (scsiblk.command.bmCBWFlags == CBW_DataIN))
	{
		//Link CSW to DataIN
		ehci_DataIn_TD->hw_next = (UpperAddr(ehci_CSW_TD) << 16) + LowerAddr(ehci_CSW_TD);
	
		//Write TD to QH, valid DataIN and CSW TD
		ehci_Ep1->hw_qtd_next = (UpperAddr(ehci_DataIn_TD) << 16) + LowerAddr(ehci_DataIn_TD);	
	}
	else
	{
		//Write TD to QH, valid CSW TD
		ehci_Ep1->hw_qtd_next = (UpperAddr(ehci_CSW_TD) << 16) + LowerAddr(ehci_CSW_TD);
	}
	//End EP1 ----------------------------------------------------------------------------
	
	Do_TD_Complete = 0;
	do{} while(Do_TD_Complete == 0);
	
	if(((ehci_CBW_TD->hw_token & 0x7E) != 0) || ((ehci_DataIn_TD->hw_token & 0x7E) != 0) 
		|| ((ehci_DataOut_TD->hw_token & 0x7E) != 0)|| ((ehci_CSW_TD->hw_token & 0x7E) != 0))
		return FALSE;
	return TRUE;
}

BOOL Inquiry_Command(void)
{
	int i;
	char *p, *q;
	
	struct INQUIRY_DATA Std_inquiry_data = {0,0x80,0x02,0x02,31,{0,0,0},"OTi     ","Flash Disk      " ,"2.00"};
	//struct CSW Std_CSW = {"USBS", 0x81715C68L, 0, 0};
	
	//Inquiry
	InitCBW();
	scsiblk.command.dCBWDataTransferLength = 0x00000024;
	scsiblk.command.bmCBWFlags = CBW_DataIN;
	scsiblk.command.bCBWLUN = 0;
	scsiblk.command.bCBWCBLength = 0x06;
	scsiblk.command.CDB[0] = 0x12;
	scsiblk.command.CDB[4] = 0x24;
	if(Scsi_Command_Process(&inquiry_data) == FALSE)
		return FALSE;
	
	/*p=(void far*)&inquiry_data;
	q=(void far*)&Std_inquiry_data;
	//for(i=0;i<sizeof(inquiry_data);i++)
   for(i=0;i<5;i++)
		if(*p++ != *q++)
			return FALSE;
	p=(void far*)&scsiblk.status;
	q=(void far*)&Std_CSW;
	for(i=0;i<sizeof(Std_CSW);i++)
		if(*p++ != *q++)
			return FALSE;*/
			
	return TRUE;
}

BOOL Read_Format_Capa_Command(void)
{
	int i;
	char *p, *q;
	
	char CapList[12];
	char Std_CapLins[12] = {0,0,0,8,1,0,0, 0, 3,0,2,0};
	struct CSW Std_CSW = {"USBS", 0x81715C68L, 0xF0, 0};
	
	//Inquiry
	InitCBW();
	scsiblk.command.dCBWDataTransferLength = 0x000000FC;
	scsiblk.command.bmCBWFlags = CBW_DataIN;
	scsiblk.command.bCBWLUN = 0;
	scsiblk.command.bCBWCBLength = 0x0A;
	scsiblk.command.CDB[0] = 0x23;
	scsiblk.command.CDB[8] = 0xFC;
	Scsi_Command_Process(CapList);
	
	/*p=(void far*)CapList;
	q=(void far*)Std_CapLins;
	for(i=0;i<sizeof(CapList);i++)
		if(*p++ != *q++)
			return FALSE;
	p=(void far*)&scsiblk.status;
	q=(void far*)&Std_CSW;
	for(i=0;i<sizeof(Std_CSW);i++)
		if(*p++ != *q++)
			return FALSE;*/
			
	return TRUE;
}

BOOL AllocateDisk()
{
 	static char buf[30];
 	char buf1[26]={"Doing SCSI Command......."};
 	char *p, *q;
 	int i;
	
	if(Inquiry_Command() == FALSE)
		return FALSE;
	
	if(Read_Format_Capa_Command() == FALSE)
		return FALSE;

	SCSICnt++;
	if(SCSICnt == 0x0000){
		p=buf;
		q=buf1;
		for(i=0;i<sizeof(buf1);i++)
			*p++ = *q++;
		*p++ = 10;
		*p++ = 13;
		UART_SendData(buf, sizeof(buf));
	}

	return TRUE;
}

void SendSCSI2UART(void)
{
	static char buf[40];
	char buf1[33] = {"SCSI Command transfer times : 0x"};
	char buf2[33] = {"Bulk Loop transfer times    : 0x"};
	char *p, *q;
	int i;

	if((dev_des->idVendor != 0x1463) && (dev_des->idProduct != 0x05CB))	//Normal bulk SCSI command
		q=buf1;
	else
		q=buf2;
	
	p=buf;
	for(i=0;i<sizeof(buf1);i++)
		*p++ = *q++;
	
	p = Num_ASCII_W(p, SCSICnt, FALSE);
	*p++ = 10;
	*p++ = 13;
	UART_SendData(buf, sizeof(buf));	
}