main.c.ori

支持三星原产的S3C2413开发板

	OALMSG(OAL_FUNC, (TEXT("+OEMPreDownload.\r\n")));

	// Create device name based on Ethernet address (this is how Platform Builder identifies this device).
	//
	OALKitlCreateName(BSP_DEVICE_PREFIX, pBSPArgs->kitl.mac, pBSPArgs->deviceId);
	OALMSG(OAL_INFO, (L"INFO: *** Device Name '%hs' ***\r\n", pBSPArgs->deviceId));

	if ( g_bUSBDownload == FALSE )
	{
		// If the user wants to use a static IP address, don't request an address 
		// from a DHCP server.  This is done by passing in a NULL for the DHCP 
		// lease time variable.  If user specified a static IP address, use it (don't use DHCP).
		//
		if (!(g_pBootCfg->ConfigFlags & CONFIG_FLAGS_DHCP))
		{
			// Static IP address.
			pBSPArgs->kitl.ipAddress = g_pBootCfg->EdbgAddr.dwIP;
			pBSPArgs->kitl.ipMask	 = g_pBootCfg->SubnetMask;
			pBSPArgs->kitl.flags	 &= ~OAL_KITL_FLAGS_DHCP;
			pdwDHCPLeaseTime = NULL;
			OALMSG(OAL_INFO, (TEXT("INFO: Using static IP address %s.\r\n"), inet_ntoa(pBSPArgs->kitl.ipAddress))); 
			OALMSG(OAL_INFO, (TEXT("INFO: Using subnet mask %s.\r\n"),	   inet_ntoa(pBSPArgs->kitl.ipMask))); 
		}
		else
		{
			pBSPArgs->kitl.ipAddress = 0;
			pBSPArgs->kitl.ipMask	= 0;
		}

		if ( !g_bDownloadImage)
		{
			return(BL_JUMP);
		}

		// Initialize the the TFTP transport.
		//
		g_DeviceAddr.dwIP = pBSPArgs->kitl.ipAddress;
		memcpy(g_DeviceAddr.wMAC, pBSPArgs->kitl.mac, (3 * sizeof(UINT16)));
		g_DeviceAddr.wPort = 0;

		if (!EbootInitEtherTransport(&g_DeviceAddr,
									 &pBSPArgs->kitl.ipMask,
									 &bGotJump,
									 pdwDHCPLeaseTime,
									 EBOOT_VERSION_MAJOR,
									 EBOOT_VERSION_MINOR,
									 BSP_DEVICE_PREFIX,
									 pBSPArgs->deviceId,
									 EDBG_CPU_ARM720,
									 dwBootFlags))
		{
			OALMSG(OAL_ERROR, (TEXT("ERROR: OEMPreDownload: Failed to initialize Ethernet connection.\r\n")));
			return(BL_ERROR);
		}


		// If the user wanted a DHCP address, we presumably have it now - save it for the OS to use.
		//
		if (g_pBootCfg->ConfigFlags & CONFIG_FLAGS_DHCP)
		{
			// DHCP address.
			pBSPArgs->kitl.ipAddress  = g_DeviceAddr.dwIP;
			pBSPArgs->kitl.flags	 |= OAL_KITL_FLAGS_DHCP;
		}
			
			OALMSG(1, (TEXT("_OEMPreDownload.\r\n")));
	}
	else
	{
		OALMSG(TRUE, (TEXT("Please send the Image through USB.\r\n"))); 
	}

	return(bGotJump ? BL_JUMP : BL_DOWNLOAD);
}


/*
	@func   BOOL | OEMReadData | Generically read download data (abstracts actual transport read call).
	@rdesc  TRUE = Success, FALSE = Failure.
	@comm	
	@xref   
*/
BOOL OEMReadData(DWORD dwData, PUCHAR pData)
{
/*
	OALMSG(OAL_FUNC, (TEXT("+OEMReadData.\r\n")));
	return(EbootEtherReadData(dwData, pData));
*/
// the following is from 2440 magneto. - 0106
	BOOL ret;
	int i;
	if ( g_bUSBDownload == FALSE )
	{
//		OALMSG(TRUE, (TEXT("\r\nINFO: dwData = %x, pData = %x\r\n"), dwData, pData));
		ret = EbootEtherReadData(dwData, pData);
//		OALMSG(TRUE, (TEXT("\r\n")));
//		for ( i = 0; i < dwData; i++ )
//		{
//			OALMSG(TRUE, (TEXT("<%x>"), *(pData+i)));
//			if ( i % 16 == 15 )
//				OALMSG(TRUE, (TEXT("\r\n")));
//		}
//		OALMSG(TRUE, (TEXT("\r\n")));

	    return(ret);
	}
	else
	{
//		OALMSG(TRUE, (TEXT("\r\nINFO: dwData = %x, pData = %x\r\n"), dwData, pData));
		ret = UbootReadData(dwData, pData);
//		OALMSG(TRUE, (TEXT("\r\n")));
//		for ( i = 0; i < dwData; i++ )
//		{
//			OALMSG(TRUE, (TEXT("<%x>"), *(pData+i)));
//			if ( i % 16 == 15 )
//				OALMSG(TRUE, (TEXT("\r\n")));
//		}
//		OALMSG(TRUE, (TEXT("\r\n")));
		return(ret);
	}
}


