nand.cpp

支持三星原产的S3C2413开发板

					{
						EdbgOutputDebugString("ReadSector : 0x%x page(%d Block %d Page) \r\n", i*64 + j, i, j);
						RETAILMSG(1, (TEXT("Spare ECC values are different!!!!!!!!!! \r\n")));
						RETAILMSG(1, (TEXT("SECC0 = %08X \r\n"), dwSECC));
						RETAILMSG(1, (TEXT("((DWORD *)tbuf)[(2048+12)/4] = %08X \r\n"), ((DWORD *)tbuf)[(2048+12)/4]));
					}
				}
			}
EXITLOOP:
            break;

        case 0x1B:
			goto MENU_DONE;

        default:
            break;
        }
    }
MENU_DONE:
	return;

}
#endif

void BootConfigPrint(void)
{
	EdbgOutputDebugString( "BootCfg { \r\n");
	EdbgOutputDebugString( "  ConfigFlags: 0x%x\r\n", g_pBootCfg->ConfigFlags);
	EdbgOutputDebugString( "  BootDelay: 0x%x\r\n", g_pBootCfg->BootDelay);
	EdbgOutputDebugString( "  ImageIndex: %d \r\n", g_pBootCfg->ImageIndex);
	EdbgOutputDebugString( "  IP: %s\r\n", inet_ntoa(g_pBootCfg->EdbgAddr.dwIP));
	EdbgOutputDebugString( "  MAC Address: %B:%B:%B:%B:%B:%B\r\n",
						   g_pBootCfg->EdbgAddr.wMAC[0] & 0x00FF, g_pBootCfg->EdbgAddr.wMAC[0] >> 8,
						   g_pBootCfg->EdbgAddr.wMAC[1] & 0x00FF, g_pBootCfg->EdbgAddr.wMAC[1] >> 8,
						   g_pBootCfg->EdbgAddr.wMAC[2] & 0x00FF, g_pBootCfg->EdbgAddr.wMAC[2] >> 8);
	EdbgOutputDebugString( "  Port: %s\r\n", inet_ntoa(g_pBootCfg->EdbgAddr.wPort));

	EdbgOutputDebugString( "  SubnetMask: %s\r\n", inet_ntoa(g_pBootCfg->SubnetMask));
	EdbgOutputDebugString( "}\r\n");
}


// Set default boot configuration values
static void BootConfigInit(DWORD dwIndex)
{

	EdbgOutputDebugString("+BootConfigInit\r\n");

	g_pBootCfg = &g_pTOC->BootCfg;

	memset(g_pBootCfg, 0, sizeof(BOOT_CFG));

	g_pBootCfg->ImageIndex   = dwIndex;

	g_pBootCfg->ConfigFlags  = BOOT_TYPE_MULTISTAGE | CONFIG_FLAGS_DEBUGGER | BOOT_TYPE_DIRECT;

	g_pBootCfg->BootDelay	= CONFIG_BOOTDELAY_DEFAULT;

	g_pBootCfg->SubnetMask = inet_addr("255.255.255.0");

	EdbgOutputDebugString("-BootConfigInit\r\n");
	return;
}

void ID_Print(DWORD i) {
	DWORD j;
	EdbgOutputDebugString("ID[%u] {\r\n", i);
	EdbgOutputDebugString("  dwVersion: 0x%x\r\n",  g_pTOC->id[i].dwVersion);
	EdbgOutputDebugString("  dwSignature: 0x%x\r\n", g_pTOC->id[i].dwSignature);
	EdbgOutputDebugString("  String: '%s'\r\n", g_pTOC->id[i].ucString);
	EdbgOutputDebugString("  dwImageType: 0x%x\r\n", g_pTOC->id[i].dwImageType);
	EdbgOutputDebugString("  dwTtlSectors: 0x%x\r\n", g_pTOC->id[i].dwTtlSectors);
	EdbgOutputDebugString("  dwLoadAddress: 0x%x\r\n", g_pTOC->id[i].dwLoadAddress);
	EdbgOutputDebugString("  dwJumpAddress: 0x%x\r\n", g_pTOC->id[i].dwJumpAddress);
	EdbgOutputDebugString("  dwStoreOffset: 0x%x\r\n", g_pTOC->id[i].dwStoreOffset);
	for (j = 0; j < MAX_SG_SECTORS; j++) {
		if ( !g_pTOC->id[i].sgList[j].dwLength )
			break;
		EdbgOutputDebugString("  sgList[%u].dwSector: 0x%x\r\n", j, g_pTOC->id[i].sgList[j].dwSector);
		EdbgOutputDebugString("  sgList[%u].dwLength: 0x%x\r\n", j, g_pTOC->id[i].sgList[j].dwLength);
	}

	EdbgOutputDebugString("}\r\n");
}

