1 /****************************************************************************** 2 * 3 * Copyright (C) 1999-2014 Broadcom Corporation 4 * Copyright 2018-2020 NXP 5 * 6 * Licensed under the Apache License, Version 2.0 (the "License"); 7 * you may not use this file except in compliance with the License. 8 * You may obtain a copy of the License at: 9 * 10 * http://www.apache.org/licenses/LICENSE-2.0 11 * 12 * Unless required by applicable law or agreed to in writing, software 13 * distributed under the License is distributed on an "AS IS" BASIS, 14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 15 * See the License for the specific language governing permissions and 16 * limitations under the License. 17 * 18 ******************************************************************************/ 19 #ifndef UWB_TYPES_H 20 #define UWB_TYPES_H 21 #if __cplusplus > 199711L 22 #define register // Deprecated in C++11. 23 #endif // #if __cplusplus > 199711L 24 /**************************************************************************** 25 ** UWB_HDR header definition for UWB messages 26 *****************************************************************************/ 27 typedef struct { 28 uint16_t event; 29 uint16_t len; 30 uint16_t offset; 31 uint16_t layer_specific; 32 } UWB_HDR; 33 #define UWB_HDR_SIZE (sizeof(UWB_HDR)) 34 35 /* Mask for UWB_HDR event field */ 36 #define UWB_EVT_MASK 0xFF00 37 #define UWB_SUB_EVT_MASK 0x00FF 38 39 /**************************************************************************** 40 ** UWB_HAL_TASK definitions 41 *****************************************************************************/ 42 43 /* UWB_HAL_TASK event messages */ 44 /* UCI message for sending to UWBC */ 45 #define UWB_HAL_EVT_TO_UWB_UCI 0x0100 46 /* Request to start UCIT quick timer */ 47 #define UWB_HAL_EVT_POST_CORE_RESET 0x0200 48 /* Request to start chip-specific config */ 49 #define UWB_HAL_EVT_TO_START_QUICK_TIMER 0x0300 50 /* UCI message for hci persistency data */ 51 #define UWB_HAL_EVT_HCI 0x0400 52 /* UCI message to issue prediscover config */ 53 #define UWB_HAL_EVT_PRE_DISCOVER 0x0500 54 /* permission to send commands queued in HAL*/ 55 #define UWB_HAL_EVT_CONTROL_GRANTED 0x0600 56 57 /* UWB_HAL_TASK sub event messages */ 58 #define UWB_HAL_HCI_RSP_NV_READ_EVT (0x01 | UWB_HAL_EVT_HCI) 59 #define UWB_HAL_HCI_RSP_NV_WRITE_EVT (0x02 | UWB_HAL_EVT_HCI) 60 #define UWB_HAL_HCI_VSC_TIMEOUT_EVT (0x03 | UWB_HAL_EVT_HCI) 61 62 /* Event masks for UWB_TASK messages */ 63 /* UCI message for sending to host stack */ 64 #define UWB_EVT_TO_UWB_UCI 0x4000 65 /* Error notification to UWB Task */ 66 #define UWB_EVT_TO_UWB_ERR 0x4100 67 /* Messages between UWB and UCI task */ 68 #define UWB_EVT_TO_UWB_MSGS 0x4200 69 70 /***************************************************************************** 71 ** Macros to get and put bytes to and from a stream (Little Endian format). 72 *****************************************************************************/ 73 74 #define UINT32_TO_STREAM(p, u32) \ 75 { \ 76 *(p)++ = (uint8_t)(u32); \ 77 *(p)++ = (uint8_t)((u32) >> 8); \ 78 *(p)++ = (uint8_t)((u32) >> 16); \ 79 *(p)++ = (uint8_t)((u32) >> 24); \ 80 } 81 #define UINT24_TO_STREAM(p, u24) \ 82 { \ 83 *(p)++ = (uint8_t)(u24); \ 84 *(p)++ = (uint8_t)((u24) >> 8); \ 85 *(p)++ = (uint8_t)((u24) >> 16); \ 86 } 87 #define UINT16_TO_STREAM(p, u16) \ 88 { \ 89 *(p)++ = (uint8_t)(u16); \ 90 *(p)++ = (uint8_t)((u16) >> 8); \ 91 } 92 #define UINT8_TO_STREAM(p, u8) \ 93 { *(p)++ = (uint8_t)(u8); } 94 #define INT8_TO_STREAM(p, u8) \ 95 { *(p)++ = (int8_t)(u8); } 96 #define ARRAY32_TO_STREAM(p, a) \ 97 { \ 98 register int ijk; \ 99 for (ijk = 0; ijk < 32; ijk++) *(p)++ = (uint8_t)a[31 - ijk]; \ 100 } 101 #define ARRAY16_TO_STREAM(p, a) \ 102 { \ 103 register int ijk; \ 104 for (ijk = 0; ijk < 16; ijk++) *(p)++ = (uint8_t)a[15 - ijk]; \ 105 } 106 #define ARRAY8_TO_STREAM(p, a) \ 107 { \ 108 register int ijk; \ 109 for (ijk = 0; ijk < 8; ijk++) *(p)++ = (uint8_t)a[7 - ijk]; \ 110 } 111 #define BDADDR_TO_STREAM(p, a) \ 112 { \ 113 register int ijk; \ 114 for (ijk = 0; ijk < BD_ADDR_LEN; ijk++) \ 115 *(p)++ = (uint8_t)a[BD_ADDR_LEN - 1 - ijk]; \ 116 } 117 #define LAP_TO_STREAM(p, a) \ 118 { \ 119 register int ijk; \ 120 for (ijk = 0; ijk < LAP_LEN; ijk++) \ 121 *(p)++ = (uint8_t)a[LAP_LEN - 1 - ijk]; \ 122 } 123 #define DEVCLASS_TO_STREAM(p, a) \ 124 { \ 125 register int ijk; \ 126 for (ijk = 0; ijk < DEV_CLASS_LEN; ijk++) \ 127 *(p)++ = (uint8_t)a[DEV_CLASS_LEN - 1 - ijk]; \ 128 } 129 #define ARRAY_TO_STREAM(p, a, len) \ 130 { \ 131 register int ijk; \ 132 for (ijk = 0; ijk < len; ijk++) *(p)++ = (uint8_t)a[ijk]; \ 133 } 134 #define REVERSE_ARRAY_TO_STREAM(p, a, len) \ 135 { \ 136 register int ijk; \ 137 for (ijk = 0; ijk < len; ijk++) *(p)++ = (uint8_t)a[len - 1 - ijk]; \ 138 } 139 140 #define STREAM_TO_UINT8(u8, p) \ 141 { \ 142 u8 = (uint8_t)(*(p)); \ 143 (p) += 1; \ 144 } 145 #define STREAM_TO_UINT16(u16, p) \ 146 { \ 147 u16 = (uint16_t)((uint16_t)(*(p)) + (((uint16_t)(*((p) + 1))) << 8)); \ 148 (p) += 2; \ 149 } 150 #define STREAM_TO_INT16(i16, p) \ 151 { \ 152 i16 = (int16_t)((uint16_t)(*(p)) + (((uint16_t)(*((p) + 1))) << 8)); \ 153 (p) += 2; \ 154 } 155 #define STREAM_TO_UINT24(u32, p) \ 156 { \ 157 u32 = (((uint32_t)(*(p))) + ((((uint32_t)(*((p) + 1)))) << 8) + \ 158 ((((uint32_t)(*((p) + 2)))) << 16)); \ 159 (p) += 3; \ 160 } 161 #define STREAM_TO_UINT32(u32, p) \ 162 { \ 163 u32 = (((uint32_t)(*(p))) + ((((uint32_t)(*((p) + 1)))) << 8) + \ 164 ((((uint32_t)(*((p) + 2)))) << 16) + \ 165 ((((uint32_t)(*((p) + 3)))) << 24)); \ 166 (p) += 4; \ 167 } 168 #define STREAM_TO_UINT64(u64, p) \ 169 { \ 170 u64 = (((uint64_t)(*(p))) + ((((uint64_t)(*((p) + 1)))) << 8) + \ 171 ((((uint64_t)(*((p) + 2)))) << 16) + \ 172 ((((uint64_t)(*((p) + 3)))) << 24) + \ 173 ((((uint64_t)(*((p) + 4)))) << 32) + \ 174 ((((uint64_t)(*((p) + 5)))) << 40) + \ 175 ((((uint64_t)(*((p) + 6)))) << 48) + \ 176 ((((uint64_t)(*((p) + 7)))) << 56)); \ 177 (p) += 8; \ 178 } 179 #define STREAM_TO_BDADDR(a, p) \ 180 { \ 181 register int ijk; \ 182 register uint8_t* pbda = (uint8_t*)a + BD_ADDR_LEN - 1; \ 183 for (ijk = 0; ijk < BD_ADDR_LEN; ijk++) *pbda-- = *p++; \ 184 } 185 #define STREAM_TO_ARRAY32(a, p) \ 186 { \ 187 register int ijk; \ 188 register uint8_t* _pa = (uint8_t*)a + 31; \ 189 for (ijk = 0; ijk < 32; ijk++) *_pa-- = *p++; \ 190 } 191 #define STREAM_TO_ARRAY16(a, p) \ 192 { \ 193 register int ijk; \ 194 register uint8_t* _pa = (uint8_t*)a + 15; \ 195 for (ijk = 0; ijk < 16; ijk++) *_pa-- = *p++; \ 196 } 197 #define STREAM_TO_ARRAY8(a, p) \ 198 { \ 199 register int ijk; \ 200 register uint8_t* _pa = (uint8_t*)a + 7; \ 201 for (ijk = 0; ijk < 8; ijk++) *_pa-- = *p++; \ 202 } 203 #define STREAM_TO_DEVCLASS(a, p) \ 204 { \ 205 register int ijk; \ 206 register uint8_t* _pa = (uint8_t*)a + DEV_CLASS_LEN - 1; \ 207 for (ijk = 0; ijk < DEV_CLASS_LEN; ijk++) *_pa-- = *p++; \ 208 } 209 #define STREAM_TO_LAP(a, p) \ 210 { \ 211 register int ijk; \ 212 register uint8_t* plap = (uint8_t*)a + LAP_LEN - 1; \ 213 for (ijk = 0; ijk < LAP_LEN; ijk++) *plap-- = *p++; \ 214 } 215 #define STREAM_TO_ARRAY(a, p, len) \ 216 { \ 217 register int ijk; \ 218 for (ijk = 0; ijk < len; ijk++) ((uint8_t*)a)[ijk] = *p++; \ 219 } 220 #define REVERSE_STREAM_TO_ARRAY(a, p, len) \ 221 { \ 222 register int ijk; \ 223 register uint8_t* _pa = (uint8_t*)a + len - 1; \ 224 for (ijk = 0; ijk < len; ijk++) *_pa-- = *p++; \ 225 } 226 227 /***************************************************************************** 228 ** Macros to get and put bytes to and from a field (Little Endian format). 229 ** These are the same as to stream, except the pointer is not incremented. 230 *****************************************************************************/ 231 232 #define UINT32_TO_FIELD(p, u32) \ 233 { \ 234 *(uint8_t*)(p) = (uint8_t)(u32); \ 235 *((uint8_t*)(p) + 1) = (uint8_t)((u32) >> 8); \ 236 *((uint8_t*)(p) + 2) = (uint8_t)((u32) >> 16); \ 237 *((uint8_t*)(p) + 3) = (uint8_t)((u32) >> 24); \ 238 } 239 #define UINT24_TO_FIELD(p, u24) \ 240 { \ 241 *(uint8_t*)(p) = (uint8_t)(u24); \ 242 *((uint8_t*)(p) + 1) = (uint8_t)((u24) >> 8); \ 243 *((uint8_t*)(p) + 2) = (uint8_t)((u24) >> 16); \ 244 } 245 #define UINT16_TO_FIELD(p, u16) \ 246 { \ 247 *(uint8_t*)(p) = (uint8_t)(u16); \ 248 *((uint8_t*)(p) + 1) = (uint8_t)((u16) >> 8); \ 249 } 250 #define UINT8_TO_FIELD(p, u8) \ 251 { *(uint8_t*)(p) = (uint8_t)(u8); } 252 253 /***************************************************************************** 254 ** Macros to get and put bytes to and from a stream (Big Endian format) 255 *****************************************************************************/ 256 257 #define UINT32_TO_BE_STREAM(p, u32) \ 258 { \ 259 *(p)++ = (uint8_t)((u32) >> 24); \ 260 *(p)++ = (uint8_t)((u32) >> 16); \ 261 *(p)++ = (uint8_t)((u32) >> 8); \ 262 *(p)++ = (uint8_t)(u32); \ 263 } 264 #define UINT24_TO_BE_STREAM(p, u24) \ 265 { \ 266 *(p)++ = (uint8_t)((u24) >> 16); \ 267 *(p)++ = (uint8_t)((u24) >> 8); \ 268 *(p)++ = (uint8_t)(u24); \ 269 } 270 #define UINT16_TO_BE_STREAM(p, u16) \ 271 { \ 272 *(p)++ = (uint8_t)((u16) >> 8); \ 273 *(p)++ = (uint8_t)(u16); \ 274 } 275 #define UINT8_TO_BE_STREAM(p, u8) \ 276 { *(p)++ = (uint8_t)(u8); } 277 #define ARRAY_TO_BE_STREAM(p, a, len) \ 278 { \ 279 register int ijk; \ 280 for (ijk = 0; ijk < len; ijk++) *(p)++ = (uint8_t)a[ijk]; \ 281 } 282 283 #define BE_STREAM_TO_UINT8(u8, p) \ 284 { \ 285 u8 = (uint8_t)(*(p)); \ 286 (p) += 1; \ 287 } 288 #define BE_STREAM_TO_UINT16(u16, p) \ 289 { \ 290 u16 = (uint16_t)(((uint16_t)(*(p)) << 8) + (uint16_t)(*((p) + 1))); \ 291 (p) += 2; \ 292 } 293 #define BE_STREAM_TO_UINT24(u32, p) \ 294 { \ 295 u32 = (((uint32_t)(*((p) + 2))) + ((uint32_t)(*((p) + 1)) << 8) + \ 296 ((uint32_t)(*(p)) << 16)); \ 297 (p) += 3; \ 298 } 299 #define BE_STREAM_TO_UINT32(u32, p) \ 300 { \ 301 u32 = ((uint32_t)(*((p) + 3)) + ((uint32_t)(*((p) + 2)) << 8) + \ 302 ((uint32_t)(*((p) + 1)) << 16) + ((uint32_t)(*(p)) << 24)); \ 303 (p) += 4; \ 304 } 305 #define BE_STREAM_TO_ARRAY(p, a, len) \ 306 { \ 307 register int ijk; \ 308 for (ijk = 0; ijk < len; ijk++) ((uint8_t*)a)[ijk] = *p++; \ 309 } 310 311 /***************************************************************************** 312 ** Macros to get and put bytes to and from a field (Big Endian format). 313 ** These are the same as to stream, except the pointer is not incremented. 314 *****************************************************************************/ 315 316 #define UINT32_TO_BE_FIELD(p, u32) \ 317 { \ 318 *(uint8_t*)(p) = (uint8_t)((u32) >> 24); \ 319 *((uint8_t*)(p) + 1) = (uint8_t)((u32) >> 16); \ 320 *((uint8_t*)(p) + 2) = (uint8_t)((u32) >> 8); \ 321 *((uint8_t*)(p) + 3) = (uint8_t)(u32); \ 322 } 323 #define UINT24_TO_BE_FIELD(p, u24) \ 324 { \ 325 *(uint8_t*)(p) = (uint8_t)((u24) >> 16); \ 326 *((uint8_t*)(p) + 1) = (uint8_t)((u24) >> 8); \ 327 *((uint8_t*)(p) + 2) = (uint8_t)(u24); \ 328 } 329 #define UINT16_TO_BE_FIELD(p, u16) \ 330 { \ 331 *(uint8_t*)(p) = (uint8_t)((u16) >> 8); \ 332 *((uint8_t*)(p) + 1) = (uint8_t)(u16); \ 333 } 334 #define UINT8_TO_BE_FIELD(p, u8) \ 335 { *(uint8_t*)(p) = (uint8_t)(u8); } 336 337 /***************************************************************************** 338 ** Define trace levels 339 *****************************************************************************/ 340 341 /* No trace messages to be generated */ 342 #define BT_TRACE_LEVEL_NONE 0 343 /* Error condition trace messages */ 344 #define BT_TRACE_LEVEL_ERROR 1 345 /* Warning condition trace messages */ 346 #define BT_TRACE_LEVEL_WARNING 2 347 /* API traces */ 348 #define BT_TRACE_LEVEL_API 3 349 /* Debug messages for events */ 350 #define BT_TRACE_LEVEL_EVENT 4 351 /* Full debug messages */ 352 #define BT_TRACE_LEVEL_DEBUG 5 353 354 #define TRACE_CTRL_GENERAL 0x00000000 355 #define TRACE_LAYER_UCI 0x00280000 356 #define TRACE_LAYER_HAL 0x00310000 357 #define TRACE_LAYER_GKI 0x001a0000 358 #define TRACE_ORG_STACK 0x00000000 359 #define TRACE_ORG_GKI 0x00000400 360 361 #define TRACE_TYPE_ERROR 0x00000000 362 #define TRACE_TYPE_WARNING 0x00000001 363 #define TRACE_TYPE_API 0x00000002 364 #define TRACE_TYPE_EVENT 0x00000003 365 #define TRACE_TYPE_DEBUG 0x00000004 366 367 #define TRACE_TYPE_GENERIC 0x00000008 368 369 #endif /* UWB_TYPES_H */ 370