fmd.cpp

Samsung公司S3C2443芯片的BSP源码包

    //  Wait for RB
	NF_DETECT_RB();	 // Wait tR(max 12us)

	if ( NF_RDSTAT & STATUS_ILLACC )
	{
		RETAILMSG(1, (TEXT("NAND_LB_WriteSectorInfo() ######## Error Programming page (Illigar Access) %d!\n")));
		s2443NAND->NFSTAT =  STATUS_ILLACC;	// Write 1 to clear.
       	bRet = FALSE;
	}
	else
	{
		//  Check the status of program
		NF_CMD(CMD_STATUS);

		if( NF_RDDATA_BYTE() & STATUS_ERROR) {
			RETAILMSG(1, (TEXT("NAND_LB_WriteSectorInfo() ######## Error Programming page %d!\n")));
			bRet = FALSE;
		}
	}

    //  Disable chip select
    NF_nFCE_H();

    SetKMode(bLastMode);

    return bRet;
}

BOOL SB_MarkBlockBad(BLOCK_ID blockID, int mode)
{
	DWORD   dwStartPage = blockID << SB_NAND_LOG_2_PAGES_PER_BLOCK;
	BOOL    bRet = TRUE;

	//RETAILMSG(1, (TEXT("SB_MarkBlockBad 0x%x \r\n"), dwStartPage));

	BOOL bLastMode = SetKMode(TRUE);

    //  Enable chip
	NF_nFCE_L();
	NF_CLEAR_RB();

    //  Issue command
    //  We are dealing with spare area
	NF_CMD(CMD_READ2);
	NF_CMD(CMD_WRITE);

    //  Set up address
	NF_ADDR(POS_BADBLOCK);
	NF_ADDR((dwStartPage) & 0xff);
	NF_ADDR((dwStartPage >> 8) & 0xff);
	if (SB_NEED_EXT_ADDR)
		NF_ADDR((dwStartPage >> 16) & 0xff);

	NF_WRDATA_BYTE(BADBLOCKMARK);

    //  Copmlete the write
	NF_CMD(CMD_WRITE2);

    //  Wait for RB
	NF_DETECT_RB();	 // Wait tR(max 12us)

	if ( NF_RDSTAT & STATUS_ILLACC )
	{
		RETAILMSG(1, (TEXT("NAND_LB_WriteSectorInfo() ######## Error Programming page (Illigar Access) %d!\n")));
		s2443NAND->NFSTAT =  STATUS_ILLACC;	// Write 1 to clear.
       	bRet = FALSE;
	}
	else
	{
		//  Check the status of program
		NF_CMD(CMD_STATUS);

		if( NF_RDDATA_BYTE() & STATUS_ERROR) {
			RETAILMSG(1, (TEXT("NAND_LB_WriteSectorInfo() ######## Error Programming page %d!\n")));
			bRet = FALSE;
		}
	}

    //  Disable chip select
    NF_nFCE_H();

    SetKMode(bLastMode);

    return bRet;
}

BOOL LB_IsBlockBad(BLOCK_ID blockID, int mode)
{
    DWORD   dwPageID = blockID << LB_NAND_LOG_2_PAGES_PER_BLOCK;
    BOOL    bRet = FALSE;
    BYTE    wFlag;

    BOOL bLastMode = SetKMode(TRUE);

    //  Enable the chip
    NF_nFCE_L();
    NF_CLEAR_RB();

    //  Issue the command
    NF_CMD(CMD_READ);

    //  Set up address
    NF_ADDR((2048+POS_BADBLOCK)&0xff);
    NF_ADDR(((2048+POS_BADBLOCK)>>8)&0xff);
    NF_ADDR((dwPageID) & 0xff);
    NF_ADDR((dwPageID >> 8) & 0xff);
    if (LB_NEED_EXT_ADDR)
        NF_ADDR((dwPageID >> 16) & 0xff);

	NF_CMD(CMD_READ3);

    //  Wait for Ready bit
	NF_DETECT_RB();	 // Wait tR(max 12us)

    //  Now get the byte we want
    wFlag = (BYTE)(NF_RDDATA_BYTE()&0xff);

    if(wFlag != 0xff) {
		RETAILMSG(1, (TEXT("FMDLB: IsBlockBad - Page #: 0x%x \r\n"), dwPageID));
        bRet = TRUE;
    }

    //  Disable the chip
    NF_nFCE_H();

    SetKMode(bLastMode);

    return bRet;
}

