bal_release/src/core/main/tm_queue_fsm.c

/******************************************************************************
 *
 *  <:copyright-BRCM:2016:DUAL/GPL:standard
 *  
 *     Copyright (c) 2016 Broadcom
 *     All Rights Reserved
 *  
 *  Unless you and Broadcom execute a separate written software license
 *  agreement governing use of this software, this software is licensed
 *  to you under the terms of the GNU General Public License version 2
 *  (the "GPL"), available at http://www.broadcom.com/licenses/GPLv2.php,
 *  with the following added to such license:
 *  
 *     As a special exception, the copyright holders of this software give
 *     you permission to link this software with independent modules, and
 *     to copy and distribute the resulting executable under terms of your
 *     choice, provided that you also meet, for each linked independent
 *     module, the terms and conditions of the license of that module.
 *     An independent module is a module which is not derived from this
 *     software.  The special exception does not apply to any modifications
 *     of the software.
 *  
 *  Not withstanding the above, under no circumstances may you combine
 *  this software in any way with any other Broadcom software provided
 *  under a license other than the GPL, without Broadcom's express prior
 *  written consent.
 *  
 *  :>
 *
 *****************************************************************************/
 
/**
 * @file tm_queue_fsm.c
 * @brief Code to support the BAL tm_queue FSM
 *
 *
 */

/*@{*/

#include <bcmos_system.h>
#include <tm_queue_fsm.h>
#include <bal_msg.h>
#include <bal_osmsg.h>
#include "bal_worker.h"
#include "bal_mac_util.h"
#include "bal_switch_util.h"
#include "rsc_mgr.h"

#include <bal_objs.h>
#include <fsm_common.h>

#ifdef ENABLE_LOG
#include <bcm_dev_log.h>

 /*
 * @brief The logging device id for tm queue
 */
static dev_log_id log_id_tm_queue;
#endif

/* local function declarations */

static bcmos_errno tm_queue_free_by_entry(tm_queue_inst *p_entry);
static bcmos_errno tm_queue_fsm_state_err(tm_queue_inst *p_tm_queue_inst, void *msg, tm_queue_fsm_event *p_event);
static void tm_queue_inst_entry_obj_init(tm_queue_inst *p_entry);

/*
 * @brief The Global tm_queue fsm context data structure
 */
static tm_queue_fsm_ctx g_tm_queue_fsm_tm_queue_list_ctx;

/*
 * Macros for tm_queue ctx access
 */
#define TM_QUEUE_FSM_TM_QUEUE_LIST_CTX      (g_tm_queue_fsm_tm_queue_list_ctx)
#define TM_QUEUE_FSM_TM_QUEUE_LIST_CTX_PTR  (&g_tm_queue_fsm_tm_queue_list_ctx)


/*
 *  @brief The definition of a tm_queue FSM state processing function
 */
typedef bcmos_errno (* tm_queue_fsm_state_processor)(tm_queue_inst *, void *, tm_queue_fsm_event *);
static bcmos_errno bcmbal_tm_queue_create(tm_queue_inst *p_tm_queue_inst, 
										   void *msg, 
										   tm_queue_fsm_event *p_event);

static bcmos_errno bcmbal_tm_queue_active_destroy (tm_queue_inst *p_tm_queue_inst, 
										   void *msg, 
										   tm_queue_fsm_event *p_event);
static bcmos_errno bcmbal_tm_queue_inactive_destroy(tm_queue_inst *p_tm_queue_inst, 
										   void *msg, 
										   tm_queue_fsm_event *p_event);


static tm_queue_fsm_state_processor tm_queue_states[TM_QUEUE_FSM_STATE__NUM_OF][TM_QUEUE_FSM_EVENT_TYPE__NUM_OF] = 
{
    [TM_QUEUE_FSM_STATE_NULL] = 
    {
        [TM_QUEUE_FSM_EVENT_TYPE_CREATE] = bcmbal_tm_queue_create,
    },
    [TM_QUEUE_FSM_STATE_INACTIVE] = 
    {
        [TM_QUEUE_FSM_EVENT_TYPE_DESTROY] = bcmbal_tm_queue_inactive_destroy,
    },
    [TM_QUEUE_FSM_STATE_ACTIVE] = 
    {
        [TM_QUEUE_FSM_EVENT_TYPE_DESTROY] = bcmbal_tm_queue_active_destroy,
    },

};

static char *state_name_str[] =
{
    "TM_QUEUE_FSM_STATE_NULL",
    "TM_QUEUE_FSM_STATE_INACTIVE",	
    "TM_QUEUE_FSM_STATE_ACTIVE",
    "TM_QUEUE_FSM_STATE_IN_USE",
    "TM_QUEUE_FSM_STATE_DELETING",
};

/* Ensure that the name array size matches the associated enum */
BAL_STATIC_ASSERT(TM_QUEUE_FSM_STATE__LAST == (sizeof (state_name_str) / sizeof (char *)), tm_queue_fsm_state);

static char *tm_queue_state_name_get(tm_queue_fsm_state state)
{
    if(state < TM_QUEUE_FSM_STATE__LAST)
    {
        return state_name_str[state];
    }
    else
    {
        return "TM_QUEUE_UNKNOWN";
    }
}

