ohciscsiblk.c

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\USBOHCI.h"
#include "..\Include\SCSIBLK.H"

struct scsi_blk ohci_scsiblk;
ohci_ed_t __far *ohci_Ep1;
ohci_ed_t __far *ohci_Ep2;
ohci_td_t __far *ohci_Ep1_TD0;
ohci_td_t __far *ohci_Ep2_TD0;

ohci_td_t __far *ohci_CBW_TD;
ohci_td_t __far *ohci_CSW_TD;
ohci_td_t __far *ohci_DataOut_TD;
ohci_td_t __far *ohci_DataIn_TD;

struct INQUIRY_DATA ohci_inquiry_data;

char BulkOut1[255];
char BulkOut2[255];
char BulkIn1[255];

extern std_dev_des __far *dev_des;
extern std_cfg_des __far *cfg_des;
extern ohci_registers __far *ohci_regs;
extern std_edp_des __far *edp_des1;
extern std_edp_des __far *edp_des2;
extern u16 TD_Status;
extern int SCSICnt;
extern BOOL BulkLoopInitData;

/* +++++++++++++++++++++ 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);

/* +++++++++++++++++++++ OHCIHCD.c +++++++++++++++++++++++++ */
void InsertEmptyTD(ohci_ed_t __far *ed, ohci_td_t __far *td);
void AddingTDtoED(ohci_ed_t __far *ed, ohci_td_t __far *td);
void OHCI_Set_Configuration(int num);
void OHCI_Init_BulkLoop(void);

/* +++++++++++++++++++++ USBUART.c +++++++++++++++++++++++++ */
void UART_SendData(char* buf, int size);


// ============================================================================
void OHCI_InitEndPoint1_2(void)
{
	u16 temp;
	char __far *Host_memory_ptr;

	//Allocate TD format structure
	Host_memory_ptr = (char *)malloc(sizeof(ohci_ed_t)+16);	//sizeof ohci_ed_t + 16
	Host_memory_ptr = (char *) (((unsigned long)Host_memory_ptr + 0xF) & ~0xF);

	ohci_Ep1 = (ohci_ed_t *) Host_memory_ptr;
	
	temp = (edp_des1->bEndpointAddress & 0x0F) << 7;
	ohci_Ep1->hwINFO = 0x00400000L|ED_D_IN|temp|ED_FA_3;
	ohci_Ep1->hwTailP = 0;
	ohci_Ep1->hwHeadP = 0;
	ohci_Ep1->hwNextED = 0;
	
	InsertEmptyTD(ohci_Ep1, ohci_Ep1_TD0);
	
	DWordWriteHL(&ohci_regs->ed_bulkhead, UpperAddr(ohci_Ep1), LowerAddr(ohci_Ep1));
	
	//Allocate TD format structure
	Host_memory_ptr = (char *)malloc(sizeof(ohci_ed_t)+16);	//sizeof ohci_ed_t + 16
	Host_memory_ptr = (char *) (((unsigned long)Host_memory_ptr + 0xF) & ~0xF);

	ohci_Ep2 = (ohci_ed_t *) Host_memory_ptr;
	
	temp = (edp_des2->bEndpointAddress & 0x0F) << 7;
	ohci_Ep2->hwINFO = 0x00400000L|ED_D_OUT|temp|ED_FA_3;
	ohci_Ep2->hwTailP = 0;
	ohci_Ep2->hwHeadP = 0;
	ohci_Ep2->hwNextED = 0;
	
	InsertEmptyTD(ohci_Ep2, ohci_Ep2_TD0);
	
	ohci_Ep1->hwNextED = (UpperAddr(ohci_Ep2)<<16) + LowerAddr(ohci_Ep2);
}

