doscsicommand.c

瑞萨单片机开发软代码.非常实用小巧的平台,很多应用都可以在上面实现.

/*
****************************************************************************
					H I T A C H I    P R O P R I E T A R Y

	COPYRIGHT (c)	2001 BY Semiconductor & Integrated Circuits,Hitachi,Ltd.
						---  ALL RIGHTS RESERVED  ---

	File Name	:DoSCSICommand.c
	Working		:Judging and Executing SCSI Command
	Modified	:Rev 2001_11_28 {Author : T.Ishikawa}
	Modified	:Rev 2001_09_28 {Author : T.Ishikawa}
	Created		:Rev 1.0 {Author : T.Ishikawa[2001.Jan.10]}
****************************************************************************
*/

#include	"CatProType.h"
#include	"SetSCSIInfo.h"
#include "sci.h"

#include "flashdisk.h"

extern MSC MBRCache;
extern DATA_BUFF Cache[];
extern unsigned char debug;       
extern volatile unsigned char write_protect;  
extern volatile unsigned char report_wp;

unsigned long				DecBotCmd(void);       
void	SetBotCmdErr(unsigned char, unsigned char);  

enum	BotCmdErrType		{INVALID_0,INVALID_1,NOT_READY};

/***************************************************************************
Function Name	:DecBotCmd(unsigned long,unsigned char)
Working			:Judging and Executing SCSI Command
Return Value	:unsigned long
Modified		:{Author : T.Ishikawa[2001.Nov.28]}
Modified		:{Author : T.Ishikawa[2001.Aug.09]}
Created			:{Author : T.Ishikawa[2001.Jan.10]}
***************************************************************************/
unsigned long	DecBotCmd(void) 
{
	unsigned char	counter;
	char c;
	unsigned long Address;
 	unsigned int i;
 	unsigned int Buf_loc;	
	unsigned long workValue = 0;	/*	SCSI Commands returnable data size in Data Stage	*/

//	SCI_Str("\r\nSCSI");
//	SCI_HexB(cbwDataGVar->cbwType.cmdOpeCode);
	
	switch (cbwDataGVar->cbwType.cmdOpeCode) 
	{
		case 0x00:	/*	TEST UNIT READY		*/
			if (EpInfo[USE_OUT_EP].PresentState != TRANS_OUT) 
			{	//	command direction does not according with Data Transport direction
				cswDataGVar->cswMeaningType.bCSWStatus = 0x02;
				break;
			}

			workValue = 0;
			
			// UNIT is NOT READY
			if ((unit_state[0] & 0x01) == 0x01) {
				SetBotCmdErr(NOT_READY,0);
				workValue = 0;
			    break;
			}    				
			
			reqSensDataGVar[2] = 0x00;	/*	Sense Key	*/
			reqSensDataGVar[12] = 0x00; /*	Additional Sense Code	*/
			reqSensDataGVar[13] = 0x00;	/*	Additional Sense Code Qualifier	*/
			//	make CSW BCSWStatus	
			//cswDataGVar->cswMeaningType.bCSWStatus = 0x00;
			break;

		case 0x03:	/*	REQUEST SENSE COMMAND	*/
			if (EpInfo[USE_OUT_EP].PresentState != TRANS_IN) 
			{	/*	command direction does not according with Data Transport direction	*/
				/*	set up data buffer pointers	*/
				BufPtr[DATA_INFO].sPtr = &returnData->byteVal[0];
				BufPtr[DATA_INFO].ePtr = &returnData->byteVal[63];
				cswDataGVar->cswMeaningType.bCSWStatus = 0x02;
				break;
			}

			for (workValue = 0; workValue <= 17; workValue++) 
			{
				returnData->byteVal[workValue] = reqSensDataGVar[workValue];
			}
            // locate "workValue" from CBW
            workValue = (unsigned long)cbwDataGVar->cbwType.cmd4;
            
			/*	set up data buffer pointers	*/
			BufPtr[DATA_INFO].ePtr = &returnData->byteVal[workValue];
			BufPtr[DATA_INFO].sPtr = &returnData->byteVal[0];

			// clear REQUEST SENSE value
			reqSensDataGVar[2] = 0x00;	//	Sense Key	
			reqSensDataGVar[12] = 0x00;	//	Additional Sense Code	
			reqSensDataGVar[13] = 0x00;	//	Additional Sense Code Qualifier	
			break;

		case 0x12:	/*	INQUIRY	report drive information	*/
			
			SCI_Str("\r\nInq-");
			
			if (EpInfo[USE_OUT_EP].PresentState != TRANS_IN) {
			/*	command direction does not according with Data Transport direction	*/
				/*	set up data buffer pointers	*/
				BufPtr[DATA_INFO].sPtr = &returnData->byteVal[0];
				BufPtr[DATA_INFO].ePtr = &returnData->byteVal[63];
				cswDataGVar->cswMeaningType.bCSWStatus = 0x02;
				break;
			}
			
			if (cbwDataGVar->cbwType.cmd1 != 0x00) 
				error();

			workValue = (unsigned char)cbwDataGVar->cbwType.cmd4;      
			
			/*	Allocation Length has report data byte size	*/
			if ((EpInfo[USE_OUT_EP].PresentState == TRANS_OUT) & (workValue == 0x00000000)) 
				error();

			/*	set up data buffer pointers	*/
			BufPtr[DATA_INFO].sPtr = &ansInquiryData[0];
			BufPtr[DATA_INFO].ePtr = &ansInquiryData[96];
            // HOST expectant data length > Funciton expectant data length
			// function max. send 96 bytes of inquiry data
            if (workValue < 96)
            	BufPtr[DATA_INFO].ePtr = &ansInquiryData[workValue];
            	
			workValue = BufPtr[DATA_INFO].ePtr - BufPtr[DATA_INFO].sPtr;	/*	transfer data size	*/
			// In case workValue > max end-point size
			Cache->ReadCache.Modified = 0;
            
			SCI_Hex(workValue);
            // clear REQUEST_SENSE value
			reqSensDataGVar[2] = 0x00;	//	Sense Key	
			reqSensDataGVar[12] = 0x00;	//	Additional Sense Code	
			reqSensDataGVar[13] = 0x00;	//	Additional Sense Code Qualifier	
			break;

      	case 0x1A:	//	MODE SENSE(6) COMMAND	
			// clear return value
			for(workValue = 0; workValue < 16; workValue++) {
				returnData->longVal[workValue] = 0x00000000;
			}
			
			// check write protected,
			// write protect should be returned in "Mode Parameter Header"
			if (write_protect == 1)
			  returnData->byteVal[2] = 0x80;        
			
			workValue = 3;
			
			if ((cbwDataGVar->cbwType.cmd1 & 0x08) == 0x08){
				// no block descriptor
				returnData->byteVal[workValue]=0x00;
				workValue++;
			}
			else{                     
			    // block descriptor required
				returnData->byteVal[workValue]=0x08;
				workValue++;
				for (counter=0;counter<8;counter++,workValue++){
					returnData->byteVal[workValue] = modeSensBlockDescriptorGVar[counter];
				}
			}
			// check page code 1C (Timer and Protect page) or 3F (all pages)
			c = (cbwDataGVar->cbwType.cmd2 & 0x3F);
			if ((c == 0x1C) || (c == 0x3F)){
				//for (counter=0;counter<12;counter++,workValue++){
				for (counter=0;counter<8;counter++,workValue++){
					returnData->byteVal[workValue] = modeSens_1C_GVar[counter];
				}
			}
			returnData->byteVal[0] = workValue -1;
			
			if (workValue > (cbwDataGVar->cbwType.cmd4))
				workValue = (unsigned long)(cbwDataGVar->cbwType.cmd4);
			
			//SCI_Str("\r\nSCSI-MS-");
			//SCI_HexS(workValue);         
			
			//	set up data buffer pointers	
			BufPtr[DATA_INFO].ePtr = &returnData->byteVal[workValue];
			BufPtr[DATA_INFO].sPtr = &returnData->byteVal[0];        

 			// data length adjust
            //cbwDataGVar->cbwType.dCBWDataTransferLength = workValue;

			// In case workValue > max end-point size
			Cache->ReadCache.Modified = 0;

			//  clear REQUEST SENSE value
			reqSensDataGVar[2] = 0x00;	//	Sense Key	
			reqSensDataGVar[12] = 0x00;	//	Additional Sense Code	
			reqSensDataGVar[13] = 0x00;	//	Additional Sense Code Qualifier	
			break;

		case 0x1B:	/*	STOP START UNIT COMMAND		*/

			
			if (EpInfo[USE_OUT_EP].PresentState != TRANS_OUT) {
			/*	command direction does not according with Data Transport direction	*/
				cswDataGVar->cswMeaningType.bCSWStatus = 0x02;
				break;
			}
			
			workValue = 0;

			if ((cbwDataGVar->cbwType.cmd4 & 0x01) == 0x00)
				unit_state[0] |= 0x01;
			else
				unit_state[0] &= ~0x01;

			//SCI_Str("\r\nSCSI-1B-");
			//SCI_HexB(unit_state[0]);

			/*	clear REQUEST SENSE value	*/
			reqSensDataGVar[2] = 0x00;	/*	Sense Key	*/
			reqSensDataGVar[12] = 0x00;	/*	Additional Sense Code	*/
			reqSensDataGVar[13] = 0x00;	/*	Additional Sense Code Qualifier	*/
			break;

		case 0x1E:	/*	PREVENT/ALLOW MEDIUM REMOVAL COMMAND	*/
			if (EpInfo[USE_OUT_EP].PresentState != TRANS_OUT) 
			{	/*	command direction does not according with Data Transport direction	*/
				cswDataGVar->cswMeaningType.bCSWStatus = 0x02;
				break;
			}                           
			
			// UNIT is NOT READY
			if ((unit_state[0] & 0x01) == 0x01){
				SetBotCmdErr(NOT_READY,0);
				workValue = 0;
				break;
			}	
			workValue = 0;

			//SCI_Str("\r\nSCSI-1E-");
			//SCI_HexB(unit_state[0]);
            
            // clear REQUEST_SENSE value
			reqSensDataGVar[2] = 0x00;	//	Sense Key	
			reqSensDataGVar[12] = 0x00;	//	Additional Sense Code	
			reqSensDataGVar[13] = 0x00;	//	Additional Sense Code Qualifier	
			break;

        // added by HMSA-HK