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

 #define FILE_ID	0x594D555D

 #include "bootldr.h"

 void CloseAndDeleteFile();

 RFs TheFs;

 // Extra stuff to determine inner compression from the ROM header

 #include <e32rom.h>

 extern TInt memcmp1(const TUint8* aTrg, const TUint8* aSrc, TInt aLength);

 // XXX FIXED DRIVE PATH

 const TPtrC filePath=_L("d:\\");

 #if defined(__SUPPORT_UNZIP__)

 const TBool ZipIsSupported = ETrue;

 #else

 const TBool ZipIsSupported = EFalse;

 #endif

 #if defined(__SUPPORT_FLASH_REPRO__)

 const TBool FlashIsSupported = ETrue;

 #else

 const TBool FlashIsSupported = EFalse;

 #endif

 typedef struct 

 	{

 	TPtrC filename;

 	TBool Zip;        // set to ETrue if this file is a ZIP file

 	TBool Flash;      // set to ETrue if this file is to be written to flash

 	TBool BootLoader; // set to ETrue if this file is to be flashed to the BootLoader address

 	TBool Delete;     // set to ETrue if this file is to be deleted after loading into RAM

 	}

 	TFileTypes;

 TFileTypes supportedFileTypes [] =

 	{

 		// Name              Zip     Flash   BootLoader  Delete

 		{_L("FLASHLDR.ZIP"), ETrue,  ETrue,  ETrue,      ETrue   },

 		{_L("FLASHLDR.BIN"), EFalse, ETrue,  ETrue,      ETrue   },

 		{VARIANT_ZIP,        ETrue,  EFalse, EFalse,     EFalse  },

 		{VARIANT_BIN,        EFalse, EFalse, EFalse,     EFalse  },

 		{_L("SYS$ROM.ZIP"),  ETrue,  EFalse, EFalse,     EFalse  },

 		{_L("SYS$ROM.BIN"),  EFalse, EFalse, EFalse,     EFalse  },

         {_L("FLASHIMG.ZIP"), ETrue,  ETrue,  EFalse,     EFalse  },

 		{_L("FLASHIMG.BIN"), EFalse, ETrue,  EFalse,     EFalse  },

         {_L("BOOTLDR.ZIP"),  ETrue,  ETrue,  ETrue,      EFalse  },

 		{_L("BOOTLDR.BIN"),  EFalse, ETrue,  ETrue,      EFalse  },

 		{_L("COREIMG.BIN"),  EFalse, EFalse, EFalse,     ETrue   },

 		{_L(""),0} // Last Entry - this empty row is used in code to detect table end

 	};

 GLDEF_C TBool SearchDrivesRaw()

 	{

 	// Scan local drives directly (i.e. via TLocalDrv rather than RFS)

 	PrintToScreen(_L("Checking local drives directly.\r\n"));

 	TDriveInfoV1Buf diBuf;

 	UserHal::DriveInfo(diBuf);

 	TDriveInfoV1 &di=diBuf();

 	LocDrvChg = EFalse;

 	LocDrvPos = 0;

 	TInt LocalDriveNum = KErrNotFound;

 	TInt r = KErrNone;

 	TInt n=0;

 	for ( ; n<KMaxLocalDrives && LocalDriveNum == KErrNotFound; n++)

 		{

 		r = LocDrv.Connect(n, LocDrvChg);

 		if(r != KErrNone)

 			{

 			RDebug::Print(_L("\nDrive %d: TBusLocalDrive::Connect() failed %d"), n, r);

 			continue;

 			}	

 	    TLocalDriveCapsV5Buf capsBuf;

 	    TLocalDriveCapsV5& caps = capsBuf();

 		r = LocDrv.Caps(capsBuf);

 		if(r != KErrNone)

 			{

 			RDebug::Print(_L("\nDrive %d: TBusLocalDrive::Caps() failed %d"), n, r);

 			continue;

 			}

 		else

 			{

 			PrintToScreen(_L("Found Drive %d OK\r\n"),n);

 			RDebug::Print(_L("\nDrive %d: %S"), n, &di.iDriveName[n]);

 			RDebug::Print(_L("PartitionType %X"), caps.iPartitionType);

 			RDebug::Print(_L("PartitionSize %ld"), caps.iSize);

 			// Check that drive is labelled as MMC or SDIO, 

 			// note that this is a platform specific label...

 			if ((di.iDriveName[n].MatchF(_L("MultiMediaCard0")) == KErrNone) ||

 			    (di.iDriveName[n].MatchF(_L("SDIOCard0")) == KErrNone))

 				{

 				if (caps.iPartitionType == KPartitionTypeROM)

 					{

 					RDebug::Print(_L("- ROM Partition"));

 					LocalDriveNum = n;

 					FileSize = caps.iSize;

 					break;

 					}

 				}

 			CloseLocalDrive();

 			}

 		}

 	if (LocalDriveNum == KErrNotFound)

 		{

 		RDebug::Print(_L("No ROM Partitions found"));

 		return EFalse;

 		}

 	else

 		{

 		RDebug::Print(_L("Query ROM in drive %d"), LocalDriveNum);

 		}

 	InputFunction=ReadFromLocalDrive;

 	CloseInputFunction=CloseLocalDrive;

 	RDebug::Print(_L("Determine the compression"));

     r = GetInnerCompression(ImageDeflated, RomLoaderHeaderExists);

     if(KErrNone != r)

         {

         PrintToScreen(_L("Unable to determine the compression!\r\n"));

 	    BOOT_FAULT();    

         }

     else

     	{

     	// Put position back to start

     	LocDrvPos = 0;

     	}

 	return ETrue;

 	}

 TInt ReadFromLocalDrive(TUint8* aDest, TInt& aLength)

 	{

 	// construct as TPtr8(TUint8 *aBuf, TInt aMaxLength);

 	// .. because TBusLocalDrive.Read only understands descriptors

 	TPtr8 d(aDest, aLength);

 	TInt r = LocDrv.Read(LocDrvPos,aLength,d);

 	LocDrvPos+=aLength;

 	if (LocDrvPos >= FileSize)

 		{

 		// ROM read completely

 		r = KErrEof;

 		}

 	return r;

 	}

 void CloseLocalDrive()

 	{

 	LocDrv.Disconnect();

 	}

 GLDEF_C TBool SearchDrives()

 	{

 	// set up the list of files to look for -- this code will search through

 	// all available drives until it finds one of these files in a root

 	// directory

 	PrintToScreen(_L("Checking local drives.\r\n"));

 	// search for files

 	TInt r = TheFs.Connect();

 	if (r != KErrNone)

 		{

 		RDebug::Print(_L("FAULT: Connecting RFs returned %d\r\n"),r);

 		BOOT_FAULT();

 		}

 	TFindFile finder(TheFs);

 	// for each file in the list

 	TInt NrChecked = 0;

 	r = KErrNotFound;

 	while ( (*(supportedFileTypes[NrChecked].filename.Ptr()) != 0) && (r == KErrNotFound))

 		{

 		if (  (!ZipIsSupported && (supportedFileTypes[NrChecked].Zip))

 		   || (!FlashIsSupported && (supportedFileTypes[NrChecked].Flash))

 		   )

 			{

 			//skip ZIP/FLASH file types if they aren't supported

 			}

 		else

 			{

 			TPtrC thisFile = supportedFileTypes[NrChecked].filename;

 			r = finder.FindByDir(thisFile, filePath);

 			if (r == KErrNone)

 				PrintToScreen(_L("Found %s\r\n"), thisFile.Ptr());

 			}

 		NrChecked++;

 		}

 	// if found

 	if (r == KErrNone)

 		{

 		// setup some flags 

 		LoadFile=--NrChecked; // predecrement since this was incremented at the end of the last loop

 		LoadDevice=ELoadDrive;

 		const TPtrC bootFileName = finder.File();

 		PrintToScreen(_L("Opening: %s\r\n"), supportedFileTypes[NrChecked].filename.Ptr());

 		r = bootFile.Open(TheFs, bootFileName, EFileRead);

 		if (r != KErrNone)

 			{

 			PrintToScreen(_L("Bootfile failed to open - err %d.\r\n"),r);

 			BOOT_FAULT();

 			}

 		ImageZip         = supportedFileTypes[NrChecked].Zip;

 		LoadToFlash      = supportedFileTypes[NrChecked].Flash;

 		FlashBootLoader  = supportedFileTypes[NrChecked].BootLoader;

 		InputFunction=ReadFromFile;

 		CloseInputFunction = supportedFileTypes[NrChecked].Delete ? CloseAndDeleteFile : CloseFile;

         if( !ImageZip)

             {

             r = GetInnerCompression(ImageDeflated, RomLoaderHeaderExists);

             if(KErrNone != r)

                 {

                 PrintToScreen(_L("Unable to determine the compression!\r\n"));

 			    BOOT_FAULT();    

                 }

             else

             	{

             	// Move file pos back to the beginning

             	TInt pos = 0;

                 r = bootFile.Seek(ESeekStart, pos);

             	}

             }

 		r = bootFile.Size(FileSize);

 		if (r == KErrNone)

 			{

 			PrintToScreen(_L("Opened, size: %d bytes.\r\n"), FileSize);

 			if(ImageDeflated)

     			{

     			PrintToScreen(_L("ROM Image is deflated.\r\n"));    

     			}

 			}

 		else

 			{

 			PrintToScreen(_L("Unable to read file size\r\n"));

 			BOOT_FAULT();

 			}

 		// Found image - return true

 		return ETrue;

 		}

 	// else NOT FOUND

 	return EFalse;

 	}

 TInt ReadFromFile(TUint8* aDest, TInt& aLength)

 	{

 	// construct as TPtr8(TUint8 *aBuf, TInt aMaxLength);

 	// .. because RFile.Read only understands descriptors

 	TPtr8 d(aDest, aLength);

 	TInt r = bootFile.Read(d);

 	if (d.Length() < aLength) // may happen at the end of a file

 		{

 		aLength = d.Length();

 		}

 	if (d.Length() == 0)	// indicates end of file

 		{

 		if (FileSize-aLength == ImageReadProgress)

 			return KErrEof;

 		else

 			// this will drop through to the error code below and will fault

 			return KErrGeneral;

 		}

 	return r;

 	}

 void CloseFile()

 	{

 	bootFile.Close();

 	}

 void CloseAndDeleteFile()

 	{

 	TFileName fileName;

 	TInt r = bootFile.FullName(fileName);

 	if (r != KErrNone)

 		PrintToScreen(_L("CloseAndDeleteFile() RFile::FullName returned %d"), r);

 	bootFile.Close();

 	r = TheFs.Delete(fileName);

 	PrintToScreen(_L("Deleted file fileName %S"), &fileName);

 	}

 //#define TROM_LOADER_HEADER_SIZE 0x100

 #define BUFFER_SIZE         (TROM_LOADER_HEADER_SIZE + sizeof(TRomHeader))

 TInt GetInnerCompression(TBool &aImageDeflated, TBool &aRomLoaderHeaderExists )

     {

     TInt r = KErrNone;

     TUint8 buffer[BUFFER_SIZE];

     TInt   bufferSize = BUFFER_SIZE;

     const TUint8 * romLoaderSignature1 = (const TUint8*)"EPOC";

     const TUint8 * romLoaderSignature2 = (const TUint8*)"ROM";

     r = ReadInputData((TUint8*)&buffer, bufferSize);

 	if( KErrNone!=r)

 		{

 		PrintToScreen(_L("Unable to read loader headers... (size:%d)\r\n"), bufferSize);

 		BOOT_FAULT();    

 		}

 	else

     	{

     	// Check headers

     	TRomHeader* romHeader= (TRomHeader *) &buffer;

     	aRomLoaderHeaderExists = EFalse;

     	if( !memcmp1(buffer, romLoaderSignature1, 4) && !memcmp1(&buffer[8], romLoaderSignature2, 3) )

     	    {

             // We have TRomLoaderHeader skip it

             romHeader = (TRomHeader *) (&buffer[TROM_LOADER_HEADER_SIZE]);

             aRomLoaderHeaderExists = ETrue;

     	    }

         if(romHeader->iCompressionType == 0 )

             {

              RDebug::Print(_L("Image is NOT Compressed"));

              aImageDeflated = EFalse;

              FileSize = romHeader->iUncompressedSize;

              PrintToScreen(_L("ROMSIZE:%d\r\n"), romHeader->iUncompressedSize);

              RDebug::Print(_L("ROMSIZE:%d"), romHeader->iUncompressedSize);

          	if (romHeader->iPageableRomStart > 0)

          		{

          		PrintToScreen(_L("Paged ROM FOUND\r\n"));

          		RDebug::Print(_L("Paged ROM FOUND"));

          		FileSize = romHeader->iPageableRomStart;

          		RDebug::Print(_L("Unpaged ROMSIZE:%d"), romHeader->iPageableRomStart);

          		}          

             }

         else if (romHeader->iCompressionType == KUidCompressionDeflate )

             {

             RDebug::Print(_L("Image is Compressed\r\n"));

             aImageDeflated = ETrue;

             FileSize = romHeader->iUnpagedUncompressedSize;

             RDebug::Print(_L("Compressed ROMSIZE:%d\r\n"), romHeader->iUnpagedUncompressedSize);       

             }

         else

             {

             RDebug::Print(_L("Not supported compression method:0x%08x\r\n"), romHeader->iCompressionType);

             PrintToScreen(_L("Not supported compression method:0x%08x\r\n"), romHeader->iCompressionType);

             r = KErrNotSupported;

             }

      	}

 	return r;        

     }