/*

* 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 <kernel.h>

#include <IscDefinitions.h>

#include "IscChannel.h"

#include "IscChannelContainer.h"

#include "IscTrace.h"

#ifdef __WINS__

#include <windows.h>

#endif

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS

const TInt KChannelComplitionDfcPriority( 2 );

// MACROS

// LOCAL CONSTANTS AND MACROS

DIscChannel* IscChannelContainer::iIscChannels[KIscNumberOfUnits][KIscMaxNumberOfChannelSharers];

TDfc* IscChannelContainer::iDfc = NULL;

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

#ifdef __WINS__

CRITICAL_SECTION g_IscCriticalSection;

#endif

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

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

// IscChannelContainer::SetChannel

// Set pointer to channel

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

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

//

EXPORT_C TInt IscChannelContainer::SetChannel( 

    DIscChannel* aChannel,

    const TUint16 aUnit )

    {

    C_TRACE( ( _T( "IscChannelContainer::SetChannel(0x%x, 0x%x)" ), aChannel, aUnit ) );

    TInt error( KErrNoMemory );

    //check values

    if ( aUnit < KIscNumberOfUnits )

        {

        for ( TInt i( 0 ); i < KIscMaxNumberOfChannelSharers; i++ )

            {

            if ( !iIscChannels[aUnit][i] )

                {

                iIscChannels[aUnit][i] = aChannel;

                error = KErrNone;

                break;

                }

            }

        }

    else

        {

        ASSERT_RESET_ALWAYS( 0, "IscDriver",EIscPanicSetChannel );

        }

    C_TRACE( ( _T( "IscChannelContainer::SetChannel - return 0x%x" ), error ) );

    return error;    

    }

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

// IscChannelContainer::Channel

// Return pointer to channel

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

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

//

DIscChannel* IscChannelContainer::Channel( 

    const TUint16 aChannel, 

    const TUint16 aChannelSharingIndex )    

    {

    TRACE_ASSERT( aChannel < KIscNumberOfUnits );

    TRACE_ASSERT( aChannelSharingIndex < KIscMaxNumberOfChannelSharers );

    return( iIscChannels[ aChannel ][ aChannelSharingIndex ] );    

    }

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

// IscChannelContainer::RemoveChannel

// 

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

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

//

TInt IscChannelContainer::RemoveChannel

		( 

    	DIscChannel* aChannel

    	)

    {

    TRACE_ASSERT( aChannel );

    C_TRACE( ( _T( "IscChannelContainer::RemoveChannel(0x%x)" ), aChannel ) );

    TUint16 channelNumber = aChannel->GetChannelNumber();

    TInt error( KErrNotFound );

    for ( TInt i( KErrNone ); ( i < KIscMaxNumberOfChannelSharers ) && ( KErrNone != error ); i++ )

        {

        if ( iIscChannels[channelNumber][i] == aChannel )

            {

            iIscChannels[channelNumber][i] = NULL;

            error = KErrNone;

            }

        }

    C_TRACE( ( _T( "IscChannelContainer::RemoveChannel - return %d" ), error ) );

    return error;

    }

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

// IscChannelContainer::ChannelComplition

// Goes through channels and open ones are emptied

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

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

//

void IscChannelContainer::ChannelComplition( 

    TAny* /*a*/ )

    {

    C_TRACE( ( _T( "IscChannelContainer::ChannelComplition()" ) ) );

#ifdef __WINS__

    EnterCriticalSection( &g_IscCriticalSection );

#endif

    DIscChannel* channelPtr = NULL;

    for ( TUint16 channel( KIscFirstChannel ) ; channel < KIscNumberOfUnits; channel++ )

        {

        for ( TUint16 i( 0 ); i < KIscMaxNumberOfChannelSharers; i++ )

            {

            channelPtr = iIscChannels[channel][i];

            if ( channelPtr )

                {

                channelPtr->EmptyBuffers();

                }

            }

        }

#ifdef __WINS__

    LeaveCriticalSection( &g_IscCriticalSection );

#endif

    C_TRACE( ( _T( "IscChannelContainer::ChannelComplition - return 0x%x" ), KErrNone ) );

    }

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

// IscChannelContainer::AddDfc

// Adds ChannelComplition Dfc

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

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

//

void IscChannelContainer::AddDfc()

    {

    C_TRACE( ( _T( "IscChannelContainer::AddDfc()" ) ) );

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

        {

        iDfc->Add();

        }

    else

        {

        iDfc->Enque();

        }    

    }

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

// IscChannelContainer::Initialize

// Allocates Dfc function dynamically and formats data tables.

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

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

//

void IscChannelContainer::Initialize()

    {    

    C_TRACE( ( _T( "IscChannelContainer::Initialize()" ) ) );

    if ( !iDfc )

        {

        iDfc = new TDfc( IscChannelContainer::ChannelComplition, NULL, Kern::DfcQue0(),

                         KChannelComplitionDfcPriority );

        ASSERT_RESET_ALWAYS( iDfc, "IscDriver",EIscMemoryAllocationFailure );

        }

    for ( TUint16 channel( 0 ); channel < KIscNumberOfUnits; channel++ )

        {

        for ( TUint16 i( 0 ); i < KIscMaxNumberOfChannelSharers; i++ )

            {

            iIscChannels[channel][i] = NULL;

            }

        }

#ifdef __WINS__

    InitializeCriticalSection( &g_IscCriticalSection );

#endif

    }

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

// IscChannelContainer::DeActivate

// Deallocates Dfc function

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

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

//

void IscChannelContainer::DeActivate()

    {    

    if ( iDfc )

        {

        delete iDfc;

        iDfc = NULL;

        }

#ifdef __WINS__

    DeleteCriticalSection( &g_IscCriticalSection );

#endif

    }

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

// IscChannelContainer::ValidateChannel

// 

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

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

//

TInt IscChannelContainer::ValidateChannel( 

    DIscChannel* aChannelPtr )

    {

    C_TRACE( ( _T( "IscChannelContainer::ValidateChannel(0x%x)" ), aChannelPtr ) );

    TInt error( KErrNotFound );

    if( !aChannelPtr )

    	{

    	C_TRACE( ( _T( "IscChannelContainer::ValidateChannel aChannelPtr was NULL" ) ) );

    	error = KErrArgument;	

    	}

    else

    	{

	    for ( TUint16 channelNumber( 0 ); channelNumber < KIscNumberOfUnits ; channelNumber++ )

	        {

	        for ( TInt i( KErrNone ); i < KIscMaxNumberOfChannelSharers ; i++ )

	            {

	            if ( iIscChannels[channelNumber][i] == aChannelPtr )

	                {

	                error = KErrNone;

	                break;

	                }

	            }

	        }    		

    	}

    C_TRACE( ( _T( "IscChannelContainer::ValidateChannel - return %d" ), error ) );

    return error;

    }

//  End of File