tpbulk.c

来自「51环境下的FAT及FAT32文件系统源码」· C语言 代码 · 共 410 行

C
410 行
字号 
#include "common.h"
#include "usb.h"
#include "tpbulk.h"

SYS_INFO_BLOCK  DeviceInfo;
//unsigned int FatSectorPointer;
//FILE_INFO xdata ThisFile;
TPB_STRUC data TPBulk_Block;

extern XXGFLAGS bdata bXXGFlags;	//union XXGFLAGS is defined in common.h
extern UINT8 xdata DBUF[SECT_LEN];
extern XXGPKG usbstack;
extern UINT16 xdata FAT[SECT_LEN/2];

///////////////////////////////////////////////////////////////////////////
unsigned char EnumMassDev(void)
{
	UINT32 FATSz;
	UINT32 TotSec;
	UINT32 RootDirSectors;
	UINT32 DataSec;
	UINT32 CountofClusters;

	pMBR_BLOCK pMBR;
	pBPB_BLOCK pBPB;
	pBPB_BLOCK32 pBPB32;

	////////////////////////////////////////////////////
	if(!SPC_Inquiry())
		return FALSE;
	DelayUs(2);
	if(!SPC_RequestSense())
		return FALSE;
	DelayUs(2);
	if(!SPC_TestUnit())
		return FALSE;
	DelayUs(2);
	if(!RBC_ReadCapacity())
		return FALSE;
	 
	////////////////////////////////////////////////////
	pMBR=(pMBR_BLOCK)DBUF;

	DeviceInfo.BPB_BytesPerSec=512; //暂假设为512
	if(!SPC_RequestSense())
		return FALSE;
//	DelayUs(5);
//	if(!SPC_TestUnit())
//		return FALSE;

	DelayUs(5);
	if(!RBC_ReadCapacity())
		return FALSE;

	DelayUs(5);
    // Read sector 0 (MBR)
	if(!RBC_ReadOneSec(0x0,DBUF))
		return FALSE;
	//////////////////////////////////
	if(DBUF[0]==0xeb||DBUF[0]==0xe9)
		{
		DeviceInfo.StartSector=0;
		//DeviceInfo.TotalSector=SwapINT32(pMBR->TotalSector);
		}
	else
		{
	//////////////////////////////////
		DeviceInfo.StartSector=SwapINT32(pMBR->StartSector);
		//DeviceInfo.TotalSector=SwapINT32(pMBR->TotalSector);
		}
	///////////////////////////////////////////////////////
	pBPB=(pBPB_BLOCK)DBUF;
	pBPB32 = (pBPB_BLOCK32)DBUF;
	DelayUs(5);

	if(!RBC_ReadOneSec(DeviceInfo.StartSector, DBUF))
		return FALSE;
	DeviceInfo.BPB_BytesPerSec=WordSwap(pBPB->BPB_BytesPerSec);
	DeviceInfo.BPB_SecPerClus=pBPB->BPB_SecPerClus;
	DeviceInfo.BPB_NumFATs=pBPB->BPB_NumFATs;
	DeviceInfo.BPB_RootEntCnt=WordSwap(pBPB->BPB_RootEntCnt);
	DeviceInfo.BPB_TotSec16=WordSwap(pBPB->BPB_TotSec16);
	DeviceInfo.BPB_FATSz16=WordSwap(pBPB->BPB_FATSz16);
	DeviceInfo.BPB_FATSz32=WordSwap(pBPB32->BPB_FATSz32);
	DeviceInfo.BPB_TotSec32=SwapINT32(pBPB->BPB_TotSec32);
	DeviceInfo.FatStartSector=DeviceInfo.StartSector+WordSwap(pBPB->BPB_RsvdSecCnt);
	DeviceInfo.RootStartSector=DeviceInfo.FatStartSector+2*DeviceInfo.BPB_FATSz16;
	DeviceInfo.FirstDataSector=DeviceInfo.RootStartSector+0x20;
	///////////////////////////////////////////////////////
//	ThisFile.bFileOpen=0;

	//Judge the FAT type
	if(DeviceInfo.BPB_FATSz16 != 0)
	    FATSz = DeviceInfo.BPB_FATSz16;
	else
	    FATSz = DeviceInfo.BPB_FATSz32;  
	
	if(DeviceInfo.BPB_TotSec16 != 0)
	    TotSec = DeviceInfo.BPB_TotSec16;
	else
	    TotSec = DeviceInfo.BPB_TotSec32;
	
	RootDirSectors = ((DeviceInfo.BPB_RootEntCnt * 32) + (DeviceInfo.BPB_BytesPerSec - 1)) / DeviceInfo.BPB_BytesPerSec;
	DataSec = TotSec - (WordSwap(pBPB->BPB_RsvdSecCnt) + (DeviceInfo.BPB_NumFATs * FATSz) + RootDirSectors);
	CountofClusters = DataSec / DeviceInfo.BPB_SecPerClus;

	if(CountofClusters < 4085) 
	{
		DeviceInfo.bFatType = 1; //fat12
	} 
	else if(CountofClusters < 65525) 
	{
	    DeviceInfo.bFatType = 2; //fat16
#ifdef FAT32OR16_LIGHT
		light ( 2, 0, 100, 10 );
		light ( 5, 0, 100, 10 );
		light ( 2, 0, 100, 10 );
#endif
	} 
	else 
	{
	    DeviceInfo.bFatType = 3; //fat32
		DeviceInfo.TotCluster =
		(DeviceInfo.BPB_TotSec32-DeviceInfo.FirstDataSector+1)/DeviceInfo.BPB_SecPerClus+1;
#ifdef FAT32OR16_LIGHT
		light ( 5, 0, 200, 10 );
		light ( 2, 0, 200, 10 );
		light ( 5, 0, 200, 10 );
#endif
	}
	//End Judge the FAT type

	///////////////////////////////////////////////////////
	return TRUE;
}

