/*

* Copyright (c) 2006-2010 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 creating a traffic stream.

*

*/

/*

* %version: 6 %

*/

#include "core_operation_create_ts.h"

#include "core_operation_delete_ts.h"

#include "core_traffic_stream.h"

#include "core_sub_operation_create_ts.h"

#include "core_frame_wmm_ie.h"

#include "core_server.h"

#include "core_tools.h"

#include "core_traffic_stream_list_iter.h"

#include "core_virtual_traffic_stream_list_iter.h"

#include "am_debug.h"

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

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

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

//

core_operation_create_ts_c::core_operation_create_ts_c(

    u32_t request_id,

    core_server_c* server,

    abs_core_driverif_c* drivers,

    abs_core_server_callback_c* adaptation,

    u8_t tid,

    u8_t user_priority,

    bool_t is_automatic_stream,

    const core_traffic_stream_params_s& params,

    u32_t& stream_id,

    core_traffic_stream_status_e& stream_status ) :

    core_operation_base_c( core_operation_create_ts, request_id, server, drivers, adaptation,

        core_base_flag_none ),

    requested_tid_m( tid ),

    tid_m( tid ),

    user_priority_m( user_priority ),

    access_class_m( core_access_class_best_effort ),

    is_automatic_stream_m( is_automatic_stream ),

    requested_params_m( params ),

    params_m( params ),

    stream_id_m( stream_id ),

    stream_status_m( stream_status ),

    stream_m( NULL )

    {

    DEBUG( "core_operation_create_ts_c::core_operation_create_ts_c()" );

    }

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

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

//

core_operation_create_ts_c::~core_operation_create_ts_c()

    {

    DEBUG( "core_operation_create_ts_c::~core_operation_create_ts_c()" );

    delete stream_m;

    }

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

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

//

