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 23 /* Task States: (For OSRdyTbl) */ 24 #define TASK_DEAD 0 /* b0000 */ 25 #define TASK_READY 1 /* b0001 */ 26 27 /******************************************************************** 28 ** Internal Error codes 29 *********************************************************************/ 30 #define GKI_ERROR_BUF_CORRUPTED 0xFFFF 31 #define GKI_ERROR_NOT_BUF_OWNER 0xFFFE 32 #define GKI_ERROR_FREEBUF_BAD_QID 0xFFFD 33 #define GKI_ERROR_FREEBUF_BUF_LINKED 0xFFFC 34 #define GKI_ERROR_SEND_MSG_BAD_DEST 0xFFFB 35 #define GKI_ERROR_SEND_MSG_BUF_LINKED 0xFFFA 36 #define GKI_ERROR_ENQUEUE_BUF_LINKED 0xFFF9 37 #define GKI_ERROR_DELETE_POOL_BAD_QID 0xFFF8 38 #define GKI_ERROR_BUF_SIZE_TOOBIG 0xFFF7 39 #define GKI_ERROR_BUF_SIZE_ZERO 0xFFF6 40 41 /******************************************************************** 42 ** Misc constants 43 *********************************************************************/ 44 45 #define GKI_MAX_INT32 (0x7fffffffL) 46 47 /******************************************************************** 48 ** Buffer Management Data Structures 49 *********************************************************************/ 50 51 typedef struct _buffer_hdr { 52 struct _buffer_hdr* p_next; /* next buffer in the queue */ 53 uint8_t q_id; /* id of the queue */ 54 uint8_t task_id; /* task which allocated the buffer*/ 55 uint8_t status; /* FREE, UNLINKED or QUEUED */ 56 uint8_t Type; 57 #if defined(DYN_ALLOC) || defined(FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION) 58 uint16_t size; 59 #endif 60 } BUFFER_HDR_T; 61 62 typedef struct _free_queue { 63 BUFFER_HDR_T* p_first; /* first buffer in the queue */ 64 BUFFER_HDR_T* p_last; /* last buffer in the queue */ 65 uint16_t size; /* size of the buffers in the pool */ 66 uint16_t total; /* toatal number of buffers */ 67 uint16_t cur_cnt; /* number of buffers currently allocated */ 68 uint16_t max_cnt; /* maximum number of buffers allocated at any time */ 69 } FREE_QUEUE_T; 70 71 /* Buffer related defines 72 */ 73 #define ALIGN_POOL(pl_size) \ 74 ((((pl_size) + 3) / sizeof(uint32_t)) * sizeof(uint32_t)) 75 /* Offset past header */ 76 #define BUFFER_HDR_SIZE (sizeof(BUFFER_HDR_T)) 77 /* Header + Magic Number */ 78 #define BUFFER_PADDING_SIZE (sizeof(BUFFER_HDR_T) + sizeof(uint32_t)) 79 /* pool size must allow for header */ 80 #define MAX_USER_BUF_SIZE ((uint16_t)0xffff - BUFFER_PADDING_SIZE) 81 #define MAGIC_NO 0xDDBADDBA 82 83 #define BUF_STATUS_FREE 0 84 #define BUF_STATUS_UNLINKED 1 85 #define BUF_STATUS_QUEUED 2 86 87 /* Put all GKI variables into one control block 88 */ 89 typedef struct { 90 /* Task management variables 91 */ 92 /* The stack and stack size are not used on Windows 93 */ 94 95 #if (GKI_NUM_FIXED_BUF_POOLS > 0) 96 uint8_t bufpool0[(ALIGN_POOL(GKI_BUF0_SIZE) + BUFFER_PADDING_SIZE) * 97 GKI_BUF0_MAX]; 98 #endif 99 100 #if (GKI_NUM_FIXED_BUF_POOLS > 1) 101 uint8_t bufpool1[(ALIGN_POOL(GKI_BUF1_SIZE) + BUFFER_PADDING_SIZE) * 102 GKI_BUF1_MAX]; 103 #endif 104 105 #if (GKI_NUM_FIXED_BUF_POOLS > 2) 106 uint8_t bufpool2[(ALIGN_POOL(GKI_BUF2_SIZE) + BUFFER_PADDING_SIZE) * 107 GKI_BUF2_MAX]; 108 #endif 109 110 #if (GKI_NUM_FIXED_BUF_POOLS > 3) 111 uint8_t bufpool3[(ALIGN_POOL(GKI_BUF3_SIZE) + BUFFER_PADDING_SIZE) * 112 GKI_BUF3_MAX]; 113 #endif 114 115 #if (GKI_NUM_FIXED_BUF_POOLS > 4) 116 uint8_t bufpool4[(ALIGN_POOL(GKI_BUF4_SIZE) + BUFFER_PADDING_SIZE) * 117 GKI_BUF4_MAX]; 118 #endif 119 120 #if (GKI_NUM_FIXED_BUF_POOLS > 5) 121 uint8_t bufpool5[(ALIGN_POOL(GKI_BUF5_SIZE) + BUFFER_PADDING_SIZE) * 122 GKI_BUF5_MAX]; 123 #endif 124 125 #if (GKI_NUM_FIXED_BUF_POOLS > 6) 126 uint8_t bufpool6[(ALIGN_POOL(GKI_BUF6_SIZE) + BUFFER_PADDING_SIZE) * 127 GKI_BUF6_MAX]; 128 #endif 129 130 #if (GKI_NUM_FIXED_BUF_POOLS > 7) 131 uint8_t bufpool7[(ALIGN_POOL(GKI_BUF7_SIZE) + BUFFER_PADDING_SIZE) * 132 GKI_BUF7_MAX]; 133 #endif 134 135 #if (GKI_NUM_FIXED_BUF_POOLS > 8) 136 uint8_t bufpool8[(ALIGN_POOL(GKI_BUF8_SIZE) + BUFFER_PADDING_SIZE) * 137 GKI_BUF8_MAX]; 138 #endif 139 140 #if (GKI_NUM_FIXED_BUF_POOLS > 9) 141 uint8_t bufpool9[(ALIGN_POOL(GKI_BUF9_SIZE) + BUFFER_PADDING_SIZE) * 142 GKI_BUF9_MAX]; 143 #endif 144 145 #if (GKI_NUM_FIXED_BUF_POOLS > 10) 146 uint8_t bufpool10[(ALIGN_POOL(GKI_BUF10_SIZE) + BUFFER_PADDING_SIZE) * 147 GKI_BUF10_MAX]; 148 #endif 149 150 #if (GKI_NUM_FIXED_BUF_POOLS > 11) 151 uint8_t bufpool11[(ALIGN_POOL(GKI_BUF11_SIZE) + BUFFER_PADDING_SIZE) * 152 GKI_BUF11_MAX]; 153 #endif 154 155 #if (GKI_NUM_FIXED_BUF_POOLS > 12) 156 uint8_t bufpool12[(ALIGN_POOL(GKI_BUF12_SIZE) + BUFFER_PADDING_SIZE) * 157 GKI_BUF12_MAX]; 158 #endif 159 160 #if (GKI_NUM_FIXED_BUF_POOLS > 13) 161 uint8_t bufpool13[(ALIGN_POOL(GKI_BUF13_SIZE) + BUFFER_PADDING_SIZE) * 162 GKI_BUF13_MAX]; 163 #endif 164 165 #if (GKI_NUM_FIXED_BUF_POOLS > 14) 166 uint8_t bufpool14[(ALIGN_POOL(GKI_BUF14_SIZE) + BUFFER_PADDING_SIZE) * 167 GKI_BUF14_MAX]; 168 #endif 169 170 #if (GKI_NUM_FIXED_BUF_POOLS > 15) 171 uint8_t bufpool15[(ALIGN_POOL(GKI_BUF15_SIZE) + BUFFER_PADDING_SIZE) * 172 GKI_BUF15_MAX]; 173 #endif 174 175 uint8_t* OSStack[GKI_MAX_TASKS]; /* pointer to beginning of stack */ 176 uint16_t OSStackSize[GKI_MAX_TASKS]; /* stack size available to each task */ 177 178 int8_t* OSTName[GKI_MAX_TASKS]; /* name of the task */ 179 180 uint8_t OSRdyTbl[GKI_MAX_TASKS]; /* current state of the task */ 181 uint16_t OSWaitEvt 182 [GKI_MAX_TASKS]; /* events that have to be processed by the task */ 183 uint16_t OSWaitForEvt[GKI_MAX_TASKS]; /* events the task is waiting for*/ 184 185 uint32_t OSTicks; /* system ticks from start */ 186 uint32_t OSIdleCnt; /* idle counter */ 187 int16_t 188 OSDisableNesting; /* counter to keep track of interrupt disable nesting */ 189 int16_t OSLockNesting; /* counter to keep track of sched lock nesting */ 190 int16_t OSIntNesting; /* counter to keep track of interrupt nesting */ 191 192 /* Timer related variables 193 */ 194 int32_t OSTicksTilExp; /* Number of ticks till next timer expires */ 195 #if (GKI_DELAY_STOP_SYS_TICK > 0) 196 uint32_t OSTicksTilStop; /* inactivity delay timer; OS Ticks till stopping 197 system tick */ 198 #endif 199 int32_t OSNumOrigTicks; /* Number of ticks between last timer expiration to 200 the next one */ 201 202 int32_t OSWaitTmr 203 [GKI_MAX_TASKS]; /* ticks the task has to wait, for specific events */ 204 205 /* Only take up space timers used in the system (GKI_NUM_TIMERS defined in 206 * target.h) */ 207 #if (GKI_NUM_TIMERS > 0) 208 int32_t OSTaskTmr0[GKI_MAX_TASKS]; 209 int32_t OSTaskTmr0R[GKI_MAX_TASKS]; 210 #endif 211 212 #if (GKI_NUM_TIMERS > 1) 213 int32_t OSTaskTmr1[GKI_MAX_TASKS]; 214 int32_t OSTaskTmr1R[GKI_MAX_TASKS]; 215 #endif 216 217 #if (GKI_NUM_TIMERS > 2) 218 int32_t OSTaskTmr2[GKI_MAX_TASKS]; 219 int32_t OSTaskTmr2R[GKI_MAX_TASKS]; 220 #endif 221 222 #if (GKI_NUM_TIMERS > 3) 223 int32_t OSTaskTmr3[GKI_MAX_TASKS]; 224 int32_t OSTaskTmr3R[GKI_MAX_TASKS]; 225 #endif 226 227 /* Buffer related variables 228 */ 229 BUFFER_HDR_T* OSTaskQFirst[GKI_MAX_TASKS] 230 [NUM_TASK_MBOX]; /* array of pointers to the first 231 event in the task mailbox */ 232 BUFFER_HDR_T* OSTaskQLast[GKI_MAX_TASKS] 233 [NUM_TASK_MBOX]; /* array of pointers to the last 234 event in the task mailbox */ 235 236 /* Define the buffer pool management variables 237 */ 238 FREE_QUEUE_T freeq[GKI_NUM_TOTAL_BUF_POOLS]; 239 240 uint16_t pool_buf_size[GKI_NUM_TOTAL_BUF_POOLS]; 241 uint16_t pool_max_count[GKI_NUM_TOTAL_BUF_POOLS]; 242 uint16_t pool_additions[GKI_NUM_TOTAL_BUF_POOLS]; 243 244 /* Define the buffer pool start addresses 245 */ 246 uint8_t* pool_start[GKI_NUM_TOTAL_BUF_POOLS]; /* array of pointers to the 247 start of each buffer pool */ 248 uint8_t* 249 pool_end[GKI_NUM_TOTAL_BUF_POOLS]; /* array of pointers to the end of each 250 buffer pool */ 251 uint16_t pool_size 252 [GKI_NUM_TOTAL_BUF_POOLS]; /* actual size of the buffers in a pool */ 253 254 /* Define the buffer pool access control variables */ 255 void* p_user_mempool; /* User O/S memory pool */ 256 uint16_t 257 pool_access_mask; /* Bits are set if the corresponding buffer pool is a 258 restricted pool */ 259 uint8_t pool_list[GKI_NUM_TOTAL_BUF_POOLS]; /* buffer pools arranged in the 260 order of size */ 261 uint8_t 262 curr_total_no_of_pools; /* number of fixed buf pools + current number of 263 dynamic pools */ 264 265 bool timer_nesting; /* flag to prevent timer interrupt nesting */ 266 267 /* Time queue arrays */ 268 TIMER_LIST_Q* timer_queues[GKI_MAX_TIMER_QUEUES]; 269 /* System tick callback */ 270 SYSTEM_TICK_CBACK* p_tick_cb; 271 bool system_tick_running; /* TRUE if system tick is running. Valid only if 272 p_tick_cb is not NULL */ 273 274 } tGKI_COM_CB; 275 276 /* Internal GKI function prototypes 277 */ 278 extern bool gki_chk_buf_damage(void*); 279 extern bool gki_chk_buf_owner(void*); 280 extern void gki_buffer_init(void); 281 extern void gki_timers_init(void); 282 extern void gki_adjust_timer_count(int32_t); 283 284 #endif 285