intel_c3_1x16.c

EP9315的wince下载程序。download.exe

//**********************************************************************
//                                                                      
// Filename: intelj3_1x16.c
//                                                                      
// Description: Flashing program for intel j3.  One j3 flash chips
//  in 16 bit mode.
//
// 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 "intel_c3_1x16.h"


//
// Definitions for Flash erasing.
//
#define     FLASH_BLOCK_SIZE            0x20000
#define     FLASH_BLOCK_MASK            ~(FLASH_BLOCK_SIZE - 1)
#define     FLASH_BUFFER_SIZE           32

//
//Flash cmd and status
//
#define     FLASH_READ_MODE             				0x00FF
#define     FLASH_BLOCK_ERASE           				0x0020
#define     FLASH_CLEAR_STATUS          				0x0050
#define     FLASH_BLOCK_ERASE_RESUME    			0x00d0
#define     FLASH_BLOCK_PROGRAM_RESUME  		0x00d0
#define     FLASH_WRITE_TO_BUFFER       			0x00E8
#define     FLASH_READ_STATUS           				0x0070
#define     FLASH_LOCK_BIT              				0x0060
#define     FLASH_LOCK_SET              				0x0001
#define     FLASH_LOCK_CLEAR            				0x00d0

#define	  FLASH_READ_ID_CODES                   		0x0090
#define     FLASH_READ_QUERY                      		0x0098

#define     STATUS_WRITE_READY          0x0080
#define     EXT_STATUS_WBUFFER_READY    0x0080

//
//
//
static DWORD    			gdwStartAddr            		= 0;
static DWORD    			gdwLength               		= 0;
static volatile PUSHORT  	gpusCurAddr    			= 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		=0;

//
// Private functions.
//
static BOOL  WaitForReady(volatile USHORT *pusFlash, ULONG ulTimeoutInMsec, USHORT ulBitField);


BOOL  GotEraseFlashSectorIndex(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(void)
{
    DWORD dwBlockSize;

    dwBlockSize = sBlockInfo[gdwCurEraseRegion].block_size;

    return dwBlockSize;

}

BOOL QueryIntelFlashC3_1x16(void)
{
	DWORD iIdx = 0;
	
	gpusCurAddr	= (unsigned short*)PHYSICAL_ADDR_FLASH_INTEL;
	//
	// Query 16 bitwidth id.
	//
        *gpusCurAddr 		= FLASH_READ_ID_CODES;
        gdwManufactureId 	= *gpusCurAddr;

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

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

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

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

        EdbgOutputDebugString
        (
            "Flash Query: Nor Flash ID %x,size %x \r\n",
            gdwManufactureId,gdwFlashSize
        );

	if((gdwManufactureId == 0x0089)||((gdwManufactureId == 0x002c)))
	{
		return TRUE;
	}
	else
		return FALSE;

}


//****************************************************************************
// StartEraseFlashJ3_1x16
//****************************************************************************
//  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 StartEraseFlashC3_1x16(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(dwStartAddr  & (FLASH_BLOCK_SIZE - 1))
    if(GotEraseFlashSectorIndex(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       = gdwFlashSize;//dwLength;
    gpusCurAddr     = (PUSHORT) dwStartAddr;

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

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

    return TRUE;
}

//****************************************************************************
// ContinueEraseFlashJ3_1x16
//****************************************************************************
// Continues the flash erasing processes for J3 Flash.  See 
// OEMContinueEraseFlash for Parameter description.
// 
//
void ContinueEraseFlashC3_1x16(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((*gpusCurAddr & EXT_STATUS_WBUFFER_READY) != EXT_STATUS_WBUFFER_READY)
    {
        return;
    }

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

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

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

        //
        // Advance to the next block.
        //
        gpusCurAddr+= sBlockInfo[gdwCurEraseRegion].block_size>>1;

	//
	//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.
        //
        *gpusCurAddr = FLASH_LOCK_BIT;
        *gpusCurAddr = FLASH_LOCK_CLEAR;
        *gpusCurAddr = FLASH_READ_STATUS;

        gbUnlocked  = TRUE;
    }

}

//****************************************************************************
// FinishEraseFlashJ3_1x16
//****************************************************************************
// Finishes the flash eraseing processes for J3 Flash.  See 
// OEMFinishEraseFlash for paramter description.
//
BOOL  FinishEraseFlashC3_1x16 (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(gpusCurAddr, 10000, EXT_STATUS_WBUFFER_READY);
    if(bSuccess == FALSE)
    {
        return FALSE;
    }

    *gpusCurAddr  = FLASH_CLEAR_STATUS;

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

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

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

        *gpusCurAddr    = FLASH_CLEAR_STATUS;
        gbUnlocked      = FALSE;

        //
        // Increment to the next block.
        //
        gpusCurAddr+= sBlockInfo[gdwCurEraseRegion].block_size>>1;

	//
	//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 FALSE;
	 }

	 
    }


    //
    // Erase the Flash
    //
    while((DWORD)gpusCurAddr < (gdwStartAddr + gdwLength))
    {

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

        //
        // Wait for the Flash block command to succeed.
        //
        bSuccess = WaitForReady(gpusCurAddr, 10000, EXT_STATUS_WBUFFER_READY);
        *gpusCurAddr  = FLASH_CLEAR_STATUS;
        
        if(!bSuccess)
        {
            break;