norflash_strata.c

s3c2410开发板的测试代码,包括lcd

/*
*********************************************************
* Copyright (c)
* All rights reserved.				            
*
* 文件名称：norflash_strata.c
* 文件标识：
* 摘    要：S3C2410 Intel Strata NOR Flash Test Program
* 当前版本：1.0
* 作    者：刘征
* 完成日期：2005.4.3
*
* 取代版本：
* 作    者：
* 完成日期：
*********************************************************
*/

/*
*********************************************************
*   					 头文件
*********************************************************
*/
#include <stdlib.h>
#include <string.h>
#include "def.h"
#include "option.h"
#include "2410addr.h"
#include "2410lib.h"
#include "2410slib.h"
#include "norflash_strata.h"

/*
*********************************************************
*  					  函数定义
*********************************************************
*/
static void InputAddresses(void);

static int  Strata_ProgFlash(U32 realAddr,U16 data);
static void Strata_EraseSector(int targetAddr);
static int  Strata_CheckID(int targetAddr);
static int  Strata_CheckDevice(int targetAddr);
static int  Strata_CheckBlockLock(int targetAddr);
static int  Strata_BlankCheck(int targetAddr,int targetSize);
static int  _WAIT(void);

/*
*********************************************************
*  					  宏定义
*********************************************************
*/
// Because S3C2410 is connected to Intel StrataFlash 28F128J3A,
// the addr parameter has to be a HAIFWORD address, so called in Intel specification.
// set nGcs1 = 16bit 
#define _WR(addr,data)  *((volatile U16 *)(addr))=(U16)data 
#define _RD(addr)       ( *((volatile U16 *)(addr)) )       
#define _RESET()    	_WR(targetAddress,0x00ff)
//#define TARGET_ADDR_28F128      0x08000000  // nGCS1, 128MB area
#define TARGET_ADDR_28F128      0x00000000  // nGCS0,
#define SOURCE_ADDR_FOR_28F128  0x31000000  // After 16MB of SDRAM
                                            // 0x30000000 - 0x30ffffff : Area for this test program

/*
*********************************************************
*  					  变量
*********************************************************
*/
static U32 downloadAddress;
static U32 downloadProgramSize;

static U32 srcAddress;
static U32 targetOffset; 
static U32 targetAddress; 
static U32 targetSize; 

static int error_erase=0;       // Read Status Register, SR.5
static int error_program=0;     // Read Status Register, SR.4

/*
*********************************************************
* 函数介绍：本函数读NOR FLASH ID 号。				
* 输入参数：targetAddr---目标地址
*           
* 输出参数：无
* 返回值  ：返回芯片ID号
*********************************************************
*/
int Strata_CheckID(int targetAddr) 
{
    //_RESET();
    _WR(targetAddr, 0x0090); 
    return _RD(targetAddr); // Read Identifier Code, including 16-bit, Intel Strate Flash ROM
                            // targetAddress must be the beginning location of a Block Address
}

/*
*********************************************************
* 函数介绍：本函数读NOR FLASH Device Code号。				
* 输入参数：targetAddr---目标地址
*           
* 输出参数：无
* 返回值  ：返回芯片Device Code号
*********************************************************
*/
int Strata_CheckDevice(int targetAddr) 
{
    //_RESET();
    _WR(targetAddr, 0x0090);
    return _RD(targetAddr+0x2); // Read Device Code, including 16-bit, Intel Strate Flash ROM
                                // targetAddress must be the beginning location of a Block Address
}

/*
*********************************************************
* 函数介绍：本函数读NOR FLASH Block Lock configuration。				
* 输入参数：targetAddr---目标地址
*           
* 输出参数：无
* 返回值  ：返回芯片Block Lock configuration
*********************************************************
*/
int Strata_CheckBlockLock(int targetAddr) 
{
    //_RESET();
    _WR(targetAddr, 0x0090);
    return _RD(targetAddr+0x8); // Read Block Lock configuration, 
                                // targetAddress must be the beginning location of a Block Address
}

