1 /* 2 * Copyright (C) 2014 BlueKitchen GmbH 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions 6 * are met: 7 * 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 3. Neither the name of the copyright holders nor the names of 14 * contributors may be used to endorse or promote products derived 15 * from this software without specific prior written permission. 16 * 4. Any redistribution, use, or modification is done solely for 17 * personal benefit and not for any commercial purpose or for 18 * monetary gain. 19 * 20 * THIS SOFTWARE IS PROVIDED BY BLUEKITCHEN GMBH AND CONTRIBUTORS 21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 22 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 23 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL MATTHIAS 24 * RINGWALD OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 25 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 26 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS 27 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 28 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 29 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF 30 * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 31 * SUCH DAMAGE. 32 * 33 * Please inquire about commercial licensing options at 34 * [email protected] 35 * 36 */ 37 38 39 #define BTSTACK_FILE__ "btstack_memory.c" 40 41 42 /* 43 * btstack_memory.c 44 * 45 * @brief BTstack memory management via configurable memory pools 46 * 47 * @note code generated by tool/btstack_memory_generator.py 48 * @note returnes buffers are initialized with 0 49 * 50 */ 51 52 #include "btstack_memory.h" 53 #include "btstack_memory_pool.h" 54 #include "btstack_debug.h" 55 56 #include <stdlib.h> 57 58 #ifdef HAVE_MALLOC 59 typedef struct btstack_memory_buffer { 60 struct btstack_memory_buffer * next; 61 struct btstack_memory_buffer * prev; 62 } btstack_memory_buffer_t; 63 64 static btstack_memory_buffer_t * btstack_memory_malloc_buffers; 65 66 static void btstack_memory_tracking_add(btstack_memory_buffer_t * buffer){ 67 btstack_assert(buffer != NULL); 68 buffer->prev = NULL; 69 buffer->next = btstack_memory_malloc_buffers; 70 btstack_memory_malloc_buffers = buffer; 71 } 72 73 static void btstack_memory_tracking_remove(btstack_memory_buffer_t * buffer){ 74 btstack_assert(buffer != NULL); 75 if (buffer->prev == NULL){ 76 // first item 77 btstack_memory_malloc_buffers = buffer->next; 78 } else { 79 buffer->prev->next = buffer->next; 80 } 81 if (buffer->next != NULL){ 82 buffer->next->prev = buffer->prev; 83 } 84 } 85 #endif 86 87 void btstack_memory_deinit(void){ 88 #ifdef HAVE_MALLOC 89 while (btstack_memory_malloc_buffers != NULL){ 90 btstack_memory_buffer_t * buffer = btstack_memory_malloc_buffers; 91 btstack_memory_malloc_buffers = buffer->next; 92 free(buffer); 93 } 94 #endif 95 } 96 97 98 // MARK: hci_connection_t 99 #if !defined(HAVE_MALLOC) && !defined(MAX_NR_HCI_CONNECTIONS) 100 #if defined(MAX_NO_HCI_CONNECTIONS) 101 #error "Deprecated MAX_NO_HCI_CONNECTIONS defined instead of MAX_NR_HCI_CONNECTIONS. Please update your btstack_config.h to use MAX_NR_HCI_CONNECTIONS." 102 #else 103 #define MAX_NR_HCI_CONNECTIONS 0 104 #endif 105 #endif 106 107 #ifdef MAX_NR_HCI_CONNECTIONS 108 #if MAX_NR_HCI_CONNECTIONS > 0 109 static hci_connection_t hci_connection_storage[MAX_NR_HCI_CONNECTIONS]; 110 static btstack_memory_pool_t hci_connection_pool; 111 hci_connection_t * btstack_memory_hci_connection_get(void){ 112 void * buffer = btstack_memory_pool_get(&hci_connection_pool); 113 if (buffer){ 114 memset(buffer, 0, sizeof(hci_connection_t)); 115 } 116 return (hci_connection_t *) buffer; 117 } 118 void btstack_memory_hci_connection_free(hci_connection_t *hci_connection){ 119 btstack_memory_pool_free(&hci_connection_pool, hci_connection); 120 } 121 #else 122 hci_connection_t * btstack_memory_hci_connection_get(void){ 123 return NULL; 124 } 125 void btstack_memory_hci_connection_free(hci_connection_t *hci_connection){ 126 UNUSED(hci_connection); 127 }; 128 #endif 129 #elif defined(HAVE_MALLOC) 130 131 typedef struct { 132 hci_connection_t data; 133 btstack_memory_buffer_t tracking; 134 } btstack_memory_hci_connection_t; 135 136 hci_connection_t * btstack_memory_hci_connection_get(void){ 137 btstack_memory_hci_connection_t * buffer = (btstack_memory_hci_connection_t *) malloc(sizeof(btstack_memory_hci_connection_t)); 138 if (buffer){ 139 memset(buffer, 0, sizeof(hci_connection_t)); 140 btstack_memory_tracking_add(&buffer->tracking); 141 return &buffer->data; 142 } else { 143 return NULL; 144 } 145 } 146 void btstack_memory_hci_connection_free(hci_connection_t *hci_connection){ 147 btstack_memory_hci_connection_t * buffer = (btstack_memory_hci_connection_t *) hci_connection; 148 btstack_memory_tracking_remove(&buffer->tracking); 149 free(buffer); 150 } 151 #endif 152 153 154 155 // MARK: l2cap_service_t 156 #if !defined(HAVE_MALLOC) && !defined(MAX_NR_L2CAP_SERVICES) 157 #if defined(MAX_NO_L2CAP_SERVICES) 158 #error "Deprecated MAX_NO_L2CAP_SERVICES defined instead of MAX_NR_L2CAP_SERVICES. Please update your btstack_config.h to use MAX_NR_L2CAP_SERVICES." 159 #else 160 #define MAX_NR_L2CAP_SERVICES 0 161 #endif 162 #endif 163 164 #ifdef MAX_NR_L2CAP_SERVICES 165 #if MAX_NR_L2CAP_SERVICES > 0 166 static l2cap_service_t l2cap_service_storage[MAX_NR_L2CAP_SERVICES]; 167 static btstack_memory_pool_t l2cap_service_pool; 168 l2cap_service_t * btstack_memory_l2cap_service_get(void){ 169 void * buffer = btstack_memory_pool_get(&l2cap_service_pool); 170 if (buffer){ 171 memset(buffer, 0, sizeof(l2cap_service_t)); 172 } 173 return (l2cap_service_t *) buffer; 174 } 175 void btstack_memory_l2cap_service_free(l2cap_service_t *l2cap_service){ 176 btstack_memory_pool_free(&l2cap_service_pool, l2cap_service); 177 } 178 #else 179 l2cap_service_t * btstack_memory_l2cap_service_get(void){ 180 return NULL; 181 } 182 void btstack_memory_l2cap_service_free(l2cap_service_t *l2cap_service){ 183 UNUSED(l2cap_service); 184 }; 185 #endif 186 #elif defined(HAVE_MALLOC) 187 188 typedef struct { 189 l2cap_service_t data; 190 btstack_memory_buffer_t tracking; 191 } btstack_memory_l2cap_service_t; 192 193 l2cap_service_t * btstack_memory_l2cap_service_get(void){ 194 btstack_memory_l2cap_service_t * buffer = (btstack_memory_l2cap_service_t *) malloc(sizeof(btstack_memory_l2cap_service_t)); 195 if (buffer){ 196 memset(buffer, 0, sizeof(l2cap_service_t)); 197 btstack_memory_tracking_add(&buffer->tracking); 198 return &buffer->data; 199 } else { 200 return NULL; 201 } 202 } 203 void btstack_memory_l2cap_service_free(l2cap_service_t *l2cap_service){ 204 btstack_memory_l2cap_service_t * buffer = (btstack_memory_l2cap_service_t *) l2cap_service; 205 btstack_memory_tracking_remove(&buffer->tracking); 206 free(buffer); 207 } 208 #endif 209 210 211 // MARK: l2cap_channel_t 212 #if !defined(HAVE_MALLOC) && !defined(MAX_NR_L2CAP_CHANNELS) 213 #if defined(MAX_NO_L2CAP_CHANNELS) 214 #error "Deprecated MAX_NO_L2CAP_CHANNELS defined instead of MAX_NR_L2CAP_CHANNELS. Please update your btstack_config.h to use MAX_NR_L2CAP_CHANNELS." 215 #else 216 #define MAX_NR_L2CAP_CHANNELS 0 217 #endif 218 #endif 219 220 #ifdef MAX_NR_L2CAP_CHANNELS 221 #if MAX_NR_L2CAP_CHANNELS > 0 222 static l2cap_channel_t l2cap_channel_storage[MAX_NR_L2CAP_CHANNELS]; 223 static btstack_memory_pool_t l2cap_channel_pool; 224 l2cap_channel_t * btstack_memory_l2cap_channel_get(void){ 225 void * buffer = btstack_memory_pool_get(&l2cap_channel_pool); 226 if (buffer){ 227 memset(buffer, 0, sizeof(l2cap_channel_t)); 228 } 229 return (l2cap_channel_t *) buffer; 230 } 231 void btstack_memory_l2cap_channel_free(l2cap_channel_t *l2cap_channel){ 232 btstack_memory_pool_free(&l2cap_channel_pool, l2cap_channel); 233 } 234 #else 235 l2cap_channel_t * btstack_memory_l2cap_channel_get(void){ 236 return NULL; 237 } 238 void btstack_memory_l2cap_channel_free(l2cap_channel_t *l2cap_channel){ 239 UNUSED(l2cap_channel); 240 }; 241 #endif 242 #elif defined(HAVE_MALLOC) 243 244 typedef struct { 245 l2cap_channel_t data; 246 btstack_memory_buffer_t tracking; 247 } btstack_memory_l2cap_channel_t; 248 249 l2cap_channel_t * btstack_memory_l2cap_channel_get(void){ 250 btstack_memory_l2cap_channel_t * buffer = (btstack_memory_l2cap_channel_t *) malloc(sizeof(btstack_memory_l2cap_channel_t)); 251 if (buffer){ 252 memset(buffer, 0, sizeof(l2cap_channel_t)); 253 btstack_memory_tracking_add(&buffer->tracking); 254 return &buffer->data; 255 } else { 256 return NULL; 257 } 258 } 259 void btstack_memory_l2cap_channel_free(l2cap_channel_t *l2cap_channel){ 260 btstack_memory_l2cap_channel_t * buffer = (btstack_memory_l2cap_channel_t *) l2cap_channel; 261 btstack_memory_tracking_remove(&buffer->tracking); 262 free(buffer); 263 } 264 #endif 265 266 267 #ifdef ENABLE_CLASSIC 268 269 // MARK: rfcomm_multiplexer_t 270 #if !defined(HAVE_MALLOC) && !defined(MAX_NR_RFCOMM_MULTIPLEXERS) 271 #if defined(MAX_NO_RFCOMM_MULTIPLEXERS) 272 #error "Deprecated MAX_NO_RFCOMM_MULTIPLEXERS defined instead of MAX_NR_RFCOMM_MULTIPLEXERS. Please update your btstack_config.h to use MAX_NR_RFCOMM_MULTIPLEXERS." 273 #else 274 #define MAX_NR_RFCOMM_MULTIPLEXERS 0 275 #endif 276 #endif 277 278 #ifdef MAX_NR_RFCOMM_MULTIPLEXERS 279 #if MAX_NR_RFCOMM_MULTIPLEXERS > 0 280 static rfcomm_multiplexer_t rfcomm_multiplexer_storage[MAX_NR_RFCOMM_MULTIPLEXERS]; 281 static btstack_memory_pool_t rfcomm_multiplexer_pool; 282 rfcomm_multiplexer_t * btstack_memory_rfcomm_multiplexer_get(void){ 283 void * buffer = btstack_memory_pool_get(&rfcomm_multiplexer_pool); 284 if (buffer){ 285 memset(buffer, 0, sizeof(rfcomm_multiplexer_t)); 286 } 287 return (rfcomm_multiplexer_t *) buffer; 288 } 289 void btstack_memory_rfcomm_multiplexer_free(rfcomm_multiplexer_t *rfcomm_multiplexer){ 290 btstack_memory_pool_free(&rfcomm_multiplexer_pool, rfcomm_multiplexer); 291 } 292 #else 293 rfcomm_multiplexer_t * btstack_memory_rfcomm_multiplexer_get(void){ 294 return NULL; 295 } 296 void btstack_memory_rfcomm_multiplexer_free(rfcomm_multiplexer_t *rfcomm_multiplexer){ 297 UNUSED(rfcomm_multiplexer); 298 }; 299 #endif 300 #elif defined(HAVE_MALLOC) 301 302 typedef struct { 303 rfcomm_multiplexer_t data; 304 btstack_memory_buffer_t tracking; 305 } btstack_memory_rfcomm_multiplexer_t; 306 307 rfcomm_multiplexer_t * btstack_memory_rfcomm_multiplexer_get(void){ 308 btstack_memory_rfcomm_multiplexer_t * buffer = (btstack_memory_rfcomm_multiplexer_t *) malloc(sizeof(btstack_memory_rfcomm_multiplexer_t)); 309 if (buffer){ 310 memset(buffer, 0, sizeof(rfcomm_multiplexer_t)); 311 btstack_memory_tracking_add(&buffer->tracking); 312 return &buffer->data; 313 } else { 314 return NULL; 315 } 316 } 317 void btstack_memory_rfcomm_multiplexer_free(rfcomm_multiplexer_t *rfcomm_multiplexer){ 318 btstack_memory_rfcomm_multiplexer_t * buffer = (btstack_memory_rfcomm_multiplexer_t *) rfcomm_multiplexer; 319 btstack_memory_tracking_remove(&buffer->tracking); 320 free(buffer); 321 } 322 #endif 323 324 325 // MARK: rfcomm_service_t 326 #if !defined(HAVE_MALLOC) && !defined(MAX_NR_RFCOMM_SERVICES) 327 #if defined(MAX_NO_RFCOMM_SERVICES) 328 #error "Deprecated MAX_NO_RFCOMM_SERVICES defined instead of MAX_NR_RFCOMM_SERVICES. Please update your btstack_config.h to use MAX_NR_RFCOMM_SERVICES." 329 #else 330 #define MAX_NR_RFCOMM_SERVICES 0 331 #endif 332 #endif 333 334 #ifdef MAX_NR_RFCOMM_SERVICES 335 #if MAX_NR_RFCOMM_SERVICES > 0 336 static rfcomm_service_t rfcomm_service_storage[MAX_NR_RFCOMM_SERVICES]; 337 static btstack_memory_pool_t rfcomm_service_pool; 338 rfcomm_service_t * btstack_memory_rfcomm_service_get(void){ 339 void * buffer = btstack_memory_pool_get(&rfcomm_service_pool); 340 if (buffer){ 341 memset(buffer, 0, sizeof(rfcomm_service_t)); 342 } 343 return (rfcomm_service_t *) buffer; 344 } 345 void btstack_memory_rfcomm_service_free(rfcomm_service_t *rfcomm_service){ 346 btstack_memory_pool_free(&rfcomm_service_pool, rfcomm_service); 347 } 348 #else 349 rfcomm_service_t * btstack_memory_rfcomm_service_get(void){ 350 return NULL; 351 } 352 void btstack_memory_rfcomm_service_free(rfcomm_service_t *rfcomm_service){ 353 UNUSED(rfcomm_service); 354 }; 355 #endif 356 #elif defined(HAVE_MALLOC) 357 358 typedef struct { 359 rfcomm_service_t data; 360 btstack_memory_buffer_t tracking; 361 } btstack_memory_rfcomm_service_t; 362 363 rfcomm_service_t * btstack_memory_rfcomm_service_get(void){ 364 btstack_memory_rfcomm_service_t * buffer = (btstack_memory_rfcomm_service_t *) malloc(sizeof(btstack_memory_rfcomm_service_t)); 365 if (buffer){ 366 memset(buffer, 0, sizeof(rfcomm_service_t)); 367 btstack_memory_tracking_add(&buffer->tracking); 368 return &buffer->data; 369 } else { 370 return NULL; 371 } 372 } 373 void btstack_memory_rfcomm_service_free(rfcomm_service_t *rfcomm_service){ 374 btstack_memory_rfcomm_service_t * buffer = (btstack_memory_rfcomm_service_t *) rfcomm_service; 375 btstack_memory_tracking_remove(&buffer->tracking); 376 free(buffer); 377 } 378 #endif 379 380 381 // MARK: rfcomm_channel_t 382 #if !defined(HAVE_MALLOC) && !defined(MAX_NR_RFCOMM_CHANNELS) 383 #if defined(MAX_NO_RFCOMM_CHANNELS) 384 #error "Deprecated MAX_NO_RFCOMM_CHANNELS defined instead of MAX_NR_RFCOMM_CHANNELS. Please update your btstack_config.h to use MAX_NR_RFCOMM_CHANNELS." 385 #else 386 #define MAX_NR_RFCOMM_CHANNELS 0 387 #endif 388 #endif 389 390 #ifdef MAX_NR_RFCOMM_CHANNELS 391 #if MAX_NR_RFCOMM_CHANNELS > 0 392 static rfcomm_channel_t rfcomm_channel_storage[MAX_NR_RFCOMM_CHANNELS]; 393 static btstack_memory_pool_t rfcomm_channel_pool; 394 rfcomm_channel_t * btstack_memory_rfcomm_channel_get(void){ 395 void * buffer = btstack_memory_pool_get(&rfcomm_channel_pool); 396 if (buffer){ 397 memset(buffer, 0, sizeof(rfcomm_channel_t)); 398 } 399 return (rfcomm_channel_t *) buffer; 400 } 401 void btstack_memory_rfcomm_channel_free(rfcomm_channel_t *rfcomm_channel){ 402 btstack_memory_pool_free(&rfcomm_channel_pool, rfcomm_channel); 403 } 404 #else 405 rfcomm_channel_t * btstack_memory_rfcomm_channel_get(void){ 406 return NULL; 407 } 408 void btstack_memory_rfcomm_channel_free(rfcomm_channel_t *rfcomm_channel){ 409 UNUSED(rfcomm_channel); 410 }; 411 #endif 412 #elif defined(HAVE_MALLOC) 413 414 typedef struct { 415 rfcomm_channel_t data; 416 btstack_memory_buffer_t tracking; 417 } btstack_memory_rfcomm_channel_t; 418 419 rfcomm_channel_t * btstack_memory_rfcomm_channel_get(void){ 420 btstack_memory_rfcomm_channel_t * buffer = (btstack_memory_rfcomm_channel_t *) malloc(sizeof(btstack_memory_rfcomm_channel_t)); 421 if (buffer){ 422 memset(buffer, 0, sizeof(rfcomm_channel_t)); 423 btstack_memory_tracking_add(&buffer->tracking); 424 return &buffer->data; 425 } else { 426 return NULL; 427 } 428 } 429 void btstack_memory_rfcomm_channel_free(rfcomm_channel_t *rfcomm_channel){ 430 btstack_memory_rfcomm_channel_t * buffer = (btstack_memory_rfcomm_channel_t *) rfcomm_channel; 431 btstack_memory_tracking_remove(&buffer->tracking); 432 free(buffer); 433 } 434 #endif 435 436 437 438 // MARK: btstack_link_key_db_memory_entry_t 439 #if !defined(HAVE_MALLOC) && !defined(MAX_NR_BTSTACK_LINK_KEY_DB_MEMORY_ENTRIES) 440 #if defined(MAX_NO_BTSTACK_LINK_KEY_DB_MEMORY_ENTRIES) 441 #error "Deprecated MAX_NO_BTSTACK_LINK_KEY_DB_MEMORY_ENTRIES defined instead of MAX_NR_BTSTACK_LINK_KEY_DB_MEMORY_ENTRIES. Please update your btstack_config.h to use MAX_NR_BTSTACK_LINK_KEY_DB_MEMORY_ENTRIES." 442 #else 443 #define MAX_NR_BTSTACK_LINK_KEY_DB_MEMORY_ENTRIES 0 444 #endif 445 #endif 446 447 #ifdef MAX_NR_BTSTACK_LINK_KEY_DB_MEMORY_ENTRIES 448 #if MAX_NR_BTSTACK_LINK_KEY_DB_MEMORY_ENTRIES > 0 449 static btstack_link_key_db_memory_entry_t btstack_link_key_db_memory_entry_storage[MAX_NR_BTSTACK_LINK_KEY_DB_MEMORY_ENTRIES]; 450 static btstack_memory_pool_t btstack_link_key_db_memory_entry_pool; 451 btstack_link_key_db_memory_entry_t * btstack_memory_btstack_link_key_db_memory_entry_get(void){ 452 void * buffer = btstack_memory_pool_get(&btstack_link_key_db_memory_entry_pool); 453 if (buffer){ 454 memset(buffer, 0, sizeof(btstack_link_key_db_memory_entry_t)); 455 } 456 return (btstack_link_key_db_memory_entry_t *) buffer; 457 } 458 void btstack_memory_btstack_link_key_db_memory_entry_free(btstack_link_key_db_memory_entry_t *btstack_link_key_db_memory_entry){ 459 btstack_memory_pool_free(&btstack_link_key_db_memory_entry_pool, btstack_link_key_db_memory_entry); 460 } 461 #else 462 btstack_link_key_db_memory_entry_t * btstack_memory_btstack_link_key_db_memory_entry_get(void){ 463 return NULL; 464 } 465 void btstack_memory_btstack_link_key_db_memory_entry_free(btstack_link_key_db_memory_entry_t *btstack_link_key_db_memory_entry){ 466 UNUSED(btstack_link_key_db_memory_entry); 467 }; 468 #endif 469 #elif defined(HAVE_MALLOC) 470 471 typedef struct { 472 btstack_link_key_db_memory_entry_t data; 473 btstack_memory_buffer_t tracking; 474 } btstack_memory_btstack_link_key_db_memory_entry_t; 475 476 btstack_link_key_db_memory_entry_t * btstack_memory_btstack_link_key_db_memory_entry_get(void){ 477 btstack_memory_btstack_link_key_db_memory_entry_t * buffer = (btstack_memory_btstack_link_key_db_memory_entry_t *) malloc(sizeof(btstack_memory_btstack_link_key_db_memory_entry_t)); 478 if (buffer){ 479 memset(buffer, 0, sizeof(btstack_link_key_db_memory_entry_t)); 480 btstack_memory_tracking_add(&buffer->tracking); 481 return &buffer->data; 482 } else { 483 return NULL; 484 } 485 } 486 void btstack_memory_btstack_link_key_db_memory_entry_free(btstack_link_key_db_memory_entry_t *btstack_link_key_db_memory_entry){ 487 btstack_memory_btstack_link_key_db_memory_entry_t * buffer = (btstack_memory_btstack_link_key_db_memory_entry_t *) btstack_link_key_db_memory_entry; 488 btstack_memory_tracking_remove(&buffer->tracking); 489 free(buffer); 490 } 491 #endif 492 493 494 495 // MARK: bnep_service_t 496 #if !defined(HAVE_MALLOC) && !defined(MAX_NR_BNEP_SERVICES) 497 #if defined(MAX_NO_BNEP_SERVICES) 498 #error "Deprecated MAX_NO_BNEP_SERVICES defined instead of MAX_NR_BNEP_SERVICES. Please update your btstack_config.h to use MAX_NR_BNEP_SERVICES." 499 #else 500 #define MAX_NR_BNEP_SERVICES 0 501 #endif 502 #endif 503 504 #ifdef MAX_NR_BNEP_SERVICES 505 #if MAX_NR_BNEP_SERVICES > 0 506 static bnep_service_t bnep_service_storage[MAX_NR_BNEP_SERVICES]; 507 static btstack_memory_pool_t bnep_service_pool; 508 bnep_service_t * btstack_memory_bnep_service_get(void){ 509 void * buffer = btstack_memory_pool_get(&bnep_service_pool); 510 if (buffer){ 511 memset(buffer, 0, sizeof(bnep_service_t)); 512 } 513 return (bnep_service_t *) buffer; 514 } 515 void btstack_memory_bnep_service_free(bnep_service_t *bnep_service){ 516 btstack_memory_pool_free(&bnep_service_pool, bnep_service); 517 } 518 #else 519 bnep_service_t * btstack_memory_bnep_service_get(void){ 520 return NULL; 521 } 522 void btstack_memory_bnep_service_free(bnep_service_t *bnep_service){ 523 UNUSED(bnep_service); 524 }; 525 #endif 526 #elif defined(HAVE_MALLOC) 527 528 typedef struct { 529 bnep_service_t data; 530 btstack_memory_buffer_t tracking; 531 } btstack_memory_bnep_service_t; 532 533 bnep_service_t * btstack_memory_bnep_service_get(void){ 534 btstack_memory_bnep_service_t * buffer = (btstack_memory_bnep_service_t *) malloc(sizeof(btstack_memory_bnep_service_t)); 535 if (buffer){ 536 memset(buffer, 0, sizeof(bnep_service_t)); 537 btstack_memory_tracking_add(&buffer->tracking); 538 return &buffer->data; 539 } else { 540 return NULL; 541 } 542 } 543 void btstack_memory_bnep_service_free(bnep_service_t *bnep_service){ 544 btstack_memory_bnep_service_t * buffer = (btstack_memory_bnep_service_t *) bnep_service; 545 btstack_memory_tracking_remove(&buffer->tracking); 546 free(buffer); 547 } 548 #endif 549 550 551 // MARK: bnep_channel_t 552 #if !defined(HAVE_MALLOC) && !defined(MAX_NR_BNEP_CHANNELS) 553 #if defined(MAX_NO_BNEP_CHANNELS) 554 #error "Deprecated MAX_NO_BNEP_CHANNELS defined instead of MAX_NR_BNEP_CHANNELS. Please update your btstack_config.h to use MAX_NR_BNEP_CHANNELS." 555 #else 556 #define MAX_NR_BNEP_CHANNELS 0 557 #endif 558 #endif 559 560 #ifdef MAX_NR_BNEP_CHANNELS 561 #if MAX_NR_BNEP_CHANNELS > 0 562 static bnep_channel_t bnep_channel_storage[MAX_NR_BNEP_CHANNELS]; 563 static btstack_memory_pool_t bnep_channel_pool; 564 bnep_channel_t * btstack_memory_bnep_channel_get(void){ 565 void * buffer = btstack_memory_pool_get(&bnep_channel_pool); 566 if (buffer){ 567 memset(buffer, 0, sizeof(bnep_channel_t)); 568 } 569 return (bnep_channel_t *) buffer; 570 } 571 void btstack_memory_bnep_channel_free(bnep_channel_t *bnep_channel){ 572 btstack_memory_pool_free(&bnep_channel_pool, bnep_channel); 573 } 574 #else 575 bnep_channel_t * btstack_memory_bnep_channel_get(void){ 576 return NULL; 577 } 578 void btstack_memory_bnep_channel_free(bnep_channel_t *bnep_channel){ 579 UNUSED(bnep_channel); 580 }; 581 #endif 582 #elif defined(HAVE_MALLOC) 583 584 typedef struct { 585 bnep_channel_t data; 586 btstack_memory_buffer_t tracking; 587 } btstack_memory_bnep_channel_t; 588 589 bnep_channel_t * btstack_memory_bnep_channel_get(void){ 590 btstack_memory_bnep_channel_t * buffer = (btstack_memory_bnep_channel_t *) malloc(sizeof(btstack_memory_bnep_channel_t)); 591 if (buffer){ 592 memset(buffer, 0, sizeof(bnep_channel_t)); 593 btstack_memory_tracking_add(&buffer->tracking); 594 return &buffer->data; 595 } else { 596 return NULL; 597 } 598 } 599 void btstack_memory_bnep_channel_free(bnep_channel_t *bnep_channel){ 600 btstack_memory_bnep_channel_t * buffer = (btstack_memory_bnep_channel_t *) bnep_channel; 601 btstack_memory_tracking_remove(&buffer->tracking); 602 free(buffer); 603 } 604 #endif 605 606 607 608 // MARK: hfp_connection_t 609 #if !defined(HAVE_MALLOC) && !defined(MAX_NR_HFP_CONNECTIONS) 610 #if defined(MAX_NO_HFP_CONNECTIONS) 611 #error "Deprecated MAX_NO_HFP_CONNECTIONS defined instead of MAX_NR_HFP_CONNECTIONS. Please update your btstack_config.h to use MAX_NR_HFP_CONNECTIONS." 612 #else 613 #define MAX_NR_HFP_CONNECTIONS 0 614 #endif 615 #endif 616 617 #ifdef MAX_NR_HFP_CONNECTIONS 618 #if MAX_NR_HFP_CONNECTIONS > 0 619 static hfp_connection_t hfp_connection_storage[MAX_NR_HFP_CONNECTIONS]; 620 static btstack_memory_pool_t hfp_connection_pool; 621 hfp_connection_t * btstack_memory_hfp_connection_get(void){ 622 void * buffer = btstack_memory_pool_get(&hfp_connection_pool); 623 if (buffer){ 624 memset(buffer, 0, sizeof(hfp_connection_t)); 625 } 626 return (hfp_connection_t *) buffer; 627 } 628 void btstack_memory_hfp_connection_free(hfp_connection_t *hfp_connection){ 629 btstack_memory_pool_free(&hfp_connection_pool, hfp_connection); 630 } 631 #else 632 hfp_connection_t * btstack_memory_hfp_connection_get(void){ 633 return NULL; 634 } 635 void btstack_memory_hfp_connection_free(hfp_connection_t *hfp_connection){ 636 UNUSED(hfp_connection); 637 }; 638 #endif 639 #elif defined(HAVE_MALLOC) 640 641 typedef struct { 642 hfp_connection_t data; 643 btstack_memory_buffer_t tracking; 644 } btstack_memory_hfp_connection_t; 645 646 hfp_connection_t * btstack_memory_hfp_connection_get(void){ 647 btstack_memory_hfp_connection_t * buffer = (btstack_memory_hfp_connection_t *) malloc(sizeof(btstack_memory_hfp_connection_t)); 648 if (buffer){ 649 memset(buffer, 0, sizeof(hfp_connection_t)); 650 btstack_memory_tracking_add(&buffer->tracking); 651 return &buffer->data; 652 } else { 653 return NULL; 654 } 655 } 656 void btstack_memory_hfp_connection_free(hfp_connection_t *hfp_connection){ 657 btstack_memory_hfp_connection_t * buffer = (btstack_memory_hfp_connection_t *) hfp_connection; 658 btstack_memory_tracking_remove(&buffer->tracking); 659 free(buffer); 660 } 661 #endif 662 663 664 665 // MARK: service_record_item_t 666 #if !defined(HAVE_MALLOC) && !defined(MAX_NR_SERVICE_RECORD_ITEMS) 667 #if defined(MAX_NO_SERVICE_RECORD_ITEMS) 668 #error "Deprecated MAX_NO_SERVICE_RECORD_ITEMS defined instead of MAX_NR_SERVICE_RECORD_ITEMS. Please update your btstack_config.h to use MAX_NR_SERVICE_RECORD_ITEMS." 669 #else 670 #define MAX_NR_SERVICE_RECORD_ITEMS 0 671 #endif 672 #endif 673 674 #ifdef MAX_NR_SERVICE_RECORD_ITEMS 675 #if MAX_NR_SERVICE_RECORD_ITEMS > 0 676 static service_record_item_t service_record_item_storage[MAX_NR_SERVICE_RECORD_ITEMS]; 677 static btstack_memory_pool_t service_record_item_pool; 678 service_record_item_t * btstack_memory_service_record_item_get(void){ 679 void * buffer = btstack_memory_pool_get(&service_record_item_pool); 680 if (buffer){ 681 memset(buffer, 0, sizeof(service_record_item_t)); 682 } 683 return (service_record_item_t *) buffer; 684 } 685 void btstack_memory_service_record_item_free(service_record_item_t *service_record_item){ 686 btstack_memory_pool_free(&service_record_item_pool, service_record_item); 687 } 688 #else 689 service_record_item_t * btstack_memory_service_record_item_get(void){ 690 return NULL; 691 } 692 void btstack_memory_service_record_item_free(service_record_item_t *service_record_item){ 693 UNUSED(service_record_item); 694 }; 695 #endif 696 #elif defined(HAVE_MALLOC) 697 698 typedef struct { 699 service_record_item_t data; 700 btstack_memory_buffer_t tracking; 701 } btstack_memory_service_record_item_t; 702 703 service_record_item_t * btstack_memory_service_record_item_get(void){ 704 btstack_memory_service_record_item_t * buffer = (btstack_memory_service_record_item_t *) malloc(sizeof(btstack_memory_service_record_item_t)); 705 if (buffer){ 706 memset(buffer, 0, sizeof(service_record_item_t)); 707 btstack_memory_tracking_add(&buffer->tracking); 708 return &buffer->data; 709 } else { 710 return NULL; 711 } 712 } 713 void btstack_memory_service_record_item_free(service_record_item_t *service_record_item){ 714 btstack_memory_service_record_item_t * buffer = (btstack_memory_service_record_item_t *) service_record_item; 715 btstack_memory_tracking_remove(&buffer->tracking); 716 free(buffer); 717 } 718 #endif 719 720 721 722 // MARK: avdtp_stream_endpoint_t 723 #if !defined(HAVE_MALLOC) && !defined(MAX_NR_AVDTP_STREAM_ENDPOINTS) 724 #if defined(MAX_NO_AVDTP_STREAM_ENDPOINTS) 725 #error "Deprecated MAX_NO_AVDTP_STREAM_ENDPOINTS defined instead of MAX_NR_AVDTP_STREAM_ENDPOINTS. Please update your btstack_config.h to use MAX_NR_AVDTP_STREAM_ENDPOINTS." 726 #else 727 #define MAX_NR_AVDTP_STREAM_ENDPOINTS 0 728 #endif 729 #endif 730 731 #ifdef MAX_NR_AVDTP_STREAM_ENDPOINTS 732 #if MAX_NR_AVDTP_STREAM_ENDPOINTS > 0 733 static avdtp_stream_endpoint_t avdtp_stream_endpoint_storage[MAX_NR_AVDTP_STREAM_ENDPOINTS]; 734 static btstack_memory_pool_t avdtp_stream_endpoint_pool; 735 avdtp_stream_endpoint_t * btstack_memory_avdtp_stream_endpoint_get(void){ 736 void * buffer = btstack_memory_pool_get(&avdtp_stream_endpoint_pool); 737 if (buffer){ 738 memset(buffer, 0, sizeof(avdtp_stream_endpoint_t)); 739 } 740 return (avdtp_stream_endpoint_t *) buffer; 741 } 742 void btstack_memory_avdtp_stream_endpoint_free(avdtp_stream_endpoint_t *avdtp_stream_endpoint){ 743 btstack_memory_pool_free(&avdtp_stream_endpoint_pool, avdtp_stream_endpoint); 744 } 745 #else 746 avdtp_stream_endpoint_t * btstack_memory_avdtp_stream_endpoint_get(void){ 747 return NULL; 748 } 749 void btstack_memory_avdtp_stream_endpoint_free(avdtp_stream_endpoint_t *avdtp_stream_endpoint){ 750 UNUSED(avdtp_stream_endpoint); 751 }; 752 #endif 753 #elif defined(HAVE_MALLOC) 754 755 typedef struct { 756 avdtp_stream_endpoint_t data; 757 btstack_memory_buffer_t tracking; 758 } btstack_memory_avdtp_stream_endpoint_t; 759 760 avdtp_stream_endpoint_t * btstack_memory_avdtp_stream_endpoint_get(void){ 761 btstack_memory_avdtp_stream_endpoint_t * buffer = (btstack_memory_avdtp_stream_endpoint_t *) malloc(sizeof(btstack_memory_avdtp_stream_endpoint_t)); 762 if (buffer){ 763 memset(buffer, 0, sizeof(avdtp_stream_endpoint_t)); 764 btstack_memory_tracking_add(&buffer->tracking); 765 return &buffer->data; 766 } else { 767 return NULL; 768 } 769 } 770 void btstack_memory_avdtp_stream_endpoint_free(avdtp_stream_endpoint_t *avdtp_stream_endpoint){ 771 btstack_memory_avdtp_stream_endpoint_t * buffer = (btstack_memory_avdtp_stream_endpoint_t *) avdtp_stream_endpoint; 772 btstack_memory_tracking_remove(&buffer->tracking); 773 free(buffer); 774 } 775 #endif 776 777 778 779 // MARK: avdtp_connection_t 780 #if !defined(HAVE_MALLOC) && !defined(MAX_NR_AVDTP_CONNECTIONS) 781 #if defined(MAX_NO_AVDTP_CONNECTIONS) 782 #error "Deprecated MAX_NO_AVDTP_CONNECTIONS defined instead of MAX_NR_AVDTP_CONNECTIONS. Please update your btstack_config.h to use MAX_NR_AVDTP_CONNECTIONS." 783 #else 784 #define MAX_NR_AVDTP_CONNECTIONS 0 785 #endif 786 #endif 787 788 #ifdef MAX_NR_AVDTP_CONNECTIONS 789 #if MAX_NR_AVDTP_CONNECTIONS > 0 790 static avdtp_connection_t avdtp_connection_storage[MAX_NR_AVDTP_CONNECTIONS]; 791 static btstack_memory_pool_t avdtp_connection_pool; 792 avdtp_connection_t * btstack_memory_avdtp_connection_get(void){ 793 void * buffer = btstack_memory_pool_get(&avdtp_connection_pool); 794 if (buffer){ 795 memset(buffer, 0, sizeof(avdtp_connection_t)); 796 } 797 return (avdtp_connection_t *) buffer; 798 } 799 void btstack_memory_avdtp_connection_free(avdtp_connection_t *avdtp_connection){ 800 btstack_memory_pool_free(&avdtp_connection_pool, avdtp_connection); 801 } 802 #else 803 avdtp_connection_t * btstack_memory_avdtp_connection_get(void){ 804 return NULL; 805 } 806 void btstack_memory_avdtp_connection_free(avdtp_connection_t *avdtp_connection){ 807 UNUSED(avdtp_connection); 808 }; 809 #endif 810 #elif defined(HAVE_MALLOC) 811 812 typedef struct { 813 avdtp_connection_t data; 814 btstack_memory_buffer_t tracking; 815 } btstack_memory_avdtp_connection_t; 816 817 avdtp_connection_t * btstack_memory_avdtp_connection_get(void){ 818 btstack_memory_avdtp_connection_t * buffer = (btstack_memory_avdtp_connection_t *) malloc(sizeof(btstack_memory_avdtp_connection_t)); 819 if (buffer){ 820 memset(buffer, 0, sizeof(avdtp_connection_t)); 821 btstack_memory_tracking_add(&buffer->tracking); 822 return &buffer->data; 823 } else { 824 return NULL; 825 } 826 } 827 void btstack_memory_avdtp_connection_free(avdtp_connection_t *avdtp_connection){ 828 btstack_memory_avdtp_connection_t * buffer = (btstack_memory_avdtp_connection_t *) avdtp_connection; 829 btstack_memory_tracking_remove(&buffer->tracking); 830 free(buffer); 831 } 832 #endif 833 834 835 836 // MARK: avrcp_connection_t 837 #if !defined(HAVE_MALLOC) && !defined(MAX_NR_AVRCP_CONNECTIONS) 838 #if defined(MAX_NO_AVRCP_CONNECTIONS) 839 #error "Deprecated MAX_NO_AVRCP_CONNECTIONS defined instead of MAX_NR_AVRCP_CONNECTIONS. Please update your btstack_config.h to use MAX_NR_AVRCP_CONNECTIONS." 840 #else 841 #define MAX_NR_AVRCP_CONNECTIONS 0 842 #endif 843 #endif 844 845 #ifdef MAX_NR_AVRCP_CONNECTIONS 846 #if MAX_NR_AVRCP_CONNECTIONS > 0 847 static avrcp_connection_t avrcp_connection_storage[MAX_NR_AVRCP_CONNECTIONS]; 848 static btstack_memory_pool_t avrcp_connection_pool; 849 avrcp_connection_t * btstack_memory_avrcp_connection_get(void){ 850 void * buffer = btstack_memory_pool_get(&avrcp_connection_pool); 851 if (buffer){ 852 memset(buffer, 0, sizeof(avrcp_connection_t)); 853 } 854 return (avrcp_connection_t *) buffer; 855 } 856 void btstack_memory_avrcp_connection_free(avrcp_connection_t *avrcp_connection){ 857 btstack_memory_pool_free(&avrcp_connection_pool, avrcp_connection); 858 } 859 #else 860 avrcp_connection_t * btstack_memory_avrcp_connection_get(void){ 861 return NULL; 862 } 863 void btstack_memory_avrcp_connection_free(avrcp_connection_t *avrcp_connection){ 864 UNUSED(avrcp_connection); 865 }; 866 #endif 867 #elif defined(HAVE_MALLOC) 868 869 typedef struct { 870 avrcp_connection_t data; 871 btstack_memory_buffer_t tracking; 872 } btstack_memory_avrcp_connection_t; 873 874 avrcp_connection_t * btstack_memory_avrcp_connection_get(void){ 875 btstack_memory_avrcp_connection_t * buffer = (btstack_memory_avrcp_connection_t *) malloc(sizeof(btstack_memory_avrcp_connection_t)); 876 if (buffer){ 877 memset(buffer, 0, sizeof(avrcp_connection_t)); 878 btstack_memory_tracking_add(&buffer->tracking); 879 return &buffer->data; 880 } else { 881 return NULL; 882 } 883 } 884 void btstack_memory_avrcp_connection_free(avrcp_connection_t *avrcp_connection){ 885 btstack_memory_avrcp_connection_t * buffer = (btstack_memory_avrcp_connection_t *) avrcp_connection; 886 btstack_memory_tracking_remove(&buffer->tracking); 887 free(buffer); 888 } 889 #endif 890 891 892 893 // MARK: avrcp_browsing_connection_t 894 #if !defined(HAVE_MALLOC) && !defined(MAX_NR_AVRCP_BROWSING_CONNECTIONS) 895 #if defined(MAX_NO_AVRCP_BROWSING_CONNECTIONS) 896 #error "Deprecated MAX_NO_AVRCP_BROWSING_CONNECTIONS defined instead of MAX_NR_AVRCP_BROWSING_CONNECTIONS. Please update your btstack_config.h to use MAX_NR_AVRCP_BROWSING_CONNECTIONS." 897 #else 898 #define MAX_NR_AVRCP_BROWSING_CONNECTIONS 0 899 #endif 900 #endif 901 902 #ifdef MAX_NR_AVRCP_BROWSING_CONNECTIONS 903 #if MAX_NR_AVRCP_BROWSING_CONNECTIONS > 0 904 static avrcp_browsing_connection_t avrcp_browsing_connection_storage[MAX_NR_AVRCP_BROWSING_CONNECTIONS]; 905 static btstack_memory_pool_t avrcp_browsing_connection_pool; 906 avrcp_browsing_connection_t * btstack_memory_avrcp_browsing_connection_get(void){ 907 void * buffer = btstack_memory_pool_get(&avrcp_browsing_connection_pool); 908 if (buffer){ 909 memset(buffer, 0, sizeof(avrcp_browsing_connection_t)); 910 } 911 return (avrcp_browsing_connection_t *) buffer; 912 } 913 void btstack_memory_avrcp_browsing_connection_free(avrcp_browsing_connection_t *avrcp_browsing_connection){ 914 btstack_memory_pool_free(&avrcp_browsing_connection_pool, avrcp_browsing_connection); 915 } 916 #else 917 avrcp_browsing_connection_t * btstack_memory_avrcp_browsing_connection_get(void){ 918 return NULL; 919 } 920 void btstack_memory_avrcp_browsing_connection_free(avrcp_browsing_connection_t *avrcp_browsing_connection){ 921 UNUSED(avrcp_browsing_connection); 922 }; 923 #endif 924 #elif defined(HAVE_MALLOC) 925 926 typedef struct { 927 avrcp_browsing_connection_t data; 928 btstack_memory_buffer_t tracking; 929 } btstack_memory_avrcp_browsing_connection_t; 930 931 avrcp_browsing_connection_t * btstack_memory_avrcp_browsing_connection_get(void){ 932 btstack_memory_avrcp_browsing_connection_t * buffer = (btstack_memory_avrcp_browsing_connection_t *) malloc(sizeof(btstack_memory_avrcp_browsing_connection_t)); 933 if (buffer){ 934 memset(buffer, 0, sizeof(avrcp_browsing_connection_t)); 935 btstack_memory_tracking_add(&buffer->tracking); 936 return &buffer->data; 937 } else { 938 return NULL; 939 } 940 } 941 void btstack_memory_avrcp_browsing_connection_free(avrcp_browsing_connection_t *avrcp_browsing_connection){ 942 btstack_memory_avrcp_browsing_connection_t * buffer = (btstack_memory_avrcp_browsing_connection_t *) avrcp_browsing_connection; 943 btstack_memory_tracking_remove(&buffer->tracking); 944 free(buffer); 945 } 946 #endif 947 948 949 #endif 950 #ifdef ENABLE_BLE 951 952 // MARK: gatt_client_t 953 #if !defined(HAVE_MALLOC) && !defined(MAX_NR_GATT_CLIENTS) 954 #if defined(MAX_NO_GATT_CLIENTS) 955 #error "Deprecated MAX_NO_GATT_CLIENTS defined instead of MAX_NR_GATT_CLIENTS. Please update your btstack_config.h to use MAX_NR_GATT_CLIENTS." 956 #else 957 #define MAX_NR_GATT_CLIENTS 0 958 #endif 959 #endif 960 961 #ifdef MAX_NR_GATT_CLIENTS 962 #if MAX_NR_GATT_CLIENTS > 0 963 static gatt_client_t gatt_client_storage[MAX_NR_GATT_CLIENTS]; 964 static btstack_memory_pool_t gatt_client_pool; 965 gatt_client_t * btstack_memory_gatt_client_get(void){ 966 void * buffer = btstack_memory_pool_get(&gatt_client_pool); 967 if (buffer){ 968 memset(buffer, 0, sizeof(gatt_client_t)); 969 } 970 return (gatt_client_t *) buffer; 971 } 972 void btstack_memory_gatt_client_free(gatt_client_t *gatt_client){ 973 btstack_memory_pool_free(&gatt_client_pool, gatt_client); 974 } 975 #else 976 gatt_client_t * btstack_memory_gatt_client_get(void){ 977 return NULL; 978 } 979 void btstack_memory_gatt_client_free(gatt_client_t *gatt_client){ 980 UNUSED(gatt_client); 981 }; 982 #endif 983 #elif defined(HAVE_MALLOC) 984 985 typedef struct { 986 gatt_client_t data; 987 btstack_memory_buffer_t tracking; 988 } btstack_memory_gatt_client_t; 989 990 gatt_client_t * btstack_memory_gatt_client_get(void){ 991 btstack_memory_gatt_client_t * buffer = (btstack_memory_gatt_client_t *) malloc(sizeof(btstack_memory_gatt_client_t)); 992 if (buffer){ 993 memset(buffer, 0, sizeof(gatt_client_t)); 994 btstack_memory_tracking_add(&buffer->tracking); 995 return &buffer->data; 996 } else { 997 return NULL; 998 } 999 } 1000 void btstack_memory_gatt_client_free(gatt_client_t *gatt_client){ 1001 btstack_memory_gatt_client_t * buffer = (btstack_memory_gatt_client_t *) gatt_client; 1002 btstack_memory_tracking_remove(&buffer->tracking); 1003 free(buffer); 1004 } 1005 #endif 1006 1007 1008 // MARK: whitelist_entry_t 1009 #if !defined(HAVE_MALLOC) && !defined(MAX_NR_WHITELIST_ENTRIES) 1010 #if defined(MAX_NO_WHITELIST_ENTRIES) 1011 #error "Deprecated MAX_NO_WHITELIST_ENTRIES defined instead of MAX_NR_WHITELIST_ENTRIES. Please update your btstack_config.h to use MAX_NR_WHITELIST_ENTRIES." 1012 #else 1013 #define MAX_NR_WHITELIST_ENTRIES 0 1014 #endif 1015 #endif 1016 1017 #ifdef MAX_NR_WHITELIST_ENTRIES 1018 #if MAX_NR_WHITELIST_ENTRIES > 0 1019 static whitelist_entry_t whitelist_entry_storage[MAX_NR_WHITELIST_ENTRIES]; 1020 static btstack_memory_pool_t whitelist_entry_pool; 1021 whitelist_entry_t * btstack_memory_whitelist_entry_get(void){ 1022 void * buffer = btstack_memory_pool_get(&whitelist_entry_pool); 1023 if (buffer){ 1024 memset(buffer, 0, sizeof(whitelist_entry_t)); 1025 } 1026 return (whitelist_entry_t *) buffer; 1027 } 1028 void btstack_memory_whitelist_entry_free(whitelist_entry_t *whitelist_entry){ 1029 btstack_memory_pool_free(&whitelist_entry_pool, whitelist_entry); 1030 } 1031 #else 1032 whitelist_entry_t * btstack_memory_whitelist_entry_get(void){ 1033 return NULL; 1034 } 1035 void btstack_memory_whitelist_entry_free(whitelist_entry_t *whitelist_entry){ 1036 UNUSED(whitelist_entry); 1037 }; 1038 #endif 1039 #elif defined(HAVE_MALLOC) 1040 1041 typedef struct { 1042 whitelist_entry_t data; 1043 btstack_memory_buffer_t tracking; 1044 } btstack_memory_whitelist_entry_t; 1045 1046 whitelist_entry_t * btstack_memory_whitelist_entry_get(void){ 1047 btstack_memory_whitelist_entry_t * buffer = (btstack_memory_whitelist_entry_t *) malloc(sizeof(btstack_memory_whitelist_entry_t)); 1048 if (buffer){ 1049 memset(buffer, 0, sizeof(whitelist_entry_t)); 1050 btstack_memory_tracking_add(&buffer->tracking); 1051 return &buffer->data; 1052 } else { 1053 return NULL; 1054 } 1055 } 1056 void btstack_memory_whitelist_entry_free(whitelist_entry_t *whitelist_entry){ 1057 btstack_memory_whitelist_entry_t * buffer = (btstack_memory_whitelist_entry_t *) whitelist_entry; 1058 btstack_memory_tracking_remove(&buffer->tracking); 1059 free(buffer); 1060 } 1061 #endif 1062 1063 1064 // MARK: sm_lookup_entry_t 1065 #if !defined(HAVE_MALLOC) && !defined(MAX_NR_SM_LOOKUP_ENTRIES) 1066 #if defined(MAX_NO_SM_LOOKUP_ENTRIES) 1067 #error "Deprecated MAX_NO_SM_LOOKUP_ENTRIES defined instead of MAX_NR_SM_LOOKUP_ENTRIES. Please update your btstack_config.h to use MAX_NR_SM_LOOKUP_ENTRIES." 1068 #else 1069 #define MAX_NR_SM_LOOKUP_ENTRIES 0 1070 #endif 1071 #endif 1072 1073 #ifdef MAX_NR_SM_LOOKUP_ENTRIES 1074 #if MAX_NR_SM_LOOKUP_ENTRIES > 0 1075 static sm_lookup_entry_t sm_lookup_entry_storage[MAX_NR_SM_LOOKUP_ENTRIES]; 1076 static btstack_memory_pool_t sm_lookup_entry_pool; 1077 sm_lookup_entry_t * btstack_memory_sm_lookup_entry_get(void){ 1078 void * buffer = btstack_memory_pool_get(&sm_lookup_entry_pool); 1079 if (buffer){ 1080 memset(buffer, 0, sizeof(sm_lookup_entry_t)); 1081 } 1082 return (sm_lookup_entry_t *) buffer; 1083 } 1084 void btstack_memory_sm_lookup_entry_free(sm_lookup_entry_t *sm_lookup_entry){ 1085 btstack_memory_pool_free(&sm_lookup_entry_pool, sm_lookup_entry); 1086 } 1087 #else 1088 sm_lookup_entry_t * btstack_memory_sm_lookup_entry_get(void){ 1089 return NULL; 1090 } 1091 void btstack_memory_sm_lookup_entry_free(sm_lookup_entry_t *sm_lookup_entry){ 1092 UNUSED(sm_lookup_entry); 1093 }; 1094 #endif 1095 #elif defined(HAVE_MALLOC) 1096 1097 typedef struct { 1098 sm_lookup_entry_t data; 1099 btstack_memory_buffer_t tracking; 1100 } btstack_memory_sm_lookup_entry_t; 1101 1102 sm_lookup_entry_t * btstack_memory_sm_lookup_entry_get(void){ 1103 btstack_memory_sm_lookup_entry_t * buffer = (btstack_memory_sm_lookup_entry_t *) malloc(sizeof(btstack_memory_sm_lookup_entry_t)); 1104 if (buffer){ 1105 memset(buffer, 0, sizeof(sm_lookup_entry_t)); 1106 btstack_memory_tracking_add(&buffer->tracking); 1107 return &buffer->data; 1108 } else { 1109 return NULL; 1110 } 1111 } 1112 void btstack_memory_sm_lookup_entry_free(sm_lookup_entry_t *sm_lookup_entry){ 1113 btstack_memory_sm_lookup_entry_t * buffer = (btstack_memory_sm_lookup_entry_t *) sm_lookup_entry; 1114 btstack_memory_tracking_remove(&buffer->tracking); 1115 free(buffer); 1116 } 1117 #endif 1118 1119 1120 #endif 1121 #ifdef ENABLE_MESH 1122 1123 // MARK: mesh_network_pdu_t 1124 #if !defined(HAVE_MALLOC) && !defined(MAX_NR_MESH_NETWORK_PDUS) 1125 #if defined(MAX_NO_MESH_NETWORK_PDUS) 1126 #error "Deprecated MAX_NO_MESH_NETWORK_PDUS defined instead of MAX_NR_MESH_NETWORK_PDUS. Please update your btstack_config.h to use MAX_NR_MESH_NETWORK_PDUS." 1127 #else 1128 #define MAX_NR_MESH_NETWORK_PDUS 0 1129 #endif 1130 #endif 1131 1132 #ifdef MAX_NR_MESH_NETWORK_PDUS 1133 #if MAX_NR_MESH_NETWORK_PDUS > 0 1134 static mesh_network_pdu_t mesh_network_pdu_storage[MAX_NR_MESH_NETWORK_PDUS]; 1135 static btstack_memory_pool_t mesh_network_pdu_pool; 1136 mesh_network_pdu_t * btstack_memory_mesh_network_pdu_get(void){ 1137 void * buffer = btstack_memory_pool_get(&mesh_network_pdu_pool); 1138 if (buffer){ 1139 memset(buffer, 0, sizeof(mesh_network_pdu_t)); 1140 } 1141 return (mesh_network_pdu_t *) buffer; 1142 } 1143 void btstack_memory_mesh_network_pdu_free(mesh_network_pdu_t *mesh_network_pdu){ 1144 btstack_memory_pool_free(&mesh_network_pdu_pool, mesh_network_pdu); 1145 } 1146 #else 1147 mesh_network_pdu_t * btstack_memory_mesh_network_pdu_get(void){ 1148 return NULL; 1149 } 1150 void btstack_memory_mesh_network_pdu_free(mesh_network_pdu_t *mesh_network_pdu){ 1151 UNUSED(mesh_network_pdu); 1152 }; 1153 #endif 1154 #elif defined(HAVE_MALLOC) 1155 1156 typedef struct { 1157 mesh_network_pdu_t data; 1158 btstack_memory_buffer_t tracking; 1159 } btstack_memory_mesh_network_pdu_t; 1160 1161 mesh_network_pdu_t * btstack_memory_mesh_network_pdu_get(void){ 1162 btstack_memory_mesh_network_pdu_t * buffer = (btstack_memory_mesh_network_pdu_t *) malloc(sizeof(btstack_memory_mesh_network_pdu_t)); 1163 if (buffer){ 1164 memset(buffer, 0, sizeof(mesh_network_pdu_t)); 1165 btstack_memory_tracking_add(&buffer->tracking); 1166 return &buffer->data; 1167 } else { 1168 return NULL; 1169 } 1170 } 1171 void btstack_memory_mesh_network_pdu_free(mesh_network_pdu_t *mesh_network_pdu){ 1172 btstack_memory_mesh_network_pdu_t * buffer = (btstack_memory_mesh_network_pdu_t *) mesh_network_pdu; 1173 btstack_memory_tracking_remove(&buffer->tracking); 1174 free(buffer); 1175 } 1176 #endif 1177 1178 1179 // MARK: mesh_segmented_pdu_t 1180 #if !defined(HAVE_MALLOC) && !defined(MAX_NR_MESH_SEGMENTED_PDUS) 1181 #if defined(MAX_NO_MESH_SEGMENTED_PDUS) 1182 #error "Deprecated MAX_NO_MESH_SEGMENTED_PDUS defined instead of MAX_NR_MESH_SEGMENTED_PDUS. Please update your btstack_config.h to use MAX_NR_MESH_SEGMENTED_PDUS." 1183 #else 1184 #define MAX_NR_MESH_SEGMENTED_PDUS 0 1185 #endif 1186 #endif 1187 1188 #ifdef MAX_NR_MESH_SEGMENTED_PDUS 1189 #if MAX_NR_MESH_SEGMENTED_PDUS > 0 1190 static mesh_segmented_pdu_t mesh_segmented_pdu_storage[MAX_NR_MESH_SEGMENTED_PDUS]; 1191 static btstack_memory_pool_t mesh_segmented_pdu_pool; 1192 mesh_segmented_pdu_t * btstack_memory_mesh_segmented_pdu_get(void){ 1193 void * buffer = btstack_memory_pool_get(&mesh_segmented_pdu_pool); 1194 if (buffer){ 1195 memset(buffer, 0, sizeof(mesh_segmented_pdu_t)); 1196 } 1197 return (mesh_segmented_pdu_t *) buffer; 1198 } 1199 void btstack_memory_mesh_segmented_pdu_free(mesh_segmented_pdu_t *mesh_segmented_pdu){ 1200 btstack_memory_pool_free(&mesh_segmented_pdu_pool, mesh_segmented_pdu); 1201 } 1202 #else 1203 mesh_segmented_pdu_t * btstack_memory_mesh_segmented_pdu_get(void){ 1204 return NULL; 1205 } 1206 void btstack_memory_mesh_segmented_pdu_free(mesh_segmented_pdu_t *mesh_segmented_pdu){ 1207 UNUSED(mesh_segmented_pdu); 1208 }; 1209 #endif 1210 #elif defined(HAVE_MALLOC) 1211 1212 typedef struct { 1213 mesh_segmented_pdu_t data; 1214 btstack_memory_buffer_t tracking; 1215 } btstack_memory_mesh_segmented_pdu_t; 1216 1217 mesh_segmented_pdu_t * btstack_memory_mesh_segmented_pdu_get(void){ 1218 btstack_memory_mesh_segmented_pdu_t * buffer = (btstack_memory_mesh_segmented_pdu_t *) malloc(sizeof(btstack_memory_mesh_segmented_pdu_t)); 1219 if (buffer){ 1220 memset(buffer, 0, sizeof(mesh_segmented_pdu_t)); 1221 btstack_memory_tracking_add(&buffer->tracking); 1222 return &buffer->data; 1223 } else { 1224 return NULL; 1225 } 1226 } 1227 void btstack_memory_mesh_segmented_pdu_free(mesh_segmented_pdu_t *mesh_segmented_pdu){ 1228 btstack_memory_mesh_segmented_pdu_t * buffer = (btstack_memory_mesh_segmented_pdu_t *) mesh_segmented_pdu; 1229 btstack_memory_tracking_remove(&buffer->tracking); 1230 free(buffer); 1231 } 1232 #endif 1233 1234 1235 // MARK: mesh_upper_transport_pdu_t 1236 #if !defined(HAVE_MALLOC) && !defined(MAX_NR_MESH_UPPER_TRANSPORT_PDUS) 1237 #if defined(MAX_NO_MESH_UPPER_TRANSPORT_PDUS) 1238 #error "Deprecated MAX_NO_MESH_UPPER_TRANSPORT_PDUS defined instead of MAX_NR_MESH_UPPER_TRANSPORT_PDUS. Please update your btstack_config.h to use MAX_NR_MESH_UPPER_TRANSPORT_PDUS." 1239 #else 1240 #define MAX_NR_MESH_UPPER_TRANSPORT_PDUS 0 1241 #endif 1242 #endif 1243 1244 #ifdef MAX_NR_MESH_UPPER_TRANSPORT_PDUS 1245 #if MAX_NR_MESH_UPPER_TRANSPORT_PDUS > 0 1246 static mesh_upper_transport_pdu_t mesh_upper_transport_pdu_storage[MAX_NR_MESH_UPPER_TRANSPORT_PDUS]; 1247 static btstack_memory_pool_t mesh_upper_transport_pdu_pool; 1248 mesh_upper_transport_pdu_t * btstack_memory_mesh_upper_transport_pdu_get(void){ 1249 void * buffer = btstack_memory_pool_get(&mesh_upper_transport_pdu_pool); 1250 if (buffer){ 1251 memset(buffer, 0, sizeof(mesh_upper_transport_pdu_t)); 1252 } 1253 return (mesh_upper_transport_pdu_t *) buffer; 1254 } 1255 void btstack_memory_mesh_upper_transport_pdu_free(mesh_upper_transport_pdu_t *mesh_upper_transport_pdu){ 1256 btstack_memory_pool_free(&mesh_upper_transport_pdu_pool, mesh_upper_transport_pdu); 1257 } 1258 #else 1259 mesh_upper_transport_pdu_t * btstack_memory_mesh_upper_transport_pdu_get(void){ 1260 return NULL; 1261 } 1262 void btstack_memory_mesh_upper_transport_pdu_free(mesh_upper_transport_pdu_t *mesh_upper_transport_pdu){ 1263 UNUSED(mesh_upper_transport_pdu); 1264 }; 1265 #endif 1266 #elif defined(HAVE_MALLOC) 1267 1268 typedef struct { 1269 mesh_upper_transport_pdu_t data; 1270 btstack_memory_buffer_t tracking; 1271 } btstack_memory_mesh_upper_transport_pdu_t; 1272 1273 mesh_upper_transport_pdu_t * btstack_memory_mesh_upper_transport_pdu_get(void){ 1274 btstack_memory_mesh_upper_transport_pdu_t * buffer = (btstack_memory_mesh_upper_transport_pdu_t *) malloc(sizeof(btstack_memory_mesh_upper_transport_pdu_t)); 1275 if (buffer){ 1276 memset(buffer, 0, sizeof(mesh_upper_transport_pdu_t)); 1277 btstack_memory_tracking_add(&buffer->tracking); 1278 return &buffer->data; 1279 } else { 1280 return NULL; 1281 } 1282 } 1283 void btstack_memory_mesh_upper_transport_pdu_free(mesh_upper_transport_pdu_t *mesh_upper_transport_pdu){ 1284 btstack_memory_mesh_upper_transport_pdu_t * buffer = (btstack_memory_mesh_upper_transport_pdu_t *) mesh_upper_transport_pdu; 1285 btstack_memory_tracking_remove(&buffer->tracking); 1286 free(buffer); 1287 } 1288 #endif 1289 1290 1291 // MARK: mesh_network_key_t 1292 #if !defined(HAVE_MALLOC) && !defined(MAX_NR_MESH_NETWORK_KEYS) 1293 #if defined(MAX_NO_MESH_NETWORK_KEYS) 1294 #error "Deprecated MAX_NO_MESH_NETWORK_KEYS defined instead of MAX_NR_MESH_NETWORK_KEYS. Please update your btstack_config.h to use MAX_NR_MESH_NETWORK_KEYS." 1295 #else 1296 #define MAX_NR_MESH_NETWORK_KEYS 0 1297 #endif 1298 #endif 1299 1300 #ifdef MAX_NR_MESH_NETWORK_KEYS 1301 #if MAX_NR_MESH_NETWORK_KEYS > 0 1302 static mesh_network_key_t mesh_network_key_storage[MAX_NR_MESH_NETWORK_KEYS]; 1303 static btstack_memory_pool_t mesh_network_key_pool; 1304 mesh_network_key_t * btstack_memory_mesh_network_key_get(void){ 1305 void * buffer = btstack_memory_pool_get(&mesh_network_key_pool); 1306 if (buffer){ 1307 memset(buffer, 0, sizeof(mesh_network_key_t)); 1308 } 1309 return (mesh_network_key_t *) buffer; 1310 } 1311 void btstack_memory_mesh_network_key_free(mesh_network_key_t *mesh_network_key){ 1312 btstack_memory_pool_free(&mesh_network_key_pool, mesh_network_key); 1313 } 1314 #else 1315 mesh_network_key_t * btstack_memory_mesh_network_key_get(void){ 1316 return NULL; 1317 } 1318 void btstack_memory_mesh_network_key_free(mesh_network_key_t *mesh_network_key){ 1319 UNUSED(mesh_network_key); 1320 }; 1321 #endif 1322 #elif defined(HAVE_MALLOC) 1323 1324 typedef struct { 1325 mesh_network_key_t data; 1326 btstack_memory_buffer_t tracking; 1327 } btstack_memory_mesh_network_key_t; 1328 1329 mesh_network_key_t * btstack_memory_mesh_network_key_get(void){ 1330 btstack_memory_mesh_network_key_t * buffer = (btstack_memory_mesh_network_key_t *) malloc(sizeof(btstack_memory_mesh_network_key_t)); 1331 if (buffer){ 1332 memset(buffer, 0, sizeof(mesh_network_key_t)); 1333 btstack_memory_tracking_add(&buffer->tracking); 1334 return &buffer->data; 1335 } else { 1336 return NULL; 1337 } 1338 } 1339 void btstack_memory_mesh_network_key_free(mesh_network_key_t *mesh_network_key){ 1340 btstack_memory_mesh_network_key_t * buffer = (btstack_memory_mesh_network_key_t *) mesh_network_key; 1341 btstack_memory_tracking_remove(&buffer->tracking); 1342 free(buffer); 1343 } 1344 #endif 1345 1346 1347 // MARK: mesh_transport_key_t 1348 #if !defined(HAVE_MALLOC) && !defined(MAX_NR_MESH_TRANSPORT_KEYS) 1349 #if defined(MAX_NO_MESH_TRANSPORT_KEYS) 1350 #error "Deprecated MAX_NO_MESH_TRANSPORT_KEYS defined instead of MAX_NR_MESH_TRANSPORT_KEYS. Please update your btstack_config.h to use MAX_NR_MESH_TRANSPORT_KEYS." 1351 #else 1352 #define MAX_NR_MESH_TRANSPORT_KEYS 0 1353 #endif 1354 #endif 1355 1356 #ifdef MAX_NR_MESH_TRANSPORT_KEYS 1357 #if MAX_NR_MESH_TRANSPORT_KEYS > 0 1358 static mesh_transport_key_t mesh_transport_key_storage[MAX_NR_MESH_TRANSPORT_KEYS]; 1359 static btstack_memory_pool_t mesh_transport_key_pool; 1360 mesh_transport_key_t * btstack_memory_mesh_transport_key_get(void){ 1361 void * buffer = btstack_memory_pool_get(&mesh_transport_key_pool); 1362 if (buffer){ 1363 memset(buffer, 0, sizeof(mesh_transport_key_t)); 1364 } 1365 return (mesh_transport_key_t *) buffer; 1366 } 1367 void btstack_memory_mesh_transport_key_free(mesh_transport_key_t *mesh_transport_key){ 1368 btstack_memory_pool_free(&mesh_transport_key_pool, mesh_transport_key); 1369 } 1370 #else 1371 mesh_transport_key_t * btstack_memory_mesh_transport_key_get(void){ 1372 return NULL; 1373 } 1374 void btstack_memory_mesh_transport_key_free(mesh_transport_key_t *mesh_transport_key){ 1375 UNUSED(mesh_transport_key); 1376 }; 1377 #endif 1378 #elif defined(HAVE_MALLOC) 1379 1380 typedef struct { 1381 mesh_transport_key_t data; 1382 btstack_memory_buffer_t tracking; 1383 } btstack_memory_mesh_transport_key_t; 1384 1385 mesh_transport_key_t * btstack_memory_mesh_transport_key_get(void){ 1386 btstack_memory_mesh_transport_key_t * buffer = (btstack_memory_mesh_transport_key_t *) malloc(sizeof(btstack_memory_mesh_transport_key_t)); 1387 if (buffer){ 1388 memset(buffer, 0, sizeof(mesh_transport_key_t)); 1389 btstack_memory_tracking_add(&buffer->tracking); 1390 return &buffer->data; 1391 } else { 1392 return NULL; 1393 } 1394 } 1395 void btstack_memory_mesh_transport_key_free(mesh_transport_key_t *mesh_transport_key){ 1396 btstack_memory_mesh_transport_key_t * buffer = (btstack_memory_mesh_transport_key_t *) mesh_transport_key; 1397 btstack_memory_tracking_remove(&buffer->tracking); 1398 free(buffer); 1399 } 1400 #endif 1401 1402 1403 // MARK: mesh_virtual_address_t 1404 #if !defined(HAVE_MALLOC) && !defined(MAX_NR_MESH_VIRTUAL_ADDRESSS) 1405 #if defined(MAX_NO_MESH_VIRTUAL_ADDRESSS) 1406 #error "Deprecated MAX_NO_MESH_VIRTUAL_ADDRESSS defined instead of MAX_NR_MESH_VIRTUAL_ADDRESSS. Please update your btstack_config.h to use MAX_NR_MESH_VIRTUAL_ADDRESSS." 1407 #else 1408 #define MAX_NR_MESH_VIRTUAL_ADDRESSS 0 1409 #endif 1410 #endif 1411 1412 #ifdef MAX_NR_MESH_VIRTUAL_ADDRESSS 1413 #if MAX_NR_MESH_VIRTUAL_ADDRESSS > 0 1414 static mesh_virtual_address_t mesh_virtual_address_storage[MAX_NR_MESH_VIRTUAL_ADDRESSS]; 1415 static btstack_memory_pool_t mesh_virtual_address_pool; 1416 mesh_virtual_address_t * btstack_memory_mesh_virtual_address_get(void){ 1417 void * buffer = btstack_memory_pool_get(&mesh_virtual_address_pool); 1418 if (buffer){ 1419 memset(buffer, 0, sizeof(mesh_virtual_address_t)); 1420 } 1421 return (mesh_virtual_address_t *) buffer; 1422 } 1423 void btstack_memory_mesh_virtual_address_free(mesh_virtual_address_t *mesh_virtual_address){ 1424 btstack_memory_pool_free(&mesh_virtual_address_pool, mesh_virtual_address); 1425 } 1426 #else 1427 mesh_virtual_address_t * btstack_memory_mesh_virtual_address_get(void){ 1428 return NULL; 1429 } 1430 void btstack_memory_mesh_virtual_address_free(mesh_virtual_address_t *mesh_virtual_address){ 1431 UNUSED(mesh_virtual_address); 1432 }; 1433 #endif 1434 #elif defined(HAVE_MALLOC) 1435 1436 typedef struct { 1437 mesh_virtual_address_t data; 1438 btstack_memory_buffer_t tracking; 1439 } btstack_memory_mesh_virtual_address_t; 1440 1441 mesh_virtual_address_t * btstack_memory_mesh_virtual_address_get(void){ 1442 btstack_memory_mesh_virtual_address_t * buffer = (btstack_memory_mesh_virtual_address_t *) malloc(sizeof(btstack_memory_mesh_virtual_address_t)); 1443 if (buffer){ 1444 memset(buffer, 0, sizeof(mesh_virtual_address_t)); 1445 btstack_memory_tracking_add(&buffer->tracking); 1446 return &buffer->data; 1447 } else { 1448 return NULL; 1449 } 1450 } 1451 void btstack_memory_mesh_virtual_address_free(mesh_virtual_address_t *mesh_virtual_address){ 1452 btstack_memory_mesh_virtual_address_t * buffer = (btstack_memory_mesh_virtual_address_t *) mesh_virtual_address; 1453 btstack_memory_tracking_remove(&buffer->tracking); 1454 free(buffer); 1455 } 1456 #endif 1457 1458 1459 // MARK: mesh_subnet_t 1460 #if !defined(HAVE_MALLOC) && !defined(MAX_NR_MESH_SUBNETS) 1461 #if defined(MAX_NO_MESH_SUBNETS) 1462 #error "Deprecated MAX_NO_MESH_SUBNETS defined instead of MAX_NR_MESH_SUBNETS. Please update your btstack_config.h to use MAX_NR_MESH_SUBNETS." 1463 #else 1464 #define MAX_NR_MESH_SUBNETS 0 1465 #endif 1466 #endif 1467 1468 #ifdef MAX_NR_MESH_SUBNETS 1469 #if MAX_NR_MESH_SUBNETS > 0 1470 static mesh_subnet_t mesh_subnet_storage[MAX_NR_MESH_SUBNETS]; 1471 static btstack_memory_pool_t mesh_subnet_pool; 1472 mesh_subnet_t * btstack_memory_mesh_subnet_get(void){ 1473 void * buffer = btstack_memory_pool_get(&mesh_subnet_pool); 1474 if (buffer){ 1475 memset(buffer, 0, sizeof(mesh_subnet_t)); 1476 } 1477 return (mesh_subnet_t *) buffer; 1478 } 1479 void btstack_memory_mesh_subnet_free(mesh_subnet_t *mesh_subnet){ 1480 btstack_memory_pool_free(&mesh_subnet_pool, mesh_subnet); 1481 } 1482 #else 1483 mesh_subnet_t * btstack_memory_mesh_subnet_get(void){ 1484 return NULL; 1485 } 1486 void btstack_memory_mesh_subnet_free(mesh_subnet_t *mesh_subnet){ 1487 UNUSED(mesh_subnet); 1488 }; 1489 #endif 1490 #elif defined(HAVE_MALLOC) 1491 1492 typedef struct { 1493 mesh_subnet_t data; 1494 btstack_memory_buffer_t tracking; 1495 } btstack_memory_mesh_subnet_t; 1496 1497 mesh_subnet_t * btstack_memory_mesh_subnet_get(void){ 1498 btstack_memory_mesh_subnet_t * buffer = (btstack_memory_mesh_subnet_t *) malloc(sizeof(btstack_memory_mesh_subnet_t)); 1499 if (buffer){ 1500 memset(buffer, 0, sizeof(mesh_subnet_t)); 1501 btstack_memory_tracking_add(&buffer->tracking); 1502 return &buffer->data; 1503 } else { 1504 return NULL; 1505 } 1506 } 1507 void btstack_memory_mesh_subnet_free(mesh_subnet_t *mesh_subnet){ 1508 btstack_memory_mesh_subnet_t * buffer = (btstack_memory_mesh_subnet_t *) mesh_subnet; 1509 btstack_memory_tracking_remove(&buffer->tracking); 1510 free(buffer); 1511 } 1512 #endif 1513 1514 1515 #endif 1516 // init 1517 void btstack_memory_init(void){ 1518 #if MAX_NR_HCI_CONNECTIONS > 0 1519 btstack_memory_pool_create(&hci_connection_pool, hci_connection_storage, MAX_NR_HCI_CONNECTIONS, sizeof(hci_connection_t)); 1520 #endif 1521 #if MAX_NR_L2CAP_SERVICES > 0 1522 btstack_memory_pool_create(&l2cap_service_pool, l2cap_service_storage, MAX_NR_L2CAP_SERVICES, sizeof(l2cap_service_t)); 1523 #endif 1524 #if MAX_NR_L2CAP_CHANNELS > 0 1525 btstack_memory_pool_create(&l2cap_channel_pool, l2cap_channel_storage, MAX_NR_L2CAP_CHANNELS, sizeof(l2cap_channel_t)); 1526 #endif 1527 #ifdef ENABLE_CLASSIC 1528 #if MAX_NR_RFCOMM_MULTIPLEXERS > 0 1529 btstack_memory_pool_create(&rfcomm_multiplexer_pool, rfcomm_multiplexer_storage, MAX_NR_RFCOMM_MULTIPLEXERS, sizeof(rfcomm_multiplexer_t)); 1530 #endif 1531 #if MAX_NR_RFCOMM_SERVICES > 0 1532 btstack_memory_pool_create(&rfcomm_service_pool, rfcomm_service_storage, MAX_NR_RFCOMM_SERVICES, sizeof(rfcomm_service_t)); 1533 #endif 1534 #if MAX_NR_RFCOMM_CHANNELS > 0 1535 btstack_memory_pool_create(&rfcomm_channel_pool, rfcomm_channel_storage, MAX_NR_RFCOMM_CHANNELS, sizeof(rfcomm_channel_t)); 1536 #endif 1537 #if MAX_NR_BTSTACK_LINK_KEY_DB_MEMORY_ENTRIES > 0 1538 btstack_memory_pool_create(&btstack_link_key_db_memory_entry_pool, btstack_link_key_db_memory_entry_storage, MAX_NR_BTSTACK_LINK_KEY_DB_MEMORY_ENTRIES, sizeof(btstack_link_key_db_memory_entry_t)); 1539 #endif 1540 #if MAX_NR_BNEP_SERVICES > 0 1541 btstack_memory_pool_create(&bnep_service_pool, bnep_service_storage, MAX_NR_BNEP_SERVICES, sizeof(bnep_service_t)); 1542 #endif 1543 #if MAX_NR_BNEP_CHANNELS > 0 1544 btstack_memory_pool_create(&bnep_channel_pool, bnep_channel_storage, MAX_NR_BNEP_CHANNELS, sizeof(bnep_channel_t)); 1545 #endif 1546 #if MAX_NR_HFP_CONNECTIONS > 0 1547 btstack_memory_pool_create(&hfp_connection_pool, hfp_connection_storage, MAX_NR_HFP_CONNECTIONS, sizeof(hfp_connection_t)); 1548 #endif 1549 #if MAX_NR_SERVICE_RECORD_ITEMS > 0 1550 btstack_memory_pool_create(&service_record_item_pool, service_record_item_storage, MAX_NR_SERVICE_RECORD_ITEMS, sizeof(service_record_item_t)); 1551 #endif 1552 #if MAX_NR_AVDTP_STREAM_ENDPOINTS > 0 1553 btstack_memory_pool_create(&avdtp_stream_endpoint_pool, avdtp_stream_endpoint_storage, MAX_NR_AVDTP_STREAM_ENDPOINTS, sizeof(avdtp_stream_endpoint_t)); 1554 #endif 1555 #if MAX_NR_AVDTP_CONNECTIONS > 0 1556 btstack_memory_pool_create(&avdtp_connection_pool, avdtp_connection_storage, MAX_NR_AVDTP_CONNECTIONS, sizeof(avdtp_connection_t)); 1557 #endif 1558 #if MAX_NR_AVRCP_CONNECTIONS > 0 1559 btstack_memory_pool_create(&avrcp_connection_pool, avrcp_connection_storage, MAX_NR_AVRCP_CONNECTIONS, sizeof(avrcp_connection_t)); 1560 #endif 1561 #if MAX_NR_AVRCP_BROWSING_CONNECTIONS > 0 1562 btstack_memory_pool_create(&avrcp_browsing_connection_pool, avrcp_browsing_connection_storage, MAX_NR_AVRCP_BROWSING_CONNECTIONS, sizeof(avrcp_browsing_connection_t)); 1563 #endif 1564 #endif 1565 #ifdef ENABLE_BLE 1566 #if MAX_NR_GATT_CLIENTS > 0 1567 btstack_memory_pool_create(&gatt_client_pool, gatt_client_storage, MAX_NR_GATT_CLIENTS, sizeof(gatt_client_t)); 1568 #endif 1569 #if MAX_NR_WHITELIST_ENTRIES > 0 1570 btstack_memory_pool_create(&whitelist_entry_pool, whitelist_entry_storage, MAX_NR_WHITELIST_ENTRIES, sizeof(whitelist_entry_t)); 1571 #endif 1572 #if MAX_NR_SM_LOOKUP_ENTRIES > 0 1573 btstack_memory_pool_create(&sm_lookup_entry_pool, sm_lookup_entry_storage, MAX_NR_SM_LOOKUP_ENTRIES, sizeof(sm_lookup_entry_t)); 1574 #endif 1575 #endif 1576 #ifdef ENABLE_MESH 1577 #if MAX_NR_MESH_NETWORK_PDUS > 0 1578 btstack_memory_pool_create(&mesh_network_pdu_pool, mesh_network_pdu_storage, MAX_NR_MESH_NETWORK_PDUS, sizeof(mesh_network_pdu_t)); 1579 #endif 1580 #if MAX_NR_MESH_SEGMENTED_PDUS > 0 1581 btstack_memory_pool_create(&mesh_segmented_pdu_pool, mesh_segmented_pdu_storage, MAX_NR_MESH_SEGMENTED_PDUS, sizeof(mesh_segmented_pdu_t)); 1582 #endif 1583 #if MAX_NR_MESH_UPPER_TRANSPORT_PDUS > 0 1584 btstack_memory_pool_create(&mesh_upper_transport_pdu_pool, mesh_upper_transport_pdu_storage, MAX_NR_MESH_UPPER_TRANSPORT_PDUS, sizeof(mesh_upper_transport_pdu_t)); 1585 #endif 1586 #if MAX_NR_MESH_NETWORK_KEYS > 0 1587 btstack_memory_pool_create(&mesh_network_key_pool, mesh_network_key_storage, MAX_NR_MESH_NETWORK_KEYS, sizeof(mesh_network_key_t)); 1588 #endif 1589 #if MAX_NR_MESH_TRANSPORT_KEYS > 0 1590 btstack_memory_pool_create(&mesh_transport_key_pool, mesh_transport_key_storage, MAX_NR_MESH_TRANSPORT_KEYS, sizeof(mesh_transport_key_t)); 1591 #endif 1592 #if MAX_NR_MESH_VIRTUAL_ADDRESSS > 0 1593 btstack_memory_pool_create(&mesh_virtual_address_pool, mesh_virtual_address_storage, MAX_NR_MESH_VIRTUAL_ADDRESSS, sizeof(mesh_virtual_address_t)); 1594 #endif 1595 #if MAX_NR_MESH_SUBNETS > 0 1596 btstack_memory_pool_create(&mesh_subnet_pool, mesh_subnet_storage, MAX_NR_MESH_SUBNETS, sizeof(mesh_subnet_t)); 1597 #endif 1598 #endif 1599 } 1600