source: svn/trunk/newcon3bcm2_21bu/magnum/basemodules/mem/bmem_local.c @ 11

/***************************************************************************
 *     Copyright (c) 2002-2012, 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_Workfile: bmem_local.c $
 * $brcm_Revision: Hydra_Software_Devel/26 $
 * $brcm_Date: 2/7/12 6:36p $
 *
 * Module Description:
 *
 * Revision History:
 *
 * $brcm_Log: /magnum/basemodules/mem/bmem_local.c $
 * 
 * Hydra_Software_Devel/26   2/7/12 6:36p albertl
 * SW7425-2345: Changed total allocation and number of allocation tracking
 * to work in eFastest.
 * 
 * Hydra_Software_Devel/25   11/14/11 2:22p albertl
 * SW7425-1293: Fixed use of uncached address when cached addresses exist
 * during heap creation.  Fixed coverity issues.
 * 
 * Hydra_Software_Devel/24   9/9/11 7:10p albertl
 * SW7346-201: Moved watermark calculation to alloc and free for accurate
 * calculation.
 * 
 * Hydra_Software_Devel/23   3/28/11 5:12p albertl
 * SW7425-247: Incorporated BDBG_OBJECT handle validation.
 * 
 * Hydra_Software_Devel/22   1/10/11 3:32p albertl
 * SW7408-193: BMEM_Heapinfo now includes high watermark.  Added
 * BMEM_Heap_ResetHighWatermark().
 * 
 * Hydra_Software_Devel/21   11/8/10 4:48p albertl
 * SW7420-1155: Fixed size calculation to match fixed implementation of
 * pEnd.
 * 
 * Hydra_Software_Devel/20   11/4/10 7:39p albertl
 * SW7420-1155: Fixed pEnd to really be last available byte and addrEnd to
 * be last byte in chunk rather than byte after that.
 * 
 * Hydra_Software_Devel/19   5/26/09 4:18p albertl
 * PR55389: Replaced uintptr_t with uint32_t.
 * 
 * Hydra_Software_Devel/18   7/12/07 6:26p albertl
 * PR31066:  Updated warning message to give platform and user specified
 * uiAlignment size.
 * 
 * Hydra_Software_Devel/17   7/6/07 6:53p albertl
 * PR31066:  Changed BMEM_HEAP_ALIGNMENT to 6 for 7400 B0 and later and
 * 7405.  Added warnings when user specified alignment is less than and
 * forced to BMEM_HEAP_ALIGNMENT.
 * 
 * Hydra_Software_Devel/16   3/15/07 7:23p albertl
 * PR28682:  Changed BMEM_GUARD_SIZE_BYTES to be dynamically calculated
 * based on runtime safety config.
 * 
 * Hydra_Software_Devel/15   6/21/06 3:11p albertl
 * PR20247:  Moved safety config table to bmem.c  BMEM_P_Heap now uses a
 * BMEM_P_SafetyConfigInfo pointer to track safety configuration settings
 * instead of tracking each configuration separately.
 * 
 * Hydra_Software_Devel/14   6/16/06 3:23p albertl
 * PR20247, PR20276, PR20354:  Added the ability to control debug
 * configuration at runtime.  Added address and offset checking to
 * conversion functions.  BMEM_SetCache can now only be called before
 * heaps are allocated from.  Added BMEM_Heap functions.
 * 
 * Hydra_Software_Devel/13   10/7/05 3:53p jasonh
 * PR 17374: Allowed GetHeapInfo to return original creation parameters.
 * 
 * Hydra_Software_Devel/12   3/10/05 5:05p albertl
 * PR13677:  Both local and system bookkeeping made available at heap
 * creation though functions BMEM_CreateHeapSystem and
 * BMEM_CreateHeapLocal.
 * 
 * Hydra_Software_Devel/11   1/21/05 4:23p albertl
 * PR13717:  Replaced BMEM_DBG_ENTER with BDBG_ENTER.  Moved printouts to
 * DBG_MSG, fixed pvHeap.
 * 
 * Hydra_Software_Devel/10   11/2/04 5:27p pntruong
 * PR13076: Initialized new members added.
 *
 * Hydra_Software_Devel/9   4/1/04 12:49p vsilyaev
 * PR 10201: Added memory monitor
 *
 * Hydra_Software_Devel/8   12/31/03 12:02p jasonh
 * PR 8940: Changed return type of destroyheap to void. Removed use of
 * DEBUG macro and printf.
 *
 * Hydra_Software_Devel/7   9/15/03 5:21p jasonh
 * Fixed heap control to store offset and address. Added local specific
 * destroy heap function.
 *
 * Hydra_Software_Devel/6   9/5/03 2:04p jasonh
 * Changed Check to ValidateHeap.
 *
 * Hydra_Software_Devel/5   9/5/03 1:41p jasonh
 * Wrapped unused arguments with BSTD_UNUSED.
 *
 * Hydra_Software_Devel/4   9/2/03 1:48p vadim
 * Some magnum updates.
 *
 * Hydra_Software_Devel/2   3/20/03 3:51p erickson
 * renamed all MEM_ to BMEM_
 *
 * Hydra_Software_Devel/1   3/20/03 3:24p erickson
 * initial bmem work, taken from SetTop/memorylib
 *
 * SanJose_DVTSW_Devel\4   4/15/02 10:14p eric
 * BMEM_CheckHeap is dead.  Long live bcmHeapCheck.
 *
 * SanJose_DVTSW_Devel\3   4/15/02 3:34p poz
 * Updated function name to bcmHeapCreate.
 *
 * SanJose_DVTSW_Devel\2   4/15/02 2:29p poz
 * Modified to get semaphore when BMEM_REENTRANT.
 *
 * SanJose_DVTSW_Devel\1   4/15/02 1:35p poz
 * Implementation of local-memory heap manager.
 *
 ***************************************************************************/