/*
	@func   void | OEMShowProgress | Displays download progress for the user.
	@rdesc  N/A.
	@comm	
	@xref   
*/
void OEMShowProgress(DWORD dwPacketNum)
{
	OALMSG(OAL_FUNC, (TEXT("+OEMShowProgress.\r\n")));
}


/*
	@func   void | OEMLaunch | Executes the stored/downloaded image.
	@rdesc  N/A.
	@comm	
	@xref   
*/

void OEMLaunch( DWORD dwImageStart, DWORD dwImageLength, DWORD dwLaunchAddr, const ROMHDR *pRomHdr )
{
	DWORD dwPhysLaunchAddr;
	EDBG_ADDR EshellHostAddr;
	EDBG_OS_CONFIG_DATA *pCfgData;	

	OALMSG(1, (TEXT("+OEMLaunch.\r\n")));
	//OALMSG(TRUE, (TEXT("+OEMLaunch.\r\n")));

	// If the user requested that a disk image (stored in RAM now) be written to the SmartMedia card, so it now.
	//
	if (g_bDownloadImage && (g_pBootCfg->ConfigFlags & TARGET_TYPE_NAND))
	{
		// Since this platform only supports RAM images, the image cache address is the same as the image RAM address.
		//

		switch (g_ImageType) 
		{
			case IMAGE_TYPE_STEPLDR:
				if (!WriteRawImageToBootMedia(dwImageStart, dwImageLength, dwLaunchAddr))
				{
					//OALMSG(OAL_ERROR, (TEXT("ERROR: OEMLaunch: Failed to store image to Smart Media.\r\n")));
					goto CleanUp;
				}

				// DonGo
				//Mark_BadBlock(NBOOT_BLOCK, NBOOT_BLOCK+NBOOT_BLOCK_SIZE-1);
				//Mark_BadBlock(TOC_BLOCK, TOC_BLOCK+TOC_BLOCK_SIZE-1);

				OALMSG(TRUE, (TEXT("INFO: Step loader image stored to Smart Media.  Please Reboot.  Halting...\r\n")));
				while(1)
				{
					// Wait...
				}
				break;
			
			case IMAGE_TYPE_EBOOT:
				g_pTOC->id[0].dwLoadAddress = dwImageStart;
				g_pTOC->id[0].dwTtlSectors = FILE_TO_SECTOR_SIZE(dwImageLength);
				if (!WriteRawImageToBootMedia(dwImageStart, dwImageLength, dwLaunchAddr))
				{
					OALMSG(OAL_ERROR, (TEXT("ERROR: OEMLaunch: Failed to store image to Smart Media.\r\n")));
					goto CleanUp;
				}
				if (dwLaunchAddr && (g_pTOC->id[0].dwJumpAddress != dwLaunchAddr))
				{
					g_pTOC->id[0].dwJumpAddress = dwLaunchAddr;
					if ( !TOC_Write() ) {
						EdbgOutputDebugString("*** OEMLaunch ERROR: TOC_Write failed! Next boot may not load from disk *** \r\n");
					}
					// DonGo
					//Mark_BadBlock(EBOOT_BLOCK, EBOOT_BLOCK+EBOOT_BLOCK_SIZE-1);
					//Mark_BadBlock(TOC_BLOCK, TOC_BLOCK+TOC_BLOCK_SIZE-1);
					
					TOC_Print();
				}
				
				OALMSG(TRUE, (TEXT("INFO: Eboot image stored to Smart Media.  Please Reboot.  Halting...\r\n")));
				while(1)
				{
					// Wait...
				}				
								
				break;

			case IMAGE_TYPE_NKBIN:
				g_pTOC->id[g_dwTocEntry].dwLoadAddress = dwImageStart;
				g_pTOC->id[g_dwTocEntry].dwTtlSectors = FILE_TO_SECTOR_SIZE(dwImageLength);
				if (!WriteOSImageToBootMedia(dwImageStart, dwImageLength, dwLaunchAddr))
				{
					OALMSG(OAL_ERROR, (TEXT("ERROR: OEMLaunch: Failed to store image to Smart Media.\r\n")));
					goto CleanUp;
				}

				if (dwLaunchAddr && (g_pTOC->id[g_dwTocEntry].dwJumpAddress != dwLaunchAddr))
				{
					g_pTOC->id[g_dwTocEntry].dwJumpAddress = dwLaunchAddr;
					if ( !TOC_Write() ) {
						EdbgOutputDebugString("*** OEMLaunch ERROR: TOC_Write failed! Next boot may not load from disk *** \r\n");
					}
					TOC_Print();
				}
				else
				{
					dwLaunchAddr= g_pTOC->id[g_dwTocEntry].dwJumpAddress;
					EdbgOutputDebugString("INFO: using TOC[%d] dwJumpAddress: 0x%x\r\n", g_dwTocEntry, dwLaunchAddr);
				}
								
				break;
		}
	}
	else if(g_bDownloadImage)
	{
		switch (g_ImageType) 
		{
			case IMAGE_TYPE_STEPLDR:
				//OALMSG(TRUE, (TEXT("Stepldr image can't launch from ram.\r\n")));
				//OALMSG(TRUE, (TEXT("You should program it into flash.\r\n")));
				SpinForever();
				break;
			case IMAGE_TYPE_EBOOT:
				//OALMSG(TRUE, (TEXT("Eboot image can't launch from ram.\r\n")));
				//OALMSG(TRUE, (TEXT("You should program it into flash.\r\n")));
				SpinForever();
				break;
			default:
				break;
		}
	}

	OALMSG(1, (TEXT("waitforconnect\r\n")));
	// Wait for Platform Builder to connect after the download and send us IP and port settings for service
	// connections - also sends us KITL flags.  This information is used later by the OS (KITL).
	//
	#if 1
	if (g_bDownloadImage && g_bWaitForConnect)
	{
		memset(&EshellHostAddr, 0, sizeof(EDBG_ADDR));

		g_DeviceAddr.dwIP  = pBSPArgs->kitl.ipAddress;
		memcpy(g_DeviceAddr.wMAC, pBSPArgs->kitl.mac, (3 * sizeof(UINT16)));
		g_DeviceAddr.wPort = 0;

		if (!(pCfgData = EbootWaitForHostConnect(&g_DeviceAddr, &EshellHostAddr)))
		{
			//OALMSG(1, (TEXT("ERROR: OEMLaunch: EbootWaitForHostConnect failed.\r\n")));
			goto CleanUp;
		}

		// If the user selected "passive" KITL (i.e., don't connect to the target at boot time), set the
		// flag in the args structure so the OS image can honor it when it boots.
		//
		if (pCfgData->KitlTransport & KTS_PASSIVE_MODE)
		{
			pBSPArgs->kitl.flags |= OAL_KITL_FLAGS_PASSIVE;
		}
	}
	#endif
	// If a launch address was provided, we must have downloaded the image, save the address in case we
	// want to jump to this image next time.  If no launch address was provided, retrieve the last one.
	//
	if (dwLaunchAddr && (g_pTOC->id[g_dwTocEntry].dwJumpAddress != dwLaunchAddr))
	{
		g_pTOC->id[g_dwTocEntry].dwJumpAddress = dwLaunchAddr;
	}
	else
	{
		dwLaunchAddr= g_pTOC->id[g_dwTocEntry].dwJumpAddress;
		OALMSG(OAL_INFO, (TEXT("INFO: using TOC[%d] dwJumpAddress: 0x%x\r\n"), g_dwTocEntry, dwLaunchAddr));
	}

	// Jump to downloaded image (use the physical address since we'll be turning the MMU off)...
	//
	dwPhysLaunchAddr = (DWORD)OALVAtoPA((void *)dwLaunchAddr);
	OALMSG(TRUE, (TEXT("INFO: OEMLaunch: Jumping to Physical Address 0x%Xh (Virtual Address 0x%Xh)...\r\n\r\n\r\n"), dwPhysLaunchAddr, dwLaunchAddr));

	// Jump...
	//
	Launch(dwPhysLaunchAddr);


CleanUp:

	OALMSG(TRUE, (TEXT("ERROR: OEMLaunch: Halting...\r\n")));
	SpinForever();
}


