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

/**
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++;
		aNum>>=1;
		}
	return(res);
}

/**
Returns the sectors per cluster ratio

@internalComponent
@released

@return iSectorsPerCluster
*/
unsigned char TFATBaseBootSector::SectorsPerCluster() const
{
	return iSectorsPerCluster;
}

/**
Returns the 16 bit count of total sectors on the volume 

@internalComponent
@released

@return iTotalSectors 
*/
unsigned short TFATBaseBootSector::LowSectorsCount() const
{
	return iTotalSectors;
}

/**
Returns the 32 bit count of total sectors on the volume 

@internalComponent
@released

@return iTotalSectors 
*/
unsigned int TFATBaseBootSector::HighSectorsCount() const
{
	return iTotalSectors32;
}

/**
Returns sectors used for the Fat table, zero for FAT32

@internalComponent
@released

@return iFatSectors
*/
unsigned short TFATBaseBootSector::FatSectors() const
{
	return (unsigned short)iFatSectors;
}

/**
Returns sectors used for the Fat table in FAT32

@internalComponent
@released

@return iFatSectors32
*/
unsigned int TFATBaseBootSector::FatSectors32() const
{
	return iFatSectors32;
}