nandfat.c

NAND FLASH FAT文件系统建立范例

	error = HD_NFlashWrite((UINT32) gNFLASHBuf,temp_addr1) ;
	if (error != HW_ERR_NONE)
	{
		return error ;
	}
	error = HD_NFlashWrite((UINT32) gNFLASHBuf,temp_addr2) ;
	if (error != HW_ERR_NONE)
	{
		return error ;
	}

	return HW_ERR_NONE;
}

/*
 * Function:	   NandFatTableRecord
 * DeSCRiption:   this function is used to write the value(NextNum) to the position(CurNum),
						to update Fat table
 * Calls:   	   
 * Called By:      
 * Table Accessed: 
 * Table Updated:  
 * Input:   	   
 * Output:  	   
 * Return:  	   
 * Others:  	   
 */
UINT8 NandFatTableRecord(UINT16 CurNum, UINT16 NextNum)
{
	UINT32 tmp_addr = 0 ;
	UINT32 tmp_addr1 = 0 ;
	UINT32 tmp_addr2 = 0 ;
	UINT16 offset = 0 ;
	UINT8 error = HW_ERR_NONE;

	tmp_addr = (CurNum * 2) / 512 ;
	offset = (CurNum * 2) % 512  ;

	tmp_addr1 = gNandFATSYS.FAT1_addr + tmp_addr * 256 ;
	tmp_addr2 = gNandFATSYS.FAT2_addr + tmp_addr * 256 ;

	error = HD_NFlashRead(tmp_addr1,(UINT32) (gNFLASHBuf)) ;
	if (error != HW_ERR_NONE)
	{
		return error ;
	}
	gNFLASHBuf[offset + 1] = (UINT8) ((NextNum & 0xff00) >> 8);
	gNFLASHBuf[offset] = (UINT8) (NextNum & 0x00ff) ;	
	error = HD_NFlashWrite((UINT32) (gNFLASHBuf),tmp_addr1) ;
	if (error != HW_ERR_NONE)
	{
		return error ;
	}
	error = HD_NFlashWrite((UINT32) (gNFLASHBuf),tmp_addr2) ;
	if (error != HW_ERR_NONE)
	{
		return error ;
	}

	return TRUE ;
} 

/*
 * Function:	   NandFileNameConversion()
 * DeSCRiption:    this function is used to convert a constant string file name into the proper format
 * Calls:   	   
 * Called By:      
 * Table Accessed: 
 * Table Updated:  
 * Input:   	   UINT8 *current_file
 * Output:  	  none 
 * Return:  	  true and fasle 
 * Others:  	   
 */
UINT8 * NandFileNameConversion(UINT8 *current_file)
{
	UINT8 n, c;
	UINT8 filename[14] ;

	c = 0;

	for (n = 0; n < 14; n++)
	{
		if (NandValidFileChar(current_file[n]) == TRUE)
			// If the character is valid, save in uppeRCAse to file name buffer
		{
			gNandFileName[c++] = toupper(current_file[n]);
		}
		else if (current_file[n] == '.')
			// If it is a period, back fill buffer with [spaces], till 8 characters deep
		{
			while (c < 8)
				gNandFileName[c++] = 0x20;
		}
		else if (current_file[n] == 0)
		{
			// If it is NULL, back fill buffer with [spaces], till 11 characters deep
			while (c < 11)
				gNandFileName[c++] = 0x20;
			break;
		}
		else
		{
			return FALSE;
		}
		if (c >= 11)
		{
			break;
		}
	}
	filename[c] = 0;
	// Return the pointer of the filename
	return (gNandFileName);
}

