📄 my_640j3.c
字号:
/***************************************************
公司: 好易通科技有限公司
产品名: TETRA数字集群终端
CPU: OMAP5910
功能: 28F640J3C flash测试
作者: YuanLin
编写时间: 2004.12.31
修改时间： 2005.06.02
****************************************************/
#include "640J3.h"
#include "io.h"
#include "type.h"
//#include "Header.h"
#define BYTE_NUM 15
#define WRITE_FLASH_ADDR BLOCK_BASE_FLASH_ADDRESS
/****************************************************************************
* Function:
* This procedure is called to read,write,erase,lock and unlock operation.
*
* Parameters: None
*
* Returns: NONE
***************************************************************************/
/************ Flash Operate routine ************/
void TestFlash(void)
{
UINT16 i;
Flash_Status state;
UINT32 ManufactureCode;
BYTE *p_buffer;
BYTE buffer[BYTE_NUM] = {0x77, 0x77, 0x77, 0x77,
0x77, 0x77, 0x77, 0x77,
0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77};
p_buffer = &buffer[0]; //why can not use p_buffer = buffer
Flash_init();
/* Read Device ID */
ManufactureCode = ReadDeviceID( (UINT32 *)BASE_FLASH_ADDRESS );
asm (" NOP");
printf("\n-----the flash manufacture id is 0x%x\n", ManufactureCode);
for( i = 0; i < 40000; i++ ) /* Delay for next operation */
{
}
/* Erase all Blocks,all 64 blocks */
for ( i=0; i < TOTAL_NUMBLOCKS; i++ ) /* 64M bits memory,64 blocks */
{
state = EraseBlock( i );
if ( state.Result != StatCompleted )
{
break;
}
printf("The %dth block have been erased\n", i);
}
if( state.Result == StatCompleted )
{
if( !( state.SR & 0x0020 ) ) /* Status register NO.4 and NO.5 bit */
{
printf("\n-----All Blocks Successful Erase!\n");
}
else
{
printf("\n-----All Blocks Erase Error!\n");
}
}
else
{
if( !( state.SR & 0x0020 ) ) /* Status register NO.4 and NO.5 bit */
{
printf("\n-----All Blocks Successful Erase! But Time Over\n");
}
else
{
printf("\n-----All Blocks Erase Error and Time Over!\n");
}
}
/* Program , Write Data into Flash */
//i = 0xaa55; //0xaa55
//state = ProgramFlash( BLOCK_BASE_FLASH_ADDRESS, i );
//ManufactureCode = ReadFlash( BLOCK_BASE_FLASH_ADDRESS );
//ManufactureCode &= 0x0000ffff;
//Programming the flash with write buffer
state = ProgramFlashBuffered(WRITE_FLASH_ADDR, p_buffer, BYTE_NUM);
if(state.SR == 0x80)
{
printf("\n-----WriteBuffer Program Successful!\n");
}
else
{
printf("\n-----WriteBuffer Program Error!\n");
}
/*
if((ManufactureCode == i) && (state.Result == StatCompleted))
{
printf("\n-----Program Successful!\n");
}
else
{
printf("\n-----Program Error!\n");
}
*/
return;
}
/****************************************************************************
* Function:
* This procedure is called to read device ID.
*
* Parameters: pManufactureCode ---- The manufacture code
* pDeviceCode ---- The device code
*
* Returns: NONE
***************************************************************************/
/************ Read Device ID ************/
UINT32 ReadDeviceID( UINT32 *pManuCode )
{
UINT32 Deviceid;
WriteFlash( BASE_FLASH_ADDRESS, READ_ID_CODES ); /* Write read ID command 0x0090 */
Delay(1000);
//Flash_wpoff(); //turn off the write protect
Deviceid = ReadFlash( BASE_FLASH_ADDRESS ); /* Read Manufacture Code */
/* return device to read array mode */
WriteFlash( BASE_FLASH_ADDRESS, READ_ARRAY ); /* Enter into read array mode command 0x00ff */
return(Deviceid);
}
/* return device to read array mode */
// WriteFlash( BASE_FLASH_ADDRESS, READ_ARRAY ); /* Enter into read array mode command 0x00ff */
/* Flash_Stat.Result = StatCompleted;
return( Flash_stat ); */
/****************************************************************************
* Function:
* This procedure is called to read data(word).
*
* Parameters: address ---- The address which data read
* value ---- The data read
*
* Returns: NONE
***************************************************************************/
/************* Read Data *****************/
UINT32 ReadFlash( UINT32 address )
{
UINT32 fptr;
//fptr = ( UINT32_PTR )address;
//*pvalue = *fptr;
fptr = GetIo32(address);
return(fptr);
}
/****************************************************************************
* Function:
* This procedure is called to erase a block.
*
* Parameters: blocknum ---- The number of block
*
* Returns: stat ---- The state of flash
***************************************************************************/
/********************** Erase a Block ********************************/
Flash_Status EraseBlock( UINT16 blocknum )
{
Flash_Status stat;
UINT32 blockadd;
stat = GetBlockAddress( blocknum, &blockadd );
if ( stat.Result != StatCompleted )
{
return( stat );
}
WriteFlash( BASE_FLASH_ADDRESS, CLEAR_STATUS_REGISTER ); // address 0x0000,clear status register command 0x0050
// stat.SR = ReadStatus();
WriteFlash(blockadd, BLOCK_ERASE); // block erase 1st command 0x0020
WriteFlash(blockadd, CONFIRM); // block erase 2nd command 0x00d0
while((ReadStatus() != 0x0080));
stat.SR = ReadStatus();
/* return device to read array mode */
WriteFlash(BASE_FLASH_ADDRESS, READ_ARRAY ); /*Write 00FFH after the last
operation to reset the device to array mode*/
return( stat );
}
/****************************************************************************
* Function:
* This procedure is called to program a word.
*
* Parameters: address ---- The program address
* value ---- The program value
*
* Returns: None
***************************************************************************/
/*************** Program a data ************************/
void WriteFlash( UINT32 address, UINT16 value )
{
*(UINT16 *)address = value;
}
/****************************************************************************
* Function:
* This procedure is called to wait erase complete.
*
* Parameters: timeout ---- Erase time
*
* Returns: TRUE ---- Erase time OK
* FALSE ---- Erase time over
***************************************************************************/
/***************** Wait erase complete *****************/
BYTE WaitUntilReady( UINT16 timeout )
{
while( timeout )
{
if ( mIsStatusReady( ReadStatus() ) )
{
return( TRUE ); /* Have written finish, time doesn't be over */
}
timeout--;
}
return( FALSE );
}
/****************************************************************************
* Function:
* This procedure is called to read flash status.
*
* Parameters: None
*
* Returns: status ---- Read the flash status
***************************************************************************/
/****************** Read Status ********************/
UINT16 ReadStatus( void )
{
UINT16 status;
*(UINT16 *)0x0c120000 = 0x0070; //before: 0x0c000000
//Modified by wzhui, address = any address within the device
status = *(UINT16 *)0x0c120000;
// WriteFlash( BASE_FLASH_ADDRESS, READ_STATUS_REGISTER ); /* any address, this set 0x0000; read status command 0x0070 */
// status = ReadFlash( BASE_FLASH_ADDRESS ); /* any address, get status register state */
return( status );
}
/*********************** Erase Block Suspend ***********************/
Flash_Status EraseSuspend( UINT16 blocknum )
{
Flash_Status stat;
UINT32 blockaddr;
// UINT16 status;
stat = GetBlockAddress( blocknum, &blockaddr );
if ( stat.Result != StatCompleted )
{
return( stat );
}
WriteFlash( BASE_FLASH_ADDRESS, CLEAR_STATUS_REGISTER ); /* Clear status register */
WriteFlash( blockaddr, BLOCK_SUSPEND );
if ( !WaitUntilReady( PROGRAM_TIMEOUT ) )
{
stat.Result = StatTimeout;
}
else
{
stat.Result = StatCompleted;
}
stat.SR = ReadStatus();
/* return device to read array mode */
WriteFlash( BASE_FLASH_ADDRESS, READ_ARRAY );
return( stat );
}
/******************** Extended Query *****************/
Flash_Status ExtendedQuery( struct ExtQueryData *extquery )
{
Flash_Status stat;
struct Flash_QueryData query;
UINT32 item;
UINT32 addr;
UINT32 longitem;
UINT32 i;
UINT32 offset;
stat = Flash_Queryc( &query );
if ( stat.Result != StatCompleted )
{
return( stat );
}
offset = query.ExtTablePtr;
WriteFlash( BASE_FLASH_ADDRESS, READ_QUERY );
/* read extended query string */
for ( i=0; i < 3; i++ )
{
stat = GetQueryAddress( offset, &addr );
if ( stat.Result != StatCompleted )
{
return( stat );
}
// ReadFlash( addr, &item );
item &= 0xff;
extquery->ExtQueryStr[i] = (char)item;
offset++;
}
extquery->ExtQueryStr[3] = '\0'; /* null terminate string */
/* read major version number */
stat = GetQueryAddress( offset, &addr );
if ( stat.Result != StatCompleted )
{
return( stat );
}
// ReadFlash( addr, &item );
item &= 0xff;
extquery->MajorVersionNum = (BYTE)item;
offset++;
/* read minor version number */
stat = GetQueryAddress( offset, &addr );
if ( stat.Result != StatCompleted )
{
return( stat );
}
// ReadFlash( addr, &item );
item &= 0xff;
extquery->MinorVersionNum = (BYTE)item;
offset++;
extquery->OptionalFeature = 0;
for ( i=0; i < 4; i++ )
{
stat = GetQueryAddress( offset, &addr );
if ( stat.Result != StatCompleted )
{
return( stat );
}
// ReadFlash( addr, &item );
item &= 0xff;
longitem = (UINT32)((UINT32)item << (8*i));
extquery->OptionalFeature = (UINT32)( extquery->OptionalFeature | longitem );
offset++;
}
/* read after suspend functions */
stat = GetQueryAddress( offset, &addr );
if ( stat.Result != StatCompleted )
{
return( stat );
}
// ReadFlash( addr, &item );
item &= 0xff;
extquery->AfterSuspendFunctions = (BYTE)item;
offset++;
/* read vendor id */
extquery->BlockLockStatus = 0;
for ( i=0; i < 2; i++ )
{
stat = GetQueryAddress( offset, &addr );
if ( stat.Result != StatCompleted )
{
return( stat );
}
// ReadFlash( addr, &item );
item &= 0xff;
item = item << (8*i);
extquery->BlockLockStatus = (UINT16)( extquery->BlockLockStatus | item );
offset++;
}
/* read vcc optimum */
stat = GetQueryAddress( offset, &addr );
if ( stat.Result != StatCompleted )
{
return( stat );
}
// ReadFlash( addr, &item );
item &= 0xff;
extquery->VccOptimum = (BYTE)item;
offset++;
/* read vpp optimum */
stat = GetQueryAddress( offset, &addr );
if ( stat.Result != StatCompleted )
{
return( stat );
}
// ReadFlash( addr, &item );
item &= 0xff;
extquery->VppOptimum = (BYTE)item;
offset++;
stat.Result = StatCompleted;
/* return device to read array mode */
WriteFlash( BASE_FLASH_ADDRESS, READ_ARRAY );
return( stat );
}
/************************ Get Query Address *************************/
Flash_Status GetQueryAddress ( UINT32 offset, UINT32_PTR address )
{
Flash_Status stat;
*address = offset << 1;
*address += BASE_FLASH_ADDRESS;
stat.Result = StatCompleted;
return( stat );
}
/************************ Get Block Address *************************/
Flash_Status GetBlockAddress( UINT16 blocknum, UINT32 *address )
{
Flash_Status stat;
if ( blocknum < TOTAL_NUMBLOCKS ) /* 64 blocks */
{
*address = BASE_FLASH_ADDRESS + ( blocknum * BLOCK_NUMBYTES ); /* 1M bits/block */
}
else
{
stat.Result = StatBadBlock;
return( stat );
}
stat.Result = StatCompleted;
return( stat );
}
/******************** Set Block Lock bit *************************/
Flash_Status LockBlock( UINT16 blocknum )
{
Flash_Status stat;
UINT32 blockaddr;
stat = GetBlockAddress( blocknum, &blockaddr );
if ( stat.Result != StatCompleted )
{
return( stat );
}
WriteFlash( BASE_FLASH_ADDRESS, CLEAR_STATUS_REGISTER ); /* Clear status register */
WriteFlash( blockaddr, CONFIG_SETUP );
WriteFlash( blockaddr, LOCK_BIT_SET );
if ( !WaitUntilReady( PROGRAM_TIMEOUT ) )
{
stat.Result = StatTimeout;
}
else
{
stat.Result = StatCompleted;
}
stat.SR = ReadStatus();
/* return device to read array mode */
WriteFlash( BASE_FLASH_ADDRESS, READ_ARRAY );
return( stat );
}
/******************** Protect lock *************************/
Flash_Status LockProtection( void )
{
UINT32 baseadd;
UINT32 location;
UINT32 address;
Flash_Status stat;
location = PROTECTION_LOCK_LOCATION; /* 0 */
baseadd = BASE_FLASH_ADDRESS; /* 0 */
address = OTP_BASE + BASE_FLASH_ADDRESS; /* 256 ????? */
address += ( location * sizeof(UINT16) ); /* use word mode */
WriteFlash( BASE_FLASH_ADDRESS, CLEAR_STATUS_REGISTER ); /* Clear status register */
WriteFlash(baseadd, OTP_PROGRAM ); /* any address, 1st command 0x00c0 */
WriteFlash(address, OTP_LOCK); /* program address, 0xfffd */
if ( !WaitUntilReady( PROGRAM_TIMEOUT ) )
{
stat.Result = StatTimeout;
}
else
{
stat.Result = StatCompleted;
}
stat.SR = ReadStatus();
/* return device to read array mode */
WriteFlash(BASE_FLASH_ADDRESS, READ_ARRAY );
return( stat );
}
/************************ Enable Page Mode ***************************/
Flash_Status PageMode( UINT16 enable )
{
Flash_Status stat;
UINT32 address; /* contains the address to load the Read Configuration Register with */
if ( enable )
{
address = PAGE_READ_MODE;
}
else
{
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -