path: root/wl1271/stad/src/Sta_Management/scr.c

/*
 * scr.c
 *
 * Copyright(c) 1998 - 2009 Texas Instruments. All rights reserved.      
 * All rights reserved.                                                  
 *                                                                       
 * Redistribution and use in source and binary forms, with or without    
 * modification, are permitted provided that the following conditions    
 * are met:                                                              
 *                                                                       
 *  * Redistributions of source code must retain the above copyright     
 *    notice, this list of conditions and the following disclaimer.      
 *  * Redistributions in binary form must reproduce the above copyright  
 *    notice, this list of conditions and the following disclaimer in    
 *    the documentation and/or other materials provided with the         
 *    distribution.                                                      
 *  * Neither the name Texas Instruments nor the names of its            
 *    contributors may be used to endorse or promote products derived    
 *    from this software without specific prior written permission.      
 *                                                                       
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS   
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT     
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT  
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT      
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT   
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/** \file  scr.c
 *  \brief This file include the SCR module implementation
 *
 *  \see   scr.h, scrApi.h
 */

#define __FILE_ID__  FILE_ID_82
#include "tidef.h"
#include "report.h"
#include "osApi.h"
#include "scr.h"
#include "DrvMainModules.h"


/*
 ***********************************************************************
 *  External data definitions.
 ***********************************************************************
 */

/**
 * \brief This array holds configuration values for abort others field for different clients.\n
 */
static EScrClientId abortOthers[ SCR_RESOURCE_NUM_OF_RESOURCES ][ SCR_CID_NUM_OF_CLIENTS ] = 
/* APP_SCAN           DRV_FG             CONT_SCAN          XCC_MSR            BASIC_MSR          CONNECT                IMMED_SCN              SWITCH_CHNL*/
{/* Serving channel resource */
 { SCR_CID_NO_CLIENT, SCR_CID_NO_CLIENT, SCR_CID_NO_CLIENT, SCR_CID_NO_CLIENT, SCR_CID_NO_CLIENT, SCR_CID_BASIC_MEASURE, SCR_CID_BASIC_MEASURE, SCR_CID_BASIC_MEASURE },
 /* periodic scan resource */
 { SCR_CID_NO_CLIENT, SCR_CID_APP_SCAN,  SCR_CID_NO_CLIENT, SCR_CID_NO_CLIENT, SCR_CID_NO_CLIENT, SCR_CID_DRIVER_FG_SCAN,SCR_CID_NO_CLIENT,     SCR_CID_NO_CLIENT }
};

/**
 * \brief This array holds configuration values for the client status field for different clients and groups. \n
 */