//------------------------------------------------------------------------------
//
//  Function Name:  OEMVerifyMemory( DWORD dwStartAddr, DWORD dwLength )
//  Description..:  This function verifies the passed address range lies
//				  within a valid region of memory. Additionally this function
//				  sets the g_ImageType if the image is a boot loader. 
//  Inputs.......:  DWORD		   Memory start address
//				  DWORD		   Memory length
//  Outputs......:  BOOL - true if verified, false otherwise
//
//------------------------------------------------------------------------------

BOOL OEMVerifyMemory( DWORD dwStartAddr, DWORD dwLength )
{

	OALMSG(OAL_FUNC, (TEXT("+OEMVerifyMemory.\r\n")));

	// Is the image being downloaded the stepldr?
	if ((dwStartAddr >= STEPLDR_RAM_IMAGE_BASE) &&
		((dwStartAddr + dwLength - 1) < (STEPLDR_RAM_IMAGE_BASE + STEPLDR_RAM_IMAGE_SIZE)))
	{
		OALMSG(1, (TEXT("Stepldr image\r\n")));
		g_ImageType = IMAGE_TYPE_STEPLDR;	 // Stepldr image.
		return TRUE;
	}
	// Is the image being downloaded the bootloader?
	else if ((dwStartAddr >= EBOOT_STORE_ADDRESS) &&
		((dwStartAddr + dwLength - 1) < (EBOOT_STORE_ADDRESS + EBOOT_STORE_MAX_LENGTH)))
	{
		OALMSG(1, (TEXT("Eboot image\r\n")));
		g_ImageType = IMAGE_TYPE_EBOOT;	 // Eboot image.
		return TRUE;
	}

	// Is it a ram image?
	else if ((dwStartAddr >= ROM_RAMIMAGE_START) &&
		((dwStartAddr + dwLength - 1) < (ROM_RAMIMAGE_START + ROM_RAMIMAGE_SIZE  + 0x10000000)))
	{
		OALMSG(1, (TEXT("RAM image\r\n")));
		g_ImageType = IMAGE_TYPE_NKBIN;
		return TRUE;
	}
	else if (!dwStartAddr && !dwLength)
	{
		OALMSG(TRUE, (TEXT("Don't support raw image\r\n")));
		g_ImageType = IMAGE_TYPE_RAWBIN;
		return FALSE;
	}

	// HACKHACK: get around MXIP images with funky addresses
	OALMSG(TRUE, (TEXT("BIN image type unknow\r\n")));

#if 1
	OALMSG(TRUE, (TEXT("dwStartAddr, dwLength=%xh,%xh\r\n"), dwStartAddr, dwLength));
#endif

	OALMSG(OAL_FUNC, (TEXT("_OEMVerifyMemory.\r\n")));

	return FALSE;
}

