/*******************************************************************************
**
** Function GKI_getpoolbuf
**
** Description Called by an application to get a free buffer from
** a specific buffer pool.
**
** Note: If there are no more buffers available from the pool,
** the public buffers are searched for an available buffer.
**
** Parameters pool_id - (input) pool ID to get a buffer out of.
**
** Returns A pointer to the buffer, or NULL if none available
**
*******************************************************************************/
void *GKI_getpoolbuf (UINT8 pool_id)
{
FREE_QUEUE_T *Q;
BUFFER_HDR_T *p_hdr;
tGKI_COM_CB *p_cb = &gki_cb.com;
if (pool_id >= GKI_NUM_TOTAL_BUF_POOLS)
{
GKI_exception(GKI_ERROR_GETPOOLBUF_BAD_QID, "getpoolbuf bad pool");
return (NULL);
}
/* Make sure the buffers aren't disturbed til finished with allocation */
GKI_disable();
Q = &p_cb->freeq[pool_id];
if(Q->cur_cnt < Q->total)
{
// btla-specific ++
#ifdef GKI_USE_DEFERED_ALLOC_BUF_POOLS
if(Q->p_first == 0 && gki_alloc_free_queue(pool_id) != TRUE)
{
GKI_enable();
return NULL;
}
#endif
// btla-specific --
p_hdr = Q->p_first;
Q->p_first = p_hdr->p_next;
if (!Q->p_first)
Q->p_last = NULL;
if(++Q->cur_cnt > Q->max_cnt)
Q->max_cnt = Q->cur_cnt;
GKI_enable();
p_hdr->task_id = GKI_get_taskid();
p_hdr->status = BUF_STATUS_UNLINKED;
p_hdr->p_next = NULL;
p_hdr->Type = 0;
return ((void *) ((UINT8 *)p_hdr + BUFFER_HDR_SIZE));
}
/* If here, no buffers in the specified pool */
GKI_enable();
/* try for free buffers in public pools */
return (GKI_getbuf(p_cb->freeq[pool_id].size));
}
/*******************************************************************************
**
** Function GKI_getbuf
**
** Description Called by an application to get a free buffer which
** is of size greater or equal to the requested size.
**
** Note: This routine only takes buffers from public pools.
** It will not use any buffers from pools
** marked GKI_RESTRICTED_POOL.
**
** Parameters size - (input) number of bytes needed.
**
** Returns A pointer to the buffer, or NULL if none available
**
*******************************************************************************/
void *GKI_getbuf (UINT16 size)
{
UINT8 i;
FREE_QUEUE_T *Q;
BUFFER_HDR_T *p_hdr;
tGKI_COM_CB *p_cb = &gki_cb.com;
if (size == 0)
{
GKI_exception (GKI_ERROR_BUF_SIZE_ZERO, "getbuf: Size is zero");
return (NULL);
}
/* Find the first buffer pool that is public that can hold the desired size */
for (i=0; i < p_cb->curr_total_no_of_pools; i++)
{
if ( size <= p_cb->freeq[p_cb->pool_list[i]].size )
break;
}
if(i == p_cb->curr_total_no_of_pools)
{
GKI_exception (GKI_ERROR_BUF_SIZE_TOOBIG, "getbuf: Size is too big");
return (NULL);
}
/* Make sure the buffers aren't disturbed til finished with allocation */
GKI_disable();
/* search the public buffer pools that are big enough to hold the size
* until a free buffer is found */
for ( ; i < p_cb->curr_total_no_of_pools; i++)
{
/* Only look at PUBLIC buffer pools (bypass RESTRICTED pools) */
if (((UINT16)1 << p_cb->pool_list[i]) & p_cb->pool_access_mask)
continue;
Q = &p_cb->freeq[p_cb->pool_list[i]];
if(Q->cur_cnt < Q->total)
{
// btla-specific ++
#ifdef GKI_USE_DEFERED_ALLOC_BUF_POOLS
if(Q->p_first == 0 && gki_alloc_free_queue(i) != TRUE)
return NULL;
#endif
// btla-specific --
p_hdr = Q->p_first;
Q->p_first = p_hdr->p_next;
if (!Q->p_first)
Q->p_last = NULL;
if(++Q->cur_cnt > Q->max_cnt)
Q->max_cnt = Q->cur_cnt;
GKI_enable();
p_hdr->task_id = GKI_get_taskid();
p_hdr->status = BUF_STATUS_UNLINKED;
p_hdr->p_next = NULL;
p_hdr->Type = 0;
return ((void *) ((UINT8 *)p_hdr + BUFFER_HDR_SIZE));
}
}
GKI_enable();
GKI_exception (GKI_ERROR_OUT_OF_BUFFERS, "getbuf: out of buffers");
return (NULL);
}
void *GKI_getpoolbuf (UINT8 pool_id)
#endif
{
FREE_QUEUE_T *Q;
BUFFER_HDR_T *p_hdr;
tGKI_COM_CB *p_cb = &gki_cb.com;
if (pool_id >= GKI_NUM_TOTAL_BUF_POOLS)
return (NULL);
#if GKI_BUFFER_DEBUG
LOGD("GKI_getpoolbuf() requesting from %d func:%s(line=%d)", pool_id, _function_, _line_);
#endif
/* Make sure the buffers aren't disturbed til finished with allocation */
GKI_disable();
Q = &p_cb->freeq[pool_id];
if(Q->cur_cnt < Q->total)
{
#ifdef GKI_USE_DEFERED_ALLOC_BUF_POOLS
if(Q->p_first == 0 && gki_alloc_free_queue(pool_id) != TRUE)
return NULL;
#endif
if(Q->p_first == 0)
{
/* gki_alloc_free_queue() failed to alloc memory */
GKI_TRACE_ERROR_0("GKI_getpoolbuf() fail alloc free queue");
return NULL;
}
p_hdr = Q->p_first;
Q->p_first = p_hdr->p_next;
if (!Q->p_first)
Q->p_last = NULL;
if(++Q->cur_cnt > Q->max_cnt)
Q->max_cnt = Q->cur_cnt;
GKI_enable();
p_hdr->task_id = GKI_get_taskid();
p_hdr->status = BUF_STATUS_UNLINKED;
p_hdr->p_next = NULL;
p_hdr->Type = 0;
#if GKI_BUFFER_DEBUG
LOGD("GKI_getpoolbuf() allocated, %x, %x (%d of %d used) %d", (UINT8*)p_hdr + BUFFER_HDR_SIZE, p_hdr, Q->cur_cnt, Q->total, p_cb->freeq[pool_id].total);
strncpy(p_hdr->_function, _function_, _GKI_MAX_FUNCTION_NAME_LEN);
p_hdr->_function[_GKI_MAX_FUNCTION_NAME_LEN] = '\0';
p_hdr->_line = _line_;
#endif
return ((void *) ((UINT8 *)p_hdr + BUFFER_HDR_SIZE));
}
/* If here, no buffers in the specified pool */
GKI_enable();
#if GKI_BUFFER_DEBUG
/* try for free buffers in public pools */
return (GKI_getbuf_debug(p_cb->freeq[pool_id].size, _function_, _line_));
#else
/* try for free buffers in public pools */
return (GKI_getbuf(p_cb->freeq[pool_id].size));
#endif
}
void *GKI_getbuf (UINT16 size)
#endif
{
UINT8 i;
FREE_QUEUE_T *Q;
BUFFER_HDR_T *p_hdr;
tGKI_COM_CB *p_cb = &gki_cb.com;
#if GKI_BUFFER_DEBUG
UINT8 x;
#endif
if (size == 0)
{
GKI_exception (GKI_ERROR_BUF_SIZE_ZERO, "getbuf: Size is zero");
return (NULL);
}
#if GKI_BUFFER_DEBUG
LOGD("GKI_getbuf() requesting %d func:%s(line=%d)", size, _function_, _line_);
#endif
/* Find the first buffer pool that is public that can hold the desired size */
for (i=0; i < p_cb->curr_total_no_of_pools; i++)
{
if ( size <= p_cb->freeq[p_cb->pool_list[i]].size )
break;
}
if(i == p_cb->curr_total_no_of_pools)
{
GKI_exception (GKI_ERROR_BUF_SIZE_TOOBIG, "getbuf: Size is too big");
return (NULL);
}
/* Make sure the buffers aren't disturbed til finished with allocation */
GKI_disable();
/* search the public buffer pools that are big enough to hold the size
* until a free buffer is found */
for ( ; i < p_cb->curr_total_no_of_pools; i++)
{
/* Only look at PUBLIC buffer pools (bypass RESTRICTED pools) */
if (((UINT16)1 << p_cb->pool_list[i]) & p_cb->pool_access_mask)
continue;
Q = &p_cb->freeq[p_cb->pool_list[i]];
if(Q->cur_cnt < Q->total)
{
#ifdef GKI_USE_DEFERED_ALLOC_BUF_POOLS
if(Q->p_first == 0 && gki_alloc_free_queue(i) != TRUE)
{
GKI_TRACE_ERROR_0("GKI_getbuf() out of buffer");
GKI_enable();
return NULL;
}
#endif
if(Q->p_first == 0)
{
/* gki_alloc_free_queue() failed to alloc memory */
GKI_TRACE_ERROR_0("GKI_getbuf() fail alloc free queue");
GKI_enable();
return NULL;
}
p_hdr = Q->p_first;
Q->p_first = p_hdr->p_next;
if (!Q->p_first)
Q->p_last = NULL;
if(++Q->cur_cnt > Q->max_cnt)
Q->max_cnt = Q->cur_cnt;
GKI_enable();
p_hdr->task_id = GKI_get_taskid();
p_hdr->status = BUF_STATUS_UNLINKED;
p_hdr->p_next = NULL;
p_hdr->Type = 0;
#if GKI_BUFFER_DEBUG
LOGD("GKI_getbuf() allocated, %x, %x (%d of %d used) %d", (UINT8*)p_hdr + BUFFER_HDR_SIZE, p_hdr, Q->cur_cnt, Q->total, p_cb->freeq[i].total);
strncpy(p_hdr->_function, _function_, _GKI_MAX_FUNCTION_NAME_LEN);
p_hdr->_function[_GKI_MAX_FUNCTION_NAME_LEN] = '\0';
p_hdr->_line = _line_;
#endif
return ((void *) ((UINT8 *)p_hdr + BUFFER_HDR_SIZE));
}
}
GKI_TRACE_ERROR_0("GKI_getbuf() unable to allocate buffer!!!!!");
#if GKI_BUFFER_DEBUG
LOGD("GKI_getbuf() unable to allocate buffer!!!!!");
LOGD("******************** GKI Memory Pool Dump ********************");
p_cb = &gki_cb.com;
LOGD("Dumping total of %d buffer pools", p_cb->curr_total_no_of_pools);
for (i=0 ; i < p_cb->curr_total_no_of_pools; i++)
{
p_hdr = (BUFFER_HDR_T *)p_cb->pool_start[i];
LOGD("pool %d has a total of %d buffers (start=%p)", i, p_cb->freeq[i].total, p_hdr);
for (x=0; p_hdr && x < p_cb->freeq[i].total; x++)
{
if (p_hdr->status != BUF_STATUS_FREE)
{
LOGD("pool:%d, buf[%d]:%x, hdr:%x status=%d func:%s(line=%d)", i, x, (UINT8*)p_hdr + BUFFER_HDR_SIZE, p_hdr, p_hdr->status, p_hdr->_function, p_hdr->_line);
}
p_hdr = (BUFFER_HDR_T *)((UINT8 *)p_hdr + p_cb->pool_size[i]);
}
}
LOGD("**************************************************************");
#endif
GKI_TRACE_ERROR_0("Failed to allocate GKI buffer");
GKI_enable();
return (NULL);
}