void OHCI_InitBulk4TD(void)
{
	char __far *Host_memory_ptr;
	
	//Allocate TD format structure
	Host_memory_ptr = (char *)malloc(sizeof(ohci_td_t)+16);	//sizeof ohci_ed_t + 16
	Host_memory_ptr = (char *) (((unsigned long)Host_memory_ptr + 0xF) & ~0xF);
	ohci_CBW_TD = (ohci_td_t *) Host_memory_ptr;
	
	//Allocate TD format structure
	Host_memory_ptr = (char *)malloc(sizeof(ohci_td_t)+16);	//sizeof ohci_ed_t + 16
	Host_memory_ptr = (char *) (((unsigned long)Host_memory_ptr + 0xF) & ~0xF);
	ohci_CSW_TD = (ohci_td_t *) Host_memory_ptr;

	//Allocate TD format structure
	Host_memory_ptr = (char *)malloc(sizeof(ohci_td_t)+16);	//sizeof ohci_ed_t + 16
	Host_memory_ptr = (char *) (((unsigned long)Host_memory_ptr + 0xF) & ~0xF);
	ohci_DataOut_TD = (ohci_td_t *) Host_memory_ptr;

	//Allocate TD format structure
	Host_memory_ptr = (char *)malloc(sizeof(ohci_td_t)+16);	//sizeof ohci_ed_t + 16
	Host_memory_ptr = (char *) (((unsigned long)Host_memory_ptr + 0xF) & ~0xF);
	ohci_DataIn_TD = (ohci_td_t *) Host_memory_ptr;
}

void OHCI_Init_scsiblk()
{
	OHCI_InitEndPoint1_2();
	OHCI_InitBulk4TD();
	
	ohci_scsiblk.phase=Ready;
	ohci_scsiblk.data_len=0;
	ohci_scsiblk.cur_pos=0;
	ohci_scsiblk.start_log_blk=0;
	
	ohci_scsiblk.command.dCBWSignature[0]='U';
	ohci_scsiblk.command.dCBWSignature[1]='S';
	ohci_scsiblk.command.dCBWSignature[2]='B';
	ohci_scsiblk.command.dCBWSignature[3]='C';	
	ohci_scsiblk.command.dCBWTag = 0x81430008L;
}

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

void OHCI_Scsi_Command_Process(void far *p)
{
	//CBW
	ohci_CBW_TD->hwINFO = TD_DP_OUT|TD_T_ED|TD_DI;
	ohci_CBW_TD->hwNextTD = 0;
	ohci_CBW_TD->hwCBP = (UpperAddr(&ohci_scsiblk.command) << 16) + LowerAddr(&ohci_scsiblk.command);
	ohci_CBW_TD->hwBE = ohci_CBW_TD->hwCBP + sizeof(ohci_scsiblk.command) - 1;

	AddingTDtoED(ohci_Ep2, ohci_CBW_TD);
		
	//Data_In
	if((ohci_scsiblk.command.dCBWDataTransferLength > 0) && (ohci_scsiblk.command.bmCBWFlags == CBW_DataIN))
	{
		ohci_DataIn_TD->hwINFO = TD_DP_IN|TD_T_ED|TD_DI|TD_R;
		ohci_DataIn_TD->hwNextTD = 0;
		ohci_DataIn_TD->hwCBP = (UpperAddr(p) << 16) + LowerAddr(p);
		ohci_DataIn_TD->hwBE = ohci_DataIn_TD->hwCBP + ohci_scsiblk.command.dCBWDataTransferLength - 1;
		
		AddingTDtoED(ohci_Ep1, ohci_DataIn_TD);
	}
	
	//CSW
	ohci_CSW_TD->hwINFO = TD_DP_IN|TD_T_ED|TD_DI|TD_R;
	ohci_CSW_TD->hwNextTD = 0;
	ohci_CSW_TD->hwCBP = (UpperAddr(&ohci_scsiblk.status) << 16) + LowerAddr(&ohci_scsiblk.status);
	ohci_CSW_TD->hwBE = ohci_CSW_TD->hwCBP + sizeof(ohci_scsiblk.status) - 1;
	
	AddingTDtoED(ohci_Ep1, ohci_CSW_TD);
}