/*
*********************************************************
* 函数介绍：本函数擦除NOR FLASH 扇区。				
* 输入参数：targetAddr---目标地址
*           
* 输出参数：无
* 返回值  ：无
*********************************************************
*/
void Strata_EraseSector(int targetAddress) 
{
    unsigned long ReadStatus;
    unsigned long bSR5;     // Erase and Clear Lock-bits Status, lower 16bit, 8MB Intel Strate Flash ROM
    unsigned long bSR7;     // Write State Machine Status, lower 16bit, 8MB Intel Strate Flash ROM
    //_RESET();
    _WR(targetAddress, 0x0020); // Block Erase, First Bus Cycle, targetAddress is the address withint the block
    _WR(targetAddress, 0x00d0); // Block Erase, Second Bus Cycle, targetAddress is the address withint the block
    
    //_RESET();
    _WR(targetAddress, 0x0070); // Read Status Register, First Bus Cycle, targetAddress is any valid address within the device
    ReadStatus=_RD(targetAddress);  // Read Status Register, Second Bus Cycle, targetAddress is any valid address within the device
    bSR7=ReadStatus & (1<<7);       // lower 16-bit 8MB Strata
    while(!bSR7) 
    {
      //  _WR(targetAddress, 0x0070);
        ReadStatus=_RD(targetAddress);
        bSR7=ReadStatus & (1<<7);
//      Uart_Printf("wait !!\n");
    }

    _WR(targetAddress, 0x0070); // When the block erase is complete, status register bit SR.5 should be checked. 
                    // If a block erase error is detected, the status register should be cleared before
                    // system software attempts correct actions.
    ReadStatus=_RD(targetAddress);  
    bSR5=ReadStatus & (1<<5);           // lower 16-bit 8MB Strata 
    if (bSR5==0) 
    {
        Uart_Printf("Block_%x Erase O.K. \n",targetAddress);
    } 
    else 
    {
        //Uart_Printf("Error in Block Erasure!!\n");
        _WR(targetAddress, 0x0050); // Clear Status Register
        error_erase=1;                  // But not major, is it casual ?
    }

    _RESET();   // write 0xffh(_RESET()) after the last opoeration to reset the device to read array mode.
}

/*
*********************************************************
* 函数介绍：本函数校验NOR FLASH 数据。				
* 输入参数：targetAddr---目标地址
*           targetSize---目标大小
* 输出参数：无
* 返回值  ：0--正确
*           1--失败
*********************************************************
*/
int Strata_BlankCheck(int targetAddr,int targetSize) 
{
    int i,j;
    for (i=0; i<targetSize; i+=2) 
    {
        j=*((volatile U16 *)(i+targetAddr));
        if (j!=0xffff)      // In erasure it changes all block dta to 0xff
        {
            Uart_Printf("E : %x = %x\n", (i+targetAddr), j);
            return 0;
        }
    }
    return 1;
}

/*
*********************************************************
* 函数介绍：本函数写数据进入NOR FLASH 扇区。				
* 输入参数：realAddr---目标地址
*           data---数据
* 输出参数：无
* 返回值  ：0
*********************************************************
*/
int Strata_ProgFlash(U32 realAddr,U16 data) 
{
    unsigned long ReadStatus;
    unsigned long bSR4;    // Erase and Clear Lock-bits Status, lower 16bit, 8MB Intel Strate Flash ROM
    unsigned long bSR7;    // Write State Machine Status, lower 16bit, 8MB Intel Strate Flash ROM

    //_RESET();

    _WR(realAddr, 0x0040);  // realAddr is any valid adress within the device
                                // Word/Byte Program(or 0x0010 can be used)
    _WR(realAddr, data);// 16 bit data
    
    //_RESET();
    _WR(realAddr, 0x0070);  // Read Status Register
    ReadStatus=_RD(realAddr);   // realAddr is any valid address within the device
    bSR7=ReadStatus & (1<<7);
    while(!bSR7) 
    {
        // _RESET();
        _WR(realAddr, 0x0070);        // Read Status Register
        ReadStatus=_RD(realAddr);
        bSR7=ReadStatus & (1<<7);
    }
    
    _WR(realAddr, 0x0070); 
    ReadStatus=_RD(realAddr);             // Real Status Register
    bSR4=ReadStatus & (1<<4);
    
    if (bSR4==0) 
    {
        Uart_Printf("Successful Program!!\n");
    } 
    else 
    {
        Uart_Printf("Error Program!!\n");
        _WR(realAddr, 0x0050);          // Clear Status Register
        error_program=1;                    // But not major, is it casual ?
    }
    _RESET();
    return 0;
}