static char *event_name_str[] =
{
    "TM_QUEUE_FSM_CREATE_EVENT",
    "TM_QUEUE_FSM_DESTROY_EVENT",
    "FLOW_FSM_UTIL_MSG_EVENT",
};

/* Ensure that the name array size matches the associated enum */
BAL_STATIC_ASSERT(TM_QUEUE_FSM_EVENT_TYPE__LAST == (sizeof (event_name_str) / sizeof (char *)), tm_queue_fsm_event_type);

static char *tm_queue_event_name_get(tm_queue_fsm_event_type event)
{
    if(event < TM_QUEUE_FSM_EVENT_TYPE__LAST)
    {
        return event_name_str[event];
    }
    else
    {
        return "TM_QUEUE_EVT_UNKNOWN";
    }
}

/*****************************************************************************/
/**
 * @brief The Tm queue FSM function which is executed when an error
 *        is encountered during FSM processing.
 *
 * @param p_tm_queue_inst     Pointer to a tm_queue instance
 * @param msg              Pointer to a BAL message received from one of
 *                         the BAL apps.
 * @param p_event          Pointer to a tm_queue event structure
 *
 * @returns bcmos_errno
 *****************************************************************************/
static bcmos_errno tm_queue_fsm_state_err(tm_queue_inst *p_tm_queue_inst,
                                      void *msg,
                                      tm_queue_fsm_event *p_event)
{
    bcmos_errno ret = BCM_ERR_INVALID_OP;

    BCM_LOG(DEBUG, log_id_tm_queue,
            "Error encountered processing TM_queue FSM"
            " - BAD EVENT ()\n");

    return ret;
}


/*****************************************************************************/
/**
 * @brief A function to initialize the Tm Queue FSM infrastructure.
 *
 *        NOTE: This is called once on startup and NOT for each FSM instance.
 *
 * @returns bcmos_errno
 *****************************************************************************/
bcmos_errno tm_queue_fsm_init(void)
{
    int ii;
    tm_queue_inst *new_entry;
    bcmos_errno ret = BCM_ERR_OK;

#ifdef ENABLE_LOG
    log_id_tm_queue = bcm_dev_log_id_register("TM_QUEUE", DEV_LOG_LEVEL_INFO, DEV_LOG_ID_TYPE_BOTH);
    BUG_ON(log_id_tm_queue == DEV_LOG_INVALID_ID);
#endif

    /* Initialize all of the tm_queue queues */
    TAILQ_INIT(&TM_QUEUE_FSM_TM_QUEUE_LIST_CTX_PTR->free_tm_queue_list);
    TAILQ_INIT(&TM_QUEUE_FSM_TM_QUEUE_LIST_CTX_PTR->active_tm_queue_list);

    /* Populate the free list with it's initial set of tm_queues
     */
    for(ii=0; ii<TM_QUEUE_ALLOCATION_BLOCK_SIZE; ii++)
    {
        new_entry = bcmos_calloc(sizeof(tm_queue_inst));
        if(NULL == new_entry)
        {
            BCM_LOG(FATAL, log_id_tm_queue,  "Failed to initialize the tm_queue free list - FATAL\n");
            ret = BCM_ERR_NOMEM;
            break;
        }
       tm_queue_free_by_entry(new_entry);
    }
    return ret;
}

/*****************************************************************************/
/**
 * @brief A function to un-initialize the Tm Queue FSM infrastructure.
 *
 *        NOTE: This is called once on shutdown and NOT for each FSM instance.
 *
 * @returns bcmos_errno
 *****************************************************************************/
bcmos_errno tm_queue_fsm_finish(void)
{

    tm_queue_inst *current_entry, *p_temp_entry;

    /* Free all the entries on the active list */
    TAILQ_FOREACH_SAFE(current_entry,
                       &TM_QUEUE_FSM_TM_QUEUE_LIST_CTX_PTR->active_tm_queue_list,
                       tm_queue_inst_next,
                       p_temp_entry)
    {
        /* Remove it from the active list */
        TAILQ_REMOVE(&TM_QUEUE_FSM_TM_QUEUE_LIST_CTX_PTR->active_tm_queue_list, current_entry, tm_queue_inst_next);

        bcmos_free(current_entry);

    }

    /* Free all the entries on the free list */
    TAILQ_FOREACH_SAFE(current_entry,
                       &TM_QUEUE_FSM_TM_QUEUE_LIST_CTX_PTR->free_tm_queue_list,
                       tm_queue_inst_next,
                       p_temp_entry)
    {
        /* Remove it from the active list */
        TAILQ_REMOVE(&TM_QUEUE_FSM_TM_QUEUE_LIST_CTX_PTR->free_tm_queue_list, current_entry, tm_queue_inst_next);

        bcmos_free(current_entry);
    }

    return BCM_ERR_OK;
}

