fat16.c

SPI FLASH,SL811HST驱动

#include <stdio.h>
#include "fat16.h"
#include "sl811.h"
#include <string.h>
#include "struct.h"

extern SYSTEMTIME CurrentTime;

extern  void GotoXY(unsigned char x,unsigned char y); 
extern  void Print(const char * s);
extern  void pause_ms(unsigned char tps);
extern void ClearLcd(void);
uint16 BPB_BytesPerSec;
uint8 BPB_SecPerClus;
uint16 BPB_RsvdSecCnt;
uint8 BPB_NumFATs;
uint16 BPB_RootEntCnt;
uint16 BPB_TotSec16;
uint16 BPB_FATSz16;
uint32 BPB_HiddSec;


//uint16 ClusOfFileDir;
//uint16  DirOffset;
//********************************************************************************************
//读一个扇区
//void ReadBlock(uint32 LBA)
//********************************************************************************************
//{
//	return;
//}

//********************************************************************************************
//写一个扇区
//void WriteBlock(uint32 LBA)
//********************************************************************************************
//{
//	return;
//}

//********************************************************************************************
void CopyBytes(void* S, void* D, uint16 size)
//********************************************************************************************
{
	uint8 *s = S, *d = D;
	uint16 i;
	for(i = 0; i < size; i++)
		*d++ = *s++;
}

//********************************************************************************************
uint8 IsEqual(void* A, void* B, uint8 Size)
//********************************************************************************************
{
	uint8 i, *a = A, *b = B;
	for(i = 0; i < Size; i++)
		if(a[i] != b[i])
			return 0;
	return 1;
}

//********************************************************************************************
void EmptyBytes(void* D, uint16 size)
//********************************************************************************************
{
	uint16 i;
	uint8* data = (uint8*)D;
	for(i = 0; i < size; i++)
	{
		*data++ = 0;
	}
}

//********************************************************************************************
//读取BPB数据结构
void ReadBPB(void)
//********************************************************************************************
{
	FAT_BPB* BPB = (FAT_BPB*)buffer;
	//ReadBlock(0);
	sl811_read_sector(0x00000000, buffer);
	//获取参数
	BPB_BytesPerSec = BPB->BPB_BytesPerSec;
	BPB_SecPerClus = BPB->BPB_SecPerClus;  //每簇扇区数
	BPB_RsvdSecCnt = BPB->BPB_RsvdSecCnt;
	BPB_NumFATs = BPB->BPB_NumFATs;
	BPB_RootEntCnt = BPB->BPB_RootEntCnt;
	BPB_TotSec16 = BPB->BPB_TotSec16;
	BPB_FATSz16 = BPB->BPB_FATSz16;
	BPB_HiddSec = BPB->BPB_HiddSec;

}

//********************************************************************************************
//获取根目录开始扇区号
uint32 DirStartSec(void)
//********************************************************************************************
{
	return BPB_RsvdSecCnt + ((uint32)BPB_NumFATs) * ((uint32)BPB_FATSz16);
}

//********************************************************************************************
//获取数据区开始扇区号
uint32 DataStartSec(void)
//********************************************************************************************
{
	return (uint32)(DirStartSec() + ((uint32)BPB_RootEntCnt) * 32 / BPB_BytesPerSec);
}

//********************************************************************************************
//目录项占用的扇区数
uint16 GetDirSecCount(void)
//********************************************************************************************
{
	return BPB_RootEntCnt * 32 / 512;
}

//********************************************************************************************
//获取一个簇的开始扇区
uint32 ClusConvLBA(uint16 ClusID)
//********************************************************************************************
{
	return DataStartSec() + ((uint32)BPB_SecPerClus )* (ClusID - 2);
}

//********************************************************************************************
//读取文件分配表的指定项
uint16 ReadFAT(uint16 Index)
//********************************************************************************************
{
	uint16 *RAM = (uint16*)buffer;
	//ReadBlock(BPB_RsvdSecCnt + Index / 256);
	sl811_read_sector(BPB_RsvdSecCnt + Index / 256, buffer);
	return RAM[Index % 256];
}

//********************************************************************************************
//写文件分配表的指定项
void WriteFAT(uint16 Index, uint16 Value)
//********************************************************************************************
{
	uint16 *RAM = (uint16*)buffer;
	uint32 SecID;
	SecID = BPB_RsvdSecCnt + Index / 256;
	//ReadBlock(SecID);
	sl811_read_sector(SecID, buffer);
	RAM[Index % 256] = Value;
	//WriteBlock(SecID);
	sl811_write_sector(SecID, buffer);
}

