/*

* Copyright (c) 2002-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:  Interface to drivers

*

*/

#include <wlanhwinit.h>

#include "wlanlddcommon.h"

#include "am_debug.h"

#include "wlmdriverif.h"

#include "wlanmgmtcommandhandler.h"

#include "wlanmgmtframehandler.h"

#include "wlannotificationhandler.h"

#include "wlanconversionutil.h"

#include "abs_core_driverif_callback.h"

#define PDD_FILE_NAME _L("wlanpdd")

#define PDD_NAME _L("wlan.phys")

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

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

// CWlmDriverIf::CWlmDriverIf

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

// might leave.

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

//

CWlmDriverIf::CWlmDriverIf() :

    iCoreServer( NULL ),

    iPendingRequestId( 0 ),

    iNotificationHandler( NULL ),

    iManagementCommandHandler( NULL ),

    iManagementFrameHandler( NULL ),

    iAsynchCallback( NULL ),

    iErrorStatus( core_error_ok ),

    iHwInit( NULL ),

    iIsPDDLoaded( EFalse ),

    iIsLDDLoaded( EFalse ),

    iManagementStatus( NULL )

    {

    DEBUG( "CWlmDriverIf::CWlmDriverIf()" );

    }

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

// CWlmDriverIf::NewL

// Two-phased constructor.

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

//