/*unsigned char TPBulk_GetMaxLUN(void)
{
	
	usbstack.setup.bmRequest=0xa1;
	usbstack.setup.bRequest=0xfe;
	usbstack.setup.wValue=0;
	usbstack.setup.wIndex=0;
	usbstack.setup.wLength=1;
	usbstack.buffer=DBUF;
	return ep0Xfer();

}	 
*/

unsigned char SPC_Inquiry(void)
{
#define cdbInquirySPC RBC_CDB.SpcCdb_Inquiry

	//unsigned char len;
	//unsigned char retStatus=FALSE;
	TPBulk_CBW.dCBW_Signature=CBW_SIGNATURE;
	TPBulk_CBW.dCBW_Tag=0x60a624de;
    //TPBulk_CBW.dCBW_Tag=0x12000000;
	TPBulk_CBW.dCBW_DataXferLen=0x24000000;
	TPBulk_CBW.bCBW_Flag=0x80;
	TPBulk_CBW.bCBW_LUN=0;
	TPBulk_CBW.bCBW_CDBLen=sizeof(INQUIRY_SPC);
	
	/////////////////////////////////
	cdbInquirySPC.OperationCode=SPC_CMD_INQUIRY;
	cdbInquirySPC.EnableVPD=0; 
	cdbInquirySPC.CmdSupportData=0;
	cdbInquirySPC.PageCode=0;
	cdbInquirySPC.AllocationLen=0x24;
	cdbInquirySPC.Control=0;
	////////////////////////////////
	//if(!epBulkRcv(DBUF,5))
	//	return FALSE;
//	if(!epBulkSend((unsigned char *)&TPBulk_CBW,sizeof(TPBulk_CBW)))
	if(!epBulkSend((unsigned char *)&TPBulk_CBW,31))
		return FALSE;
	DelayMs(150);
	//len=36;
	if(!epBulkRcv(DBUF,36))	 // FIXME: 38 including crc??, but here we get rid of crc via reset
		return FALSE;

	if(!epBulkRcv((unsigned char *)&TPBulk_CSW,13))  //Roy Tseng: failed here. USB2.0
		return FALSE;
	////////////////////////////////
	return TRUE;	
#undef cdbInquirySPC
}

