/*

* Copyright (c) 2006-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: 

* This file contains the definition of class TFATBaseBootSector. 

* TFATBaseBootSector is the base class for the boot sector class 

* of different FAT file system type.This contains the data member 

* representing the common fields in each FAT image type

* @internalComponent

* @released

*

*/

#include "fatbasebootsector.h"

#include <cstring>

/**

Constructor of the base boot sector class

@internalComponent

@released

*/

TFATBaseBootSector::TFATBaseBootSector()

{

}

/**

Destructor of the base boot sector class

@internalComponent

@released

*/

TFATBaseBootSector::~TFATBaseBootSector()

{

}

/**

Function Sets the OEM name generally, Indication of what system 

formats the volume

@internalComponent

@released

*/

void TFATBaseBootSector::SetOEMName()

	{

		strcpy( reinterpret_cast<char*>(iOEMName),KDefaultOEMName);

	}

/**

Function to get the OEM name

@internalComponent

@released

@return OEM Name

*/

unsigned char* TFATBaseBootSector::OEMName() 

	{

		return iOEMName;

	}

/**

Function to set the jump instructions

@internalComponent

@released

*/

void TFATBaseBootSector::SetJumpInstruction()

{

	iJmpBoot[0]= 0xEB;

	iJmpBoot[1]= 0x5A;

	iJmpBoot[2]= 0x90;

}

/**

Function to get the jump instructions

@internalComponent

@released

@return jump boot instruction

*/

unsigned char* TFATBaseBootSector::JumpInstruction()  

{

	return iJmpBoot;

}

/**

Function to set the bytes per sector.  

@internalComponent

@released

@param aDriveSectorSize Sector size in bytes 

*/

void TFATBaseBootSector::SetBytesPerSector(unsigned int aDriveSectorSize)

{

	// Take the default value if SectorSize is not provided by the user. 

	if (aDriveSectorSize != 0)

	{

		unsigned short int acceptableValues[] = {512,1024,2048,4096};

		unsigned short int acceptableValuesCount = 4;

		bool validSectorSize = false;

		for (unsigned int count=0; count<acceptableValuesCount; count++)

		{

			if(aDriveSectorSize == acceptableValues[count])

			{

				validSectorSize = true;

				break;

			}

		}

		// If invalid value for Sector Size is provided, consider the default value.

		if (validSectorSize)

		{

			iBytesPerSector=aDriveSectorSize;

			return;

		}

		else

		{

			std::cout<<"Warning: Invalid Sector Size value. Default value is considered.\n";

		}

	}

	iBytesPerSector=KDefaultBytesPerSector;	

}

/**

Return the bytes per sector

@internalComponent

@released

@return bytes per sector, hard coded as 512 here.

*/

unsigned int TFATBaseBootSector::BytesPerSector() const

{

	return iBytesPerSector;

}

/**

Sets the number of Fats on the volume

@internalComponent

@released

@param aDriveNoOfFATs Number of fats

*/

void TFATBaseBootSector::SetNumberOfFats(unsigned int aDriveNoOfFATs) 

{

	// Take the default value if No of FATs is not provided by the user. 

	if (aDriveNoOfFATs != 0)

	{

		// If invalid value for No of FATs is provided, generate a warning and take the default value. 

		if ((aDriveNoOfFATs>255) || (aDriveNoOfFATs<1))

		{

			std::cout<<"Warning: No of FATs should be between 0 and 256. Default value is considered.\n";

			iNumberOfFats= KDefaultNumFats;

			return;

		}

		iNumberOfFats= aDriveNoOfFATs;

	}

	else

	{

		iNumberOfFats= KDefaultNumFats;

	}

}

/**

Total sectors on the volume,This count includes the total count of all sectors 

in all four regions of the volume.iTatalSectors is a 16 bit field and iTotalSectors32

is a 32 bit field.Hence if the total sectors are more than 2^16(0x10000 in hex) 

then iTotalSectors32 is set otherwise it is zero.

@internalComponent

@released

@param aPartitionSize Partition size in bytes

*/

void TFATBaseBootSector::ComputeTotalSectors(Long64 aPartitionSize)

{

	int Log2OfBytesPerSector = Log2(iBytesPerSector);

	unsigned long TotalSectors64 = (unsigned long)(aPartitionSize >> Log2OfBytesPerSector);

	if(TotalSectors64 >= 0x10000)

	{

			iTotalSectors = 0;

			iTotalSectors32 = (unsigned int) TotalSectors64;

	}

	else

	{

			iTotalSectors = (unsigned short)TotalSectors64;

			iTotalSectors32=0;

	}

}

/**

Set the media descriptor,0xF8 is the standard for fixed (non removable) media.

@internalComponent

@released

*/

void TFATBaseBootSector::SetMedia()

{

	iMedia=KBPBMedia;

}

/**

This methods gets the media descriptor

@internalComponent

@released

@return media descriptor

*/

unsigned char TFATBaseBootSector::Media() const

{

	return iMedia;

}

/**

Set the number of hidden sectors in the volume,Count of hidden sector

preceding the partition.

@internalComponent

@released

*/

void TFATBaseBootSector::SetHiddenSectors()

{

	iHiddenSectors=KDefaultHiddenSectors;

}

/**

Gets the number of hidden sectors in the volume

@internalComponent

@released

@return the number of hidden sectors in a given FAT Volume

*/

unsigned int TFATBaseBootSector::HiddenSectors() const

{

	return iHiddenSectors;

}

/**

Set the sectors per track preceding the partition.

@internalComponent

@released

*/

