intel_p30_1x16.c

Ep93XX TionProV2 BSP

//**********************************************************************
//                                                                      
// Filename: intel93_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_p30_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 USHORT * 	gpusCurAddr    		  = 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;

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


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

    dwBlockSize = sBlockInfo[gdwCurEraseRegion].block_size;

    return dwBlockSize;

}

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

	EdbgOutputDebugString("init flash manufacture %x\r\n.",gdwManufactureId );

	//
	// Query 16 bitwidth flash.
	//
	*gpusCurAddr 			= FLASH_READ_QUERY;

	gdwFlashSize			= 1 << (*(gpusCurAddr + 0x27) & 0xFF);

	EdbgOutputDebugString("bootloader flash size  %x\r\n.",gdwFlashSize );

	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;

		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.
	//
	*gpusCurAddr = FLASH_READ_MODE;

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

		return FALSE;
	}
	return TRUE;
}

//****************************************************************************
// 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 StartEraseFlashP30_1x16(DWORD dwStartAddr, DWORD dwLength)
{
    //
    // Check to make sure that the flash is on a Block boundary.
    //
    if(GotEraseFlashSectorIndex_P30_1X16(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;
    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 ContinueEraseFlashP30_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
			//