hardwareadaptationlayer.c

NAND FLASH FAT文件系统建立范例

#include "OSModule_MemoryManagement.h"

#include "HardwareAdaptationLayer.h"
#include "LLD.h"



//Struct LLDHandler, the entry point to HAL advanced function
//*********************************************************
typedef struct lldHandler
{
	NFTL_Return (*ReadPage)(UINT16, UINT8, UINT8 *);
	NFTL_Return (*WritePage)(UINT16, UINT8, UINT8 *);
	NFTL_Return (*CopyPage)(UINT16, UINT8, UINT16, UINT8);
	NFTL_Return (*GetPageStatus)(UINT16, UINT8, UINT8 *);
	NFTL_Return (*SetPageStatus)(UINT16, UINT8, UINT8 *);
	NFTL_Return (*BlockErase)(UINT16);
}LLDHandler;
//*********************************************************




//struct used when write buffering is enabled
//******************************************************
typedef struct WriteDBuffer
{
	UINT8 **Buffer;
	INT16 LastBlock;
	INT8 NoOfChunks;
	INT8 *ChunkStatus;
	INT8 NoOfSequentialWrite;
	INT8 *PageNumber;
	INT8 NoOfPages;
	UINT8 ChunkWithError;
}WriteDataBuffer;
//*****************************************************




//struct used when read buffering is enabled
//******************************************************
typedef struct ReadDBuffer
{
	UINT8 *Buffer;//[LLD_PAGE_FAMILY];
	INT16 LastBlockRead;
	INT8 LastPageRead;
	UINT8 PendingRead;
}ReadDataBuffer;
//*****************************************************


static DeviceArchitecture *currentDevice = NULL;
//************************************************************
//					CalculateAddress						 *
//************************************************************
// retrieve the address of a page from block and page number *
//-----------------------------------------------------------*
// PARAMETERS:												 *
//   blockNumber : number of block							 *
//   pageNumber : number of page							 *
//   returnAddress : the addres searched					 *
// RETURN VALUES:											 *
//   SUCCESS : ADDRESS CALCULATED							 *
//************************************************************
//#define mCalculateAddress(BlockNumber,PageNumber) (((UINT32)(BlockNumber)<<14)+(((UINT32)(PageNumber))<<9))

 void CalculateAddress(UINT16 blockNumber, UINT8 pageNumber, UINT32 *returnAddress)
{

	//UINT32 blockStart;

	//blockStart = blockNumber*BLOCK_SIZE;
	//*returnAddress = blockStart + (512 * pageNumber);
	*returnAddress=(((UINT32)(blockNumber)<<14)+(((UINT32)(pageNumber))<<9));
}



//************** FUNCTION DEFINITION *********************************
NFTL_Return CopyWithCopyBack(UINT16 sourceBlock, UINT8 sourcePage,
	UINT16 destinationBlock, UINT8 destinationPage);
NFTL_Return CopyWithoutCopyBack(UINT16 sourceBlock, UINT8 sourcePage,
	UINT16 destinationBlock, UINT8 destinationPage);
NFTL_Return Read(UINT16 blockNumber, UINT8 pageNumber, UINT8 *buffer);

NFTL_Return CalculateChunkPosition(UINT16 blockNumber, UINT8 pageNumber,
	UINT8 *pageOffset, UINT8 *chunkPosition);
NFTL_Return EraseBlock(UINT16 BlockNumber);
NFTL_Return ReadSpare528(UINT16 BlockNumber, UINT8 PageNumber, UINT8 *buffer);
NFTL_Return WriteSpare528(UINT16 BlockNumber, UINT8 PageNumber, UINT8 *buffer);
NFTL_Return Write528(UINT16 BlockNumber, UINT8 PageNumber, UINT8 *buffer);

NFTL_Return FlushBuffer(void);
NFTL_Return Write528Cached(UINT16 BlockNumber, UINT8 PageNumber, UINT8 *buffer);


//********************************************************************


static LLDHandler Handler =
{
	NULL, NULL, NULL, NULL, NULL, NULL
};
static WriteDataBuffer *WDBuffer=NULL;
//static ReadDataBuffer *RDBuffer;





//**********************************************************************
//							Handled Function 
//*********************************************************************
// The following functions are available to upper layer




//**********************************************************************
//								ReadPage							   *
//**********************************************************************
// Read the page (or chunk) from required position					   *
//----------------------------------------------------------------------
// PARAMETERS 														   *
// BlockNumber : the number of block where read						   *
// PageNumber : the page (or chunk ) to read						   *
// buffer : 528 bytes (data+spare) read								   *
//**********************************************************************

NFTL_Return ReadPage(UINT16 BlockNumber, UINT8 PageNumber, UINT8 *buffer)
{
	return Handler.ReadPage(BlockNumber,PageNumber,buffer);
}




//**********************************************************************
//			  					WritePage							   *
//**********************************************************************
// Write the page (or chunk) in required position   				   *
//																	   *
// PARAMETERS   													   *
// BlockNumber : the number of block where write  					   *
// PageNumber : the page (or chunk ) to write  						   *
// buffer : 528 bytes (data+spare) to write  						   *
//**********************************************************************
NFTL_Return WritePage(UINT16 BlockNumber, UINT8 PageNumber, UINT8 *buffer)
{
	return Handler.WritePage(BlockNumber,PageNumber,buffer);
}