UINT32 NandGetFileEntry(INT8 *filename)
{
	UINT8 n;
	UINT16 s, calc_temp;
	UINT32 addr_temp;
	UINT8 *sp, *qp;
	UINT8 error = HW_ERR_NONE ;

	// Get the filename into a form we can use to compare
	qp = NandFileNameConversion((UINT8 *) filename);
	if (qp == FALSE)  //name error
	{
		return (FALSE);
	}

	for (s = 0; s < gNandFATSYS.Bpb50.bpbBytesPerSec; s++)
	{
		// Scan through directory entries to find file
		addr_temp = gNandFATSYS.DIR_adrr + (0x200 * s);
		error = HD_NFlashRead(addr_temp,(UINT32) gNFLASHBuf) ;
		if (error != HW_ERR_NONE)
		{
			return error;
		}

		for (n = 0; n < 16; n++)
		{
			calc_temp = (UINT16) n * 0x20;
			qp = &gNandFileName[0];
			sp = &gNFLASHBuf[calc_temp];
			if (*sp == 0)
			{
				return (FALSE);
			}
			if (strncmp((INT8 *)qp,(INT8 *)sp,11) == 0)		// Does this entry == Filename
			{
				return (calc_temp + addr_temp);
			}
		}
	}
	return(FALSE);
}

/*
 * Function:   FatParaCaculate    
 * DeSCRiption:    this function is used to calculate the format parameter according to  the card capacivity
 * Calls:   	 
 * Called By:      
 * Table Accessed: 
 * Table Updated:  
 * Input:      none  
 * Output:    gFsType   ,gNFLASHBuf ,gBpb50
 * Return:    none  
 * Others:  	 
 */