static void tm_queue_inst_entry_obj_init(tm_queue_inst *p_entry)
{
    /* The actual key content is irrelevant for free tm_queues */
    bcmbal_tm_queue_key key = { .id = 0, .sched_id = 0, .sched_dir = BCMBAL_TM_SCHED_DIR_US};

    /* And add it to the free list */
    p_entry->fsm_state = TM_QUEUE_FSM_STATE_NULL;

    BCMBAL_CFG_INIT(&p_entry->current_tm_queue_info,
                    tm_queue,
                    key);

    BCMBAL_OBJ_IN_PROGRESS_SET(&(p_entry->current_tm_queue_info), BCMOS_FALSE);
}
/*****************************************************************************/
/**
 * @brief A function to free a tm_queue instance specified by a the supplied
 *        entry pointer.
 *
 * @param p_entry A pointer to the entry to be freed
 *
 *
 * @returns bcmos_errno
 *****************************************************************************/
static bcmos_errno tm_queue_free_by_entry(tm_queue_inst *p_entry)
{
    bcmos_errno ret = BCM_ERR_OK;
    tm_queue_inst *current_entry;
    tm_queue_inst *p_temp_entry;

    /*
     * First, check the active list (an active tm_queue can be in the adding or removing state)
     */
    TAILQ_FOREACH_SAFE(current_entry,
                       &TM_QUEUE_FSM_TM_QUEUE_LIST_CTX_PTR->active_tm_queue_list,
                       tm_queue_inst_next,
                       p_temp_entry)
    {
        if(current_entry == p_entry)
        {
           /* Remove it from the active list */
            TAILQ_REMOVE(&TM_QUEUE_FSM_TM_QUEUE_LIST_CTX_PTR->active_tm_queue_list, current_entry, tm_queue_inst_next);
            break;
        }
    }
	tm_queue_inst_entry_obj_init(p_entry);
    TAILQ_INSERT_TAIL(&TM_QUEUE_FSM_TM_QUEUE_LIST_CTX_PTR->free_tm_queue_list, p_entry, tm_queue_inst_next);

    return ret;
}

/*****************************************************************************/
/**
 * @brief The Tm queue FSM state processing executive function
 * @param p_tm_queue_inst  Pointer to a tm_queu instance
 * @param p_event      Pointer to a tm_Queue event structure
 *
 * @returns bcmos_errno
 *****************************************************************************/
static bcmos_errno tm_queue_fsm_exec(tm_queue_inst *p_tm_queue_inst, tm_queue_fsm_event *p_event)
{
    bcmos_errno ret = BCM_ERR_OK;
    tm_queue_fsm_state pre_state;
    tm_queue_fsm_state_processor tm_queue_state_processor;

    /* Parameter checks */
    BUG_ON(NULL == p_tm_queue_inst);
    BUG_ON(NULL == p_event);

    /* Record the present state for debug printing
     */
    pre_state = p_tm_queue_inst->fsm_state;

    /*
     * Get the state processing function
     */
    tm_queue_state_processor = tm_queue_states[p_tm_queue_inst->fsm_state][p_event->event_type];

    /*
     * If there's a state processing function for this event and state, execute it.
     * Otherwise, process a generic error.
     */
    if(tm_queue_state_processor)
    {
        ret = tm_queue_state_processor(p_tm_queue_inst, p_event->msg, p_event);
    } 
	else
    {
        tm_queue_fsm_state_err(p_tm_queue_inst, p_event->msg, p_event);
    }

    if(BCM_ERR_OK != ret)
    {
        BCM_LOG(ERROR, log_id_tm_queue, "*** Error detected during state processing\n");
        p_tm_queue_inst->fsm_state = pre_state;
    }

    BCM_LOG(DEBUG, log_id_tm_queue,  "*** Event %s, State: %s --> %s\n\n",
            tm_queue_event_name_get(p_event->event_type),
            tm_queue_state_name_get(pre_state),
            tm_queue_state_name_get(p_tm_queue_inst->fsm_state));

    return ret;
}

/*****************************************************************************/
/**
 * @brief A function to retrieve a tm_queue instance of the specified class.
 *
 * @param key            A pointer to the key of the tm_queue being referenced
 * @param search_flag    A flag specifying the type of tm_queue
 *                       instance to be retrieved
 *
 * @returns tm_queue_inst_t* A pointer to the found tm_queue instance,
 *                       or NULL if one is not found
 *****************************************************************************/
