fsmdataitem.c

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

	return fd;
}

/*****************************************************************
 * Function Name:
 *           FsmDataItemFindNext
 *
 * Description  :
 *           Write content to an opened data item file
 *
 * Input :
 *           ItemFd
 *
 * First Edit 2003.9.30 wsm
 *  The queue should be flushed first for exactly searching.
 *****************************************************************/

uint32 FsmDataItemFindNext(uint32 ItemFd, FsmItemInfoT * Info)
{
	uint32			Lsn;
	uint32			EntryCount;
	uint16			type;
	uint16			id;
	uint8			found;

	FsmItemDirEntryT	Entry;
	FsmFlashMediaT *	MediaP;

#ifdef FSM_DEBUG
	MonPrintf("Enter interface Find Next Data Item in %d \n", __LINE__);
#endif

	/* arguments check */
	if (FsmDataItemDevObjP == NULL)
	{
		return ERR_SYSTEM;
	}

	MediaP = (FsmFlashMediaT *)FsmDataItemDevObjP->MediaObjP;

	if (MediaP == NULL)
	{
		return ERR_SYSTEM;
	}

	if (ItemFd >= MAX_DIM_FD)
	{
		return ERR_PARAM;
	}

	/* lock the data item */
	if (FsmGetMtxSem(DataItemMtxSem) != ERR_NONE)
	{
	#ifdef FSM_DEBUG
		MonPrintf("DataItemLock semaphore fail!");
	#endif
		return ERR_SYSTEM;
	}

	if (DataItemFds[ItemFd].Flag == DID_FLAG_FREE)
	{
		FsmReleaseMtxSem(DataItemMtxSem);
		return ERR_PARAM;
	}

	if ((DataItemFds[ItemFd].ItemType != MATCH_TYPE) && (DataItemFds[ItemFd].ItemId != MATCH_ID))
	{
		/* There is no "next item" with exact match. */
		FsmReleaseMtxSem(DataItemMtxSem);
		return ERR_NOTEXIST;
	}

	if (FsmGetMtxSem(MediaP->MapTblLock) != ERR_NONE )
	{
#ifdef FSM_DEBUG
		MonPrintf(" MapTblLock semaphore fail!\n");
#endif
		FsmReleaseMtxSem(DataItemMtxSem);

		return ERR_SYSTEM;
	}

	type = DataItemFds[ItemFd].ItemType;
	id = DataItemFds[ItemFd].ItemId;

	/* the lsn and the start entry count store in the FD structure */
	Lsn = DataItemFds[ItemFd].FirstLsn;
	EntryCount = DataItemFds[ItemFd].ItemLength;

	found = FALSE;

	while(ReadDataItemEntry(&Lsn, &EntryCount, &Entry) == ERR_NONE)
	{
		if ((type == MATCH_TYPE) && (id == MATCH_ID))
		{
    		found = TRUE;
		}
		else if ((type == MATCH_TYPE) && (id == Entry.ItemId ))
		{  
    		found = TRUE;
		}
		else if ((type == Entry.ItemType ) && (id == MATCH_ID))
		{
    		found = TRUE;
		}
		else
		{
    		found = FALSE;
			continue;
		}

    	Info->ItemType = Entry.ItemType ;
    	Info->ItemId = Entry.ItemId ;
    	Info->ItemLength = Entry.Length ;
    	Info->Attrib = Entry.Type ;
    	Info->Method = Entry.Method;  

    	/* we save the lsn in Firstlsn and the entry count in ItemLength */
    	DataItemFds[ItemFd].FirstLsn = Lsn;
		DataItemFds[ItemFd].ItemLength = EntryCount;
    	
    	break;
	}

	FsmReleaseMtxSem(MediaP->MapTblLock);
	FsmReleaseMtxSem(DataItemMtxSem);

	if (found == FALSE)
	{
		return ERR_NOTEXIST;
	}

	return ERR_NONE;    
}

/*****************************************************************
 * Function Name:
 *           FsmDataItemFlush
 *
 * Description  :
 *           wait the data item flush into media
 *
 * Input :
 *           ItemFd
 *
 * First Edit 2003.9.30 wsm
 *
 *****************************************************************/

uint32 FsmDataItemFlush(uint16 type, uint16 id)
{
    uint32		status;
    
#ifdef FSM_DEBUG
	MonPrintf("Enter interface Data Item Flush in %d \n", __LINE__);
#endif

	if ((status = FsmGetMtxSem(DataItemMtxSem)) != ERR_NONE)
	{
		return status;
	}

	/* check in the write queue */
	status = WaitTypeIdEmpty(type, id, WAIT_FOREVER);

	FsmReleaseMtxSem(DataItemMtxSem);

    return status;
}

/*****************************************************************
 * Function Name:
 *           FsmDataItemFlushAll
 *
 * Description  :
 *           wait all data item flush into media
 *
 * Input :
 *
 * First Edit 2003.9.30 wsm
 *
 *****************************************************************/

