// Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).

 // All rights reserved.

 // This component and the accompanying materials are made available

 // under the terms of the License "Eclipse Public License v1.0"

 // which accompanies this distribution, and is available

 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

 //

 // Initial Contributors:

 // Nokia Corporation - initial contribution.

 //

 // Contributors:

 //

 // Description:

 // improvised boot loader mechanism

 // 

 //

 /**

  @file

 */

 #include <e32const.h>

 #include <e32const_private.h>

 #include <e32std.h>

 #include <e32std_private.h>

 #include <e32svr.h>

 #include <e32cons.h>

 #include <f32file.h>

 #include <hal.h>

 #include <u32hal.h>

 #include "bootloader_variantconfig.h"

 #include <nkern/nk_trace.h>

 #include <e32twin.h>

 #include <e32rom.h>

 #include <hal.h>

 #include <d32ethernet.h>

 #define FILE_ID	0x594D555D

 #include "bootldr.h"

 #include "ubootldrldd.h"

 #include <d32comm.h>

 #ifdef _DEBUG_CORELDR_

 #define WAIT_TO_REBOOT  10000000

 #else

 #define WAIT_TO_REBOOT    100000

 #endif

 #define addr_to_page(a) (a&~(0x1000-1))

 _LIT(KPanicText,"UBOOTLDR");

 _LIT(LDD_NAME, "Enet");

 _LIT(PDD_NAME, "Ethernet");

 // Memory

 RUBootldrLdd Ldd;

 RChunk TheRamChunk;		// This is the download area

 /// Global number of seconds to delay before reboot

 void GetChunk()

 	{

 	TInt PageSize;

 	UserHal::PageSizeInBytes(PageSize);

 	TInt r = User::LoadLogicalDevice(KBootldrLddName);

 	r = Ldd.Open();

 	if (r!=KErrNone)

 			{

 			PrintToScreen(_L("FAULT due to LDD open\r\n"));

 			BOOT_FAULT();

 			}

 	TUint8* kernelAddress;

 	r=Ldd.CreateChunk(KRamTargetSize,(TAny**)&kernelAddress);

 	if (r!=KErrNone)

 			{

 			PrintToScreen(_L("FAULT due to chunk create\r\n"));

 			BOOT_FAULT();

 			}

 	r = Ldd.CommitMemory(KRamTargetSize,addr_to_page(KRamTargetAddr));

 	if (r!=KErrNone)

 			{

 			PrintToScreen(_L("FAULT due to commit\r\n"));

 			BOOT_FAULT();

 			}

 	r = Ldd.GetChunkHandle(TheRamChunk);

 	if (r!=KErrNone)

 			{

 			PrintToScreen(_L("FAULT due to handle\r\n"));

 			BOOT_FAULT();

 			}

 	TUint8* Base = TheRamChunk.Base();

 	ActualDestinationAddress = (TUint32*)Base;

 	}

 // method of getting the date string at build time

 // Taken from e32test\device\t_usbco22.cpp

 #define WIDEN2(x) L ## x

 #define WIDEN(x) WIDEN2(x)

 #define __WDATE__ WIDEN(__DATE__)

 //////////////////////////////////////////////////////////////////////////////

 //

 // Application entry point

 //

 //////////////////////////////////////////////////////////////////////////////

 LOCAL_C void RunAppL()

 	{

 	TInt r;

 	// Get the memory download area mapped into a chunk

 	GetChunk();

 	// Initialise our graphical screen

 	InitDisplay();

 #ifdef __USE_VARIANT_INIT__

 	// The variant initialisation function is likely to perform bootloader

 	// configuration or print debug information.

 	VariantInit();

 #endif

 #ifdef __USE_USBMS__

 	// If the bootloader is in the USB Mass Storage mode (indicated by the Variant

 	// initialisation routine) then call that method first; it will either read/boot

 	// an image, start the USB Mass Storage boot application or return.

 	if ((LoadDevice==ELoadUSBMS) || (LoadDevice==EBootUSBMS))

 		TryUSBMS();

 #endif

 	// Start the menu UI thread, this will cause a console to overwrite the framebuffer

 	StartMenu();

 	ClearScreen();

 	PrintToScreen(_L("Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).\r\n"));

 	PrintToScreen(_L("BootLoader %d.%d\r\n"), BOOTLDR_VERSION_MAJOR, BOOTLDR_VERSION_MINOR);

 	PrintToScreen(_L("Platform build %d\n\rBuilt: %s\r\n"), PLATFORM_BUILD, __WDATE__);

 	// Load Ethernet driver:  it might need to load to set the MAC address in HAL

     TInt pddLoaded = KErrUnknown;

 	TInt lddLoaded = KErrUnknown;

 	TInt opened    = KErrUnknown;

 	RBusDevEthernet card;

     pddLoaded = User::LoadPhysicalDevice(PDD_NAME);

 	if (pddLoaded == KErrNone)

 		{

 		lddLoaded = User::LoadLogicalDevice(LDD_NAME);

 		if (lddLoaded == KErrNone)

 			{

 			opened = card.Open(0);

 			User::After(2000);

 			}

 		}

 	TInt serialNum;

 	r = HAL::Get(HAL::ESerialNumber, serialNum);

 	if (r == KErrNone && serialNum != 0)

 		{

 		// we only show the serial number if it was available from HAL and set to something

 		PrintToScreen(_L("MAC Address: 00-0a-%02x-%02x-%02x-%02x\r\n"),

 			(serialNum & 0xFF000000) >> 24,

 			(serialNum & 0x00FF0000) >> 16,

 			(serialNum & 0x0000FF00) >>  8,

 			(serialNum & 0x000000FF)

 			);

 		}

 	// Free the Ethernet driver now we're done getting the MAC address

 	if (opened == KErrNone)

 		{

 		card.Close();

 		}

 	if (lddLoaded == KErrNone)

 		{

 	    User::FreeLogicalDevice(LDD_NAME);

 		}

 	if (pddLoaded == KErrNone)

 		{

 	    User::FreePhysicalDevice(PDD_NAME);

 		}

 	if (LoadDevice == EBootEMMC)

 		{

 		if ( SearchDrivesRaw() )

 			{

 			DoDownload();

 			}

 		}

 #ifdef __USE_LOCAL_DRIVES__

 	// The next method to test is reading an image file from removable media

 	if (SearchDrives())

 		DoDownload();

 #endif

 	// The last method is to attempt to download an image over the serial port

 	switch (SerialBaud)

 		{

 		case EBps115200:

 			PrintToScreen(_L("Initiating YModem-G on port %d @ 115200 baud\r\n"), SerialDownloadPort);

 			break;

 		case EBps230400:

 			PrintToScreen(_L("Initiating YModem-G on port %d @ 230400 baud\r\n"), SerialDownloadPort);

 			break;

 		default:

 			PrintToScreen(_L("Initiating YModem-G download on port %d\r\n"), SerialDownloadPort);

 			SerialBaud = EBps115200;

 			break;

 		}

 	r=InitSerialDownload(SerialDownloadPort);

 	if (r!=KErrNone)

 		{

 		RDebug::Print(_L("FAULT: YModem-G download returned %d\r\n"),r);

 		BOOT_FAULT();

 		}

 	PrintToScreen(_L("Receiving %lS\r\nSize %d\r\n"),&FileName,FileSize);

 	DoDownload();

 }

 TUint Check(const TUint32* aPtr, TInt aSize)

 	{

 	TUint sum=0;

 	aSize/=4;

 	while (aSize-->0)

 		sum+=*aPtr++;

 	return sum;

 	}

 TUint CheckSumRom()

 	{

 #if 0

 	//

 	// This code was obtained from t_romchk in the e32tests, it was useful for

 	// checking that roms were not getting corrupted during the download

 	// process.

 	//

 	// However, it is not a universal checksum and is not suitable for all

 	// types of images it is therefore being disabled until we need it again.

 	//

 	PrintToScreen(_L("Checking ROM contents...\r\n"));

 	const TRomHeader* romHdr = (const TRomHeader*)DestinationAddress();

 	TInt size = romHdr->iUnpagedUncompressedSize;

 	const TUint32* addr = (TUint32*)romHdr;

 	PrintToScreen(_L("ROM at %x, size %x\r\n"),addr,size);

 	TUint checkSum = Check(addr,size);

 	// hack the checksum because ROMBUILD is broken

 	checkSum -= (romHdr->iRomSize-size)/4; // adjust for missing 0xffffffff

 	checkSum -= romHdr->iCompressionType;

 	checkSum -= romHdr->iUnpagedCompressedSize;

 	checkSum -= romHdr->iUnpagedUncompressedSize;

 	TUint expectedChecksum = 0x12345678;

 	if (checkSum != expectedChecksum)

 		{

 		PrintToScreen(_L("Fail: Checksum = %8x, expected %8x\r\n"),checkSum,expectedChecksum);

 		RDebug::Print(_L("Fail: Checksum = %8x, expected %8x\r\n"),checkSum,expectedChecksum);

 		BOOT_FAULT();

 		}

 	else

 		{

 		PrintToScreen(_L("Pass: Checksum = %8x, expected %8x\r\n"),checkSum,expectedChecksum);

 		RDebug::Print(_L("Pass: Checksum = %8x, expected %8x\r\n"),checkSum,expectedChecksum);

 		}

 #endif

 	return 0;

 	}

 GLDEF_C void DoDownload()

 /*

  The DoDownload method is ultimatly called by all the download routines, it is

  responsible for unzipping images as well as stripping off EPOC headers and

  starting the flash writing methods.

  */

 	{

 	TInt r;

 	// If the image is zipped start the unzip thread

 	if (ImageZip)

 		{

 		// initialise unzip

 		PrintToScreen(_L("Loading zip ..\r\n"));

 		r=DoZipDownload(bootFile);

 		if (r!=KErrNone)

 			{

 			PrintToScreen(_L("\r\nFAULT due to zip %d\r\n"), r);

 			BOOT_FAULT();

 			}

 		PrintToScreen(_L("\r\nZip download complete.\r\n"));

 		}

 	else

 		{

 		LoadSize=FileSize;

 		if( ImageDeflated )

     		{

     		PrintToScreen(_L("\r\n\r\nLoading deflated image...\r\n"));

     	    ImageHeaderPresent=EFalse;

     	    DoDeflateDownload();

     	    PrintToScreen(_L("Deflated image download complete.\r\n"));	  

     		}

 		else

     		{

     		// If it isn't a zipped or deflated image then the filesize is the image size -

     		// check that it is valid for a Symbian image and determine whether to

     		// remove any header that may be present.

     		TInt size_mod_4k=FileSize & 0xfff;

     		if (size_mod_4k==0)

     			{

     			ImageHeaderPresent=EFalse;

     			PrintToScreen(_L("Image header not present.\r\n"));

     			}

     		else if (size_mod_4k==256)

     			{

     			ImageHeaderPresent=ETrue;

     			PrintToScreen(_L("Image header present.\r\n"));

     			}

     		else

     			{

     		    PrintToScreen(_L("\r\n\r\nInvalid size\r\n"));

     			BOOT_FAULT();	

     			}

     		ImageSize=ImageHeaderPresent ? LoadSize-256 : LoadSize;

     		TUint8* pD=(TUint8*)DestinationAddress();

     		TInt block_size;

     		if (FileSize==0)

     			block_size=0x1000;		// YModem download with unknown size

     		else

     			block_size=Max(0x1000,FileSize>>8);

     		block_size=(block_size+0xfff)&~0xfff;

     		if (FileSize>0)

     			InitProgressBar(0,(TUint)FileSize,_L("LOAD"));

     		r=KErrNone;

 // If target location is flash start the flasher thread

 #ifdef __SUPPORT_FLASH_REPRO__

     		if (LoadToFlash)

     			{

     			r=InitFlashWrite();

     			if (r!=KErrNone)

     				{

     				PrintToScreen(_L("FAULT due to InitFlashWrite return %d\r\n"), r);

     				BOOT_FAULT();

     				}

     			}

 #endif

     		while (r==KErrNone)

     			{

     			TInt len=block_size;

     			r=ReadInputData(pD,len);

     			if (r!=KErrNone && r!=KErrEof)

     				break;

     			pD+=len;

     			ImageReadProgress+=len;

     			if (FileSize>0)

     				{

     				UpdateProgressBar(0,(TUint)ImageReadProgress);

 				}

 #ifdef __SUPPORT_FLASH_REPRO__

     			if (LoadToFlash)

     				NotifyDataAvailable(ImageReadProgress);

 #endif

     			}

     		if (r!=KErrEof)	

     			{

     			PrintToScreen(_L("FAULT due to EOF. %d bytes read.\r\n"), ImageReadProgress);

     			BOOT_FAULT();

     			}

     		else

     			PrintToScreen(_L("Loaded %d bytes.\r\n"), ImageReadProgress);

     		if (ImageReadProgress < LoadSize)

     			ImageSize=ImageHeaderPresent ? ImageReadProgress-256 : ImageReadProgress;

 #ifdef __SUPPORT_FLASH_REPRO__

     		if (LoadToFlash)

     			NotifyDownloadComplete();

 #endif

     		}

 		}

 	if (CloseInputFunction)

 		CloseInput();

 	if (LoadToFlash)

 		{

 		// In the load to flash scenario it will boot the image.

 		while(1)

 			User::After(10000000);

 		}

 	// Booting from Ram - remove the header

 	if (ImageHeaderPresent)

 		{

 		TUint8* pI=(TUint8*)DestinationAddress();

 		Mem::Move(pI,pI+256,ImageSize);

 		}

 	CheckSumRom();

 	PrintToScreen(_L("Booting Image...\r\n"));

 	// Restart board with "boot image + located in ram"

 	User::After(WAIT_TO_REBOOT);

 	HAL::Set(HAL::EDisplayState, 0);

 	Restart(KtRestartReasonBootRestart | KtRestartReasonRAMImage);

 	//  *** NOTREACHED ***

 	}

 GLDEF_C TInt E32Main()

 	{

 	CTrapCleanup* cleanup=CTrapCleanup::New();

 	// Make bootloader panics fault the system. This means that this process

 	// will NEVER END

 	User::SetCritical(User::ESystemPermanent);

 	TRAPD(error,RunAppL());

 	__ASSERT_ALWAYS(!error, User::Panic(KPanicText, error));

 	delete cleanup;

 	PrintToScreen(_L("Boot loader ended abnormally")); 

 	Ldd.Close();

 	return 0;

 	}