usb_rbc.c

一个linux下的usb接口源代码

/*********************************************************************
**	Module Name:		USB_RBC.c									**
**	Author:				ZhangQuan									**
**	Version:			1.0											**
**	CreateDate:			2001-05-18									**
**	Description:		These are the structures and definitions	**
**						used in the Reduced Block Command Set		**
**	Remark:															**
**	Revision History:												**
**********************************************************************/
//#include <linux/interrupt.h>
#include "DataType.h"
#include "MC68VZ328.h"

UCHAR ATAPI_1e(void);				//Command 0x1e:Test unit Ready
UCHAR ATAPI_O_Inquiry(void);		// Command 0x12;
UCHAR ATAPI_O_ReadFormatCapa();		//Command 0x23:Read Format capacity
UCHAR ATAPI_O_ReadCapacity(void);	//Command 0x25:Read Capacity
UCHAR ATAPI_O_ModeSense5A(void);	//Command 0x5A:Mode Select 0x5A
UCHAR ATAPI_O_RequestSense(void);	//Command 0x03:Request Sense package
UCHAR ATAPI_O_NonSense(void);		//Command 0x06:Non-sense
UCHAR ATAPI_Read10();				//Command 0x28: Read data
UCHAR ATAPI_Write10();				//Command 0x2A: Write Data
UCHAR ATAPI_I_ModeSelect55(void);	//Command 0x15:Mode Select 0x15
UCHAR ATAPI_I_VeryPacket();			//Command 0x2f: Verify Packet Command
UCHAR ATAPI_TestUnit(void);			//Command 0x00:Test unit Ready
UCHAR ATAPI_NoCommand(void);
UCHAR ATAPIWriteInforToHost(UCHAR *DataBuff,ULONG ToHostDataLength);
UCHAR ATAPIWriteInforToZip(UCHAR *DataBuff,ULONG ToZipDataLength);
UCHAR ATAPI_I_Base(void);
UCHAR ATAPI_O_Base(void);
//*******************************************************************
//****     Following is  the function for ATAPI processing       ****
//****     	IOmega PocketZip OEM Disk Drive Technical Info       ****
//*******************************************************************

UCHAR IOZip_AtapiHandle(void)
{
	UCHAR status= FALSE;

	//The first byte in bAtapi_CommandPackage is the ATAPI command.
	UCHAR OpCode = TPBulk_CommandBlock_bAtapi_CommandPackage0;

	switch(OpCode)
	{	
//		case ATAPI_READSECTORID:
//		case ATAPI_FORMATUNIT:
		case ATAPI_READFORMATCAPA:
			ATAPI_O_ReadFormatCapa();	//Command 0x23:Read Format capacity
			break;
		case ATAPI_RAEDCAPACITY:
			ATAPI_O_ReadCapacity();
			break;
		case ATAPI_INQUIRE:
			ATAPI_O_Inquiry();
			break;
		case ATAPI_REQUESTSENSE:
			ATAPI_O_RequestSense();	//Command 0x03:Request Sense package					
			break;
		case ATAPI_READ10:
			ATAPI_Read10();
			break;
		case ATAPI_WRITE10:
			ATAPI_Write10();
			break;
	 	case ATAPI_MODESENSE5A:
	 		ATAPI_O_ModeSense5A();	//Command 0x5A:Mode Select 0x5A
	 		break;
		case ATAPI_NONSENSE:
			ATAPI_O_NonSense();		//Command 0x06:Non-sense
			break;
		case ATAPI_MODESELECT55:
			ATAPI_I_ModeSelect55();	//Command 0x55:Mode Select 0x55
			break;
	 	case ATAPI_TESTUNIT:
	 		ATAPI_TestUnit(); 
	 		break;
	 	case 0x1e:
	 		ATAPI_1e(); 
	 		break;
	 	case 0x2f:
	 		ATAPI_I_VeryPacket();
	 		break;
		default:
		    printk("Not finished\n");
		    cli();
			TPBulk_ErrorHandler(CASECBW,0);
			bD12flags.bits.BOT_state = USBFSM4BOT_STALL;
			sti();
			break;
	}
	return status;
}


UCHAR ATAPI_NoCommand(void)
{
	UCHAR c[2];
	usb_initialize();
	c[0]=0;c[1]=0;
	cli();
	D12_WriteEndpoint(5, c, 2);

	TPBulk_CommandStatus_dCSW_DataResidue = 0;
	TPBulk_CommandStatus_bCSW_Status = CSW_FAIL;//CSW_PHASE_ERROR;//CSW_BAD;
	TPBulk_CommandStatus_dCSW_Signature = CSW_SIGNATURE;
	TPBulk_CommandStatus_dCSW_Tag = TPBulk_CommandBlock_dCBW_Tag;
	sti();
	return 1;
}