/*unsigned char SPC_READLONG(void)
{
#define cdbReadLong RBC_CDB.SpcCdb_ReadLong	
	//nsigned char retStatus=FALSE;
	TPBulk_CBW.dCBW_Signature=CBW_SIGNATURE;
	TPBulk_CBW.dCBW_Tag=0x60a624de;
	TPBulk_CBW.dCBW_DataXferLen=0xfc000000;
	TPBulk_CBW.bCBW_Flag=0x80;
	TPBulk_CBW.bCBW_LUN=0;
	TPBulk_CBW.bCBW_CDBLen=sizeof(READ_LONG_CMD);
	
	/////////////////////////////////////
	cdbReadLong.OperationCode=SPC_CMD_READLONG;
	cdbReadLong.LogicalUnitNum=0;
	cdbReadLong.AllocationLen=0xfc;
	//////////////////////////////////////
	if(!epBulkSend((unsigned char *)&TPBulk_CBW,sizeof(TPBulk_CBW)))
		return FALSE;
	DelayMs(5);
	//len=36;
	if(!epBulkRcv(DBUF,0xfc))
		return FALSE;
	
	if(!epBulkRcv((unsigned char *)&TPBulk_CSW,13))
		return FALSE;
  ////////////////////////////
  return TRUE;
#undef cdbReadLong
}	 */
unsigned char SPC_RequestSense(void)
{
#define cdbRequestSenseSPC RBC_CDB.SpcCdb_RequestSense	
	//unsigned char retStatus=FALSE;
	TPBulk_CBW.dCBW_Signature=CBW_SIGNATURE;
	TPBulk_CBW.dCBW_Tag=0x60a624de;
	//TPBulk_CBW.dCBW_Tag=0x03000000;
	TPBulk_CBW.dCBW_DataXferLen=0x0e000000;
	TPBulk_CBW.bCBW_Flag=0x80;
	TPBulk_CBW.bCBW_LUN=0;
	TPBulk_CBW.bCBW_CDBLen=sizeof(REQUEST_SENSE_SPC);
		
	/////////////////////////////////////
	cdbRequestSenseSPC.OperationCode=SPC_CMD_REQUESTSENSE;
	cdbRequestSenseSPC.AllocationLen=0x00;
	
	//////////////////////////////////////
//	if(!epBulkSend((unsigned char *)&TPBulk_CBW,sizeof(TPBulk_CBW)))
	if(!epBulkSend((unsigned char *)&TPBulk_CBW,31))
		return FALSE;
	DelayMs(5);
	//len=36;
	if(!epBulkRcv(DBUF,14))
		return FALSE;
	
	if(!epBulkRcv((unsigned char *)&TPBulk_CSW,13))
		return FALSE;
/////////////////////////////
	return TRUE;
	
#undef cdbRequestSenseSPC
}

unsigned char SPC_TestUnit(void)
{
#define cdbTestUnit RBC_CDB.SpcCdb_TestUnit	
	//unsigned char retStatus=FALSE;
	TPBulk_CBW.dCBW_Signature=CBW_SIGNATURE;
	TPBulk_CBW.dCBW_Tag=0x60a624de;
	//TPBulk_CBW.dCBW_Tag=0x00000000;
	TPBulk_CBW.dCBW_DataXferLen=0x00000000;
	//TPBulk_CBW.bCBW_Flag=0x00;
	TPBulk_CBW.bCBW_Flag=0x80;
	TPBulk_CBW.bCBW_LUN=0;
	TPBulk_CBW.bCBW_CDBLen=sizeof(TEST_UNIT_SPC);
	/////////////////////////////////////
	cdbTestUnit.OperationCode=SPC_CMD_TESTUNITREADY;
	cdbTestUnit.Reserved[3]=0x0;    // reset this field to 0

	//////////////////////////////////////
//	if(!epBulkSend((unsigned char *)&TPBulk_CBW,sizeof(TPBulk_CBW)))
	if(!epBulkSend((unsigned char *)&TPBulk_CBW,31))
		return FALSE;
	DelayMs(5);
	if(!epBulkRcv((unsigned char *)&TPBulk_CSW,13))
		return FALSE;
#undef cdbTestUnit
////////////////////////////
	return TRUE;
}

