#include <platform.h>

#include <assp.h>

#include <kernel/kernel.h>

#include <e32cmn.h>

#include <graphics/devicereqhandler.h>

#include <graphics/virtualvideohwinterface.h>

#include <graphics/virtualvideotracing.h>

#include "remotefunctioncall.h"

#include "serializedfunctioncall.h"

#include "driverrfc.h"

#include "openvgrfc.h" //For the opcodes

#include "eglrfc.h" //For the opcodes

#include "opengles11rfc.h" //For the opcodes

using namespace GuestVideoDriver;

// LOCAL DATA TYPES

TInt CmpTPbsIds(const TPbSId& a, const TPbSId& b)

    {

    if( a.iPbuffer == b.iPbuffer )

        return 0;

    else

        return b.iPbuffer - a.iPbuffer;

    }

TInt CmpTVGIsIds(const TVGISId& a, const TVGISId& b)

    {

    if( a.iVGImage == b.iVGImage )

        return 0;

    else

        return b.iVGImage - a.iVGImage;

    }

/*

 * Copies data from client space to the request buffer during serialisation

 */

class TDataFromClientSpaceCopier: public MDataCopier

    {

public:

    TDataFromClientSpaceCopier( DThread* aUserThread ):

        iUserThread(aUserThread)

        {

        }

    TInt CopyData( TUint8* aDest, const TUint8* aSource, TUint32 aSize )

        {

        memcpy( aDest, aSource, aSize );

        return KErrNone;

        }

    TInt CopyVector( TUint8* aDest, const TUint8* aSource, TUint32 aSize )

        {

        return Kern::ThreadRawRead( iUserThread, aSource, aDest, aSize );

        }

    DThread* iUserThread;

    };

/*

 * Copies data to client space from the request buffer during deserialisation

 */

class TDataToClientSpaceCopier: public MDataCopier

    {

public:

    TDataToClientSpaceCopier( DThread* aUserThread ):

        iUserThread(aUserThread)

        {

        }

    TInt CopyData( TUint8* aDest, const TUint8* aSource, TUint32 aSize )

        {

        memcpy( aDest, aSource, aSize );

        return KErrNone;

        }

    TInt CopyVector( TUint8* aDest, const TUint8* aSource, TUint32 aSize )

        {

        return Kern::ThreadRawWrite(iUserThread, aDest, aSource, aSize );

        }

    DThread* iUserThread;

    };

// LOCAL FUNCTION DEFINITIONS

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

// ListRemoteFunctionCall

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

//

inline void ListRemoteFunctionCall(RemoteFunctionCallData& call)

    {

#if _DEBUG

    VVHW_TRACE("RFC: %u %u %u %u %u %u %u",

    call.Header().iOpCode,

    call.Header().iTransactionId,

    call.Header().iProcessId,

    call.Header().iThreadId,

    call.Header().iParameterCount,

    call.Header().iOpType,

    call.Header().iReturnValue);

    for ( TInt i = 0; i < call.Header().iParameterCount; i++)

        {

        RemoteFunctionCallData::TParam param = call.Parameters()[i];

        TUint32 dir = param.iDir;

        TUint32 type = param.iType;

        if ( RemoteFunctionCallData::TParam::ESimple == param.iType )

            {

            TUint32 datatype = param.iSimpleParam.iDataType; 

            VVHW_TRACE("RFC Simple Param %d: %u %u %u",i, dir, type, datatype );

            }

        else if ( RemoteFunctionCallData::TParam::EVector == param.iType )

            {

            TUint32 datatype = param.iVectorParam.iDataType; 

            TUint32 size = param.iVectorParam.iVectorLength;

            VVHW_TRACE("RFC Vec Param %d: %u %u %u %u",i, dir, type, datatype, size );

            }

        }

#endif // _DEBUG

    }

// CONSTANTS

const TInt KDfcPriority = 1;

// ============================= LOCAL FUNCTIONS ===============================

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

// Isr

// Interrupt service routine

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

//