tm_queue_inst *tm_queue_inst_get(bcmbal_tm_queue_key key, tm_queue_flag search_flag)
{
    tm_queue_inst *current_entry = NULL;

    /*
     * First, check the active list if the caller has chosen to do so
     */
    if(TM_QUEUE_FLAG_ACTIVE & search_flag)
    {
        TAILQ_FOREACH(current_entry,
                      &TM_QUEUE_FSM_TM_QUEUE_LIST_CTX_PTR->active_tm_queue_list,
                      tm_queue_inst_next)
        {

            if(current_entry->api_req_tm_queue_info.key.id == key.id
				&& current_entry->api_req_tm_queue_info.key.sched_id == key.sched_id
                && current_entry->api_req_tm_queue_info.key.sched_dir == key.sched_dir)
            {
                BCM_LOG(DEBUG, log_id_tm_queue,  "Found active tm_queue\n");
                /* The tm_queue instance pointer is in current_entry */
                break;
            }
        }
    }
    /*
     * Next, check the free list if the caller has chosen to do so
     */
    if((TM_QUEUE_FLAG_FREE & search_flag) && (NULL == current_entry))
    {
        /* Now check the free list */
        if(!TAILQ_EMPTY(&TM_QUEUE_FSM_TM_QUEUE_LIST_CTX_PTR->free_tm_queue_list))
        {
            /* Just grab the first entry */
            current_entry = TAILQ_FIRST(&TM_QUEUE_FSM_TM_QUEUE_LIST_CTX_PTR->free_tm_queue_list);

            /* Remove it from the free list */
            TAILQ_REMOVE(&TM_QUEUE_FSM_TM_QUEUE_LIST_CTX_PTR->free_tm_queue_list, current_entry, tm_queue_inst_next);

            /* And add it to the active list */
            TAILQ_INSERT_TAIL(&TM_QUEUE_FSM_TM_QUEUE_LIST_CTX_PTR->active_tm_queue_list, current_entry, tm_queue_inst_next);

            /*
             * Initialize the fsm state
             */
            current_entry->fsm_state = TM_QUEUE_FSM_STATE_NULL;

            BCM_LOG(DEBUG, log_id_tm_queue,  "Using new tm_queue\n");
        }
    }

    if((TM_QUEUE_FLAG_ANY & search_flag) && (NULL == current_entry))
    {
        /*A tm_queue was not found on either list*/

        BCM_LOG(DEBUG, log_id_tm_queue,  "************** ERROR: no tm_queue found\n");
    }

    return current_entry;
}

static bcmos_errno bcmbal_tm_queue_validate(bcmbal_tm_queue_cfg *p_tm_queue_cfg)
{
    bcmos_errno  ret = BCM_ERR_OK;
    bcmbal_tm_sched_key tm_sched_key = {.id = p_tm_queue_cfg->key.sched_id, .dir = p_tm_queue_cfg->key.sched_dir};
    tm_sched_inst *p_tm_sched_inst = NULL;
    do
    {
        /*get the tm sched instance*/
        p_tm_sched_inst = tm_sched_inst_get(tm_sched_key, TM_SCHED_FLAG_ACTIVE);
        if(NULL == p_tm_sched_inst)
        {
            BCM_LOG(ERROR, log_id_tm_queue,  "ERROR: no related tm_sched found (id = %d dir = %s)\n",
                                               tm_sched_key.id, TM_SCHED_DIR_TO_STR(tm_sched_key.dir));
            ret = BCM_ERR_NOENT;
            break;
        }
        /*check it is not an agg port tm sched - as there are no queues to such node*/      
        if(BCMBAL_CFG_PROP_IS_SET(&p_tm_sched_inst->req_tm_sched_info, tm_sched, owner))
		{
            if(BCMBAL_TM_SCHED_OWNER_TYPE_AGG_PORT == p_tm_sched_inst->req_tm_sched_info.data.owner.type)
            {
                BCM_LOG(ERROR, log_id_tm_queue,  "ERROR: should not attach queue to node which is owned by agg port (id = %d dir = %s)\n",
                                                   tm_sched_key.id, TM_SCHED_DIR_TO_STR(tm_sched_key.dir));
                ret = BCM_ERR_PARM;
                break;
            }				
		}

        /*sched level should be 'queue'*/
        if(BCMBAL_TM_SCHED_CHILD_TYPE_QUEUE != p_tm_sched_inst->req_tm_sched_info.data.sched_child_type)		
        {
            BCM_LOG(ERROR, log_id_tm_queue,  "ERROR: tm sched sched level is invalid (%d), should be BCMBAL_TM_SCHED_CHILD_TYPE_QUEUE\n",
                    p_tm_sched_inst->req_tm_sched_info.data.sched_child_type);
            ret = BCM_ERR_PARM;
            break;
        }

        /*based on sched type, check priority / weight is set and is valid */
        if(BCMBAL_TM_SCHED_TYPE_SP == p_tm_sched_inst->req_tm_sched_info.data.sched_type)
        {
            if(!BCMBAL_CFG_PROP_IS_SET(p_tm_queue_cfg, tm_queue, priority))
            {
                BCM_LOG(ERROR, log_id_tm_queue, "Queue must be set with a priority, as its scheduler' sched_type is sp\n");
                ret = BCM_ERR_PARM;
                break;
            }
            if(BCMBAL_CFG_PROP_IS_SET(p_tm_queue_cfg, tm_queue, weight))
            {
                BCM_LOG(ERROR, log_id_tm_queue, "Queue can not be set with a weight, as its scheduler' sched_type is sp\n");
                ret = BCM_ERR_PARM;
                break;
            }
            if(p_tm_queue_cfg->data.priority >= p_tm_sched_inst->req_tm_sched_info.data.num_priorities)
            {
                BCM_LOG(ERROR, log_id_tm_queue, "Queue priority (%d) is higher than the allowed at parent scheduler (id = %d dir = %s num of priorities = %d )\n",
                        p_tm_queue_cfg->data.priority , tm_sched_key.id, TM_SCHED_DIR_TO_STR(tm_sched_key.dir),
                        p_tm_sched_inst->req_tm_sched_info.data.num_priorities);
                
                ret = BCM_ERR_PARM;
                break;
            }
        }     
        else
            if(BCMBAL_TM_SCHED_TYPE_WFQ == p_tm_sched_inst->req_tm_sched_info.data.sched_type)
            {
                if(!BCMBAL_CFG_PROP_IS_SET(p_tm_queue_cfg, tm_queue, weight))
                {
                    BCM_LOG(ERROR, log_id_tm_queue, "Queue must be set with a weight, as its scheduler' sched_type sched_type is wfq\n");
                    ret = BCM_ERR_PARM;
                    break;
                }
                if(BCMBAL_CFG_PROP_IS_SET(p_tm_queue_cfg, tm_queue, priority))
                {
                    BCM_LOG(ERROR, log_id_tm_queue, "Queue can not be set with a priority, as its scheduler' sched_type sched_type is wfq \n");
                    ret = BCM_ERR_PARM;
                    break;
                }
            }
        else
            if(BCMBAL_TM_SCHED_TYPE_SP_WFQ == p_tm_sched_inst->req_tm_sched_info.data.sched_type)
            {
                if(BCMBAL_CFG_PROP_IS_SET(p_tm_queue_cfg, tm_queue, priority)
                    && BCMBAL_CFG_PROP_IS_SET(p_tm_queue_cfg, tm_queue, weight))
                {
                    BCM_LOG(ERROR, log_id_tm_queue, "Queue must be set with either weight or priority, not both. as its scheduler' sched_type is sp_wfq\n");
                    ret = BCM_ERR_PARM;
                    break;
                }        
                if(!BCMBAL_CFG_PROP_IS_SET(p_tm_queue_cfg, tm_queue, priority)
                    && !BCMBAL_CFG_PROP_IS_SET(p_tm_queue_cfg, tm_queue, weight))
                {
                    BCM_LOG(ERROR, log_id_tm_queue, "Queue must be set with either weight or priority, as its scheduler' sched_type is sp_wfq\n");
                    ret = BCM_ERR_PARM;
                    break;
                }
            }
        }while(0);
    return ret;
}