/*
*********************************************************
* 函数介绍：本函数是NOR FLASH 28F128J3A 编程测试函数。				
* 输入参数：无
* 输出参数：无
* 返回值  ：无
*********************************************************
*/
void Program28F128J3A(void)
{
// FlashROM write program must reside at RAM region NOT ROM region
// In reading and writing all interrupts are disabled because the flash ROM
// strongly dislike to be disturbed by other stuff.
// And the region of flash ROM must be I/O region which means NO cacheable
// and NO bufferable in MMU. Check it out !!!

    unsigned long interrupt_reservoir;
    int i;
    
    downloadAddress=0x31000000;
    downloadProgramSize=0x0;

    printf("\n[28F128J3A Flash JTAG Programmer (16bits)]\n");
    
    rINTMSK = BIT_ALLMSK; //close all intterupt  
    targetAddress=TARGET_ADDR_28F128;
    targetSize=downloadProgramSize;

    if(targetSize==0)
    {
        srcAddress=downloadAddress; 
    }
    else
    { 
        srcAddress=downloadAddress+4; //to discard the data head for the size
    }
        
    InputAddresses(); //srcAddress,targetSize,targetOffset will be determined.      
    Uart_Printf("Source base address(0x31000000) = 0x%x\n",srcAddress);
    Uart_Printf("Target base address(0x00000000) = 0x%x\n",targetAddress);
    Uart_Printf("Target offset      (0x0)        = 0x%x\n",targetOffset);
    Uart_Printf("Target size        (0x20000*n)  = 0x%x\n",targetSize);//128K

    if ( (Strata_CheckID(targetAddress) & 0xffff) != 0x0089 )       // ID number = 0x0089
    {
        Uart_Printf("Identification check error !!\n");
        return ;
    }

    if ( (Strata_CheckDevice(targetAddress) & 0xffff) != 0x0018 )   // Device number=0x0018
    {
        Uart_Printf("Device check error !!\n");
        return ;
    }

    Uart_Printf("\nErase the sector : 0x%x.\n", targetAddress);

    for(i=0;i<targetSize;i+=0x20000)
    {
        Strata_EraseSector(targetAddress+targetOffset+i);
    }
    
    if(!Strata_BlankCheck(targetAddress+targetOffset,targetSize))
    {
        Uart_Printf("Blank Check Error!!!\n");
        return;
    }

    Uart_Printf("\nStart of the data writing...\n");

    for (i=0; i<targetSize; i+=2) 
    {
        Strata_ProgFlash(i+targetAddress+targetOffset, *((U16 *)(srcAddress+i)));
        if(i%0x10000==0xfffc)
            Uart_Printf("[%x]",(i+2)/0x10000);
    }
    Uart_Printf("\nEnd of the data writing \n");

    _RESET();

    Uart_Printf("Verifying Start...\n");
    for (i=0; i<targetSize; i+=2) 
    {
        if (*((U16 *)(i+targetAddress+targetOffset)) !=*((U16 *)(srcAddress+i))) //校验如果数据不符将数据输出
        {
            Uart_Printf("verify error  src %08x = %08x\n", srcAddress+i, *((U16 *)(srcAddress+i)));
            Uart_Printf("verify error  des %08x = %08x\n", i+targetAddress+targetOffset, *((U16 *)(i+targetAddress)));
            return;
        }
    }
    Uart_Printf("Verifying End!!!\n");
}

/*
*********************************************************
* 函数介绍：本函数是输入NOR FLASH 目标地址、大小。				
* 输入参数：无
* 输出参数：无
* 返回值  ：无
*********************************************************
*/
static void InputAddresses(void)
{
    Uart_Printf("\n[ 28F128J3A Writing Program ]\n");

    Uart_Printf("\nSource size [0x?] : 0h~%xh\n",downloadProgramSize);
    Uart_Printf("\nAvailable Target Offset Address [0x?] : \n"); 
    Uart_Printf("0h,20000h,40000h, ..., 1000000h\n");
    Uart_Printf("Input target address offset [0x?] : ");
    targetOffset=Uart_GetIntNum()+0x800000;//从16M字节的后8M字节开是写数据，避免从0X00000开始写数据将已烧录的BOOTLOAD程序擦除
    if(targetSize==0)
    {
        Uart_Printf("Input target size [0x?] : ");
        targetSize=Uart_GetIntNum();//输入数据大小
    }
}