uint32 FsmDataItemFlushAll()
{
    uint32 ErrorCode;

#ifdef FSM_DEBUG
	MonPrintf("Enter interface Data Item Flush in %d \n", __LINE__);
#endif
    
    ErrorCode = WaitQueueEmpty(WAIT_FOREVER);
    
    return ErrorCode;
}

/*****************************************************************
 * Function Name:
 *           FsmDataItemError
 *
 * Description  :
 *           get the errorcode
 *
 * Input :
 *
 * First Edit 2003.9.30 wsm
 *
 *****************************************************************/

uint32 FsmDataItemError(uint32 ItemFd)
{
    if (ItemFd >= MAX_DIM_FD )
    {
        return ERR_PARAM;
    }
    
   	return DataItemFds[ItemFd].ErrorCode;
}

uint32 FsmDataItemGetError()
{
	return DimErrorCode;
}

/************************************************* Local Function *************************************************/

static uint32 LocateDataItem(
	uint16 type,
	uint16 id, 
	FsmItemDirEntryT * entry
	)
{
	uint32		status;
	uint32		Lsn;
	uint32		EntryCount;
	uint32		length;
	uint16		found = FALSE;

	FsmFlashMediaT  *	MediaP;

	MediaP = (FsmFlashMediaT *)FsmDataItemDevObjP->MediaObjP;

	/* lock the write process and the reclaim process */
	if ((status = FsmGetMtxSem(MediaP->MapTblLock)) != ERR_NONE )
	{
#ifdef FSM_DEBUG
		MonPrintf(" MapTblLock semaphore fail!\n");
#endif

		return status;
	}


	/* look up the data item on flash */
	Lsn = 1;
	EntryCount = 0;

	while ((status = ReadDataItemEntry(&Lsn, &EntryCount, entry)) == ERR_NONE)
	{
		if ((entry->ItemType == type) && (entry->ItemId == id))
		{
			found = TRUE;
    		break;
		}
	}

	status = QueueGetDataItemLength(type, id, &length);

	if (status == ERR_NONE)
	{
		if(found == TRUE)
		{
			entry->Length = length;
		}
		else
		{
			entry->Status = ENTRY_VALID;
			entry->Type = ENTRY_TYPE_ITEM;
			entry->Method = METHOD_SINGLE;
			entry->ItemType = type;
			entry->ItemId = id;
			entry->Length = length;
			entry->FirstLsn = -1;

			found = TRUE;
		}
	}

	FsmReleaseMtxSem(MediaP->MapTblLock);

	if(found == FALSE)
		return status;
	else
		return ERR_NONE;
}

static uint32 ReadDataItemEntry(
	uint32 * Lsn, 
	uint32 * EntryCount,
	FsmItemDirEntryT * Entry
	)
{
	uint32		status;
	uint32		sector_size;
	uint32		paddr;
	uint32		entry_offset;
	uint32		Count;
	uint32		ValidEntryCount;

	FsmFlashMediaT *	MediaP;
	DEV_READ_FUNCPTR	DevRead;

	DevRead = FsmDataItemDevObjP->DevDrvP->FsmDevRead;
	MediaP = (FsmFlashMediaT *)FsmDataItemDevObjP->MediaObjP;

	paddr = DfsLsn2Psn(MediaP, *Lsn);
	paddr = DfsPsn2Addr(MediaP, paddr);

	if(paddr == (uint32)(-1))
	{
		return ERR_EOF;
	}

	sector_size = MediaP->SectorSize ;

	Count = *EntryCount + 1;

	entry_offset  = 0;
	ValidEntryCount = 0;

	while (Count > 0)
	{
		status = DevRead( FsmDataItemDevObjP,
						  (uint8 *)Entry,
						  paddr + sizeof(FsmFlashSectorHdrT) + entry_offset,
						  sizeof(FsmItemDirEntryT)
						  );

		if (status != ERR_NONE)
		{
			return status;
		}

		if (Entry->Status == ENTRY_VALID)
		{
			Count--;

			ValidEntryCount++;

			if(Count == 0)
			{
				*EntryCount = ValidEntryCount;
				return ERR_NONE;
			}
		}

		entry_offset += sizeof(FsmItemDirEntryT);

		if (entry_offset >= sector_size)
		{
			status = DevRead(FsmDataItemDevObjP,
							 (uint8 *)Lsn,
							 paddr + FIELD_OFFSET(FsmFlashSectorHdrT, NextLsn),
							 FIELD_SIZE(FsmFlashSectorHdrT, NextLsn)
							 );

			if(status != ERR_NONE)
			{
				return status;
			}

			if(*Lsn == (uint32)(-1))
			{
				return ERR_EOF;
			}

			paddr = DfsLsn2Psn(MediaP, *Lsn);
			paddr = DfsPsn2Addr(MediaP, paddr);

			if(paddr == (uint32)(-1))
			{
				return ERR_EOF;
			}

			entry_offset = 0;
			ValidEntryCount = 0;
		}
	}

	/*  program can't reach here. */
	return ERR_SYSTEM;
}