void Isr( TAny* aParam )

    {

    DDeviceReqHandler* handler = ( DDeviceReqHandler* )aParam;

    Interrupt::Disable( handler->InterruptId() );

    handler->Dfc().Add();

    }

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

// DfcFunc

// Function to call when HW has an interrupt

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

//

void DfcFunc( TAny* aParam )

    {

    DDeviceReqHandler* handler = ( DDeviceReqHandler* )aParam;

    handler->ProcessDfc();

    }

// ============================ MEMBER FUNCTIONS ===============================

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

// DDeviceReqHandler::DDeviceReqHandler

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

//

DDeviceReqHandler::DDeviceReqHandler(

    DVirtualVideoHwInterface& aHwInterface,

    TDfcQue* aQueue) :

    iPbufferSgMapOrder ( &CmpTPbsIds ),

    iVGImageSgMapOrder ( &CmpTVGIsIds ),

    iCurrClientData(NULL),

    iInitialized(EFalse),

    iHwInterface( aHwInterface ),

    iDfc( DfcFunc, (TAny*)this, aQueue, KDfcPriority ),

    iInterruptId( 0 ),

    iTransactionId( 1 ),

    iRequestBuffer( *this, VVI_PARAMETERS_INPUT_MEMORY_SIZE )

    {

    iDriverRfcProcessId = 0;

    iDriverRfcThreadId  = 0;

    iOpType       = 0; 

    iOpChainPhase = 0;

    iInterruptId  = VVI_IRQ;

    VVHW_TRACE( "DDeviceReqHandler constructor" );

    VVHW_TRACE( "Called in process/thread %0x / %0x", Kern::CurrentProcess().iId, Kern::CurrentThread().iId );

    TInt err = Interrupt::Bind( iInterruptId, Isr, ( TAny* )this );

    if ( err != KErrNone )

        {

        VVHW_TRACE( "Interrupt::Bind Error: %d", err );

        }

    err = Interrupt::Enable( iInterruptId );

    if ( err != KErrNone )

        {

        Interrupt::Unbind( iInterruptId );

        iInterruptId = 0;

        VVHW_TRACE( "Interrupt::Enable Error: %d", err );

        }

    iRequestBuffer.InitBuffer();

    //Register this object with the extension

    VVHW_TRACE( "DDeviceReqHandler calling ReqHandlerExtension" );

#ifdef FAISALMEMON_S4_SGIMAGE

    ReqHandlerExtension::SetReqHandler( this );

#endif

    }

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

// DDeviceReqHandler::~DDeviceReqHandler

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

//

DDeviceReqHandler::~DDeviceReqHandler()

    {

    for( TInt i=0; i < iClientData.Count(); ++i )

        {

        delete iClientData[i];

        }

    iClientData.Close();

    Interrupt::Disable( iInterruptId );

    Interrupt::Unbind( iInterruptId );

    iInterruptId = 0;

    }

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

// DDeviceReqHandler::HandleClientShutdown

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

//

TInt DDeviceReqHandler::HandleClientShutdown( TUint aProcessId, TUint aThreadId )

    {

    VVHW_TRACE("DDeviceReqHandler::HandleClientShutdown");

    TInt err( KErrNone );

    TAsyncRequest* req = AllocRequest( NULL, NULL, NULL, NULL, TAsyncRequest::ERTDriver );

    if ( req )

        {

        DriverRFC drfc( req->iRemoteFunctionCall );

        drfc.Init( DriverRFC::EDrvClientShutdown, RemoteFunctionCallData::EOpRequest );        

        req->iRemoteFunctionCall.SetTransactionId( ++iTransactionId );

        req->iRemoteFunctionCall.SetThreadInformation( aProcessId, aThreadId );        

        iPendingRequestRoot.AppendToLast( req );

        TInt ret = ProcessNextPendingRequest();

        while ( KErrNone == ret )

            {

            ret = ProcessNextPendingRequest();

            }

        }

    else

        {

        err = KErrNoMemory;

        }

    return err;

    }

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

// DDeviceReqHandler::ProcessNextPendingRequest

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

//