UCHAR ATAPI_TestUnit(void)	//Command 0x00:Test unit Ready
{
	UWORD	errno;
	UCHAR i;
	UCHAR	c[2];
	
	Buffer_Length =TPBulk_CommandBlock_dCBW_DataXferLen;
	Buffer_Pointer=Allbuffer;
	Id=ID_OTHERS;

	cli();
 	errno=Exec_ATAPI_Command1();

	if(errno==0)	//Modified by Mike Chan
 		TPBulk_CommandStatus_bCSW_Status = CSW_GOOD;
 	else 
 	{
 		TPBulk_CommandStatus_bCSW_Status = CSW_FAIL;
 	}
 		 	
	TPBulk_CommandStatus_dCSW_DataResidue = 0;
	TPBulk_CommandStatus_dCSW_Signature = CSW_SIGNATURE;
	TPBulk_CommandStatus_dCSW_Tag = TPBulk_CommandBlock_dCBW_Tag;

	TPBulk_CSWHandler();
	sti();	
	return 1;
}


UCHAR ATAPI_1e(void)	//Command 0x00:Test unit Ready
{
	UWORD	errno;
	UCHAR i;
	UCHAR	c[2];
	
	Buffer_Length =TPBulk_CommandBlock_dCBW_DataXferLen;
	Buffer_Pointer=Allbuffer;
	Id=ID_SET;

	cli();
 	errno=Exec_ATAPI_Command1();
	if(errno==0)	//Modified by Mike Chan
 		TPBulk_CommandStatus_bCSW_Status = CSW_GOOD;
 	else 
 	{
 		TPBulk_CommandStatus_bCSW_Status = CSW_FAIL;
 	}
 		 	
	TPBulk_CommandStatus_dCSW_DataResidue = 0;
	TPBulk_CommandStatus_dCSW_Signature = CSW_SIGNATURE;
	TPBulk_CommandStatus_dCSW_Tag = TPBulk_CommandBlock_dCBW_Tag;

	TPBulk_CSWHandler();
	sti();
	return 1;
}

UCHAR ATAPI_I_Base(void)		
{
	UWORD	errno;
	ULONG i;
		
	Buffer_Length =TPBulk_CommandBlock_dCBW_DataXferLen;
	Buffer_Pointer=Allbuffer;
	Id=ID_SET;		//Wrong for ID_OTHERS	
	ATAPIWriteInforToZip(Buffer_Pointer, Buffer_Length);

	while(bD12flags.bits.BOT_state != USBFSM4BOT_DATAOVER)
	{
		printk("ATAPI_I_Base while die loop\n");
	}

	cli();
 	errno = Exec_ATAPI_Command1();
 	
 	if(errno==0)	//Modified by Mike Chan
 		TPBulk_CommandStatus_bCSW_Status = CSW_GOOD;
 	else 
 	{
 		TPBulk_CommandStatus_bCSW_Status = CSW_FAIL;
 	}

	TPBulk_CSWHandler();
	sti();
	return errno;
}

UCHAR ATAPI_O_Base(void)		
{
	static entercnt = 0;
	UCHAR	errno;
	ULONG i;

	entercnt ++;
	Buffer_Length =TPBulk_CommandBlock_dCBW_DataXferLen;
	Buffer_Pointer=Allbuffer;
	Id=ID_OTHERS;
	cli();
 	errno=Exec_ATAPI_Command1();
 	 	
 	if(errno==0)	//Modified by Mike Chan
 		TPBulk_CommandStatus_bCSW_Status = CSW_GOOD;
 	else 
 	{
 		TPBulk_CommandStatus_bCSW_Status = CSW_FAIL;
 	}
 	sti();
	ATAPIWriteInforToHost(Buffer_Pointer, Buffer_Length);
	return errno;
}

UCHAR ATAPI_O_ReadSectorID(void)//Command 0x05:Read Sector IDs Packet Command
{
	return 0;
}


UCHAR ATAPI_O_RequestSense(void)	//Command 0x03:Request Sense package
{
	return ATAPI_O_Base();
}

UCHAR ATAPI_O_ReadFormatCapa()	//Command 0x23:Read Format capacity
{
	return ATAPI_O_Base();
}


