intel_p30_2x16.c

EP9315的wince下载程序。download.exe

//**********************************************************************
//                                                                      
// Filename: intel_j3_2x16.c
//                                                                      
// Description: Routines for programming the Intel J3 flash 2x16.
//
// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
// PARTICULAR PURPOSE.
//
// Use of this source code is subject to the terms of the Cirrus end-user
// license agreement (EULA) under which you licensed this SOFTWARE PRODUCT.
// If you did not accept the terms of the EULA, you are not authorized to 
// use this source code. For a copy of the EULA, please see the 
// EULA.RTF on your install media.
//
// Copyright(c) Cirrus Logic Corporation 2005, All Rights Reserved                       
//                                                                      
//**********************************************************************
#include<windows.h>
#include<hwdefs.h>
#include<halether.h>
#include<debugtimer.h>
#include"flash.h"

#include"intel_p30_2x16.h"



//
// Flash commands.
//
#define     FLASH_BLOCK_SIZE            0x40000
#define     FLASH_BLOCK_MASK            ~(FLASH_BLOCK_SIZE - 1)
#define     FLASH_BUFFER_SIZE           64

//
//
//
#define     FLASH_READ_MODE             0x00FF00FF
#define     FLASH_BLOCK_ERASE           0x00200020
#define     FLASH_CLEAR_STATUS          0x00500050
#define     FLASH_BLOCK_ERASE_RESUME    0x00d000d0
#define     FLASH_BLOCK_PROGRAM_RESUME  0x00d000d0
#define     FLASH_WRITE_TO_BUFFER       0x00E800E8
#define     FLASH_READ_STATUS           0x00700070
#define     FLASH_LOCK_BIT              0x00600060
#define     FLASH_LOCK_SET              0x00010001
#define     FLASH_LOCK_CLEAR            0x00d000d0


#define	  FLASH_READ_ID_CODES                   		0x00900090
#define     FLASH_READ_QUERY                      		0x00980098

#define     STATUS_WRITE_READY          0x00800080
#define     EXT_STATUS_WBUFFER_READY    0x00800080


//
//
//
static DWORD    gdwStartAddr            = 0;
static DWORD    gdwLength               = 0;
static volatile PULONG  gpulCurAddr     = 0;
static BOOL     gbFlashEraseComplete    = FALSE;
static BOOL     gbUnlocked              = TRUE;

static DWORD				gdwFlashSize			=0;
static DWORD                      gdwManufactureId		=0;
struct EraseBlockInfo       	sBlockInfo[4];
static DWORD				gdwNumEraseRegion		=0;
static DWORD				gdwCurEraseRegion		=0;
static DWORD				gdwCurEraseBlock		=0;
static DWORD				gdwCurEraseBlockMask	=0;
static DWORD				gdwFlashBufferSize		=64;

//
// Function prototypes
//
static int  WaitForReady(volatile ULONG *pFlash, ULONG ulTimeoutInMsec, ULONG ulBitField);

BOOL  GotEraseFlashSectorIndex_P30_2X16(DWORD dwStartAddr)
{
   DWORD i,j,dwEraseLen;

   dwEraseLen = dwStartAddr-FLASH_VIRTUAL_MEMORY;
   
    for(i = 0; i <gdwNumEraseRegion; i++) 
   {
        for(j = 0; j< sBlockInfo[i].blocks; j++) 
	{

            if(dwEraseLen > sBlockInfo[i].block_size) 
	    {
                dwEraseLen = dwEraseLen - sBlockInfo[i].block_size;
               
            } 
	     else if(dwEraseLen ==sBlockInfo[i].block_size)
	     {
                gdwCurEraseRegion = i;
		  gdwCurEraseBlock    = j;
		  
                return TRUE;
            }
	     else 
	     {
                gdwCurEraseRegion = i;
		  gdwCurEraseBlock    = j;
		  
                return FALSE;
            }

         }
    }




   return FALSE;

}