void TOC_Print(void)
{
	int i;

	EdbgOutputDebugString("TOC {\r\n");
	EdbgOutputDebugString("dwSignature: 0x%x\r\n", g_pTOC->dwSignature);

	BootConfigPrint( );

	for (i = 0; i < MAX_TOC_DESCRIPTORS; i++) {
		if ( !VALID_IMAGE_DESCRIPTOR(&g_pTOC->id[i]) )
			break;

		ID_Print(i);
	}

	//  Print out Chain Information
	EdbgOutputDebugString("chainInfo.dwLoadAddress: 0X%X\r\n", g_pTOC->chainInfo.dwLoadAddress);
	EdbgOutputDebugString("chainInfo.dwFlashAddress: 0X%X\r\n", g_pTOC->chainInfo.dwFlashAddress);
	EdbgOutputDebugString("chainInfo.dwLength: 0X%X\r\n", g_pTOC->chainInfo.dwLength);

	EdbgOutputDebugString("}\r\n");
}


// init the TOC to defaults
BOOL TOC_Init(DWORD dwEntry, DWORD dwImageType, DWORD dwImageStart, DWORD dwImageLength, DWORD dwLaunchAddr)
{
	DWORD dwSig = 0;

	EdbgOutputDebugString("TOC_Init: dwEntry:%u, dwImageType: 0x%x, dwImageStart: 0x%x, dwImageLength: 0x%x, dwLaunchAddr: 0x%x\r\n",
		dwEntry, dwImageType, dwImageStart, dwImageLength, dwLaunchAddr);

	if (0 == dwEntry) {
		EdbgOutputDebugString("\r\n*** WARNING: TOC_Init blasting Eboot ***\r\n");
		return FALSE;
	}

	#if 1
	switch (dwImageType) {
		case IMAGE_TYPE_EBOOT:
			dwSig = IMAGE_EBOOT_SIG;
			break;
		case IMAGE_TYPE_NKBIN:
			dwSig = IMAGE_RAM_SIG;
			break;
	case IMAGE_TYPE_BINFS:
			dwSig = IMAGE_BINFS_SIG;
			break;			
		default:
			EdbgOutputDebugString("ERROR: OEMLaunch: unknown image type: 0x%x \r\n", dwImageType);
			return FALSE;
	}
	#else
	if (dwImageType & IMAGE_TYPE_EBOOT) dwSig = IMAGE_EBOOT_SIG;
	else if (dwImageType & IMAGE_TYPE_NKBIN) dwSig = IMAGE_RAM_SIG;
	else if (dwImageType & IMAGE_TYPE_BINFS) dwSig = IMAGE_BINFS_SIG;
	else 
	{
		EdbgOutputDebugString("ERROR: OEMLaunch: unknown image type: 0x%x \r\n", dwImageType);
		return FALSE;
	}
	#endif
	
	memset(g_pTOC, 0, sizeof(g_TOC));

	// init boof cfg
	BootConfigInit(dwEntry);

	// update our index
	g_dwTocEntry = dwEntry;

	// debugger enabled?
	g_bWaitForConnect = (g_pBootCfg->ConfigFlags & CONFIG_FLAGS_DEBUGGER) ? TRUE : FALSE;

	// init TOC...
	//
	g_pTOC->dwSignature = TOC_SIGNATURE;

	//  init TOC entry for Eboot
	//  Those are hard coded numbers from boot.bib
	g_pTOC->id[0].dwVersion	 = (EBOOT_VERSION_MAJOR << 16) | EBOOT_VERSION_MINOR;
	g_pTOC->id[0].dwSignature   = IMAGE_EBOOT_SIG;
	memcpy(g_pTOC->id[0].ucString, "eboot.nb0", sizeof("eboot.nb0")+1);   //  NUll terminate
	g_pTOC->id[0].dwImageType   = IMAGE_TYPE_NKBIN;
	g_pTOC->id[0].dwLoadAddress = EBOOT_RAM_IMAGE_BASE;
	g_pTOC->id[0].dwJumpAddress = EBOOT_RAM_IMAGE_BASE;
	g_pTOC->id[0].dwTtlSectors  = FILE_TO_SECTOR_SIZE(EBOOT_RAM_IMAGE_SIZE);
	// 1 contigious segment
	g_pTOC->id[0].sgList[0].dwSector = BLOCK_TO_SECTOR(EBOOT_BLOCK);
	g_pTOC->id[0].sgList[0].dwLength = g_pTOC->id[0].dwTtlSectors;

	// init the TOC entry
	g_pTOC->id[dwEntry].dwVersion	 = 0x001;
	g_pTOC->id[dwEntry].dwSignature   = dwSig;
	memset(g_pTOC->id[dwEntry].ucString, 0, IMAGE_STRING_LEN);
	g_pTOC->id[dwEntry].dwImageType   = dwImageType;
	g_pTOC->id[dwEntry].dwLoadAddress = dwImageStart;
	g_pTOC->id[dwEntry].dwJumpAddress = dwLaunchAddr;
	g_pTOC->id[dwEntry].dwStoreOffset = 0;
	g_pTOC->id[dwEntry].dwTtlSectors  = FILE_TO_SECTOR_SIZE(dwImageLength);
	// 1 contigious segment
	g_pTOC->id[dwEntry].sgList[0].dwSector = BLOCK_TO_SECTOR(g_dwImageStartBlock);
	g_pTOC->id[dwEntry].sgList[0].dwLength = g_pTOC->id[dwEntry].dwTtlSectors;

	TOC_Print();

	return TRUE;
}