static TI_BOOL clientStatus[ SCR_RESOURCE_NUM_OF_RESOURCES ][ SCR_MID_NUM_OF_MODES ][ SCR_GID_NUM_OF_GROUPS ][ SCR_CID_NUM_OF_CLIENTS ] = 
            { 
                {/* serving channel resource */
                    {/* This is the table for Normal mode  */
                        /* client status for idle group */
                        { TI_FALSE,    /**< client status for SCR_CID_APP_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_DRIVER_FG_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_CONT_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_XCC_MEASURE */
                          TI_FALSE,    /**< client status for SCR_CID_BASIC_MEASURE */
                          TI_FALSE,    /**< client status for SCR_CID_CONNECT */
                          TI_FALSE,    /**< client status for SCR_CID_IMMED_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_SWITCH_CHANNEL */ },
                       /* client status for DRV scan group */
                        { TI_TRUE,     /**< client status for SCR_CID_APP_SCAN */
                          TI_FALSE,     /**< client status for SCR_CID_DRIVER_FG_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_CONT_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_XCC_MEASURE */
                          TI_FALSE,    /**< client status for SCR_CID_BASIC_MEASURE */
                          TI_FALSE,    /**< client status for SCR_CID_CONNECT */
                          TI_FALSE,    /**< client status for SCR_CID_IMMED_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_SWITCH_CHANNEL */ },
                       /* client status for APP scan group */
                        { TI_TRUE,     /**< client status for SCR_CID_APP_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_DRIVER_FG_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_CONT_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_XCC_MEASURE */
                          TI_FALSE,    /**< client status for SCR_CID_BASIC_MEASURE */
                          TI_FALSE,    /**< client status for SCR_CID_CONNECT */
                          TI_FALSE,    /**< client status for SCR_CID_IMMED_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_SWITCH_CHANNEL */ },
                       /* client status for connect group */
                        { TI_FALSE,    /**< client status for SCR_CID_APP_SCAN */
                          TI_TRUE,     /**< client status for SCR_CID_DRIVER_FG_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_CONT_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_XCC_MEASURE */
                          TI_FALSE,    /**< client status for SCR_CID_BASIC_MEASURE */
                          TI_TRUE,     /**< client status for SCR_CID_CONNECT */
                          TI_FALSE,    /**< client status for SCR_CID_IMMED_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_SWITCH_CHANNEL */ },                       
                       /* client status for connected group */
                        { TI_TRUE,     /**< client status for SCR_CID_APP_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_DRIVER_FG_SCAN */
                          TI_TRUE,     /**< client status for SCR_CID_CONT_SCAN */
                          TI_TRUE,     /**< client status for SCR_CID_XCC_MEASURE */
                          TI_TRUE,     /**< client status for SCR_CID_BASIC_MEASURE */
                          TI_FALSE,    /**< client status for SCR_CID_CONNECT */
                          TI_FALSE,    /**< client status for SCR_CID_IMMED_SCAN */
                          TI_TRUE,     /**< client status for SCR_CID_SWITCH_CHANNEL */ },
                       /* client status for roaming group */
                        { TI_FALSE,    /**< client status for SCR_CID_APP_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_DRIVER_FG_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_CONT_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_XCC_MEASURE */
                          TI_FALSE,    /**< client status for SCR_CID_BASIC_MEASURE */
                          TI_TRUE,     /**< client status for SCR_CID_CONNECT */
                          TI_TRUE,     /**< client status for SCR_CID_IMMED_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_SWITCH_CHANNEL */ }
                    },

                    /* This is the table for the Soft gemini mode   */

                    { /* client status for idle group */
                        { TI_FALSE,    /**< client status for SCR_CID_APP_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_DRIVER_FG_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_CONT_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_XCC_MEASURE */
                          TI_FALSE,    /**< client status for SCR_CID_BASIC_MEASURE */
                          TI_FALSE,    /**< client status for SCR_CID_CONNECT */
                          TI_FALSE,    /**< client status for SCR_CID_IMMED_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_SWITCH_CHANNEL */ },
                       /* client status for DRV scan group */
                        { TI_TRUE,     /**< client status for SCR_CID_APP_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_DRIVER_FG_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_CONT_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_XCC_MEASURE */
                          TI_FALSE,    /**< client status for SCR_CID_BASIC_MEASURE */
                          TI_FALSE,    /**< client status for SCR_CID_CONNECT */
                          TI_FALSE,    /**< client status for SCR_CID_IMMED_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_SWITCH_CHANNEL */ },
                       /* client status for APP scan group */
                        { TI_TRUE,     /**< client status for SCR_CID_APP_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_DRIVER_FG_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_CONT_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_XCC_MEASURE */
                          TI_FALSE,    /**< client status for SCR_CID_BASIC_MEASURE */
                          TI_FALSE,    /**< client status for SCR_CID_CONNECT */
                          TI_FALSE,    /**< client status for SCR_CID_IMMED_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_SWITCH_CHANNEL */ },
                       /* client status for connect group */
                        { TI_FALSE,    /**< client status for SCR_CID_APP_SCAN */
                          TI_TRUE,     /**< client status for SCR_CID_DRIVER_FG_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_CONT_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_XCC_MEASURE */
                          TI_FALSE,    /**< client status for SCR_CID_BASIC_MEASURE */
                          TI_TRUE,     /**< client status for SCR_CID_CONNECT */
                          TI_FALSE,    /**< client status for SCR_CID_IMMED_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_SWITCH_CHANNEL */ },                       
                       /* client status for connected group */
                        { TI_TRUE,     /**< client status for SCR_CID_APP_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_DRIVER_FG_SCAN */
                          TI_TRUE,     /**< client status for SCR_CID_CONT_SCAN */
                          TI_TRUE,     /**< client status for SCR_CID_XCC_MEASURE */
                          TI_TRUE,     /**< client status for SCR_CID_BASIC_MEASURE */
                          TI_FALSE,    /**< client status for SCR_CID_CONNECT */
                          TI_FALSE,    /**< client status for SCR_CID_IMMED_SCAN */
                          TI_TRUE,     /**< client status for SCR_CID_SWITCH_CHANNEL */ },
                       /* client status for roaming group */
                        { TI_FALSE,    /**< client status for SCR_CID_APP_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_DRIVER_FG_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_CONT_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_XCC_MEASURE */
                          TI_FALSE,    /**< client status for SCR_CID_BASIC_MEASURE */
                          TI_TRUE,     /**< client status for SCR_CID_CONNECT */
                          TI_TRUE,     /**< client status for SCR_CID_IMMED_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_SWITCH_CHANNEL */ }
                    }
                },
                {/* periodic-scan resource */
                    {/* This is the table for Normal mode */
                        /* client status for idle group */
                        { TI_FALSE,    /**< client status for SCR_CID_APP_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_DRIVER_FG_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_CONT_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_XCC_MEASURE */
                          TI_FALSE,    /**< client status for SCR_CID_BASIC_MEASURE */
                          TI_FALSE,    /**< client status for SCR_CID_CONNECT */
                          TI_FALSE,    /**< client status for SCR_CID_IMMED_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_SWITCH_CHANNEL */ },
                       /* client status for DRV scan gorup */
                        { TI_FALSE,     /**< client status for SCR_CID_APP_SCAN */
                          TI_TRUE,     /**< client status for SCR_CID_DRIVER_FG_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_CONT_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_XCC_MEASURE */
                          TI_FALSE,    /**< client status for SCR_CID_BASIC_MEASURE */
                          TI_FALSE,    /**< client status for SCR_CID_CONNECT */
                          TI_FALSE,    /**< client status for SCR_CID_IMMED_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_SWITCH_CHANNEL */ },
                       /* client status for APP scan gorup */
                        { TI_TRUE,     /**< client status for SCR_CID_APP_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_DRIVER_FG_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_CONT_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_XCC_MEASURE */
                          TI_FALSE,    /**< client status for SCR_CID_BASIC_MEASURE */
                          TI_FALSE,    /**< client status for SCR_CID_CONNECT */
                          TI_FALSE,    /**< client status for SCR_CID_IMMED_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_SWITCH_CHANNEL */ },
                       /* client status for connect group */
                        { TI_FALSE,    /**< client status for SCR_CID_APP_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_DRIVER_FG_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_CONT_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_XCC_MEASURE */
                          TI_FALSE,    /**< client status for SCR_CID_BASIC_MEASURE */
                          TI_TRUE,     /**< client status for SCR_CID_CONNECT */
                          TI_FALSE,    /**< client status for SCR_CID_IMMED_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_SWITCH_CHANNEL */ },                       
                       /* client status for connected group */
                        { TI_FALSE,    /**< client status for SCR_CID_APP_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_DRIVER_FG_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_CONT_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_XCC_MEASURE */
                          TI_FALSE,    /**< client status for SCR_CID_BASIC_MEASURE */
                          TI_FALSE,    /**< client status for SCR_CID_CONNECT */
                          TI_FALSE,    /**< client status for SCR_CID_IMMED_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_SWITCH_CHANNEL */ },
                       /* client status for roaming group */
                        { TI_FALSE,    /**< client status for SCR_CID_APP_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_DRIVER_FG_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_CONT_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_XCC_MEASURE */
                          TI_FALSE,    /**< client status for SCR_CID_BASIC_MEASURE */
                          TI_TRUE,     /**< client status for SCR_CID_CONNECT */
                          TI_FALSE,    /**< client status for SCR_CID_IMMED_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_SWITCH_CHANNEL */ }
                    },

                    /* This is the table for the Soft gemini mode   */

                    { /* client status for idle group */
                        { TI_FALSE,    /**< client status for SCR_CID_APP_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_DRIVER_FG_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_CONT_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_XCC_MEASURE */
                          TI_FALSE,    /**< client status for SCR_CID_BASIC_MEASURE */
                          TI_FALSE,    /**< client status for SCR_CID_CONNECT */
                          TI_FALSE,    /**< client status for SCR_CID_IMMED_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_SWITCH_CHANNEL */ },
                       /* client status for DRV scan gorup */
                        { TI_FALSE,    /**< client status for SCR_CID_APP_SCAN */
                          TI_TRUE,     /**< client status for SCR_CID_DRIVER_FG_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_CONT_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_XCC_MEASURE */
                          TI_FALSE,    /**< client status for SCR_CID_BASIC_MEASURE */
                          TI_FALSE,    /**< client status for SCR_CID_CONNECT */
                          TI_FALSE,    /**< client status for SCR_CID_IMMED_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_SWITCH_CHANNEL */ },
                       /* client status for APP scan gorup */
                        { TI_TRUE,     /**< client status for SCR_CID_APP_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_DRIVER_FG_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_CONT_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_XCC_MEASURE */
                          TI_FALSE,    /**< client status for SCR_CID_BASIC_MEASURE */
                          TI_FALSE,    /**< client status for SCR_CID_CONNECT */
                          TI_FALSE,    /**< client status for SCR_CID_IMMED_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_SWITCH_CHANNEL */ },
                       /* client status for connect group */
                        { TI_FALSE,    /**< client status for SCR_CID_APP_SCAN */
                          TI_FALSE,     /**< client status for SCR_CID_DRIVER_FG_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_CONT_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_XCC_MEASURE */
                          TI_FALSE,    /**< client status for SCR_CID_BASIC_MEASURE */
                          TI_TRUE,     /**< client status for SCR_CID_CONNECT */
                          TI_FALSE,    /**< client status for SCR_CID_IMMED_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_SWITCH_CHANNEL */ },                       
                       /* client status for connected group */
                        { TI_FALSE,    /**< client status for SCR_CID_APP_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_DRIVER_FG_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_CONT_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_XCC_MEASURE */
                          TI_FALSE,    /**< client status for SCR_CID_BASIC_MEASURE */
                          TI_FALSE,    /**< client status for SCR_CID_CONNECT */
                          TI_FALSE,    /**< client status for SCR_CID_IMMED_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_SWITCH_CHANNEL */ },
                       /* client status for roaming group */
                        { TI_FALSE,    /**< client status for SCR_CID_APP_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_DRIVER_FG_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_CONT_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_XCC_MEASURE */
                          TI_FALSE,    /**< client status for SCR_CID_BASIC_MEASURE */
                          TI_TRUE,     /**< client status for SCR_CID_CONNECT */
                          TI_FALSE,    /**< client status for SCR_CID_IMMED_SCAN */
                          TI_FALSE,    /**< client status for SCR_CID_SWITCH_CHANNEL */ }
                    }
                }                
            };

                
