/*****************************************************************************
* 函 数 名 : bsp_sfree
*
* 功能描述 : BSP 动态内存释放(加spin lock保护,多核场景使用)
*
* 输入参数 : pMem: 动态内存指针
* 输出参数 : 无
* 返 回 值 : 无
*****************************************************************************/
void bsp_sfree(void* pMem)
{
u32 u32Size;
u32 u32Flags;
if(0 == *g_mem_init_mark)
{
return;
}
/* Invalid Cache */
if (!MEM_IS_AXI_ADDR(pMem))
{
MEM_INVALID_CACHE(MEM_GET_ALLOC_ADDR(pMem), MEM_MGR_SIZE_FOR_CACHE);
}
#ifdef __BSP_MEM_DEBUG__
/* 检查当前内存是否有效 */
if (bsp_ptr_invalid(pMem) ||
MEM_FREE == MEM_ITEM_STATUS(pMem) ||
MEM_ITEM_FLAGS(pMem) == MEM_NORM_DDR_POOL)
{
printk("warning! ptr:0x%x, invalid mem block, or may free twice, or wrong mem flags line:%d\n", (unsigned int)pMem, __LINE__);
return;
}
#endif
u32Size = MEM_ITEM_SIZE(pMem);
u32Flags = MEM_ITEM_FLAGS(pMem);
bsp_memory_free(u32Flags, pMem, u32Size);
return;
}
/*****************************************************************************
* 函 数 名 : bsp_free
*
* 功能描述 : BSP 动态内存释放
*
* 输入参数 : pMem: 动态内存指针
* 输出参数 : 无
* 返 回 值 : 无
*****************************************************************************/
void bsp_free(void* pMem)
{
#if 1
if(pMem)
/* coverity[freed_arg] */
kfree(pMem);
#else
u32 u32Size;
u32 u32Flags;
u32 u32MagicNumber;
MEM_SPIN_LOCK();
u32Size = MEM_ITEM_SIZE(pMem);
u32Flags = MEM_ITEM_FLAGS(pMem);
u32MagicNumber= MEM_ITEM_MAGIC(pMem);
MEM_SPIN_UNLOCK();
if(MEM_MAGIC_NUM != u32MagicNumber)
{
kfree(pMem);
}
else if(MEM_NORM_DDR_POOL < u32Flags)
{
bsp_memory_free(u32Flags, pMem, u32Size);
}
else
{
printk("bsp_free failed: pMem is 0x%x, u32MagicNumber is 0x%x, u32Flags is 0x%x\n",(u32)pMem, u32MagicNumber, u32Flags);
}
#endif
}
STATIC s32 bsp_mem_scan(u32 u32PoolType)
{
MEM_ALLOC_INFO* pAllocInfo = 0;
u32 u32CurScan = 0;
u32 u32EndAddr = 0;
u32 u32MgrSize = 0;
s32 s32GetChar = 0;
pAllocInfo = MEM_GET_ALLOC_INFO(u32PoolType);
if (u32PoolType >= MEM_POOL_MAX)
{
bsp_trace(BSP_LOG_LEVEL_ERROR, BSP_MODU_MEM,"invalid pool type:%d\n", u32PoolType);
return BSP_ERROR;
}
u32CurScan = pAllocInfo->memPoolInfo.u32BaseAddr;
u32MgrSize = pAllocInfo->memPoolInfo.u32MgrSize;
u32EndAddr = pAllocInfo->memPoolInfo.u32CurPosAddr;
bsp_trace(BSP_LOG_LEVEL_ERROR, BSP_MODU_MEM,"Beg Scan Mem (%s):\n", g_memPoolName[u32PoolType]);
bsp_trace(BSP_LOG_LEVEL_ERROR, BSP_MODU_MEM,"================================\n");
bsp_trace(BSP_LOG_LEVEL_ERROR, BSP_MODU_MEM,"mem pool info:\n");
bsp_trace(BSP_LOG_LEVEL_ERROR, BSP_MODU_MEM,"--------------------------------\n");
bsp_trace(BSP_LOG_LEVEL_ERROR, BSP_MODU_MEM,"Base Addr: 0x%x\n", pAllocInfo->memPoolInfo.u32BaseAddr);
bsp_trace(BSP_LOG_LEVEL_ERROR, BSP_MODU_MEM,"Total Size: %d(0x%x)\n", pAllocInfo->memPoolInfo.u32Size, pAllocInfo->memPoolInfo.u32Size);
bsp_trace(BSP_LOG_LEVEL_ERROR, BSP_MODU_MEM,"Left Size: %d(0x%x)\n", pAllocInfo->memPoolInfo.u32Left, pAllocInfo->memPoolInfo.u32Left);
bsp_trace(BSP_LOG_LEVEL_ERROR, BSP_MODU_MEM,"Cur Pos Addr: 0x%x\n", pAllocInfo->memPoolInfo.u32CurPosAddr);
bsp_trace(BSP_LOG_LEVEL_ERROR, BSP_MODU_MEM,"Mgr Size: %d\n", pAllocInfo->memPoolInfo.u32MgrSize);
bsp_trace(BSP_LOG_LEVEL_ERROR, BSP_MODU_MEM,"Most Used Item: %d\n", pAllocInfo->mostUsedItem);
bsp_trace(BSP_LOG_LEVEL_ERROR, BSP_MODU_MEM,"\n");
/* 扫描 MemPool */
while(u32CurScan < u32EndAddr)
{
/* 先拿到usr ptr */
u32CurScan += u32MgrSize;
/* 打印当前内存块信息 */
/*(void)bsp_mem_dump_block(u32CurScan);*/
/* 移动到下一个内存块 */
u32CurScan += MEM_ITEM_SIZE(u32CurScan);
bsp_trace(BSP_LOG_LEVEL_ERROR, BSP_MODU_MEM,"\npress \'Enter\' to continue, press \'q\' to stop scan\n");
/*lint -save -e666 -e586*/
/* coverity[returned_null] */
s32GetChar = getchar();
/*lint -restore*/
if(!s32GetChar)
{
bsp_trace(BSP_LOG_LEVEL_ERROR, BSP_MODU_MEM,"error! please input a valid char\n");
}
if ('q' == s32GetChar)
{
break;
}
}
return BSP_OK;
}
void* bsp_get_item(MEM_ALLOC_INFO* pAllocInfo, u32 cnt, u32 u32PoolType, u32 u32Size)
{
void *pItem;
void **ppHead = &(pAllocInfo->allocList[cnt]);
/* 如果链表中没有节点,则从内存池中分配 */
if (!*ppHead)
{
/* 判断是否达到最大个数 */
if((u32PoolType != MEM_ICC_DDR_POOL) || (pAllocInfo->allocNum[cnt] < sg_AllocMaxNum[cnt]))
{
/* 注意从内存池中分配的尺寸要额外包含 MGR 的部分 */
pItem = bsp_pool_alloc(pAllocInfo, u32Size+pAllocInfo->memPoolInfo.u32MgrSize);
if (NULL == pItem)
{
pAllocInfo->u32AllocFailCnt++;
return NULL;
}
MEM_ITEM_MAGIC(pItem) = (u32)MEM_MAGIC_NUM;
MEM_ITEM_SIZE(pItem) = u32Size;
MEM_ITEM_FLAGS(pItem) = u32PoolType;
if(MEM_ICC_DDR_POOL == u32PoolType)
{
pAllocInfo->allocNum[cnt]++;
}
#ifdef __BSP_MEM_DEBUG__
MEM_ITEM_FILE_NAME(pItem) = 0;
MEM_ITEM_LINE(pItem) = 0;
#endif
}
else
{
pAllocInfo->u32AllocFailCnt++;
return NULL;
}
}
/* 从链表中取出节点 */
else
{
pItem = (void*)PHY_TO_VIRT((unsigned int)*ppHead);
/* Invalid Cache */
MEM_INVALID_CACHE_BY_TYPE(MEM_GET_ALLOC_ADDR(pItem), MEM_MGR_SIZE_FOR_CACHE, u32PoolType);
*ppHead = (void*)MEM_ITEM_NEXT(pItem);
}
return pItem;
}
s32 bsp_mem_scan(u32 u32PoolType)
{
MEM_ALLOC_INFO* pAllocInfo = NULL;
u32 u32CurScan;
u32 u32EndAddr;
u32 u32MgrSize;
pAllocInfo = MEM_GET_ALLOC_INFO(u32PoolType);
if (u32PoolType >= MEM_POOL_MAX)
{
printk("invalid pool type:%d\n", u32PoolType);
return ERROR;
}
u32CurScan = pAllocInfo->memPoolInfo.u32BaseAddr;
u32MgrSize = pAllocInfo->memPoolInfo.u32MgrSize;
u32EndAddr = pAllocInfo->memPoolInfo.u32CurPosAddr;
printk("Beg Scan Mem (%s):\n", g_memPoolName[u32PoolType]);
printk("================================\n");
printk("mem pool info:\n");
printk("--------------------------------\n");
printk("Base Addr: 0x%x\n", pAllocInfo->memPoolInfo.u32BaseAddr);
printk("Total Size: %d(0x%x)\n", pAllocInfo->memPoolInfo.u32Size, pAllocInfo->memPoolInfo.u32Size);
printk("Left Size: %d(0x%x)\n", pAllocInfo->memPoolInfo.u32Left, pAllocInfo->memPoolInfo.u32Left);
printk("Cur Pos Addr: 0x%x\n", pAllocInfo->memPoolInfo.u32CurPosAddr);
printk("Mgr Size: %d\n", pAllocInfo->memPoolInfo.u32MgrSize);
printk("Most Used Item: %d\n", pAllocInfo->mostUsedItem);
printk("\n");
/* 扫描 MemPool */
while(u32CurScan < u32EndAddr)
{
/* 先拿到usr ptr */
u32CurScan += u32MgrSize;
/* 打印当前内存块信息 */
(void)bsp_mem_dump_block(u32CurScan);
/* 移动到下一个内存块 */
u32CurScan += MEM_ITEM_SIZE(u32CurScan);
printk("\npress \'Enter\' to continue, press \'q\' to stop scan\n");
}
return OK;
}
/*****************************************************************************
* 函 数 名 : bsp_sfree
*
* 功能描述 : BSP 动态内存释放(加spin lock保护,多核场景使用)
*
* 输入参数 : pMem: 动态内存指针
* 输出参数 : 无
* 返 回 值 : 无
*****************************************************************************/
void bsp_sfree(void* pMem)
{
u32 u32Size;
u32 u32Flags;
if(0 == *g_mem_init_mark)
{
return;
}
#ifdef __BSP_MEM_DEBUG__
if (bsp_ptr_invalid(pMem))
{
bsp_trace(BSP_LOG_LEVEL_ERROR, BSP_MODU_MEM,
"warning! ptr:0x%x, invalid mem block line:%d\n", pMem, __LINE__);
return;
}
#endif
/* Invalid Cache */
if (!MEM_IS_AXI_ADDR(pMem))
{
MEM_INVALID_CACHE(MEM_GET_ALLOC_ADDR(pMem), MEM_MGR_SIZE_FOR_CACHE);
}
#ifdef __BSP_MEM_DEBUG__
/* 检查当前内存是否有效 */
if (MEM_FREE == MEM_ITEM_STATUS(pMem))
{
bsp_trace(BSP_LOG_LEVEL_ERROR, BSP_MODU_MEM,
"warning! ptr:0x%x, may free twice, or wrong mem status line:%d\n", (unsigned int)pMem, __LINE__);
return;
}
#endif
u32Size = MEM_ITEM_SIZE(pMem);
u32Flags = MEM_ITEM_FLAGS(pMem);
bsp_memory_free(u32Flags, pMem, u32Size);
return;
}
STATIC s32 bsp_mem_dump_block(u32 u32Addr)
{
BSP_BOOL bBlockInvalid = FALSE;
bBlockInvalid = bBlockInvalid;
if (NULL == (void *)u32Addr)
{
bsp_trace(BSP_LOG_LEVEL_ERROR, BSP_MODU_MEM,"can't dump the block, the input ptr is NULL\n");
return BSP_ERROR;
}
if (MEM_MAGIC_NUM != MEM_ITEM_MAGIC(u32Addr))
{
bBlockInvalid = TRUE;
bsp_trace(BSP_LOG_LEVEL_ERROR, BSP_MODU_MEM,"The Block:0x%x may Invalid!\n", u32Addr);
}
/* 为确保正确,统一刷下Cache */
MEM_INVALID_CACHE(MEM_GET_ALLOC_ADDR(u32Addr), MEM_MGR_SIZE_FOR_CACHE);
bsp_trace(BSP_LOG_LEVEL_ERROR, BSP_MODU_MEM,"================================\n");
bsp_trace(BSP_LOG_LEVEL_ERROR, BSP_MODU_MEM,"dump mem block info:\n");
bsp_trace(BSP_LOG_LEVEL_ERROR, BSP_MODU_MEM,"================================\n");
bsp_trace(BSP_LOG_LEVEL_ERROR, BSP_MODU_MEM,"usr ptr: 0x%x\n", u32Addr);
bsp_trace(BSP_LOG_LEVEL_ERROR, BSP_MODU_MEM,"alloc ptr: 0x%x\n", (u32)MEM_GET_ALLOC_ADDR(u32Addr));
bsp_trace(BSP_LOG_LEVEL_ERROR, BSP_MODU_MEM,"magic num: 0x%x\n", MEM_ITEM_MAGIC(u32Addr));
bsp_trace(BSP_LOG_LEVEL_ERROR, BSP_MODU_MEM,"block size: %d\n", MEM_ITEM_SIZE(u32Addr));
bsp_trace(BSP_LOG_LEVEL_ERROR, BSP_MODU_MEM,"mem flags: 0x%x\n", MEM_ITEM_FLAGS(u32Addr));
bsp_trace(BSP_LOG_LEVEL_ERROR, BSP_MODU_MEM,"mem item next: 0x%x\n", MEM_ITEM_NEXT(u32Addr));
#ifdef __BSP_MEM_DEBUG__
bsp_trace(BSP_LOG_LEVEL_ERROR, BSP_MODU_MEM,"used file name: %s\n", (bBlockInvalid) ? ("invalid") : (BSP_CHAR*)MEM_ITEM_FILE_NAME(u32Addr));
bsp_trace(BSP_LOG_LEVEL_ERROR, BSP_MODU_MEM,"used line: %d\n", MEM_ITEM_LINE(u32Addr));
bsp_trace(BSP_LOG_LEVEL_ERROR, BSP_MODU_MEM,"mem status: %s\n", (MEM_ITEM_STATUS(u32Addr)) ? ("ALLOC") : ("FREE"));
#endif
bsp_trace(BSP_LOG_LEVEL_ERROR, BSP_MODU_MEM,"================================\n");
return BSP_OK;
}