DWORD GetEraseFlashBlockSize_P30_2X16(void)
{
    DWORD dwBlockSize;

    dwBlockSize = sBlockInfo[gdwCurEraseRegion].block_size;

    return dwBlockSize;

}

BOOL QueryIntelFlashP30_2x16(void)
{
	DWORD iIdx = 0;
	
	gpulCurAddr	= (unsigned long*)PHYSICAL_ADDR_FLASH_INTEL;
	//
	// Query 16 bitwidth id.
	//
        *gpulCurAddr 		= FLASH_READ_ID_CODES;
        gdwManufactureId 	= *gpulCurAddr;

	//
       // Query 16 bitwidth flash.
       //
        *gpulCurAddr 			= FLASH_READ_QUERY;
	
        gdwFlashSize			= 1 << (*(gpulCurAddr + 0x27) & 0xFF);
	 gdwFlashSize			=gdwFlashSize*2;
	 
        gdwNumEraseRegion 	= *(gpulCurAddr + 0x2c) & 0xFFFF;

        for(iIdx = 0; iIdx < gdwNumEraseRegion; iIdx++)
	{
            sBlockInfo[iIdx].blocks = (*(gpulCurAddr + 0x2d + (iIdx<<2)) & 0xFFFF) + 1;

	     sBlockInfo[iIdx].block_size =
                (((*(gpulCurAddr + 0x30 + (iIdx<<2)) & 0xFFFF) << 8) +
                (*(gpulCurAddr + 0x2f + (iIdx<<2)) & 0xFFFF)) << 8;
        }

	//
       // Put the FLASH into read array mode.
       //
        *gpulCurAddr = FLASH_READ_MODE;

	if((gdwManufactureId == 0x00890089)||((gdwManufactureId == 0x002c002c)))
	{
		return TRUE;
	}
	else
		return FALSE;

}



//****************************************************************************
//  StartEraseFlashJ3_2x16
//****************************************************************************
//  dwStartAddr - Start address, in flash, to start erasing from. The 
//                platform loader code needs to ensure this is a flash 
//                block-aligned address or needs to handle it specially if 
//                it is not. 
//
//  dwLength    - Number of bytes of flash to be erased. 
//
//  return      TRUE indicates success. FALSE indicates failure.
//
BOOL StartEraseFlashP30_2x16 (DWORD dwStartAddr, DWORD dwLength )
{
    //
    // Make sure that the flash addresses are valid.
    //
    if(dwStartAddr + dwLength > FLASH_VIRTUAL_MEMORY + gdwFlashSize  || 
       dwStartAddr < FLASH_VIRTUAL_MEMORY)
    {
        EdbgOutputDebugString
        (
            "ERROR: No Flash located in the locations from %x to %xr\r\n",
            dwStartAddr,
            dwLength
        );
        return FALSE;
    }

    //
    // Check to make sure that the flash is on a Block boundary.
    //
    if(GotEraseFlashSectorIndex_P30_2X16(dwStartAddr))
    {

        EdbgOutputDebugString
        (
            "ERROR: Address %x is not on a flash block boundary.\r\n",
            dwStartAddr
        );
        return FALSE;
    }

    //
    // Save off the start address and the length.
    //
    gdwStartAddr    = dwStartAddr;
    gdwLength       = dwLength;
    gpulCurAddr     = (PULONG) dwStartAddr;


    //
    // Put the flash in read mode to make sure that we are not in the middle 
    // of a command.
    //
    *gpulCurAddr = FLASH_READ_MODE;

    // DelayInuSec(500);


    //
    // Clear the lock bit.
    //
    *gpulCurAddr = FLASH_LOCK_BIT;
    *gpulCurAddr = FLASH_LOCK_CLEAR;
    *gpulCurAddr = FLASH_READ_STATUS;
    gbUnlocked  = TRUE;


    return TRUE;
}

