// sysinfo.cpp

// 

// Copyright (c) 2008 - 2010 Accenture. All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the "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:

// Accenture - Initial contribution

//

//

// CCmdSysInfo.

//

#include "u32std.h"

#include <ETELMM.H>

#include "sysinfo.h"

#include <fshell/common.mmh>

#include <fshell/ltkhal.h>

#include <fshell/ltkutils.h>

#ifdef FSHELL_CORE_SUPPORT_SYSINFO_WLAN

#include <wlansdkpskeys.h>	//for WLAN info

#endif

#include <e32rom.h>

CCommandBase* CCmdSysInfo::NewLC()

	{

	CCmdSysInfo* self = new (ELeave) CCmdSysInfo();

	CleanupStack::PushL(self);

	self->BaseConstructL();

	return self;

	}

CCmdSysInfo::~CCmdSysInfo()

	{

	}

CCmdSysInfo::CCmdSysInfo()

	: CCommandBase(EReportAllErrors)

	{

	}

void CCmdSysInfo::PrintHalL(HALData::TAttribute aHalAttribute)

	{

	LtkUtils::CHalAttribute* attrib = LtkUtils::GetHalInfoL(aHalAttribute);

	if (attrib->iError)

		{

		PrintWarning(_L("Unable to read %S: %S (%d)"), &attrib->iAttributeName, Stringify::Error(attrib->iError), attrib->iError);

		}

	else

		{

		Printf(_L("%S: %S\r\n"), &attrib->iAttributeName, attrib->iDescription);

		}

	delete attrib;

	}

void CCmdSysInfo::PrintWlanL()

	{

#ifdef FSHELL_CORE_SUPPORT_SYSINFO_WLAN

    //result format 00:18:0f:1e:96:a2.

    TBuf8<KPSWlanMacAddressLength> DesC8AddrText;

    TBuf<50> formatedMacAddress;

    LeaveIfErr(RProperty::Get(KPSUidWlan,KPSWlanMacAddress,DesC8AddrText), _L("Unable to get MAC address"));

    for ( TInt i=0; i < (TInt)KPSWlanMacAddressLength; i++ )

        {

        // Set separator

        if( i > 0 )

            formatedMacAddress.Append(':');

        // Set data

        TBuf<10> FormatText;

        FormatText.Format(_L("%02x"), DesC8AddrText[i]);

        formatedMacAddress.Append(FormatText);

        }

    Printf(_L("WLAN MAC Address: %S\r\n"), &formatedMacAddress);

#endif

	}

void CCmdSysInfo::PrintPhoneIdL()

	{

#ifdef FSHELL_TELEPHONY_SUPPORT

	TRequestStatus status;

	RTelServer telSvr;

	LeaveIfErr(telSvr.Connect(), _L("Unable to connect to telephony server"));

	CleanupClosePushL(telSvr);

	RMobilePhone mobilePhone;

	LeaveIfErr(mobilePhone.Open(telSvr, _L("DefaultPhone")), _L("Unable to open default mobile phone"));

	CleanupClosePushL(mobilePhone);

	TUint32 identCap;

	mobilePhone.GetIdentityCaps(identCap);

	RMobilePhone::TMobilePhoneIdentityV1 Id;

	mobilePhone.GetPhoneId(status, Id);

	User::WaitForRequest(status);

	LeaveIfErr(status.Int(), _L("Unable to retrieve phone identity"));

	if (identCap & RMobilePhone::KCapsGetManufacturer)

		Printf(_L("Manufacturer (from TSY): %S\r\n"), &(Id.iManufacturer) );

	if (identCap & RMobilePhone::KCapsGetModel)

		Printf(_L("Model (from TSY): %S\r\n"), &(Id.iModel) );

	if (identCap & RMobilePhone::KCapsGetRevision)

		Printf(_L("Revision (from TSY): %S\r\n"), &(Id.iRevision) );

	if (identCap & RMobilePhone::KCapsGetSerialNumber)

		Printf(_L("SerialNumber (IMEI): %S\r\n"), &(Id.iSerialNumber) );

	//query subscriber id

	if (identCap & RMobilePhone::KCapsGetSubscriberId)

		{

		RMobilePhone::TMobilePhoneSubscriberId subsId;

		mobilePhone.GetSubscriberId(status, subsId);

		User::WaitForRequest(status);

		LeaveIfErr(status.Int(), _L("Unable to query subscriber id"));

		Printf(_L("SubscriberId (IMSI): %S\r\n"), &(subsId) );

		}

	TPckgBuf<RMobilePhone::TMobilePhoneNetworkInfoV1> info;

	RMobilePhone::TMobilePhoneLocationAreaV1 loc;

	mobilePhone.GetCurrentNetwork(status, info, loc);

	User::WaitForRequest(status);

	LeaveIfErr(status.Int(), _L("Unable to get current network info"));

	Printf(_L8("Network id: %S "), &info().iNetworkId);

	Printf(_L("shortName: %S longName: %S displayTag: %S"), &info().iShortName, &info().iLongName, &info().iDisplayTag);

	CleanupStack::PopAndDestroy();	//mobilePhone

	CleanupStack::PopAndDestroy();	//telSvr

#endif	

	}	