/*
	@func   void | OEMMultiBINNotify | Called by blcommon to nofity the OEM code of the number, size, and location of one or more BIN regions,
									   this routine collects the information and uses it when temporarily caching a flash image in RAM prior to final storage.
	@rdesc  N/A.
	@comm
	@xref
*/
void OEMMultiBINNotify(const PMultiBINInfo pInfo)
{
	BYTE nCount;
	DWORD g_dwMinImageStart;

	OALMSG(OAL_FUNC, (TEXT("+OEMMultiBINNotify.\r\n")));

	if (!pInfo || !pInfo->dwNumRegions)
	{
		OALMSG(OAL_WARN, (TEXT("WARNING: OEMMultiBINNotify: Invalid BIN region descriptor(s).\r\n")));
		return;
	}

	if (!pInfo->Region[0].dwRegionStart && !pInfo->Region[0].dwRegionLength)
	{
		return;
	}

	g_dwMinImageStart = pInfo->Region[0].dwRegionStart;

	OALMSG(TRUE, (TEXT("\r\nDownload BIN file information:\r\n")));
	OALMSG(TRUE, (TEXT("-----------------------------------------------------\r\n")));
	for (nCount = 0 ; nCount < pInfo->dwNumRegions ; nCount++)
	{
		OALMSG(TRUE, (TEXT("[%d]: Base Address=0x%x  Length=0x%x\r\n"),
			nCount, pInfo->Region[nCount].dwRegionStart, pInfo->Region[nCount].dwRegionLength));
		if (pInfo->Region[nCount].dwRegionStart < g_dwMinImageStart)
		{
			g_dwMinImageStart = pInfo->Region[nCount].dwRegionStart;
			if (g_dwMinImageStart == 0)
			{
				OALMSG(OAL_WARN, (TEXT("WARNING: OEMMultiBINNotify: Bad start address for region (%d).\r\n"), nCount));
				return;
			}
		}
	}

	memcpy((LPBYTE)&g_BINRegionInfo, (LPBYTE)pInfo, sizeof(MultiBINInfo));

	OALMSG(TRUE, (TEXT("-----------------------------------------------------\r\n")));
	OALMSG(OAL_FUNC, (TEXT("_OEMMultiBINNotify.\r\n")));
}

/////////////////////// START - Stubbed functions - START //////////////////////////////
/*
	@func   void | SC_WriteDebugLED | Write to debug LED.
	@rdesc  N/A.
	@comm	
	@xref   
*/

void SC_WriteDebugLED(USHORT wIndex, ULONG dwPattern)
{
	// Stub - needed by NE2000 EDBG driver...
	//