//****************************************************************************
// ContinueEraseFlashJ3_2x16
//****************************************************************************
// Continues the flash erasing processes for J3 Flash.  See 
// OEMContinueEraseFlash for Parameter description.
// 
//
void ContinueEraseFlashP30_2x16(void)
{
    //
    // Check to see if the flash has been completely erased. If so just
    // return.
    //
    if(gbFlashEraseComplete)
    {
        return;
    }

    //
    // Check to see if the last block has been erased.
    //
    if((*gpulCurAddr & EXT_STATUS_WBUFFER_READY) != EXT_STATUS_WBUFFER_READY)
    {
        return;
    }

    //
    // Clear Status.
    //
    *gpulCurAddr  = FLASH_CLEAR_STATUS;


    if(gbUnlocked)
    {
        //
        // Erase the flash block
        //
        *gpulCurAddr = FLASH_BLOCK_ERASE;
        *gpulCurAddr = FLASH_BLOCK_ERASE_RESUME;

        //
        // Read erase status.
        //
        *gpulCurAddr = FLASH_READ_STATUS;
        gbUnlocked   = FALSE;
    }
    else
    {
        //
        // Check to see if we have finished erasing the flash memory.
        //
        if(gdwStartAddr + gdwLength < ((DWORD)gpulCurAddr) + sBlockInfo[gdwCurEraseRegion].block_size)
        {
            gbFlashEraseComplete = TRUE;
            return;
        }

        //
        // Advance to the next block.
        //
        //gpulCurAddr+= FLASH_BLOCK_SIZE>>2;
        gpulCurAddr+= sBlockInfo[gdwCurEraseRegion].block_size>>2;

	//
	//go to the next bloxk
	//
	 gdwCurEraseBlock = gdwCurEraseBlock+1;
	 if(gdwCurEraseBlock>=sBlockInfo[gdwCurEraseRegion].blocks)
	 {
		gdwCurEraseBlock=0;
		gdwCurEraseRegion=gdwCurEraseRegion+1;
		//
		//return error the current postiotn > the Flash MAX length
		//
		if(gdwCurEraseRegion>=gdwNumEraseRegion)
			return ;
	 }

	 
        //
        // Clear the lock bits if the flash block was locked.
        //
        *gpulCurAddr = FLASH_LOCK_BIT;
        *gpulCurAddr = FLASH_LOCK_CLEAR;
        *gpulCurAddr = FLASH_READ_STATUS;

        gbUnlocked  = TRUE;
    }
}

//****************************************************************************
// FinishEraseFlashJ3_2x16
//****************************************************************************
// Finishes the flash eraseing processes for J3 Flash.  See 
// OEMFinishEraseFlash for paramter description.
//
BOOL  FinishEraseFlashP30_2x16 (void)
{
    BOOL    bSuccess;
    //
    // Check to see if the flash has been completely erased. If so just
    // return.
    //
    if(gbFlashEraseComplete)
    {
        return TRUE;
    }

    //
    // Wait for the Flash block command to succeed.
    //
    bSuccess = WaitForReady(gpulCurAddr, 10000, EXT_STATUS_WBUFFER_READY);
    if(bSuccess == FALSE)
    {
        return FALSE;
    }
    *gpulCurAddr  = FLASH_CLEAR_STATUS;


    //
    // Erase the block before unlocking the next block.
    //
    if(gbUnlocked)
    {
        //
        // Erase the flash block
        //
        *gpulCurAddr = FLASH_BLOCK_ERASE;
        *gpulCurAddr = FLASH_BLOCK_ERASE_RESUME;

        //
        // Read erase status.
        //
        *gpulCurAddr = FLASH_READ_STATUS;

        //
        // Wait for the Flash block command to succeed.
        //
        bSuccess = WaitForReady(gpulCurAddr, 10000, EXT_STATUS_WBUFFER_READY);
        if(bSuccess == FALSE)
        {
            return FALSE;