/*

* Copyright (c) 2005 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:  An example implementation for ISC Driver Reference

*

*/

// INCLUDE FILES

#include <IscDefinitions.h>

#include <IscMultiplexerBase.h>

#include "IscMainRcvBuffer.h"

#include "IscQueue.h"

#include "IscDevice.h"

#include "IscChannel.h"

#include "IscChannelContainer.h"

#include "IscTrace.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS

DIscMainRcvBuffer* DIscMainRcvBuffer::iThisPointer = NULL;

const TInt KBufferCleanUpDfcPriority( 4 );

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

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

// DIscMainRcvBuffer::DIscMainRcvBuffer

// C++ default constructor

// ( other items were commented in a header ).

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

//

DIscMainRcvBuffer::DIscMainRcvBuffer( DIscDevice *aDevice, TUint16 aIscMainRcvBufferQueueSize )

    :iDevice ( aDevice ),

     iDfc( NULL ),

     iMainRcvBufferQueue( NULL )

    {

    iIscMainRcvBufferQueueSize = aIscMainRcvBufferQueueSize;

    iMainRcvBuffer = new TUint32*[iIscMainRcvBufferQueueSize];

    ASSERT_RESET_ALWAYS( iMainRcvBuffer, "IscDriver",EIscMemoryAllocationFailure );

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

        {

        iMainRcvBuffer[i] = NULL;

        }

    }

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

// DIscMainRcvBuffer::DoCreate

// Second-phase constructor to complete construction.

// ( other items were commented in a header ).

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

//

void DIscMainRcvBuffer::DoCreate()

    {

    if ( iThisPointer ) //Only one instance of this class is allowed

        {

        ASSERT_RESET_ALWAYS( 0,"IscDriver",EIscMainRcvBufferInitialize );

        }

    iDfc = new TDfc( BufferCleanUp, this, Kern::DfcQue0(), KBufferCleanUpDfcPriority );

    ASSERT_RESET_ALWAYS( iDfc, "IscDriver",EIscMemoryAllocationFailure );

    iMainRcvBufferQueue = new DIscQueue( iMainRcvBuffer, iIscMainRcvBufferQueueSize );

    ASSERT_RESET_ALWAYS( iMainRcvBufferQueue, "IscDriver",EIscMemoryAllocationFailure );

    //Store pointer of this instance that can be used from static functions

    iThisPointer = this;

    }

//Destructor

DIscMainRcvBuffer::~DIscMainRcvBuffer()

    {

    delete iDfc;

    delete iMainRcvBufferQueue;

    iDfc = NULL;

    iMainRcvBufferQueue = NULL;

    iThisPointer = NULL;

    iDevice = NULL;

    }

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

// DIscMainRcvBuffer::MsgReceive

// Function that should be called to store incoming frame

// ( other items were commented in a header ).

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

//

void DIscMainRcvBuffer::MsgReceive( TDesC8* aData )

    {    

    E_TRACE( ( _T( "IMRB:MR(0x%x)" ), aData ) );

    //Check that instance of this class is created

    if ( !iThisPointer )

        {

        // MainRcvBuffer not initialized -> panic

        ASSERT_RESET_ALWAYS( 0,"IscDriver",EIscMainRcvBufferInitialize );

        }

    TInt r = iThisPointer->iMainRcvBufferQueue->Add( aData );

    ASSERT_RESET_ALWAYS( r == KErrNone, "IscDriver",EIscMainRcvBufferOverflow );

    iThisPointer->AddDfc();

    }

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

// DIscMainRcvBuffer::AddDfc

// Function for adding Dfc

// ( other items were commented in a header ).

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

//

void DIscMainRcvBuffer::AddDfc()

    {    

#ifndef __WINS__

    if ( NKern::CurrentContext() == NKern::EInterrupt )

        {

        iDfc->Add();

        }

    else

        {

        iDfc->Enque();

        }

#else

    // Have to do DoEnque since Enque() & Add() cannot be called from pure 

    // win32 thread context. And this call might come directly in win32 thread

    // since the implementation of ISC Data Transmission API can do virtually 

    // anything in WINS

    iDfc->DoEnque();

#endif

    }

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

// DIscMainRcvBuffer::BufferCleanUp

// Function to empty messages in main buffer

// ( other items were commented in a header ).

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

//

void DIscMainRcvBuffer::BufferCleanUp( TAny* aPtr )

    {

    C_TRACE( ( _T( "DIscMainRcvBuffer::BufferCleanUp(0x%x)" ), aPtr ) );

    DIscMainRcvBuffer* Buffer = ( DIscMainRcvBuffer* )aPtr;

    TUint16 rcvChannelId( KIscFrameReceiverNotFound );

    TAny* channelPtr = NULL;

    DIscChannel* tempPtr = NULL;

    TBool channelFound( EFalse );

    TDesC8* ptr = NULL;

    ptr = ( TDesC8* )Buffer->iMainRcvBufferQueue->RemoveFirst();

    while ( ptr )

        {

        Buffer->iDevice->iIscMultiplexerInterface->GetRcvChannelId( *ptr, rcvChannelId, channelPtr );

        C_TRACE( ( _T( "DIscMainRcvBuffer::BufferCleanUp channelId (0x%x) channelPtr (0x%x)" ), rcvChannelId, channelPtr ) );

        if ( rcvChannelId >= KIscFirstChannel &&  rcvChannelId < KIscNumberOfUnits && channelPtr )

            {

            channelFound = EFalse;

            for ( TUint16 i( 0 ); ( i < KIscMaxNumberOfChannelSharers ) && ( !channelFound ); i++ )

                {

                tempPtr = IscChannelContainer::Channel( rcvChannelId, i );

                if ( tempPtr == channelPtr )

                    {

                    // correct channel found

                    ( ( DIscChannel* )channelPtr )->StoreFrame( ptr );

                    channelFound = ETrue;

                    }

                tempPtr = NULL;

                }

            if ( !channelFound )

                {

                TRACE_ASSERT_ALWAYS;

                // correct channel was not found -> release frame

                Buffer->iDevice->ReleaseMemoryBlock( ( TDes8* ) ptr );

                }

            }

        else if ( rcvChannelId == KIscFrameReceiverNotFound )

            {

            C_TRACE( ( _T( "DIscMainRcvBuffer::BufferCleanUp Frame Receiver not found!" ) ) );

            Buffer->iDevice->ReleaseMemoryBlock( ( TDes8* ) ptr );

            }

        // Frame going to control channel

        else if ( rcvChannelId == 0x00 )

            {

            Buffer->iDevice->iIscMultiplexerInterface->HandleControlFrame( *ptr );

            }

        else

            {

            TRACE_ASSERT_ALWAYS;

            Buffer->iDevice->ReleaseMemoryBlock( ( TDes8* ) ptr );

            }

        // get the next frame from the queue

        ptr = ( TDes8* )Buffer->iMainRcvBufferQueue->RemoveFirst();

        }

    IscChannelContainer::ChannelComplition( NULL );

    C_TRACE( ( _T( "DIscMainRcvBuffer::BufferCleanUp - return 0x%x" ) ) );

    }

// ========================== OTHER EXPORTED FUNCTIONS =========================

//  End of File