/*****************************************************************************/
/**
 * @brief A function called by the core worker thread to process an
 *        tm_queue object message (SET, GET, CLEAR, STATS) received
 *        from the BAL Public API.
 *
 * @param msg_payload      Pointer to a BAL message received from the
 *                         BAL Public API.
 *
 * @returns bcmos_errno
 *****************************************************************************/
bcmos_errno process_tm_queue_object(void *msg_payload)
{
    bcmos_errno ret = BCM_ERR_OK;	
    bcmbal_tm_queue_cfg *p_tm_queue_cfg = (bcmbal_tm_queue_cfg *)msg_payload;
    tm_queue_inst *p_tm_queue_inst = NULL;
    tm_queue_fsm_event fsm_event;
    bcmbal_tm_queue_key tm_queue_key;
    bcmbal_obj_msg_type oper_type;
    bcmbal_tm_sched_key tm_sched_key;    
    tm_sched_inst *p_tm_sched_inst = NULL;
    bcmbal_interface_key intf_key;
    bcmbal_tm_sched_owner owner;
	
    BUG_ON(NULL == msg_payload);
    
    BCM_LOG(DEBUG, log_id_tm_queue,  "Processing a tm queue object\n");
    
    tm_queue_key = p_tm_queue_cfg->key;   
    oper_type = p_tm_queue_cfg->hdr.hdr.type;
    
    /*
    * A message pointer may be passed inside the event structure.
    */
    fsm_event.msg = msg_payload;
    
    /* SET or GET or CLEAR...? */
    switch(oper_type)
    {
        case(BCMBAL_OBJ_MSG_TYPE_SET):
        {
            do
            {
                BCM_LOG(DEBUG, log_id_tm_queue,  "Processing a tm queue SET REQ mgmt message\n");
                if(BCMBAL_STATUS_UP != acc_term_status_get())
                {
                    BCM_LOG(ERROR, log_id_tm_queue, "ERROR - Access-terminal is not UP. No further processing\n");
                    ret = BCM_ERR_STATE;
                    break;
                }

                /*Find the specified tm_queue instance is already created */
                p_tm_queue_inst = tm_queue_inst_get(tm_queue_key, TM_QUEUE_FLAG_ACTIVE);
				
                if(NULL != p_tm_queue_inst)
                {
                    /* This is a fatal error condition */
                    BCM_LOG(ERROR, log_id_tm_queue,
                        "ERROR - tm queue found.  Set after create is currently not supported. No further processing\n");
                    ret = BCM_ERR_NOT_SUPPORTED;
                    break;
                }
				
                p_tm_queue_inst = tm_queue_inst_get(tm_queue_key, TM_QUEUE_FLAG_FREE);
                if(NULL == p_tm_queue_inst )
                {
                    /* This is a fatal error condition */
                    BCM_LOG(ERROR, log_id_tm_queue,
                        "ERROR - tm queue not found.  No further processing\n");
                    ret = BCM_ERR_NOMEM;
                    break;
                }
				if(BCM_ERR_OK != (ret = bcmbal_tm_queue_validate(p_tm_queue_cfg)))
								  {
									  BCM_LOG(ERROR, log_id_tm_queue, "tm_queue fsm validation Failed (%d)\n", ret);
									  tm_queue_free_by_entry(p_tm_queue_inst);
									  break;
								  }
								  
								  
								  /* Perform the validation check(s) that the utils require */
								  if(BCM_ERR_OK != (ret = sw_util_tm_queue_validate(p_tm_queue_cfg)))
								  {
									  BCM_LOG(ERROR, log_id_tm_queue, "tm_queue switch validation Failed (%d)\n", ret);
									  tm_queue_free_by_entry(p_tm_queue_inst);
									  break;
								  }

				

				BCM_LOG(DEBUG, log_id_tm_queue,
					"Creating a new tm queue\n");
			
            }while(0);
			
            ret = mgmt_msg_send_balapi_rsp(ret, msg_payload, oper_type, log_id_tm_queue);
            
            if(BCM_ERR_OK != ret )
            {
                break;
            }
			
            BCMBAL_CFG_PROP_SET(p_tm_queue_cfg, tm_queue, creation_mode, BCMBAL_TM_CREATION_MODE_MANUAL);
            
            bcmbal_tm_queue_object_overlay(&p_tm_queue_inst->api_req_tm_queue_info, p_tm_queue_cfg);
            
            fsm_event.event_type = TM_QUEUE_FSM_EVENT_TYPE_CREATE;
            fsm_event.msg = msg_payload;
            ret = tm_queue_fsm_exec(p_tm_queue_inst,&fsm_event);
        }
        break;
		
        case(BCMBAL_OBJ_MSG_TYPE_GET):
        {        
            BCM_LOG(DEBUG, log_id_tm_queue,  "Processing a tm queue GET REQ mgmt message\n");
            if(BCMBAL_STATUS_UP != acc_term_status_get())
            {
                BCM_LOG(ERROR, log_id_tm_queue, "ERROR - Access-terminal is not UP.  No further processing\n");
                ret = BCM_ERR_STATE;
            }
            else
            {
            /* Find the specified tm_queue instance */
                p_tm_queue_inst = tm_queue_inst_get(tm_queue_key, TM_QUEUE_FLAG_ACTIVE);
            }
            
            if(NULL == p_tm_queue_inst)
            {
                BCM_LOG(ERROR, log_id_tm_queue,  "ERROR - Specified tm_queue (%d) not found\n", tm_queue_key.id);
                ret =  BCM_ERR_NOENT;
                
           	}
            else
            {
                /* We respond to the BAL public API backend with a result. We always
                            * send a complete msg_payload back to the API, but the data portion
                            * of the object is only relevant when a GET or GET-STATS has been requested */
                p_tm_queue_inst->api_req_tm_queue_info.hdr.hdr.comm_hdr = ((bcmbal_obj *)msg_payload)->comm_hdr;
                *((bcmbal_tm_queue_cfg *)msg_payload) = p_tm_queue_inst->api_req_tm_queue_info;
            }            
            mgmt_msg_send_balapi_rsp(ret, msg_payload, oper_type, log_id_tm_queue);
        }
        break;
        
        case(BCMBAL_OBJ_MSG_TYPE_CLEAR):
        {
            do
            {
                BCM_LOG(DEBUG, log_id_tm_queue,  "Processing a tm queue CLEAR REQ mgmt message\n");
                if(BCMBAL_STATUS_UP != acc_term_status_get())
                {
                    BCM_LOG(ERROR, log_id_tm_queue, "ERROR - Access-terminal is not UP.  No further processing\n");
                    ret = BCM_ERR_STATE;
                    break;
                }
                /*
                * Find the specified tm_queue instance
                */
                p_tm_queue_inst = tm_queue_inst_get(tm_queue_key, TM_QUEUE_FLAG_ACTIVE);
                
                if(NULL == p_tm_queue_inst)
                {
                    BCM_LOG(ERROR, log_id_tm_queue, "Specified tm_queue not found on CLEAR\n");
                    ret = BCM_ERR_NOENT;
                    break;                
                }
				

                if(TM_QUEUE_FSM_STATE_IN_USE == p_tm_queue_inst->fsm_state)
                {
                    BCM_LOG(ERROR, log_id_tm_queue, "Specified tm_queue is in use and can not be removed\n");
                    ret = BCM_ERR_PARM;
                    break;
                }

				/*TM_QUEUEs (either auto or manually created) that are associated with a TM_NODE with owner interface 
				may only be deleted when the associated interface is in the ADMIN-DOWN state*/
			    tm_sched_key.id = tm_queue_key.sched_id;
				tm_sched_key.dir = tm_queue_key.sched_dir;
				
				p_tm_sched_inst = tm_sched_inst_get(tm_sched_key, TM_SCHED_FLAG_ACTIVE);
				if(NULL == p_tm_sched_inst)
                {
					BCM_LOG(ERROR, log_id_tm_queue,  "ERROR: no related tm_sched found (id = %d dir = %s)\n",
													   tm_sched_key.id, TM_SCHED_DIR_TO_STR(tm_sched_key.dir));
					ret = BCM_ERR_NOENT;
                    break;
                }
				if(BCMBAL_CFG_PROP_IS_SET(&(p_tm_sched_inst->req_tm_sched_info), tm_sched, owner))
				{
					owner = p_tm_sched_inst->req_tm_sched_info.data.owner;
					switch(owner.type)
					{
                        case BCMBAL_TM_SCHED_OWNER_TYPE_INTERFACE:
                        {
							intf_key.intf_type = owner.u.interface.intf_type;
							intf_key.intf_id = owner.u.interface.intf_id;
							if(BCMBAL_STATUS_DOWN != bcmbal_interface_status_get(intf_key))
							{
								BCM_LOG(ERROR, log_id_tm_queue, "Specified tm_queue is attached to sched that is owned by interface that is not admin down, and can be removed only when the associated interface is in the ADMIN-DOWN state\n");
								ret = BCM_ERR_PARM;
								break;	   
							}		
                       	}
						break;

						default:
							break;
					}
				}

                /*generate destroy event*/
                
                fsm_event.event_type = TM_QUEUE_FSM_EVENT_TYPE_DESTROY;
                fsm_event.msg = msg_payload;
                ret = tm_queue_fsm_exec(p_tm_queue_inst,&fsm_event);
                
            }while(0);
            mgmt_msg_send_balapi_rsp(ret, msg_payload, oper_type, log_id_tm_queue);			
        }
        break;

        default:
        {
            BCM_LOG(ERROR, log_id_tm_queue,  "Unsupported operation on tm queue object (%d)\n", oper_type );
            ret = BCM_ERR_NOT_SUPPORTED;
            
            /* We respond to the BAL public API backend with a result. We always
            * send a complete msg_payload back to the API, but the data portion
            * of the object is only relevant when a GET or GET-STATS has been requested.
            */
            mgmt_msg_send_balapi_rsp(ret, msg_payload, oper_type, log_id_tm_queue);
        }
    }
    
    BCM_LOG(DEBUG, log_id_tm_queue, "%s returns\n", __FUNCTION__);
    return ret;

}

