android-2.0.1_r1/s

/** \file nrfsm.c
 *  \brief non-recursive finite state machine source code
 *
 *  \see nrfsm.h
 */

 /****************************************************************************
**+-----------------------------------------------------------------------+**
**|                                                                       |**
**| Copyright(c) 1998 - 2008 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.  |**
**|                                                                       |**
**+-----------------------------------------------------------------------+**
****************************************************************************/

/***************************************************************************/
/*                                                                         */
/*      MODULE: fsm.c                                                      */
/*    PURPOSE:  Finite State Machine source code                           */
/*                                                                         */
/***************************************************************************/

#include "osTIType.h"
#include "osApi.h"
#include "utils.h"
#include "nrfsm.h"

/* Constants */

/* Enumerations */

/* Typedefs */

/* Structures */

/** General NR-FSM structure */
typedef struct
{
    TI_HANDLE               hOs;                    /**< OS handle */
    nrfsm_matrix_t          matrix;                 /**< State\event matrix */
    UINT32                  uMaxNoOfStates;         /**< Max number of states in the matrix */
    UINT32                  uMaxNoOfEvents;         /**< Max number of events in the matrix */
    UINT32                  uActNoOfStates;         /**< Actual number of states in the matrix */
    UINT32                  uActNoOfEvents;         /**< Actual number of events in the matrix */
    UINT32                  uInAction;              /**< Number of handled events */
    UINT32                  state;                  /**< Current state */
    UINT32                  event;                  /**< Last event sent */
    void                   *pData;                  /**< Last event data */
    BOOL                    bEventPending;          /**< Event pending indicator */

} nrfsm_t;


/* External data definitions */

/* External functions definitions */

/* Function prototypes */

/**
*
* nrfsm_Init  - Initialize the FSM structure
*
* \b Description:
*
* Init The FSM structure. If matrix argument is NULL, allocate memory for
* new matrix.
*
* \b ARGS:
*
*  I   - hOs  - OS handler
*  O   - hFsm - the generated FSM module  \n
*  I   - uMaxNoOfStates - Number of states in the module \n
*  I   - uMaxNoOfEvents - Number of events in the module \n
*
* \b RETURNS:
*
*  OK on success, NOK on failure
*
* \sa fsm_Event
*/
TI_STATUS nrfsm_Create (TI_HANDLE  hOs,
                        TI_HANDLE *hFsm,
                        UINT32     uMaxNoOfStates,
                        UINT32     uMaxNoOfEvents)
{
    nrfsm_t *pFsm;

    /* Check for preliminary conditions */
    if (hFsm == NULL || uMaxNoOfStates == 0 || uMaxNoOfEvents == 0)
    {
        return NOK;
    }

    /* Allocate memory for FSM context */
    pFsm = (nrfsm_t *)os_memoryAlloc (hOs, sizeof(nrfsm_t));
    if (pFsm == NULL)
    {
        return NOK;
    }

    /* Allocate memory for FSM matrix */
    pFsm->matrix = (nrfsm_matrix_t)os_memoryAlloc (hOs, uMaxNoOfStates * uMaxNoOfEvents * sizeof(nrfsm_action_cell_t));
    if (pFsm->matrix == NULL)
    {
        os_memoryFree (hOs, pFsm, sizeof(nrfsm_t));
        return NOK;
    }

    /* Update pFsm structure with parameters */
    pFsm->uMaxNoOfStates = uMaxNoOfStates;
    pFsm->uMaxNoOfEvents = uMaxNoOfEvents;
    pFsm->hOs = hOs;

    *hFsm = (TI_HANDLE)pFsm;

    return OK;
}


/**
*
* nrfsm_Unload  - free all memory allocated to FSM structure
*
* \b Description:
*
* Unload the FSM structure.
*
* \b ARGS:
*
*  I   - hFsm - the generated FSM module handle \n
*
* \b RETURNS:
*
*  OK on success, NOK on failure
*
* \sa fsm_Event
*/
TI_STATUS nrfsm_Unload (TI_HANDLE hFsm)
{
    nrfsm_t *pFsm = (nrfsm_t *)hFsm;

    /* Check for preliminary conditions */
    if (pFsm == NULL)
    {
        return NOK;
    }

    /* Free memory of FSM matrix */
    if (pFsm->matrix != NULL)
    {
        os_memoryFree (pFsm->hOs,
                       pFsm->matrix,
                       pFsm->uMaxNoOfStates * pFsm->uMaxNoOfEvents * sizeof(nrfsm_action_cell_t));
    }

    /* Free memory for FSM context (no need to check for null) */
    os_memoryFree (pFsm->hOs, pFsm, sizeof(nrfsm_t));

    return OK;
}