/**
 * \\n
 * \date 01-Dec-2004\n
 * \brief Creates the SCR object
 *
 * Function Scope \e Public.\n
 * \param hOS - handle to the OS object.\n
 * \return a handle to the SCR object.\n
 */
TI_HANDLE scr_create( TI_HANDLE hOS )
{
    /* allocate the SCR object */
    TScr    *pScr = os_memoryAlloc( hOS, sizeof(TScr));

    if ( NULL == pScr )
    {
        WLAN_OS_REPORT( ("ERROR: Failed to create SCR module"));
        return NULL;
    }

    /* store the OS handle */
    pScr->hOS = hOS;

    return pScr;
}

/**
 * \\n
 * \date 01-Dec-2004\n
 * \brief Finalizes the SCR object (freeing memory)
 *
 * Function Scope \e Public.\n
 * \param hScr - handle to the SCR object.\n
 */
void scr_release( TI_HANDLE hScr )
{
    TScr    *pScr = (TScr*)hScr;

    os_memoryFree( pScr->hOS, hScr, sizeof(TScr));
}

/**
 * \\n
 * \date 01-Dec-2004\n
 * \brief Initializes the SCR object
 *
 * \param  pStadHandles  - The driver modules handles
 * \return void  
 */
void scr_init (TStadHandlesList *pStadHandles)
{
    TScr        *pScr = (TScr*)(pStadHandles->hSCR);
    TI_UINT32   i, j;

    /* store the report object */
    pScr->hReport = pStadHandles->hReport;

    /* mark current group as idle */
    pScr->currentGroup = SCR_GID_IDLE;

    /* mark current mode as normal */
    pScr->currentMode = SCR_MID_NORMAL;

    /* signal not within request process */
    pScr->statusNotficationPending = TI_FALSE;

    /* mark that no client is currently running */
    for (i = 0; i < SCR_RESOURCE_NUM_OF_RESOURCES; i++)
    {
        pScr->runningClient[ i ] = SCR_CID_NO_CLIENT;
    }

    /* initialize client array */
    for (i = 0; i < SCR_CID_NUM_OF_CLIENTS; i++ )
    {
        for (j = 0; j < SCR_RESOURCE_NUM_OF_RESOURCES; j++)
        {
            pScr->clientArray[ i ].state[ j ] = SCR_CS_IDLE;
            pScr->clientArray[ i ].currentPendingReason[ j ] = SCR_PR_NONE;
        }
        pScr->clientArray[ i ].clientRequestCB = NULL;
        pScr->clientArray[ i ].ClientRequestCBObj = NULL;
    }
    
    TRACE0(pScr->hReport, REPORT_SEVERITY_INIT , ".....SCR configured successfully\n");
}

