fsmwritetask.c

norflash的文件系统。 用于中低端手机开发的参考

						);

		if(ret != ERR_NONE)
			return ret;

		if (FsmGetMtxSem(MediaObjP->MapTblLock) != ERR_NONE)
		{
			return ERR_SYSTEM;
		}
		MediaObjP->Lsn2PsnP[lsn] = NewPsn;
		if (FsmReleaseMtxSem(MediaObjP->MapTblLock) != ERR_NONE)
		{
			return ERR_SYSTEM;
		}

		/* new sector state to updating */
		SectorHdr.Status = SECTOR_UPDATING;
		ret = DevWrite( DevP,
						(uint8 *)&SectorHdr.Status,
						NewSectorAddr + FIELD_OFFSET(FsmFlashSectorHdrT, Status), 
						FIELD_SIZE(FsmFlashSectorHdrT, Status)
						);

		if(ret != ERR_NONE)
			return ret;

		/* old sector state to deleting */
		SectorHdr.Status = SECTOR_DELETING;
		ret = DevWrite( DevP,
						(uint8 *)&SectorHdr.Status, 
						OldSectorAddr + FIELD_OFFSET(FsmFlashSectorHdrT, Status),
						FIELD_SIZE(FsmFlashSectorHdrT, Status)
						);	

		if(ret != ERR_NONE)
			return ret;

		/* new sector state to valid */
		SectorHdr.Status = SECTOR_VALID;
		ret = DevWrite( DevP,
						(uint8 *)&SectorHdr.Status, 
						NewSectorAddr + FIELD_OFFSET(FsmFlashSectorHdrT, Status), 
						FIELD_SIZE(FsmFlashSectorHdrT, Status)
						);

		if(ret != ERR_NONE)
			return ret;

		/* old sector state to invalid */
		SectorHdr.Status = SECTOR_INVALID;
		ret = DevWrite( DevP,
						(uint8 *)&SectorHdr.Status, 
						OldSectorAddr + FIELD_OFFSET(FsmFlashSectorHdrT, Status),
						FIELD_SIZE(FsmFlashSectorHdrT, Status)
						);	

		if(ret != ERR_NONE)
			return ret;

		BlkNum = (uint16)(OldPsn / MediaObjP->SectorsPerBlock);

		if (FsmGetMtxSem(MediaObjP->InfoLock) != ERR_NONE)
		{
			return ERR_SYSTEM;
		}
		MediaObjP->BlockInfoP[BlkNum].DirtySectors += 1;
		MediaObjP->BlockInfoP[BlkNum].UsedSectors -= 1;
		if (FsmReleaseMtxSem(MediaObjP->InfoLock) != ERR_NONE)
		{
			return ERR_SYSTEM;
		}
	}
	else
	{
		uint16		NewFreeInstIndex;

		/* address of the first Status field; */
		temp = OldSectorAddr + sizeof(FsmFlashSectorHdrT)		\
					+ FIELD_OFFSET(FsmMultiInstanceT, Status[0]);

		for (NewFreeInstIndex = InstIndex + 1;
				NewFreeInstIndex < Instances ; 
				NewFreeInstIndex++)
		{
			MultiInstStatus = 0;

			ret  =  DevRead( DevP, 
							 (uint8 *)&MultiInstStatus,
							 temp + NewFreeInstIndex * FIELD_SIZE(FsmMultiInstanceT, Status), 
							 FIELD_SIZE(FsmMultiInstanceT, Status)
							 );

			if(ret != ERR_NONE)
				return ret;

			if (MultiInstStatus == INSTANCE_EMPTY)
			{
				break;
			}
		}

		if (NewFreeInstIndex >= Instances)
		{
			goto Modify_Allocate_New;
		}


		MultiInstStatus = INSTANCE_WRITING;
		ret = DevWrite( DevP, 
						(uint8 *)&MultiInstStatus,
						OldSectorAddr + sizeof(FsmFlashSectorHdrT)		\
							+ FIELD_OFFSET(FsmMultiInstanceT, Status[0])		\
							+ NewFreeInstIndex * FIELD_SIZE(FsmMultiInstanceT, Status), 
						FIELD_SIZE(FsmMultiInstanceT, Status)
						);

		if(ret != ERR_NONE)
			return ret;

		NewWriteOffset = FIELD_SIZE(FsmMultiInstanceT, Length)		\
							+ Instances * FIELD_SIZE(FsmMultiInstanceT, Status)	\
							+ NewFreeInstIndex * len;

		OldWriteOffset = FIELD_SIZE(FsmMultiInstanceT, Length)		\
							+ Instances * FIELD_SIZE(FsmMultiInstanceT, Status)	\
							+ InstIndex * len;

		ret =  DevCopy( DevP,
						OldSectorAddr + sizeof(FsmFlashSectorHdrT) + NewWriteOffset,
						OldSectorAddr + sizeof(FsmFlashSectorHdrT) + OldWriteOffset,
						ItemP->offset
						);

		if(ret != ERR_NONE)
			return ret;

		NewWriteOffset += ItemP->offset;
		OldWriteOffset += ItemP->offset;

		ret = DevWrite( DevP, 
						(uint8 *)(ItemP + 1), 
						OldSectorAddr + sizeof(FsmFlashSectorHdrT) + NewWriteOffset,
						ItemP->length
						);

		if(ret != ERR_NONE)
			return ret;

		NewWriteOffset += ItemP->length;
		OldWriteOffset += ItemP->length;

		ret =  DevCopy( DevP,
						OldSectorAddr + sizeof(FsmFlashSectorHdrT) + NewWriteOffset, 
						OldSectorAddr + sizeof(FsmFlashSectorHdrT) + OldWriteOffset, 
						len - (ItemP->offset + ItemP->length)
						);

		if(ret != ERR_NONE)
			return ret;

		MultiInstStatus = INSTANCE_VALID;
		ret = DevWrite( DevP, 
						(uint8 *)&MultiInstStatus,
						OldSectorAddr + sizeof(FsmFlashSectorHdrT)			\
							+ FIELD_OFFSET(FsmMultiInstanceT, Status[0])		\
							+ NewFreeInstIndex * FIELD_SIZE(FsmMultiInstanceT, Status), 
						FIELD_SIZE(FsmMultiInstanceT, Status)
						);

		if(ret != ERR_NONE)
			return ret;

		MultiInstStatus = INSTANCE_INVALID;
		ret = DevWrite( DevP,
						(uint8 *)&MultiInstStatus,
						OldSectorAddr + sizeof(FsmFlashSectorHdrT)			\
							+ FIELD_OFFSET(FsmMultiInstanceT, Status[0])		\
							+ InstIndex * FIELD_SIZE(FsmMultiInstanceT, Status),
						FIELD_SIZE(FsmMultiInstanceT, Status)
						);

		if(ret != ERR_NONE)
			return ret;
	}

	return ERR_NONE;
}