/**
*
* fsm_Init  - Initialize the FSM structure
*
* \b Description:
*
* Init The FSM structure. If matrix argument is NULL, allocate memory for
* new matrix.
*
* \b ARGS:
*
*  O   - hFsm - the generated FSM module handle \n
*  I   - uActNoOfStates - Actual number of states in the module \n
*  I   - uActNoOfEvents - Actual number of events in the module \n
*  I/O - pMatrix - the state event matrix pointer
*
* \b RETURNS:
*
*  OK on success, NOK on failure
*
* \sa fsm_Event
*/
TI_STATUS nrfsm_Config (TI_HANDLE      hFsm,
                        nrfsm_matrix_t pMatrix,
                        UINT32         uActNoOfStates,
                        UINT32         uActNoOfEvents)
{
    nrfsm_t *pFsm = (nrfsm_t *)hFsm;

    /* Check for preliminary conditions */
    if (pFsm == NULL || pMatrix == NULL)
    {
        return NOK;
    }

    if (uActNoOfStates > pFsm->uMaxNoOfStates ||
        uActNoOfEvents > pFsm->uMaxNoOfEvents)
    {
        return NOK;
    }

    /* Copy matrix to FSM context */
    os_memoryCopy (pFsm->hOs,
                   pFsm->matrix,
                   pMatrix,
                   uActNoOfStates * uActNoOfEvents * sizeof(nrfsm_action_cell_t));

    /* Update pFsm structure with parameters */
    pFsm->uActNoOfStates = uActNoOfStates;
    pFsm->uActNoOfEvents = uActNoOfEvents;
    pFsm->uInAction = 0;
    pFsm->state = 0;

    return OK;
}


/**
*
* nrfsm_Event  - perform event transition in the matrix
*
* \b Description:
*
* Perform event transition in the matrix
*
* \b ARGS:
*
*  I   - hFsm - the generated FSM module handle handle \n
*  I   - event - event causing transition \n
*  I   - pData - data for activation function \n
*
* \b RETURNS:
*
*  OK on success, NOK on failure, 1 on pending in queue
*
* \sa fsm_Init
*/
TI_STATUS nrfsm_Event (TI_HANDLE hFsm, UINT32 event, void *pData)
{
    nrfsm_t *pFsm = (nrfsm_t *)hFsm;
    UINT32   uIndex;

    /* Check for FSM existance */
    if (pFsm == NULL)
    {
        return NOK;
    }

    /* Boundary check */
    if (pFsm->state >= pFsm->uActNoOfStates || event >= pFsm->uActNoOfEvents)
    {
        return NOK;
    }

    /* Store request action */
    pFsm->event = event;
    pFsm->pData = pData;
    pFsm->bEventPending = TRUE;
    /*pFsm->uInAction ++;*/

    /* If currently performing an action, return (requested event will be handled when current action is finished) */
    if (pFsm->uInAction > 0)
    {
        if (pFsm->uInAction > 1)
            return NOK;
        return (TI_STATUS)1;
    }

    /* Perform requested events (avoid recursion when an action sends another event to any SM) */
    while (pFsm->bEventPending/*pFsm->uInAction*/)
    {
        pFsm->uInAction ++;
        pFsm->bEventPending = FALSE;

        /* Calculate action cell index */
        uIndex = pFsm->state * pFsm->uActNoOfEvents + pFsm->event;

        /* Update current state */
        pFsm->state = pFsm->matrix[uIndex].nState;

        /* Activate transition function */
        (*pFsm->matrix[uIndex].fAction) (pFsm->pData);

        pFsm->uInAction --;
    }

    return OK;
}


/**
*
* nrfsm_SetState  - Set the initial state.
*
* \b Description:
*
* Set the initial state.
*
* \b ARGS:
*
*  I   - hFsm - the generated FSM module handle \n
*  I   - state - current state of the SM \n
*
* \b RETURNS:
*
*  OK on success, NOK on failure
*
* \sa
*/
TI_STATUS nrfsm_SetState (TI_HANDLE hFsm, UINT32 state)
{
    nrfsm_t *pFsm = (nrfsm_t *)hFsm;

    /* Boundary check */
    if (pFsm->state >= pFsm->uActNoOfStates)
    {
        return NOK;
    }
    else
    {
        pFsm->state = state;
        return OK;
    }
}


/**
*
* nrfsm_GetNextState  - Return the current state.
*
* \b Description:
*
* Return the current state.
*
* \b ARGS:
*
*  I   - hFsm - the generated FSM module handle \n
*  O   - state - current state of the SM \n
*
* \b RETURNS:
*
*  OK on success, NOK on failure
*
* \sa
*/
TI_STATUS nrfsm_GetState (TI_HANDLE hFsm, UINT32 *state)
{
    nrfsm_t *pFsm = (nrfsm_t *)hFsm;

    *state = pFsm->state;

    return OK;
}


/**
*
* nrfsm_GetNextState  - Return the next state for a given current state and an event.
*
* \b Description:
*
* Return the next state for a given current state and an event.
*
* \b ARGS:
*
*  I   - pFsm - the generated FSM module  \n
*  I   - event - event causing transition \n
*  O   - state - returned next state \n
*
* \b RETURNS:
*
*  OK on success, NOK on failure
*
* \sa
*/
TI_STATUS nrfsm_GetNextState (TI_HANDLE  hFsm, UINT32 event, UINT32 *state)
{
    nrfsm_t *pFsm = (nrfsm_t *)hFsm;

    if (pFsm != NULL)
    {
        if (pFsm->state < pFsm->uActNoOfStates && event < pFsm->uActNoOfEvents)
        {
            *state = pFsm->matrix[pFsm->state * pFsm->uActNoOfEvents + event].nState;
            return OK;
        }
    }

    return NOK;
}


/*TI_STATUS action_nop(void *pData)
{
    return OK;
}*/