#if 1
static void FatParaCaculate(void)
{
	UINT16 nbHeads ;
	UINT16 SectorperTrack ;
	UINT8 SectorperCluster ;
	UINT32 HiddenSectors ;
	UINT32 totalsize ;
	UINT16 fatsec;
	UINT16 i ;

	gNandFATSYS.FAT_type = PART_TYPE_FAT16 ;

	nbHeads = 8 ;
	SectorperTrack = 2 ;
	SectorperCluster = 2 ;
	HiddenSectors = 39 ;
	totalsize = 125440 ;
	fatsec = 244 ;

	//junp command
	gNFLASHBuf[0] = 0xEB ;
	gNFLASHBuf[1] = 0x00 ;
	gNFLASHBuf[2] = 0x90 ;

	//system indentifier
	gNFLASHBuf[3] = 'V'  ; // 
	gNFLASHBuf[4] = 'I'  ; // 
	gNFLASHBuf[5] = 'A' ; // 
	gNFLASHBuf[6] = 'T' ; //
	gNFLASHBuf[7] = 'E' ; // 
	gNFLASHBuf[8] = 'C' ; //
	gNFLASHBuf[9] = 'T' ; //
	gNFLASHBuf[10] = 'H' ;//

	//sector size(bytes per sec )
	gNFLASHBuf[11] = (UINT8) (512 & 0xff) ;
	gNFLASHBuf[12] = (UINT8) ((512 & 0xff00) >> 8);

	//sector per cluster
	gNFLASHBuf[13] = SectorperCluster ;

	//reserved sector count  (for fat16 and fat12 this is 1 )
	gNFLASHBuf[14] = (UINT8) (1 & 0x00ff) ;
	gNFLASHBuf[15] = 0 ;

	//number of fats
	gNFLASHBuf[16] = 2 ;

	//number of root directory entries 
	gNFLASHBuf[17] = (UINT8) (512 & 0xff) ;
	gNFLASHBuf[18] = (UINT8) ((512 & 0xff00) >> 8);

	//total sectors (16bits)
	gNFLASHBuf[19] = 0 ;
	gNFLASHBuf[20] = 0 ;

	//medium indentifier
	gNFLASHBuf[21] = 0xf8 ;

	//sectors per fat
	gNFLASHBuf[22] = (UINT8) (fatsec & 0xff) ;
	gNFLASHBuf[23] = (UINT8) ((fatsec & 0xff00) >> 8);

	//sectors per track
	gNFLASHBuf[24] = (UINT8) (SectorperTrack & 0xff) ;
	gNFLASHBuf[25] = (UINT8) ((SectorperTrack & 0xff00) >> 8);

	//number of slide(head)
	gNFLASHBuf[26] = (UINT8) (nbHeads & 0xff) ;
	gNFLASHBuf[27] = (UINT8) ((nbHeads & 0xff00) >> 8);

	//number of hidden sectors   
	gNFLASHBuf[28] = (UINT8) (HiddenSectors & 0x000000ff) ;
	gNFLASHBuf[29] = (UINT8) ((HiddenSectors & 0x0000ff00) >> 8);
	gNFLASHBuf[30] = (UINT8) ((HiddenSectors & 0x00ff0000) >> 16);
	gNFLASHBuf[31] = (UINT8) ((HiddenSectors & 0xff000000) >> 24);

	//total sectors (32bits)	
	gNFLASHBuf[32] = (UINT8) (totalsize & 0x000000ff) ;
	gNFLASHBuf[33] = (UINT8) ((totalsize & 0x0000ff00) >> 8) ;
	gNFLASHBuf[34] = (UINT8) ((totalsize & 0x00ff0000) >> 16) ;
	gNFLASHBuf[35] = (UINT8) ((totalsize & 0xff000000) >> 24) ;

	//physical disk number  
	gNFLASHBuf[36] = 0x80;

	//reserved
	gNFLASHBuf[37] = 0x00;

	//extend boot record signature
	gNFLASHBuf[38] = 0x29 ; 

	//volume ID number
	gNFLASHBuf[39] = 0x01 ;
	gNFLASHBuf[40] = 0x23 ;
	gNFLASHBuf[41] = 0x45 ;
	gNFLASHBuf[42] = 0x67 ;

	//volume label
	for (i = 0 ; i < 11; i++)
	{
		gNFLASHBuf[43 + i] = (0x41 + i);
	} //a~a+10)   

	//file system type  
	gNFLASHBuf[54] = 'F' ;
	gNFLASHBuf[55] = 'A' ;
	gNFLASHBuf[56] = 'T' ;
	gNFLASHBuf[57] = '1' ;
	gNFLASHBuf[58] = '6' ;

	gNFLASHBuf[59] = 0 ;
	gNFLASHBuf[60] = 0 ;
	gNFLASHBuf[61] = 0 ;

	//not restricted
	for (i = 0 ; i < 448; i++)
	{
		gNFLASHBuf[62 + i] = 0;
	}
	//signature word
	gNFLASHBuf[510] = 0x55 ;
	gNFLASHBuf[511] = 0xaa ;

	gNandFATSYS.Bpb50.bpbBytesPerSec = 512 ; 
	gNandFATSYS.Bpb50.bpbResSectors = 1 ;
	gNandFATSYS.Bpb50.bpbFATsecs = fatsec ;
	gNandFATSYS.Bpb50.bpbFATs = 2 ;
	gNandFATSYS.Bpb50.bpbRootDirEnts = 512 ;

	return ;
} 
#endif
/*
 * Function:   FAT_Format(void)  
 * DeSCRiption: format the sd card completely   
 * Calls:   	 
 * Called By:      
 * Table Accessed: 
 * Table Updated:  
 * Input:      none    
 * Output:    none     
 * Return:    true and false   
 * Others:  	 
 */
