/*
* Copyright (c) 2006-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:   WlanTimer implementation
*
*/

/*
* %version: 10 %
*/

#include "osa_includeme.h"

#include <wlantimerclient.h>

#include "osatimer.h"
#include "osa.h"

// mask value to check is timer periodic or not
const TUint KPeriodicTimerMask( 1 << 1 );
// mask value to check if timer is running
const TUint KTimerRunningMask( 1 << 2 );


// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
WlanTimer::WlanTimer( WlanOsa& aOsa, void* aDfcQueue )
  : iTimerDfc( WlanTimer::TimerTrigger, this, 0 ),
    iOsa( aOsa ),
    iNTimer( ),
    iTimerClient( NULL ),
    iTimeoutInMicroSeconds( 0 ),
    iCtx( 0 ),
    iFlags( 0 ),
    iRefCnt( 1 )
    {
    TraceDump(INFO_LEVEL | TIMER_LEVEL, ("[WLAN] WlanTimer() ctor +"));

    MWlanOsa::Assert( 
        reinterpret_cast<const TInt8*>(WLAN_FILE), __LINE__,
        aDfcQueue != NULL );

    iTimerDfc.SetDfcQ( reinterpret_cast<TDfcQue*>(aDfcQueue) );
    Validate();

    TraceDump(INFO_LEVEL | TIMER_LEVEL, ("[WLAN] WlanTimer() ctor -"));
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
WlanTimer::~WlanTimer()
    {
    TraceDump(INFO_LEVEL | TIMER_LEVEL, ("[WLAN] WlanTimer() dtor +"));

    if ( iRefCnt != 0 )
        {
        TraceDump(CRIT_LEVEL, (("[WLAN] error: Timer destroyed while "
                                "active - delete used directly?")));
        MWlanOsa::Assert(
            reinterpret_cast<const TInt8*>(WLAN_FILE), __LINE__ );
        }

    TraceDump(INFO_LEVEL | TIMER_LEVEL, ("[WLAN] WlanTimer() dtor -"));
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void WlanTimer::TimerTrigger( TAny* aPtr )
    {
    WlanTimer* timer = reinterpret_cast< WlanTimer* >( aPtr );
    timer->TimerTrigger();
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void WlanTimer::TimerTrigger()
    {
    WlanOsa &osa = iOsa;

    TraceDump(INFO_LEVEL | TIMER_LEVEL, ("[WLAN] WlanTimer::TimerTrigger +"));

    // get hold of the global mutex
    iOsa.MutexAcquire();

    if (iFlags & KTimerRunningMask)
        {
        if ( iFlags & KPeriodicTimerMask )
            {
            // a periodic timer was requested - re-arm the timer for the next
            // run now.
            const TInt ticks(
                NKern::TimerTicks( iTimeoutInMicroSeconds / 1000 ));
            TraceDump(TIMER_LEVEL, (("[WLAN] timer ticks: %d"), ticks));

            // on arming the timer, add a reference to it - the reference
            // shall be cleared upon the completion callback execution.
            RefAdd();
            const TInt ret (iNTimer.Again( ticks ));

            if ( ret != KErrNone )
                {
                TraceDump(CRIT_LEVEL, (("[WLAN] error: ret %d"), ret));
                MWlanOsa::Assert(
                    reinterpret_cast<const TInt8*>(WLAN_FILE), __LINE__ );
                RefDel();
                }
            }
        else
            {
            // clear the timer running mask
            iFlags &= (~KTimerRunningMask);
            }

        TraceDump(TIMER_LEVEL,
            (("[WLAN] current system time: %d"), Kern::SystemTime()));
        TraceDump(TIMER_LEVEL,
            (("[WLAN] timer client address: 0x%08x"), iTimerClient));
        TraceDump(TIMER_LEVEL,
            (("[WLAN] call timer callback with context: %d"), iCtx));

        // execute the timer client call back function
        iTimerClient->OnTimeout( iCtx );
        }

    // a reference was added for this timer instance upon arming of the
    // timer - here, we must remove that reference - and possibly delete
    // the object instance if we were last to hold reference to it.
    // NOTE! here the reference count may become zero (if the
    // TimerDestroy OSA method was called for the instance prior to this
    // handler executing) and hence the instance may be deleted upon this
    // call. do not touch instance data after this call.
    RefDel();

    // release the global mutex - do not use the "iOsa" as the instance
    // may now have been deleted, instead use a local reference.
    osa.MutexRelease();

    TraceDump(INFO_LEVEL | TIMER_LEVEL, ("[WLAN] WlanTimer::TimerTrigger -"));
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void WlanTimer::Enqueue(
    MWlanTimerClient& aTimerClient,
    TInt aCtx,
    TInt aTimeoutInMicroSeconds,
    TBool aPeriodic )
    {

    if ( iFlags & KTimerRunningMask )
        {
        // ignore the call if the timer is already running
        TraceDump(INFO_LEVEL | TIMER_LEVEL,
            (("[WLAN] WlanTimer::Enqueue: + addr: 0x%08x: "
              "Timer already enqueued, no effect."), this));
        }
    else
        {
        TraceDump(INFO_LEVEL | TIMER_LEVEL,
            (("[WLAN] WlanTimer::Enqueue: + addr: 0x%08x"), this));
        TraceDump(TIMER_LEVEL,
            (("[WLAN] timeout in microseconds: %d"), aTimeoutInMicroSeconds));
        TraceDump(TIMER_LEVEL, (("[WLAN] periodic: %d"), aPeriodic));

        // store timer parameters
        iFlags = KTimerRunningMask;
        iTimerClient = &aTimerClient;
        iCtx = aCtx;

        if ( aPeriodic )
            {
            iFlags |= KPeriodicTimerMask;
            }

        const TInt KMinTimeout = 1000;

        // the timeout minimum is 1000 us
        if (aTimeoutInMicroSeconds < KMinTimeout)
            {
              iTimeoutInMicroSeconds = KMinTimeout;
            }
        else
            {
            // adding 999 here will allow the us timeout to be rounded
            // up to the next full ms, guaranteeing at least the timeout
            // requested, no less.
            iTimeoutInMicroSeconds = aTimeoutInMicroSeconds + 999;
            }

        // arm the timer (using ms instead of us for the unit)
        const TInt ticks( NKern::TimerTicks( iTimeoutInMicroSeconds / 1000 ));

        TraceDump(TIMER_LEVEL, (("[WLAN] timeout in ticks: %d"), ticks));
        TraceDump(TIMER_LEVEL,
            (("[WLAN] current system time: %d"), Kern::SystemTime()));

        // add reference to the timer instance - this reference will be
        // removed once the timeout event has been handled
        RefAdd();
        const TInt ret( iNTimer.OneShot( ticks, iTimerDfc ));

        if ( ret != KErrNone )
            {
            TraceDump(CRIT_LEVEL, (("[WLAN] error: ret %d"), ret));
            MWlanOsa::Assert(
                reinterpret_cast<const TInt8*>(WLAN_FILE), __LINE__ );
            RefDel();
            }
        }

    TraceDump(INFO_LEVEL | TIMER_LEVEL,
        (("[WLAN] WlanTimer::Enqueue: - addr: 0x%08x: "), this));
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void WlanTimer::Dequeue()
    {
    TraceDump(INFO_LEVEL | TIMER_LEVEL,
        (("[WLAN] WlanTimer::Dequeue: + addr: 0x%08x"), this));

    if ( iFlags & KTimerRunningMask )
        {
        iFlags = 0;

        if ( iNTimer.Cancel())
            {
            // if cancellation of the timer succeeds, remove a reference from
            // the timer instance - as this will not be done in the timeout
            // handler now. NOTE! that here the reference count should never
            // reach zero (instance exists + the timer is running == 2)
            RefDel();

            }
        // if the cancellation of the timer failed above, the DFC is most
        // likely already executing - attempting to cancel it here would
        // be wasting of clock cycles.
        //
        // the most common scenario is that the timer cancel succeeds. for
        // the rare cases of a failure, we just let the DFC execute, and
        // do nothing (the flags are cleared.)
        }
    else
        {
        TraceDump(INFO_LEVEL | TIMER_LEVEL,
             (("[WLAN] WlanTimer::Dequeue: Timer is not running.")));
        }

    TraceDump(INFO_LEVEL | TIMER_LEVEL,
        (("[WLAN] WlanTimer::Dequeue: - addr: 0x%08x"), this));
    }


// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void WlanTimer::RefDel(void)
    {
    // decrement the reference counter
    iRefCnt --;

    if (iRefCnt == 0)
        {
        // referees have reached zero, the object is abandoned, and
        // shall be deleted
        WlanTimer *timer = this;
        delete timer;
        }
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void WlanTimer::RefAdd(void)
    {
    // increment the reference counter
    iRefCnt ++;
    }