static BOOLEAN gki_alloc_free_queue(UINT8 id)
{
FREE_QUEUE_T *Q;
tGKI_COM_CB *p_cb = &gki_cb.com;
#if GKI_BUFFER_DEBUG
ALOGD("\ngki_alloc_free_queue in, id:%d \n", id);
#endif
Q = &p_cb->freeq[p_cb->pool_list[id]];
if(Q->p_first == 0)
{
void* p_mem = GKI_os_malloc((Q->size + BUFFER_PADDING_SIZE) * Q->total);
if(p_mem)
{
//re-initialize the queue with allocated memory
#if GKI_BUFFER_DEBUG
ALOGD("\ngki_alloc_free_queue calling gki_init_free_queue, id:%d size:%d, totol:%d\n", id, Q->size, Q->total);
#endif
gki_init_free_queue(id, Q->size, Q->total, p_mem);
#if GKI_BUFFER_DEBUG
ALOGD("\ngki_alloc_free_queue ret OK, id:%d size:%d, totol:%d\n", id, Q->size, Q->total);
#endif
return TRUE;
}
GKI_exception (GKI_ERROR_BUF_SIZE_TOOBIG, "gki_alloc_free_queue: Not enough memory");
}
#if GKI_BUFFER_DEBUG
ALOGD("\ngki_alloc_free_queue out failed, id:%d\n", id);
#endif
return FALSE;
}
/*******************************************************************************
**
** Function GKI_create_pool
**
** Description Called by applications to create a buffer pool.
**
** Parameters: size - (input) length (in bytes) of each buffer in the pool
** count - (input) number of buffers to allocate for the pool
** permission - (input) restricted or public access?
** (GKI_PUBLIC_POOL or GKI_RESTRICTED_POOL)
** p_mem_pool - (input) pointer to an OS memory pool, NULL if not provided
**
** Returns the buffer pool ID, which should be used in calls to
** GKI_getpoolbuf(). If a pool could not be created, this
** function returns 0xff.
**
*******************************************************************************/
UINT8 GKI_create_pool (UINT16 size, UINT16 count, UINT8 permission, void *p_mem_pool)
{
UINT8 xx;
UINT32 mem_needed;
INT32 tempsize = size;
tGKI_COM_CB *p_cb = &gki_cb.com;
/* First make sure the size of each pool has a valid size with room for the header info */
if (size > MAX_USER_BUF_SIZE)
return (GKI_INVALID_POOL);
/* First, look for an unused pool */
for (xx = 0; xx < GKI_NUM_TOTAL_BUF_POOLS; xx++)
{
if (!p_cb->pool_start[xx])
break;
}
if (xx == GKI_NUM_TOTAL_BUF_POOLS)
return (GKI_INVALID_POOL);
/* Ensure an even number of longwords */
tempsize = (INT32)ALIGN_POOL(size);
mem_needed = (tempsize + BUFFER_PADDING_SIZE) * count;
if (!p_mem_pool)
p_mem_pool = GKI_os_malloc(mem_needed);
if (p_mem_pool)
{
/* Initialize the new pool */
gki_init_free_queue (xx, size, count, p_mem_pool);
gki_add_to_pool_list(xx);
(void) GKI_set_pool_permission (xx, permission);
p_cb->curr_total_no_of_pools++;
return (xx);
}
else
return (GKI_INVALID_POOL);
}
/*******************************************************************************
**
** Function gki_buffer_init
**
** Description Called once internally by GKI at startup to initialize all
** buffers and free buffer pools.
**
** Returns void
**
*******************************************************************************/
void gki_buffer_init(void)
{
UINT8 i, tt, mb;
tGKI_COM_CB *p_cb = &gki_cb.com;
/* Initialize mailboxes */
for (tt = 0; tt < GKI_MAX_TASKS; tt++)
{
for (mb = 0; mb < NUM_TASK_MBOX; mb++)
{
p_cb->OSTaskQFirst[tt][mb] = NULL;
p_cb->OSTaskQLast [tt][mb] = NULL;
}
}
for (tt = 0; tt < GKI_NUM_TOTAL_BUF_POOLS; tt++)
{
p_cb->pool_start[tt] = NULL;
p_cb->pool_end[tt] = NULL;
p_cb->pool_size[tt] = 0;
p_cb->freeq[tt].p_first = 0;
p_cb->freeq[tt].p_last = 0;
p_cb->freeq[tt].size = 0;
p_cb->freeq[tt].total = 0;
p_cb->freeq[tt].cur_cnt = 0;
p_cb->freeq[tt].max_cnt = 0;
}
/* Use default from target.h */
p_cb->pool_access_mask = GKI_DEF_BUFPOOL_PERM_MASK;
// btla-specific ++
#if (!defined GKI_USE_DEFERED_ALLOC_BUF_POOLS && (GKI_USE_DYNAMIC_BUFFERS == TRUE))
// btla-specific --
#if (GKI_NUM_FIXED_BUF_POOLS > 0)
p_cb->bufpool0 = (UINT8 *)GKI_os_malloc ((GKI_BUF0_SIZE + BUFFER_PADDING_SIZE) * GKI_BUF0_MAX);
#endif
#if (GKI_NUM_FIXED_BUF_POOLS > 1)
p_cb->bufpool1 = (UINT8 *)GKI_os_malloc ((GKI_BUF1_SIZE + BUFFER_PADDING_SIZE) * GKI_BUF1_MAX);
#endif
#if (GKI_NUM_FIXED_BUF_POOLS > 2)
p_cb->bufpool2 = (UINT8 *)GKI_os_malloc ((GKI_BUF2_SIZE + BUFFER_PADDING_SIZE) * GKI_BUF2_MAX);
#endif
#if (GKI_NUM_FIXED_BUF_POOLS > 3)
p_cb->bufpool3 = (UINT8 *)GKI_os_malloc ((GKI_BUF3_SIZE + BUFFER_PADDING_SIZE) * GKI_BUF3_MAX);
#endif
#if (GKI_NUM_FIXED_BUF_POOLS > 4)
p_cb->bufpool4 = (UINT8 *)GKI_os_malloc ((GKI_BUF4_SIZE + BUFFER_PADDING_SIZE) * GKI_BUF4_MAX);
#endif
#if (GKI_NUM_FIXED_BUF_POOLS > 5)
p_cb->bufpool5 = (UINT8 *)GKI_os_malloc ((GKI_BUF5_SIZE + BUFFER_PADDING_SIZE) * GKI_BUF5_MAX);
#endif
#if (GKI_NUM_FIXED_BUF_POOLS > 6)
p_cb->bufpool6 = (UINT8 *)GKI_os_malloc ((GKI_BUF6_SIZE + BUFFER_PADDING_SIZE) * GKI_BUF6_MAX);
#endif
#if (GKI_NUM_FIXED_BUF_POOLS > 7)
p_cb->bufpool7 = (UINT8 *)GKI_os_malloc ((GKI_BUF7_SIZE + BUFFER_PADDING_SIZE) * GKI_BUF7_MAX);
#endif
#if (GKI_NUM_FIXED_BUF_POOLS > 8)
p_cb->bufpool8 = (UINT8 *)GKI_os_malloc ((GKI_BUF8_SIZE + BUFFER_PADDING_SIZE) * GKI_BUF8_MAX);
#endif
#if (GKI_NUM_FIXED_BUF_POOLS > 9)
p_cb->bufpool9 = (UINT8 *)GKI_os_malloc ((GKI_BUF9_SIZE + BUFFER_PADDING_SIZE) * GKI_BUF9_MAX);
#endif
#if (GKI_NUM_FIXED_BUF_POOLS > 10)
p_cb->bufpool10 = (UINT8 *)GKI_os_malloc ((GKI_BUF10_SIZE + BUFFER_PADDING_SIZE) * GKI_BUF10_MAX);
#endif
#if (GKI_NUM_FIXED_BUF_POOLS > 11)
p_cb->bufpool11 = (UINT8 *)GKI_os_malloc ((GKI_BUF11_SIZE + BUFFER_PADDING_SIZE) * GKI_BUF11_MAX);
#endif
#if (GKI_NUM_FIXED_BUF_POOLS > 12)
p_cb->bufpool12 = (UINT8 *)GKI_os_malloc ((GKI_BUF12_SIZE + BUFFER_PADDING_SIZE) * GKI_BUF12_MAX);
#endif
#if (GKI_NUM_FIXED_BUF_POOLS > 13)
p_cb->bufpool13 = (UINT8 *)GKI_os_malloc ((GKI_BUF13_SIZE + BUFFER_PADDING_SIZE) * GKI_BUF13_MAX);
#endif
#if (GKI_NUM_FIXED_BUF_POOLS > 14)
p_cb->bufpool14 = (UINT8 *)GKI_os_malloc ((GKI_BUF14_SIZE + BUFFER_PADDING_SIZE) * GKI_BUF14_MAX);
#endif
#if (GKI_NUM_FIXED_BUF_POOLS > 15)
p_cb->bufpool15 = (UINT8 *)GKI_os_malloc ((GKI_BUF15_SIZE + BUFFER_PADDING_SIZE) * GKI_BUF15_MAX);
#endif
#endif
#if (GKI_NUM_FIXED_BUF_POOLS > 0)
gki_init_free_queue(0, GKI_BUF0_SIZE, GKI_BUF0_MAX, p_cb->bufpool0);
#endif
#if (GKI_NUM_FIXED_BUF_POOLS > 1)
gki_init_free_queue(1, GKI_BUF1_SIZE, GKI_BUF1_MAX, p_cb->bufpool1);
#endif
#if (GKI_NUM_FIXED_BUF_POOLS > 2)
gki_init_free_queue(2, GKI_BUF2_SIZE, GKI_BUF2_MAX, p_cb->bufpool2);
#endif
#if (GKI_NUM_FIXED_BUF_POOLS > 3)
gki_init_free_queue(3, GKI_BUF3_SIZE, GKI_BUF3_MAX, p_cb->bufpool3);
#endif
#if (GKI_NUM_FIXED_BUF_POOLS > 4)
gki_init_free_queue(4, GKI_BUF4_SIZE, GKI_BUF4_MAX, p_cb->bufpool4);
#endif
#if (GKI_NUM_FIXED_BUF_POOLS > 5)
gki_init_free_queue(5, GKI_BUF5_SIZE, GKI_BUF5_MAX, p_cb->bufpool5);
#endif
#if (GKI_NUM_FIXED_BUF_POOLS > 6)
gki_init_free_queue(6, GKI_BUF6_SIZE, GKI_BUF6_MAX, p_cb->bufpool6);
#endif
#if (GKI_NUM_FIXED_BUF_POOLS > 7)
gki_init_free_queue(7, GKI_BUF7_SIZE, GKI_BUF7_MAX, p_cb->bufpool7);
#endif
#if (GKI_NUM_FIXED_BUF_POOLS > 8)
gki_init_free_queue(8, GKI_BUF8_SIZE, GKI_BUF8_MAX, p_cb->bufpool8);
#endif
#if (GKI_NUM_FIXED_BUF_POOLS > 9)
gki_init_free_queue(9, GKI_BUF9_SIZE, GKI_BUF9_MAX, p_cb->bufpool9);
#endif
#if (GKI_NUM_FIXED_BUF_POOLS > 10)
gki_init_free_queue(10, GKI_BUF10_SIZE, GKI_BUF10_MAX, p_cb->bufpool10);
#endif
#if (GKI_NUM_FIXED_BUF_POOLS > 11)
gki_init_free_queue(11, GKI_BUF11_SIZE, GKI_BUF11_MAX, p_cb->bufpool11);
#endif
#if (GKI_NUM_FIXED_BUF_POOLS > 12)
gki_init_free_queue(12, GKI_BUF12_SIZE, GKI_BUF12_MAX, p_cb->bufpool12);
#endif
#if (GKI_NUM_FIXED_BUF_POOLS > 13)
gki_init_free_queue(13, GKI_BUF13_SIZE, GKI_BUF13_MAX, p_cb->bufpool13);
#endif
#if (GKI_NUM_FIXED_BUF_POOLS > 14)
gki_init_free_queue(14, GKI_BUF14_SIZE, GKI_BUF14_MAX, p_cb->bufpool14);
#endif
#if (GKI_NUM_FIXED_BUF_POOLS > 15)
gki_init_free_queue(15, GKI_BUF15_SIZE, GKI_BUF15_MAX, p_cb->bufpool15);
#endif
/* add pools to the pool_list which is arranged in the order of size */
for(i=0; i < GKI_NUM_FIXED_BUF_POOLS ; i++)
{
p_cb->pool_list[i] = i;
}
p_cb->curr_total_no_of_pools = GKI_NUM_FIXED_BUF_POOLS;
return;
}