msd-b2.c

PIC18F4550 SD CARD USB

/** I N C L U D E S **********************************************************/
#include <p18cxxx.h>
#include "system\typedefs.h"
#include "system\usb\usb.h"
#include "fileio.h"
//#include "system\sdcard\sdcard.h"

#include<string.h>
//#ifndef MSD_H
//#include "system\usb\class\msd\msd.h"

#ifdef USB_USE_MSD
#define mLED_Both_On()          {mLED_2_On();mLED_3_On();}
#define CSD_SIZE 16
extern CSD gblCSDReg;
extern SDC_Error RMediaInitialize(SDCSTATE*);
extern SDC_Error sdcardinitialize(void);
extern SDC_Error MediaInitialize();
extern void SocketInitialize(void);
extern byte MediaDetect(void);
extern void DetectSDCard(void); 
extern SDC_Error SECTORread(dword, byte*);
extern SDC_Error CSDread(byte*);

// Global Variable for keeping state of the MSD firmware
byte MSD_State;
byte MSD_Data;
USB_MSD_CBW gblCBW;
byte gblCBWLength;
SDCSTATE gblFlag;


	
const rom InquiryResponse inq_resp = {
	0x00,				// peripheral device is connected, direct access block device
	0x80,               // removable
	0x04,				// version = 00=> does not conform to any standard, 4=> SPC-2
	0x02,				// response is in format specified by SPC-2
	0x20,				// n-4 = 36-4=32= 0x20
	0x00,				// sccs etc.
	0x00,				// bque=1 and cmdque=0, indicates simple queueing 00 is obsolete, 
						// but as in case of other device, we are just using 00
	0x00,				// 00 obsolete, 0x80 for basic task queueing
	"Microchp",
	"Ma$$ Storage    ",
	"0001"
};

/**************************************************
Initialize the SD Card
***************************************************/
	
void MSInit(void) 
{
	SDC_Error status;

	SocketInitialize();
    mInitAllLEDs();
    status=RMediaInitialize(&gblFlag);
    if (status) { mLED_1_On(); mLED_2_On(); mLED_3_On(); mLED_4_On();}		// If there was some error, turn on all leds 
	MSD_State=MSD_WAIT;
 }    
 
 
/******************************************************************************
 * Function:        void USBCheckMSDRequest(void)
 *
 * PreCondition:    None
 *
 * Input:           None
 *
 * Output:          None
 *
 * Side Effects:    None
 *
 * Overview:        This routine handles the standard RESET and GET_MAX_LUN command requests on control endpoint
 *
 * Note:            None
 *****************************************************************************/	
void USBCheckMSDRequest(void)
{
	
	//if(SetupPkt.Recipient != RCPT_INTF) return;
    if(SetupPkt.bIntfID != MSD_INTF_ID) return;
    if(SetupPkt.RequestType != CLASS) return;
    switch(SetupPkt.bRequest)
    {
	    case MSD_RESET:
	    	ctrl_trf_session_owner = MUID_MSD;
	    	mDisableEP1to15();                          // See usbdrv.h
	    	MSDInitEP();
	    	break;
	    case GET_MAX_LUN:
	    	ctrl_trf_session_owner = MUID_MSD;
	    	CtrlTrfData._byte[0] = MAX_LUN;
	    	wCount._word = 1;
	    	pSrc.bRam = (unsigned char*)&CtrlTrfData;
	    	usb_stat.ctrl_trf_mem = _RAM;
	    	break;
    }	//end switch(SetupPkt.bRequest)
}

