/*

* Copyright (c) 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: 

*

*/

#include "queue.h"                  // For DQueue

#include "isauserchannel.h"         // For DISAUserChannel

#include "iadtrace.h"               // For C_TRACE, ASSERT_RESET.. and fault codes.

#include "isaaccessextension.h"     // For DIsaAccessExtension

#include "iadnokiadefinitions.h"    // For checking allowed user channels.

// Extracting and adding the pipeheader.

#include <phonetisi.h>              // For ISI_HEADER_SIZE

#include <pipeisi.h>                // For PNS_PIPE_DATA_OFFSET_DATA

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "isauserchannelTraces.h"

#endif

const TInt KPipeDataHeader( ISI_HEADER_SIZE + PNS_PIPE_DATA_OFFSET_DATA );

const TInt KFirstParam( 0 );

const TInt KSecondParam( 1 );

const TInt KThirdParam( 2 );

const TInt KNoParams( KErrNone );

const TInt KOneParam( 1 );

const TInt KTwoParams( 2 );

const TInt KThreeParams( 3 );

const TInt KDestStartOffset( 0 );

//

// user <-> kernel interaction() done in LDD DFC thread

// 

// kernel<->kernel interaction() done in Extension DFC thread

//

////////////////// NOTE! /////////////////////////////////////////

// 

// SYNCHRONIZATION:

// Check sync of mutex guarded shread members. 

// Rule1: No blocking operation like trace prints inside mutex guareded code sections.

//

// DEMAND_PAGING

// Receive (write k->u) is done only in LDD thread context to allow Extension thread to continue when dp swaps.

// Send ((write u->k) is not done at the moment in LDD thread context only. Check is it possible to happend (not to be in usable memory after send (unlikely?)).

// Change this to use UniqueID of DThread instead and to extension 

void DISAUserChannel::CheckDfc()

    {

    OstTrace0( TRACE_NORMAL, DISAUSERCHANNEL_CHECKDFC_ENTRY, ">DISAUserChannel::CheckDfc" );

    DObject* tempObj = reinterpret_cast<DObject*>( &Kern::CurrentThread() ); 

    TUint8* buffer = ( TUint8* )Kern::Alloc( 100 );

    TPtr8* bufferPtr = new ( TPtr8 )( buffer, 100 );

    tempObj->Name( *bufferPtr );

    C_TRACE( ( _T( "DISAUserChannel::CheckDfc" ) ) );

    if ( bufferPtr->Compare( KIADLddDfc ) != KErrNone )

        {

        for( TInt i( 0 );i < bufferPtr->Length(); ++i )

           {

           C_TRACE( ( _T( "%c" ), i, bufferPtr->Ptr()[ i ] ) );

           }

        ASSERT_RESET_ALWAYS( 0, EIADWrongDFCQueueUsed| EIADFaultIdentifier3 << KFaultIdentifierShift  );

        }

    Kern::Free( buffer );

    delete bufferPtr;

    bufferPtr = NULL;

    OstTrace0( TRACE_NORMAL, DISAUSERCHANNEL_CHECKDFC_EXIT, "<DISAUserChannel::CheckDfc" );

    }

#ifdef _DEBUG

#define    ASSERT_DFCTHREAD_INLDD()// CheckDfc()

#else

#define    ASSERT_DFCTHREAD_INLDD()

#endif