BOOL SB_IsBlockBad(BLOCK_ID blockID, int mode)
{
    DWORD   dwPageID = blockID << SB_NAND_LOG_2_PAGES_PER_BLOCK;
    BOOL    bRet = FALSE;
    BYTE    wFlag;

    //RETAILMSG(1,(TEXT("#### FMD_DRIVER:::FMD_sbisblockbad \r\n")));

    BOOL bLastMode = SetKMode(TRUE);

    //  Enable the chip
    NF_nFCE_L();
	NF_CLEAR_RB();
    //  Issue the command
    NF_CMD(CMD_READ2);

    //  Set up address
    NF_ADDR(POS_BADBLOCK);
    NF_ADDR((dwPageID) & 0xff);
    NF_ADDR((dwPageID >> 8) & 0xff);
    if (SB_NEED_EXT_ADDR)
        NF_ADDR((dwPageID >> 16) & 0xff);

    //  Wait for Ready bit
	NF_DETECT_RB();	 // Wait tR(max 12us)

    //  Now get the byte we want
    wFlag = (BYTE) NF_RDDATA_BYTE();

    if(wFlag != 0xff) {
	RETAILMSG(1, (TEXT("FMDSB: IsBlockBad - Page #: 0x%x \r\n"), dwPageID));
        bRet = TRUE;
    }
		
    //  Disable the chip
    NF_nFCE_H();

    SetKMode(bLastMode);

    return bRet;
}


#if MAGNETO
BOOL  FMD_GetInfoEx(PFlashInfoEx pFlashInfo, PDWORD pdwNumRegions)
{
    // Temp
    RETAILMSG(1, (L"FMD_GetInfoEx enter.\r\n"));

    
    if (!pdwNumRegions) 
    {
        return FALSE;
    }
    
    if (!pFlashInfo)
    {
        // Return required buffer size to caller
        *pdwNumRegions = g_dwNumRegions;
        return TRUE;
    }
    
    if (*pdwNumRegions < g_dwNumRegions)
    {
        *pdwNumRegions = g_dwNumRegions;
        DEBUGMSG (1, (TEXT("FMD_GetInfoEx: Insufficient buffer for number of regions")));
        return FALSE;
    }

    memcpy (pFlashInfo->region, g_pRegionTable, g_dwNumRegions * sizeof(FlashRegion));

    // Temp
    for (DWORD iRegion = 0; iRegion < g_dwNumRegions; iRegion++) {
        RETAILMSG(1, (L"Type=%d, StartP=0x%x, NumP=0x%x, NumL=0x%x, Sec/Blk=0x%x, B/Blk=0x%x, Compact=%d.\r\n", 
            g_pRegionTable[iRegion].regionType,
            g_pRegionTable[iRegion].dwStartPhysBlock,
            g_pRegionTable[iRegion].dwNumPhysBlocks,
            g_pRegionTable[iRegion].dwNumLogicalBlocks,
            g_pRegionTable[iRegion].dwSectorsPerBlock,
            g_pRegionTable[iRegion].dwBytesPerBlock,
            g_pRegionTable[iRegion].dwCompactBlocks));

    }

    *pdwNumRegions = g_dwNumRegions;

    pFlashInfo->cbSize					= sizeof(FlashInfoEx);
    pFlashInfo->flashType				= NAND;
    pFlashInfo->dwNumBlocks				= NUM_OF_BLOCKS;
    pFlashInfo->dwDataBytesPerSector	= NAND_SECTOR_SIZE;
    pFlashInfo->dwNumRegions			= g_dwNumRegions;

    return(TRUE);
}

BOOL FMD_GetOEMReservedByte(SECTOR_ADDR physicalSectorAddr, PBYTE pOEMReserved)
{

	if ( IS_LB )
		FMD_LB_GetOEMReservedByte( physicalSectorAddr,  pOEMReserved, USE_NFCE);
	else
		FMD_SB_GetOEMReservedByte( physicalSectorAddr,  pOEMReserved, USE_NFCE);
	
	return TRUE;
}

