/*
* Function: mpool_free
*
* Purpose:
* Free memory block allocated from mpool..
* Parameters:
* pool - mpool handle (from mpool_create)
* addr - address of memory block to free
* Returns:
* Nothing
*/
void
mpool_free(mpool_handle_t pool, void *addr)
{
unsigned char *address = (unsigned char *)addr;
mpool_mem_t *ptr = pool, *prev = NULL;
MPOOL_LOCK();
while (ptr && ptr->next) {
if (ptr->next->address == address) {
#ifdef TRACK_DMA_USAGE
_dma_mem_used -= ptr->next->size;
#endif
break;
}
ptr = ptr->next;
}
if (ptr && ptr->next) {
prev = ptr;
ptr = ptr->next;
prev->next = ptr->next;
FREE(ptr);
}
MPOOL_UNLOCK();
}
/*
* Function: mpool_create
*
* Purpose:
* Create and initialize mpool control structures.
* Parameters:
* base_ptr - pointer to mpool memory block
* size - total size of mpool memory block
* Returns:
* mpool handle
* Notes
* The mpool handle returned must be used for subsequent
* memory allocations from the mpool.
*/
mpool_handle_t
mpool_create(void *base_ptr, int size)
{
mpool_mem_t *head, *tail;
int mod = (int)(((unsigned long)base_ptr) & (BCM_CACHE_LINE_BYTES - 1));
MPOOL_LOCK();
if (mod) {
base_ptr = (char*)base_ptr + (BCM_CACHE_LINE_BYTES - mod);
size -= (BCM_CACHE_LINE_BYTES - mod);
}
size &= ~(BCM_CACHE_LINE_BYTES - 1);
head = (mpool_mem_t *)MALLOC(sizeof(mpool_mem_t));
if (head == NULL) {
return NULL;
}
tail = (mpool_mem_t *)MALLOC(sizeof(mpool_mem_t));
if (tail == NULL) {
FREE(head);
return NULL;
}
head->size = tail->size = 0;
head->address = base_ptr;
tail->address = head->address + size;
head->next = tail;
tail->next = NULL;
MPOOL_UNLOCK();
return head;
}
int
dal_mpool_destroy(unsigned char lchip, dal_mpool_mem_t* pool)
{
dal_mpool_mem_t* ptr, * next;
MPOOL_LOCK();
for (ptr = pool; ptr; ptr = next)
{
next = ptr->next;
DAL_FREE(ptr);
}
for (ptr = p_desc_pool[lchip]; ptr; ptr = next)
{
next = ptr->next;
DAL_FREE(ptr);
}
for (ptr = p_data_pool[lchip]; ptr; ptr = next)
{
next = ptr->next;
DAL_FREE(ptr);
}
MPOOL_UNLOCK();
return 0;
}
void
dal_mpool_free(unsigned char lchip, dal_mpool_mem_t* pool, void* addr)
{
dal_mpool_mem_t* ptr = pool;
MPOOL_LOCK();
switch(pool->type)
{
case DAL_MPOOL_TYPE_USELESS:
ptr = pool;
_dal_mpool_free(ptr, addr, DAL_MPOOL_TYPE_USELESS);
break;
case DAL_MPOOL_TYPE_DESC:
ptr = p_desc_pool[lchip];
_dal_mpool_free(ptr, addr, DAL_MPOOL_TYPE_DESC);
break;
case DAL_MPOOL_TYPE_DATA:
ptr = p_data_pool[lchip];
_dal_mpool_free(ptr, addr, DAL_MPOOL_TYPE_DATA);
break;
default:
break;
}
MPOOL_UNLOCK();
return;
}
void*
dal_mpool_alloc(unsigned char lchip, dal_mpool_mem_t* pool, int size, int type)
{
dal_mpool_mem_t* ptr = NULL;
dal_mpool_mem_t* new_ptr = NULL;
int mod;
MPOOL_LOCK();
mod = size & (DAL_CACHE_LINE_BYTES - 1);
if (mod != 0)
{
size += (DAL_CACHE_LINE_BYTES - mod);
}
switch(type)
{
case DAL_MPOOL_TYPE_USELESS:
ptr = pool;
new_ptr = _dal_mpool_alloc_comon(ptr, size, type);
if (NULL == new_ptr)
{
MPOOL_UNLOCK();
return NULL;
}
break;
case DAL_MPOOL_TYPE_DESC:
ptr = p_desc_pool[lchip];
new_ptr = _dal_mpool_alloc_comon(ptr, size, type);
if (NULL == new_ptr)
{
MPOOL_UNLOCK();
return NULL;
}
break;
case DAL_MPOOL_TYPE_DATA:
ptr = p_data_pool[lchip];
new_ptr = _dal_mpool_alloc_comon(ptr, size, type);
if (NULL == new_ptr)
{
MPOOL_UNLOCK();
return NULL;
}
break;
default:
MPOOL_UNLOCK();
return NULL;
break;
}
MPOOL_UNLOCK();
if( NULL == new_ptr )
{
return NULL;
}
return new_ptr->address;
}
dal_mpool_mem_t*
dal_mpool_create(unsigned char lchip, void* base, int size)
{
dal_mpool_mem_t* head = NULL;
int mod = (int)(((unsigned long)base) & (DAL_CACHE_LINE_BYTES - 1));
MPOOL_LOCK();
if (mod)
{
base = (char*)base + (DAL_CACHE_LINE_BYTES - mod);
size -= (DAL_CACHE_LINE_BYTES - mod);
}
size &= ~(DAL_CACHE_LINE_BYTES - 1);
/* init for common linkptr, only used for GB */
head = _dal_mpool_create(base, size, DAL_MPOOL_TYPE_USELESS);
if (NULL == head)
{
MPOOL_UNLOCK();
return NULL;
}
/* init for desc linkptr */
p_desc_pool[lchip] = _dal_mpool_create(base, DAL_MPOOL_MAX_DESX_SIZE, DAL_MPOOL_TYPE_DESC);
if (NULL == p_desc_pool[lchip])
{
MPOOL_UNLOCK();
DAL_FREE(head->next);
DAL_FREE(head);
return NULL;
}
/* init for data linkptr */
p_data_pool[lchip] = _dal_mpool_create(((char*)base+DAL_MPOOL_MAX_DESX_SIZE), (size - DAL_MPOOL_MAX_DESX_SIZE), DAL_MPOOL_TYPE_DATA);
if (NULL == p_data_pool[lchip])
{
MPOOL_UNLOCK();
DAL_FREE(head->next);
DAL_FREE(head);
DAL_FREE(p_desc_pool[lchip]->next);
DAL_FREE(p_desc_pool[lchip]);
return NULL;
}
MPOOL_UNLOCK();
return head;
}
/*
* Function: mpool_usage
*
* Purpose:
* Report total sum of allocated mpool memory.
* Parameters:
* pool - mpool handle (from mpool_create)
* Returns:
* Number of bytes currently allocated using mpool_alloc.
*/
int
mpool_usage(mpool_handle_t pool)
{
int usage = 0;
mpool_mem_t *ptr;
MPOOL_LOCK();
for (ptr = pool; ptr; ptr = ptr->next) {
usage += ptr->size;
}
MPOOL_UNLOCK();
return usage;
}
/*
* Function: mpool_destroy
*
* Purpose:
* Free mpool control structures.
* Parameters:
* pool - mpool handle (from mpool_create)
* Returns:
* Always 0
*/
int
mpool_destroy(mpool_handle_t pool)
{
mpool_mem_t *ptr, *next;
MPOOL_LOCK();
for (ptr = pool; ptr; ptr = next) {
next = ptr->next;
FREE(ptr);
}
MPOOL_UNLOCK();
return 0;
}
int
dal_mpool_debug(dal_mpool_mem_t* pool)
{
dal_mpool_mem_t* ptr;
int index = 0;
MPOOL_LOCK();
for (ptr = pool; ptr; ptr = ptr->next)
{
// DAL_PRINT("%2dst mpool block: address=0x%8x, size=0x%x \n", index, (unsigned int)ptr->address, ptr->size);
DAL_PRINT("%2dst mpool block: address=%p, size=0x%x \n", index, ptr->address, ptr->size); // note
index++;
}
MPOOL_UNLOCK();
return 0;
}
int
dal_mpool_usage(dal_mpool_mem_t* pool, int type)
{
int usage = 0;
dal_mpool_mem_t* ptr;
MPOOL_LOCK();
for (ptr = pool; ptr; ptr = ptr->next)
{
if (ptr->type == type || ptr->type == -1)
{
usage += ptr->size;
}
}
MPOOL_UNLOCK();
return usage;
}
/*
* Function: mpool_alloc
*
* Purpose:
* Allocate memory block from mpool.
* Parameters:
* pool - mpool handle (from mpool_create)
* size - size of memory block to allocate
* Returns:
* Pointer to allocated memory block or NULL if allocation fails.
*/
void *
mpool_alloc(mpool_handle_t pool, int size)
{
mpool_mem_t *ptr = pool, *newptr = NULL;
int mod;
MPOOL_LOCK();
mod = size & (BCM_CACHE_LINE_BYTES - 1);
if (mod != 0 ) {
size += (BCM_CACHE_LINE_BYTES - mod);
}
while (ptr && ptr->next) {
if (ptr->next->address - (ptr->address + ptr->size) >= size) {
break;
}
ptr = ptr->next;
}
if (!(ptr && ptr->next)) {
MPOOL_UNLOCK();
return NULL;
}
newptr = MALLOC(sizeof(mpool_mem_t));
if (!newptr) {
MPOOL_UNLOCK();
return NULL;
}
newptr->address = ptr->address + ptr->size;
newptr->size = size;
newptr->next = ptr->next;
ptr->next = newptr;
#ifdef TRACK_DMA_USAGE
_dma_mem_used += size;
#endif
MPOOL_UNLOCK();
return newptr->address;
}
