source: svn/newcon3bcm2_21bu/magnum/basemodules/dbg/ucos_ii/bdbg_os_priv.c

/***************************************************************************
 *     Copyright (c) 2006-2010, Broadcom Corporation
 *     All Rights Reserved
 *     Confidential Property of Broadcom Corporation
 *
 *  THIS SOFTWARE MAY ONLY BE USED SUBJECT TO AN EXECUTED SOFTWARE LICENSE
 *  AGREEMENT  BETWEEN THE USER AND BROADCOM.  YOU HAVE NO RIGHT TO USE OR
 *  EXPLOIT THIS MATERIAL EXCEPT SUBJECT TO THE TERMS OF SUCH AN AGREEMENT.
 *
 * $brcm_Revision: Hydra_Software_Devel/1 $
 * $brcm_Date: 7/19/10 2:47p $
 * $brcm_Workfile: bdbg_os_priv.c $
 *
 * Module Description:
 *
 * Revision History:
 *
 * $brcm_Log: /magnum/basemodules/dbg/ucos_ii/bdbg_os_priv.c $
 * 
 * Hydra_Software_Devel/1   7/19/10 2:47p jfisher
 * SW7572-30:  Add ucos_ii support.
 * 
 * Hydra_Software_Devel/1   7/19/10 1:05p jfisher
 * SW7572-30:  Add ucos_ii support.
 * 
 * Hydra_Software_Devel/6   3/20/09 4:24p cnovak
 * PR51415: Fix release build compile warnings. Detab file.
 * 
 * Hydra_Software_Devel/5   2/18/09 11:22a cnovak
 * PR51415: In BDBG_P_Lock/Unlock, call bkni's CHECK_CRITICAL to know
 * whether or not to mutex lock.
 * 
 * Hydra_Software_Devel/4   1/26/09 5:20p cnovak
 * PR51415: rework bdbg_os_priv interface to not suggest BKNI_EventHandle
 * usage in BDBG_P_Lock, which must lock in both task and isr contexts
 * 
 * Hydra_Software_Devel/3   1/21/09 2:50p cnovak
 * PR24626: Now that assert checks have been added to bkni for context
 * validity, BDBG_P_Lock/Unlock can not use the BKNI interface for its
 * mutex.
 * 
 * Hydra_Software_Devel/2   6/19/08 4:05p cnovak
 * PR43697: Move to Hydra branch.
 * 
 * Platform_Software_Devel/3   7/31/06 5:21p cnovak
 * PR12841: Add support for task-mode uC/OS driver.
 * 
 * Platform_Software_Devel/2   5/17/06 6:11p cnovak
 * PR21065: Add BDBG_P_Lock/Unlock
 * 
 * Platform_Software_Devel/1   3/8/06 1:07p cnovak
 * PR 12841: From HDI97401_Integration
 * 
 ***************************************************************************/

/* uCOS include files */
#include "bos.h"
 
#include "bstd.h"
#include "bkni.h"
#include "bdbg_os_priv.h"

/****************************************************************************
    Global functions
****************************************************************************/
/* tap into bkni's function to check for a BKNI critical section. It's ugly,
   but there is no BKNI standard interface to do this.
*/
/* 
        JPF - The PI often calls BDBG_MSG which calls BDBG_P_Lock in critical sections 
        BDBG_P_Lock uses a mutex which causes scheduling which is not legal in a real 
        critical section.  One possible workaround is to not do real critical sections.
        The current workaround is to have CHECK_CRITICAL return true when uCos 
        OSLockNesting > 0.
  */
extern unsigned char OSLockNesting;
extern unsigned char OSIntNesting;
#define CHECK_CRITICAL() ( bos_in_interrupt() || (OSLockNesting > 0) || (OSIntNesting > 0))

/****************************************************************************
    Static data
****************************************************************************/
/* platform spefic type for timestamps */
static unsigned int initTicks;
/* OS-specific mutex */
static b_mutex_t g_BdbgMutex;
static b_mutex_t *g_pBdbgMutex = NULL;

/****************************************************************************
****************************************************************************/
void
BDBG_P_InitializeTimeStamp(void)
{
    initTicks = bos_getticks();
}

/****************************************************************************
****************************************************************************/
void
BDBG_P_GetTimeStamp(char *timeStamp, int size_t)
{
    unsigned int currentTicks;
    int milliseconds;

    currentTicks = bos_getticks();

    milliseconds = (currentTicks - initTicks)*(1000/g_ticks_per_second);

    /* print the formatted time including the milliseconds  */
    BKNI_Snprintf(timeStamp, size_t, "%08u", milliseconds);
    return;
}

/****************************************************************************
****************************************************************************/
BERR_Code 
BDBG_P_OsInit(void)
{
    BERR_Code rc;
    
    /* This lock needs to work between both ISR and Task contexts. We're using
       a mutex because we only have a tiny amount of code running in ISR 
       context -- the L1 handler -- and we don't expect it to need the BDBG 
       lock.
       
       The lock is only used when a debug module is registered for the first
       time.
       
       We need to go directly to the OS for our mutex because we have code
       in BKNI which checks to make sure no one is trying to call AcquireMutex
       from within a Magnum ISR context. 
    */
    if (g_pBdbgMutex != NULL) {
#if 0
        rc = BERR_TRACE(BERR_UNKNOWN);
        BKNI_Fail();
#else
                return BERR_SUCCESS;
#endif
    }

        if (bos_create_mutex(&g_BdbgMutex) != BERR_SUCCESS)
        {
        rc = BERR_TRACE(BERR_OS_ERROR);
        BKNI_Fail();
        }

    g_pBdbgMutex = &g_BdbgMutex;
    
    return BERR_SUCCESS;
}

/****************************************************************************
****************************************************************************/
void 
BDBG_P_OsUninit(void)
{
    /* No way to release kernel object in uCOS */
    BKNI_Printf("%s: uCOS Event Leak - no method to destroy semaphore\n", __FUNCTION__);
    if (g_pBdbgMutex) {
                bos_delete_mutex(g_pBdbgMutex);
                g_pBdbgMutex = NULL;
        }
}

/****************************************************************************
****************************************************************************/
void 
BDBG_P_Lock(void)
{
    unsigned char ucosError;

    if (g_pBdbgMutex == NULL) {
        ucosError = BERR_TRACE(BERR_NOT_INITIALIZED);
        return;
    }
    
    if (CHECK_CRITICAL()) {
        return;
    }
    
    /* Wait forever on this mutex */
    bos_acquire_mutex(g_pBdbgMutex,BOS_PEND_FOREVER); 
}

/****************************************************************************
****************************************************************************/
void 
BDBG_P_Unlock(void)
{
    BERR_Code rc;

    if (g_pBdbgMutex == NULL) {
        rc = BERR_TRACE(BERR_NOT_INITIALIZED);
        return;
    }

    if (CHECK_CRITICAL()) {
        return;
    }

    bos_release_mutex(g_pBdbgMutex);
}

/* End of file */