diff -r 000000000000 -r c40eb8fe8501 wlan_bearer/wlanengine/wlan_common/wlanengine_common_3.1/src/core_sub_operation_load_drivers.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/wlan_bearer/wlanengine/wlan_common/wlanengine_common_3.1/src/core_sub_operation_load_drivers.cpp Tue Feb 02 02:03:13 2010 +0200 @@ -0,0 +1,370 @@ +/* +* 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; + }