bcmos_errno bcmbal_tm_queue_auto_create(bcmbal_tm_queue_cfg cfg)
{
    bcmos_errno ret = BCM_ERR_OK;
    tm_queue_inst *p_tm_queue_inst = NULL;
    do
    {
        /*Find a free tm_queue instance */
        p_tm_queue_inst = tm_queue_inst_get(cfg.key, TM_QUEUE_FLAG_FREE);
        if(NULL == p_tm_queue_inst)
        {
            /* This is a fatal error condition*/
            BCM_LOG(ERROR, log_id_tm_queue,"ERROR - tm queue not found.  No further processing\n");
            ret = BCM_ERR_NOMEM;
            break;
        }
        p_tm_queue_inst->api_req_tm_queue_info = cfg;
        ret = bcmbal_tm_queue_create(p_tm_queue_inst,NULL, NULL);
    }while(0);
    return ret;
}

bcmos_errno bcmbal_tm_queue_activate(tm_queue_inst *p_tm_queue_inst)
{
    bcmos_errno ret = BCM_ERR_OK;
    do
    {

        ret = sw_util_tm_queue_set(p_tm_queue_inst);
        if(BCM_ERR_OK != ret)
        {
            BCM_LOG(ERROR, log_id_tm_queue, "queue	could not be set by switch\n");
            break;
        }

        p_tm_queue_inst->fsm_state = TM_QUEUE_FSM_STATE_ACTIVE; 
        /* The hardware has properly accepted the object info, so the request object becomes
        * the current state.
        */
        bcmbal_tm_queue_object_overlay(&p_tm_queue_inst->current_tm_queue_info,
            &p_tm_queue_inst->api_req_tm_queue_info);
    
    }while(0);
    return ret;

}