/**
 * \\n
 * \date 01-Dec-2004\n
 * \brief Registers the callback function to be used per client.
 *
 * Function Scope \e Public.\n
 * \param hScr - handle to the SCR object.\n
 * \param client - the client ID.\n
 * \param callbackFunc - the address of the callback function to use.\n
 * \param callbackObj - the handle of the object to pass to the callback function (the client object).\n
 */
void scr_registerClientCB( TI_HANDLE hScr, 
                           EScrClientId client,
                           TScrCB callbackFunc, 
                           TI_HANDLE callbackObj )
{
    TScr    *pScr = (TScr*)hScr;

#ifdef TI_DBG
    if (client >= SCR_CID_NUM_OF_CLIENTS)
    {
        TRACE1( pScr->hReport, REPORT_SEVERITY_ERROR, "Attempting to register callback for invalid client %d\n", client);
        return;
    }
#endif
    pScr->clientArray[ client ].clientRequestCB = callbackFunc;
    pScr->clientArray[ client ].ClientRequestCBObj = callbackObj;
}

/**
 * \\n
 * \date 01-Dec-2004\n
 * \brief Notifies the running process upon a firmware reset.
 *
 * Function Scope \e Public.\n
 * \param hScr - handle to the SCR object.\n
 */
void scr_notifyFWReset( TI_HANDLE hScr )
{
    TScr        *pScr = (TScr*)hScr;
    TI_UINT32   uResourceIndex;

    /* check both resources */
    for (uResourceIndex = 0; uResourceIndex < SCR_RESOURCE_NUM_OF_RESOURCES; uResourceIndex++)
    {
        /* if a client is currently running, notify it of the recovery event */
        if ( SCR_CID_NO_CLIENT != pScr->runningClient[ uResourceIndex ] )
        {
            TRACE1( pScr->hReport, REPORT_SEVERITY_INFORMATION, "FW reset occured. Client %d Notified.\n", pScr->runningClient[ uResourceIndex ]);
            if ( NULL != pScr->clientArray[ pScr->runningClient[ uResourceIndex ] ].clientRequestCB )
            {
                pScr->clientArray[ pScr->runningClient[ uResourceIndex ] ].clientRequestCB( pScr->clientArray[ pScr->runningClient[ uResourceIndex ] ].ClientRequestCBObj,
                                                                                          SCR_CRS_FW_RESET, uResourceIndex, SCR_PR_NONE );
            }
            else
            {
                TRACE1( pScr->hReport, REPORT_SEVERITY_ERROR, "Trying to call client %d callback, which is NULL\n", pScr->runningClient[ uResourceIndex ]);
            }
        }
    #ifdef TI_DBG
        else
        {
            TRACE0( pScr->hReport, REPORT_SEVERITY_INFORMATION, "FW reset occured. No client was running.\n");
        }
    #endif
    }
}

/**
 * \\n
 * \date 27-April-2005\n
 * \brief Changes the current SCR group.\n
 *
 * Function Scope \e Public.\n
 * \param hScr - handle to the SCR object.\n
 * \param newGroup - the new group to use.\n
 */