//
// Retrieve TOC from Nand.
//
BOOL TOC_Read(void)
{
	SectorInfo si;

	EdbgOutputDebugString("+TOC_Read.\r\n");

	if ( !g_bBootMediaExist ) {
		EdbgOutputDebugString("TOC_Read ERROR: no boot media\r\n");
		return FALSE;
	}

	if ( !FMD_ReadSector(TOC_SECTOR, (PUCHAR)g_pTOC, &si, 1) ) {
		EdbgOutputDebugString("TOC_Read ERROR: Unable to read TOC\r\n");
		return FALSE;
	}

	// is it a valid TOC?
	if ( !VALID_TOC(g_pTOC) ) {
		EdbgOutputDebugString("TOC_Read ERROR: INVALID_TOC Signature: 0x%x\r\n", g_pTOC->dwSignature);
		return FALSE;
	}

	// is it an OEM block?
	if ( (si.bBadBlock != BADBLOCKMARK) || !(si.bOEMReserved & (OEM_BLOCK_RESERVED | OEM_BLOCK_READONLY)) ) {
		EdbgOutputDebugString("TOC_Read ERROR: SectorInfo verify failed: %x %x %x %x\r\n",
			si.dwReserved1, si.bOEMReserved, si.bBadBlock, si.wReserved2);
		return FALSE;
	}

	// update our boot config
	g_pBootCfg = &g_pTOC->BootCfg;

	// update our index
	g_dwTocEntry = g_pBootCfg->ImageIndex;

	// debugger enabled?
	g_bWaitForConnect = (g_pBootCfg->ConfigFlags & CONFIG_FLAGS_DEBUGGER) ? TRUE : FALSE;

	// cache image type
	g_ImageType = g_pTOC->id[g_dwTocEntry].dwImageType;

//	EdbgOutputDebugString("-TOC_Read\r\n");

	return TRUE;

}
//
// Store TOC to Nand
// BUGBUG: only uses 1 sector for now.
//
BOOL TOC_Write(void)
{
	SectorInfo si, si2;

	//EdbgOutputDebugString("+TOC_Write\r\n");

	if ( !g_bBootMediaExist ) {
		EdbgOutputDebugString("TOC_Write WARN: no boot media\r\n");
		return FALSE;
	}

	// is it a valid TOC?
	if ( !VALID_TOC(g_pTOC) ) {
		EdbgOutputDebugString("TOC_Write ERROR: INVALID_TOC Signature: 0x%x\r\n", g_pTOC->dwSignature);
		return FALSE;
	}

	// is it a valid image descriptor?
	if ( !VALID_IMAGE_DESCRIPTOR(&g_pTOC->id[g_dwTocEntry]) ) {
		EdbgOutputDebugString("TOC_Write ERROR: INVALID_IMAGE[%u] Signature: 0x%x\r\n",
			g_dwTocEntry, g_pTOC->id[g_dwTocEntry].dwSignature);
		return FALSE;
	}

	// in order to write a sector we must erase the entire block first
	// !! BUGBUG: must cache the TOC first so we don't trash other image descriptors !!
	if ( !FMD_EraseBlock(TOC_BLOCK) ) {
		RETAILMSG(1, (TEXT("TOC_Write ERROR: EraseBlock[%d] \r\n"), TOC_BLOCK));
		return FALSE;
	}

	// setup our metadata so filesys won't stomp us
	si.dwReserved1 = 0;
	si.bOEMReserved = OEM_BLOCK_RESERVED | OEM_BLOCK_READONLY;
	si.bBadBlock = BADBLOCKMARK;
	si.wReserved2 = 0;

	// write the sector & metadata
	if ( !FMD_WriteSector(TOC_SECTOR, (PUCHAR)&g_TOC, &si, 1) ) {
		EdbgOutputDebugString("TOC_Write ERROR: Unable to save TOC\r\n");
		return FALSE;
	}

	// read it back & verify both data & metadata
	if ( !FMD_ReadSector(TOC_SECTOR, (PUCHAR)&toc, &si2, 1) ) {
		EdbgOutputDebugString("TOC_Write ERROR: Unable to read/verify TOC\r\n");
		return FALSE;
	}

	if ( 0 != memcmp(&g_TOC, &toc, SECTOR_SIZE) ) {
		EdbgOutputDebugString("TOC_Write ERROR: TOC verify failed\r\n");
		return FALSE;
	}

	if ( 0 != memcmp(&si, &si2, sizeof(si)) ) {
		EdbgOutputDebugString("TOC_Write ERROR: SectorInfo verify failed: %x %x %x %x\r\n",
			si.dwReserved1, si.bOEMReserved, si.bBadBlock, si.wReserved2);
		return FALSE;
	}

	//EdbgOutputDebugString("-TOC_Write\r\n");
	return TRUE;
}