UCHAR ATAPI_O_ReadCapacity(void)//Command 0x25:Read Capacity
{
	return ATAPI_O_Base();
}


UCHAR ATAPI_O_NonSense(void)//Command 0x06:Non-sense
{
	return ATAPI_O_Base();
}


UCHAR ATAPI_O_Inquiry(void)		// Command 0x12;
{
	UWORD	errno;
	UCHAR i;

	Buffer_Length =122;
	Buffer_Pointer=Allbuffer;
	Id=ID_OTHERS;

	cli();
 	errno = Exec_ATAPI_Command1();
 	
 	if(errno==0)	//Modified by Mike Chan
 		TPBulk_CommandStatus_bCSW_Status = CSW_GOOD;
 	else 
 	{
 		TPBulk_CommandStatus_bCSW_Status = CSW_FAIL;
 	}
 	sti();
 		
	ATAPIWriteInforToHost(Buffer_Pointer, Buffer_Length);

	return errno;	
}

UCHAR ATAPI_O_ModeSense5A(void)	//Command 0x5A:Mode Select 0x5A
{
	return ATAPI_O_Base();
}

UCHAR ATAPI_I_VeryPacket(void)	//Command 0x2f:Verify Packet Command
{
	return ATAPI_I_Base();
}

UCHAR ATAPI_I_ModeSelect55(void)	//Command 0x55:Mode Select 0x55
{
	return ATAPI_I_Base();
}

UCHAR ATAPI_Read10(void)		// Command 0x28;
{
	UWORD	errno;
	UWORD i;
	
	Buffer_Length =TPBulk_CommandBlock_dCBW_DataXferLen;
	Buffer_Pointer=Allbuffer;
	Id=ID_RD;

	cli();
 	errno=Exec_ATAPI_Command1();

	if(errno==0)	//Modified by Mike Chan
 		TPBulk_CommandStatus_bCSW_Status = CSW_GOOD;
 	else 
 	{
 		TPBulk_CommandStatus_bCSW_Status = CSW_FAIL;
 	}	 	
 	sti();
 	
	return ATAPIWriteInforToHost(Buffer_Pointer, Buffer_Length);
}

UCHAR ATAPI_Write10(void)		// Command 0x2A;
{
	UWORD	errno;
	ULONG i = 0;
	
	Buffer_Length =TPBulk_CommandBlock_dCBW_DataXferLen;
	Buffer_Pointer=Allbuffer;
	Id=ID_WR;

	ATAPIWriteInforToZip(Buffer_Pointer, Buffer_Length);

	while(bD12flags.bits.BOT_state != USBFSM4BOT_DATAOVER)
	{
		i ++;
		if (i > 1000000)
		{
			break;
		}
	};
	
	//When the data received over, then execute next instruction.
	cli();
	if(bD12flags.bits.BOT_state == USBFSM4BOT_DATAOVER)
	{
 	 	errno = Exec_ATAPI_Command1();
	 	
 		if(errno==0)	//Modified by Mike Chan
	 		TPBulk_CommandStatus_bCSW_Status = CSW_GOOD;
	 	else
	 	{
	 		TPBulk_CommandStatus_bCSW_Status = CSW_FAIL;
	 	}	
 	}
	else
	{
		TPBulk_CommandStatus_bCSW_Status = CSW_FAIL;
	}
	TPBulk_CSWHandler();
	sti();
	return errno;
}

//*******************************************************************
//**** This function is used as a basic function for all ATAPI   ****
//**** command to transmit or receive the ATAPI information to   ****
//**** Host from PD12
//**** In para:
//**** Out para:
//**** Comment :(1) Not use para spcInquiry->AllocationLen for 
//**** check data length;But use TPBulk_CommandBlock.dCBW_DataXferLen;
//****		   (2) This function transfers the data length the 
//****			Host expected automatically;
//**** Author: Mike Chan(ChenXiaotian) 
//**** Date:   2001/7/14
//*******************************************************************