void scr_setGroup( TI_HANDLE hScr, EScrGroupId newGroup )
{
    TScr            *pScr = (TScr*)hScr;
    TI_UINT32       i, uResourceIndex;
    EScrClientId    highestPending;

    TRACE1( pScr->hReport, REPORT_SEVERITY_INFORMATION, "Setting group %d.\n", newGroup);

#ifdef TI_DBG
    if (newGroup >= SCR_GID_NUM_OF_GROUPS)
    {
        TRACE1( pScr->hReport, REPORT_SEVERITY_ERROR, "Attempting to set invalid group to %d\n", newGroup);
        return;
    }
#endif

    /* keep the new group */
    pScr->currentGroup = newGroup;

    /* check both resources */
    for (uResourceIndex = 0; uResourceIndex < SCR_RESOURCE_NUM_OF_RESOURCES; uResourceIndex++)
    {
        /* for all pending clients */
        for ( i = 0; i < SCR_CID_NUM_OF_CLIENTS; i++ )
        {
            /* if the pending reason has escalated */
            if ( (pScr->clientArray[ i ].state[ uResourceIndex ] == SCR_CS_PENDING) && /* the client is pending */
                 (pScr->clientArray[ i ].currentPendingReason[ uResourceIndex ] < SCR_PR_DIFFERENT_GROUP_RUNNING) && /* the client was enabled in the previous group */
                 (TI_FALSE == clientStatus[ uResourceIndex ][ pScr->currentMode ][ newGroup ][ i ])) /* the client is not enabled in the new group */
            {
                /* mark the new pending reason */
                pScr->clientArray[ i ].currentPendingReason[ uResourceIndex ] = SCR_PR_DIFFERENT_GROUP_RUNNING;

                /* notify the client of the change, using its callback */
                if ( NULL != pScr->clientArray[ i ].clientRequestCB )
                {
                    pScr->clientArray[ i ].clientRequestCB( pScr->clientArray[ i ].ClientRequestCBObj, 
                                                            SCR_CRS_PEND, uResourceIndex, SCR_PR_DIFFERENT_GROUP_RUNNING );
                }
                else
                {
                    TRACE1( pScr->hReport, REPORT_SEVERITY_ERROR, "Trying to call client %d callback, which is NULL\n", i);
                }
            }
        }
    

        /*
         * if no client is running call the highest pending client 
         * (after group change, previously pending clients may be enabled)
         */
        if ( SCR_CID_NO_CLIENT == pScr->runningClient[ uResourceIndex ] )
        {
            highestPending = scrFindHighest( hScr, SCR_CS_PENDING, uResourceIndex, 
                                             (SCR_CID_NUM_OF_CLIENTS - 1), 0 );
            if (( SCR_CID_NO_CLIENT != highestPending ) && (highestPending < SCR_CID_NUM_OF_CLIENTS))
            {
                pScr->clientArray[ highestPending ].state[ uResourceIndex ] = SCR_CS_RUNNING;
                pScr->clientArray[ highestPending ].currentPendingReason[ uResourceIndex ] = SCR_PR_NONE;
                pScr->runningClient[ uResourceIndex ] = (EScrClientId)highestPending;
                if ( NULL != pScr->clientArray[ highestPending ].clientRequestCB )
                {
                    pScr->clientArray[ highestPending ].clientRequestCB( pScr->clientArray[ highestPending ].ClientRequestCBObj, 
                                                                         SCR_CRS_RUN, uResourceIndex, SCR_PR_NONE );
                }
                else
                {
                    TRACE1( pScr->hReport, REPORT_SEVERITY_ERROR, "Trying to call client %d callback, which is NULL\n", highestPending);
                }
            }
        }
    }
}

/**
 * \\n
 * \date 23-Nov-2005\n
 * \brief Changes the current SCR mode.\n
 *
 * Function Scope \e Public.\n
 * \param hScr - handle to the SCR object.\n
 * \param newMode - the new mode to use.\n
 */
