flash.c

Microsoft WinCE 6.0 BSP FINAL release source code for use with the i.MX27ADS TO2 WCE600_FINAL_MX27_S

//-----------------------------------------------------------------------------
//
//  Use of this source code is subject to the terms of the Microsoft 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 LICENSE.RTF on
//  your install media.
//
//-----------------------------------------------------------------------------
//
//  Copyright (C) 2004-2007, Freescale Semiconductor, Inc. All Rights Reserved.
//  THIS SOURCE CODE, AND ITS USE AND DISTRIBUTION, IS SUBJECT TO THE TERMS
//  AND CONDITIONS OF THE APPLICABLE LICENSE AGREEMENT
//
//-----------------------------------------------------------------------------
//
//  File:  flash.c
//
//  Contains flash functions used by boot loader.
//
//-----------------------------------------------------------------------------
#include <windows.h>
#include "bsp.h"
#include "loader.h"

//-----------------------------------------------------------------------------
// External Functions
BOOL NORWrite(DWORD dwStartAddr, DWORD dwLength);
BOOL NORLoadEBootCFG(BYTE * pBootCfg, DWORD cbBootCfgSize);
BOOL NORStoreEBootCFG(BYTE * pBootCfg, DWORD cbBootCfgSize);
BOOL NANDWriteXldr(DWORD dwStartAddr, DWORD dwLength);
BOOL NANDWriteEboot(DWORD dwStartAddr, DWORD dwLength);
BOOL NANDWriteIPL(DWORD dwStartAddr, DWORD dwLength);
BOOL NANDStartWriteBinDIO(DWORD dwStartAddr, DWORD dwLength);
BOOL NANDContinueWriteBinDIO(DWORD dwAddress, BYTE *pbData, DWORD dwSize);
BOOL NANDFinishWriteBinDIO();
BOOL NANDWriteNK(DWORD dwStartAddr, DWORD dwLength);
BOOL NANDLoadEBootCFG(BYTE * pBootCfg, DWORD cbBootCfgSize);
BOOL NANDStoreEBootCFG(BYTE * pBootCfg, DWORD cbBootCfgSize);

//-----------------------------------------------------------------------------
// External Variables
extern IMAGE_TYPE g_ImageType;
extern IMAGE_MEMORY g_ImageMemory;
extern BOOL g_bNandBootloader;
extern EBOOT_BINDIO_CONTEXT g_BinDIO;


//-----------------------------------------------------------------------------
// Defines


//-----------------------------------------------------------------------------
// Types


//-----------------------------------------------------------------------------
// Global Variables


//-----------------------------------------------------------------------------
// Local Variables


//-----------------------------------------------------------------------------
//
//  Function:  OEMIsFlashAddr
//
//  This function determines whether the address provided lies in a platform's 
//  flash memory or RAM address range.
//
//  Parameters:
//      dwAddr 
//          [in] Address of a BIN file record. This is the address that is 
//          checked to see whether it lies in flash or RAM.
//
//  Returns:
//      Returns TRUE if an address is a flash address, and FALSE if not.
//-----------------------------------------------------------------------------
BOOL OEMIsFlashAddr (DWORD dwAddr)
{
    // OEMVerifyMemory will be called first to determine the destination of the
    // the image.  Use g_ImageMemory set by OEMVerifyMemory to determine if this 
    // is a NOR/NAND flash address.

    if ((g_ImageMemory == IMAGE_MEMORY_NOR) || (g_ImageMemory == IMAGE_MEMORY_NAND))
    {
        return TRUE;
    }
    else
    {
        return FALSE;
    }
}


//-----------------------------------------------------------------------------
//
//  Function:  OEMMapMemAddr
//
//  This function remaps a flash-resident address to a unique RAM-based address 
//  so that flash memory OS images can be temporarily cached in RAM while the 
//  download occurs. 
//
//  Parameters:
//      dwImageStart 
//          [in] Starting address of OS image. 
//
//      dwAddr 
//          [in] Address of a BIN record. If this address lies in a 
//          platform's flash memory address space, typically the offset from 
//          dwImageStart is computed and added to a RAM-based file cache area.
//
//  Returns:
//      Address from which the BIN record should be copied to provide file 
//      caching before and during the flash update process.
//-----------------------------------------------------------------------------
LPBYTE OEMMapMemAddr (DWORD dwImageStart, DWORD dwAddr)
{
    if (OEMIsFlashAddr(dwAddr))
    {
        if (g_ImageType == IMAGE_TYPE_BINDIO && g_ImageMemory == IMAGE_MEMORY_NAND)
        {
            // The record offset is needed in order to know where the image
            // is required to be flashed.  It's the offset of this one recored
            // from the image start.
            //
            // Note: The record can be a non contiguous image.
            //
            // The dwImageStart would always be the pInfo->Region[0].dwRegionStart
            // we saw in OEMMultiBINNotify().
            g_BinDIO.recordOffset = dwAddr - dwImageStart;
	            
            // Always cache data to the same place since DIO is flashed 
            // immediately on download and thus the buffer can be reused.
            dwAddr = EBOOT_FLASHBLOCK_CACHE_START;
        }
        else
        {
            // The image being downloaded is a flash image - temporarily
            // cache the image in RAM until it's completely downloaded.
            //
            dwAddr -= dwImageStart;
            dwAddr += EBOOT_FLASHBLOCK_CACHE_START;
        }
    }

    return((LPBYTE) (dwAddr));
}