static uint32 SingleInstanceCreate(
	FsmQueueItemT * ItemP,
	FsmDevObjHdrT * DevP,
	FsmDfsFileDescriptorT * FdP,
	char * NameP)
{
	uint32				ret;

	uint16				temp_uint16;

	uint32				len, FirstLsn;
	uint32				lsn, NextLsn, NewPsn;
	uint32				NewEntryAddr, NewSectorAddr;

	uint8 *				DataP = (uint8 *)(ItemP + 1);

	FsmFlashMediaT *	MediaObjP = (FsmFlashMediaT * )DevP->MediaObjP;

	DEV_WRITE_FUNCPTR	DevWrite = DevP->DevDrvP->FsmDevWrite;
	DEV_READ_FUNCPTR	DevRead = DevP->DevDrvP->FsmDevRead;

	ret = GetFreeEntry(ItemP, &NewEntryAddr);
	if (ret != ERR_NONE)
	{
		return ret;
	}

	ret = GetFreeLsn(DevP, &FirstLsn);
	if (ret != ERR_NONE)
	{
		return ret;
	}

	len = ItemP->length;

	for ( lsn = FirstLsn; len > 0; lsn = NextLsn)
	{
		ret = GetFreePsn(DevP, &NewPsn);
		if (ret != ERR_NONE)
		{
			return ret;
		}

		NewSectorAddr = DfsPsn2Addr(MediaObjP, NewPsn);

		/* sector state to writing */
		temp_uint16 = SECTOR_WRITING;
		ret = DevWrite( DevP, 
						(uint8 *)&temp_uint16,
						NewSectorAddr + FIELD_OFFSET(FsmFlashSectorHdrT, Status), 
						FIELD_SIZE(FsmFlashSectorHdrT, Status)
						);

		if(ret != ERR_NONE)
			return ret;

		if (len <= MediaObjP->SectorSize)
		{
			ret = DevWrite( DevP,
							DataP,
							NewSectorAddr + sizeof(FsmFlashSectorHdrT),
							len
							);

			if(ret != ERR_NONE)
				return ret;

			NextLsn = (uint32)(-1);
			len = 0;
		}
		else
		{
			ret = DevWrite( DevP, 
							DataP, 
							NewSectorAddr + sizeof(FsmFlashSectorHdrT),
							MediaObjP->SectorSize
							);

			if(ret != ERR_NONE)
				return ret;

			len -= MediaObjP->SectorSize;

			DataP = &DataP[MediaObjP->SectorSize];
		}

		temp_uint16 = SECTOR_TYPE_SID;
		ret = DevWrite( DevP, 
						(uint8 *)&temp_uint16, 
						NewSectorAddr + FIELD_OFFSET(FsmFlashSectorHdrT, Type),
						FIELD_SIZE(FsmFlashSectorHdrT, Type)
						);

		if(ret != ERR_NONE)
			return ret;

		ret = DevWrite( DevP,
						(uint8 *)&lsn, 
						NewSectorAddr + FIELD_OFFSET(FsmFlashSectorHdrT, Lsn),
						FIELD_SIZE(FsmFlashSectorHdrT, Lsn)
						);

		if(ret != ERR_NONE)
			return ret;

		if (FsmGetMtxSem(MediaObjP->MapTblLock) != ERR_NONE)
		{
			return ERR_SYSTEM;
		}
		/* Update the Map table,so the subsequent */
		/* call to GetFreeLsn will not return value of this lsn. */
		MediaObjP->Lsn2PsnP[lsn] = NewPsn;
		if (FsmReleaseMtxSem(MediaObjP->MapTblLock) != ERR_NONE)
		{
			return ERR_SYSTEM;
		}

		if (len != 0)
		{
			ret = GetFreeLsn(DevP, &NextLsn);
			if (ret != ERR_NONE)
			{
				return ret;
			}

			ret = DevWrite( DevP, 
							(uint8 *)&NextLsn, 
							NewSectorAddr + FIELD_OFFSET(FsmFlashSectorHdrT, NextLsn),
							FIELD_SIZE(FsmFlashSectorHdrT, NextLsn)
							);

			if(ret != ERR_NONE)
				return ret;
		}
	}

	for (lsn = FirstLsn; lsn != (uint32)(-1);)
	{
		NewPsn = DfsLsn2Psn(MediaObjP, lsn);
		NewSectorAddr = DfsPsn2Addr(MediaObjP, NewPsn);

		/* sector state to allocated */
		temp_uint16 = SECTOR_ALLOCATED;
		ret = DevWrite( DevP,
						(uint8 *)&temp_uint16,
						NewSectorAddr + FIELD_OFFSET(FsmFlashSectorHdrT, Status),
						FIELD_SIZE(FsmFlashSectorHdrT, Status)
						);

		if(ret != ERR_NONE)
			return ret;

		ret  =  DevRead( DevP,
						 (uint8 *)&lsn, 
						 NewSectorAddr + FIELD_OFFSET(FsmFlashSectorHdrT, NextLsn),
						 FIELD_SIZE(FsmFlashSectorHdrT, NextLsn)
						 );

		if(ret != ERR_NONE)
			return ret;
	}

	if (ItemP->type == QUEUE_FILE_DIR)
	{
		FsmFileDirEntryT	FileEntry;

		/* entry state to writing */
		temp_uint16 = ENTRY_WRITING;
		ret = DevWrite( DevP, 
						(uint8 *)&temp_uint16, 
						NewEntryAddr + FIELD_OFFSET(FsmFileDirEntryT, Status), 
						FIELD_SIZE(FsmFileDirEntryT, Status)
						);

		if(ret != ERR_NONE)
			return ret;

		FileEntry.Status   = ENTRY_WRITING;
		FileEntry.Type     = ENTRY_TYPE_FILE;
		FileEntry.Rfu      = 0xFF;
		FileEntry.Date     = FdP->CreateDate;
		FileEntry.Time     = FdP->CreateTime;
		FileEntry.Length   = ItemP->length;
		FileEntry.FirstLsn = FirstLsn;

		/* strcpy(FileEntry.FileName, NameP); */
		/* strncpy(FileEntry.FileName, NameP, FIELD_SIZE(FsmFileDirEntryT, FileName)); */

		len = strlen(NameP) + 1; /* include the terminating zero. */
		if(len > FIELD_SIZE(FsmFileDirEntryT, FileName))
			len = FIELD_SIZE(FsmFileDirEntryT, FileName);

		FsmMemoryMove((uint8 *)&FileEntry.FileName[0],
					  (uint8 *)NameP, 
					  len /*FIELD_SIZE(FsmFileDirEntryT, FileName)*/
					  );

		ret = DevWrite( DevP, 
						(uint8 *)&FileEntry,
						NewEntryAddr, 
						sizeof(FsmFileDirEntryT)
						);

		if(ret != ERR_NONE)
			return ret;

		/* entry state to allocated */
		temp_uint16 = ENTRY_ALLOCATED;
		ret = DevWrite( DevP,
						(uint8 *)&temp_uint16,
						NewEntryAddr + FIELD_OFFSET(FsmFileDirEntryT, Status),
						FIELD_SIZE(FsmFileDirEntryT, Status)
						);

		if(ret != ERR_NONE)
			return ret;
	}
	else
	{
		FsmItemDirEntryT	ItemEntry;

		/* entry state to writing */
		temp_uint16 = ENTRY_WRITING;
		ret = DevWrite( DevP,
						(uint8 *)&temp_uint16,
						NewEntryAddr + FIELD_OFFSET(FsmItemDirEntryT, Status),
						FIELD_SIZE(FsmItemDirEntryT, Status)
						);

		if(ret != ERR_NONE)
			return ret;

		ItemEntry.Status   = ENTRY_WRITING;
		ItemEntry.Type     = ENTRY_TYPE_ITEM;
		ItemEntry.ItemType = ItemP->ItemFd.Item.ItemType;
		ItemEntry.ItemId   = ItemP->ItemFd.Item.ItemId;
		ItemEntry.Method   = METHOD_SINGLE;
		ItemEntry.Length   = ItemP->length;
		ItemEntry.FirstLsn = FirstLsn;

		ret = DevWrite( DevP,
						(uint8 *)&ItemEntry, 
						NewEntryAddr,
						sizeof(FsmItemDirEntryT)
						);

		if(ret != ERR_NONE)
			return ret;

		/* entry state to allocated */
		temp_uint16 = ENTRY_ALLOCATED;
		ret = DevWrite( DevP,
						(uint8 *)&temp_uint16,
						NewEntryAddr + FIELD_OFFSET(FsmItemDirEntryT, Status),
						FIELD_SIZE(FsmItemDirEntryT, Status)
						);

		if(ret != ERR_NONE)
			return ret;
	}

	for (lsn = FirstLsn; lsn != (uint32)(-1);)
	{
		NewPsn = DfsLsn2Psn(MediaObjP, lsn);
		NewSectorAddr = DfsPsn2Addr(MediaObjP, NewPsn);

		/* sector state to valid */
		temp_uint16 = SECTOR_VALID;
		ret = DevWrite( DevP,
						(uint8 *)&temp_uint16,
						NewSectorAddr + FIELD_OFFSET(FsmFlashSectorHdrT, Status),
						FIELD_SIZE(FsmFlashSectorHdrT, Status)
						);

		if(ret != ERR_NONE)
			return ret;

		ret  =  DevRead( DevP,
						 (uint8 *)&lsn,
						 NewSectorAddr + FIELD_OFFSET(FsmFlashSectorHdrT, NextLsn),
						 FIELD_SIZE(FsmFlashSectorHdrT, NextLsn)
						 );

		if(ret != ERR_NONE)
			return ret;
	}

	/* entry state to valid */
	temp_uint16 = ENTRY_VALID;
	if (ItemP->type == QUEUE_FILE_DIR)
	{
		ret = DevWrite( DevP,
						(uint8 *)&temp_uint16,
						NewEntryAddr + FIELD_OFFSET(FsmFileDirEntryT, Status),
						FIELD_SIZE(FsmFileDirEntryT, Status)
						);

		if(ret != ERR_NONE)
			return ret;

		/* FirstLsn updating should be synchronized with FsmRead function. */
		if (FsmGetMtxSem(MediaObjP->MapTblLock) != ERR_NONE)
		{
			return ERR_SYSTEM;
		}
		FdP->FirstLsn = FirstLsn;
		if (FsmReleaseMtxSem(MediaObjP->MapTblLock) != ERR_NONE)
		{
			return ERR_SYSTEM;
		}
	}
	else
	{
		ret = DevWrite( DevP,
						(uint8 *)&temp_uint16,
						NewEntryAddr + FIELD_OFFSET(FsmItemDirEntryT, Status),
						FIELD_SIZE(FsmItemDirEntryT, Status)
						);

		if(ret != ERR_NONE)
			return ret;
	}
	
	return ERR_NONE;
}