EXPORT_C DISAUserChannel::DISAUserChannel(

        // None

        )

    :

    iChannelNumber( KNotInitializedChannel ),

    iIADConnectionStatusPtr( NULL ),

    iIADFlowControlStatusPtr( NULL ),

    iFlowCtrlStatus( EIADTransmissionEnd ),

    iLastNotifiedFlowCtrlStatus( EIADTransmissionEnd ),

    iReceiveBufPtr( NULL ),

    iDataReceiveBufPtr( NULL ),

    iNeededBufLen( NULL ),

    iNeededDataBufLen( NULL ),

    iRx( NULL ),

    iDataRx( NULL ),

    iThread( &Kern::CurrentThread() ),

    iPep( NULL ),

    iReqQueue( NULL ),

    iMsgQue( MsgQueFunc, this, NULL, 1 ),

    iRxDeAllocate( NULL ),

    iDataRxDeAllocate( NULL )

    {

    OstTrace0( TRACE_NORMAL, DISAUSERCHANNEL_DISAUSERCHANNEL_ENTRY, ">DISAUserChannel::DISAUserChannel" );

    C_TRACE( ( _T( "DISAUserChannel::DISAUserChannel ->" ) ) );

    iExtensionApi = DIsaAccessExtension::GetChannel2IADApi();

    iEmptyRxQueueDfc = new TDfc( EmptyRxQueueDfc, this, DIsaAccessExtension::GetDFCThread( EIADLddDfcQueue ), KIADLddEmptyRxQueuePriori );

    iEmptyDataRxQueueDfc = new TDfc( EmptyDataRxQueueDfc, this, DIsaAccessExtension::GetDFCThread( EIADLddDfcQueue ), KIADLddEmptyDataRxQueuePriori );

    ASSERT_RESET_ALWAYS( iExtensionApi && iEmptyRxQueueDfc && iEmptyDataRxQueueDfc,

                                             EIADMemoryAllocationFailure | EIADFaultIdentifier20 << KFaultIdentifierShift );

    iConnectionStatusDfc = new TDfc( ConnectionStatusDfc, this, DIsaAccessExtension::GetDFCThread( EIADLddDfcQueue ), KIADLddConnStatPriori );

    iFlowCtrlStatusDfc = new TDfc( FlowCtrlStatusDfc, this, DIsaAccessExtension::GetDFCThread( EIADLddDfcQueue ), KIADLddFlowStatPriori );

    iCompleteChannelRequestDfc = new TDfc( CompleteChReqDfc, this, DIsaAccessExtension::GetDFCThread( EIADLddDfcQueue ), KIADLddCompleteChannelPriori );

    // For sync between ldd <-> extension dfc threads. NOTE! must not be held when accessing to user memory!

    iChFastMutex = new NFastMutex();

    ASSERT_RESET_ALWAYS( iConnectionStatusDfc && iFlowCtrlStatusDfc && iCompleteChannelRequestDfc && iChFastMutex,

                                           EIADMemoryAllocationFailure | EIADFaultIdentifier21 << KFaultIdentifierShift );

    iCleanDfc = new TDfc( CleanBlocksDfc, this, DIsaAccessExtension::GetDFCThread( EIADExtensionDfcQueue ), KIADLddEmptyRxQueuePriori );

    iCleanDataDfc = new TDfc( CleanDataBlocksDfc, this, DIsaAccessExtension::GetDFCThread( EIADExtensionDfcQueue ), KIADLddEmptyDataRxQueuePriori );

    ASSERT_RESET_ALWAYS( iCleanDfc && iCleanDataDfc, EIADMemoryAllocationFailure | EIADFaultIdentifier21 << KFaultIdentifierShift );

    C_TRACE( ( _T( "DISAUserChannel::DISAUserChannel <-" ) ) );

    OstTrace0( TRACE_NORMAL, DISAUSERCHANNEL_DISAUSERCHANNEL_EXIT, "<DISAUserChannel::DISAUserChannel" );

    }

void DISAUserChannel::MsgQueFunc(

        TAny* aPtr

        )

    {

    OstTrace1( TRACE_NORMAL, DISAUSERCHANNEL_MSGQUEFUNC_ENTRY, ">DISAUserChannel::MsgQueFunc;aPtr=%x", ( TUint )( aPtr ) );

    DISAUserChannel* ch = reinterpret_cast<DISAUserChannel*>( aPtr );

    ch->HandleMsg( ch->iMsgQue.iMessage );

    OstTrace0( TRACE_NORMAL, DISAUSERCHANNEL_MSGQUEFUNC_EXIT, "<DISAUserChannel::MsgQueFunc" );

    }