core_error_e core_operation_create_ts_c::next_state()

    {

    DEBUG( "core_operation_create_ts_c::next_state()" );

    switch ( operation_state_m )

        {              

        case core_state_init:

            {

            if( !server_m->get_core_settings().is_connected() )

                {

                DEBUG( "core_operation_create_ts_c::next_state() - not connected, nothing to do" );

                return core_error_general;

                }

            if( !is_valid_params() )

                {

                DEBUG( "core_operation_create_ts_c::next_state() - invalid traffic stream parameters" );

                return core_error_illegal_argument;                

                }

            access_class_m = core_tools_c::convert_user_priority_to_ac( user_priority_m );

            core_traffic_stream_list_c& ts_list(

                server_m->get_connection_data()->traffic_stream_list() );

            core_virtual_traffic_stream_list_c& virtual_ts_list(

                server_m->get_connection_data()->virtual_traffic_stream_list() );

            core_traffic_stream_list_iter_c ts_iter( ts_list );

            core_virtual_traffic_stream_list_iter_c virtual_ts_iter( virtual_ts_list );

            DEBUG( "core_operation_create_ts_c::next_state() - current traffic streams:" );

            virtual_ts_list.print_contents();

            ts_list.print_contents();

            if( tid_m != TRAFFIC_STREAM_TID_NONE )

                {

                /**

                 * If TID has been specified for the virtual traffic stream, check

                 * whether it clashes with an existing traffic stream.

                 */

                if( ts_list.is_traffic_stream_for_tid( tid_m ) )

                    {

                    DEBUG1( "core_operation_create_ts_c::next_state() - stream already exists for TID %u",

                        tid_m );

                    return core_error_already_exists;

                    }

                }

            else

                {

                /**

                 * If TID has been left unspecified, select the next free

                 * TID.

                 *

                 * First try to select the next free TID from virtual traffic

                 * stream list. In the unlikely scenario where all TIDs are

                 * in use, try the traffic stream list next.

                 */

                tid_m = virtual_ts_list.next_tid();

                if( tid_m == MAX_TRAFFIC_STREAM_TID )

                    {

                    tid_m = ts_list.next_tid();

                    if( tid_m == MAX_TRAFFIC_STREAM_TID )

                        {                    

                        DEBUG( "core_operation_create_ts_c::next_state() - no free TIDs" );

                        return core_error_general;

                        }

                    }

                }

#ifdef _DEBUG

            DEBUG2( "core_operation_create_ts_c::next_state() - Traffic Stream TID is %u, UP is %u",

                tid_m, user_priority_m );

            DEBUG( "core_operation_create_ts_c::next_state() - trying to create a traffic stream with values:" );

            if( params_m.is_periodic_traffic )

                {

                DEBUG( "core_operation_create_ts_c::next_state() - Traffic pattern:              periodic" );

                }

            else

                {

                DEBUG( "core_operation_create_ts_c::next_state() - Traffic pattern:              aperiodic" );

                }            

            if( params_m.direction == core_traffic_stream_direction_uplink )

                {

                DEBUG( "core_operation_create_ts_c::next_state() - Direction:                    uplink" );

                }

            else if( params_m.direction == core_traffic_stream_direction_downlink )

                {

                DEBUG( "core_operation_create_ts_c::next_state() - Direction:                    downlink" );

                }

            else

                {

                DEBUG( "core_operation_create_ts_c::next_state() - Direction:                    bi-directional" );

                }                

            DEBUG2( "core_operation_create_ts_c::next_state() - Nominal MSDU Size:            %u (0x%04X)",

                params_m.nominal_msdu_size, params_m.nominal_msdu_size );                

            DEBUG2( "core_operation_create_ts_c::next_state() - Maximum MSDU Size:            %u (0x%04X)",

                params_m.maximum_msdu_size, params_m.maximum_msdu_size );

            DEBUG2( "core_operation_create_ts_c::next_state() - Minimum Service Interval:     %u (0x%08X)",

                params_m.minimum_service_interval, params_m.minimum_service_interval );

            DEBUG2( "core_operation_create_ts_c::next_state() - Maximum Service Interval:     %u (0x%08X)",

                params_m.maximum_service_interval, params_m.maximum_service_interval );

            DEBUG2( "core_operation_create_ts_c::next_state() - Inactivity Interval:          %u (0x%08X)",

                params_m.inactivity_interval, params_m.inactivity_interval );

            DEBUG2( "core_operation_create_ts_c::next_state() - Suspension Interval:          %u (0x%08X)",

                params_m.suspension_interval, params_m.suspension_interval );

            DEBUG2( "core_operation_create_ts_c::next_state() - Service Start Time:           %u (0x%08X)",

                params_m.service_start_time, params_m.service_start_time );

            DEBUG2( "core_operation_create_ts_c::next_state() - Minimum Data Rate:            %u (0x%08X)",

                params_m.minimum_data_rate, params_m.minimum_data_rate );        

            DEBUG2( "core_operation_create_ts_c::next_state() - Mean Data Rate:               %u (0x%08X)",

                params_m.mean_data_rate, params_m.mean_data_rate );

            DEBUG2( "core_operation_create_ts_c::next_state() - Peak Data Rate:               %u (0x%08X)",

                params_m.peak_data_rate, params_m.peak_data_rate );

            DEBUG2( "core_operation_create_ts_c::next_state() - Maximum Burst Size:           %u (0x%08X)",

                params_m.maximum_burst_size, params_m.maximum_burst_size );

            DEBUG2( "core_operation_create_ts_c::next_state() - Delay Bound:                  %u (0x%08X)",

                params_m.delay_bound, params_m.delay_bound );

            DEBUG2( "core_operation_create_ts_c::next_state() - Minimum PHY Rate:             %u (0x%08X)",

                params_m.minimum_phy_rate, params_m.minimum_phy_rate );

            DEBUG2( "core_operation_create_ts_c::next_state() - Nominal PHY Rate:             %u (0x%04X)",

                params_m.nominal_phy_rate, params_m.nominal_phy_rate );

            DEBUG2( "core_operation_create_ts_c::next_state() - Surplus Bandwidth Allowance:  %u (0x%04X)",

                params_m.surplus_bandwidth_allowance, params_m.surplus_bandwidth_allowance );

#endif // _DEBUG

            stream_m = new core_traffic_stream_c(

                tid_m,

                user_priority_m );

            if( !stream_m )

                {

                DEBUG( "core_operation_create_ts_c::next_state() - unable to allocate a traffic stream instance" );

                return core_error_no_memory;

                }

            /**

             * If the Max Tx MSDU Lifetime is not overridden, use the default value.             

             */

            if( !params_m.override_max_tx_msdu_lifetime )

                {

                params_m.override_max_tx_msdu_lifetime = server_m->get_device_settings().max_tx_msdu_life_time;

                }

            stream_m->set_default_traffic_values( params_m );            

            stream_m->reset_to_default_values();            

            /**

             * If this is a manual traffic stream, all automatic streams

             * need to be deleted before continuing.

             */

            if( !is_automatic_stream_m )

                {

                server_m->get_connection_data()->set_ac_traffic_mode(

                    access_class_m,

                    core_access_class_traffic_mode_manual );

                /**

                 * Send an indication to notify clients that traffic mode

                 * is now set to manual.

                 */

                u8_t buf[5];

                buf[0] = static_cast<u8_t>( 

                    access_class_m );

                buf[1] = static_cast<u8_t>(

                    core_access_class_traffic_mode_manual );

                adaptation_m->notify(

                    core_notification_ac_traffic_mode_changed,

                    sizeof( buf ),

                    buf );

                return goto_state( core_state_delete_streams );

                }

            /**

             * Otherwise proceed with stream creation.

             */            

            return goto_state( core_state_create_stream );

            }

        case core_state_delete_streams:

            {

            core_virtual_traffic_stream_list_iter_c virtual_ts_iter(

                server_m->get_connection_data()->virtual_traffic_stream_list() );

            for( core_virtual_traffic_stream_c* iter = virtual_ts_iter.first(); iter; iter = virtual_ts_iter.next() )

                {

                if( iter->access_class() == access_class_m &&

                    iter->is_automatic_stream() )

                    {

                    core_operation_base_c* operation = new core_operation_delete_ts_c(

                        request_id_m,

                        server_m,

                        drivers_m,

                        adaptation_m,

                        iter->id() );

                    return run_sub_operation( operation, core_state_delete_streams );                    

                    }

                }

            return asynch_goto( core_state_create_stream );

            }            

        case core_state_create_stream:

            {

            core_ap_data_c* current_ap = server_m->get_connection_data()->current_ap_data();

            if( !current_ap->is_wmm_ie_present() ||

                !current_ap->is_admission_control_required( access_class_m ) )

                {

                DEBUG1( "core_operation_create_ts_c::next_state() - AP doesn't require admission control on AC %u",

                    access_class_m );

                /**

                 * An actual traffic stream is not needed but the virtual traffic

                 * stream is still created.

                 */                

                server_m->get_connection_data()->virtual_traffic_stream_list().add_traffic_stream(

                    requested_tid_m,

                    TRAFFIC_STREAM_TID_NONE,

                    user_priority_m,

                    is_automatic_stream_m,

                    requested_params_m,

                    stream_id_m,

                    core_traffic_stream_status_inactive_not_required );

                return core_error_ok;

                }

            /**

             * Try to create the actual traffic stream.

             */

            core_operation_base_c* operation = new core_sub_operation_create_ts_c(

                request_id_m,

                server_m,

                drivers_m,

                adaptation_m,

                *server_m->get_connection_data()->current_ap_data(),

                tid_m,

                user_priority_m,

                params_m,

                stream_status_m );

            return run_sub_operation( operation, core_state_create_stream_success );

            }

        case core_state_create_stream_failed:

            {

            DEBUG( "core_operation_create_ts_c::next_state() - traffic stream creation failed" );

            /**

             * Eventhough the actual traffic stream couldn't be created, the virtual traffic

             * stream is still created.

             */            

            server_m->get_connection_data()->virtual_traffic_stream_list().add_traffic_stream(

                requested_tid_m,

                TRAFFIC_STREAM_TID_NONE,

                user_priority_m,

                is_automatic_stream_m,

                requested_params_m,

                stream_id_m,

                stream_status_m );

            return core_error_ok;

            }

        case core_state_create_stream_success:

            {

            operation_state_m = core_state_parameters_set;

            DEBUG( "core_operation_create_ts_c::next_state() - traffic stream created successfully" );

            server_m->get_connection_data()->virtual_traffic_stream_list().add_traffic_stream(

                requested_tid_m,

                tid_m,

                user_priority_m,

                is_automatic_stream_m,

                requested_params_m,

                stream_id_m,

                core_traffic_stream_status_active );

            /**

             * Store the new traffic stream parameters.

             */

            stream_m->set_status( core_traffic_stream_status_active );

            stream_m->set_traffic_values( params_m );            

            server_m->get_connection_data()->traffic_stream_list().update_traffic_stream(

                *stream_m );

            if( params_m.direction == core_traffic_stream_direction_uplink ||

                params_m.direction == core_traffic_stream_direction_bidirectional )

                {

                server_m->get_connection_data()->set_ac_traffic_status(

                    access_class_m,

                    core_access_class_traffic_status_admitted );

                /**

                 * Send an indication to notify clients that this access class

                 * is now admitted. 

                 */

                u8_t buf[5];

                buf[0] = static_cast<u8_t>( 

                    access_class_m );

                buf[1] = static_cast<u8_t>(

                    core_access_class_traffic_status_admitted );

                adaptation_m->notify(

                    core_notification_ac_traffic_status_changed,

                    sizeof( buf ),

                    buf );

                /**

                 * Set the parameters to the drivers based on the created

                 * traffic stream.

                 */

                DEBUG( "core_operation_create_ts_c::next_state() - setting tx queue parameters" );

                drivers_m->set_tx_queue_parameters(

                    request_id_m,

                    stream_m->access_class(),

                    stream_m->medium_time(),

                    stream_m->max_tx_msdu_lifetime() );

                }

            else

                {

                /**

                 * Since TX queue parameters apply only to uplink, there is nothing

                 * more to do on downlink streams.

                 */

                return core_error_ok;                

                }

            break;

            }

        case core_state_parameters_set:

            {

            DEBUG( "core_operation_create_ts_c::next_state() - tx queue parameters set" );

            return core_error_ok;

            } 

        default:

            {

            ASSERT( false_t );

            }

        }

    return core_error_request_pending;

    }

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

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

//

core_error_e core_operation_create_ts_c::cancel()

    {

    DEBUG( "core_operation_create_ts_c::cancel() " );    

    switch( operation_state_m )

        {              

        case core_state_create_stream_success:

            {

            return goto_state( core_state_create_stream_failed );

            }

        default:

            {

            return failure_reason_m;

            }

        }

    }

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

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

//

bool_t core_operation_create_ts_c::is_valid_params()

    {

    if( tid_m >= MAX_TRAFFIC_STREAM_TID && tid_m != TRAFFIC_STREAM_TID_NONE )

        {

        DEBUG1( "core_operation_create_ts_c::is_valid_params() - invalid TID value: %u",

            tid_m );

        return false_t;

        }

    if( user_priority_m >= MAX_QOS_USER_PRIORITY )

        {

        DEBUG1( "core_operation_create_ts_c::is_valid_params() - invalid user priority value: %u",

            user_priority_m );        

        return false_t;

        }

    return true_t;

    }