// Copyright (c) 2007-2010 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

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

//

#include <kernel/arm/assp.h>

#include <kernel/kernel.h>

#include <TraceCoreCommon.h>

#include "TraceCore.h"

#include "TraceCoreConstants.h"

#include "TraceOnActivation.h"

#include "TraceOnActivationIf.h"

#include "TraceConnection.h"

//===========================================================================

// DTcFactory Class

//===========================================================================

//---------------------------------------------------------------------------

/**

    DTcFactory Constructor

*/

DTcFactory::DTcFactory()

: DLogicalDevice()

    {

    // The version of this logical device

    iVersion = TVersion( RTraceOnActivation::EMajorVersionNumber,

                         RTraceOnActivation::EMinorVersionNumber,

                         RTraceOnActivation::EBuildVersionNumber );

    // A bitmasks that indicates device properties

    iParseMask = 0;

    iUnitsMask = 0;

    }

//---------------------------------------------------------------------------

/**

    DTcFactory Destructor

*/

DTcFactory::~DTcFactory()

    {

    }

//---------------------------------------------------------------------------

/**

    Completes the installation of this logical device i.e. to do secondary

    initialization

    @return KErrNone, if successful

*/

TInt DTcFactory::Install()

    {

    return SetName( &KTraceOnActivationDriverName );

    }

//---------------------------------------------------------------------------

/**

    Gets the capabilities of this logical device. Current implementation does

    nothing.

    @param  aDes  On return, contains information describing

                  the capabilities of the device

*/

void DTcFactory::GetCaps(TDes8& /*aDes*/) const

    {

    }

//---------------------------------------------------------------------------

/**

    Creates a logical channel

    @param  aChannel Set to point to the created Logical Channel

    @return KErrNone, if successfull

*/

TInt DTcFactory::Create(DLogicalChannelBase*& aChannel)

    {

	TInt r(KErrNone);

    aChannel = new DTcChannel( this );

    if ( aChannel == NULL )

        {

        r = KErrNoMemory;

        }

    return r;

    }

//===========================================================================

// DTcChannel Class

//===========================================================================

//---------------------------------------------------------------------------

/**

    Constructor

    @param  aDevice  A pointer to the LDD factory object that

                    is constructing this logical channel

*/

DTcChannel::DTcChannel(DLogicalDevice* /*aDevice*/)

        : DLogicalChannel()

        , iClientThread( NULL )

        , iActivationQue(NULL)

    {   

    }

//---------------------------------------------------------------------------

/**

    Destructor

*/

DTcChannel::~DTcChannel()

    {

    delete iTraceConnection;

    iTraceConnection = NULL;

    // Close our reference on the client thread

    Kern::SafeClose( reinterpret_cast<DObject*&>( iClientThread ), NULL );

#ifdef __SMP_

    __e32_memory_barrier();

#endif

    }

//---------------------------------------------------------------------------

/**

    Completes the outstanding request identified by the specified request

    number.

    @param  aMsg  System message from user side

*/

void DTcChannel::HandleMsg(TMessageBase* aMsg)

    {

    // Synchronous kernel-side message. There is one per thread, and the

    // thread always blocks while the message is outstanding.

    TThreadMessage& msg = *( 

    				static_cast<TThreadMessage*>( aMsg ) ); 

    TInt id = msg.iValue;

    if ( id == static_cast<TInt>( ECloseMsg ) )

        {

        // Don't receive any more messages

        msg.Complete( KErrNone, EFalse );

        // Complete all outstanding messages on this queue

        iMsgQ.CompleteAll( KErrServerTerminated );

        }

    else

        {

        // DoControl

        TInt ret = DoControl( id, msg.Ptr0() );

        msg.Complete( ret, ETrue );

        }

    }

//---------------------------------------------------------------------------

/**

    Performs secondary initialisation of the logical channel

    @param  aUnit  parameter to the user side handle

    @param  anInfo  extra information for the device

    @param  aVer  version requested by the thread

    @return KErrNone, if succesfull

*/

TInt DTcChannel::DoCreate(TInt aUnit, const  TDesC8* /*anInfo*/,

                                             const  TVersion& aVer)

    {

    // Get pointer to client threads DThread object

    iClientThread = &Kern::CurrentThread();

    TInt ret = iClientThread->Open();

    if(ret != KErrNone)

        return ret;

    DTraceCore* tCore = DTraceCore::GetInstance();

    if(!tCore)

        return KErrNotReady;

    iActivationQue = tCore->ActivationQ();

    // This device driver framework does not apply meaning to the idea of a unit.

    if ( aUnit != KNullUnit || !iDevice->QueryVersionSupported( aVer ) )

        {

        ret = KErrNotSupported;

        }

    else

        {

        // security check

        if ( !Kern::CurrentThreadHasCapability( ECapabilityCommDD, 

                        __PLATSEC_DIAGNOSTIC_STRING("Checked by Tc driver") ) )

            {

            ret = KErrPermissionDenied;

            }

        if(ret==KErrNone)

            {

            iTraceConnection = new DTraceConnection(this);

            if(!iTraceConnection)

                {

                ret=KErrNoMemory;

                }

            }

        if(ret==KErrNone)

            {

            // Set the DFC queue to be used by this logical channel to

            // low priority DFC queue (owned by the TraceCore)

            SetDfcQ( iActivationQue  );

            // Mark queue ready to accept messages

            iMsgQ.Receive();

            }

        }

    return ret;

    }

