The Android Open Source Project | e9df6ba | 2012-12-13 14:55:37 -0800 | [diff] [blame] | 1 | /****************************************************************************** |
| 2 | * |
| 3 | * Copyright (C) 1999-2012 Broadcom Corporation |
| 4 | * |
| 5 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 6 | * you may not use this file except in compliance with the License. |
| 7 | * You may obtain a copy of the License at: |
| 8 | * |
| 9 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 10 | * |
| 11 | * Unless required by applicable law or agreed to in writing, software |
| 12 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 14 | * See the License for the specific language governing permissions and |
| 15 | * limitations under the License. |
| 16 | * |
| 17 | ******************************************************************************/ |
| 18 | #ifndef GKI_COMMON_H |
| 19 | #define GKI_COMMON_H |
| 20 | |
| 21 | #include "gki.h" |
| 22 | #include "dyn_mem.h" |
| 23 | |
| 24 | #ifndef GKI_DEBUG |
| 25 | #define GKI_DEBUG FALSE |
| 26 | #endif |
| 27 | |
| 28 | /* Task States: (For OSRdyTbl) */ |
| 29 | #define TASK_DEAD 0 /* b0000 */ |
| 30 | #define TASK_READY 1 /* b0001 */ |
| 31 | #define TASK_WAIT 2 /* b0010 */ |
| 32 | #define TASK_DELAY 4 /* b0100 */ |
| 33 | #define TASK_SUSPEND 8 /* b1000 */ |
| 34 | |
| 35 | |
| 36 | /******************************************************************** |
| 37 | ** Internal Error codes |
| 38 | *********************************************************************/ |
| 39 | #define GKI_ERROR_BUF_CORRUPTED 0xFFFF |
| 40 | #define GKI_ERROR_NOT_BUF_OWNER 0xFFFE |
| 41 | #define GKI_ERROR_FREEBUF_BAD_QID 0xFFFD |
| 42 | #define GKI_ERROR_FREEBUF_BUF_LINKED 0xFFFC |
| 43 | #define GKI_ERROR_SEND_MSG_BAD_DEST 0xFFFB |
| 44 | #define GKI_ERROR_SEND_MSG_BUF_LINKED 0xFFFA |
| 45 | #define GKI_ERROR_ENQUEUE_BUF_LINKED 0xFFF9 |
| 46 | #define GKI_ERROR_DELETE_POOL_BAD_QID 0xFFF8 |
| 47 | #define GKI_ERROR_BUF_SIZE_TOOBIG 0xFFF7 |
| 48 | #define GKI_ERROR_BUF_SIZE_ZERO 0xFFF6 |
| 49 | #define GKI_ERROR_ADDR_NOT_IN_BUF 0xFFF5 |
| 50 | |
| 51 | |
| 52 | /******************************************************************** |
| 53 | ** Misc constants |
| 54 | *********************************************************************/ |
| 55 | |
| 56 | #define GKI_MAX_INT32 (0x7fffffffL) |
| 57 | #define GKI_MAX_TIMESTAMP (0xffffffffL) |
| 58 | |
| 59 | /******************************************************************** |
| 60 | ** Buffer Management Data Structures |
| 61 | *********************************************************************/ |
| 62 | |
| 63 | typedef struct _buffer_hdr |
| 64 | { |
| 65 | struct _buffer_hdr *p_next; /* next buffer in the queue */ |
| 66 | UINT8 q_id; /* id of the queue */ |
| 67 | UINT8 task_id; /* task which allocated the buffer*/ |
| 68 | UINT8 status; /* FREE, UNLINKED or QUEUED */ |
| 69 | UINT8 Type; |
| 70 | |
| 71 | #if GKI_BUFFER_DEBUG |
| 72 | /* for tracking who allocated the buffer */ |
| 73 | #define _GKI_MAX_FUNCTION_NAME_LEN (50) |
| 74 | char _function[_GKI_MAX_FUNCTION_NAME_LEN+1]; |
| 75 | int _line; |
| 76 | #endif |
| 77 | |
| 78 | } BUFFER_HDR_T; |
| 79 | |
| 80 | typedef struct _free_queue |
| 81 | { |
| 82 | BUFFER_HDR_T *p_first; /* first buffer in the queue */ |
| 83 | BUFFER_HDR_T *p_last; /* last buffer in the queue */ |
| 84 | UINT16 size; /* size of the buffers in the pool */ |
| 85 | UINT16 total; /* toatal number of buffers */ |
| 86 | UINT16 cur_cnt; /* number of buffers currently allocated */ |
| 87 | UINT16 max_cnt; /* maximum number of buffers allocated at any time */ |
| 88 | } FREE_QUEUE_T; |
| 89 | |
| 90 | |
| 91 | /* Buffer related defines |
| 92 | */ |
| 93 | #define ALIGN_POOL(pl_size) ( (((pl_size) + 3) / sizeof(UINT32)) * sizeof(UINT32)) |
| 94 | #define BUFFER_HDR_SIZE (sizeof(BUFFER_HDR_T)) /* Offset past header */ |
| 95 | #define BUFFER_PADDING_SIZE (sizeof(BUFFER_HDR_T) + sizeof(UINT32)) /* Header + Magic Number */ |
| 96 | #define MAX_USER_BUF_SIZE ((UINT16)0xffff - BUFFER_PADDING_SIZE) /* pool size must allow for header */ |
| 97 | #define MAGIC_NO 0xDDBADDBA |
| 98 | |
| 99 | #define BUF_STATUS_FREE 0 |
| 100 | #define BUF_STATUS_UNLINKED 1 |
| 101 | #define BUF_STATUS_QUEUED 2 |
| 102 | |
| 103 | #define GKI_USE_DEFERED_ALLOC_BUF_POOLS |
| 104 | |
| 105 | /* Exception related structures (Used in debug mode only) |
| 106 | */ |
| 107 | #if (GKI_DEBUG == TRUE) |
| 108 | typedef struct |
| 109 | { |
| 110 | UINT16 type; |
| 111 | UINT8 taskid; |
| 112 | UINT8 msg[GKI_MAX_EXCEPTION_MSGLEN]; |
| 113 | } EXCEPTION_T; |
| 114 | #endif |
| 115 | |
| 116 | |
| 117 | /* Put all GKI variables into one control block |
| 118 | */ |
| 119 | typedef struct |
| 120 | { |
| 121 | /* Task management variables |
| 122 | */ |
| 123 | /* The stack and stack size are not used on Windows |
| 124 | */ |
| 125 | #if (!defined GKI_USE_DEFERED_ALLOC_BUF_POOLS && (GKI_USE_DYNAMIC_BUFFERS == FALSE)) |
| 126 | |
| 127 | #if (GKI_NUM_FIXED_BUF_POOLS > 0) |
| 128 | UINT8 bufpool0[(ALIGN_POOL(GKI_BUF0_SIZE) + BUFFER_PADDING_SIZE) * GKI_BUF0_MAX]; |
| 129 | #endif |
| 130 | |
| 131 | #if (GKI_NUM_FIXED_BUF_POOLS > 1) |
| 132 | UINT8 bufpool1[(ALIGN_POOL(GKI_BUF1_SIZE) + BUFFER_PADDING_SIZE) * GKI_BUF1_MAX]; |
| 133 | #endif |
| 134 | |
| 135 | #if (GKI_NUM_FIXED_BUF_POOLS > 2) |
| 136 | UINT8 bufpool2[(ALIGN_POOL(GKI_BUF2_SIZE) + BUFFER_PADDING_SIZE) * GKI_BUF2_MAX]; |
| 137 | #endif |
| 138 | |
| 139 | #if (GKI_NUM_FIXED_BUF_POOLS > 3) |
| 140 | UINT8 bufpool3[(ALIGN_POOL(GKI_BUF3_SIZE) + BUFFER_PADDING_SIZE) * GKI_BUF3_MAX]; |
| 141 | #endif |
| 142 | |
| 143 | #if (GKI_NUM_FIXED_BUF_POOLS > 4) |
| 144 | UINT8 bufpool4[(ALIGN_POOL(GKI_BUF4_SIZE) + BUFFER_PADDING_SIZE) * GKI_BUF4_MAX]; |
| 145 | #endif |
| 146 | |
| 147 | #if (GKI_NUM_FIXED_BUF_POOLS > 5) |
| 148 | UINT8 bufpool5[(ALIGN_POOL(GKI_BUF5_SIZE) + BUFFER_PADDING_SIZE) * GKI_BUF5_MAX]; |
| 149 | #endif |
| 150 | |
| 151 | #if (GKI_NUM_FIXED_BUF_POOLS > 6) |
| 152 | UINT8 bufpool6[(ALIGN_POOL(GKI_BUF6_SIZE) + BUFFER_PADDING_SIZE) * GKI_BUF6_MAX]; |
| 153 | #endif |
| 154 | |
| 155 | #if (GKI_NUM_FIXED_BUF_POOLS > 7) |
| 156 | UINT8 bufpool7[(ALIGN_POOL(GKI_BUF7_SIZE) + BUFFER_PADDING_SIZE) * GKI_BUF7_MAX]; |
| 157 | #endif |
| 158 | |
| 159 | #if (GKI_NUM_FIXED_BUF_POOLS > 8) |
| 160 | UINT8 bufpool8[(ALIGN_POOL(GKI_BUF8_SIZE) + BUFFER_PADDING_SIZE) * GKI_BUF8_MAX]; |
| 161 | #endif |
| 162 | |
| 163 | #if (GKI_NUM_FIXED_BUF_POOLS > 9) |
| 164 | UINT8 bufpool9[(ALIGN_POOL(GKI_BUF9_SIZE) + BUFFER_PADDING_SIZE) * GKI_BUF9_MAX]; |
| 165 | #endif |
| 166 | |
| 167 | #if (GKI_NUM_FIXED_BUF_POOLS > 10) |
| 168 | UINT8 bufpool10[(ALIGN_POOL(GKI_BUF10_SIZE) + BUFFER_PADDING_SIZE) * GKI_BUF10_MAX]; |
| 169 | #endif |
| 170 | |
| 171 | #if (GKI_NUM_FIXED_BUF_POOLS > 11) |
| 172 | UINT8 bufpool11[(ALIGN_POOL(GKI_BUF11_SIZE) + BUFFER_PADDING_SIZE) * GKI_BUF11_MAX]; |
| 173 | #endif |
| 174 | |
| 175 | #if (GKI_NUM_FIXED_BUF_POOLS > 12) |
| 176 | UINT8 bufpool12[(ALIGN_POOL(GKI_BUF12_SIZE) + BUFFER_PADDING_SIZE) * GKI_BUF12_MAX]; |
| 177 | #endif |
| 178 | |
| 179 | #if (GKI_NUM_FIXED_BUF_POOLS > 13) |
| 180 | UINT8 bufpool13[(ALIGN_POOL(GKI_BUF13_SIZE) + BUFFER_PADDING_SIZE) * GKI_BUF13_MAX]; |
| 181 | #endif |
| 182 | |
| 183 | #if (GKI_NUM_FIXED_BUF_POOLS > 14) |
| 184 | UINT8 bufpool14[(ALIGN_POOL(GKI_BUF14_SIZE) + BUFFER_PADDING_SIZE) * GKI_BUF14_MAX]; |
| 185 | #endif |
| 186 | |
| 187 | #if (GKI_NUM_FIXED_BUF_POOLS > 15) |
| 188 | UINT8 bufpool15[(ALIGN_POOL(GKI_BUF15_SIZE) + BUFFER_PADDING_SIZE) * GKI_BUF15_MAX]; |
| 189 | #endif |
| 190 | |
| 191 | #else |
| 192 | /* Definitions for dynamic buffer use */ |
| 193 | #if (GKI_NUM_FIXED_BUF_POOLS > 0) |
| 194 | UINT8 *bufpool0; |
| 195 | #endif |
| 196 | |
| 197 | #if (GKI_NUM_FIXED_BUF_POOLS > 1) |
| 198 | UINT8 *bufpool1; |
| 199 | #endif |
| 200 | |
| 201 | #if (GKI_NUM_FIXED_BUF_POOLS > 2) |
| 202 | UINT8 *bufpool2; |
| 203 | #endif |
| 204 | |
| 205 | #if (GKI_NUM_FIXED_BUF_POOLS > 3) |
| 206 | UINT8 *bufpool3; |
| 207 | #endif |
| 208 | |
| 209 | #if (GKI_NUM_FIXED_BUF_POOLS > 4) |
| 210 | UINT8 *bufpool4; |
| 211 | #endif |
| 212 | |
| 213 | #if (GKI_NUM_FIXED_BUF_POOLS > 5) |
| 214 | UINT8 *bufpool5; |
| 215 | #endif |
| 216 | |
| 217 | #if (GKI_NUM_FIXED_BUF_POOLS > 6) |
| 218 | UINT8 *bufpool6; |
| 219 | #endif |
| 220 | |
| 221 | #if (GKI_NUM_FIXED_BUF_POOLS > 7) |
| 222 | UINT8 *bufpool7; |
| 223 | #endif |
| 224 | |
| 225 | #if (GKI_NUM_FIXED_BUF_POOLS > 8) |
| 226 | UINT8 *bufpool8; |
| 227 | #endif |
| 228 | |
| 229 | #if (GKI_NUM_FIXED_BUF_POOLS > 9) |
| 230 | UINT8 *bufpool9; |
| 231 | #endif |
| 232 | |
| 233 | #if (GKI_NUM_FIXED_BUF_POOLS > 10) |
| 234 | UINT8 *bufpool10; |
| 235 | #endif |
| 236 | |
| 237 | #if (GKI_NUM_FIXED_BUF_POOLS > 11) |
| 238 | UINT8 *bufpool11; |
| 239 | #endif |
| 240 | |
| 241 | #if (GKI_NUM_FIXED_BUF_POOLS > 12) |
| 242 | UINT8 *bufpool12; |
| 243 | #endif |
| 244 | |
| 245 | #if (GKI_NUM_FIXED_BUF_POOLS > 13) |
| 246 | UINT8 *bufpool13; |
| 247 | #endif |
| 248 | |
| 249 | #if (GKI_NUM_FIXED_BUF_POOLS > 14) |
| 250 | UINT8 *bufpool14; |
| 251 | #endif |
| 252 | |
| 253 | #if (GKI_NUM_FIXED_BUF_POOLS > 15) |
| 254 | UINT8 *bufpool15; |
| 255 | #endif |
| 256 | |
| 257 | #endif |
| 258 | |
| 259 | UINT8 *OSStack[GKI_MAX_TASKS]; /* pointer to beginning of stack */ |
| 260 | UINT16 OSStackSize[GKI_MAX_TASKS]; /* stack size available to each task */ |
| 261 | |
| 262 | |
| 263 | INT8 *OSTName[GKI_MAX_TASKS]; /* name of the task */ |
| 264 | |
| 265 | UINT8 OSRdyTbl[GKI_MAX_TASKS]; /* current state of the task */ |
| 266 | UINT16 OSWaitEvt[GKI_MAX_TASKS]; /* events that have to be processed by the task */ |
| 267 | UINT16 OSWaitForEvt[GKI_MAX_TASKS]; /* events the task is waiting for*/ |
| 268 | |
| 269 | UINT32 OSTicks; /* system ticks from start */ |
| 270 | UINT32 OSIdleCnt; /* idle counter */ |
| 271 | INT16 OSDisableNesting; /* counter to keep track of interrupt disable nesting */ |
| 272 | INT16 OSLockNesting; /* counter to keep track of sched lock nesting */ |
| 273 | INT16 OSIntNesting; /* counter to keep track of interrupt nesting */ |
| 274 | |
| 275 | /* Timer related variables |
| 276 | */ |
| 277 | INT32 OSTicksTilExp; /* Number of ticks till next timer expires */ |
| 278 | #if (defined(GKI_DELAY_STOP_SYS_TICK) && (GKI_DELAY_STOP_SYS_TICK > 0)) |
| 279 | UINT32 OSTicksTilStop; /* inactivity delay timer; OS Ticks till stopping system tick */ |
| 280 | #endif |
| 281 | INT32 OSNumOrigTicks; /* Number of ticks between last timer expiration to the next one */ |
| 282 | |
| 283 | INT32 OSWaitTmr [GKI_MAX_TASKS]; /* ticks the task has to wait, for specific events */ |
| 284 | |
| 285 | /* Only take up space timers used in the system (GKI_NUM_TIMERS defined in target.h) */ |
| 286 | #if (GKI_NUM_TIMERS > 0) |
| 287 | INT32 OSTaskTmr0 [GKI_MAX_TASKS]; |
| 288 | INT32 OSTaskTmr0R [GKI_MAX_TASKS]; |
| 289 | #endif |
| 290 | |
| 291 | #if (GKI_NUM_TIMERS > 1) |
| 292 | INT32 OSTaskTmr1 [GKI_MAX_TASKS]; |
| 293 | INT32 OSTaskTmr1R [GKI_MAX_TASKS]; |
| 294 | #endif |
| 295 | |
| 296 | #if (GKI_NUM_TIMERS > 2) |
| 297 | INT32 OSTaskTmr2 [GKI_MAX_TASKS]; |
| 298 | INT32 OSTaskTmr2R [GKI_MAX_TASKS]; |
| 299 | #endif |
| 300 | |
| 301 | #if (GKI_NUM_TIMERS > 3) |
| 302 | INT32 OSTaskTmr3 [GKI_MAX_TASKS]; |
| 303 | INT32 OSTaskTmr3R [GKI_MAX_TASKS]; |
| 304 | #endif |
| 305 | |
| 306 | |
| 307 | |
| 308 | /* Buffer related variables |
| 309 | */ |
| 310 | BUFFER_HDR_T *OSTaskQFirst[GKI_MAX_TASKS][NUM_TASK_MBOX]; /* array of pointers to the first event in the task mailbox */ |
| 311 | BUFFER_HDR_T *OSTaskQLast [GKI_MAX_TASKS][NUM_TASK_MBOX]; /* array of pointers to the last event in the task mailbox */ |
| 312 | |
| 313 | /* Define the buffer pool management variables |
| 314 | */ |
| 315 | FREE_QUEUE_T freeq[GKI_NUM_TOTAL_BUF_POOLS]; |
| 316 | |
| 317 | UINT16 pool_buf_size[GKI_NUM_TOTAL_BUF_POOLS]; |
| 318 | UINT16 pool_max_count[GKI_NUM_TOTAL_BUF_POOLS]; |
| 319 | UINT16 pool_additions[GKI_NUM_TOTAL_BUF_POOLS]; |
| 320 | |
| 321 | /* Define the buffer pool start addresses |
| 322 | */ |
| 323 | UINT8 *pool_start[GKI_NUM_TOTAL_BUF_POOLS]; /* array of pointers to the start of each buffer pool */ |
| 324 | UINT8 *pool_end[GKI_NUM_TOTAL_BUF_POOLS]; /* array of pointers to the end of each buffer pool */ |
| 325 | UINT16 pool_size[GKI_NUM_TOTAL_BUF_POOLS]; /* actual size of the buffers in a pool */ |
| 326 | |
| 327 | /* Define the buffer pool access control variables */ |
| 328 | void *p_user_mempool; /* User O/S memory pool */ |
| 329 | UINT16 pool_access_mask; /* Bits are set if the corresponding buffer pool is a restricted pool */ |
| 330 | UINT8 pool_list[GKI_NUM_TOTAL_BUF_POOLS]; /* buffer pools arranged in the order of size */ |
| 331 | UINT8 curr_total_no_of_pools; /* number of fixed buf pools + current number of dynamic pools */ |
| 332 | |
| 333 | BOOLEAN timer_nesting; /* flag to prevent timer interrupt nesting */ |
| 334 | |
| 335 | /* Time queue arrays */ |
| 336 | TIMER_LIST_Q *timer_queues[GKI_MAX_TIMER_QUEUES]; |
| 337 | /* System tick callback */ |
| 338 | SYSTEM_TICK_CBACK *p_tick_cb; |
| 339 | BOOLEAN system_tick_running; /* TRUE if system tick is running. Valid only if p_tick_cb is not NULL */ |
| 340 | |
| 341 | #if (GKI_DEBUG == TRUE) |
| 342 | UINT16 ExceptionCnt; /* number of GKI exceptions that have happened */ |
| 343 | EXCEPTION_T Exception[GKI_MAX_EXCEPTION]; |
| 344 | #endif |
| 345 | |
| 346 | } tGKI_COM_CB; |
| 347 | |
| 348 | |
| 349 | #ifdef __cplusplus |
| 350 | extern "C" { |
| 351 | #endif |
| 352 | |
| 353 | /* Internal GKI function prototypes |
| 354 | */ |
| 355 | GKI_API extern BOOLEAN gki_chk_buf_damage(void *); |
| 356 | extern BOOLEAN gki_chk_buf_owner(void *); |
| 357 | extern void gki_buffer_init (void); |
| 358 | extern void gki_timers_init(void); |
| 359 | extern void gki_adjust_timer_count (INT32); |
| 360 | |
| 361 | extern void OSStartRdy(void); |
| 362 | extern void OSCtxSw(void); |
| 363 | extern void OSIntCtxSw(void); |
| 364 | extern void OSSched(void); |
| 365 | extern void OSIntEnter(void); |
| 366 | extern void OSIntExit(void); |
| 367 | |
| 368 | |
| 369 | /* Debug aids |
| 370 | */ |
| 371 | typedef void (*FP_PRINT)(char *, ...); |
| 372 | |
| 373 | #if (GKI_DEBUG == TRUE) |
| 374 | |
| 375 | typedef void (*PKT_PRINT)(UINT8 *, UINT16); |
| 376 | |
| 377 | extern void gki_print_task(FP_PRINT); |
| 378 | extern void gki_print_exception(FP_PRINT); |
| 379 | extern void gki_print_timer(FP_PRINT); |
| 380 | extern void gki_print_stack(FP_PRINT); |
| 381 | extern void gki_print_buffer(FP_PRINT); |
| 382 | extern void gki_print_buffer_statistics(FP_PRINT, INT16); |
| 383 | GKI_API extern void gki_print_used_bufs (FP_PRINT, UINT8); |
| 384 | extern void gki_dump(UINT8 *, UINT16, FP_PRINT); |
| 385 | extern void gki_dump2(UINT16 *, UINT16, FP_PRINT); |
| 386 | extern void gki_dump4(UINT32 *, UINT16, FP_PRINT); |
| 387 | |
| 388 | #endif |
| 389 | #ifdef __cplusplus |
| 390 | } |
| 391 | #endif |
| 392 | |
| 393 | #endif |