TInt DDeviceReqHandler::ProcessNextPendingRequest()

    {

    VVHW_TRACE("DDeviceReqHandler::ProcessNextPendingRequest");

    TInt err( KErrNone );

    TAsyncRequest* req = iPendingRequestRoot.iNext;

    if ( !req )

        {

        VVHW_TRACE("DDeviceReqHandler::ProcessNextPendingRequest !req");

        return KErrUnderflow;

        }

    //Try to serve the client from here, or do some sgImage specific stuff

    TInt mode = InterpretRequest( req );

    switch( mode )

        {

        case ENormal:

            {

            //Nothing, process as normal

            break;

            }

        case EHandled:

            {

            //Already handled, remove and signal complete

            req->RemoveFromList( &iPendingRequestRoot );

            Kern::RequestComplete( req->iAsyncClient, req->iStatus, KErrNone );

            ReleaseRequest( req );

            return KErrNone;//Change to "err" if you add lines above this that may set it to something else

            }

        case EQueued:

            {

            //To be removed from the usual queues, but not deleted (released) or completed

            req->RemoveFromList( &iPendingRequestRoot );

            return KErrNone;

            }

        default:

            {

            break;

            }

        }

    if ( TAsyncRequest::ERTCommandLoad == req->iCommandLoadRequest )

        {

        VVHW_TRACE("DDeviceReqHandler::HandleLoadCommands");

        TInt loaderr( KErrNone );

        TInt len = Kern::ThreadGetDesLength( req->iAsyncClient, req->iA1 );

        if ( len < 0 )

            {

            VVHW_TRACE("DDeviceReqHandler::HandleLoadCommands len < 0");

            return KErrUnderflow;;

            }

        if ( !iRequestBuffer.CheckForSpace( len ) )

           {

           //Not enough space

           VVHW_TRACE("DDeviceReqHandler::HandleLoadCommands No space");

           return KErrNoMemory;

           }

        req->RemoveFromList( &iPendingRequestRoot );

        const TUint32 base( iRequestBuffer.AllocateBytes( len ) );

        //Next, serialize the call to the HW memory

        const TLinAddr paramAddr( iHwInterface.InputParametersAddress() + base );

        TPtr8 ptr(reinterpret_cast<TUint8*>(paramAddr), 0, len );

        //Read the RemoveFunctionCall

        loaderr = Kern::ThreadDesRead( req->iAsyncClient, req->iA1, ptr, 0, 0 );

        VVHW_TRACE("DDeviceReqHandler::HandleLoadCommands ThreadDesRead %d", loaderr);

        if ( KErrNone == loaderr )

            {

            VVHW_TRACE("DDeviceReqHandler::HandleLoadCommands CommitBytes");

            iRequestBuffer.CommitBytes( base, len );

            iHwInterface.IssueCommand( VVI_EXECUTE );

            }

        Kern::RequestComplete( req->iAsyncClient, req->iStatus, loaderr );

        ReleaseRequest( req );

        }

    else //ERTRequest or ERTDriver

        {

#if _DEBUG

        ListRemoteFunctionCall( req->iRemoteFunctionCall );

#endif

       VVHW_TRACE("DDeviceReqHandler::ProcessNextPendingRequest req %u tid %u opcode %u", 

            req, req->iRemoteFunctionCall.Header().iTransactionId,

            req->iRemoteFunctionCall.Header().iOpCode );

        const TUint32 serializedLength( req->iRemoteFunctionCall.SerialisedLength() );

        if ( !iRequestBuffer.CheckForSpace( serializedLength ) )

           {

           //Not enough space

           VVHW_TRACE("DDeviceReqHandler::ProcessNextPendingRequest No space");

           return KErrOverflow;

           }

        req->RemoveFromList( &iPendingRequestRoot );

        if ( RemoteFunctionCallData::EOpRequestWithReply == req->iRemoteFunctionCall.Header().iOpType )

            {

            VVHW_TRACE("DDeviceReqHandler::ProcessNextPendingRequest 3");

            iSerializedRequestRoot.AppendToLast( req );

            }

        TDataFromClientSpaceCopier datacopier( req->iAsyncClient );

        SerializedFunctionCall sfc( req->iRemoteFunctionCall );

        if ( TAsyncRequest::ERTRequest == req->iCommandLoadRequest )

            {

            sfc.SetDataCopier( &datacopier );            

            }

        const TUint32 base( iRequestBuffer.AllocateBytes( serializedLength ) );

        //Next, serialize the call to the HW memory

        const TLinAddr paramAddr( iHwInterface.InputParametersAddress() + base );

        TInt len = sfc.WriteToBuffer( reinterpret_cast<TUint8*>(paramAddr),

                VVI_PARAMETERS_INPUT_MEMORY_SIZE - 1 - base );

        sfc.SetDataCopier( NULL );

        VVHW_TRACE("DDeviceReqHandler::ProcessNextPendingRequest Write at index %u with length %u", base, len );

        iRequestBuffer.CommitBytes( base, serializedLength );

        iHwInterface.IssueCommand( VVI_EXECUTE );

        if ( RemoteFunctionCallData::EOpRequest == req->iRemoteFunctionCall.Header().iOpType )

            {

            if ( TAsyncRequest::ERTRequest == req->iCommandLoadRequest )

                {

                VVHW_TRACE("DDeviceReqHandler::ProcessNextPendingRequest RequestComplete");

                Kern::RequestComplete( req->iAsyncClient, req->iStatus, KErrNone );

                }

            ReleaseRequest( req );

            }

        }

    VVHW_TRACE("DDeviceReqHandler::ProcessNextPendingRequest DONE");

    return err;

    }

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