void scr_setMode( TI_HANDLE hScr, EScrModeId newMode )
{
	TScr            *pScr = (TScr*)hScr;
#ifdef SCR_ABORT_NOTIFY_ENABLED
    TI_UINT32       i, uResourceIndex;
    EScrClientId    highestPending;
#endif

    TRACE1( pScr->hReport, REPORT_SEVERITY_INFORMATION, "Setting mode %d.\n", newMode);

#ifdef TI_DBG
    if (newMode >= SCR_MID_NUM_OF_MODES)
    {
        TRACE1( pScr->hReport, REPORT_SEVERITY_ERROR, "Attempting to set invalid mode to %d\n", newMode);
        return;
    }
#endif

    /* keep the new mode */
    pScr->currentMode = newMode;

#ifdef SCR_ABORT_NOTIFY_ENABLED

    for (uResourceIndex = 0; uResourceIndex < SCR_RESOURCE_NUM_OF_RESOURCES; uResourceIndex++)
    {
        /* Stage I : if someone is running and shouldn't be running in the new mode - Abort it */
        if ( (SCR_CID_NO_CLIENT != pScr->runningClient[ uResourceIndex ]) && 
             (TI_FALSE == clientStatus[ uResourceIndex ][ pScr->currentMode ][ pScr->currentGroup ][ pScr->runningClient[ uResourceIndex ] ]))
        {
            /* abort the running client */
            pScr->clientArray[ pScr->runningClient[ uResourceIndex ] ].state[ uResourceIndex ] = SCR_CS_ABORTING;
            if ( NULL != pScr->clientArray[ pScr->runningClient[ uResourceIndex ] ].clientRequestCB )
            {
                TRACE2( pScr->hReport, REPORT_SEVERITY_INFORMATION, "Sending abort request to client %d for resource %d\n", pScr->runningClient[ uResourceIndex ], uResourceIndex);
                pScr->clientArray[ pScr->runningClient[ uResourceIndex ] ].clientRequestCB( pScr->clientArray[ pScr->runningClient[ uResourceIndex ] ].ClientRequestCBObj,
                                                                                            SCR_CRS_ABORT,
                                                                                            uResourceIndex,
                                                                                            SCR_PR_NONE );
            }
            else
            {
                TRACE1( pScr->hReport, REPORT_SEVERITY_ERROR, "Trying to call client %d callback, which is NULL\n", pScr->runningClient[ uResourceIndex ]);
            }
        }
    
        /* Stage II : notify escalated pending reason */
        /* for all pending clients */
        for ( i = 0; i < SCR_CID_NUM_OF_CLIENTS; i++ )
        {
            /* if the pending reason has escalated */
            if ( (pScr->clientArray[ i ].state[ uResourceIndex ] == SCR_CS_PENDING) && /* the client is pending */
                 (pScr->clientArray[ i ].currentPendingReason[ uResourceIndex ] < SCR_PR_DIFFERENT_GROUP_RUNNING) && /* the client was enabled in the previous group */
                 (TI_FALSE == clientStatus[ uResourceIndex ][ pScr->currentMode ][ pScr->currentGroup ][ i ])) /* the client is not enabled in the new group/mode */
            {
                /* mark the new pending reason */
                pScr->clientArray[ i ].currentPendingReason[ uResourceIndex ] = SCR_PR_DIFFERENT_GROUP_RUNNING;
                
                /* notify the client of the change, using its callback */
                if ( NULL != pScr->clientArray[ i ].clientRequestCB )
                {
                    pScr->clientArray[ i ].clientRequestCB( pScr->clientArray[ i ].ClientRequestCBObj, 
                                                            SCR_CRS_PEND, uResourceIndex, 
                                                            SCR_PR_DIFFERENT_GROUP_RUNNING );
                }
                else
                {
                    TRACE1( pScr->hReport, REPORT_SEVERITY_ERROR, "Trying to call client %d callback, which is NULL\n", i);
                }
            }
        }
    
       
        /* Stage III : call Highest Pending Client who is enabled in the new mode   */
        if ( SCR_CID_NO_CLIENT == pScr->runningClient[ uResourceIndex ] )
        {
            highestPending = scrFindHighest( hScr, SCR_CS_PENDING, uResourceIndex, 
                                             (SCR_CID_NUM_OF_CLIENTS - 1), 0 );
            if (SCR_CID_NO_CLIENT != highestPending)
            {
                pScr->clientArray[ highestPending ].state[ uResourceIndex ] = SCR_CS_RUNNING;
                pScr->clientArray[ highestPending ].currentPendingReason[ uResourceIndex ] = SCR_PR_NONE;
                pScr->runningClient[ uResourceIndex ] = (EScrClientId)highestPending;
                if ( NULL != pScr->clientArray[ highestPending ].clientRequestCB )
                {
                    pScr->clientArray[ highestPending ].clientRequestCB( pScr->clientArray[ highestPending ].ClientRequestCBObj, 
                                                                         SCR_CRS_RUN, uResourceIndex,
                                                                         SCR_PR_NONE );
                }
                else
                {
                    TRACE1( pScr->hReport, REPORT_SEVERITY_ERROR, "Trying to call client %d callback, which is NULL\n", highestPending);
                }
            }
        }
    }
#endif	/* SCR_ABORT_NOTIFY_ENABLED */ 
}


/**
 * \\n
 * \date 01-Dec-2004\n
 * \brief Request the channel use by a client
 *
 * Function Scope \e Public.\n
 * \param hScr - handle to the SCR object.\n
 * \param client - the client ID requesting the channel.\n
 * \param resource - the requested resource.\n
 * \param pPendReason - the reason for a pend reply.\n
 * \return The request status.\n
 * \retval SCR_CRS_REJECT the channel cannot be allocated to this client.
 * \retval SCR_CRS_PEND the channel is currently busy, and this client had been placed on the waiting list.
 * \retval SCR_CRS_RUN the channel is allocated to this client.
 */