//---------------------------------------------------------------------------

/**

    Handles a synchronous request

    @param  aFunction  A number identifying specific functionality

    @param  a1  If specified, a parameter from the user side

    @param  a2  If specified, a parameter from the user side

    @return KErrNone, if successful

*/

TInt DTcChannel::DoControl(TInt aFunction, TAny* a1 = NULL)

    {

    TInt ret( KErrNotSupported );

    switch ( aFunction )

        {

        case RTraceOnActivation::ERegisterNotificationReceiver:

            {

            ret = RegisterNotificationReceiver( static_cast<TTraceOnActivationParams*>(a1) );

            break;

            }

        case RTraceOnActivation::EUnregisterNotificationReceiver:

            {

            ret = UnregisterNotificationReceiver( static_cast<TTraceOnActivationParams*>(a1) );

            break;

            }

        default:

            break;

        }

    return ret;

    }

//---------------------------------------------------------------------------

/**

    Read parameters from user-side thread and call TraceConnection::RegisterNotificationReceiver

    @param  aParameters Parameters from user-side

*/

TInt DTcChannel::RegisterNotificationReceiver( TTraceOnActivationParams* aParameters )

    {

    TTraceOnActivationParams params;

    TInt ret(KErrNone);

     //get userside information

	ret = Kern::ThreadRawRead(iClientThread, (const TAny *)aParameters,

			(TAny*)&params, sizeof(TTraceOnActivationParams) );

	if(ret != KErrNone)

	    {

	    return ret;

	    }

    if(iTraceConnection)

        {

        // Use correct part of iGroupId

        params.iGroupId = FixGroupId( params.iGroupId );

        // Check if iGroupId is valid

        if (!GroupIdIsValid(params.iGroupId))

            {

            ret = KErrArgument;

            }

        else

            {

            iTraceConnection->RegisterNotificationReceiver( params.iComponentId, params.iGroupId );

            }

        }

    else

        {

        ret = KErrGeneral;

        }

    return ret;

    }

//---------------------------------------------------------------------------

/**

    Read parameters from user-side thread and call TraceConnection::UnregisterNotificationReceiver

    @param  aParameters Parameters from user-side

*/

TInt DTcChannel::UnregisterNotificationReceiver( TTraceOnActivationParams* aParameters )

    {

    TTraceOnActivationParams params;

    TInt ret(KErrNone);

     //get userside information

	ret = Kern::ThreadRawRead(iClientThread, (const TAny *)aParameters,

			(TAny*)&params, sizeof(TTraceOnActivationParams) );

	if(ret != KErrNone)

	    return ret;

    if(iTraceConnection)

        {

        // Use correct part of iGroupId

        params.iGroupId = FixGroupId( params.iGroupId );

        // Check if iGroupId is valid

        if (!GroupIdIsValid(params.iGroupId))

            {

            ret = KErrArgument;

            }

        else

            {

            iTraceConnection->UnregisterNotificationReceiver( params.iComponentId, params.iGroupId );

            }

        }

    else

        {

        ret = KErrGeneral;

        }

    return ret;

    }

/**

    TraceActivated Notification

    Called from TraceConnection-TraceCore

    @param  aComponentId ComponentId of activated trace

    @param  aGroupId GroupId of activated trace

*/

TInt DTcChannel::TraceActivated( TUint32 aComponentId, TUint16 aGroupId )

    {    

    // Set component ID used in trace point

    TComponentId KOstTraceComponentID = aComponentId;

    // Calculate trace word from Group ID

    TUint32 traceWord = (aGroupId << GROUPIDSHIFT) | 1;

    // Instrument a trace point, as a simulated priming trace

    OstTrace0(aGroupId, traceWord, "Priming trace");

    return KErrNone;

    }

/**

    TraceDeactivated Notification

    Called from TraceConnection-TraceCore

    @param  aComponentId ComponentId of activated trace

    @param  aGroupId GroupId of activated trace

    @return 

*/

TInt DTcChannel::TraceDeactivated( TUint32 /*aComponentId*/, TUint16 /*aGroupId*/ )

    {

    return KErrNone;

    }

//---------------------------------------------------------------------------

/**

    DECLARE_STANDARD_LDD

    @return DTcFactory object

*/

DECLARE_STANDARD_LDD()

    {

    return new DTcFactory;

    }