UCHAR ATAPIWriteInforToHost(UCHAR *DataBuff,ULONG ToHostDataLength)
{
	ULONG dataLen;	

	cli();
 	ControlData.pData=DataBuff;			
 	bEPPflags.bits.in_isr = 1;	
	if(TPBulk_CommandBlock_bCBW_Flag & CBW_FLAG_IN) //==0x80
	{
		//Modified by ChenXiaotian(2001/7/14)
		if(TPBulk_CommandBlock_dCBW_DataXferLen < ToHostDataLength)
		{
			dataLen = TPBulk_CommandBlock_dCBW_DataXferLen;
		}
		else 
			dataLen = ToHostDataLength;

		if(dataLen == 0x00)
		{
			TPBulk_ErrorHandler(CASE7,0);
			bD12flags.bits.BOT_state = USBFSM4BOT_STALL;
			
			bEPPflags.bits.in_isr = 0;
			sti();
 			return FALSE;
		}
		
		else
	    {
	    	TPBulk_CommandStatus_dCSW_DataResidue = 0;
			TPBulk_CommandStatus_dCSW_Signature = CSW_SIGNATURE;
			TPBulk_CommandStatus_dCSW_Tag = TPBulk_CommandBlock_dCBW_Tag;
   	    	bD12flags.bits.BOT_state = USBFSM4BOT_DATAIN;
			ControlData.wLength = dataLen; // Bytes to transfer
			ControlData.wCount = 0;
			if(dataLen>=64)
				D12_WriteEndpoint(5, DataBuff, EP2_PACKET_SIZE);
			else
				D12_WriteEndpoint(5, DataBuff, dataLen);

			if(dataLen>=64)
				ControlData.wCount += EP2_PACKET_SIZE;
			else
				ControlData.wCount += dataLen;
			bEPPflags.bits.in_isr = 0;
			sti();
 			return TRUE;
		}
	}
	else
	{
		printk("Wrong Direction : ATAPIWriteInforToHost\n");
		TPBulk_ErrorHandler(CASECBW,0);
		bD12flags.bits.BOT_state = USBFSM4BOT_STALL;
		bEPPflags.bits.in_isr = 0;
		sti();
 		return FALSE;
	}
}


UCHAR ATAPIWriteInforToZip(UCHAR *DataBuff,ULONG ToZipDataLength)
{
	ULONG dataLen;	
	UCHAR i;
	UCHAR c1;
	cli();
 	ControlData.pData=DataBuff;			
 	bEPPflags.bits.in_isr = 1;	
	if((TPBulk_CommandBlock_bCBW_Flag & CBW_FLAG_IN)==0) //==0x0
	{
		//Modified by ChenXiaotian(2001/7/14)
		if(TPBulk_CommandBlock_dCBW_DataXferLen < ToZipDataLength)
		{
			dataLen = TPBulk_CommandBlock_dCBW_DataXferLen;
		}
		else 
			dataLen = ToZipDataLength;
		
		if(dataLen == 0x00)
		{
			TPBulk_CommandStatus_dCSW_DataResidue = 0;
			TPBulk_CommandStatus_dCSW_Signature = CSW_SIGNATURE;
			TPBulk_CommandStatus_dCSW_Tag = TPBulk_CommandBlock_dCBW_Tag;
			bD12flags.bits.BOT_state = USBFSM4BOT_DATAOVER;
			bEPPflags.bits.in_isr = 0;
			sti();
 			return TRUE;
		}
		else
	    	{
			TPBulk_CommandStatus_dCSW_DataResidue = 0;
			TPBulk_CommandStatus_dCSW_Signature = CSW_SIGNATURE;
			TPBulk_CommandStatus_dCSW_Tag = TPBulk_CommandBlock_dCBW_Tag;
   	    	bD12flags.bits.BOT_state = USBFSM4BOT_DATAOUT;	
			ControlData.wLength = dataLen; // Bytes to transfer
			ControlData.wCount = 0;

			i = D12_ReadEndpointStatus(4);
			c1 = i & 0x60;

			if(i & (D12_BUFFER0FULL | D12_BUFFER1FULL)) 
			{																
				i =	D12_ReadMainEndpoint(ControlData.pData);			
				ControlData.wCount += i;
				if(c1==0x60)
				{
					i =	D12_ReadMainEndpoint(ControlData.pData + ControlData.wCount);
					ControlData.wCount += i;
				}
				if(i != EP2_PACKET_SIZE || ControlData.wCount >= ControlData.wLength)
				{
					bD12flags.bits.BOT_state =USBFSM4BOT_DATAOVER;	//Modified by Mike 2001/8/21
				}				
			}	
			bEPPflags.bits.in_isr = 0;
			sti();
 			return TRUE;
		}
	}
	else
	{
		printk("Wrong Direction : ATAPIWriteInforToZip\n");

		TPBulk_ErrorHandler(CASECBW,0);
		bD12flags.bits.BOT_state = USBFSM4BOT_STALL;
		bEPPflags.bits.in_isr = 0;
		sti();
 		return FALSE;
	}
}