--- /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;
+ }