/*
* Copyright (c) 2005-2006 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:  Statemachine for loading the drivers
*
*/


#include "core_sub_operation_load_drivers.h"
#include "core_operation_update_rxtx_parameters.h"
#include "core_server.h"
#include "am_debug.h"

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

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
core_sub_operation_load_drivers_c::core_sub_operation_load_drivers_c(
    u32_t request_id,
    core_server_c* server,
    abs_core_driverif_c* drivers,
    abs_core_server_callback_c* adaptation ) :
    core_operation_base_c( core_operation_unspecified, request_id, server, drivers, adaptation,
        core_base_flag_none ),
    region_m( core_wlan_region_etsi ),
    mcc_known_m( false_t )
    {
    DEBUG( "core_sub_operation_load_drivers_c::core_sub_operation_load_drivers_c()" );
    }

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
core_sub_operation_load_drivers_c::~core_sub_operation_load_drivers_c()
    {
    DEBUG( "core_sub_operation_load_drivers_c::~core_sub_operation_load_drivers_c()" );
    }

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
core_error_e core_sub_operation_load_drivers_c::next_state()
    {
    DEBUG( "core_sub_operation_load_drivers_c::next_state()" );

    switch ( operation_state_m )
        {
        case core_state_init:
            {
            if ( !server_m->get_core_settings().is_wlan_enabled() )
                {
                DEBUG( "core_sub_operation_load_drivers_c::next_state() - WLAN is disabled, drivers cannot be loaded" );
                return core_error_wlan_disabled;
                }

            if ( server_m->get_core_settings().is_driver_loaded() )
                {
                DEBUG( "core_sub_operation_load_drivers_c::next_state() - drivers already loaded" );
                return core_error_ok;
                }

            DEBUG( "core_sub_operation_load_drivers_c::next_state() - requesting region" );

            operation_state_m = core_state_req_region;

            adaptation_m->get_regulatory_domain(
                request_id_m,
                region_m,
                mcc_known_m );

            break;
            }
        case core_state_req_region:
            {            
            DEBUG1( "core_sub_operation_load_drivers_c::next_state() - current region %u",
                region_m );
            server_m->get_core_settings().set_regional_domain(
                region_m );
            server_m->get_core_settings().set_mcc_known( mcc_known_m );

            DEBUG( "core_sub_operation_load_drivers_c::next_state() - loading drivers" );

            operation_state_m = core_state_req_load_drivers;
            
            drivers_m->load_drivers(
                request_id_m,
                server_m->get_device_settings().rts,
                server_m->get_device_settings().max_tx_msdu_life_time,
                server_m->get_device_settings().qos_null_frame_entry_timeout,
                server_m->get_device_settings().qos_null_frame_entry_tx_count,
                server_m->get_device_settings().qos_null_frame_interval,
                server_m->get_device_settings().qos_null_frame_exit_timeout,
                server_m->get_device_settings().keep_alive_interval,
                server_m->get_device_settings().sp_rcpi_target,
                server_m->get_device_settings().sp_time_target,
                server_m->get_device_settings().sp_min_indication_interval );

            break;
            }
        case core_state_req_load_drivers:
            {
            server_m->get_core_settings().set_driver_state( true_t );

            DEBUG1( "core_sub_operation_load_drivers_c::next_state() - setting tx power (%u)",
                server_m->get_device_settings().tx_power_level );

            operation_state_m = core_state_req_set_tx_power;

            drivers_m->set_tx_power_level(
                request_id_m,
                server_m->get_device_settings().tx_power_level );

            break;
            }
        case core_state_req_set_tx_power:
            {
            DEBUG( "core_sub_operation_load_drivers_c::next_state() - setting power mode to CORE_POWER_MODE_CAM" );

            operation_state_m = core_state_req_set_rxtx_parameters;

            server_m->get_core_settings().set_power_mode(
                CORE_POWER_MODE_CAM );

            drivers_m->set_power_mode(
                request_id_m,
                CORE_POWER_MODE_CAM );

            break;
            }
        case core_state_req_set_rxtx_parameters:
            {
            DEBUG( "core_sub_operation_load_drivers_c::next_state() - setting rxtx parameters" );

            operation_state_m = core_state_req_set_uapsd_settings;

            core_operation_base_c* operation = new core_operation_update_rxtx_parameters_c(
                request_id_m,
                server_m,
                drivers_m,
                adaptation_m );

            return run_sub_operation( operation );
            }            
        case core_state_req_set_uapsd_settings:
            {
            DEBUG( "core_sub_operation_load_drivers_c::next_state() - setting U-APSD settings" );

            operation_state_m = core_state_req_set_power_save_settings;

            const core_uapsd_settings_s& settings(
                server_m->get_core_settings().uapsd_settings() );

            DEBUG1( "core_sub_operation_load_drivers_c::next_state() - max_service_period: %u",
                settings.max_service_period );
            DEBUG1( "core_sub_operation_load_drivers_c::next_state() - uapsd_enabled_for_voice: %u",
                settings.uapsd_enabled_for_voice );
            DEBUG1( "core_sub_operation_load_drivers_c::next_state() - uapsd_enabled_for_video: %u",
                settings.uapsd_enabled_for_video );
            DEBUG1( "core_sub_operation_load_drivers_c::next_state() - uapsd_enabled_for_best_effort: %u",
                settings.uapsd_enabled_for_best_effort );
            DEBUG1( "core_sub_operation_load_drivers_c::next_state() - uapsd_enabled_for_background: %u",
                settings.uapsd_enabled_for_background );

            drivers_m->set_uapsd_settings(
                request_id_m,
                settings );

            break;
            }
        case core_state_req_set_power_save_settings:
            {
            DEBUG( "core_sub_operation_load_drivers_c::next_state() - setting power save settings" );

            operation_state_m = core_state_req_set_power_mode_mgmt_settings;

            const core_power_save_settings_s& settings(
                server_m->get_core_settings().power_save_settings() );

            DEBUG1( "core_sub_operation_load_drivers_c::next_state() - stay_in_uapsd_power_save_for_voice: %u",
                settings.stay_in_uapsd_power_save_for_voice );
            DEBUG1( "core_sub_operation_load_drivers_c::next_state() - stay_in_uapsd_power_save_for_video: %u",
                settings.stay_in_uapsd_power_save_for_video );
            DEBUG1( "core_sub_operation_load_drivers_c::next_state() - stay_in_uapsd_power_save_for_best_effort: %u",
                settings.stay_in_uapsd_power_save_for_best_effort );
            DEBUG1( "core_sub_operation_load_drivers_c::next_state() - stay_in_uapsd_power_save_for_background: %u",
                settings.stay_in_uapsd_power_save_for_background );

            DEBUG1( "core_sub_operation_load_drivers_c::next_state() - stay_in_legacy_power_save_for_voice: %u",
                settings.stay_in_legacy_power_save_for_voice );
            DEBUG1( "core_sub_operation_load_drivers_c::next_state() - stay_in_legacy_power_save_for_video: %u",
                settings.stay_in_legacy_power_save_for_video );
            DEBUG1( "core_sub_operation_load_drivers_c::next_state() - stay_in_legacy_power_save_for_best_effort: %u",
                settings.stay_in_legacy_power_save_for_best_effort );
            DEBUG1( "core_sub_operation_load_drivers_c::next_state() - stay_in_legacy_power_save_for_background: %u",
                settings.stay_in_legacy_power_save_for_background );

            drivers_m->set_power_save_settings(
                request_id_m,
                settings );

            break;
            }
        case core_state_req_set_power_mode_mgmt_settings:
            {
            DEBUG( "core_sub_operation_load_drivers_c::next_state() - setting power mode mgmt settings" );

            operation_state_m = core_state_req_set_block_ack_usage;

            core_power_mode_mgmt_parameters_s settings;
            settings.active_to_light_timeout =
                server_m->get_device_settings().ps_active_to_light_timeout;
            settings.active_to_light_threshold =
                server_m->get_device_settings().ps_active_to_light_threshold;
            settings.light_to_active_timeout =
                server_m->get_device_settings().ps_light_to_active_timeout;
            settings.light_to_active_threshold =
                server_m->get_device_settings().ps_light_to_active_threshold;
            settings.light_to_deep_timeout =
                server_m->get_device_settings().ps_light_to_deep_timeout;
            settings.light_to_deep_threshold =
                server_m->get_device_settings().ps_light_to_deep_threshold;
            settings.uapsd_rx_frame_length_threshold =
                server_m->get_device_settings().ps_uapsd_rx_frame_length;

            DEBUG1( "core_sub_operation_load_drivers_c::next_state() - active_to_light_timeout: %u",
                settings.active_to_light_timeout );
            DEBUG1( "core_sub_operation_load_drivers_c::next_state() - active_to_light_threshold: %u",
                settings.active_to_light_threshold );
            DEBUG1( "core_sub_operation_load_drivers_c::next_state() - light_to_active_timeout: %u",
                settings.light_to_active_timeout );
            DEBUG1( "core_sub_operation_load_drivers_c::next_state() - light_to_active_threshold: %u",
                settings.light_to_active_threshold );
            DEBUG1( "core_sub_operation_load_drivers_c::next_state() - light_to_deep_timeout: %u",
                settings.light_to_deep_timeout );
            DEBUG1( "core_sub_operation_load_drivers_c::next_state() - light_to_deep_threshold: %u",
                settings.light_to_deep_threshold );
            DEBUG1( "core_sub_operation_load_drivers_c::next_state() - uapsd_rx_frame_length_threshold: %u",
                settings.uapsd_rx_frame_length_threshold );

            drivers_m->set_power_mode_mgmt_parameters(
                request_id_m,
                settings );

            break;
            }
        case core_state_req_set_block_ack_usage:
            {
            DEBUG( "core_sub_operation_load_drivers_c::next_state() - setting block ACK usage" );

            operation_state_m = core_state_req_set_wpx_settings;

            const core_block_ack_usage_s& usage(
                server_m->get_core_settings().block_ack_usage() );

            DEBUG1( "core_sub_operation_load_drivers_c::next_state() - tx_usage: 0x%02X",
                usage.tx_usage );
            DEBUG1( "core_sub_operation_load_drivers_c::next_state() - rx_usage: 0x%02X",
                usage.rx_usage );

            drivers_m->set_block_ack_usage(
                request_id_m,
                usage );

            break;
            }
        case core_state_req_set_wpx_settings:
            {
            core_operation_base_c* operation =
                server_m->get_wpx_adaptation_instance().get_wpx_load_drivers_operation();
            if( !operation )
                {
                return goto_state( core_state_done );
                }

            DEBUG( "core_sub_operation_load_drivers_c::next_state() - setting WPX specific settings" );

            return run_sub_operation( operation, core_state_done );
            }
        case core_state_done:
            {
            DEBUG( "core_sub_operation_load_drivers_c::next_state() - all operations done" );

            return core_error_ok;  
            }
        case core_state_cancel_req_unload_drivers:
            {
            server_m->get_core_settings().set_driver_state( false_t );

            DEBUG( "core_sub_operation_load_drivers_c::next_state() - unloading done " );

            return failure_reason_m;
            }
        default:
            {
            ASSERT( false_t );
            }
        }

    return core_error_request_pending;
    }

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
void core_sub_operation_load_drivers_c::user_cancel(
    bool_t /* do_graceful_cancel */ )
    {
    DEBUG( "core_sub_operation_load_drivers_c::user_cancel()" );
    }

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
core_error_e core_sub_operation_load_drivers_c::cancel()
    {
    DEBUG( "core_sub_operation_load_drivers_c::cancel() " );

    switch ( operation_state_m )
        {
        case core_state_init:
            /** Falls through on purpose. */
        case core_state_req_region:
            /** Falls through on purpose. */
        case core_state_req_load_drivers:
            {
            /* Also in this case we need to make unload because it can happen that loading returns 
             * failure but there is still need to unload */
            
            DEBUG( "core_sub_operation_load_drivers_c::cancel() - unloading drivers, load failed" );
            
            operation_state_m = core_state_cancel_req_unload_drivers;
            
            drivers_m->unload_drivers(
                request_id_m );

            break;
            }
        case core_state_cancel_req_unload_drivers:
            {
            DEBUG( "core_sub_operation_load_drivers_c::cancel() - unloading failed, ignoring " );
            
            return failure_reason_m;
            }
        default:
            {            
            ASSERT( server_m->get_core_settings().is_driver_loaded() );
            DEBUG( "core_sub_operation_load_drivers_c::cancel() - unloading drivers " );
            
            operation_state_m = core_state_cancel_req_unload_drivers;
            
            drivers_m->unload_drivers(
                request_id_m );

            break;
            }
        }

    return core_error_request_pending;
    }