flashdrv.c

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

			dst_byte_ptr++;
			src_byte_ptr++;
			init_unaligned_bytes--;
			dst_offset++;
		}
		if(dst_offset < sizeof(FLASH_DATA))
		{
			FsmMemoryMove((BYTE_PTR)dst_byte_ptr, 
						  ((BYTE_PTR)dst_data_ptr) + dst_offset,
						  sizeof(FLASH_DATA) - dst_offset);
		}

		/* write to flash */
		do
		{
			DISABLE_INTERRUPTS();
			status = pLowerWrite(dst_data_ptr, &temp_data, status);
			ENABLE_INTERRUPTS();
		} while (status == HW_ERR_SUSPEND);

		/* update pointers */
		dst_data_ptr++;
		dst_offset = 0;
		dst_byte_ptr = (BYTE_PTR) &temp_data;
	}


	/* write aligned data */
	src_data_ptr = (FLASH_DATA_PTR) src_byte_ptr;

	while ((length >= sizeof(FLASH_DATA)) && (status == HW_ERR_NONE))
	{
		/* write to flash */
		do
		{
			DISABLE_INTERRUPTS();
			status = pLowerWrite(dst_data_ptr, src_data_ptr, status);
			ENABLE_INTERRUPTS();
		} while (status == HW_ERR_SUSPEND);

		/* update pointers */
		dst_data_ptr++;
		src_data_ptr++;

		length -= sizeof(FLASH_DATA);
	}

	/* write remaining unaligned bytes */
	if ((length > 0) && (status == HW_ERR_NONE))
	{
		src_byte_ptr = (BYTE_PTR) src_data_ptr;
		dst_byte_ptr = (BYTE_PTR) &temp_data;

		FsmMemoryMove((BYTE_PTR)dst_byte_ptr + length, 
					  ((BYTE_PTR)dst_data_ptr) + length, 
					  sizeof(FLASH_DATA) - length);

		/* fill temp buffer with data */
		while (length > 0)
		{
			*dst_byte_ptr = *src_byte_ptr;
			dst_byte_ptr++;
			src_byte_ptr++;
			length--;
		}

		/* write to flash */
		do
		{
			DISABLE_INTERRUPTS();
			status = pLowerWrite(dst_data_ptr, &temp_data, status);
			ENABLE_INTERRUPTS();
		} while (status == HW_ERR_SUSPEND);
	}

	/* post flash write mutex, and return */
	FsmReleaseMtxSem(pDev->DevWriteLock);

	return status;
}


/******************************************************************************
 * FsmFlashErase()
 *
 * descriptions:
 *   erase a flash block.
 *
 * parameters:
 *    FsmDevObjHdrT * DevObjP - device object
 *    uint32 Addr - The starting address of the flash block to be erased.
 *
 * return:
 *   HW_ERR_NONE,  HW_ERR_SYSTEM, HW_ERR_PARAM, HW_ERR_ERASE.
 *
 *****************************************************************************/

uint32 FsmFlashErase(FsmDevObjHdrT * DevObjP, uint32 Addr)
{
	FLASH_DATA_PTR	flash_ptr;
	uint32			status;

	FsmFlashDevT *	pDev;


	pDev = (FsmFlashDevT *)DevObjP;

	/* power loss simulation for testing purposes */

	/* validate address */
#ifdef VALIDATE_ADDRESS

	if(Addr > (pDev->BlockSize * pDev->Blocks))
	{
		return HW_ERR_PARAM;
	}

#endif //VALIDATE_ADDRESS

	Addr += pDev->DevStartAddr;


	/* Align address */
	flash_ptr = (FLASH_DATA_PTR) ALIGN_ADDRESS(Addr);

	/* take flash erase mutex */
	if(FsmGetMtxSem(pDev->DevEraseLock) != ERR_NONE)
	{
		if(FsmStarting == FALSE)
			return HW_ERR_SYSTEM;
	}

	/* 
	* If flash is in PROGRAM suspend mode, 
	* then we should wait until the PROGRAM
	* operation complete.
	*/
	while(TRUE)
	{
		DISABLE_INTERRUPTS();
		status = (pLowerReadStat(flash_ptr)) & FLASH_STATUS_WRITE_SUSPENDED;
		ENABLE_INTERRUPTS();

		if(status == FLASH_STATUS_WRITE_SUSPENDED)
		{
			TASK_SLEEP(10);
		}
		else
			break;
	}

	status = HW_ERR_NONE;

	/* perform erase */
	do
	{
		DISABLE_INTERRUPTS();
		status = pLowerErase(flash_ptr, status);
		ENABLE_INTERRUPTS();
	} while (status == HW_ERR_SUSPEND);

	/* post flash erase mutex */
	FsmReleaseMtxSem(pDev->DevEraseLock);

	return status;
}