// DDeviceReqHandler::HandleLoadCommands

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

//

TInt DDeviceReqHandler::HandleLoadCommands(

        DThread*& aUserThread,

        TRequestStatus* aStatus,

        TAny* aA1 )

    {

    VVHW_TRACE("DDeviceReqHandler::HandleLoadCommands");

    TInt err( KErrNone );

    TAsyncRequest* req = AllocRequest( aStatus, aUserThread, aA1, NULL, TAsyncRequest::ERTCommandLoad );

    if ( req )

        {

        TInt len = Kern::ThreadGetDesLength( req->iAsyncClient, req->iA1 );

        if ( len < 0 )

            {

            err = len;//TODO: this sucks

            ReleaseRequest( req );

            return err;

            }

        iPendingRequestRoot.AppendToLast( req );

        TInt ret = ProcessNextPendingRequest();

        while ( KErrNone == ret )

            {

            ret = ProcessNextPendingRequest();

            }

        }

    else

        {

        err = KErrNoMemory;

        }

    return err;

    }

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

// DDeviceReqHandler::HandleExecuteAsync

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

//

TInt DDeviceReqHandler::HandleExecuteAsync(

        DThread*& aUserThread,

        TRequestStatus* aStatus,

        TAny* a1 )

    {

    VVHW_TRACE("DDeviceReqHandler::HandleExecuteAsync");

    TInt err( KErrNone );

    TAsyncRequest* req = AllocRequest( aStatus, aUserThread, a1, NULL );

    if ( req )

        {

        TInt len = Kern::ThreadGetDesLength( req->iAsyncClient, req->iA1 );

        if ( len < 0 )

            {

            err = len;

            ReleaseRequest( req );

            return err;

            }

        TPckg<RemoteFunctionCallData> rcallbuf( req->iRemoteFunctionCall );

        //Read the RemoteFunctionCall

        err = Kern::ThreadDesRead( req->iAsyncClient, req->iA1, rcallbuf, 0, 0 );

        if ( KErrNone != err )

            {

            ReleaseRequest( req );

            return err;

            }

        req->iRemoteFunctionCall.SetTransactionId( ++iTransactionId );

        iPendingRequestRoot.AppendToLast( req );

        TInt ret = ProcessNextPendingRequest();

        while ( KErrNone == ret )

            {

            ret = ProcessNextPendingRequest();

            }

        }

    else

        {

        err = KErrNoMemory;

        }

    VVHW_TRACE("DDeviceReqHandler::HandleExecuteAsync <-");