//********************************************************************************************
//获取根目录中可以使用的一项
uint16 GetEmptyDIR()
//********************************************************************************************
{
	uint16 DirSecCut, i, m, ID = 0;
	uint32 DirStart;
	DirSecCut = GetDirSecCount();
	DirStart = DirStartSec();
	for(i = 0; i < DirSecCut; i++)
	{
		//ReadBlock(DirStart + i);
		sl811_read_sector(DirStart + i, buffer);
		for(m = 0; m < 16; m++)
		{
			if((buffer[m * 32] == 0) || (buffer[m * 32] == 0xe5))
			{
				ClusOfFileDir=i;  //文件目录所在的簇
				DirOffset=m;      //文件目录项扇区偏移量				
				return ID;
			}
			else
				ID++;
		}
	}
	return ID;
}

//********************************************************************************************
//获得和文件名对应的目录项
uint8 GetFileID(uint8 Name[11], DIR* ID)
//********************************************************************************************
{
	uint16 DirSecCut, i, m;
	uint32 DirStart;
	DIR* ID_TEMP;
	DirSecCut = GetDirSecCount();
	DirStart = DirStartSec();
	for(i = 0; i < DirSecCut; i++)
	{
		//ReadBlock(DirStart + i);
		sl811_read_sector(DirStart + i, buffer);
		for(m = 0; m <16; m++)
		{
			if(IsEqual(Name, &((DIR*)&buffer[m * 32])->FileName, 11))
			{	
			   //*ID = *((DIR*)&buffer[m * 32]);
				ID_TEMP=(DIR*)&buffer[m * 32];
				*ID = *ID_TEMP;
				
				ClusOfFileDir=i;  //文件目录所在的簇
				DirOffset=m;      //文件目录项扇区偏移量
				
				return 1; //找到对应的目录项,返回1.
			}
		}
	}
	return 0; //没有找到对应的目录项,返回0.
}
//*************************************************************************************
//读取文件大小
uint32 GetFileSize(DIR* ID)
//*************************************************************************************
{
	return (ID->FilePosit.Size);	
}

//*************************************************************************************
//设置文件大小
void SetFileSize(uint16 size)
//*************************************************************************************
{
	uint32 DirStart;
	//uint32 NewSize;
	//DIR* ID; 
	
	DirStart = DirStartSec();
	
	sl811_read_sector(DirStart + ClusOfFileDir , buffer); 
	
	(((DIR*)&buffer[DirOffset * 32]))->FilePosit.Size += size;
	
	sl811_write_sector(DirStart+ClusOfFileDir, buffer);
}

//********************************************************************************************
//获取一个空的FAT项
uint16 GetNextFAT(void)
//********************************************************************************************
{
	uint16 FAT_Count, i;
	FAT_Count = BPB_FATSz16 * 256; //FAT表总项数
	for(i = 0; i < FAT_Count; i++)
	{
		if(ReadFAT(i) == 0)
			return i;
	}
	return 0;
}

//********************************************************************************************
//读取根目录的指定项
void ReadDIR(uint16 Index, DIR* Value)
//********************************************************************************************
{
	uint32 DirStart = DirStartSec();
	//ReadBlock(DirStart + Index / 16);
	sl811_read_sector(DirStart + Index / 16, buffer);
	CopyBytes(&buffer[(Index % 16) * 32], Value, 32);
}

//********************************************************************************************
//写根目录的指定项
void WriteDIR(uint16 Index, DIR* Value)
//********************************************************************************************
{
	uint32 LBA = DirStartSec() + Index / 16;
	//ReadBlock(LBA);
	sl811_read_sector(LBA, buffer);
	CopyBytes(Value, &buffer[(Index % 16) * 32], 32);
	//WriteBlock(LBA);
	sl811_write_sector(LBA, buffer);
}
//********************************************************************************************
//写增加簇号链的
void AddClus(uint32 file_size, DIR* ID)
//********************************************************************************************
{

	uint16 ClusID, ClusNext,ClusNum;
	uint32 i;
	ClusNum = file_size / (BPB_SecPerClus * 512);        //哪一个簇

	ClusID = ID->FilePosit.Start;

	for(i = 0; i < ClusNum; i++)
		ClusID = ReadFAT(ClusID);   //找到该文件的簇尾
	
	if ( (BPB_SecPerClus * 512)-(file_size%(BPB_SecPerClus * 512)) <= 2000)
		{
			ClusNext = GetNextFAT();
			WriteFAT(ClusID, ClusNext);
			ClusID = ClusNext;
			WriteFAT(ClusID, 0xffff);
		}	

}