/* the Single instance read */
static uint32 ReadSingleInstance(
	uint32		FirstLsn, 
	uint32		offset, 
	uint8 *		buf, 
	uint32		size, 
	uint32 *	read_size
	)
{
	return DfsReadData(FsmDataItemDevObjP, buf, FirstLsn, offset, size, read_size);
}

/* The Multiple instance read function */
static uint32 ReadMultInstance(
	uint32		FirstLsn, 
	uint32		offset, 
	uint8 *		buf, 
	uint32		size, 
	uint32 *	read_size
	)
{
	uint32		status;

	uint16		InstanceStatus;
	uint16		InstanceLength;
	uint32		paddr;

	FsmFlashMediaT *	MediaP;
	DEV_READ_FUNCPTR	DevRead;

	uint32		Instances;
	uint32		InstIndex;

	*read_size = 0;

	MediaP  = (FsmFlashMediaT *)FsmDataItemDevObjP->MediaObjP;
	DevRead = FsmDataItemDevObjP->DevDrvP->FsmDevRead;

    paddr = DfsLsn2Psn(MediaP, FirstLsn);
	paddr = DfsPsn2Addr(MediaP, paddr);

	if(paddr == (uint32)(-1))
	{
        return ERR_SYSTEM;
	}

	paddr += sizeof(FsmFlashSectorHdrT);

	/* Get Instance Length */
	status = DevRead(FsmDataItemDevObjP,
					 (uint8 *)&InstanceLength,
					 paddr + FIELD_OFFSET(FsmMultiInstanceT, Length),
					 FIELD_SIZE(FsmMultiInstanceT, Length)
					 );

	if(status != ERR_NONE)
	{
#ifdef DEBUG_FSM
		MonPrintf("\nIn ReadMultInstance(), FsmDevRead Instance len Failed.");
#endif	
		return status;
	}

	if(offset >= (uint32)InstanceLength)
	{
		return ERR_PARAM;
	}

	/* calculate the item number in the Multi instance */
	Instances = MediaP->SectorSize - FIELD_SIZE(FsmMultiInstanceT, Length);
	Instances = Instances / (FIELD_SIZE(FsmMultiInstanceT, Status) + InstanceLength);

	InstIndex = 0;

	while (InstIndex < Instances)
	{
		InstanceStatus = 0;

		status = DevRead(FsmDataItemDevObjP, 
						 (uint8 *)&InstanceStatus, 
						 paddr + FIELD_OFFSET(FsmMultiInstanceT, Status[0])
							+ InstIndex * FIELD_SIZE(FsmMultiInstanceT, Status[0]), 
						 FIELD_SIZE(FsmMultiInstanceT, Status[0])
						 );

		if(status != ERR_NONE)
		{
#ifdef DEBUG_FSM
			MonPrintf("\n In ReadMultInstance(),FsmDevRead Instance Status Failed.");
#endif	
			return status;
		}

		if (InstanceStatus == INSTANCE_VALID)
		{
			break;
		}

		InstIndex++;
	}

	if (InstIndex >= Instances)
		return ERR_SYSTEM;

	paddr += FIELD_SIZE(FsmMultiInstanceT, Length);
	paddr += Instances * FIELD_SIZE(FsmMultiInstanceT, Status[0]);
	paddr += InstIndex * InstanceLength;
	paddr += offset;	/* offset into the instance. */

	if((size + offset) > (uint32)InstanceLength)
	{
		size = (uint32)InstanceLength - offset;
	}

	status = DevRead(FsmDataItemDevObjP, buf, paddr, size);

	if(status != ERR_NONE)
	{
#ifdef DEBUG_FSM
		MonPrintf("\n In ReadMultInstance(),FsmDevCopy Instance Failed.");
#endif
		return status;
	}

	*read_size = size;

	return ERR_NONE;
}

/*****************************************************************************
* $Log: FsmDataItem.c $
* Revision 1.3  2004/03/17 12:57:18  zgy
* Revision 1.15  2004/03/16 15:54:17  jjs
* Revision 1.14  2004/03/11 15:11:15  jjs
* added structure declaration of FsmDataItemDescriptorT
* Revision 1.13  2004/02/20 17:35:27  jjs
* Reserved some flash space for modification operation.
* Revision 1.12  2003/11/07 17:19:53  jjs
* LocateDataItem() is modified to search data item in queue regardless of existence in flash. 
* Revision 1.11  2003/11/05 11:37:08  jjs
* Revision 1.10  2003/11/05 11:10:32  jjs
* replace //
* Revision 1.8  2003/10/26 11:25:47  jjs
* Revision 1.7  2003/10/26 10:43:04  jjs
* Revision 1.6  2003/10/24 22:56:06  jjs
* Revision 1.5  2003/10/24 15:30:14  jjs
* Revision 1.4  2003/10/24 13:39:04  jjs
* Revision 1.3  2003/10/23 14:01:50  wsm
* Revision 1.2  2003/10/21 16:30:26  wsm
* Revision 1.1  2003/10/21 16:14:23  jjs
* Initial revision
* Revision 1.1  2003/09/30 15:06:58  wsm
* Initial revision
*****************************************************************************/