//  FMD_SetOEMReservedByte
//
//  Sets the OEM reserved byte (for metadata) for the specified physical sector.
//
BOOL FMD_SetOEMReservedByte(SECTOR_ADDR physicalSectorAddr, BYTE bOEMReserved)
{
    BOOL    bRet = TRUE;

	if ( IS_LB )
		bRet = FMD_LB_SetOEMReservedByte(physicalSectorAddr, bOEMReserved, USE_NFCE);
	else
		bRet = FMD_SB_SetOEMReservedByte(physicalSectorAddr, bOEMReserved, USE_NFCE);
	
    return bRet;
}

BOOL FMD_LB_GetOEMReservedByte(SECTOR_ADDR physicalSectorAddr, PBYTE pOEMReserved, int mode)
{
	int NewSpareAddr = 2048 + 16*(physicalSectorAddr%4);
	int NewDataAddr = 512*(physicalSectorAddr%4);
	int NewSectorAddr = physicalSectorAddr/4;

	RETAILMSG(1, (TEXT("FMD_GetOEMReservedByte 0x%x \n"), physicalSectorAddr));
    BOOL bLastMode = SetKMode(TRUE);
    
    //  Enable chip select
    NF_nFCE_L();	
	NF_CLEAR_RB();

    //  Issue command
    NF_CMD(CMD_READ);

    //  Set up address
    NF_ADDR((NewSpareAddr+POS_OEMRESERVED)&0xff);
    NF_ADDR(((NewSpareAddr+POS_OEMRESERVED)>>8)&0xff);
    NF_ADDR((NewSectorAddr) & 0xff);
    NF_ADDR((NewSectorAddr >> 8) & 0xff);
    if (LB_NEED_EXT_ADDR)
        NF_ADDR((NewSectorAddr >> 16) & 0xff);

	NF_CMD(CMD_READ3);

    //  Wait for the ready bit
	NF_DETECT_RB();	 // Wait tR(max 12us)

    //  Read the data
    *pOEMReserved = (BYTE) NF_RDDATA_BYTE();		// read and discard

    //  Disable chip select
    NF_nFCE_H();	

    SetKMode(bLastMode);
	return TRUE;

}

BOOL FMD_SB_GetOEMReservedByte(SECTOR_ADDR physicalSectorAddr, PBYTE pOEMReserved, int mode)
{
    BOOL bLastMode = SetKMode(TRUE);
    
    //  Enable chip select
    NF_nFCE_L();	
	NF_CLEAR_RB();

    //  Issue command
    NF_CMD(CMD_READ2);

    //  Set up address
    NF_ADDR(POS_OEMRESERVED);
    NF_ADDR((physicalSectorAddr) & 0xff);
    NF_ADDR((physicalSectorAddr >> 8) & 0xff);
    if (SB_NEED_EXT_ADDR)
        NF_ADDR((physicalSectorAddr >> 16) & 0xff);

    //  Wait for the ready bit
	NF_DETECT_RB();	 // Wait tR(max 12us)

    //  Read the data
    *pOEMReserved = (BYTE) NF_RDDATA_BYTE();	

    //  Disable chip select
    NF_nFCE_H();	

    SetKMode(bLastMode);
	return TRUE;

}