//-----------------------------------------------------------------------------
//
//  Function:  OEMStartEraseFlash
//
//  This function initiates the flash memory erasing process.
//
//  Parameters:
//      dwStartAddr 
//          [in] Address in flash memory from which to start erasing.
//
//      dwLength 
//          [in] Number of bytes of flash memory to be erased.
//
//  Returns:
//      TRUE indicates success. FALSE indicates failure.
//-----------------------------------------------------------------------------
BOOL OEMStartEraseFlash (DWORD dwStartAddr, DWORD dwLength)
{
    BOOL rc = TRUE;
    
    if (g_ImageType == IMAGE_TYPE_BINDIO && g_ImageMemory == IMAGE_MEMORY_NAND)
    {
        rc = NANDStartWriteBinDIO(dwStartAddr, dwLength);
    }

    return rc;
}


//-----------------------------------------------------------------------------
//
//  Function:  OEMContinueEraseFlash
//
//  This function provides a means to continue erasing flash memory blocks
//  while a download is taking place.
//
//  Parameters:
//      None.
//
//  Returns:
//      None.
//-----------------------------------------------------------------------------
void OEMContinueEraseFlash(void)
{
    if (g_ImageType == IMAGE_TYPE_BINDIO && g_ImageMemory == IMAGE_MEMORY_NAND)
    {
        NANDContinueWriteBinDIO(g_BinDIO.recordOffset, 
                                g_BinDIO.pReadBuffer, 
                                g_BinDIO.readSize);
    }
}


//-----------------------------------------------------------------------------
//
//  Function:  OEMFinishEraseFlash
//
//  This function is called by the BLCOMMON framework when it is about to 
//  write the OS image to flash memory.
//
//  Parameters:
//      None.
//
//  Returns:
//      TRUE indicates success. FALSE indicates failure.
//-----------------------------------------------------------------------------
BOOL OEMFinishEraseFlash(void)
{
    BOOL rc = TRUE;
    
    if (g_ImageType == IMAGE_TYPE_BINDIO && g_ImageMemory == IMAGE_MEMORY_NAND)
    {
        rc = NANDFinishWriteBinDIO();
    }

    return rc;
}


//-----------------------------------------------------------------------------
//
//  Function:  OEMWriteFlash
//
//  This function writes to flash memory the OS image that might be stored 
//  in a RAM file cache area.
//
//  Parameters:
//      dwStartAddr 
//          [in] Address in flash memory where the start of the downloaded 
//          OS image is to be written.
//
//      dwLength 
//          [in] Length of the OS image, in bytes, to be written to flash
//          memory.            
//
//  Returns:
//      TRUE indicates success. FALSE indicates failure.
//-----------------------------------------------------------------------------
BOOL OEMWriteFlash(DWORD dwStartAddr, DWORD dwLength)
{
    BOOL rc;
    int key;

    if (g_ImageMemory == IMAGE_MEMORY_NAND && g_ImageType == IMAGE_TYPE_BINDIO)
    {
        goto cleanUp;
    }
    
    KITLOutputDebugString("\r\nWARNING: Flash update requested.\r\n");
    KITLOutputDebugString("Do you want to continue (y/n)? ");

    do {
        key = tolower(OEMReadDebugByte());
    } while ((key != 'y') && (key != 'n'));
    KITLOutputDebugString("\r\n");
   
    if (key != 'y')
    {
        KITLOutputDebugString("Flash update has been canceled.\r\n");
        rc = FALSE;
        goto cleanUp;
    }
    
    if (g_ImageMemory == IMAGE_MEMORY_NOR)
    {
        rc = NORWrite(dwStartAddr, dwLength);
    }

    else if (g_ImageMemory == IMAGE_MEMORY_NAND)
    {
        switch(g_ImageType)
        {
        case IMAGE_TYPE_XLDR:
            rc = NANDWriteXldr(dwStartAddr, dwLength);
            break;
           
        case IMAGE_TYPE_EBOOT:
            rc = NANDWriteEboot(dwStartAddr, dwLength);
            break;
            
        case IMAGE_TYPE_IPL:
            rc = NANDWriteIPL(dwStartAddr, dwLength);
            break;

        case IMAGE_TYPE_NK:
            rc = NANDWriteNK(dwStartAddr, dwLength);
            break;

        default:
            // Should never get here...
            rc = FALSE;
            break;
        }
    }

    else
    {
        // Should never get here...
        rc = FALSE;
    }

cleanUp:    
    // For all kinds of images flashed, the system should be re-started
    KITLOutputDebugString("Reboot the device manually...\r\n");
    SpinForever();

    return rc;

}

BOOL FlashLoadEBootCFG(BYTE *pBootCfg, DWORD cbBootCfgSize)
{
    BOOL rc;
    
    if (g_bNandBootloader)
    {
        rc = NANDLoadEBootCFG(pBootCfg, cbBootCfgSize);
    }
    else
    {
        rc = NORLoadEBootCFG(pBootCfg, cbBootCfgSize);
    }

    return rc;
}


BOOL FlashStoreEBootCFG(BYTE *pBootCfg, DWORD cbBootCfgSize)
{
    BOOL rc;
    
    if (g_bNandBootloader)
    {
        rc = NANDStoreEBootCFG(pBootCfg, cbBootCfgSize);
    }
    else
    {
        rc = NORStoreEBootCFG(pBootCfg, cbBootCfgSize);
    }

    return rc;
}