bcmos_errno bcmbal_tm_queue_deactivate(tm_queue_inst *p_tm_queue_inst)
{
    bcmos_errno ret = BCM_ERR_OK;
    
    BUG_ON(NULL == p_tm_queue_inst);
    
    do
    {
        ret = sw_util_tm_queue_clear(p_tm_queue_inst);
        if(BCM_ERR_OK != ret)
        {
            BCM_LOG(ERROR, log_id_tm_queue, "queue	could not be set by switch\n");
            break;
        }
        p_tm_queue_inst->fsm_state = TM_QUEUE_FSM_STATE_INACTIVE;     
    }while(0);
    return ret;

}
static bcmos_errno bcmbal_tm_queue_create(tm_queue_inst *p_tm_queue_inst, 
										   void *msg, 
										   tm_queue_fsm_event *p_event)
{
    bcmos_errno ret = BCM_ERR_OK;
    do
    {
        p_tm_queue_inst->fsm_state = TM_QUEUE_FSM_STATE_INACTIVE;

        /*referenced tm sched exist for sure as it was already validated*/
        ret = bcmbal_tm_sched_set_queue(p_tm_queue_inst);        
        if(BCM_ERR_OK != ret)
        {
            BCM_LOG(ERROR, log_id_tm_queue, "queue  could not be attched to node \n");
            break;
        }
    }while(0);
    return ret;

}