void CCmdSysInfo::DoRunL()

	{

	if (iMachineUIDOnly)

		{

		// sysinfo command-line configured to return only the machine uid value & nothing else

		TInt value;

		TInt err = HAL::Get(HALData::EMachineUid, value);

		if (err)

			{

			PrintWarning(_L("Unable to read Machine UID %S (%d)"), Stringify::Error(err), err);

			}

		else

			{

			TBuf<10> buf;

			buf.Format(_L("%d"), value);

			Write(buf);

			}

		}

	else

		{

		// sys info command-line configured to return all information, including HAL field description

		PrintHalL(HALData::EManufacturer);

		PrintHalL(HALData::EManufacturerHardwareRev);

		PrintHalL(HALData::EManufacturerSoftwareRev);

		PrintHalL(HALData::EManufacturerSoftwareBuild);

		PrintHalL(HALData::EModel);

		PrintHalL(HALData::EMachineUid);

		PrintHalL(HALData::ECPUSpeed);

		PrintHalL(HALData::ESystemStartupReason);

		PrintHalL(HALData::ESystemTickPeriod);

		PrintHalL(HALData::ENanoTickPeriod);

		PrintHalL(HALData::EFastCounterFrequency);

		PrintHalL(HALData::EFastCounterCountsUp);

		PrintHalL(HALData::ESystemException);

		PrintHalL(HALData::EDisplayXPixels);

		PrintHalL(HALData::EDisplayYPixels);

		PrintHalL(HALData::EDisplayXTwips);

		PrintHalL(HALData::EDisplayYTwips);

		PrintHalL(HALData::EDisplayColors);

		PrintKernelHalStuff();

		PrintRomVersion();

		TRAP_IGNORE(PrintWlanL());

		TRAP_IGNORE(PrintPhoneIdL());

		}

	}

const TDesC& CCmdSysInfo::Name() const

	{

	_LIT(KName, "sysinfo");

	return KName;

	}

void CCmdSysInfo::OptionsL(RCommandOptionList& aOptions)

	{

	_LIT(KOptUid, "machine-uid");

	aOptions.AppendBoolL(iMachineUIDOnly, KOptUid);

	}

EXE_BOILER_PLATE(CCmdSysInfo)