DISAUserChannel::~DISAUserChannel(

        // None

        )

    {

    OstTrace0( TRACE_NORMAL, DUP1_DISAUSERCHANNEL_DISAUSERCHANNEL_ENTRY, ">DISAUserChannel::~DISAUserChannel" );

    C_TRACE( ( _T( "DISAUserChannel::~DISAUserChannel 0x%x 0x%x ->" ), iChannelNumber, this ) );

    OstTraceExt5( TRACE_NORMAL, DISAUSERCHANNEL_DISAUSERCHANNEL, "DISAUserChannel::~DISAUserChannel;iEmptyRxQueueDfc=%x;iEmptyDataRxQueueDfc=%x;iConnectionStatusDfc=%x;iFlowCtrlStatusDfc=%x;iCompleteChannelRequestDfc=%x", (TUint)iEmptyRxQueueDfc, (TUint)iEmptyDataRxQueueDfc, (TUint)iConnectionStatusDfc, (TUint)iFlowCtrlStatusDfc, (TUint)iCompleteChannelRequestDfc );

    if( iEmptyRxQueueDfc )

        {

        C_TRACE( ( _T( "DISAUserChannel::~DISAUserChannel iEmptyRxQueueDfc 0x%x" ), iEmptyRxQueueDfc ) );

        iEmptyRxQueueDfc->Cancel();

        delete iEmptyRxQueueDfc;

        iEmptyRxQueueDfc = NULL;

        }

    if( iEmptyDataRxQueueDfc )

        {

        C_TRACE( ( _T( "DISAUserChannel::~DISAUserChannel iEmptyDataRxQueueDfc 0x%x" ), iEmptyDataRxQueueDfc ) );

        iEmptyDataRxQueueDfc->Cancel();

        delete iEmptyDataRxQueueDfc;

        iEmptyDataRxQueueDfc = NULL;

        }

    if( iConnectionStatusDfc )

        {

        C_TRACE( ( _T( "DISAUserChannel::~DISAUserChannel iConnectionStatusDfc 0x%x" ), iConnectionStatusDfc ) );

        iConnectionStatusDfc->Cancel();

        delete iConnectionStatusDfc;

        iConnectionStatusDfc = NULL;

        }

    if( iFlowCtrlStatusDfc )

        {

        C_TRACE( ( _T( "DISAUserChannel::~DISAUserChannel iFlowCtrlStatusDfc 0x%x" ), iFlowCtrlStatusDfc ) );

        iFlowCtrlStatusDfc->Cancel();

        delete iFlowCtrlStatusDfc;

        iFlowCtrlStatusDfc = NULL;

        }

    if( iCompleteChannelRequestDfc )

        {

        C_TRACE( ( _T( "DISAUserChannel::~DISAUserChannel iCompleteChannelRequestDfc 0x%x" ), iCompleteChannelRequestDfc ) );

        iCompleteChannelRequestDfc->Cancel();

        delete iCompleteChannelRequestDfc;

        iCompleteChannelRequestDfc = NULL;

        }

    OstTraceExt4( TRACE_NORMAL, DUP1_DISAUSERCHANNEL_DISAUSERCHANNEL, "DISAUserChannel::~DISAUserChannel;iRx=%x;iDataRx=%x;iRxDeAllocate=%x;iDataRxDeAllocate=%x", (TUint)iRx, (TUint)iDataRx, (TUint)iRxDeAllocate, (TUint)iDataRxDeAllocate );

    if( iRx )

        {

        C_TRACE( ( _T( "DISAUserChannel::~DISAUserChannel iRx 0x%x" ), iRx ) );

        delete iRx;

        iRx = NULL;

        }

    if( iDataRx )

        {

        C_TRACE( ( _T( "DISAUserChannel::~DISAUserChannel iDataRx 0x%x" ), iDataRx ) );

        delete iDataRx;

        iDataRx = NULL;

        }

    if( iRxDeAllocate )

        {

        C_TRACE( ( _T( "DISAUserChannel::~DISAUserChannel iRxDeAllocate 0x%x" ), iRxDeAllocate ) );

        delete iRxDeAllocate;

        iRxDeAllocate = NULL;

        }

    if( iDataRxDeAllocate )

        {

        C_TRACE( ( _T( "DISAUserChannel::~DISAUserChannel iDataRxDeAllocate 0x%x" ), iDataRxDeAllocate ) );

        delete iDataRxDeAllocate;

        iDataRxDeAllocate = NULL;

        }

    // Not owned

    OstTraceExt4( TRACE_NORMAL, DUP9_DISAUSERCHANNEL_DISAUSERCHANNEL, "DISAUserChannel::~DISAUserChannel;iIADConnectionStatusPtr=%x;iIADFlowControlStatusPtr=%x;iReceiveBufPtr=%x;iDataReceiveBufPtr=%x", (TUint)iIADConnectionStatusPtr, (TUint)iIADFlowControlStatusPtr, (TUint)iReceiveBufPtr, (TUint)iDataReceiveBufPtr );

    if( iIADConnectionStatusPtr )

        {

        C_TRACE( ( _T( "DISAUserChannel::~DISAUserChannel iIADConnectionStatusPtr 0x%x" ), iIADConnectionStatusPtr ) );

        iIADConnectionStatusPtr = NULL;

        }

    if( iIADFlowControlStatusPtr )

        {

        C_TRACE( ( _T( "DISAUserChannel::~DISAUserChannel iIADFlowControlStatusPtr 0x%x" ), iIADFlowControlStatusPtr ) );

        iIADFlowControlStatusPtr = NULL;

        }

    if( iReceiveBufPtr )

        {

        C_TRACE( ( _T( "DISAUserChannel::~DISAUserChannel iReceiveBufPtr 0x%x" ), iReceiveBufPtr ) );

        iReceiveBufPtr = NULL;

        }

    if( iDataReceiveBufPtr )

        {

        C_TRACE( ( _T( "DISAUserChannel::~DISAUserChannel iDataReceiveBufPtr 0x%x" ), iDataReceiveBufPtr ) );

        iDataReceiveBufPtr = NULL;

        }

    OstTraceExt4( TRACE_NORMAL, DUP10_DISAUSERCHANNEL_DISAUSERCHANNEL, "DISAUserChannel::~DISAUserChannel;iNeededBufLen=%x;iNeededDataBufLen=%x;iIADUserChannelNumberPtr=%x;iReqQueue=%x", (TUint)iNeededBufLen, (TUint)iNeededDataBufLen, (TUint)iIADUserChannelNumberPtr, (TUint)iReqQueue );

    if( iNeededBufLen )

        {

        C_TRACE( ( _T( "DISAUserChannel::~DISAUserChannel iNeededBufLen 0x%x" ), iNeededBufLen ) );

        iNeededBufLen = NULL;

        }

    if( iNeededDataBufLen )

        {

        C_TRACE( ( _T( "DISAUserChannel::~DISAUserChannel iNeededDataBufLen 0x%x" ), iNeededDataBufLen ) );

        iNeededDataBufLen = NULL;

        }

    if( iIADUserChannelNumberPtr )

        {

        C_TRACE( ( _T( "DISAUserChannel::~DISAUserChannel iIADUserChannelNumberPtr 0x%x" ), iIADUserChannelNumberPtr ) );

        iIADUserChannelNumberPtr = NULL;

        }

    if( iReqQueue )

       {

       delete iReqQueue;

       iReqQueue = NULL;

       }

    iPep = NULL;

    iExtensionApi = NULL;

    // owned

    if( iChFastMutex )

        {

        C_TRACE( ( _T( "DISAUserChannel::~DISAUserChannel iChFastMutex" ) ) );

        delete iChFastMutex;

        iChFastMutex = NULL;

        }

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

    C_TRACE( ( _T( "DISAUserChannel::~DISAUserChannel 0x%x 0x%x <-" ), iChannelNumber, this ) );

    }