EScrClientRequestStatus scr_clientRequest( TI_HANDLE hScr, EScrClientId client,
                                           EScrResourceId eResource, EScePendReason* pPendReason )
{
    TScr    *pScr = (TScr*)hScr;

    TRACE2( pScr->hReport, REPORT_SEVERITY_INFORMATION, "scr_clientRequest: Client %d requesting the channel for resource %d.\n", client, eResource);

#ifdef TI_DBG
    if (client >= SCR_CID_NUM_OF_CLIENTS)
    {
        TRACE1( pScr->hReport, REPORT_SEVERITY_ERROR, "Attempting to request SCR for invalid client %d\n", client);
        return SCR_CRS_PEND;
    }
    if (SCR_RESOURCE_NUM_OF_RESOURCES <= eResource)
    {
        TRACE2( pScr->hReport, REPORT_SEVERITY_ERROR, "Attempting to request SCR by client %d for invalid resource %d\n", client, eResource);
        return SCR_CRS_PEND;
    }
#endif
    
    *pPendReason = SCR_PR_NONE;

    /* check if already inside a request - shouldn't happen!!! */
    if ( TI_TRUE == pScr->statusNotficationPending )
    {
        TRACE0( pScr->hReport, REPORT_SEVERITY_ERROR, "request call while already in request!\n");
        return SCR_CRS_PEND;
    }

    /* check if current running client is requesting */
    if ( client == pScr->runningClient[ eResource ] )
    {
        TRACE2( pScr->hReport, REPORT_SEVERITY_WARNING, "Client %d re-requesting SCR for resource %d\n", client, eResource);
        return SCR_CRS_RUN;
    }

    TRACE5( pScr->hReport, REPORT_SEVERITY_INFORMATION, "scr_clientRequest: is client enabled = %d. eResource=%d,currentMode=%d,currentGroup=%d,client=%d,\n", clientStatus[ eResource ][ pScr->currentMode ][ pScr->currentGroup ][ client ], eResource, pScr->currentMode, pScr->currentGroup, client);

    /* check if the client is enabled in the current group */
    if ( TI_TRUE != clientStatus[ eResource ][ pScr->currentMode ][ pScr->currentGroup ][ client ])
    {
        pScr->clientArray[ client ].state[ eResource ] = SCR_CS_PENDING;
        pScr->clientArray[ client ].currentPendingReason[ eResource ]
                                                = *pPendReason = SCR_PR_DIFFERENT_GROUP_RUNNING;
        return SCR_CRS_PEND;
    }
        
    /* check if a there's no running client at the moment */
    if ( SCR_CID_NO_CLIENT == pScr->runningClient[ eResource ] )
    {
        /* no running or aborted client - allow access */
        TRACE2( pScr->hReport, REPORT_SEVERITY_INFORMATION, "Resource %d allocated to client: %d\n", eResource, client);
        pScr->clientArray[ client ].state[ eResource ] = SCR_CS_RUNNING;
        pScr->runningClient[ eResource ] = client;
        return SCR_CRS_RUN;
    }
    
    /* check if any client is aborting at the moment */
    if ( SCR_CS_ABORTING == pScr->clientArray[ pScr->runningClient[ eResource ] ].state[ eResource ] )
    {
        /* a client is currently aborting, but there still might be a pending client with higher priority
           than the client currently requesting the SCR. If such client exists, the requesting client is
           notified that it is pending because of this pending client, rather than the one currently aborting.
        */
        EScrClientId highestPending;
        highestPending = scrFindHighest( hScr, SCR_CS_PENDING, eResource, 
                                         (SCR_CID_NUM_OF_CLIENTS - 1), client );
        if ( (SCR_CID_NO_CLIENT == highestPending) ||
             (highestPending < client))
        {
            /* if the requesting client has higher priority than the current highest priority pending client,
               the current highest priority pending client should be notified that its pending reason has 
               changed (it is no longer waiting for current running client to abort, but for the requesting
               client to finish, once the current has aborted */
            if ( (highestPending != SCR_CID_NO_CLIENT) &&
                 (SCR_PR_OTHER_CLIENT_ABORTING == pScr->clientArray[ highestPending ].currentPendingReason[ eResource ]))
            {

                if ( NULL != pScr->clientArray[ highestPending ].clientRequestCB )
                {
                    pScr->clientArray[ highestPending ].clientRequestCB( pScr->clientArray[ highestPending ].ClientRequestCBObj,
                                                                         SCR_CRS_PEND, eResource, SCR_PR_OTHER_CLIENT_RUNNING );
                }
                else
                {
                    TRACE1( pScr->hReport, REPORT_SEVERITY_ERROR, "Trying to call client %d callback, which is NULL\n", highestPending);
                }
            }
            pScr->clientArray[ client ].currentPendingReason[ eResource ] = *pPendReason = SCR_PR_OTHER_CLIENT_ABORTING;
        }
        else
        {
            pScr->clientArray[ client ].currentPendingReason[ eResource ] = *pPendReason = SCR_PR_OTHER_CLIENT_RUNNING;
        }
        pScr->clientArray[ client ].state[ eResource ] = SCR_CS_PENDING;
        return SCR_CRS_PEND;
    }
 
    /* check if a client with higher priority is running */
    if (pScr->runningClient[ eResource ] > client)
    {
        pScr->clientArray[ client ].state[ eResource ] = SCR_CS_PENDING;
        pScr->clientArray[ client ].currentPendingReason[ eResource ] = *pPendReason = SCR_PR_OTHER_CLIENT_RUNNING;
        return SCR_CRS_PEND;
    }

    /* if the client is not supposed to abort lower priority clients */
    if ( (SCR_CID_NO_CLIENT == abortOthers[ eResource ][ client ]) || /* client is not supposed to abort any other client */
         (pScr->runningClient[ eResource ] > abortOthers[ eResource ][ client ])) /* client is not supposed to abort running client */
    {
        /* wait for the lower priority client */
        pScr->clientArray[ client ].state[ eResource ] = SCR_CS_PENDING;
        pScr->clientArray[ client ].currentPendingReason[ eResource ] = *pPendReason = SCR_PR_OTHER_CLIENT_RUNNING;
        return SCR_CRS_PEND;
    }

    /* at this point, there is a lower priority client running, that should be aborted: */
    /* mark the requesting client as pending (until the abort process will be completed) */
    pScr->clientArray[ client ].state[ eResource ] = SCR_CS_PENDING;

    /* mark that we are in the middle of a request (if a re-entrance will occur in the complete) */
    pScr->statusNotficationPending = TI_TRUE;

    /* abort the running client */
    pScr->clientArray[ pScr->runningClient[ eResource ] ].state[ eResource ] = SCR_CS_ABORTING;
    if ( NULL != pScr->clientArray[ pScr->runningClient[ eResource ] ].clientRequestCB )
    {
        TRACE2( pScr->hReport, REPORT_SEVERITY_INFORMATION, "Sending abort request to client %d for resource %d\n", pScr->runningClient[ eResource ], eResource);
        pScr->clientArray[ pScr->runningClient[ eResource ] ].clientRequestCB( pScr->clientArray[ pScr->runningClient[ eResource ] ].ClientRequestCBObj,
                                                                               SCR_CRS_ABORT, eResource,
                                                                               SCR_PR_NONE );
    }
    else
    {
        TRACE1( pScr->hReport, REPORT_SEVERITY_ERROR, "Trying to call client %d callback, which is NULL\n", pScr->runningClient[ eResource ]);
    }

    /* mark that we have finished the request process */
    pScr->statusNotficationPending = TI_FALSE;

    /* return the current status (in case the completion changed the client status to run) */
    if ( SCR_CS_RUNNING == pScr->clientArray[ client ].state[ eResource ] )
    {
        TRACE1( pScr->hReport, REPORT_SEVERITY_INFORMATION, "channel allocated to client: %d\n", client);
        return SCR_CRS_RUN;
    }
    else
    {
        pScr->clientArray[ client ].currentPendingReason[ eResource ] = *pPendReason = SCR_PR_OTHER_CLIENT_ABORTING;
        return SCR_CRS_PEND;
    }
}