BOOL OHCI_Inquiry_Command(void)
{
	int i;
	char *p, *q;
	
	struct INQUIRY_DATA Std_inquiry_data = {0,0x80,0,1,31,{0,0,0},"USB     ","Mass Sorage     " ,"1.23"};
	struct CSW Std_CSW = {"USBS", 0x81430008L, 0, 0};
	
	//Inquiry
	OHCI_InitCBW();
	ohci_scsiblk.command.dCBWDataTransferLength = 0x00000024;
	ohci_scsiblk.command.bmCBWFlags = CBW_DataIN;
	ohci_scsiblk.command.bCBWLUN = 0;
	ohci_scsiblk.command.bCBWCBLength = 0x06;
	ohci_scsiblk.command.CDB[0] = 0x12;
	ohci_scsiblk.command.CDB[4] = 0x24;
	OHCI_Scsi_Command_Process(&ohci_inquiry_data);
	
	p=(void far*)&ohci_inquiry_data;
	q=(void far*)&Std_inquiry_data;
	for(i=0;i<sizeof(ohci_inquiry_data);i++)
		if(*p++ != *q++)
			return FALSE;
	p=(void far*)&ohci_scsiblk.status;
	q=(void far*)&Std_CSW;
	for(i=0;i<sizeof(Std_CSW);i++)
		if(*p++ != *q++)
			return FALSE;
			
	return TRUE;
}

BOOL OHCI_Read_Format_Capa_Command(void)
{
	int i;
	char *p, *q;
	
	char CapList[12];
	char Std_CapLins[12] = {0,0,0,8,0,3,0xE2, 0xC0, 2,0,2,0};
	struct CSW Std_CSW = {"USBS", 0x81430008L, 0xF0, 0};
	
	//Inquiry
	OHCI_InitCBW();
	ohci_scsiblk.command.dCBWDataTransferLength = 0x000000FC;
	ohci_scsiblk.command.bmCBWFlags = CBW_DataIN;
	ohci_scsiblk.command.bCBWLUN = 0;
	ohci_scsiblk.command.bCBWCBLength = 0x0A;
	ohci_scsiblk.command.CDB[0] = 0x23;
	ohci_scsiblk.command.CDB[8] = 0xFC;
	OHCI_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*)&ohci_scsiblk.status;
	q=(void far*)&Std_CSW;
	for(i=0;i<sizeof(Std_CSW);i++)
		if(*p++ != *q++)
			return FALSE;
			
	return TRUE;
}