TInt DISAUserChannel::DoCreate(

        TInt, //aUnit,          // Used to hold channelid now in anInfo instead no need to extension device

        const TDesC8* anInfo,   // Channelid now in anInfo instead no need to extension device 

        const TVersion& // aVer    // Not used at the moment.

        )

    {

    OstTraceExt2( TRACE_NORMAL, DISAUSERCHANNEL_DOCREATE_ENTRY, "DISAUserChannel::DoCreate;anInfo=%x;this=%x", ( TUint )( anInfo ), (TUint)(this) );

    C_TRACE( ( _T( "DISAUserChannel::DoCreate 0x%x 0x%x ->" ), iChannelNumber, anInfo ) );

    if( !Kern::CurrentThreadHasCapability( ECapabilityCommDD, __PLATSEC_DIAGNOSTIC_STRING( "Check by: ISAAccessDriver" ) ) ) return KErrPermissionDenied;  

    ASSERT_RESET_ALWAYS( anInfo, EIADChannelNumberNotSpecifiedInInfo | EIADFaultIdentifier1 << KFaultIdentifierShift );

    // Check for channel number inside anInfo.

    ASSERT_RESET_ALWAYS( ( channel < EIADNokiaLastUserChannel ),EIADWrongParameter | EIADFaultIdentifier19 << KFaultIdentifierShift );

    iChannelNumber = ~channel; // In user thread context thread in CS, cannot be pre-empted.

    C_TRACE( ( _T( "DISAUserChannel::DoCreate channelnumber 0x%x 0x%x" ), iChannelNumber, this ) );

    iRx = new DQueue( KIADLddRxQueuSize );

    iDataRx =new DQueue( KIADLddDataRxQueuSize );

    iReqQueue = new DReqQueue();

    ASSERT_RESET_ALWAYS( iRx && iDataRx && iReqQueue, EIADMemoryAllocationFailure | EIADFaultIdentifier22 << KFaultIdentifierShift );

    iRxDeAllocate = new DQueue( KIADLddRxQueuSize );

    iDataRxDeAllocate = new DQueue( KIADLddDataRxQueuSize );

    // Changed to extension DFC to guarantee that extension is handled only by one thread extensionDFC.

    // Other DFC functions handling user<->kernel copying done in ldd DFC.

    SetDfcQ( DIsaAccessExtension::GetDFCThread( EIADExtensionDfcQueue ) );// this DFCFunction prio is now 1 by the LDD framework if needed increase?

    iMsgQ.Receive();

    iMsgQue.SetDfcQ( DIsaAccessExtension::GetDFCThread( EIADLddDfcQueue ) );

    iMsgQue.Receive();

    DObject* thread = reinterpret_cast<DObject*>( iThread );

    // Open is needed to increase ref count to calling thread that is decreased in Kern::SafeClose

    // Possible returns KErrNone ? KErrGeneral

    TInt threadOpen( thread->Open() );

    TRACE_ASSERT_INFO( threadOpen == KErrNone, (TUint8)iChannelNumber << KChannelNumberShift );

    C_TRACE( ( _T( "DISAUserChannel::DoCreate 0x%x %d <-" ), iChannelNumber, threadOpen ) );

    OstTraceExt3( TRACE_NORMAL, DISAUSERCHANNEL_DOCREATE_EXIT, "<DISAUserChannel::DoCreate;iChannelNumber=%hx;this=%x;retVal=%d", iChannelNumber, (TUint)this, threadOpen );    

    return threadOpen;

    }