//  FMD_SetOEMReservedByte
//
//  Sets the OEM reserved byte (for metadata) for the specified physical sector.
//
BOOL FMD_LB_SetOEMReservedByte(SECTOR_ADDR physicalSectorAddr, BYTE bOEMReserved, int mode)
{
    BOOL    bRet = TRUE;
	int NewSpareAddr = 2048 + 16*(physicalSectorAddr%4);
	int NewDataAddr = 512*(physicalSectorAddr%4);
	int NewSectorAddr = physicalSectorAddr/4;

	RETAILMSG(1, (TEXT("FMD_SetOEMReservedByte 0x%x \n"), physicalSectorAddr));
    BOOL bLastMode = SetKMode(TRUE);

    //  Enable chip select
    NF_nFCE_L();	
	NF_CLEAR_RB();

    //  Issue command
    NF_CMD(CMD_WRITE);

    //  Set up address
    NF_ADDR((NewSpareAddr+POS_OEMRESERVED)&0xff);
    NF_ADDR(((NewSpareAddr+POS_OEMRESERVED)>>8)&0xff);
    NF_ADDR((NewSectorAddr) & 0xff);
    NF_ADDR((NewSectorAddr >> 8) & 0xff);
    if (LB_NEED_EXT_ADDR)
        NF_ADDR((NewSectorAddr >> 16) & 0xff);

    //  Write the data
	bOEMReserved = NF_RDDATA_BYTE() ;

    //  Complete the write
    NF_CMD(CMD_WRITE2);

    //  Wait for the ready bit
	NF_DETECT_RB();	 // Wait tR(max 12us)

#if 1
	if ( NF_RDSTAT & STATUS_ILLACC )
	{
		RETAILMSG(1, (TEXT("NAND_LB_WriteSectorInfo() ######## Error Programming page (Illigar Access) %d!\n"), NewSectorAddr));
		s2443NAND->NFSTAT =  STATUS_ILLACC;	// Write 1 to clear.
       	bRet = FALSE;
	}
	else
#endif		
	{
		//  Check the status of program
		NF_CMD(CMD_STATUS);

		if( NF_RDDATA_BYTE() & STATUS_ERROR) {
			RETAILMSG(1, (TEXT("NAND_LB_WriteSectorInfo() ######## Error Programming page %d!\n"), NewSectorAddr));
			bRet = FALSE;
		}
	}

    //  Disable chip select
    NF_nFCE_H();	

    SetKMode(bLastMode);
    return bRet;
}

BOOL FMD_SB_SetOEMReservedByte(SECTOR_ADDR physicalSectorAddr, BYTE bOEMReserved, int mode)
{
    BOOL    bRet = TRUE;

    BOOL bLastMode = SetKMode(TRUE);

    //  Enable chip select
    NF_nFCE_L();	
	NF_CLEAR_RB();

    //  Issue command
    NF_CMD(CMD_READ2);
    NF_CMD(CMD_WRITE);

    //  Set up address
    NF_ADDR(POS_OEMRESERVED);
    NF_ADDR((physicalSectorAddr) & 0xff);
    NF_ADDR((physicalSectorAddr >> 8) & 0xff);
    if (SB_NEED_EXT_ADDR)
        NF_ADDR((physicalSectorAddr >> 16) & 0xff);

    //  Write the data
    bOEMReserved = NF_RDDATA_BYTE();

    //  Complete the write
    NF_CMD(CMD_WRITE2);

    //  Wait for the ready bit
	NF_DETECT_RB();	 // Wait tR(max 12us)

#if 1
	if ( NF_RDSTAT & STATUS_ILLACC )
	{
		RETAILMSG(1, (TEXT("NAND_LB_WriteSectorInfo() ######## Error Programming page (Illigar Access) %d!\n"), physicalSectorAddr));
		s2443NAND->NFSTAT =  STATUS_ILLACC;	// Write 1 to clear.
       	bRet = FALSE;
	}
	else
#endif		
	{
		//  Check the status of program
		NF_CMD(CMD_STATUS);

		if( NF_RDDATA_BYTE() & STATUS_ERROR) {
			RETAILMSG(1, (TEXT("NAND_LB_WriteSectorInfo() ######## Error Programming page %d!\n"), physicalSectorAddr));
			bRet = FALSE;
		}
	}

    //  Disable chip select
    NF_nFCE_H();	

    SetKMode(bLastMode);
    return bRet;
}