void CCmdSysInfo::PrintKernelHalStuff()

	{

	enum TKernelConfigFlagsNotIn91

		{

		EKernelConfigPlatSecLocked = 1<<7,

		EKernelConfigCrazyScheduling = 1<<8,

		EKernelConfigPagingPolicyNoPaging = 0,

		EKernelConfigPagingPolicyAlwaysPage = 1,

		EKernelConfigPagingPolicyDefaultUnpaged = 2,

		EKernelConfigPagingPolicyDefaultPaged = 3,

		EKernelConfigCodePagingPolicyShift			= 5,

		EKernelConfigCodePagingPolicyMask			= 3<<5,

		EKernelConfigCodePagingPolicyNoPaging		= EKernelConfigPagingPolicyNoPaging<<5,

		EKernelConfigCodePagingPolicyAlwaysPage		= EKernelConfigPagingPolicyAlwaysPage<<5,

		EKernelConfigCodePagingPolicyDefaultUnpaged	= EKernelConfigPagingPolicyDefaultUnpaged<<5,

		EKernelConfigCodePagingPolicyDefaultPaged	= EKernelConfigPagingPolicyDefaultPaged<<5,

		EKernelConfigDataPagingPolicyShift			= 9,

		EKernelConfigDataPagingPolicyMask			= 3<<9,

		};

	enum THalFunctionsNotIn91

		{

		EKernelHalSmpSupported = 15,

		EKernelHalNumLogicalCpus = 16,

		EKernelHalConfigFlags = 20,

		};

	// Memory model

	TUint memModelInfo = UserSvr::HalFunction(EHalGroupKernel, EKernelHalMemModelInfo, 0, 0);

	Printf(_L("Memory model: "));

	const TInt EMemModelTypeFlexible = 4;

	switch (memModelInfo & EMemModelTypeMask)

		{

		case EMemModelTypeDirect:

			Printf(_L("Direct")); break;

		case EMemModelTypeMoving:

			Printf(_L("Moving")); break;

		case EMemModelTypeMultiple:

			Printf(_L("Multiple")); break;

		case EMemModelTypeEmul:

			Printf(_L("Emulator")); break;

		case EMemModelTypeFlexible:

			Printf(_L("Flexible")); break;

		default:

			Printf(_L("Unknown (%d)"), memModelInfo & EMemModelTypeMask);

			break;

		}

	Printf(_L("\r\n"));

	// Hal config

	TInt flags = UserSvr::HalFunction(EHalGroupKernel, EKernelHalConfigFlags, 0, 0); // Not the most documented of APIs but has been around since at least v9.1

	if (flags < 0)

		{

#ifdef __EPOC32__

		// The only things that are dynamically calculated are things that aren't supported on platforms that don't support the HalFunction, so this is a good compromise

		flags = ((const TRomHeader*)UserSvr::RomHeaderAddress())->iKernelConfigFlags;

#else

		return;

#endif

		}

	_LIT(KOn, "On");

	_LIT(KOff, "Off");

	Printf(_L("PlatSec Enforcement: %S\r\n"), (flags & EKernelConfigPlatSecEnforcement) ? &KOn : &KOff);

	Printf(_L("PlatSec Locked: %S\r\n"), (flags & EKernelConfigPlatSecLocked) ? &KOn : &KOff);

	Printf(_L("Crazy scheduling: %S\r\n"), (flags & EKernelConfigCrazyScheduling) ? &KOn : &KOff);

	Printf(_L("Code paging: "));

	PagingFormat((flags & EKernelConfigCodePagingPolicyMask) >> EKernelConfigCodePagingPolicyShift);

	Printf(_L("\r\nData paging: "));

	PagingFormat((flags & EKernelConfigDataPagingPolicyMask) >> EKernelConfigDataPagingPolicyShift);

	Printf(_L("\r\n"));

	// Num CPUs

	TBool smpEnabled = (UserSvr::HalFunction(EHalGroupKernel, EKernelHalSmpSupported, 0, 0) == KErrNone);

	if (smpEnabled)

		{

		TInt cpus = UserSvr::HalFunction(EHalGroupKernel, EKernelHalNumLogicalCpus, 0, 0);

		Printf(_L("Num CPUs: %d\r\n"), cpus);

		}

	else

		{

		Printf(_L("Num CPUs: 1 (no SMP)\r\n"));

		}

	}

void CCmdSysInfo::PagingFormat(TUint aFlags)

	{

	enum TMoreFlagsNotIn91

		{

		EKernelConfigPagingPolicyNoPaging = 0,

		EKernelConfigPagingPolicyAlwaysPage = 1,

		EKernelConfigPagingPolicyDefaultUnpaged = 2,

		EKernelConfigPagingPolicyDefaultPaged = 3,

		};

	switch (aFlags)

		{

		case EKernelConfigPagingPolicyNoPaging:

			Printf(_L("No paging")); break;

		case EKernelConfigPagingPolicyAlwaysPage:

			Printf(_L("Always page")); break;

		case EKernelConfigPagingPolicyDefaultUnpaged:

			Printf(_L("Default unpaged")); break;

		case EKernelConfigPagingPolicyDefaultPaged:

			Printf(_L("Default paged")); break;

		default:

			break;

		}

	}

typedef TInt(*TSysUtilGetSWVersionFunction)(TDes&);

#ifdef __EPOC32__

const TInt KSysUtilOrdinal = 9;

#else

const TInt KSysUtilOrdinal = 6;

#endif

void CCmdSysInfo::PrintRomVersion()

	{

#ifdef __EPOC32__

	// Get checksum 

	TRomHeader* romHeader = (TRomHeader*)UserSvr::RomHeaderAddress();

	if  (romHeader)

		{

		Printf(_L("Rom checksum: 0x%08x\r\n"), romHeader->iCheckSum);

		}

#endif

	// Platform version

	_LIT(KS60VersionDllName, "SysUtil.dll");

	RLibrary lib;

	if (lib.Load(KS60VersionDllName) == KErrNone)

		{

		// Get exported version function

		TLibraryFunction fn = lib.Lookup(KSysUtilOrdinal);

		if (fn != NULL)

			{

			TSysUtilGetSWVersionFunction sysUtilGetSWVersion = (TSysUtilGetSWVersionFunction) fn;

			TBuf<128> buf;

			TInt err = (*sysUtilGetSWVersion)(buf);

			if (err)

				{

				Printf(_L("Error returned from SysUtilGetSWVersionFunction: %d\r\n"), err);

				}

			else

				{

				LtkUtils::ReplaceText(buf, _L("\n"), _L(" "));

				Printf(_L("ROM version: %S\r\n"), &buf);

				}

			}

		lib.Close();

		}

	}