CWlmDriverIf* CWlmDriverIf::NewL()

    {

    DEBUG( "CWlmDriverIf::NewL()" );

    CWlmDriverIf* self = new(ELeave) CWlmDriverIf();    

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CWlmDriverIf::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CWlmDriverIf::ConstructL()

    {

    DEBUG( "CWlmDriverIf::ConstructL()" );

    // Instantiate handlers

    iManagementCommandHandler = CWlanMgmtCommandHandler::NewL( iChannel, *this );

    iManagementFrameHandler = CWlanMgmtFrameHandler::NewL( iChannel, *this );

    iNotificationHandler = CWlanNotificationHandler::NewL( iChannel, *this );

    // Instantiate asynch callback provider

    // (mainly for error situations)

    TCallBack callback( AsynchCallbackFunction, this );

    iAsynchCallback = new(ELeave) CAsyncCallBack(

            callback, CActive::EPriorityStandard );

    iHwInit = CWlanHwInit::NewL();

    }

// Destructor

CWlmDriverIf::~CWlmDriverIf()

    {

    DEBUG( "CWlmDriverIf::~CWlmDriverIf()" );

    delete iAsynchCallback;

    delete iHwInit;

    delete iManagementCommandHandler;

    delete iManagementFrameHandler;

    delete iNotificationHandler;

    iCoreServer = NULL;

    iManagementStatus = NULL;

    }

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

// CWlmDriverIf::init

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

//

void CWlmDriverIf::init(

    abs_core_driverif_callback_c* core_callback )

    {

    iCoreServer = core_callback;

    }

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

// CWlmDriverIf::load_drivers

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

//

void CWlmDriverIf::load_drivers(

    u32_t request_id,

    uint_t rts_threshold,

    u32_t max_tx_msdu_lifetime,

    u32_t qos_null_frame_entry_timeout,

    u32_t qos_null_frame_entry_tx_count,

    u32_t qos_null_frame_interval,

    u32_t qos_null_frame_exit_timeout,

    u32_t keep_alive_interval,

    u32_t sp_rcpi_target,

    u32_t sp_time_target,

    u32_t sp_min_indication_interval )

    {

    DEBUG( "CWlmDriverIf::load_drivers()" );

    // Set request id and ensure no prior requests are pending

    if( SetRequestId( request_id ) )

        {

        ASSERT( false_t );

        return;

        }

    // Buffer for initialization data    

    const TUint8* pdaData = NULL;

    TUint pdaDataLength( 0 );

    // Buffer for firmware data

    const TUint8* fwData = NULL;

    TUint fwDataLength( 0 );

    // Get the data from CMT

    iHwInit->GetHwInitData( &pdaData, pdaDataLength, &fwData, fwDataLength );

    // Load physical device

    DEBUG( "- loading PDD" );

    TInt err = KErrNone;

    err = User::LoadPhysicalDevice( PDD_FILE_NAME );

    if( ( err != KErrNone ) && ( err != KErrAlreadyExists ) )

        {

        DEBUG1("ERROR: PDD loading failed with %d", err );

        UnloadDrivers();

        iErrorStatus = core_error_drivers_not_loaded;

        iAsynchCallback->CallBack();

        return;

        }

    iIsPDDLoaded = ETrue;

    // Load logical device

    DEBUG( "- loading LDD" );

    err = User::LoadLogicalDevice( LDD_FILE_NAME );

    if( ( err != KErrNone ) && ( err != KErrAlreadyExists ) )

        {

        DEBUG1("ERROR: LDD loading failed with %d", err );

        UnloadDrivers();

        iErrorStatus = core_error_drivers_not_loaded;

        iAsynchCallback->CallBack();

        return;

        }

    iIsLDDLoaded = ETrue;

    // Open logical channel

    DEBUG( "- Open logical channel" );

    TOpenParam openParam;

    openParam.iPda = const_cast<TUint8*>( pdaData );

    openParam.iPdaLength = pdaDataLength;

    openParam.iFirmWare = const_cast<TUint8*>( fwData );

    openParam.iFirmWareLength = fwDataLength;

    err = iChannel.Open( KUnitWlan, openParam );

    if( err )

        {

        DEBUG1("ERROR: Opening channel failed with %d", err );

        UnloadDrivers();

        iErrorStatus = core_error_drivers_not_loaded;

        iAsynchCallback->CallBack();

        return;

        }

    // Activate handlers

    DEBUG( "- Activate handlers" );

    if( iNotificationHandler->IsActive() ||

        iNotificationHandler->Start() )

        {

        DEBUG("ERROR starting notification handler");

        UnloadDrivers();

        iErrorStatus = core_error_drivers_not_loaded;

        iAsynchCallback->CallBack();

        return;

        }

    if( iManagementFrameHandler->IsActive() ||

        iManagementFrameHandler->Start() )

        {

        DEBUG("ERROR starting management frame handler");

        UnloadDrivers();

        iErrorStatus = core_error_drivers_not_loaded;

        iAsynchCallback->CallBack();

        return;

        }

    // Configure drivers

    iManagementCommandHandler->Configure(

        static_cast<u16_t>( rts_threshold ),

        max_tx_msdu_lifetime,

        qos_null_frame_entry_timeout,

        qos_null_frame_entry_tx_count,

        qos_null_frame_interval,

        qos_null_frame_exit_timeout,

        keep_alive_interval,

        sp_rcpi_target,

        sp_time_target,

        sp_min_indication_interval );

    }

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

// CWlmDriverIf::unload_drivers

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

//

void CWlmDriverIf::unload_drivers( u32_t request_id )

    {

    DEBUG( "CWlmDriverIf::unload_drivers()" );

    // Set request id and ensure no prior requests are pending

    if( SetRequestId( request_id ) )

        {

        ASSERT( false_t );

        return;

        }

    // Unloading is actually asynchronous

    UnloadDrivers();

    // Order a callback

    iErrorStatus = core_error_ok;

    iAsynchCallback->CallBack();

    }

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

// CWlmDriverIf::UnloadDrivers

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

//

void CWlmDriverIf::UnloadDrivers()

    {

    DEBUG( "CWlmDriverIf::UnloadDrivers()" );

    // Cancel notification and management frame observations

    if( iNotificationHandler->IsActive() )

        {

        DEBUG( "- cancelling iNotificationHandler" );

        iNotificationHandler->Stop();

        }

    if( iManagementFrameHandler->IsActive() )

        {

        DEBUG( "- cancelling iManagementFrameHandler" );

        iManagementFrameHandler->Stop();

        }

    TInt err( KErrNone );

    if( iIsLDDLoaded )

        {

        DEBUG( "- closing logical channel" );

        iChannel.CloseChannel();

        err = User::FreeLogicalDevice( LDD_NAME );

        iIsLDDLoaded = EFalse;

        if ( err != KErrNone )

            {

            DEBUG1( "ERROR: FreeLogicalDevice() failed with %d", err );

            }

        }

    if( iIsPDDLoaded )

        {

        err = User::FreePhysicalDevice( PDD_NAME );

        iIsPDDLoaded = EFalse;

        if ( err != KErrNone )

            {

            DEBUG1( "ERROR: FreePhysicalDevice() failed with %d", err );

            }

        }

    DEBUG( "- UnloadDrivers DONE" );

    }

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

// CWlmDriverIf::start_ibss

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

//

void CWlmDriverIf::start_ibss(

    u32_t request_id,

    const core_ssid_s& ssid,

    u32_t beacon_interval,

    u32_t channel,

    core_encryption_mode_e encrypt_level )

    {

    DEBUG( "CWlmDriverIf::start_ibss()" );

    // Set request id and ensure no prior requests are pending

    if( SetRequestId( request_id ) )

        {

        ASSERT( false_t );

        return;

        }

    TSSID id;

    TWlanConversionUtil::ConvertSSID( id, ssid );

    iManagementCommandHandler->StartIBSS(

            id,

            beacon_interval,

            channel,

            TWlanConversionUtil::ConvertEncryptionMode( encrypt_level ) );

    }

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

// CWlmDriverIf::scan

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

//   

void CWlmDriverIf::scan(

    u32_t request_id,

    core_scan_mode_e scan_mode,

    const core_ssid_s& scan_ssid,

    int_t scan_rate,

    const core_scan_channels_s& scan_channels,

    u32_t scan_min_ch_time,

    u32_t scan_max_ch_time,

    bool_t is_split_scan )

    {

    DEBUG( "CWlmDriverIf::scan()" );

    // Set request id and ensure no prior requests are pending

    if( SetRequestId( request_id ) )

        {

        ASSERT( false_t );

        return;

        }

    // Convert needed parameters

    TSSID id;

    TWlanConversionUtil::ConvertSSID( id, scan_ssid );

    TScanMode scanmode = TWlanConversionUtil::ConvertScanMode( scan_mode );

    TRate rate = TWlanConversionUtil::ConvertScanRate( scan_rate );

    SChannels channels;

    TWlanConversionUtil::ConvertScanChannels( channels, scan_channels );

    // Send command to commandhandler

    iManagementCommandHandler->Scan(

        scanmode,

        id,

        rate,

        channels,

        scan_min_ch_time,

        scan_max_ch_time,

        is_split_scan );

    }

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

// CWlmDriverIf::stop_scan

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

//

void CWlmDriverIf::stop_scan(

    u32_t request_id )

    {

    DEBUG( "CWlmDriverIf::stop_scan()" );

    // Set request id and ensure no prior requests are pending

    if( SetRequestId( request_id ) )

        {

        ASSERT( false_t );

        return;

        }

    // Send command to commandhandler

    iManagementCommandHandler->StopScan();

    }

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

// CWlmDriverIf::disconnect

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

//     

void CWlmDriverIf::disconnect( u32_t request_id )

    {

    DEBUG( "CWlmDriverIf::disconnect()" );

    // Set request id and ensure no prior requests are pending

    if( SetRequestId( request_id ) )

        {

        ASSERT( false_t );

        return;

        }

    iManagementCommandHandler->Disconnect();

    }

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

// CWlmDriverIf::set_power_mode

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

//    

void CWlmDriverIf::set_power_mode(

    u32_t request_id,

    const core_power_mode_s& mode )

    {

    DEBUG( "CWlmDriverIf::set_power_mode()" );

    // Set request id and ensure no prior requests are pending

    if( SetRequestId( request_id ) )

        {

        ASSERT( false_t );

        return;

        }

    TPowerMode amMode( EPowerModeCam );

    TWlanWakeUpInterval amWakeUpModeLight( EWakeUpIntervalAllBeacons );

    TUint8 amWakeUpIntervalLight( 0 );

    TWlanWakeUpInterval amWakeUpModeDeep( EWakeUpIntervalAllDtims );

    TUint8 amWakeUpIntervalDeep( 0 );

    amMode = TWlanConversionUtil::ConvertPowerMode(

        mode.mode );    

    TWlanConversionUtil::ConvertWakeUpInterval(

        amWakeUpModeLight,

        amWakeUpIntervalLight,

        mode.wakeup_mode_light,

        mode.wakeup_interval_light );

    TWlanConversionUtil::ConvertWakeUpInterval(

        amWakeUpModeDeep,

        amWakeUpIntervalDeep,

        mode.wakeup_mode_deep,

        mode.wakeup_interval_deep );

    iManagementCommandHandler->SetPowerMode(

        amMode,

        mode.disable_dynamic_ps,

        amWakeUpModeLight,

        amWakeUpIntervalLight,

        amWakeUpModeDeep,

        amWakeUpIntervalDeep );

    }

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

// CWlmDriverIf::set_tx_power_level

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

//

void CWlmDriverIf::set_tx_power_level(

    u32_t request_id,

    u32_t tx_level )

    {

    DEBUG( "CWlmDriverIf::set_tx_power_level()" );

    // Set request id and ensure no prior requests are pending

    if( SetRequestId( request_id ) )

        {

        ASSERT( false_t );

        return;

        }

    // Send command to commandhandler

    iManagementCommandHandler->SetTxPowerLevel( tx_level ); 

    }

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

// CWlmDriverIf::add_cipher_key

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

//

void CWlmDriverIf::add_cipher_key(

    core_cipher_key_type_e cipher_suite,

    u8_t key_index,

    u16_t key_length,

    const u8_t* key_data,

    const core_mac_address_s& mac,

    bool_t use_as_default )

    {

    DEBUG( "CWlmDriverIf::add_cipher_key()" );

    TMacAddress macAddr;

    TWlanConversionUtil::ConvertMacAddress( macAddr, mac );

    iManagementCommandHandler->AddCipherKey(

        TWlanConversionUtil::ConvertCipherKeyType( cipher_suite ),

        key_index,                             // no conversion needed

        static_cast<TUint32>( key_length ),    // u16_t -> TUint32

        key_data,                              // no conversion needed

        macAddr,

        use_as_default );

    }

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

// CWlmDriverIf::get_current_rcpi

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

//

void CWlmDriverIf::get_current_rcpi(

    u32_t request_id,

    u32_t& rcpi )

    {

    // Set request id and ensure no prior requests are pending

    if( SetRequestId( request_id ) )

        {

        ASSERT( false_t );

        return;

        }

    DEBUG( "CWlmDriverIf::get_last_rcpi()" );

    iManagementCommandHandler->GetLastRCPI(

        rcpi ); // no conversion needed 

    }

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

// CWlmDriverIf::configure_multicast_group

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

//

void CWlmDriverIf::configure_multicast_group(

    u32_t request_id,

    bool_t join_group,

    const core_mac_address_s& multicast_addr )

    {

    // Set request id and ensure no prior requests are pending

    if( SetRequestId( request_id ) )