void TFATBaseBootSector::SetSectorsPerTrack()

{

	iSectorsPerTrack=KDefaultSectorsPerTrack;// default value for flash memory

}

/**

Gets the number sectors per track in the volume

@internalComponent

@released

@return the number of sectors per track in a given FAT Volume

*/

unsigned short TFATBaseBootSector::SectorsPerTrack() const

{

	 return iSectorsPerTrack;

}

/**

Set the number of heads

@internalComponent

@released

*/

void TFATBaseBootSector::SetNumberOfHeads()

{

	iNumHeads=KDefaultNumHeads;// default value for flash memory

}

/**

Gets the the number of heads

@internalComponent

@released

@return number of heads in a given FAT Volume

*/

unsigned short TFATBaseBootSector::NumberOfHeads() const

{

	return iNumHeads;// default value for flash memory

}

/**

Set the Physical drive number,not used in Symbian OS

@internalComponent

@released

*/

void TFATBaseBootSector::SetBootSectorDriveNumber()

{

	iPhysicalDriveNumber=KDefaultDriveNumber;

}

/**

Function to return drive number

@internalComponent

@released

@return Physical drive number, not used in Symbian OS

*/

unsigned char TFATBaseBootSector::BootSectorDriveNumber() const

{

	return iPhysicalDriveNumber;

}

/**

Set the reserved byte value

@internalComponent

@released

*/

void TFATBaseBootSector::SetReservedByte()

{

	iReservedByte=KDefaultReservedByte;

}

/**

Get the value of reserved byte in boot sector

@internalComponent

@released

@return Returns the reserved byte value

*/

unsigned char TFATBaseBootSector::ReservedByte() const

{

	return iReservedByte;

}

/**

Set the extended boot signature

@internalComponent

@released

*/

void TFATBaseBootSector::SetBootSignature() 

{

	iBootSign=KDefaultBootSignature;

}

/**

Gets the extended boot signature

@internalComponent

@released

@return boot signature

*/

unsigned char TFATBaseBootSector::BootSignature() const

{

	return iBootSign;

}

/**

Set the unique volume serial number,This ID is usually generated by 

simply combining the current date and time in to 32 bit value.

@internalComponent

@released

*/

void TFATBaseBootSector::SetVolumeId()

{	

	time_t rawtime;

	time(&rawtime);

	iVolumeId=rawtime;

}

/**

Returns the volume id 

@internalComponent

@released

@return volume id field of the boot sector 

*/

unsigned int TFATBaseBootSector::VolumeId() const

{

return iVolumeId ;

}

/**

Set the volume's label

@internalComponent

@released

@param aVolumeLable Data Drive Volume Label

*/

void TFATBaseBootSector::SetVolumeLab(String aVolumeLable)

{

	// Set the default value of VolumeLable(i.e. "NO NAME    ") if not provided

	// by the user.

	if (aVolumeLable.empty())	

	{

		strcpy(reinterpret_cast<char*>(iVolumeLabel),KDefaultVolumeLabel);

	}

	else 

	{

		// If the volume label provided is greater than 11 characters then consider only 

		// the first 11 characters and generate a warning.

		int volumeMaxLangth= 11;

		int volumeLabelSize= aVolumeLable.size();

		if (volumeLabelSize > volumeMaxLangth)

		{

			std::cout<<"Warning: Size overflow for Data Drive Volume Label. Truncating to 11-bytes.\n";	

			aVolumeLable.resize(volumeMaxLangth);

			strcpy(reinterpret_cast<char*>(iVolumeLabel),aVolumeLable.c_str());

			return;

		}

		// If the VolumeLable provided is less than 11-characters then pad the 

		// remaining bytes with white-spaces.		

		if (volumeLabelSize < KMaxVolumeLabel)

		{

			while(volumeLabelSize < 11)

			{

				aVolumeLable.append(" ");

				volumeLabelSize = aVolumeLable.size();

			}	

		}

		strcpy(reinterpret_cast<char*>(iVolumeLabel),aVolumeLable.c_str());

	}

}

/**

returns  the volume's label

@internalComponent

@released

*/

unsigned char* TFATBaseBootSector::VolumeLab() 

{

	return iVolumeLabel;

}

/**

Returns the number of reserved sectors on the volume

@internalComponent

@released

@return iReservedSectors

*/

unsigned short TFATBaseBootSector::ReservedSectors() const

{

	return iReservedSectors;

}

/**

Returns the number of Fats on the volume

@internalComponent

@released

@return iNumberOfFats

*/

unsigned char TFATBaseBootSector::NumberOfFats() const

{

	return iNumberOfFats;

}

/**

Returns the number of entries allowed in the root directory, specific to Fat12/16, zero for FAT32

@internalComponent

@released

@return iRootDirEntries

*/

unsigned short TFATBaseBootSector::RootDirEntries() const

{

	return iRootDirEntries;

}

/**

Returns the total sectors on the volume, 

@internalComponent

@released

@return iTotalSectors 

*/

unsigned int TFATBaseBootSector::TotalSectors(Long64 aPartitionSize) const

{

	if((aPartitionSize/iBytesPerSector)>= 0x10000)	

	return iTotalSectors32;

	else 

	return iTotalSectors;

}

/**

Returns base 2 Logarithm of a number 

@internalComponent

@released

@param aNum number whose logarithm is to be taken

@return log base 2 of the number passed

*/

int TFATBaseBootSector::Log2(int aNum) 

{

	int res=-1;

	while(aNum)

		{

		res++;