//*****************************************************************************
//								CopyPage									  *
//*****************************************************************************
// Copy a page (or chunk) in another position   							  *
//----------------------------------------------------------------------------*
// PARAMETERS																  *
// SourceBlockNumber : the number of block containing source page 			  *
// SourcePageNumber : the page (or chunk ) to copy 							  *
// DestinationBlockNumber : the number of destination block   				  *
// DestinationPageNumber : the offset of page (or chunk) in destination block *
//*****************************************************************************
NFTL_Return CopyPage(UINT16 SourceBlockNumber, UINT8 SourcePageNumber,
	UINT32 DestinationBlockNumber, UINT8 DestinationPageNumber)
{
	return Handler.CopyPage(SourceBlockNumber,SourcePageNumber,DestinationBlockNumber,
					DestinationPageNumber);
}


//**********************************************************************
//								GetPageStatus   					   *
//**********************************************************************
// Retrieve the spare area of a page (or chunk) 						*
//---------------------------------------------------------------------*
// PARAMETERS  														   *
// BlockNumber : the number of block where read  					   *
// PageNumber : the offset of page whose read the spare 			   *
// buffer : contain the spare read  								   *
//**********************************************************************
NFTL_Return GetPageStatus(UINT16 BlockNumber, UINT8 PageNumber, UINT8 *buffer)
{
	return Handler.GetPageStatus(BlockNumber,PageNumber,buffer);
}



//**********************************************************************
//								SetPageStatus   					   *
//**********************************************************************
// Write the spare area of a page (or chunk)						   *
//---------------------------------------------------------------------*
// PARAMETERS  														   *
// BlockNumber : the number of block where write  					   *
// PageNumber : the offset of page whose write the spare 			   *
// buffer : contain the spare to write  							   *
//**********************************************************************
NFTL_Return SetPageStatus(UINT16 BlockNumber, UINT8 PageNumber, UINT8 *buffer)
{
	return Handler.SetPageStatus(BlockNumber,PageNumber,buffer);
}



//**********************************************************************
//								SetPageStatus   					   *
//**********************************************************************
// Erase a block on flash   										   *
//---------------------------------------------------------------------*
// PARAMETERS  														   *
// BlockNumber : the number of block to erase    					   *
//**********************************************************************

NFTL_Return BlockErase(UINT16 BlockNumber)
{
	return Handler.BlockErase(BlockNumber);
}


//************************************END************************************

//******************************************************************
//			ResetWriteBuffer
//****************************************************************
//Resete the buffer,remove page numnres and chunk status
//*****************************************************************
void ResetWriteBuffer()
{
	UINT8 i;



	for (i = 0; i < WDBuffer->NoOfPages; i++)
		WDBuffer->PageNumber[i] = -1;

	for (i = 0; i < WDBuffer->NoOfChunks; i++)
	{
		OS_MemSet(WDBuffer->Buffer[i], 0xFF, sizeof(UINT8) * CHUNK_SIZE);
		WDBuffer->ChunkStatus[i] = 0;
	}	

	WDBuffer->NoOfSequentialWrite = 0;
	//WDBuffer->LastBlock=-1;
}





//set the handler with the right functions
//*******************************************************************************
//							HALInitialization									*
//*******************************************************************************
//Initialize each HAL structure, setting function pointers  in LLDHandler		*
//------------------------------------------------------------------------------*
//	RETURN VALUES																*
//	  SUCCESS: Initialization completed											*
//    FAILURE: an error is occured
//*******************************************************************************

NFTL_Return HALInitialization(void)
{
	NFTL_Return RetValue ;

	RetValue = NAND_Init() ;
	if (RetValue != SUCCESS)
	{
		return FAILURE ;
	}

	RecognizeDevice();
	//test buffer enabled	
	//test cache program directive
#if 0
	if(UD_BUFFER_ENABLED)
	{
		INT32 i=0;
		
		// check that buffer size is multiple of 528
		if((UD_BUFFER_SIZE%CHUNK_SIZE)!=0)
			return FAILURE;
		
		//additional check for 2k page
		
		WDBuffer=(WriteDataBuffer*)OS_DRIVER_Malloc(sizeof(WriteDataBuffer));
		if(WDBuffer==NULL)
			return FAILURE;
		
		WDBuffer->Buffer=OS_DRIVER_Malloc((sizeof(UINT8*)*UD_BUFFER_SIZE/CHUNK_SIZE));
		//error on OS_DRIVER_Malloc
		if(WDBuffer->Buffer==NULL)
		{
			return FAILURE;
		}
		
		for(i=0;i<UD_BUFFER_SIZE/CHUNK_SIZE;i++)
		{
			WDBuffer->Buffer[i]=OS_DRIVER_Malloc(sizeof(UINT8)*CHUNK_SIZE);
			if(WDBuffer->Buffer[i]==NULL)
			{
				return FAILURE;
			}
			
		}
		
		WDBuffer->NoOfChunks=UD_BUFFER_SIZE/CHUNK_SIZE;
		WDBuffer->ChunkStatus=OS_DRIVER_Malloc(WDBuffer->NoOfChunks);
		if(WDBuffer->ChunkStatus==NULL)
		{
			return FAILURE;
		}
		WDBuffer->PageNumber=OS_DRIVER_Malloc(UD_BUFFER_SIZE/currentDevice->pageSize);
		if(WDBuffer->PageNumber==NULL)
		{
			return FAILURE;
		}
		WDBuffer->LastBlock=-1;
		WDBuffer->NoOfPages=UD_BUFFER_SIZE/currentDevice->pageSize;
		ResetWriteBuffer();
	}
#endif


	//Handler.WritePage = Write528;
//if (UD_BUFFER_ENABLED)
	//			Handler.WritePage = Write528Cached;
	//else
				Handler.WritePage = Write528;
	Handler.ReadPage = Read;
	Handler.GetPageStatus = ReadSpare528;
	Handler.SetPageStatus = WriteSpare528;

	if (UD_COPY_BACK)
	{
		Handler.CopyPage = CopyWithCopyBack;
	}
	else
	{
		Handler.CopyPage = CopyWithoutCopyBack;