amd.c

freescale i.mx31 BSP CE5.0全部源码

}

//-----------------------------------------------------------------------------
//
// Function: AMDx16_EraseChip
//
// Function erases the entire flash chip
// For 16bit mode flash devices.
//
// Parameters:
//      pFlashDesc
//          [in] pointer to NOR flash descriptor
//
// Returns:
//      FALSE on failure
//
//-----------------------------------------------------------------------------
BOOL AMDx16_EraseChip(NOR_FLASH_DESC *pFlashDesc)
{
    ULONG ulFlashBase;
    BOOL bIsPaired;
    ULONG i;
    ULONG ulDataWritten;
    BOOL bDone;

    DEBUGMSG(ZONE_HAL_FUNCTION, (TEXT("AMDx16_EraseChip+ 0x%x\r\n"), pFlashDesc));
    
    if(!pFlashDesc)
    {
    	DEBUGMSG(ZONE_HAL_ERROR, (TEXT("AMDx16_EraseChip: null param\r\n")));
        return FALSE;
    }
        
    bIsPaired = pFlashDesc->PairedFlash;
    ulFlashBase = pFlashDesc->FlashBase;
    
    // Issue erase chip command
    // **************************
    WR_FLASH_REG_INDEXED16(bIsPaired, ulFlashBase, CYCLE_1_ADDR_UNLOCK_x16, CYCLE_1_DATA_UNLOCK);
    WR_FLASH_REG_INDEXED16(bIsPaired, ulFlashBase, CYCLE_2_ADDR_UNLOCK_x16, CYCLE_2_DATA_UNLOCK);
    WR_FLASH_REG_INDEXED16(bIsPaired, ulFlashBase, CYCLE_3_ADDR_CMD_x16, CYCLE_3_DATA_ERASE);
    WR_FLASH_REG_INDEXED16(bIsPaired, ulFlashBase, CYCLE_4_ADDR_ERASE, CYCLE_4_DATA_ERASE);
    WR_FLASH_REG_INDEXED16(bIsPaired, ulFlashBase, CYCLE_5_ADDR_ERASE, CYCLE_5_DATA_ERASE);
    WR_FLASH_REG_INDEXED16(bIsPaired, ulFlashBase, CYCLE_6_ADDR_CHIP_ERASE, CYCLE_6_DATA_CHIP_ERASE);

    bDone = FALSE;
#ifdef USE_OS_SERVICES
    for(i = 0; i < g_FlashProgInfo.ulMaxChipEraseTOFactor; i++)
    {
        Sleep(g_FlashProgInfo.ulChipEraseTO_ms);
#else
    i = 0;
    while(!bDone && i++ < CHECK_STATUS_TIMEOUT)
    {
#endif
        ulDataWritten = bIsPaired? *((volatile ULONG *)(ulFlashBase)) : 
                                 *((volatile USHORT *)(ulFlashBase));
        DEBUGMSG(ZONE_HAL_FUNCTION, (TEXT("[0x%x]->0x%x\r\n"), 
                                    ulFlashBase, ulDataWritten));
        if((ulDataWritten & CREATE_MASK_16(bIsPaired, AMD_FLASH_DQ7_X16)) == CREATE_MASK_16(bIsPaired, AMD_FLASH_DQ7_X16))
        {
            // DQ7 on the high and low order devices is a 1, 
            // erase completed successfully.
            // *********************************************
            bDone = TRUE;
            break;
        }
        else 
        {
            // Test the device(s) to determine if a timeout has occurred.
            // If the device was being erased (DQ7 -> 0) AND
            // a timeout has occurred (DQ5 -> 1) then there is a failure.
            // **********************************************************
            if((ulDataWritten & CREATE_MASK_16(bIsPaired, AMD_FLASH_DQ5_X16)) == CREATE_MASK_16(bIsPaired, AMD_FLASH_DQ5_X16))
            {
                ERRORMSG(ZONE_HAL_ERROR, (TEXT("ERROR: Erase chip timeout Poll cnt %d - [0x%x] rd value[0]:0x%x\r\n"), 
                    i, ulFlashBase, ulDataWritten));
                break;
            }
        }
    }

    // return to read array mode by issuing a soft reset
    WR_FLASH_REG_INDEXED16(bIsPaired, ulFlashBase, CYCLE_1_ADDR_RESET, CYCLE_1_DATA_RESET);

    DEBUGMSG(ZONE_HAL_FUNCTION, (TEXT("AMDx16_EraseChip-\r\n")));
    return bDone;
}

// WARNING: for relocation purpose. Do not move!
void AMDx16_RelocateEnd(void)
{
}

//-----------------------------------------------------------------------------
//
// Function: AMDx16_LockSector
//
// Function performs dynamic locking of a sector.
// For 16bit mode flash devices.
//
// Parameters:
//      pFlashDesc
//          [in] pointer to NOR flash descriptor
//
//      ulSectorAddress
//          [in] sector address to lock
//
// Returns:
//      FALSE on failure
//
//-----------------------------------------------------------------------------
BOOL AMDx16_LockSector(NOR_FLASH_DESC *pFlashDesc, ULONG ulSectorAddress)
{
    ULONG ulFlashBase;
    BOOL bIsPaired;
    BOOL bLock;

    DEBUGMSG(ZONE_HAL_FUNCTION, (TEXT("AMDx16_LockSector+ 0x%x 0x%x\r\n"),
                                pFlashDesc, ulSectorAddress));

    if(!pFlashDesc)
    {
    	DEBUGMSG(ZONE_HAL_ERROR, (TEXT("AMDx16_LockSector: null param\r\n")));
        return FALSE;
    }
        
    bIsPaired = pFlashDesc->PairedFlash;
    ulFlashBase = pFlashDesc->FlashBase;
    
    // Issue DYB write command
    // **************************
    WR_FLASH_REG_INDEXED16(bIsPaired, ulFlashBase, CYCLE_1_ADDR_UNLOCK_x16, CYCLE_1_DATA_UNLOCK);
    WR_FLASH_REG_INDEXED16(bIsPaired, ulFlashBase, CYCLE_2_ADDR_UNLOCK_x16, CYCLE_2_DATA_UNLOCK);
    WR_FLASH_REG_INDEXED16(bIsPaired, ulFlashBase, CYCLE_3_ADDR_CMD_x16, CYCLE_3_DATA_DYB_WRITE);
    WR_FLASH_REG_16(bIsPaired, ulSectorAddress, CYCLE_4_DATA_DYB_WRITE);

    bLock = AMDx16_IsSectorLocked(pFlashDesc, ulSectorAddress);

    // return to read array mode by issuing a soft reset
    WR_FLASH_REG_INDEXED16(bIsPaired, ulFlashBase, CYCLE_1_ADDR_RESET, CYCLE_1_DATA_RESET);

    DEBUGMSG(ZONE_HAL_FUNCTION, (TEXT("AMDx16_LockSector-\r\n")));
    if(!bLock)
        return FALSE;
    else
        return TRUE;
}

//-----------------------------------------------------------------------------
//
// Function: AMDx16_UnlockSector
//
// Function performs dynamic unlocking of a sector.
// For 16bit mode flash devices.
//
// Parameters:
//      pFlashDesc
//          [in] pointer to NOR flash descriptor
//
//      ulSectorAddress
//          [in] sector address to unlock
//
// Returns:
//      FALSE on failure
//
//-----------------------------------------------------------------------------
BOOL AMDx16_UnlockSector(NOR_FLASH_DESC *pFlashDesc, ULONG ulSectorAddress)
{
    ULONG ulFlashBase;
    BOOL bIsPaired;
    BOOL bLock;
    
    DEBUGMSG(ZONE_HAL_FUNCTION, (TEXT("AMDx16_UnlockSector+ 0x%x 0x%x\r\n"),
                                pFlashDesc, ulSectorAddress));

    if(!pFlashDesc)
    {
    	DEBUGMSG(ZONE_HAL_ERROR, (TEXT("AMDx16_UnlockSector: null param\r\n")));
        return FALSE;
    }
        
    bIsPaired = pFlashDesc->PairedFlash;
    ulFlashBase = pFlashDesc->FlashBase;
    
    // Issue DYB erase command
    // **************************
    WR_FLASH_REG_INDEXED16(bIsPaired, ulFlashBase, CYCLE_1_ADDR_UNLOCK_x16, CYCLE_1_DATA_UNLOCK);
    WR_FLASH_REG_INDEXED16(bIsPaired, ulFlashBase, CYCLE_2_ADDR_UNLOCK_x16, CYCLE_2_DATA_UNLOCK);
    WR_FLASH_REG_INDEXED16(bIsPaired, ulFlashBase, CYCLE_3_ADDR_CMD_x16, CYCLE_3_DATA_DYB_ERASE);
    WR_FLASH_REG_16(bIsPaired, ulSectorAddress, CYCLE_4_DATA_DYB_ERASE);

    bLock = AMDx16_IsSectorLocked(pFlashDesc, ulSectorAddress);

    // return to read array mode by issuing a soft reset
    WR_FLASH_REG_INDEXED16(bIsPaired, ulFlashBase, CYCLE_1_ADDR_RESET, CYCLE_1_DATA_RESET);

    DEBUGMSG(ZONE_HAL_FUNCTION, (TEXT("AMDx16_LockSector-\r\n")));
    
    if(bLock)
        return FALSE;
    else
        return TRUE;
}

//-----------------------------------------------------------------------------
//
// Function: AMDx16_IsSectorLocked
//
// Function checks the dynamic lock bit to see if block has been locked.
// For 16bit mode flash devices.
//
// Parameters:
//      pFlashDesc
//          [in] pointer to NOR flash descriptor
//
//      ulSectorAddress
//          [in] sector address to check lock status
//
// Returns:
//      FALSE if not locked.
//
//-----------------------------------------------------------------------------
BOOL AMDx16_IsSectorLocked(NOR_FLASH_DESC *pFlashDesc, ULONG ulSectorAddress)
{
    ULONG ulFlashBase;
    BOOL bIsPaired;
    BOOL bLocked;

    DEBUGMSG(ZONE_HAL_FUNCTION, (TEXT("AMDx16_IsSectorLocked+ 0x%x 0x%x\r\n"),
                                pFlashDesc, ulSectorAddress));

    if(!pFlashDesc)
    {
    	DEBUGMSG(ZONE_HAL_ERROR, (TEXT("AMDx16_IsSectorLocked: null param\r\n")));
        return FALSE;
    }
        
    bIsPaired = pFlashDesc->PairedFlash;
    ulFlashBase = pFlashDesc->FlashBase;
    
    // Issue DYB status command
    // **************************
    WR_FLASH_REG_INDEXED16(bIsPaired, ulFlashBase, CYCLE_1_ADDR_UNLOCK_x16, CYCLE_1_DATA_UNLOCK);
    WR_FLASH_REG_INDEXED16(bIsPaired, ulFlashBase, CYCLE_2_ADDR_UNLOCK_x16, CYCLE_2_DATA_UNLOCK);
    WR_FLASH_REG_INDEXED16(bIsPaired, ulFlashBase, CYCLE_3_ADDR_CMD_x16, CYCLE_3_DATA_DYB_STATUS);
    if(CHECK_FLASH_STATUS_16(bIsPaired, ulFlashBase, 1))
        bLocked = TRUE;
    else
        bLocked = FALSE;

    // return to read array mode by issuing a soft reset
    WR_FLASH_REG_INDEXED16(bIsPaired, ulFlashBase, CYCLE_1_ADDR_RESET, CYCLE_1_DATA_RESET);

    DEBUGMSG(ZONE_HAL_FUNCTION, (TEXT("AMDx16_IsSectorLocked-\r\n")));
    return bLocked;
}

//-----------------------------------------------------------------------------
// PRIVATE FUNCTIONS
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//
// Function: PrintPriExtTable
//
// Function prints the AMD CFI primary extented table.
//
// Parameters:
//      pPET
//          [in] pointer to AMD CFI primary extented table.
//
// Returns:
//      None
//
//-----------------------------------------------------------------------------
static void PrintPriExtTable(AMD_PET_QUERY_INFO *pPET)
{
    ULONG i;

    DEBUGMSG(ZONE_HAL_INFO, (TEXT("****Primary Vendor Extended Query Data****\r\n")));
    DEBUGMSG(ZONE_HAL_INFO, (TEXT("Query-unique ASCII string: %c%c%c\r\n"), 
                            pPET->ID[0], pPET->ID[0], pPET->ID[0]));
    DEBUGMSG(ZONE_HAL_INFO, (TEXT("Major version number: %c\r\n"), pPET->VersionMajor));
    DEBUGMSG(ZONE_HAL_INFO, (TEXT("Minor version number: %c\r\n"), pPET->VersionMinor));
    DEBUGMSG(ZONE_HAL_INFO, (TEXT("Address Sensitive Unlock: %d\r\n"), pPET->AddrUnlockSiTech));
    DEBUGMSG(ZONE_HAL_INFO, (TEXT("Erase Suspend Support: %d\r\n"), pPET->EraseSuspendSupport));
    DEBUGMSG(ZONE_HAL_INFO, (TEXT("Sector Protect group size: %d\r\n"), pPET->SectorProtectGroupSize));
    DEBUGMSG(ZONE_HAL_INFO, (TEXT("Temporary sector unprotect support: %d\r\n"), pPET->SectorTempUnprotectSupport));
    DEBUGMSG(ZONE_HAL_INFO, (TEXT("Sector Protect/Unprotect scheme: %d\r\n"), pPET->SectorProtectScheme));
    DEBUGMSG(ZONE_HAL_INFO, (TEXT("Simultaneous Operation support: %d\r\n"), pPET->SimulOperationSupport));
    DEBUGMSG(ZONE_HAL_INFO, (TEXT("Burst Mode support: %d\r\n"), pPET->BurstModeSupport));
    DEBUGMSG(ZONE_HAL_INFO, (TEXT("Page Mode support: %d\r\n"), pPET->PageModeSupport));
    DEBUGMSG(ZONE_HAL_INFO, (TEXT("ACC [Acceleration] Supply Minimum: %d\r\n"), pPET->ACCVmin));
    DEBUGMSG(ZONE_HAL_INFO, (TEXT("ACC [Acceleration] Supply Maximum: %d\r\n"), pPET->ACCVmax));
    DEBUGMSG(ZONE_HAL_INFO, (TEXT("Boot sector support: %d\r\n"), pPET->BootSectorSupport));
    DEBUGMSG(ZONE_HAL_INFO, (TEXT("Unlock bypass support: %d\r\n"), pPET->UnlockBypassSupport));
    DEBUGMSG(ZONE_HAL_INFO, (TEXT("Customer secure Si area size: %d\r\n"), pPET->SecSiSize));
    DEBUGMSG(ZONE_HAL_INFO, (TEXT("Embedded HW reset TO max (ns): %d\r\n"), pPET->EmbeddedHwResetTOMax_ns));
    DEBUGMSG(ZONE_HAL_INFO, (TEXT("Non-embedded HW reset TO max (ns): %d\r\n"), pPET->NonEmbeddedHwResetTOMax_ns));
    DEBUGMSG(ZONE_HAL_INFO, (TEXT("Erase Suspend timeout maximum (us): %d\r\n"), pPET->EraseSuspendTOMax_us));
    DEBUGMSG(ZONE_HAL_INFO, (TEXT("Program Suspend timeout maximum (us): %d\r\n"), pPET->ProgramSuspendTOMax_us));
    DEBUGMSG(ZONE_HAL_INFO, (TEXT("Number of banks: %d\r\n"), pPET->NumBanks));
    for(i = 0; i < pPET->NumBanks; i++)
    {
        DEBUGMSG(ZONE_HAL_INFO, (TEXT("Bank %d - Num sectors: %d\r\n"), i, pPET->SectorsInBank[i]));
    }
}

//-----------------------------------------------------------------------------
//
// Function: PrintFlashProgInfo
//
// Function prints the internal flash programming information.
//
// Parameters:
//      pInfo
//          [in] pointer to internal flash programming information struct.
//
// Returns:
//      None
//
//-----------------------------------------------------------------------------
static void PrintFlashProgInfo(FLASH_PROG_INFO *pInfo)
{
    DEBUGMSG(ZONE_HAL_INFO, (TEXT("****Flash Programming Info****\r\n")));
    DEBUGMSG(ZONE_HAL_INFO, (TEXT("Single byte/word prog TO (us): %d\r\n"), pInfo->ulDatumProgTO_us));
    DEBUGMSG(ZONE_HAL_INFO, (TEXT("Single byte/word prog TO factor: %d\r\n"), pInfo->ulMaxDatumProgTOFactor));
    DEBUGMSG(ZONE_HAL_INFO, (TEXT("Min size buffer prog TO (us): %d\r\n"), pInfo->ulBufferProgTO_us));
    DEBUGMSG(ZONE_HAL_INFO, (TEXT("Min size buffer prog TO factor: %d\r\n"), pInfo->ulMaxBufferProgTOFactor));
    DEBUGMSG(ZONE_HAL_INFO, (TEXT("Sector erase TO (ms): %d\r\n"), pInfo->ulSectorEraseTO_ms));
    DEBUGMSG(ZONE_HAL_INFO, (TEXT("Sector erase TO factor: %d\r\n"), pInfo->ulMaxSectorEraseTOFactor));
    DEBUGMSG(ZONE_HAL_INFO, (TEXT("Chip erase TO: %d\r\n"), pInfo->ulChipEraseTO_ms));
    DEBUGMSG(ZONE_HAL_INFO, (TEXT("Chip erase TO factor: %d\r\n"), pInfo->ulMaxChipEraseTOFactor));
}
//-----------------------------------------------------------------------------
// END OF FILE
//-----------------------------------------------------------------------------