You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
308 lines
9.6 KiB
308 lines
9.6 KiB
/****************************************************************************** |
|
* |
|
* Copyright (C) 1999-2012 Broadcom Corporation |
|
* |
|
* Licensed under the Apache License, Version 2.0 (the "License"); |
|
* you may not use this file except in compliance with the License. |
|
* You may obtain a copy of the License at: |
|
* |
|
* http://www.apache.org/licenses/LICENSE-2.0 |
|
* |
|
* Unless required by applicable law or agreed to in writing, software |
|
* distributed under the License is distributed on an "AS IS" BASIS, |
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
|
* See the License for the specific language governing permissions and |
|
* limitations under the License. |
|
* |
|
******************************************************************************/ |
|
#include "gki_int.h" |
|
|
|
#if (GKI_DEBUG == TRUE) |
|
|
|
const int8_t* const OSTaskStates[] = { |
|
(int8_t*)"DEAD", /* 0 */ |
|
(int8_t*)"REDY", /* 1 */ |
|
(int8_t*)"WAIT", /* 2 */ |
|
(int8_t*)"", (int8_t*)"DELY", /* 4 */ |
|
(int8_t*)"", (int8_t*)"", (int8_t*)"", (int8_t*)"SUSP", /* 8 */ |
|
}; |
|
|
|
/******************************************************************************* |
|
** |
|
** Function GKI_PrintBufferUsage |
|
** |
|
** Description Displays Current Buffer Pool summary |
|
** |
|
** Returns void |
|
** |
|
*******************************************************************************/ |
|
void GKI_PrintBufferUsage(uint8_t* p_num_pools, uint16_t* p_cur_used) { |
|
int i; |
|
FREE_QUEUE_T* p; |
|
uint8_t num = gki_cb.com.curr_total_no_of_pools; |
|
uint16_t cur[GKI_NUM_TOTAL_BUF_POOLS]; |
|
|
|
GKI_TRACE_0(""); |
|
GKI_TRACE_0("--- GKI Buffer Pool Summary (R - restricted, P - public) ---"); |
|
|
|
GKI_TRACE_0("POOL SIZE USED MAXU TOTAL"); |
|
GKI_TRACE_0("------------------------------"); |
|
for (i = 0; i < gki_cb.com.curr_total_no_of_pools; i++) { |
|
p = &gki_cb.com.freeq[i]; |
|
if ((1 << i) & gki_cb.com.pool_access_mask) { |
|
GKI_TRACE_5("%02d: (R), %4d, %3d, %3d, %3d", i, p->size, p->cur_cnt, |
|
p->max_cnt, p->total); |
|
} else { |
|
GKI_TRACE_5("%02d: (P), %4d, %3d, %3d, %3d", i, p->size, p->cur_cnt, |
|
p->max_cnt, p->total); |
|
} |
|
cur[i] = p->cur_cnt; |
|
} |
|
if (p_num_pools) *p_num_pools = num; |
|
if (p_cur_used) memcpy(p_cur_used, cur, num * 2); |
|
} |
|
|
|
/******************************************************************************* |
|
** |
|
** Function GKI_PrintBuffer |
|
** |
|
** Description Called internally by OSS to print the buffer pools |
|
** |
|
** Returns void |
|
** |
|
*******************************************************************************/ |
|
void GKI_PrintBuffer(void) { |
|
uint16_t i; |
|
for (i = 0; i < GKI_NUM_TOTAL_BUF_POOLS; i++) { |
|
GKI_TRACE_5("pool:%4u free %4u cur %3u max %3u total%3u", i, |
|
gki_cb.com.freeq[i].size, gki_cb.com.freeq[i].cur_cnt, |
|
gki_cb.com.freeq[i].max_cnt, gki_cb.com.freeq[i].total); |
|
} |
|
} |
|
|
|
/******************************************************************************* |
|
** |
|
** Function gki_calc_stack |
|
** |
|
** Description This function tries to calculate the amount of |
|
** stack used by looking non magic num. Magic num is consider |
|
** the first byte in the stack. |
|
** |
|
** Returns the number of unused byte on the stack. 4 in case of stack |
|
*overrun |
|
** |
|
*******************************************************************************/ |
|
uint16_t gki_calc_stack(uint8_t task) { |
|
int j, stacksize; |
|
uint32_t MagicNum; |
|
uint32_t* p; |
|
|
|
stacksize = (int)gki_cb.com.OSStackSize[task]; |
|
p = (uint32_t*)gki_cb.com.OSStack[task]; /* assume stack is aligned, */ |
|
MagicNum = *p; |
|
|
|
for (j = 0; j < stacksize; j++) { |
|
if (*p++ != MagicNum) break; |
|
} |
|
|
|
return (j * sizeof(uint32_t)); |
|
} |
|
|
|
/******************************************************************************* |
|
** |
|
** Function GKI_print_task |
|
** |
|
** Description Print task stack usage. |
|
** |
|
** Returns void |
|
** |
|
*******************************************************************************/ |
|
void GKI_print_task(void) { |
|
#ifdef _BT_WIN32 |
|
GKI_TRACE_0("Service not available under insight"); |
|
#else |
|
uint8_t TaskId; |
|
|
|
GKI_TRACE_0("TID TASKNAME STATE FREE_STACK STACK"); |
|
for (TaskId = 0; TaskId < GKI_MAX_TASKS; TaskId++) { |
|
if (gki_cb.com.OSRdyTbl[TaskId] != TASK_DEAD) { |
|
GKI_TRACE_5("%2u %-8s %-5s 0x%04X 0x%04X Bytes", (uint16_t)TaskId, |
|
gki_cb.com.OSTName[TaskId], |
|
OSTaskStates[gki_cb.com.OSRdyTbl[TaskId]], |
|
gki_calc_stack(TaskId), gki_cb.com.OSStackSize[TaskId]); |
|
} |
|
} |
|
#endif |
|
} |
|
|
|
/******************************************************************************* |
|
** |
|
** Function gki_print_buffer_statistics |
|
** |
|
** Description Called internally by OSS to print the buffer pools |
|
*statistics |
|
** |
|
** Returns void |
|
** |
|
*******************************************************************************/ |
|
void gki_print_buffer_statistics(FP_PRINT print, int16_t pool) { |
|
uint16_t i; |
|
BUFFER_HDR_T* hdr; |
|
uint16_t size, act_size, maxbuffs; |
|
uint32_t* magic; |
|
|
|
if (pool > GKI_NUM_TOTAL_BUF_POOLS || pool < 0) { |
|
print("Not a valid Buffer pool\n"); |
|
return; |
|
} |
|
|
|
size = gki_cb.com.freeq[pool].size; |
|
maxbuffs = gki_cb.com.freeq[pool].total; |
|
act_size = size + BUFFER_PADDING_SIZE; |
|
print("Buffer Pool[%u] size=%u cur_cnt=%u max_cnt=%u total=%u\n", pool, |
|
gki_cb.com.freeq[pool].size, gki_cb.com.freeq[pool].cur_cnt, |
|
gki_cb.com.freeq[pool].max_cnt, gki_cb.com.freeq[pool].total); |
|
|
|
print(" Owner State Sanity\n"); |
|
print("----------------------------\n"); |
|
hdr = (BUFFER_HDR_T*)(gki_cb.com.pool_start[pool]); |
|
for (i = 0; i < maxbuffs; i++) { |
|
magic = (uint32_t*)((uint8_t*)hdr + BUFFER_HDR_SIZE + size); |
|
print("%3d: 0x%02x %4d %10s\n", i, hdr->task_id, hdr->status, |
|
(*magic == MAGIC_NO) ? "OK" : "CORRUPTED"); |
|
hdr = (BUFFER_HDR_T*)((uint8_t*)hdr + act_size); |
|
} |
|
return; |
|
} |
|
|
|
/******************************************************************************* |
|
** |
|
** Function gki_print_used_bufs |
|
** |
|
** Description Dumps used buffers in the particular pool |
|
** |
|
*******************************************************************************/ |
|
void gki_print_used_bufs(FP_PRINT print, uint8_t pool_id) { |
|
uint8_t* p_start; |
|
uint16_t buf_size; |
|
uint16_t num_bufs; |
|
BUFFER_HDR_T* p_hdr; |
|
uint16_t i; |
|
uint32_t* magic; |
|
uint16_t* p; |
|
|
|
if (pool_id >= GKI_NUM_TOTAL_BUF_POOLS && |
|
gki_cb.com.pool_start[pool_id] != 0) { |
|
print("Not a valid Buffer pool\n"); |
|
return; |
|
} |
|
|
|
p_start = gki_cb.com.pool_start[pool_id]; |
|
buf_size = gki_cb.com.freeq[pool_id].size + BUFFER_PADDING_SIZE; |
|
num_bufs = gki_cb.com.freeq[pool_id].total; |
|
|
|
for (i = 0; i < num_bufs; i++, p_start += buf_size) { |
|
p_hdr = (BUFFER_HDR_T*)p_start; |
|
magic = (uint32_t*)((uint8_t*)p_hdr + buf_size - sizeof(uint32_t)); |
|
p = (uint16_t*)p_hdr; |
|
|
|
if (p_hdr->status != BUF_STATUS_FREE) { |
|
print( |
|
"%d:0x%x (Q:%d,Task:%s,Stat:%d,%s) %04x %04x %04x %04x %04x %04x " |
|
"%04x %04x\n", |
|
i, p_hdr, p_hdr->q_id, GKI_map_taskname(p_hdr->task_id), |
|
p_hdr->status, (*magic == MAGIC_NO) ? "OK" : "CORRUPTED", p[0], p[1], |
|
p[2], p[3], p[4], p[5], p[6], p[7]); |
|
} |
|
} |
|
} |
|
|
|
/******************************************************************************* |
|
** |
|
** Function gki_print_task |
|
** |
|
** Description This function prints the task states. |
|
** |
|
** Returns void |
|
** |
|
*******************************************************************************/ |
|
void gki_print_task(FP_PRINT print) { |
|
uint8_t i; |
|
|
|
print("TID VID TASKNAME STATE WAIT WAITFOR TIMEOUT STACK\n"); |
|
print("-------------------------------------------------\n"); |
|
for (i = 0; i < GKI_MAX_TASKS; i++) { |
|
if (gki_cb.com.OSRdyTbl[i] != TASK_DEAD) { |
|
print("%2u %-8s %-5s %04X %04X %7u %u/%u Bytes\n", (uint16_t)i, |
|
gki_cb.com.OSTName[i], OSTaskStates[gki_cb.com.OSRdyTbl[i]], |
|
gki_cb.com.OSWaitEvt[i], gki_cb.com.OSWaitForEvt[i], |
|
gki_cb.com.OSWaitTmr[i], gki_calc_stack(i), |
|
gki_cb.com.OSStackSize[i]); |
|
} |
|
} |
|
} |
|
|
|
/******************************************************************************* |
|
** |
|
** Function gki_print_exception |
|
** |
|
** Description This function prints the exception information. |
|
** |
|
** Returns void |
|
** |
|
*******************************************************************************/ |
|
void gki_print_exception(FP_PRINT print) { |
|
uint16_t i; |
|
EXCEPTION_T* pExp; |
|
|
|
print("GKI Exceptions:\n"); |
|
for (i = 0; i < gki_cb.com.ExceptionCnt; i++) { |
|
pExp = &gki_cb.com.Exception[i]; |
|
print("%d: Type=%d, Task=%d: %s\n", i, (int32_t)pExp->type, |
|
(int32_t)pExp->taskid, (int8_t*)pExp->msg); |
|
} |
|
} |
|
|
|
/*****************************************************************************/ |
|
void gki_dump(uint8_t* s, uint16_t len, FP_PRINT print) { |
|
uint16_t i, j; |
|
|
|
for (i = 0, j = 0; i < len; i++) { |
|
if (j == 0) |
|
print("\n%lX: %02X, ", &s[i], s[i]); |
|
else if (j == 7) |
|
print("%02X, ", s[i]); |
|
else |
|
print("%02X, ", s[i]); |
|
if (++j == 16) j = 0; |
|
} |
|
print("\n"); |
|
} |
|
|
|
void gki_dump2(uint16_t* s, uint16_t len, FP_PRINT print) { |
|
uint16_t i, j; |
|
|
|
for (i = 0, j = 0; i < len; i++) { |
|
if (j == 0) |
|
print("\n%lX: %04X, ", &s[i], s[i]); |
|
else |
|
print("%04X, ", s[i]); |
|
if (++j == 8) j = 0; |
|
} |
|
print("\n"); |
|
} |
|
|
|
void gki_dump4(uint32_t* s, uint16_t len, FP_PRINT print) { |
|
uint16_t i, j; |
|
|
|
for (i = 0, j = 0; i < len; i++) { |
|
if (j == 0) |
|
print("\n%lX: %08lX, ", &s[i], s[i]); |
|
else |
|
print("%08lX, ", s[i]); |
|
if (++j == 4) j = 0; |
|
} |
|
print("\n"); |
|
} |
|
|
|
#endif
|
|
|