void DISAUserChannel::HandleMsg

        (

        TMessageBase* aMsg

        )

    {

    OstTrace1( TRACE_NORMAL, DISAUSERCHANNEL_HANDLEMSG_ENTRY, ">DISAUserChannel::HandleMsg;aMsg=%x", ( TUint )( aMsg ) );

    C_TRACE( ( _T( "DISAUserChannel::HandleMsg 0x%x->" ), aMsg ) );

    TThreadMessage& m= *( static_cast< TThreadMessage* >( aMsg ) );

    TInt id( m.iValue );

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

        {

        C_TRACE( ( _T( "DISAUserChannel::HandleMsg ECloseMsg 0x%x" ), iChannelNumber ) );

        OstTraceExt1( TRACE_NORMAL, DISAUSERCHANNEL_HANDLEMSG, "DISAUserChannel::HandleMsg ECloseMsg;iChannelNumber=%hx", iChannelNumber );

        m.Complete( HandleSyncRequest( EIADClose, NULL ), EFalse );

        }

    else if( KMaxTInt == id )

        {

        C_TRACE( ( _T( "DISAUserChannel::HandleMsg cancel" ) ) );

        OstTrace0( TRACE_NORMAL, DUP1_DISAUSERCHANNEL_HANDLEMSG, "DISAUserChannel::HandleMsg cancel" );

        DoCancel( id, m.Int0() );

        m.Complete( KErrNone, ETrue );

        }

    else

        {

        ASSERT_RESET_ALWAYS( ( KErrNotFound < id ), EIADWrongRequest | EIADFaultIdentifier5 << KFaultIdentifierShift );

        C_TRACE( ( _T( "DISAUserChannel::HandleMsg completeValue == KErrNone" ) ) );

        OstTrace1( TRACE_NORMAL, DUP2_DISAUSERCHANNEL_HANDLEMSG, "DISAUserChannel::HandleMsg;id=%d", id );

        TInt completeValue( KErrNone );

        TInt ulen( KErrNotFound );

        switch ( id )

            {

            case EIADClose:

            case EIADGetConnectionStatus:

            case EIADGetMaxDataSize:

            case EIADResetQueues:

            case EIADGetFlowControlStatus:

#if (NCP_COMMON_SOS_VERSION_SUPPORT >= SOS_VERSION_95)

            case EIADReturnLoan:

#endif

                {

                ulen = KNoParams;

                break;

                }

            case EIADAsyncClose:

            case EIADSend:

            case EIADDataSend:

            case EIADSubscribeIndications:

            case EIADSendIndication:

            case EIADSubscribeIndications32Bit:

#if (NCP_COMMON_SOS_VERSION_SUPPORT >= SOS_VERSION_95)

            case EIADLoan:

#endif

                {

                ulen = KOneParam;

                break;

                }

            case EIADAsyncNotifyFlowControlStatus:

            case EIADAsyncNotifyConnectionStatus:

            case EIADAsyncSend:

            case EIADAsyncDataSend:

            case EIADAsyncSubscribeIndications:

            case EIADAsyncSendIndication:

            case EIADAsyncSubscribeIndications32Bit:

            //case EIADAsyncFTDInformation:

                {

                ulen = KTwoParams;

                break;

                }

            case EIADAsyncOpen:

            case EIADAsyncReceive:

            case EIADAsyncDataReceive:

                {

                ulen = KThreeParams;

                break;

                }

            default:

                {

                ASSERT_RESET_ALWAYS( 0, EIADWrongRequest | EIADFaultIdentifier6 << KFaultIdentifierShift );

                break;

                }

            }

        TUint32* table[ KThreeParams ];

        completeValue = Kern::ThreadRawRead( iThread, m.Ptr0(), table, ulen * sizeof( TAny* ) );

        if( completeValue == KErrNone )

            {

            switch( id )

                {

                // All asynchronous requests.

                case EIADAsyncOpen:

                case EIADAsyncNotifyConnectionStatus:

                case EIADAsyncClose:

                case EIADAsyncReceive:

                case EIADAsyncDataReceive:

                case EIADAsyncNotifyFlowControlStatus:

                case EIADAsyncSend:

                case EIADAsyncDataSend:

                case EIADAsyncSubscribeIndications:

                case EIADAsyncSendIndication:

                case EIADAsyncSubscribeIndications32Bit:

                //case EIADAsyncFTDInformation:

                    {

                    // No need to check return value in async functions, completed to user

                    HandleAsyncRequest( id, table );

                    break;

                    }

                case EIADClose:

                case EIADSend:

                case EIADDataSend:

                case EIADSubscribeIndications:

                case EIADSendIndication:

                case EIADGetMaxDataSize:

                case EIADSubscribeIndications32Bit:

                case EIADGetConnectionStatus:

                case EIADResetQueues:

                case EIADGetFlowControlStatus:

#if (NCP_COMMON_SOS_VERSION_SUPPORT >= SOS_VERSION_95)

                case EIADLoan:

                case EIADReturnLoan:

#endif

                    {

                    completeValue = HandleSyncRequest( id, table );

                    break;

                    }

                default:

                    {

                    ASSERT_RESET_ALWAYS( 0, EIADWrongRequest | EIADFaultIdentifier7 << KFaultIdentifierShift );

                    break;

                    }

                }

            }

        m.Complete( completeValue, ETrue );

        }

    C_TRACE( ( _T( "DISAUserChannel::HandleMsg <-" ) ) );

    OstTrace0( TRACE_NORMAL, DISAUSERCHANNEL_HANDLEMSG_EXIT, "<DISAUserChannel::HandleMsg");

    }