static uint32 SingleInstanceModify(
	FsmQueueItemT * ItemP,
	FsmDevObjHdrT * DevP,
	FsmDfsFileDescriptorT * FdP
	)
{
	uint32				temp;
	FsmFlashSectorHdrT	SectorHdr;
	uint32				ret;
	uint16				BlkNum;
	uint32				lsn, NewPsn, OldPsn;
	uint32				NewSectorAddr, OldSectorAddr;
	uint32				OldEntryAddr;

	uint32				WriteOffset;
	uint32				WriteLen;
	uint32				RemainLen;

	uint8 *				DataP = (uint8 *)(ItemP + 1);

	FsmFlashMediaT *	MediaObjP = (FsmFlashMediaT * )DevP->MediaObjP;

	DEV_COPY_FUNCPTR	DevCopy = DevP->DevDrvP->FsmDevCopy;
	DEV_WRITE_FUNCPTR	DevWrite = DevP->DevDrvP->FsmDevWrite;
	DEV_READ_FUNCPTR	DevRead = DevP->DevDrvP->FsmDevRead;


	if (ItemP->type == QUEUE_FILE_DIR)
	{
		lsn = FdP->FirstLsn;
	}
	else
	{
		ret = GetValidEntry(ItemP, &OldEntryAddr);
		if (ret != ERR_NONE)
		{
			return ret;
		}

		ret  =  DevRead( DevP, 
						 (uint8 *)&lsn,
						 OldEntryAddr + FIELD_OFFSET(FsmItemDirEntryT, FirstLsn),
						 FIELD_SIZE(FsmItemDirEntryT, FirstLsn)
						 );

		if(ret != ERR_NONE)
			return ret;