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