TInt DISAUserChannel::Request(

        TInt aReqNo,

        TAny* a1,

        TAny* //a2

        )

    {

    OstTraceExt2( TRACE_NORMAL, DISAUSERCHANNEL_REQUEST_ENTRY, "ZDISAUserChannel::Request;aReqNo=%d;a1=%x", aReqNo, ( TUint )( a1 ) );

    C_TRACE( ( _T( "DISAUserChannel::Request %d, 0x%x, 0x%x 0x%x->" ), aReqNo, a1, iChannelNumber ) );

    ASSERT_RESET_ALWAYS( aReqNo >= ( TInt ) EMinRequestId, EIADWrongRequest | EIADFaultIdentifier8 << KFaultIdentifierShift );

#if (NCP_COMMON_SOS_VERSION_SUPPORT >= SOS_VERSION_95)

    ASSERT_RESET_ALWAYS( aReqNo <= EIADReturnLoan || aReqNo == KMaxTInt, 

                                            EIADWrongRequest | EIADFaultIdentifier1 << KFaultIdentifierShift );

    ASSERT_RESET_ALWAYS( ( iChannelNumber < EIADNokiaLastUserChannel || EIADAsyncOpen == aReqNo || EIADLoan == aReqNo ),

                                               EIADWrongParameter | EIADFaultIdentifier18 << KFaultIdentifierShift );

#else

    ASSERT_RESET_ALWAYS( aReqNo <= EIADDeAllocateBlock || aReqNo == KMaxTInt, 

                                            EIADWrongRequest | EIADFaultIdentifier1 << KFaultIdentifierShift );

    ASSERT_RESET_ALWAYS( ( iChannelNumber < EIADNokiaLastUserChannel || EIADAsyncOpen == aReqNo ),

                                               EIADWrongParameter | EIADFaultIdentifier18 << KFaultIdentifierShift );

#endif

    TInt result( KErrNotFound );

    // All request go now in kernel context: easies synchronization between isa access threads.

    // We have the option still to use user context here. (CAREFULL IF DOING SO WITH DATA CORRUPTION)

    // Give to kernel address space in EXT DFC context.

    // Demand paging: if needed change this DFC to LDD DFC and

    // give the read data from LDD DFC to EXT DFC via another SendReceive (MessageQue).

    TThreadMessage& m=Kern::Message();

    m.iValue = aReqNo;

    m.iArg[ KFirstParam ] = a1;

    m.iArg[ KSecondParam ] = NULL;

    // Own kernelmessage queu for receive and datareceive which are not handling shareddata below channel (in extension).

    if( aReqNo == EIADAsyncReceive || aReqNo == EIADAsyncDataReceive )

        {

        result = m.SendReceive( &iMsgQue );

        }

    else

        {

        result = m.SendReceive( &iMsgQ );