/*
	@func   BOOL | WriteOSImageToBootMedia | Stores the image cached in RAM to the Boot Media.
	The image may be comprised of one or more BIN regions.
	@rdesc  TRUE = Success, FALSE = Failure.
	@comm
	@xref
*/
BOOL WriteOSImageToBootMedia(DWORD dwImageStart, DWORD dwImageLength, DWORD dwLaunchAddr)
{
	BYTE nCount;
	DWORD dwNumExts;
	PXIPCHAIN_SUMMARY pChainInfo = NULL;
	EXTENSION *pExt = NULL;
	DWORD dwBINFSPartLength = 0;
	HANDLE hPart, hPartEx;
	DWORD dwStoreOffset;
	DWORD dwMaxRegionLength[BL_MAX_BIN_REGIONS] = {0};
	DWORD dwChainStart, dwChainLength;
	DWORD dwBlock;
	
	//  Initialize the variables
	dwChainStart = dwChainLength = 0;

	OALMSG(OAL_FUNC, (TEXT("+WriteOSImageToBootMedia\r\n")));
	OALMSG(OAL_INFO, (TEXT("+WriteOSImageToBootMedia: g_dwTocEntry =%d, ImageStart: 0x%x, ImageLength: 0x%x, LaunchAddr:0x%x\r\n"),
							g_dwTocEntry, dwImageStart, dwImageLength, dwLaunchAddr));

	if ( !g_bBootMediaExist ) 
	{
		OALMSG(OAL_ERROR, (TEXT("ERROR: WriteOSImageToBootMedia: device doesn't exist.\r\n")));
		return(FALSE);
	}

	if ( !VALID_TOC(g_pTOC) ) 
	{
		OALMSG(OAL_WARN, (TEXT("WARN: WriteOSImageToBootMedia: INVALID_TOC\r\n")));
		if ( !TOC_Init(g_dwTocEntry, g_ImageType, dwImageStart, dwImageLength, dwLaunchAddr) ) 
		{
			OALMSG(OAL_ERROR, (TEXT("ERROR: INVALID_TOC\r\n")));
			return(FALSE);
		}
	}

	// Look in the kernel region's extension area for a multi-BIN extension descriptor.
	// This region, if found, details the number, start, and size of each BIN region.
	//
	for (nCount = 0, dwNumExts = 0 ; (nCount < g_BINRegionInfo.dwNumRegions); nCount++)
	{
		// Does this region contain nk.exe and an extension pointer?
		//
		pExt = (EXTENSION *)GetKernelExtPointer(g_BINRegionInfo.Region[nCount].dwRegionStart,
												g_BINRegionInfo.Region[nCount].dwRegionLength );
		if ( pExt != NULL)
		{
			// If there is an extension pointer region, walk it until the end.
			//
			while (pExt)
			{
				DWORD dwBaseAddr = g_BINRegionInfo.Region[nCount].dwRegionStart;
				pExt = (EXTENSION *)OEMMapMemAddr(dwBaseAddr, (DWORD)pExt);
				OALMSG(OAL_INFO, (TEXT("INFO: OEMLaunch: Found chain extenstion: '%s' @ 0x%x\r\n"), pExt->name, dwBaseAddr));
				if ((pExt->type == 0) && !strcmp(pExt->name, "chain information"))
				{