/*
* Copyright (c) 2007 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:  Implementation of DIscBufferQueue class
*
*/



// INCLUDE FILES

#include <IscDefinitions.h>
#include "IscBufferQueue.h"
#include "IscQueue.h"
#include "IscTrace.h"

#ifdef __WINS__
#include <windows.h>
#endif

// EXTERNAL DATA STRUCTURES
#ifdef __WINS__
extern CRITICAL_SECTION g_IscDTBCriticalSection;
#endif

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS
const TInt KIscInterruptLevelTwo( 2 );

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

// -----------------------------------------------------------------------------
// DIscBufferQueue::DIscBufferQueue
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
DIscBufferQueue::DIscBufferQueue()
    :   iCount( NULL ),
        iBuffers( NULL ),
        iBuffersQueue( NULL )
    {
    }
    

// -----------------------------------------------------------------------------
// DIscBufferQueue::Construct
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
TInt DIscBufferQueue::Construct( 
    TUint16 aSize, 
    TUint16 aCount, 
    TUint8* &aCurrentAddress )
    {
    C_TRACE( ( _T( "DIscBufferQueue::Construct(0x%x, 0x%x, 0x%x) 0x%x, 0x%x" ), aSize, aCount, &aCurrentAddress, iBuffers, iBuffersQueue  ) );
    
    TInt r = KErrNone;
    if ( aSize == 0 || aCount == 0 )
        return KErrArgument;
    
    iCount = aCount;
    iBuffers = new TUint32*[aCount];
    ASSERT_RESET_ALWAYS( iBuffers, "ISCDataTransmissionBase",EIscMemoryAllocationFailure );
    iBuffersQueue = new DIscQueue( iBuffers, aCount );
    ASSERT_RESET_ALWAYS( iBuffersQueue, "ISCDataTransmissionBase",EIscMemoryAllocationFailure );
    
    for ( TInt i = 0; i < aCount; i++ )
        {   
        TPtr8*  pTmp;        
#ifndef __WINS__
        pTmp = new TPtr8 ( ( TUint8* )aCurrentAddress, aSize );
        ASSERT_RESET_ALWAYS( pTmp, "ISCDataTransmissionBase",EIscMemoryAllocationFailure );
#else
        TAny* ptr = Kern::Alloc( aSize );
        ASSERT_RESET_ALWAYS( ptr, "ISCDataTransmissionBase",EIscMemoryAllocationFailure );
        pTmp = new TPtr8( ( TUint8* )ptr, 0, aSize );
        ASSERT_RESET_ALWAYS( pTmp, "ISCDataTransmissionBase",EIscMemoryAllocationFailure );
#endif // __WINS__

        // Put the buffer into RX resource queue.        
        r = iBuffersQueue->Add( pTmp );
        
        aCurrentAddress += aSize;
        }
    
    C_TRACE( ( _T( "DIscBufferQueue::Construct - return 0x%x" ),r ) );

    return r;
    }


// -----------------------------------------------------------------------------
// DIscBufferQueue::New
// Construct a new queue
// ( other items were commented in a header ).
// -----------------------------------------------------------------------------
//
DIscBufferQueue* DIscBufferQueue::New( 
    TUint16 aSize, 
    TUint16 aCount, 
    TUint8*& aCurrentAddress )
    {
    C_TRACE( ( _T( "DIscBufferQueue::New(0x%x, 0x%x, 0x%x)" ), aSize, aCount, aCurrentAddress) );

    DIscBufferQueue* self = new DIscBufferQueue();
    ASSERT_RESET_ALWAYS( self, "ISCDataTransmissionBase",EIscMemoryAllocationFailure );
    if ( self->Construct( aSize, aCount, aCurrentAddress ) != KErrNone )
        {
        delete self;
        self = NULL;
        }
    else
        {
        }

    C_TRACE( ( _T( "DIscBufferQueue::New - return 0x%x" ),self ) );
    return self;
    }

    
// -----------------------------------------------------------------------------
// DIscBufferQueue::~DIscBufferQueue
// Destructor
// ( other items were commented in a header ).
// -----------------------------------------------------------------------------
//
DIscBufferQueue::~DIscBufferQueue()
    {
    C_TRACE( ( _T( "DIscBufferQueue::~DIscBufferQueue()" ) ) );
    if ( iBuffersQueue )
        {
        /* release all buffers */
        for ( TInt i = 0; i < iBuffersQueue->Count(); i++ )
            {
            // destroy allocated buffer
            TPtr8* delBuf = ( TPtr8* )iBuffersQueue->RemoveFirst();
            
            if ( delBuf )
                {
#ifdef __WINS__
                Kern::Free( ( TAny* )delBuf->Ptr() );
                delete delBuf;
#else
                delete delBuf;
#endif
                }
            else
                {
                }
            }
        delete iBuffersQueue;
        delete []iBuffers;
        }
    C_TRACE( ( _T( "DIscBufferQueue::~DIscBufferQueue - return void" ) ) );
    }

// -----------------------------------------------------------------------------
// DIscBufferQueue::Reserve
// Reserves first element from the queue
// ( other items were commented in a header ).
// -----------------------------------------------------------------------------
//
TDes8* DIscBufferQueue::Reserve()
    {

    if ( iBuffersQueue )
        {
        TDes8* temp =  ( TDes8* )iBuffersQueue->RemoveFirst();
        if ( temp )
            {
            TInt irqLevel = DisableIrqs();
            iCount--;
            RestoreIrqs( irqLevel );
            }
        return temp;
        }
    else
        {
        return NULL;
        }

    }

// -----------------------------------------------------------------------------
// DIscBufferQueue::Release
// Releases element from the queue
// ( other items were commented in a header ).
// -----------------------------------------------------------------------------
//
void DIscBufferQueue::Release( 
    TDes8* aPtr )
    {
     
    if ( iBuffersQueue )
        {
        aPtr->Zero();
        TInt err = iBuffersQueue->Add( aPtr );
        ASSERT_RESET_ALWAYS( err == KErrNone, "ISCDataTransmissionBase",EIscBufferAllocationFailure );
        TInt irqLevel = DisableIrqs();
        iCount++;
        RestoreIrqs( irqLevel );
        }

    }

// -----------------------------------------------------------------------------
// DIscBufferQueue::DisableIrqs
// Function to disable interrupts
// ( other items were commented in a header ).
// -----------------------------------------------------------------------------
//
TInt DIscBufferQueue::DisableIrqs()
    {
#ifndef __WINS__
    return NKern::DisableInterrupts( KIscInterruptLevelTwo );    
#else //__WINS__
    EnterCriticalSection( &g_IscDTBCriticalSection );
    return KErrNone;
#endif//__WINS__
    }

// -----------------------------------------------------------------------------
// DIscBufferQueue::RestoreIrqs
// Function to restore interrupts
// ( other items were commented in a header ).
// -----------------------------------------------------------------------------
//

#ifndef __WINS__
void DIscBufferQueue::RestoreIrqs( 
    TInt aLevel )
    {
    NKern::RestoreInterrupts( aLevel );
#else //__WINS__
void DIscBufferQueue::RestoreIrqs( 
    TInt )
    {
    LeaveCriticalSection( &g_IscDTBCriticalSection );
#endif//__WINS__
    }
//  End of File