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_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; }
/* * 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(); }
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; }
/* * 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; }
/* * 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; }