BSP_BOOL bsp_ptr_invalid(const void* pMem)
{
u32 u32Type;
MEM_POOL_INFO* pPoolInfo;
u32 u32FindMem = 0;
if(NULL == pMem)
{
return FALSE;
}
for (u32Type = MEM_NORM_DDR_POOL; u32Type < MEM_POOL_MAX; u32Type++)
{
pPoolInfo = &(MEM_GET_ALLOC_INFO(u32Type)->memPoolInfo);
if ((u32)pMem >= pPoolInfo->u32BaseAddr ||
(u32)pMem < pPoolInfo->u32BaseAddr + pPoolInfo->u32Size)
{
u32FindMem = 1;
}
}
if (!u32FindMem ||
MEM_MAGIC_NUM != MEM_ITEM_MAGIC(pMem) ||
MEM_ITEM_FLAGS(pMem) >= (u32)MEM_POOL_MAX)
{
return TRUE;
}
return FALSE;
}
s32 bsp_mem_dump_alloc_list(u32 u32Size, u32 u32PoolType)
{
u32 u32Item;
u32 u32MostUsedItem;
void* pCurAddr;
u32 u32Num = 0;
MEM_ALLOC_INFO* pAllocInfo;
if (u32PoolType >= MEM_POOL_MAX)
{
bsp_trace(BSP_LOG_LEVEL_ERROR, BSP_MODU_MEM,"invalid pool type:%d\n", u32PoolType);
return BSP_ERROR;
}
pAllocInfo = MEM_GET_ALLOC_INFO(u32PoolType);
u32MostUsedItem = pAllocInfo->mostUsedItem;
MEM_FIND_RIGHT_ITEM(u32Item, u32Size, u32MostUsedItem);
if (u32Item >= MEM_ALLOC_LIST_NUM)
{
bsp_trace(BSP_LOG_LEVEL_ERROR, BSP_MODU_MEM,"invalid size:%d\n", u32Size);
return BSP_ERROR;
}
bsp_trace(BSP_LOG_LEVEL_ERROR, BSP_MODU_MEM,"dump alloc list beg:\n");
pCurAddr = pAllocInfo->allocList[u32Item];
for (;NULL != pCurAddr; pCurAddr = (void*)MEM_ITEM_NEXT(pCurAddr))
{
(void)bsp_mem_dump_block((u32)pCurAddr);
u32Num++;
}
bsp_trace(BSP_LOG_LEVEL_ERROR, BSP_MODU_MEM,"dump alloc list end, num:%d\n", u32Num);
return BSP_OK;
}
s32 bsp_mem_dump_alloc_list(u32 u32Size, u32 u32PoolType)
{
u32 u32Item;
u32 u32MostUsedItem;
void* pCurAddr;
u32 u32Num = 0;
MEM_ALLOC_INFO* pAllocInfo;
if (u32PoolType >= MEM_POOL_MAX)
{
printk("invalid pool type:%d\n", u32PoolType);
return ERROR;
}
pAllocInfo = MEM_GET_ALLOC_INFO(u32PoolType);
u32MostUsedItem = pAllocInfo->mostUsedItem;
MEM_FIND_RIGHT_ITEM(u32Item, u32Size, u32MostUsedItem);
if (u32Item >= MEM_ALLOC_LIST_NUM)
{
printk("invalid size:%d\n", u32Size);
return -1;
}
printk("dump alloc list beg:\n");
pCurAddr = (void*)PHY_TO_VIRT((unsigned int)pAllocInfo->allocList[u32Item]);
for (;NULL != pCurAddr; pCurAddr = (void*)MEM_ITEM_NEXT(pCurAddr))
{
(void)bsp_mem_dump_block((u32)pCurAddr);
u32Num++;
}
printk("dump alloc list end, num:%d\n", u32Num);
return 0;
}
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;
}
/**************************************************************************
内部函数
**************************************************************************/
s32 bsp_init_poll(u32 u32PoolType)
{
MEM_ALLOC_INFO* pAllocInfo = MEM_GET_ALLOC_INFO(u32PoolType);
/* 分配基地址和大小 */
switch((MEM_POOL_TYPE)u32PoolType)
{
case MEM_NORM_DDR_POOL:
{
/* pAllocInfo->memPoolInfo.u32CurPosAddr =
pAllocInfo->memPoolInfo.u32BaseAddr = (u32)MEM_NORM_DDR_POOL_BASE_ADDR;
pAllocInfo->memPoolInfo.u32Left =
pAllocInfo->memPoolInfo.u32Size = MEM_NORM_DDR_POOL_SIZE;
pAllocInfo->memPoolInfo.u32MgrSize = MEM_MGR_SIZE_FOR_CACHE;
*/
}
break;
case MEM_ICC_DDR_POOL:
{
pAllocInfo->memPoolInfo.u32CurPosAddr =
pAllocInfo->memPoolInfo.u32BaseAddr = (u32)SHD_DDR_V2P(MEM_ICC_DDR_POOL_BASE_ADDR);
pAllocInfo->memPoolInfo.u32Left =
pAllocInfo->memPoolInfo.u32Size = MEM_ICC_DDR_POOL_SIZE;
pAllocInfo->memPoolInfo.u32MgrSize = MEM_MGR_SIZE_FOR_CACHE;
}
break;
case MEM_ICC_AXI_POOL:
{
/* pAllocInfo->memPoolInfo.u32CurPosAddr =
pAllocInfo->memPoolInfo.u32BaseAddr = (u32)DRV_AXI_VIRT_TO_PHY(MEM_ICC_AXI_POOL_BASE_ADDR);
pAllocInfo->memPoolInfo.u32Left =
pAllocInfo->memPoolInfo.u32Size = MEM_ICC_AXI_POOL_SIZE;
pAllocInfo->memPoolInfo.u32MgrSize = MEM_MGR_SIZE_FOR_CACHE;
*/
}
break;
default:
printk("Invalid pool type:%d, line:%d\n", u32PoolType, __LINE__);
return FAIL;
}
if(u32PoolType == MEM_ICC_DDR_POOL)
{
if (!pAllocInfo->memPoolInfo.u32BaseAddr )
{
printk("Invalid pool ptr, line:%d\n", __LINE__);
return FAIL;
}
/* 初始化其他全局变量 */
pAllocInfo->mostUsedItem = 0;
}
return OK;
}
u8* bsp_memory_alloc(u32 u32PoolType, u32 u32Size)
{
u32 cnt;
void *pItem;
MEM_ALLOC_INFO* pAllocInfo = MEM_GET_ALLOC_INFO(u32PoolType);
u32 u32MostUsedItem = pAllocInfo->mostUsedItem;
/* 先查找AllocList中是否有可用的内存节点 */
MEM_FIND_RIGHT_ITEM(cnt, u32Size, u32MostUsedItem);
/* 如果没有找到则直接返回失败 */
if (cnt >= MEM_ALLOC_LIST_NUM)
{
printk(
"Invalid malloc size:%d, line:%d\n", u32Size, __LINE__);
return NULL;
}
/* 更新size为列表中的size */
u32Size = MEM_GET_ALLOC_SIZE(cnt);
/*lint -save -e718 -e746*/
MEM_LOCK_BY_TYPE(u32PoolType);
/*lint -restore*/
pItem = bsp_get_item(pAllocInfo, cnt, u32PoolType, u32Size);
if (NULL != pItem)
{
#ifdef __BSP_MEM_DEBUG__
pAllocInfo->allocUsedInfoList[cnt].u32CurNum++;
pAllocInfo->allocUsedInfoList[cnt].u32TotalMallocNum++;
if (pAllocInfo->allocUsedInfoList[cnt].u32CurNum >
pAllocInfo->allocUsedInfoList[cnt].u32MaxNum)
{
pAllocInfo->allocUsedInfoList[cnt].u32MaxNum =
pAllocInfo->allocUsedInfoList[cnt].u32CurNum;
}
MEM_ITEM_STATUS(pItem) = MEM_ALLOC;
#endif
/* 多核要 Flush Cache, 确保管理信息写入 */
MEM_FLUSH_CACHE_BY_TYPE(MEM_GET_ALLOC_ADDR(pItem), MEM_MGR_SIZE_FOR_CACHE, u32PoolType);
}
MEM_UNLOCK_BY_TYPE(u32PoolType);
return pItem;
}
s32 bsp_mem_info(u32 u32MemType)
{
u32 u32Item;
MEM_ALLOC_INFO* pAllocInfo;
if (u32MemType >= MEM_POOL_MAX)
{
bsp_trace(BSP_LOG_LEVEL_ERROR, BSP_MODU_MEM,"invalid pool type:%d\n", u32MemType);
return BSP_ERROR;
}
//for (u32MemType = MEM_NORM_DDR_POOL; u32MemType < MEM_POOL_MAX; u32MemType++)
{
pAllocInfo = MEM_GET_ALLOC_INFO(u32MemType);
bsp_trace(BSP_LOG_LEVEL_ERROR, BSP_MODU_MEM,"Dump Mem (%s):\n", g_memPoolName[u32MemType]);
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,"Alloc Fail Count: %d\n", pAllocInfo->u32AllocFailCnt);
bsp_trace(BSP_LOG_LEVEL_ERROR, BSP_MODU_MEM,"\n");
bsp_trace(BSP_LOG_LEVEL_ERROR, BSP_MODU_MEM,"================================\n");
bsp_trace(BSP_LOG_LEVEL_ERROR, BSP_MODU_MEM,"mem list used info:\n");
bsp_trace(BSP_LOG_LEVEL_ERROR, BSP_MODU_MEM,"--------------------------------\n");
for (u32Item = 0; u32Item < MEM_ALLOC_LIST_NUM; u32Item++)
{
bsp_trace(BSP_LOG_LEVEL_ERROR, BSP_MODU_MEM,"+-- dump size:%d list info:\n", MEM_GET_ALLOC_SIZE(u32Item));
bsp_trace(BSP_LOG_LEVEL_ERROR, BSP_MODU_MEM,"|-- cur alloc num: %d\n", pAllocInfo->allocUsedInfoList[u32Item].u32CurNum);
bsp_trace(BSP_LOG_LEVEL_ERROR, BSP_MODU_MEM,"|-- max alloc num: %d\n", pAllocInfo->allocUsedInfoList[u32Item].u32MaxNum);
if(u32MemType== MEM_ICC_DDR_POOL)
{
bsp_trace(BSP_LOG_LEVEL_ERROR, BSP_MODU_MEM,"|-- min num line: %d\n", sg_AllocMinNum[u32Item]);
bsp_trace(BSP_LOG_LEVEL_ERROR, BSP_MODU_MEM,"|-- max num line: %d\n", sg_AllocMaxNum[u32Item]);
}
bsp_trace(BSP_LOG_LEVEL_ERROR, BSP_MODU_MEM,"|-- total alloc num:%d\n", pAllocInfo->allocUsedInfoList[u32Item].u32TotalMallocNum);
bsp_trace(BSP_LOG_LEVEL_ERROR, BSP_MODU_MEM,"|-- total free num: %d\n", pAllocInfo->allocUsedInfoList[u32Item].u32TotalFreeNum);
bsp_trace(BSP_LOG_LEVEL_ERROR, BSP_MODU_MEM,"+-- \n");
}
bsp_trace(BSP_LOG_LEVEL_ERROR, BSP_MODU_MEM,"================================\n");
}
return BSP_OK;
}
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;
}
void bsp_memory_free(u32 u32PoolType, void* pMem, u32 u32Size)
{
u32 cnt;
u32 u32MostUsedItem;
MEM_ALLOC_INFO* pAllocInfo = MEM_GET_ALLOC_INFO(u32PoolType);
u32MostUsedItem = pAllocInfo->mostUsedItem;
/* 先查找AllocList中是否有可用的内存节点 */
MEM_FIND_RIGHT_ITEM(cnt, u32Size, u32MostUsedItem);
#ifdef __BSP_MEM_DEBUG__
/* 判断该节点是否有效 */
if (cnt >= MEM_ALLOC_LIST_NUM)
{
printk("bsp_pool_alloc Fail, size:%d, line:%d\n", u32Size, __LINE__);
return;
}
#endif
MEM_LOCK_BY_TYPE(u32PoolType);
/* 将item挂回到链表 */
if (MEM_ICC_AXI_POOL == u32PoolType)
{
MEM_ITEM_NEXT(pMem) = (u32)(pAllocInfo->allocList[cnt]);
pAllocInfo->allocList[cnt] = (void*)(DRV_AXI_VIRT_TO_PHY((u32)pMem));
}
else if (MEM_ICC_DDR_POOL == u32PoolType)
{
MEM_ITEM_NEXT(pMem) = (u32)(pAllocInfo->allocList[cnt]);
pAllocInfo->allocList[cnt] = (void *)SHD_DDR_V2P((u32)pMem);
}
#ifdef __BSP_MEM_DEBUG__
pAllocInfo->allocUsedInfoList[cnt].u32CurNum--;
pAllocInfo->allocUsedInfoList[cnt].u32TotalFreeNum++;
MEM_ITEM_STATUS(pMem) = MEM_FREE;
#endif
/* Flush Cache */
MEM_FLUSH_CACHE_BY_TYPE(MEM_GET_ALLOC_ADDR(pMem), MEM_MGR_SIZE_FOR_CACHE, u32PoolType);
MEM_UNLOCK_BY_TYPE(u32PoolType);
return;
}
s32 bsp_mem_info(u32 u32MemType)
{
u32 u32Item;
MEM_ALLOC_INFO* pAllocInfo;
if (u32MemType >= MEM_POOL_MAX)
{
printk("invalid pool type:%d\n", u32MemType);
return ERROR;
}
pAllocInfo = MEM_GET_ALLOC_INFO(u32MemType);
printk("Dump Mem (%s):\n", g_memPoolName[u32MemType]);
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("Alloc Fail Count: %d\n", pAllocInfo->u32AllocFailCnt);
printk("\n");
printk("================================\n");
printk("mem list used info:\n");
printk("--------------------------------\n");
for (u32Item = 0; u32Item < MEM_ALLOC_LIST_NUM; u32Item++)
{
printk("+-- dump size:%d list info:\n", MEM_GET_ALLOC_SIZE(u32Item));
printk("|-- cur alloc num: %d\n", pAllocInfo->allocUsedInfoList[u32Item].u32CurNum);
printk("|-- max alloc num: %d\n", pAllocInfo->allocUsedInfoList[u32Item].u32MaxNum);
if(u32MemType== MEM_ICC_DDR_POOL)
{
printk("|-- min num line: %d\n", sg_AllocMinNum[u32Item]);
printk("|-- max num line: %d\n", sg_AllocMaxNum[u32Item]);
}
printk("|-- total alloc num:%d\n", pAllocInfo->allocUsedInfoList[u32Item].u32TotalMallocNum);
printk("|-- total free num: %d\n", pAllocInfo->allocUsedInfoList[u32Item].u32TotalFreeNum);
printk("+-- \n");
}
printk("================================\n");
return 0;
}
s32 bsp_set_most_used_size(u32 u32Size, u32 u32PoolType)
{
u32 u32Item;
if (u32PoolType != MEM_ICC_DDR_POOL)
{
return ERROR;
}
for ((u32Item) = 0; (u32Item) < MEM_ALLOC_LIST_NUM && u32Size > MEM_GET_ALLOC_SIZE(u32Item); (u32Item)++)
;
if (u32Item >= MEM_ALLOC_LIST_NUM)
{
printk("invalid size:%d, line:%d\n", u32Size, __LINE__);
return ERROR;
}
/* 设置时要设置 MostItem - 1, 方便查找 */
MEM_GET_ALLOC_INFO(u32PoolType)->mostUsedItem = (u32Item == 0) ? (0) : (u32Item-1);
return OK;
}
STATIC void bsp_memory_free(u32 u32PoolType, void* pMem, u32 u32Size)
{
u32 cnt;
u32 u32MostUsedItem;
MEM_ALLOC_INFO* pAllocInfo = MEM_GET_ALLOC_INFO(u32PoolType);
u32MostUsedItem = pAllocInfo->mostUsedItem;
/* 先查找AllocList中是否有可用的内存节点 */
MEM_FIND_RIGHT_ITEM(cnt, u32Size, u32MostUsedItem);
#ifdef __BSP_MEM_DEBUG__
/* 判断该节点是否有效 */
if (cnt >= MEM_ALLOC_LIST_NUM)
{
bsp_trace(BSP_LOG_LEVEL_ERROR, BSP_MODU_MEM,
"memPoolAlloc Fail, size:%d, line:%d\n", u32Size, __LINE__);
return;
}
#endif
MEM_LOCK_BY_TYPE(u32PoolType);/*lint !e713*/
/* 将item挂回到链表 */
MEM_ITEM_NEXT(pMem) = (u32)pAllocInfo->allocList[cnt];
pAllocInfo->allocList[cnt] = pMem;
#ifdef __BSP_MEM_DEBUG__
pAllocInfo->allocUsedInfoList[cnt].u32CurNum--;
pAllocInfo->allocUsedInfoList[cnt].u32TotalFreeNum++;
MEM_ITEM_STATUS(pMem) = MEM_FREE;
#endif
/* Flush Cache */
MEM_FLUSH_CACHE_BY_TYPE(MEM_GET_ALLOC_ADDR(pMem), MEM_MGR_SIZE_FOR_CACHE, u32PoolType);
MEM_UNLOCK_BY_TYPE(u32PoolType);
return;
}
