/*

* 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:  Handles sending management commands to drivers.

*

*/

/*

*/

// INCLUDES

#include <e32std.h>

#include <es_ini.h>

#include <es_mbuf.h>

#include "wlanmgmtcommandhandler.h"

#include "am_debug.h"

// ============================= LOCAL FUNCTIONS ===============================

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

// os_memcpy

// (Declared in 802dot11.h)

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

//

TAny* os_memcpy( 

    TAny* aDest, 

    const TAny* aSrc, 

    TUint32 aLengthinBytes )

    {

    Mem::Copy( aDest, aSrc, aLengthinBytes );

    return aDest;

    }

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

// C++ default constructor can NOT contain any code, that

// might leave.

//

CWlanMgmtCommandHandler::CWlanMgmtCommandHandler(

    RWlanLogicalChannel& aChannel,

    MWlanMgmtCommandCallback& aClient ):

    CActive( CActive::EPriorityStandard ),

    iClient( aClient ),

    iChannel( aChannel ),

    iBuffer( NULL, 0, 0 )

    {

    }

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

// CWlanMgmtCommandHandler::NewL

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

//

CWlanMgmtCommandHandler* CWlanMgmtCommandHandler::NewL(

    RWlanLogicalChannel& aChannel,

    MWlanMgmtCommandCallback& aClient )

    {

    DEBUG( "CWlanMgmtCommandHandler::NewL()" );

    CWlanMgmtCommandHandler* self = 

        new(ELeave) CWlanMgmtCommandHandler( aChannel, aClient );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CWlanMgmtCommandHandler::ConstructL

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

//

void CWlanMgmtCommandHandler::ConstructL()

    {

    DEBUG( "CWlanMgmtFrameHandler::ConstructL()" );

    CActiveScheduler::Add( this );

    }

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

// CWlanMgmtCommandHandler::~CWlanMgmtCommandHandler

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

//

CWlanMgmtCommandHandler::~CWlanMgmtCommandHandler()

    {

    DEBUG( "CWlanMgmtCommandHandler::~CWlanMgmtCommandHandler()" );

    }

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

// CWlanMgmtCommandHandler::StartIBSS

// Start a IBSS network.

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

//

void CWlanMgmtCommandHandler::StartIBSS(

    const TSSID& aSSID,

    TUint32 aBeaconInterval,

    TUint32 aChannel,

    TEncryptionStatus aEncryptionStatus )

    {

    DEBUG( "CWlanMgmtCommandHandler::StartIBSS()" );

    // First, start the adhoc network synchronously

    TStartIBSSMsg msg;

    msg.hdr.oid_id = E802_11_START_IBSS;

    msg.SSID = aSSID;

    msg.beaconInterval = aBeaconInterval;

    msg.ATIM = 0; // DEPRECATED, NOT USED ANY MORE

    msg.channel = aChannel;

    msg.encryptionStatus = aEncryptionStatus;

    TPckg<TStartIBSSMsg> buf( msg );

    TInt err = iChannel.ManagementCommand( buf, NULL, &iStatus );

    if( err )

        {

        DEBUG1( "ERROR calling RWlanLogicalChannel::ManagementCommand(): %d", err );

        TRequestStatus* status = &iStatus;

        User::RequestComplete( status, err );

        SetActive();

        return;

        }

    SetActive();

    }

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

// CWlanMgmtCommandHandler::Scan

// Receive information about surrounding WLAN networks.

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

//

void CWlanMgmtCommandHandler::Scan(

    TScanMode aMode,

    const TSSID& aSSID,

    TRate aScanRate,

    const SChannels& aChannels,

    TUint32 aMinChannelTime, 

    TUint32 aMaxChannelTime,

    TBool aIsSplitScan )

    {

    DEBUG( "CWlanMgmtCommandHandler::Scan()" );

    TScanMsg msg;

    msg.hdr.oid_id = E802_11_SCAN;

    msg.mode = aMode;

    msg.SSID = aSSID;

    msg.scanRate = aScanRate;

    msg.channels = aChannels;    

    DEBUG1( "CWlanMgmtCommandHandler::Scan() - aMinChannelTime %u",

        aMinChannelTime );

    DEBUG1( "CWlanMgmtCommandHandler::Scan() - aMaxChannelTime %u",

        aMaxChannelTime );

    DEBUG1( "CWlanMgmtCommandHandler::Scan() - aIsSplitScan %u",

        aIsSplitScan );

    msg.minChannelTime = aMinChannelTime;

    msg.maxChannelTime = aMaxChannelTime;

    msg.splitScan = aIsSplitScan; 

    TPckg<TScanMsg> buf( msg );

    TInt err = iChannel.ManagementCommand( buf, NULL, &iStatus );

    if( err )

        {

        DEBUG1( "ERROR calling RWlanLogicalChannel::ManagementCommand(): %d", err );

        TRequestStatus* status = &iStatus;

        User::RequestComplete( status, err );

        SetActive();

        return;

        }

    SetActive();

    }

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

// CWlanMgmtCommandHandler::StopScan

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

//

void CWlanMgmtCommandHandler::StopScan()

    {

    DEBUG( "CWlanMgmtCommandHandler::StopScan()" );

    TStopScanMsg msg;

    msg.hdr.oid_id = E802_11_STOP_SCAN;

    TPckg<TStopScanMsg> buf( msg );

    TInt err = iChannel.ManagementCommand( buf, NULL, &iStatus );

    if( err )

        {

        DEBUG1( "ERROR calling RWlanLogicalChannel::ManagementCommand(): %d", err );

        TRequestStatus* status = &iStatus;

        User::RequestComplete( status, err );

        }

    SetActive();

    }

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

// CWlanMgmtCommandHandler::Disconnect

// Disconnect from the WLAN.

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

//

void CWlanMgmtCommandHandler::Disconnect()

    {

    DEBUG( "CWlanMgmtCommandHandler::Disconnect()" );

    TDisconnectMsg msg;

    msg.hdr.oid_id = E802_11_DISCONNECT;

    TPckg<TDisconnectMsg> buf( msg );

    TInt err = iChannel.ManagementCommand( buf, NULL, &iStatus );

    if( err )

        {

        DEBUG1( "ERROR calling RWlanLogicalChannel::ManagementCommand(): %d", err );

        TRequestStatus* status = &iStatus;

        User::RequestComplete( status, err );

        }

    SetActive();

    }

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

// CWlanMgmtCommandHandler::SetPowerMode

// Adjust current WLAN power mode.

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

//

void CWlanMgmtCommandHandler::SetPowerMode(

    TPowerMode aMode,

    TBool aDisableDynamicPs,

    TWlanWakeUpInterval aWakeUpModeLight,

    TUint8 aListenIntervalLight,

    TWlanWakeUpInterval aWakeUpModeDeep,

    TUint8 aListenIntervalDeep )

    {

    DEBUG( "CWlanMgmtCommandHandler::SetPowerMode()" );

    DEBUG1( "CWlanMgmtCommandHandler::SetPowerMode() - aMode = %u ",

        aMode );

    DEBUG1( "CWlanMgmtCommandHandler::SetPowerMode() - aDisableDynamicPs = %u ",

        aDisableDynamicPs );

    DEBUG1( "CWlanMgmtCommandHandler::SetPowerMode() - aWakeUpModeLight = %u ",

        aWakeUpModeLight );

    DEBUG1( "CWlanMgmtCommandHandler::SetPowerMode() - aListenIntervalLight = %u ",

        aListenIntervalLight );

    DEBUG1( "CWlanMgmtCommandHandler::SetPowerMode() - aWakeUpModeDeep = %u ",

        aWakeUpModeDeep );

    DEBUG1( "CWlanMgmtCommandHandler::SetPowerMode() - aListenIntervalDeep = %u ",

        aListenIntervalDeep );

    TSetPowerModeMsg msg;

    msg.hdr.oid_id = E802_11_SET_POWER_MODE;

    msg.powerMode = aMode;

    msg.disableDynamicPowerModeManagement = aDisableDynamicPs;

    msg.wakeupModeInLightPs = aWakeUpModeLight;

    msg.listenIntervalInLightPs = aListenIntervalLight;

    msg.wakeupModeInDeepPs = aWakeUpModeDeep;

    msg.listenIntervalInDeepPs = aListenIntervalDeep; 

    TPckg<TSetPowerModeMsg> buf( msg );

    TInt err = iChannel.ManagementCommand( buf, NULL, &iStatus );

    if( err )

        {

        DEBUG1( "ERROR calling RWlanLogicalChannel::ManagementCommand(): %d", err );

        TRequestStatus* status = &iStatus;

        User::RequestComplete( status, err );

        }

    SetActive();        

    }

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

// CWlanMgmtCommandHandler::SetRCPITriggerLevel

// Set RSSI trigger.

// When signal level of the current connection goes below

// this trigger an event is sent by WLAN drivers.

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

//

void CWlanMgmtCommandHandler::SetRCPITriggerLevel( TUint32 aRCPITrigger )

    {

    DEBUG( "CWlanMgmtCommandHandler::SetRCPITriggerLevel()" );

    TSetRcpiTriggerLevelMsg msg;

    msg.hdr.oid_id = E802_11_SET_RCPI_TRIGGER_LEVEL;

    msg.RcpiTrigger = aRCPITrigger;

    TPckg<TSetRcpiTriggerLevelMsg> buf( msg );

    TInt err = iChannel.ManagementCommand( buf, NULL, &iStatus );

    if( err )

        {

        DEBUG1( "ERROR calling RWlanLogicalChannel::ManagementCommand(): %d", err );

        TRequestStatus* status = &iStatus;

        User::RequestComplete( status, err );

        }

    SetActive();        

    }

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

// CWlanMgmtCommandHandler::SetTxPowerLevel

// Set WLAN TX power level.

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

//

void CWlanMgmtCommandHandler::SetTxPowerLevel( TUint32 aLevel )

    {

    DEBUG( "CWlanMgmtCommandHandler::SetTxPowerLevel()" );

    TSetTxPowerLevelMsg msg;

    msg.hdr.oid_id = E802_11_SET_TX_POWER_LEVEL;

    msg.level = aLevel;

    TPckg<TSetTxPowerLevelMsg> buf( msg );

    TInt err = iChannel.ManagementCommand( buf, NULL, &iStatus );

    if( err )

        {

        DEBUG1( "ERROR calling RWlanLogicalChannel::ManagementCommand(): %d", err );

        TRequestStatus* status = &iStatus;

        User::RequestComplete( status, err );

        }

    SetActive();        

    }

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

// CWlanMgmtCommandHandler::Configure

// Configure WLAN chip.

// This has to been done before the WLAN even scans.

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

//

void CWlanMgmtCommandHandler::Configure( 

    TUint16 aRTSThreshold,

    TUint32 aMaxTxMSDULifetime,

    TUint32 aQoSNullFrameEntryTimeout,

    TUint32 aQosNullFrameEntryTxCount,

    TUint32 aQoSNullFrameInterval,

    TUint32 aQoSNullFrameExitTimeout,

    TUint32 aKeepAliveInterval,

    TUint32 aSpRcpiTarget,

    TUint32 aSpTimeTarget,

    TUint32 aSpMinIndicationInterval )

    {

    DEBUG( "CWlanMgmtCommandHandler::Configure()" );

    DEBUG1( "CWlanMgmtCommandHandler::Configure() - aRTSThreshold = %u",

        aRTSThreshold );

    DEBUG1( "CWlanMgmtCommandHandler::Configure() - aMaxTxMSDULifetime = %u",

        aMaxTxMSDULifetime );

    DEBUG1( "CWlanMgmtCommandHandler::Configure() - aQoSNullFrameEntryTimeout = %u",

        aQoSNullFrameEntryTimeout );

    DEBUG1( "CWlanMgmtCommandHandler::Configure() - aQosNullFrameEntryTxCount = %u",

        aQosNullFrameEntryTxCount );

    DEBUG1( "CWlanMgmtCommandHandler::Configure() - aQoSNullFrameInterval = %u",

        aQoSNullFrameInterval );

    DEBUG1( "CWlanMgmtCommandHandler::Configure() - aQoSNullFrameExitTimeout = %u",

        aQoSNullFrameExitTimeout );

    DEBUG1( "CWlanMgmtCommandHandler::Configure() - aKeepAliveInterval = %u",

        aKeepAliveInterval );

    DEBUG1( "CWlanMgmtCommandHandler::Configure() - aSpRcpiTarget = %u",

        aSpRcpiTarget );

    DEBUG1( "CWlanMgmtCommandHandler::Configure() - aSpTimeTarget = %u",

        aSpTimeTarget );

    DEBUG1( "CWlanMgmtCommandHandler::Configure() - aSpMinIndicationInterval = %u",

        aSpMinIndicationInterval );

    TConfigureMsg msg;

    msg.hdr.oid_id = E802_11_CONFIGURE;

    msg.RTSThreshold = aRTSThreshold;

    msg.maxTxMSDULifetime = aMaxTxMSDULifetime;

    msg.voiceCallEntryTimeout = aQoSNullFrameEntryTimeout;

    msg.voiceCallEntryTxThreshold = aQosNullFrameEntryTxCount;

    msg.voiceNullTimeout = aQoSNullFrameInterval;

    msg.noVoiceTimeout = aQoSNullFrameExitTimeout;

    msg.keepAliveTimeout = aKeepAliveInterval;

    msg.spRcpiIndicationLevel = aSpRcpiTarget;

    msg.spTimeToCountPrediction = aSpTimeTarget;

    msg.spMinIndicationInterval = aSpMinIndicationInterval;

    TPckg<TConfigureMsg> buf( msg );

    TInt err = iChannel.ManagementCommand( buf, NULL, &iStatus );

    if( err )

        {

        DEBUG1( "ERROR calling RWlanLogicalChannel::ManagementCommand(): %d", err );

        TRequestStatus* status = &iStatus;

        User::RequestComplete( status, err );

        }

    SetActive();

    }

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

// CWlanMgmtCommandHandler::GetLastRCPI

// Get the signal quality of the last received packet.

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

//

void CWlanMgmtCommandHandler::GetLastRCPI( TUint32& aRCPI )

    {

    DEBUG( "CWlanMgmtCommandHandler::GetLastRCPI()" );

    TGetLastRcpiMsg msg;

    msg.hdr.oid_id = E802_11_GET_LAST_RCPI;

    TPckg<TGetLastRcpiMsg> outbuf( msg );

    TPckg<TUint32> inbuf( aRCPI );

    iBuffer.Set( inbuf );

    TInt err = iChannel.ManagementCommand( outbuf, &iBuffer, &iStatus );

    if( err )

        {

        DEBUG1( "ERROR calling RWlanLogicalChannel::ManagementCommand(): %d", err );

        TRequestStatus* status = &iStatus;

        User::RequestComplete( status, err );

        }

    SetActive();

    }

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

// CWlanMgmtCommandHandler::ConfigureMulticastGroup

// Get the signal quality of the last received packet.

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

//

void CWlanMgmtCommandHandler::ConfigureMulticastGroup( 

    TBool aJoinGroup,

    const TMacAddress& aMulticastAddr )

    {

    DEBUG( "CWlanMgmtCommandHandler::ConfigureMulticastGroup()" );

    TInt err = KErrNone;

    if( aJoinGroup )

        {

        TAddMulticastAddrMsg msg;

        msg.hdr.oid_id = E802_11_ADD_MULTICAST_ADDR;

        msg.macAddress = aMulticastAddr;

        TPckg<TAddMulticastAddrMsg> outbuf( msg );

        err = iChannel.ManagementCommand( outbuf, NULL, &iStatus );

        }

    else

        {

        TRemoveMulticastAddrMsg msg;

        msg.hdr.oid_id = E802_11_REMOVE_MULTICAST_ADDR;

        msg.macAddress = aMulticastAddr;

        msg.removeAll = EFalse;

        TPckg<TRemoveMulticastAddrMsg> outbuf( msg );

        err = iChannel.ManagementCommand( outbuf, NULL, &iStatus );

        }

    if( err )

        {

        DEBUG1( "ERROR calling RWlanLogicalChannel::ManagementCommand(): %d", err );

        TRequestStatus* status = &iStatus;

        User::RequestComplete( status, err );

        }

    SetActive();

    }

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

// CWlanMgmtCommandHandler::SetBssLostParameters

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

//    

void CWlanMgmtCommandHandler::SetBssLostParameters(

    TUint32 aBssLostCount,

    TUint8 aFailedTxCount )

    {

    DEBUG( "CWlanMgmtCommandHandler::SetBssLostParameters()" );

    TConfigureBssLostMsg msg;

    msg.hdr.oid_id = E802_11_CONFIGURE_BSS_LOST;

    msg.beaconLostCount = aBssLostCount;

    msg.failedTxPacketCount = aFailedTxCount;

    TPckg<TConfigureBssLostMsg> buf( msg );

    TInt err = iChannel.ManagementCommand( buf, NULL, &iStatus );

    if( err )

        {

        DEBUG1( "ERROR calling RWlanLogicalChannel::ManagementCommand(): %d", err );

        TRequestStatus* status = &iStatus;

        User::RequestComplete( status, err );

        }

    SetActive();    

    }

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

// CWlanMgmtCommandHandler::SetTxRateAdaptationParameters

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

// 

void CWlanMgmtCommandHandler::SetTxRateAdaptationParameters(

    TUint8 aMinStepUpCheckpoint,

    TUint8 aMaxStepUpCheckpoint,

    TUint8 aStepUpCheckpointFactor,

    TUint8 aStepDownCheckpoint,

    TUint8 aMinStepUpThreshold,

    TUint8 aMaxStepUpThreshold,

    TUint8 aStepUpThresholdIncrement,

    TUint8 aStepDownThreshold,

    TBool aDisableProbeHandling )

    {

    DEBUG( "CWlanMgmtCommandHandler::SetTxRateAdaptationParameters()" );

    TSetTxRateAdaptationParamsMsg msg;

    msg.hdr.oid_id = E802_11_SET_TX_RATE_ADAPT_PARAMS;

    msg.minStepUpCheckpoint = aMinStepUpCheckpoint;

    msg.maxStepUpCheckpoint = aMaxStepUpCheckpoint;

    msg.stepUpCheckpointFactor = aStepUpCheckpointFactor;

    msg.stepDownCheckpoint = aStepDownCheckpoint;

    msg.minStepUpThreshold = aMinStepUpThreshold;

    msg.maxStepUpThreshold = aMaxStepUpThreshold;

    msg.stepUpThresholdIncrement = aStepUpThresholdIncrement;

    msg.stepDownThreshold = aStepDownThreshold;

    msg.disableProbeHandling = aDisableProbeHandling;

    TPckg<TSetTxRateAdaptationParamsMsg> buf( msg );

    TInt err = iChannel.ManagementCommand( buf, NULL, &iStatus );

    if( err )

        {

        DEBUG1( "ERROR calling RWlanLogicalChannel::ManagementCommand(): %d", err );

        TRequestStatus* status = &iStatus;

        User::RequestComplete( status, err );

        }

    SetActive();    

    }

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

// CWlanMgmtCommandHandler::SetPowerModeMgmtParameters

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

//    

void CWlanMgmtCommandHandler::SetPowerModeMgmtParameters(

    TUint32 aActiveToLightTimeout,

    TUint16 aActiveToLightThreshold,

    TUint32 aLightToActiveTimeout,

    TUint16 aLightToActiveThreshold,

    TUint32 aLightToDeepTimeout,

    TUint16 aLightToDeepThreshold,

    TUint16 aUapsdRxFrameLengthThreshold )