/******************************************************************************
 * FsmFlashCopy()
 *
 * descriptions:
 *   copy data from one flash location to another.
 *
 * parameters:
 *    FsmDevObjHdrT * DevObjP - device object
 *    uint32 DstAddr - The starting address within flash to copy data to.
 *    uint32 SrcAddr - The starting address within flash to read the data from.
 *    uint32 length - The amount of data, in bytes, to be copied.
 * 
 *
 * return:
 *   HW_ERR_NONE.
 *
 *****************************************************************************/

uint32 FsmFlashCopy(FsmDevObjHdrT * DevObjP, uint32 DstAddr, uint32 SrcAddr, uint32 length)
{
	FLASH_DATA_PTR	src_data_ptr;
	FLASH_DATA_PTR	dst_data_ptr;

	uint8 *			src_byte_ptr;
	uint8 *			dst_byte_ptr;

	uint32			src_offset;
	uint32			dst_offset;

	uint32			init_unaligned_bytes;
	FLASH_DATA		temp_data;

	uint32			status = HW_ERR_NONE;

	FsmFlashDevT *	pDev;


	pDev = (FsmFlashDevT *)DevObjP;

	/* power loss simulation for testing purposes */

	/* validate address */
#ifdef VALIDATE_ADDRESS

	if((SrcAddr + length) > (pDev->BlockSize * pDev->Blocks))
	{
		return HW_ERR_PARAM;
	}

	if((DstAddr + length) > (pDev->BlockSize * pDev->Blocks))
	{
		return HW_ERR_PARAM;
	}


#endif //VALIDATE_ADDRESS

	SrcAddr += pDev->DevStartAddr;
	DstAddr += pDev->DevStartAddr;


	/* return if nothing to write */
	if (length == 0)
	{
		return HW_ERR_NONE;
	}

	/* align addresses & determine address offset */
	dst_data_ptr = (FLASH_DATA_PTR) ALIGN_ADDRESS(DstAddr);
	src_offset   = UNALIGNED_BYTES(SrcAddr);
	dst_offset   = UNALIGNED_BYTES(DstAddr);
	dst_byte_ptr = (uint8 *) &temp_data + dst_offset;

	/* calculate the number of initial unaligned bytes */
	if (src_offset == dst_offset)
	{
		if (dst_offset == 0)
		{
			init_unaligned_bytes = 0;
		}
		else
		{
			init_unaligned_bytes = GET_MIN(length, sizeof(FLASH_DATA) - dst_offset);
		}
	}
	else
	{
		init_unaligned_bytes = length;
	}
	
	length -= init_unaligned_bytes;

	/* take flash write mutex. */
	if(FsmGetMtxSem(pDev->DevWriteLock) != ERR_NONE)
	{
		if(FsmStarting == FALSE)
			return HW_ERR_SYSTEM;
	}

	/*
	* write initial unaligned data, or all data if source and destination
	* addresses do not have the same offset
	*/
	src_byte_ptr = (BYTE_PTR) SrcAddr;

	while ((init_unaligned_bytes > 0) && (status == HW_ERR_NONE))
	{
		if(dst_offset != 0)
		{
			FsmMemoryMove((BYTE_PTR)(&temp_data), (BYTE_PTR)dst_data_ptr, dst_offset);
		}
		while ((dst_offset < sizeof(FLASH_DATA)) && (init_unaligned_bytes > 0))
		{
			*dst_byte_ptr = *src_byte_ptr;
			dst_byte_ptr++;
			src_byte_ptr++;
			init_unaligned_bytes--;
			dst_offset++;
		}
		if(dst_offset < sizeof(FLASH_DATA))
		{
			FsmMemoryMove((BYTE_PTR)dst_byte_ptr, 
						  ((BYTE_PTR)dst_data_ptr) + dst_offset,
						  sizeof(FLASH_DATA) - dst_offset);
		}

		status = HW_ERR_NONE;

		/* write to flash */
		do
		{
			DISABLE_INTERRUPTS();
			status = pLowerWrite(dst_data_ptr, &temp_data, status);
			ENABLE_INTERRUPTS();
		} while (status == HW_ERR_SUSPEND);

		/* update pointers */
		dst_data_ptr++;
		dst_offset = 0;
		dst_byte_ptr = (BYTE_PTR) &temp_data;
	}


	/* write aligned data */
	src_data_ptr = (FLASH_DATA_PTR) src_byte_ptr;
	while ((length >= sizeof(FLASH_DATA)) && (status == HW_ERR_NONE))
	{
		/* write to flash */
		do
		{
			temp_data = *src_data_ptr;

			DISABLE_INTERRUPTS();
			status = pLowerWrite(dst_data_ptr, &temp_data, status);
			ENABLE_INTERRUPTS();
		} while (status == HW_ERR_SUSPEND);

		/* update pointers */
		dst_data_ptr++;
		src_data_ptr++;
		length -= sizeof(FLASH_DATA);
	}

	/* write remaining unaligned bytes */
	if ((length > 0) && (status == HW_ERR_NONE))
	{
		src_byte_ptr = (BYTE_PTR) src_data_ptr;
		dst_byte_ptr = (BYTE_PTR) &temp_data;


		FsmMemoryMove((BYTE_PTR)dst_byte_ptr + length, 
					  ((BYTE_PTR)dst_data_ptr) + length, 
					  sizeof(FLASH_DATA) - length);

		/* fill temp buffer with data */
		while (length > 0)
		{
			*dst_byte_ptr = *src_byte_ptr;
			dst_byte_ptr++;
			src_byte_ptr++;
			length--;
		}

		/* write to flash */
		do
		{
			DISABLE_INTERRUPTS();
			status = pLowerWrite(dst_data_ptr, &temp_data, status);
			ENABLE_INTERRUPTS();
		} while (status == HW_ERR_SUSPEND);
	}

	/* post flash write mutex, and return */
	FsmReleaseMtxSem(pDev->DevWriteLock);

	return status;
}

/******************************************************************************
 * FsmFlashCtrl()
 *
 * descriptions:
 *   flash driver io control.
 *
 * parameters:
 *    FsmDevObjHdrT * DevObjP - device object
 *    uint32 CtrlCode - command to be executed.
 *    void *arg - argument that is command specified
 *
 * return:
 *   HW_ERR_NONE.
 *
 *****************************************************************************/

uint32 FsmFlashCtrl(FsmDevObjHdrT * DevObjP, uint32 CtrlCode, void *arg)
{
	return HW_ERR_NONE;
}

/*****************************************************************************
* $Log: flashdrv.c $
* Revision 1.4  2004/03/17 12:58:03  zgy
* Revision 1.8  2004/03/16 15:56:21  jjs
* Revision 1.7  2003/10/27 09:51:14  jjs
* included the intel flash command & status definitions.
* Revision 1.6  2003/10/16 11:25:06  jjs
* Revision 1.5  2003/10/15 18:40:45  jjs
* Revision 1.4  2003/09/12 14:20:39  jjs
* Revision 1.3  2003/09/12 14:14:34  jjs
* Revision 1.2  2003/09/12 11:52:05  jjs
* Revision 1.1  2003/09/09 15:07:32  jjs
* Initial revision
*****************************************************************************/