/***********************************************************************  
*-Sector size is 512 bytes 
*-2 fats management 
*-512 entries in the root directory 
*----------------------------------------------------------------------------
*REQUIREMENTS : need to call initial
************************************************************************/
#if 1
UINT8 NandFATFormat(void)
{
	UINT32 c, i;
	UINT32 temp_addr1 ;
	UINT32 temp_addr2 ;
	UINT8 error = HW_ERR_NONE;

#if 0
FatParaCaculate() ;
error = HD_NFlashWrite((UINT32) gNFLASHBuf, 0) ;
//error =NFTL_Write(0,  gNFLASHBuf) ;
#endif
#if 1
	error = HD_NFlashWrite((UINT32) BPBTaBle,0) ;
	gNandFATSYS.Bpb50.bpbBytesPerSec = 512 ; 
	gNandFATSYS.Bpb50.bpbResSectors = 1 ;
	gNandFATSYS.Bpb50.bpbFATsecs = 251 ; //255
	gNandFATSYS.Bpb50.bpbFATs = 2 ;
	gNandFATSYS.Bpb50.bpbRootDirEnts = 512 ;
#endif
	if (error != HW_ERR_NONE)
	{
		return error ;
	}

	gNandFATSYS.PartitionAddr = 0;
	//get the the first fat address
	gNandFATSYS.FAT1_addr = gNandFATSYS.PartitionAddr +
		(UINT32)
		gNandFATSYS.Bpb50.bpbResSectors * (UINT32)
		gNandFATSYS.Bpb50.bpbBytesPerSec; 

	//get the the second fat address
	gNandFATSYS.FAT2_addr = gNandFATSYS.FAT1_addr +
		(UINT32)
		gNandFATSYS.Bpb50.bpbFATsecs * (UINT32)
		gNandFATSYS.Bpb50.bpbBytesPerSec ;

	//get the root directory address
	gNandFATSYS.RootAddr = (UINT32)
		gNandFATSYS.Bpb50.bpbFATs * (UINT32)
		gNandFATSYS.Bpb50.bpbFATsecs +
		gNandFATSYS.Bpb50.bpbResSectors;
	gNandFATSYS.RootAddr *= (UINT32) gNandFATSYS.Bpb50.bpbBytesPerSec; 
	gNandFATSYS.RootAddr += gNandFATSYS.PartitionAddr;

	//determine the count of sectors occupied by the root directory:
	gNandFATSYS.RootDirSectors = ((gNandFATSYS.Bpb50.bpbRootDirEnts * 32) +
		gNandFATSYS.Bpb50.bpbBytesPerSec -
		1) /
		gNandFATSYS.Bpb50.bpbBytesPerSec;

	for (c = 3; c < 512; c++)   // initialize  gNFLASHBuf to  all zero
	{
		gNFLASHBuf[c] = 0;
	}

	gNFLASHBuf[0] = 0xF8;
	gNFLASHBuf[1] = 0xFF;
	gNFLASHBuf[2] = 0xFF;
	if (gNandFATSYS.FAT_type == PART_TYPE_FAT16)
	{
		gNFLASHBuf[3] = 0xFF;
	}

	temp_addr1 = gNandFATSYS.FAT1_addr ;
	temp_addr2 = gNandFATSYS.FAT2_addr ;


	error = HD_NFlashWrite((UINT32) gNFLASHBuf,temp_addr1) ;
	if (error != HW_ERR_NONE)
	{
		return error ;
	}

	error = HD_NFlashWrite((UINT32) gNFLASHBuf,temp_addr2) ;
	if (error != HW_ERR_NONE)
	{
		return error ;
	}

	gNFLASHBuf[0] = 0x0;
	gNFLASHBuf[1] = 0x0;
	gNFLASHBuf[2] = 0x0;
	gNFLASHBuf[3] = 0x0;

	for (i = 1 ; i < gNandFATSYS.Bpb50.bpbFATsecs ; i++)
	{
		temp_addr1 = gNandFATSYS.FAT1_addr + i * 0x200 ;
		temp_addr2 = gNandFATSYS.FAT2_addr + i * 0x200 ;
		error = HD_NFlashWrite((UINT32) gNFLASHBuf,temp_addr1) ;
		if (error != HW_ERR_NONE)
		{
			return error ;
		}
		error = HD_NFlashWrite((UINT32) gNFLASHBuf,temp_addr2) ;
		if (error != HW_ERR_NONE)
		{
			return error ;
		}
	}

	temp_addr1 = gNandFATSYS.RootAddr ;
	for (i = 0 ; i < gNandFATSYS.RootDirSectors ; i++)
	{
		error = HD_NFlashWrite((UINT32) gNFLASHBuf,temp_addr1) ;
		if (error != HW_ERR_NONE)
		{
			return error ;
		}
		temp_addr1 += 0x200 ;
	}

	return (TRUE);
} 
#endif