void ProcessIO(void)
{
	byte i;
	if(!MSD_BD_OUT.Stat.UOWN)
	{
		
		if (MSD_State==MSD_DATA_IN) {
			; 
			//mLED_1_On();mLED_2_On();mLED_3_On();mLED_4_On();
		}
		if (MSD_State==MSD_DATA_OUT) {
			;
			//mLED_1_On();mLED_2_On();mLED_3_On();mLED_4_On();
		}
		if (MSD_State==MSD_WAIT) {
			gblCBW.dCBWSignature=msd_cbw.dCBWSignature;				// copy the received cbw into the gblCBW
			gblCBW.dCBWTag=msd_cbw.dCBWTag;
			gblCBW.dCBWDataTransferLength=msd_cbw.dCBWDataTransferLength;
    		gblCBW.bCBWFlags=msd_cbw.bCBWFlags;
    		gblCBW.bCBWLUN=msd_cbw.bCBWLUN;
	    	gblCBW.bCBWCBLength=msd_cbw.bCBWCBLength;				// Here most significant 3bits are zero
    		for (i=0;i<msd_cbw.bCBWCBLength;i++)
    			gblCBW.CB.CBWCB[i]=msd_cbw.CB.CBWCB[i];
	    	gblCBWLength=MSD_BD_OUT.Cnt;							// Length of command block wrapper	
			MSDCommandHandler();										// decode and process the CBW
			mUSBBufferReady(MSD_BD_OUT);							// call after every read or write on nonEP0 EP,
																	// toggles DTS and gives ownership to SIE
			USBDriverService();										// clears the TRNIF
		} 
	}
}

	
void MSDCommandHandler(void)		// In reality it is to read from EP1
{	
	if (isValidCBW()) {
		if (isMeaningfulCBW()) {
			prepareCSWData();
			if (gblCBW.bCBWFlags==0x80)
				MSD_State=MSD_DATA_IN;
			else if (gblCBW.bCBWFlags==0x00)
				MSD_State=MSD_DATA_OUT;
			switch(msd_cbw.CB.Opcode) {
        		case INQUIRY:
        			MSDInquiryHandler();
            	break;
        		case READ_FORMAT_CAPACITY:
        		    MSDReadFormatCapacityHandler();
        		break;        	
        		case READ_CAPACITY:
		            MSDReadCapacityHandler();            
        	    break;
		        case READ_10:
        			MSDReadHandler();
	            break;
    		    case WRITE_10:
    		    	MSDWriteHandler();
		            break;
        		case REQUEST_SENSE:
		        	MSDRequestSenseHandler();
        	    break;
	        	case MODE_SENSE:
	        		MSDModeSenseHandler();
    	 	       break;
		        case PREVENT_ALLOW_MEDIUM_REMOVAL:
		        	MSDMediumRemovalHandler();
        			break;
		        case TEST_UNIT_READY:
		        	MSDTestUnitReadyHandler();
        			break;
		        case VERIFY:
		        	MSDVerifyHandler();
        			break;
		        case STOP_START:
		        	MSDStopStartHandler();
        			break;
        			/*
		        default:
        			while(mMSDTxIsBusy());
					MSD_BD_IN.ADR=(byte*)&msd_buffer;
					MSD_BD_IN.Cnt=0x0;
					mUSBBufferReady(MSD_BD_IN);
					USBDriverService();
		        	MSDErrorCSW();
        			break;
        			*/
			} // end switch
		} // end isMeaningfulCBW
	} // end isValidCBW
	MSD_State=MSD_WAIT;
}

byte isValidCBW() 
{
	if ((gblCBWLength!=0x1f)||(gblCBW.dCBWSignature!=0x43425355)) return FALSE;
	else return TRUE;
}

byte isMeaningfulCBW()
{
	// 3msb bits of CBWCBLength are reserved and must be 0, 4msb bits of CBWLUN	are reserved and must be 0		
	// valid CBWCBLength is between 1 and 16B
	// flags only msb indicates data direction rest must be 0
	if ((gblCBW.bCBWLUN<=0x0f)&&(gblCBW.bCBWCBLength<=0x10)&&(gblCBW.bCBWCBLength>=0x01)&&(gblCBW.bCBWFlags==0x00|gblCBW.bCBWFlags==0x80)) 
		return TRUE;
	else return FALSE;	
	
}
		
void prepareCSWData()
{
	msd_csw.dCSWTag=gblCBW.dCBWTag;
	msd_csw.dCSWSignature=0x53425355;
}


void MSDRequestSenseHandler(void)
{
	byte i;
	for(i=0;i<18;i++)
		msd_buffer[i]=0;
	msd_buffer[0]=0xf0;
	msd_buffer[2]=0x05;
	msd_buffer[7]=0x0a;
	msd_buffer[12]=0x20;
	while(mMSDTxIsBusy());
	MSD_BD_IN.ADR=(byte*)&msd_buffer;
	MSD_BD_IN.Cnt=0x12;
	mUSBBufferReady(MSD_BD_IN);
	USBDriverService();
	MSDSuccessCSW(0x00);
}
void MSDWriteHandler()
{
	return;
}
void MSDModeSenseHandler()
{
	return;
}

void MSDMediumRemovalHandler()
{
	return;
}       
void MSDTestUnitReadyHandler()
{
	return;
}

void MSDVerifyHandler()
{
	return;
}
void MSDStopStartHandler()
{
	return;
}
		        	
void MSDReadFormatCapacityHandler(void)
{
	
    //mLED_4_On();
    /*
    msd_csw.dCSWTag=msd_cbw.dCBWTag;
	msd_csw.dCSWSignature=0x53425355;
	msd_csw.dCSWDataResidue=msd_cbw.dCBWDataTransferLength;
	msd_csw.bCSWStatus=0x1;
	while(mMSDTxIsBusy());
	MSD_BD_IN.ADR=(byte*)&msd_csw;
	MSD_BD_IN.Cnt=0x0;
	mUSBBufferReady(MSD_BD_IN);
	USBDriverService();
	while(mMSDTxIsBusy());