// 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;
	}