intel_p30_2x16.c

Ep93XX TionProV2 BSP

//**********************************************************************
//                                                                      
// 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 ULONG  * gpulCurAddr     = 0;
static BOOL     gbFlashEraseComplete    = FALSE;
static BOOL     gbUnlocked              = TRUE;

extern DWORD				gdwFlashSize			;
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;
	DWORD dwToalSize=0;
	
	gpulCurAddr	= (unsigned long*)PHYSICAL_ADDR_FLASH;
	//
	// 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;
	
	EdbgOutputDebugString("bootloader flash size  %x\r\n.",gdwFlashSize );

	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;

		sBlockInfo[iIdx].block_size <<=1;

		dwToalSize+=sBlockInfo[iIdx].block_size * sBlockInfo[iIdx].blocks;

		EdbgOutputDebugString("block size %x-- num %x\r\n.",sBlockInfo[iIdx].block_size, sBlockInfo[iIdx].blocks );
	}
	//
	// Put the FLASH into read array mode.
	//
	*gpulCurAddr = FLASH_READ_MODE;

	if( gdwFlashSize != dwToalSize) {

		EdbgOutputDebugString("*****Error, flash size error%x-- %x...stop\r\n."
			,gdwFlashSize
			,dwToalSize);

		return FALSE;
	}

	return TRUE;
}



//****************************************************************************
//  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.
    //

    //
    // 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+= 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;
        }

        *gpulCurAddr    = FLASH_CLEAR_STATUS;
        gbUnlocked      = FALSE;

        //
        // Increment to the next block.
        //

        gpulCurAddr+= sBlockInfo[gdwCurEraseRegion].block_size>>2;