#include "bstd.h"
#include "bmem.h"
#include "bmem_config.h"
#include "bmem_priv.h"
#include "bmem_debug.h"
#include "berr.h"

BDBG_MODULE(BMEM);

/**********************************************************************func*
 * BMEM_P_LocalGetAddress - Get the managed memory base address for a
 *                           block.
 *
 * Returns:
 *    0 if a NULL BlockInfo is given, otherwise the base address.
 */

uint32_t BMEM_P_LocalGetAddress
(
        BMEM_Handle pheap,
        BMEM_P_BlockInfo *pbi
)
{
        BSTD_UNUSED( pheap );
        return (uint32_t) pbi;
}

/**********************************************************************func*
 * BMEM_P_LocalGetBlockInfo - Get the bookkeeping info for a managed base
 *                             address.
 *
 * Local implementation just returns the address, being also the location
 * of the bookkeeping info.
 *
 * Returns:
 *    On success, a pointer to the BlockInfo for the managed base address.
 *
 */

BMEM_P_BlockInfo *BMEM_P_LocalGetBlockInfo
(
        BMEM_Handle pheap,
        uint32_t addr
)
{
        BSTD_UNUSED( pheap );
        return (BMEM_P_BlockInfo *) addr;
}

/**********************************************************************func*
 * BMEM_P_LocalDropBlockInfo -
 *    Free up the bookkeeping info for a managed memory base address
 *
 * Returns:
 *    void
 */

void BMEM_P_LocalDropBlockInfo
(
        BMEM_Handle pheap,
        BMEM_P_BlockInfo *pbi
)
{
        BSTD_UNUSED( pheap );
        BSTD_UNUSED( pbi );
        return;
}


/**********************************************************************func*
 * BMEM_CreateHeapLocal - Initializes the heap with local bookkeeping.
 *
 * This function inititalizes a heap at a given location and size.
 * Any previous allocations in the chunk of memory handed over to this
 * function are lost. Every heap has a base minimum alignment for all of
 * the allocations within that heap. (However, you can specify a greater
 * alignment when actually doing an allocation.)
 *
 * In this implementation, the first bit of the heap is used to store heap
 * information such as pointers to the free and used list, as well as other
 * bookkeeping information.
 *
 * Returns:
 *   Returns true if heap is initialized, or false if the given memory
 *   chunk is too small to be a heap.
 *
 */