/**
 * \\n
 * \date 01-Dec-2004\n
 * \brief Notifies the SCR that the client doe not require the channel any longer
 *
 * This function can be called both by clients that are in possession of the channel, and by
 * clients that are pending to use the channel.\n
 * Function Scope \e Public.\n
 * \param hScr - handle to the SCR object.\n
 * \param client - the client releasing the channel.\n
 * \param eResource - the resource being released.\n
 * \return TI_OK if successful, TI_NOK otherwise.\n
 */
void scr_clientComplete( TI_HANDLE hScr, EScrClientId client, EScrResourceId eResource )
{
    TScr            *pScr = (TScr*)hScr;
    EScrClientId    highestPending;

    TRACE2( pScr->hReport, REPORT_SEVERITY_INFORMATION, "Client %d releasing resource %d.\n", client, eResource);

#ifdef TI_DBG
    if (client >= SCR_CID_NUM_OF_CLIENTS)
    {
        TRACE1( pScr->hReport, REPORT_SEVERITY_ERROR, "Attempting to release SCR for invalid client %d\n", client);
        return;
    }
    if (SCR_RESOURCE_NUM_OF_RESOURCES <= eResource)
    {
        TRACE2( pScr->hReport, REPORT_SEVERITY_ERROR, "Attempting to release invalid resource %d by client %d\n", eResource, client);
        return;
    }
#endif

    /* mark client state as idle */
    pScr->clientArray[ client ].state[ eResource ] = SCR_CS_IDLE;
    pScr->clientArray[ client ].currentPendingReason[ eResource ] = SCR_PR_NONE;

    /* if completing client is running (or aborting) */
    if ( pScr->runningClient[ eResource ] == client )   
    {
        /* mark no running client */
        pScr->runningClient[ eResource ] = SCR_CID_NO_CLIENT;

        /* find the pending client with highest priority */
        highestPending = scrFindHighest( hScr, SCR_CS_PENDING, eResource, (SCR_CID_NUM_OF_CLIENTS-1), 0 );
    
        /* if a pending client exists */
        if (( SCR_CID_NO_CLIENT != highestPending ) && (highestPending < SCR_CID_NUM_OF_CLIENTS))
        {
            /* mark the client with highest priority as running */
            pScr->clientArray[ highestPending ].state[ eResource ] = SCR_CS_RUNNING;
            pScr->clientArray[ highestPending ].currentPendingReason[ eResource ] = SCR_PR_NONE;
            pScr->runningClient[ eResource ] = highestPending;
        
            /* if the SCR is not called from within a client request (re-entrance) */
            if ( TI_FALSE == pScr->statusNotficationPending )
            {
                if ( NULL != pScr->clientArray[ highestPending ].clientRequestCB )
                {
                    pScr->clientArray[ highestPending ].clientRequestCB( pScr->clientArray[ highestPending ].ClientRequestCBObj,
                                                                         SCR_CRS_RUN, eResource, SCR_PR_NONE );
                }
                else
                {
                    TRACE1( pScr->hReport, REPORT_SEVERITY_ERROR, "Trying to call client %d callback, which is NULL\n", highestPending);
                }
            }
        }
    }
}

/**
 * \\n
 * \date 01-Dec-2004\n
 * \brief Searches the client database for a client with matching state, from startFrom to endAt (inclusive).
 * \brief Only searches for clients that are enabled at the current group!!!!\n
 *
 * Function Scope \e Private.\n
 * \param hScr - handle to the SCR object.\n
 * \param requiredState - the state to match.\n
 * \param eResource - the resource to macth.\n
 * \param startFrom - the highest priority to begin searching from.\n
 * \param endAt - the lowest priority to include in the search 
 * \return the client ID if found, SCR_CID_NO_CLIENT if not found.\n
 */
EScrClientId scrFindHighest( TI_HANDLE hScr,
                             EScrClientState requiredState,
                             EScrResourceId  eResource,
                             TI_UINT32 startFrom,
                             TI_UINT32 endAt )
{
    TScr        *pScr = (TScr*)hScr;
    TI_INT32    i, iStartFrom, iEndAt;

    /* 
     * signed indexes are used to avoid an overflow in the for loop when endAt equals zero
     * and the unsigned i is "reduced" to overflow to 4 Billion
     */
    iStartFrom = (TI_INT32)startFrom;
    iEndAt = (TI_INT32)endAt;

    /* loop on all clients, from start to end */
    for ( i = iStartFrom; i >= iEndAt; i-- )
    {
        /* check if the client state matches the required state */
        if ( (TI_TRUE == clientStatus[ eResource ][ pScr->currentMode ][ pScr->currentGroup ][ i ]) && /* client is enabled in current group */
             (requiredState == pScr->clientArray[ i ].state[ eResource ])) /* client is in required state */
        {
            /* and if so, return the client index */
            return i;
        }
    }

    return SCR_CID_NO_CLIENT;
}