BOOL OHCI_Bulk_Loop(void)
{
	int i,j;
	int Len;
	
	//BulkOut1
	for(i=0;i<sizeof(BulkOut1);i=i+64){
		if((i+64) < sizeof(BulkOut1))
			Len = 64;
		else
			Len = sizeof(BulkOut1) - i;
		
		//Data out BulkOut1
		ohci_DataOut_TD->hwINFO = TD_DP_OUT|TD_T_ED|TD_DI;
		ohci_DataOut_TD->hwNextTD = 0;
		ohci_DataOut_TD->hwCBP = (UpperAddr(&BulkOut1[i]) << 16) + LowerAddr(&BulkOut1[i]);
		ohci_DataOut_TD->hwBE = ohci_DataOut_TD->hwCBP + Len - 1;

		AddingTDtoED(ohci_Ep2, ohci_DataOut_TD);
		
		//Data_In
		ohci_DataIn_TD->hwINFO = TD_DP_IN|TD_T_ED|TD_DI|TD_R;
		ohci_DataIn_TD->hwNextTD = 0;
		ohci_DataIn_TD->hwCBP = (UpperAddr(&BulkIn1[i]) << 16) + LowerAddr(&BulkIn1[i]);
		ohci_DataIn_TD->hwBE = ohci_DataIn_TD->hwCBP + Len - 1;
		
		AddingTDtoED(ohci_Ep1, ohci_DataIn_TD);
	}

	for(j=0;j<sizeof(BulkOut1);j++)
		if(BulkOut1[j] != BulkIn1[j])
			return FALSE;

	//BulkOut2
	for(i=0;i<sizeof(BulkOut2);i=i+64){
		if((i+64) < sizeof(BulkOut2))
			Len = 64;
		else
			Len = sizeof(BulkOut2) - i;
		
		//Data out BulkOut2
		ohci_DataOut_TD->hwINFO = TD_DP_OUT|TD_T_ED|TD_DI;
		ohci_DataOut_TD->hwNextTD = 0;
		ohci_DataOut_TD->hwCBP = (UpperAddr(&BulkOut2[i]) << 16) + LowerAddr(&BulkOut2[i]);
		ohci_DataOut_TD->hwBE = ohci_DataOut_TD->hwCBP + Len - 1;

		AddingTDtoED(ohci_Ep2, ohci_DataOut_TD);
		
		//Data_In
		ohci_DataIn_TD->hwINFO = TD_DP_IN|TD_T_ED|TD_DI|TD_R;
		ohci_DataIn_TD->hwNextTD = 0;
		ohci_DataIn_TD->hwCBP = (UpperAddr(&BulkIn1[i]) << 16) + LowerAddr(&BulkIn1[i]);
		ohci_DataIn_TD->hwBE = ohci_DataIn_TD->hwCBP + Len - 1;
		
		AddingTDtoED(ohci_Ep1, ohci_DataIn_TD);
	}

	for(j=0;j<sizeof(BulkOut2);j++)
		if(BulkOut2[j] != BulkIn1[j])
			return FALSE;
	
	return TRUE;
}

BOOL OHCI_AllocateDisk()
{
 	static char buf[30];
 	char buf1[26]={"Doing SCSI Command......."};
 	char buf2[26]={"Doing Bulk Loop.........."};
 	char *p, *q;
 	int i;
 	u16 temp;

	if((dev_des->idVendor != 0x1463) && (dev_des->idProduct != 0x05CB)){	//Normal bulk SCSI command
		//Init endpoint address
		temp = (edp_des1->bEndpointAddress & 0x0F) << 7;
		ohci_Ep1->hwINFO = 0x00400000L|ED_D_IN|temp|ED_FA_3;
		temp = (edp_des2->bEndpointAddress & 0x0F) << 7;
		ohci_Ep2->hwINFO = 0x00400000L|ED_D_OUT|temp|ED_FA_3;
	
		if(OHCI_Inquiry_Command() == FALSE)
			return FALSE;
	
		if(OHCI_Read_Format_Capa_Command() == FALSE)
			return FALSE;
		
		q=buf1;
	}
	else		//Bulk loop
	{
		OHCI_Init_BulkLoop();
	
		//Init Source buffer for bulk loop
		if(BulkLoopInitData == FALSE){
			for(i=0;i<sizeof(BulkOut1);i++)
				BulkOut1[i] = i+1;
			for(i=0;i<sizeof(BulkOut2);i++)
				BulkOut2[i] = (255 - i);
			BulkLoopInitData = TRUE;
		}
		
		//Init endpoint address
		temp = 2 << 7;
		ohci_Ep1->hwINFO = 0x00400000L|ED_D_IN|temp|ED_FA_3;
		temp = 4 << 7;
		ohci_Ep2->hwINFO = 0x00400000L|ED_D_OUT|temp|ED_FA_3;

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

// ============================================================================
BOOL OHCI_WriteFile()
{
	
	//Need complete the scsi init. first++++
/*	
	//Test Unit ready
	ohci_scsiblk.command.dCBWDataTransferLength = 0;
	ohci_scsiblk.command.bmCBWFlags = 0;
	ohci_scsiblk.command.bCBWLUN = 0;
	ohci_scsiblk.command.bCBWCBLength = 6;
	ohci_scsiblk.command.CDB[0] = 0;
	OHCI_Scsi_Command_Process();
*/	
	return TRUE;
}