BERR_Code BMEM_CreateHeapLocal
(
        BMEM_Handle  *ppHeap,      /* Address to store pointer of new heap info structure */
        void         *pvHeap,      /* Pointer to beginning of memory chunk to manage */
        uint32_t      ulOffset,    /* Device offset of initial location */
        size_t        zSize,       /* Size of chunk to manage in bytes */
        unsigned int  uiAlignment  /* Minimum alignment for all allocations in the heap */
)
{
        BMEM_Heap_Settings stHeapSettings;
        BMEM_Heap_Settings *pHeapSettings = &stHeapSettings;

        BMEM_Heap_GetDefaultSettings(pHeapSettings);

        pHeapSettings->uiAlignment = uiAlignment;
        pHeapSettings->eBookKeeping = BMEM_BOOKKEEPING_LOCAL;

        return (BMEM_Heap_Create(NULL, pvHeap, ulOffset, zSize, pHeapSettings, ppHeap));
}

BERR_Code BMEM_P_LocalCreateHeap
(
        BMEM_Handle        *ppHeap,      /* Address to store pointer of new heap info structure */
        void               *pvHeap,      /* Pointer to beginning of memory chunk to manage */
        uint32_t            ulOffset,    /* Device offset of initial location */
        size_t              zSize,       /* Size of chunk to manage in bytes */
        BMEM_Heap_Settings *pHeapSettings
)
{
        BERR_Code         err = BERR_SUCCESS;
        BMEM_Handle       pheap;
        BMEM_P_BlockInfo *pbi;
        uint32_t          addrHeap;
        uint32_t          addrEnd = (uint32_t)pvHeap + zSize - 1;
        unsigned int      uiAlignment = pHeapSettings->uiAlignment;
        size_t            ulAlignedSize;
        uint32_t          eSafetyConfig = pHeapSettings->eSafetyConfig;

        BDBG_ENTER(BMEM_P_LocalCreateHeap);
        BDBG_MSG(("BMEM_P_LocalCreateHeap(%p, %lu, %d)",
                pvHeap, zSize, (int)pHeapSettings->uiAlignment));

        if (pHeapSettings->eSafetyConfig > BMEM_P_SafetyTableSize)
        {
                /* Invalid safety config. */
                err = BERR_TRACE(BERR_INVALID_PARAMETER);
                goto done;
        }

        if (pHeapSettings->eSafetyConfig > BMEM_SAFETY_CONFIG)
        {
                /* Invalid run-time safety config. */
                        BDBG_ERR(("Run-time safety config cannot be higher than compiled safety config!"));
                        err = BERR_TRACE(BERR_INVALID_PARAMETER);
                goto done;
        }


        /*
         * The first bit of the heap is used to hold information about the heap
         * itself. This is forced to a 4-byte alignment if for some reason we
         * were given a non-aligned pointer.
         */
        addrHeap = BMEM_HEAP_ALIGN( pvHeap );
        if( addrEnd < addrHeap + sizeof **ppHeap - 1)
        {
                /* There is no way to use this as a heap. It's too small. */
                err = BERR_TRACE(BERR_OUT_OF_DEVICE_MEMORY);
                goto done;
        }

        /* get location of heap */
        *ppHeap = pheap = (BMEM_Handle) addrHeap;
        addrHeap += sizeof (*pheap);

        /* initialize heap */
        BDBG_OBJECT_SET(pheap, BMEM_Heap);
        pheap->pFreeTop = NULL;
        pheap->pAllocTop = NULL;
        pheap->ulAlignMask = 0;
        pheap->pStart = NULL;
        pheap->pEnd = NULL;
        pheap->ulNumErrors = 0;
        pheap->pvData = NULL;
        pheap->pvHeap = pvHeap;
        pheap->ulOffset = ulOffset;
        pheap->monitor = NULL;
        pheap->pvCache = pHeapSettings->pCachedAddress;
        pheap->pfFlushCb = pHeapSettings->flush;
        pheap->pfFlushCb_isr = pHeapSettings->flush_isr;
        pheap->zSize = zSize;
        pheap->ulNumAllocated = 0;
        pheap->ulTotalAllocated = 0;
        pheap->ulHighWatermark = 0;

        pheap->pSafetyConfigInfo = &(BMEM_P_SafetyConfigTbl[eSafetyConfig]);
        pheap->ulGuardSizeBytes  = pheap->pSafetyConfigInfo->iGuardSize * BMEM_GUARD_UNIT_BYTES;

        pheap->eBookKeeping = pHeapSettings->eBookKeeping;
        pheap->bCacheLocked = false;

        pheap->pGetAddressFunc = &BMEM_P_LocalGetAddress;
        pheap->pGetBlockInfoFunc = &BMEM_P_LocalGetBlockInfo;
        pheap->pDropBlockInfoFunc = &BMEM_P_LocalDropBlockInfo;
        pheap->pDestroyHeapFunc = &BMEM_P_LocalDestroyHeap;

#if (BMEM_REENTRANT_CONFIG==BMEM_REENTRANT)
        /* create mutex for re-entrant control */
        if(BKNI_CreateMutex(&(pheap->pMutex)) != BERR_SUCCESS)
        {
                err = BERR_OS_ERROR;
                goto done;
        }
#endif

        /*
         * The minimum alignment allowed is 4 bytes since that is the required
         * alignment for the bookkeeping information.
         */
        if(uiAlignment < BMEM_HEAP_ALIGNMENT)
        {
                BDBG_WRN(("uiAlignment %d less than platform minimum %d.  Setting alignment to minimum.", uiAlignment, BMEM_HEAP_ALIGNMENT));
                uiAlignment = BMEM_HEAP_ALIGNMENT;
        }
        pheap->uiAlignment = uiAlignment;
        pheap->ulAlignMask = (1L << uiAlignment) - 1;

        /* Align the heap to be on the requested alignment. */
        pheap->pStart = (uint8_t *)((addrHeap+pheap->ulAlignMask) & ~pheap->ulAlignMask);
        /* Last usable byte after alignment. */
        pheap->pEnd = (uint8_t *)(((addrEnd + 1) & ~pheap->ulAlignMask) - 1);

        /* Make the first block, which represents the remaining (free) heap */
        pbi = BMEM_P_LocalGetBlockInfo(pheap, (uint32_t)pheap->pStart);

        ulAlignedSize = pheap->pEnd-pheap->pStart+1;

        if(ulAlignedSize > BMEM_BOOKKEEPING_SIZE_LOCAL)
        {
                /* Create a free block representing the entire heap. */
                pbi->ulSize = ulAlignedSize;
                pbi->ulFrontScrap = 0;
                pbi->ulBackScrap = 0;
                pbi->pnext = NULL;
                BMEM_P_FillGuard(pheap, pbi);

                pheap->pFreeTop = pbi;
        }
        else
        {
                /* The chunk of memory we've been given is too small for a heap. */
                err = BERR_OS_ERROR;
        }

#if BMEM_CHECK_ALL_GUARDS
        if (pheap->pSafetyConfigInfo->bCheckAllGuards)
        {
                if (err)
                {
                        BMEM_ValidateHeap(pheap);
                }
        }
#endif

done:
        BDBG_MSG(("BMEM_P_LocalCreateHeap = %d", err));
        BDBG_LEAVE(BMEM_P_LocalCreateHeap);
        return err;
}

/***************************************************************************/
void BMEM_P_LocalDestroyHeap
(
        BMEM_Handle pheap
)
{
#if BMEM_CHECK_ALL_GUARDS
        BERR_Code  err;
#endif

        BDBG_OBJECT_ASSERT(pheap, BMEM_Heap);

#if BMEM_CHECK_ALL_GUARDS
        if (pheap->pSafetyConfigInfo->bCheckAllGuards)
        {
                /* validate heap */
                err = BERR_TRACE(BMEM_ValidateHeap(pheap));
                if (err != BERR_SUCCESS)
                {
                        /* error validating heap */
                        goto done;
                }
        }
#endif

        /* blocks still allocated? */
        if (pheap->pAllocTop)
        {
                /* leaked resource */
                BDBG_ERR(("Leaked resource -- unfreed blocks detected"));
        }

        BDBG_OBJECT_UNSET(pheap, BMEM_Heap);
#if (BMEM_REENTRANT_CONFIG==BMEM_REENTRANT)
        /* destroy mutex */
        BKNI_DestroyMutex(pheap->pMutex);
#endif

done:
        /* return */
        return;
}

/* End of File */