static BOOL DefineLayout()
{
    PFlashRegion pRegion = NULL;
    DWORD dwBlock = 0;

    if (!FMD_GetInfo (&g_flashInfo)) {
        return FALSE;
    }
    
    // Find the MBR to determine if there is a flash layout sector
    g_dwNumRegions = 0;


    // Find the first usuable block
    while (dwBlock < g_flashInfo.dwNumBlocks) {
        if (!(FMD_GetBlockStatus(dwBlock) & (BLOCK_STATUS_BAD | BLOCK_STATUS_RESERVED))) {
            break;
        }
        dwBlock++;
    }

	RETAILMSG(1, (TEXT("DefineLayout: dwBlock = 0x%x \r\n"), dwBlock));

	// Find the first usuable sector
    DWORD dwSector = dwBlock * g_flashInfo.wSectorsPerBlock;
	RETAILMSG(1, (TEXT("DefineLayout: dwSector = 0x%x \r\n"), dwSector));	
    if (!FMD_ReadSector (dwSector, g_pFLSBuffer, NULL, 1)) {
        return FALSE;
    }

    // compare the signatures
    if (IS_VALID_BOOTSEC(g_pFLSBuffer)) 
    {
        if (!FMD_ReadSector (dwSector+1, g_pFLSBuffer, NULL, 1)) {
            return FALSE;
        }
        if (IS_VALID_FLS(g_pFLSBuffer)) 
        {           
            PFlashLayoutSector pFLS = (PFlashLayoutSector)(g_pFLSBuffer);
            
            // Cache the flash layout sector information
            g_dwNumRegions = pFLS->cbRegionEntries / sizeof(FlashRegion);
			RETAILMSG(1, (TEXT("DefineLayout: g_dwNumRegions = 0x%x \r\n"), g_dwNumRegions));
           
            // FlashRegion table starts after the ReservedEntry table. 
            if (g_dwNumRegions)
            {
                pRegion = (PFlashRegion)((LPBYTE)pFLS + sizeof(FlashLayoutSector) + pFLS->cbReservedEntries); 
			RETAILMSG(1, (TEXT("DefineLayout: sizeof(FlashLayoutSector) = %x cdReservedEntries = %x  \r\n"), 
				sizeof(FlashLayoutSector),pFLS->cbReservedEntries));
            }
        }
    }
   
    if (!g_dwNumRegions) 
    {
        g_dwNumRegions = 1;
    }

    if (g_dwNumRegions > MAX_REGIONS)
        return FALSE;


    if (pRegion)
    {
        memcpy (g_pRegionTable, pRegion, g_dwNumRegions * sizeof(FlashRegion));
		g_pRegionTable[2].dwNumLogicalBlocks = g_flashInfo.dwNumBlocks - BAD_BLOCKS_MAS - g_pRegionTable[0].dwNumLogicalBlocks - g_pRegionTable[1].dwNumLogicalBlocks;
		RETAILMSG(1, (TEXT("g_pRegionTable[2].dwNumLogicalBlocks = 0x%x \r\n"), g_pRegionTable[2].dwNumLogicalBlocks));	
    }
    else

    {
        g_pRegionTable[0].dwStartPhysBlock = 0;
        g_pRegionTable[0].dwNumPhysBlocks = g_flashInfo.dwNumBlocks;
        g_pRegionTable[0].dwNumLogicalBlocks = FIELD_NOT_IN_USE;        
        g_pRegionTable[0].dwBytesPerBlock = g_flashInfo.dwBytesPerBlock;
        g_pRegionTable[0].regionType = FILESYS;
        g_pRegionTable[0].dwSectorsPerBlock = g_flashInfo.wSectorsPerBlock;
        g_pRegionTable[0].dwCompactBlocks = DEFAULT_COMPACTION_BLOCKS;    
    }

	RETAILMSG(1, (TEXT("DefineLayout: g_pRegionTable[0].dwNumPhysBlocks = 0x%x\r\ndwBytesperBlock = %x \r\ndwSectorsPerBlock = %x\r\n")
						,g_pRegionTable[0].dwNumPhysBlocks,g_pRegionTable[0].dwBytesPerBlock
						,g_pRegionTable[0].dwSectorsPerBlock));
	RETAILMSG(1, (TEXT("DefineLayout: g_flashInfo.dwNumPhysBlocks = 0x%x\r\ndwBytesperBlock = %x \r\ndwSectorsPerBlock = %x\r\n")
						,g_flashInfo.dwNumBlocks,g_flashInfo.dwBytesPerBlock
						,g_flashInfo.wSectorsPerBlock));	
    
    return TRUE;
}
#endif // MAGNETO