/*
unsigned char SPC_LockMedia(void)
{
#define cdbLockSPC RBC_CDB.SpcCdb_Remove	
	//unsigned char retStatus=FALSE;
	TPBulk_CBW.dCBW_Signature=CBW_SIGNATURE;
	TPBulk_CBW.dCBW_Tag=0x60a624de;
	TPBulk_CBW.dCBW_DataXferLen=0x00000000;
	TPBulk_CBW.bCBW_Flag=0x00;
	TPBulk_CBW.bCBW_LUN=0;
	TPBulk_CBW.bCBW_CDBLen=sizeof(MEDIA_REMOVAL_SPC);
	///////////////////////////////////////////
	cdbLockSPC.OperationCode=SPC_CMD_PRVENTALLOWMEDIUMREMOVAL;
	cdbLockSPC.Prevent=1;
	///////////////////////////////////////////
//	if(!epBulkSend((unsigned char *)&TPBulk_CBW,sizeof(TPBulk_CBW)))
	if(!epBulkSend((unsigned char *)&TPBulk_CBW,31))
		return FALSE;
	DelayMs(5);
	
	if(!epBulkRcv((unsigned char *)&TPBulk_CSW,13))
		return FALSE;
#undef cdbLockSPC
/////////////////////////////
	return TRUE;
}
*/
unsigned char RBC_ReadCapacity(void)
{
#define cdbReadCap RBC_CDB.RbcCdb_ReadCapacity	
	//unsigned char retStatus=FALSE;
	TPBulk_CBW.dCBW_Signature=CBW_SIGNATURE;
	TPBulk_CBW.dCBW_Tag=0x60a624de;
	//TPBulk_CBW.dCBW_Tag=0x25000000;
	TPBulk_CBW.bCBW_LUN=0;
	TPBulk_CBW.dCBW_DataXferLen=0x08000000;
	TPBulk_CBW.bCBW_Flag=0x80;
	
	TPBulk_CBW.bCBW_CDBLen=sizeof(READ_CAPACITY_RBC);
	/////////////////////////////////////
	cdbReadCap.OperationCode=RBC_CMD_READCAPACITY;
	
	/////////////////////////////////////
//	if(!epBulkSend((unsigned char *)&TPBulk_CBW,sizeof(TPBulk_CBW)))
	if(!epBulkSend((unsigned char *)&TPBulk_CBW,31))
		return FALSE;
	DelayMs(10);
	//len=36;
	if(!epBulkRcv(DBUF,8))
		return FALSE;
	if(!epBulkRcv((unsigned char *)&TPBulk_CSW,13))
		return FALSE;
#undef cdbReadCap
/////////////////////////////
	return TRUE;
}
unsigned char RBC_ReadOneSec(unsigned long lba, unsigned char *pBuffer)
{
#define cdbRead RBC_CDB.RbcCdb_Read	
	
	//unsigned char retStatus=FALSE;
	TPBulk_CBW.dCBW_Signature=CBW_SIGNATURE;
	TPBulk_CBW.dCBW_Tag=0x60a624de;
	//TPBulk_CBW.dCBW_Tag=0x28000000;
	TPBulk_CBW.dCBW_DataXferLen=SwapINT32(512);
	TPBulk_CBW.bCBW_Flag=0x80;
	TPBulk_CBW.bCBW_LUN=0;
	TPBulk_CBW.bCBW_CDBLen=sizeof(READ_RBC);
	/////////////////////////////////////
	cdbRead.OperationCode=RBC_CMD_READ10;
	cdbRead.VendorSpecific=0;
	cdbRead.LBA.LBA_W32=lba; 
	cdbRead.XferLength=0x1;
	//cdbRead.Reserved1[0]=0;
	//cdbRead.Reserved1[1]=0; 
	//cdbRead.Reserved1[2]=0x40;
	//////////////////////////////////////
//	if(!epBulkSend((unsigned char *)&TPBulk_CBW,sizeof(TPBulk_CBW)))
	if(!epBulkSend((unsigned char *)&TPBulk_CBW,31))
		return FALSE;
 
	if(!epBulkRcv(pBuffer,512))
		return FALSE;

	bXXGFlags.bIN_ISR = 0x0;
	if(!epBulkRcv((unsigned char *)&TPBulk_CSW,13))
		return FALSE;
#undef cdbRead
/////////////////////////////
	return TRUE;
}

/*unsigned char RBC_Write(unsigned long lba,unsigned char len,unsigned char *pBuffer)
{
#define cdbWrite RBC_CDB.RbcCdb_Write	
	//len=2;
	//unsigned int data temp;
	//unsigned char i;
	//len=1;
	//SPC_TestUnit();
	//unsigned char retStatus=FALSE;
	TPBulk_CBW.dCBW_Signature=CBW_SIGNATURE;
	TPBulk_CBW.dCBW_Tag=0xb4D977c1;
	TPBulk_CBW.dCBW_DataXferLen=SwapINT32(len*DeviceInfo.BPB_BytesPerSec);
	TPBulk_CBW.bCBW_Flag=0x0;
	TPBulk_CBW.bCBW_LUN=0;
	TPBulk_CBW.bCBW_CDBLen=sizeof(WRITE_RBC);
	/////////////////////////////////////
	cdbWrite.OperationCode=RBC_CMD_WRITE10;
	cdbWrite.VendorSpecific=0;
	cdbWrite.LBA.LBA_W32=lba;
	cdbWrite.XferLength=len;
	cdbWrite.Reserved2=0;
	cdbWrite.Control=0;
	//////////////////////////////////////
	if(!epBulkSend((unsigned char *)&TPBulk_CBW,sizeof(TPBulk_CBW)))
		return FALSE;
	DelayMs(15);
	
	if(!epBulkSend(pBuffer,DeviceInfo.BPB_BytesPerSec))
		return FALSE;
	//DelayMs(10);
	if(!epBulkRcv((unsigned char *)&TPBulk_CSW,13))
		return FALSE;
	
#undef cdbWrite

/////////////////////////////
	return TRUE;
}  */

tpbulk.c - 源码说明

本页面展示了「51环境下的FAT及FAT32文件系统源码」中的 tpbulk.c 源码文件，采用 C语言 编程语言编写，共 410 行代码。您可以在线阅读完整代码内容，也可以返回资源详情页下载完整源码包进行本地学习和开发。

虫虫下载站收录了大量与FAT相关的技术资源，包括源代码、技术文档、电路图等，是电子工程师和嵌入式开发者的专业学习平台。

⌨️ 快捷键说明

复制代码Ctrl + C
搜索代码Ctrl + F
全屏模式F11
增大字号Ctrl + =
减小字号Ctrl + -
显示快捷键?