//********************************************************************************************
//创建一个空文件
void CreateFile(uint8 FileName[11], uint32 Size)
//********************************************************************************************
{
	uint16 ClusID, ClusNum, ClusNext, i;
	DIR FileDir;
	ClusNum = Size / (BPB_SecPerClus * 512) + 1;
	EmptyBytes(&FileDir, sizeof(DIR));
	CopyBytes(FileName, &FileDir.FileName, 11);
	FileDir.FilePosit.Size = Size;
	FileDir.FilePosit.Start = GetNextFAT();
	ClusID = FileDir.FilePosit.Start;
	//FileDir.Time = Hr * 2048 + Min * 32 + Sec + 2;
	FileDir.Time =CurrentTime.Hour* 2048 + CurrentTime.Minute* 32 + 45 + 2;
	//FileDir.Date = (Yr-1980) * 512 + Mon * 32 + Day;
	FileDir.Date = ((2000+CurrentTime.Year)-1980) * 512 + CurrentTime.Month * 32 + CurrentTime.Day;
	FileDir.FileAttrib = 0x20;               //存档
	for(i = 0; i < ClusNum - 1; i++)
	{
		WriteFAT(ClusID, 0xffff);
		ClusNext = GetNextFAT();
		WriteFAT(ClusID, ClusNext);
		ClusID = ClusNext;
	}

	WriteFAT(ClusID, 0xffff);
	WriteDIR(GetEmptyDIR(), &FileDir);
}


//********************************************************************************************
//复制文件分配表,使其和备份一致
void CopyFAT(void)
//********************************************************************************************
{
	uint16 FATSz16, RsvdSecCnt, i;
	FATSz16 = BPB_FATSz16;
	RsvdSecCnt = BPB_RsvdSecCnt;
	for(i = 0; i < FATSz16; i++)
	{
			GotoXY(1,0);
			Print("811_read_sector");
			pause_ms(100);
		//ReadBlock(RsvdSecCnt + i);
		sl811_read_sector(RsvdSecCnt + i, buffer);
		//WriteBlock(RsvdSecCnt + FATSz16 + i);
			GotoXY(2,0);
			Print("811_write_sector");
			pause_ms(100);
		sl811_write_sector(RsvdSecCnt + FATSz16 + i, buffer);
	}
			GotoXY(1,0);
			Print("CopyFAT..OK!");
			pause_ms(100);
}

//********************************************************************************************
//操作文件的数据
//void OperateFile(uint8 Write ,uint8 Name[11], uint32 Start, uint32 Length, void* Data)
void OperateFile(uint8 Write , uint32 Start, uint32 Length, void* Data, DIR* FileDir)
//********************************************************************************************
{
	uint8 *data = Data;
	uint16 BytePerClus, SecPerClus, ClusNum, ClusID, m;
	uint32 LBA, i;
//	DIR FileDir;

	unsigned char asc[4];
	SecPerClus = BPB_SecPerClus;
	BytePerClus = BPB_SecPerClus * 512; // 每簇的字节数
//	GetFileID(Name, &FileDir);        //获取该文件的目录      太费时

	//计算开始位置所在簇的簇号
	ClusNum = Start / BytePerClus;        //哪一个簇
	ClusID = FileDir->FilePosit.Start;     //该文件的起始簇号
	for(i = 0; i < ClusNum; i++)
		ClusID = ReadFAT(ClusID);

	//计算开始位置所在扇区簇内偏移  //第几个扇区
	i = (Start % BytePerClus) / 512;

	//计算开始位置扇区内偏移
	m = (Start % BytePerClus) % 512; //扇区内偏移字节数
//	LBA = ClusConvLBA(ClusID) + m;  //文件起始簇号+扇区内偏移字节数
//	LBA = ClusConvLBA(ClusID) + i*512 + m;  //文件起始簇号+扇区内偏移字节数
	LBA = ClusConvLBA(ClusID) + i;  //文件起始簇号+簇内扇区偏移

	if(Write)
		//ReadBlock(LBA);
		sl811_read_sector(LBA, buffer);
	else
		//ReadBlock(LBA++);
		sl811_read_sector(LBA++, buffer);

	goto Start;

	while(1)
	{
		ClusID = ReadFAT(ClusID); //下一簇簇号
		LBA = ClusConvLBA(ClusID);
		for(i = 0; i < SecPerClus; i++)
		{
			if(Write)
				//ReadBlock(LBA);
				sl811_read_sector(LBA, buffer);
			else
				//ReadBlock(LBA++);
				sl811_read_sector(LBA++, buffer);

			for(m = 0; m < 512; m++)
			{
Start:
				if(Write)
					buffer[m] = *data++;
				else
					*data++ = buffer[m];
				//如果读取完成就退出
				if(--Length == 0)
				{
					if(Write)
						//WriteBlock(LBA); //回写扇区
						sl811_write_sector(LBA, buffer);

					return;
				}
			}
			if(Write)
				//WriteBlock(LBA++); //回写扇区,指针下移
				sl811_write_sector(LBA++, buffer);
		}
	}
}