// Copyright (c) 2002-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:
//
// e32test\smpsoak\d_smpsoak.cpp
//

// LDD for smpsoak - setting Thread CPU Affinity
//

#include "d_smpsoak.h"
#include <platform.h>
#include <kernel/kern_priv.h>

const TInt KMajorVersionNumber=0;
const TInt KMinorVersionNumber=1;
const TInt KBuildVersionNumber=1;

class DSmpSoakFactory : public DLogicalDevice
//
// IPC copy LDD factory
//
	{
public:
	DSmpSoakFactory();
	virtual TInt Install();						//overriding pure virtual
	virtual void GetCaps(TDes8& aDes) const;	//overriding pure virtual
	virtual TInt Create(DLogicalChannelBase*& aChannel);	//overriding pure virtual
	};

class DSmpSoak : public DLogicalChannelBase
	{
public:
	DSmpSoak();
	virtual ~DSmpSoak();
protected:
	virtual TInt DoCreate(TInt aUnit, const TDesC8* aInfo, const TVersion& aVer);
	virtual TInt Request(TInt aReqNo, TAny* a1, TAny* a2);
public:
	static void IDfcFn(TAny* aPtr);
public:
	void OccupyCpus();
	};

DECLARE_STANDARD_LDD()
	{
	Kern::Printf("DSmpSoak called");
    return new DSmpSoakFactory;
    }

DSmpSoakFactory::DSmpSoakFactory()
//
// Constructor
//
    {
	Kern::Printf("DSmpSoakFactory::DSmpSoakFactory called");
    iVersion=TVersion(KMajorVersionNumber,KMinorVersionNumber,KBuildVersionNumber);
    }

TInt DSmpSoakFactory::Create(DLogicalChannelBase*& aChannel)
//
// Create a new DSmpSoak on this logical device
//
    {
	Kern::Printf("DSmpSoakFactory::Create called");
	aChannel=new DSmpSoak;
    return aChannel?KErrNone:KErrNoMemory;
    }

TInt DSmpSoakFactory::Install()
//
// Install the LDD - overriding pure virtual
//
    {
	Kern::Printf("DSmpSoakFactory::Install called");
    return SetName(&KSmpSoakLddName);
    }

void DSmpSoakFactory::GetCaps(TDes8& aDes) const
//
// Get capabilities - overriding pure virtual
//
    {
    Kern::Printf("DSmpSoakFactory::GetCaps called");
    }

DSmpSoak::DSmpSoak()
//
// Constructor
//
	{
	Kern::Printf("DSmpSoak::DSmpSoak called");
	}

DSmpSoak::~DSmpSoak()
	{
	Kern::Printf("DSmpSoak::~DSmpSoak called");
	}

TInt DSmpSoak::DoCreate(TInt /*aUnit*/, const TDesC8* /*anInfo*/, const TVersion& aVer)
//
// Create channel
//
    {
	Kern::Printf("DSmpSoak::DoCreate called");

    if (!Kern::QueryVersionSupported(TVersion(KMajorVersionNumber,KMinorVersionNumber,KBuildVersionNumber),aVer))
    	return KErrNotSupported;
	
	return KErrNone;
	}


TInt DSmpSoak::Request(TInt aFunction, TAny* a1, TAny* a2)
	{
	DThread *pT = NULL;
	NThread *pMyNThread = NULL;
	TInt handle = (TInt)a1;
	TInt priority = (TInt)a2;

	TInt r = KErrNotSupported;
	Kern::Printf("DSmpSoak::Request called aFunction = %d, a1 = %d, a2 = %d", aFunction, a1, a2);

	switch (aFunction)
		{
		case RSMPSoak::KGETPROCESSORCOUNT:
			r = NKern::NumberOfCpus();
			Kern::Printf("DSmpSoak::Request Processor count = %d", r);
			break;
		case RSMPSoak::KGETCURRENTCPU:
			r = NKern::CurrentCpu();
			Kern::Printf("DSmpSoak::Request Current CPU = %d", r);
			break;
		case RSMPSoak::KGETCURRENTTHREAD:
			r = (TInt)NKern::CurrentThread();
			Kern::Printf("DSmpSoak::Request Current Thread %02x", r);
			break;
		case RSMPSoak::KTHREADSETCPUAFFINITY:
			r = NKern::ThreadSetCpuAffinity(NKern::CurrentThread(), (TInt)a1);
			r = (TInt)NKern::CurrentCpu();
			Kern::Printf("DSmpSoak::Request Current Cpu = %d", r);
			break;
		case RSMPSoak::KOCCUPYCPUS:
			Kern::Printf("DSmpSoak::Request OCCUPYCPUS: called");
			OccupyCpus();
			break;
		case RSMPSoak::KCHANGEAFFINITY:
			Kern::Printf("DSmpSoak::Request CHANGEAFFINITY");
			NKern::LockSystem();
			pT=(DThread*)Kern::CurrentThread().ObjectFromHandle(handle);
			pMyNThread=(NThread*)&pT->iNThread;
			NKern::ThreadSetCpuAffinity((NThread*)pMyNThread, (TInt)a2);
			NKern::UnlockSystem();
			break;
		case RSMPSoak::KCHANGETHREADPRIORITY:
			Kern::Printf("DSmpSoak::Request CHANGETHREADPRIORITY");
			NKern::LockSystem();
			pT=(DThread*)Kern::CurrentThread().ObjectFromHandle(handle);
			Kern::Printf("DSmpSoak::Request Current Thread %d", pT);
			pT->SetThreadPriority(priority);
			Kern::Printf("DSmpSoak::CHANGETHREADPRIORITY now  %d", pT->iThreadPriority);
			NKern::UnlockSystem();
			break;
		default:
			Kern::Printf("DSmpSoak::Request default: called");
			break;
		}
	return r;
	}

void DSmpSoak::OccupyCpus()
	{
	Kern::Printf(">>>DSmpSoak::OccupyCpus()");
	}