bcmos_errno bcmbal_tm_queue_set_owner(bcmbal_tm_queue_key key)
{
    bcmos_errno ret = BCM_ERR_OK;
    tm_queue_inst *p_tm_queue_inst;
    do
    {
        p_tm_queue_inst = tm_queue_inst_get(key,TM_QUEUE_FLAG_ACTIVE);
        if(NULL == p_tm_queue_inst)
        {
            BCM_LOG(ERROR, log_id_tm_queue,"ERROR - tm queue not found.  No further processing\n");
            ret = BCM_ERR_NOENT;
            break;
        }
        ret = bcmbal_tm_queue_activate(p_tm_queue_inst);
    }while(0);
    return ret;
}

bcmos_errno bcmbal_tm_queue_unset_owner(bcmbal_tm_queue_key key)
{
    bcmos_errno ret = BCM_ERR_OK;    
    tm_queue_inst *p_tm_queue_inst;
    do
    {
        p_tm_queue_inst = tm_queue_inst_get(key,TM_QUEUE_FLAG_ACTIVE);
        if(NULL == p_tm_queue_inst)
        {
            BCM_LOG(ERROR, log_id_tm_queue,"ERROR - tm queue not found.  No further processing\n");
            ret = BCM_ERR_NOENT;
            break;
        }
        ret = bcmbal_tm_queue_deactivate(p_tm_queue_inst);
    
    }while(0);
    
    return ret;
}

bcmos_errno bcmbal_tm_queue_use_set(tm_queue_inst *p_tm_queue_inst, bcmos_bool is_in_use)
{
    bcmos_errno  ret = BCM_ERR_OK;
    
    BUG_ON(NULL == p_tm_queue_inst);
    if(is_in_use)
    {
        /*queue might already in requested state*/
        p_tm_queue_inst->fsm_state = TM_QUEUE_FSM_STATE_IN_USE;
        p_tm_queue_inst->api_req_tm_queue_info.data.ref_count++;
    }    
    else
    {
        if(p_tm_queue_inst->api_req_tm_queue_info.data.ref_count)
        {
            p_tm_queue_inst->api_req_tm_queue_info.data.ref_count--;
            
            if(0 == p_tm_queue_inst->api_req_tm_queue_info.data.ref_count)
            {
                p_tm_queue_inst->fsm_state = TM_QUEUE_FSM_STATE_ACTIVE;		
            }
        }
        else
        {
            BCM_LOG(ERROR, log_id_tm_queue, "queue (sched.id = %d sched.dir = %s queue.id = %d) could not be unset as no flows assign to it \n", p_tm_queue_inst->api_req_tm_queue_info.key.sched_id, TM_SCHED_DIR_TO_STR(p_tm_queue_inst->api_req_tm_queue_info.key.sched_dir), p_tm_queue_inst->api_req_tm_queue_info.key.id);
            ret = BCM_ERR_INTERNAL;
        }
    }
    return ret;
}

bcmos_errno bcmbal_tm_queue_destroy(tm_queue_inst *p_tm_queue_inst, bcmos_bool remove_from_node)
{
    bcmos_errno ret = BCM_ERR_OK;
    do
    {
        p_tm_queue_inst->fsm_state = TM_QUEUE_FSM_STATE_DELETING;
        if(remove_from_node)
        {
            ret = bcmbal_tm_sched_remove_queue(p_tm_queue_inst);
            if(BCM_ERR_OK != ret)
            {
                BCM_LOG(ERROR, log_id_tm_queue, "queue could not be cleaared from its tm sched\n");
            break;
            }
        }	
        ret = tm_queue_free_by_entry(p_tm_queue_inst);
    }while(0);
    return ret;
}

static bcmos_errno bcmbal_tm_queue_inactive_destroy(tm_queue_inst *p_tm_queue_inst, 
										   void *msg, 
										   tm_queue_fsm_event *p_event)
{
    return bcmbal_tm_queue_destroy(p_tm_queue_inst, BCMOS_TRUE);
}

static bcmos_errno bcmbal_tm_queue_active_destroy(tm_queue_inst *p_tm_queue_inst, 
										   void *msg, 
										   tm_queue_fsm_event *p_event)
{
    bcmos_errno ret = BCM_ERR_OK;
    do
    {
        p_tm_queue_inst->fsm_state = TM_QUEUE_FSM_STATE_DELETING;
        ret = sw_util_tm_queue_clear(p_tm_queue_inst);
        if(BCM_ERR_OK != ret)
        {
            BCM_LOG(ERROR, log_id_tm_queue, "queue could not be cleaared from the switch\n");
            break;
        }
        ret = bcmbal_tm_queue_inactive_destroy(p_tm_queue_inst, msg, p_event);
    }while(0);
    return ret;
}
/*@}*/