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 BLUEKITCHEN 24 * GMBH 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 ENABLE_MALLOC_TEST 59 void * test_malloc(size_t size); 60 #define malloc test_malloc 61 #endif 62 63 #ifdef HAVE_MALLOC 64 typedef struct btstack_memory_buffer { 65 struct btstack_memory_buffer * next; 66 struct btstack_memory_buffer * prev; 67 } btstack_memory_buffer_t; 68 69 typedef struct { 70 btstack_memory_buffer_t tracking; 71 void * pointer; 72 } test_buffer_t; 73 74 static btstack_memory_buffer_t * btstack_memory_malloc_buffers; 75 static uint32_t btstack_memory_malloc_counter; 76 77 static void btstack_memory_tracking_add(btstack_memory_buffer_t * buffer){ 78 btstack_assert(buffer != NULL); 79 if (btstack_memory_malloc_buffers != NULL) { 80 // let current first item prev point to new first item 81 btstack_memory_malloc_buffers->prev = buffer; 82 } 83 buffer->prev = NULL; 84 buffer->next = btstack_memory_malloc_buffers; 85 btstack_memory_malloc_buffers = buffer; 86 87 btstack_memory_malloc_counter++; 88 } 89 90 static void btstack_memory_tracking_remove(btstack_memory_buffer_t * buffer){ 91 btstack_assert(buffer != NULL); 92 if (buffer->prev == NULL){ 93 // first item 94 btstack_memory_malloc_buffers = buffer->next; 95 } else { 96 buffer->prev->next = buffer->next; 97 } 98 if (buffer->next != NULL){ 99 buffer->next->prev = buffer->prev; 100 } 101 102 btstack_memory_malloc_counter--; 103 } 104 #endif 105 106 void btstack_memory_deinit(void){ 107 #ifdef HAVE_MALLOC 108 while (btstack_memory_malloc_buffers != NULL){ 109 btstack_memory_buffer_t * buffer = btstack_memory_malloc_buffers; 110 btstack_memory_malloc_buffers = buffer->next; 111 free(buffer); 112 btstack_memory_malloc_counter--; 113 } 114 btstack_assert(btstack_memory_malloc_counter == 0); 115 #endif 116 } 117 118 119 // MARK: hci_connection_t 120 #if !defined(HAVE_MALLOC) && !defined(MAX_NR_HCI_CONNECTIONS) 121 #if defined(MAX_NO_HCI_CONNECTIONS) 122 #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." 123 #else 124 #define MAX_NR_HCI_CONNECTIONS 0 125 #endif 126 #endif 127 128 #ifdef MAX_NR_HCI_CONNECTIONS 129 #if MAX_NR_HCI_CONNECTIONS > 0 130 static hci_connection_t hci_connection_storage[MAX_NR_HCI_CONNECTIONS]; 131 static btstack_memory_pool_t hci_connection_pool; 132 hci_connection_t * btstack_memory_hci_connection_get(void){ 133 void * buffer = btstack_memory_pool_get(&hci_connection_pool); 134 if (buffer){ 135 memset(buffer, 0, sizeof(hci_connection_t)); 136 } 137 return (hci_connection_t *) buffer; 138 } 139 void btstack_memory_hci_connection_free(hci_connection_t *hci_connection){ 140 btstack_memory_pool_free(&hci_connection_pool, hci_connection); 141 } 142 #else 143 hci_connection_t * btstack_memory_hci_connection_get(void){ 144 return NULL; 145 } 146 void btstack_memory_hci_connection_free(hci_connection_t *hci_connection){ 147 UNUSED(hci_connection); 148 }; 149 #endif 150 #elif defined(HAVE_MALLOC) 151 152 typedef struct { 153 btstack_memory_buffer_t tracking; 154 hci_connection_t data; 155 } btstack_memory_hci_connection_t; 156 157 hci_connection_t * btstack_memory_hci_connection_get(void){ 158 btstack_memory_hci_connection_t * buffer = (btstack_memory_hci_connection_t *) malloc(sizeof(btstack_memory_hci_connection_t)); 159 if (buffer){ 160 memset(buffer, 0, sizeof(btstack_memory_hci_connection_t)); 161 btstack_memory_tracking_add(&buffer->tracking); 162 return &buffer->data; 163 } else { 164 return NULL; 165 } 166 } 167 void btstack_memory_hci_connection_free(hci_connection_t *hci_connection){ 168 // reconstruct buffer start 169 btstack_memory_buffer_t * buffer = &((btstack_memory_buffer_t *) hci_connection)[-1]; 170 btstack_memory_tracking_remove(buffer); 171 free(buffer); 172 } 173 #endif 174 175 176 177 // MARK: l2cap_service_t 178 #if !defined(HAVE_MALLOC) && !defined(MAX_NR_L2CAP_SERVICES) 179 #if defined(MAX_NO_L2CAP_SERVICES) 180 #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." 181 #else 182 #define MAX_NR_L2CAP_SERVICES 0 183 #endif 184 #endif 185 186 #ifdef MAX_NR_L2CAP_SERVICES 187 #if MAX_NR_L2CAP_SERVICES > 0 188 static l2cap_service_t l2cap_service_storage[MAX_NR_L2CAP_SERVICES]; 189 static btstack_memory_pool_t l2cap_service_pool; 190 l2cap_service_t * btstack_memory_l2cap_service_get(void){ 191 void * buffer = btstack_memory_pool_get(&l2cap_service_pool); 192 if (buffer){ 193 memset(buffer, 0, sizeof(l2cap_service_t)); 194 } 195 return (l2cap_service_t *) buffer; 196 } 197 void btstack_memory_l2cap_service_free(l2cap_service_t *l2cap_service){ 198 btstack_memory_pool_free(&l2cap_service_pool, l2cap_service); 199 } 200 #else 201 l2cap_service_t * btstack_memory_l2cap_service_get(void){ 202 return NULL; 203 } 204 void btstack_memory_l2cap_service_free(l2cap_service_t *l2cap_service){ 205 UNUSED(l2cap_service); 206 }; 207 #endif 208 #elif defined(HAVE_MALLOC) 209 210 typedef struct { 211 btstack_memory_buffer_t tracking; 212 l2cap_service_t data; 213 } btstack_memory_l2cap_service_t; 214 215 l2cap_service_t * btstack_memory_l2cap_service_get(void){ 216 btstack_memory_l2cap_service_t * buffer = (btstack_memory_l2cap_service_t *) malloc(sizeof(btstack_memory_l2cap_service_t)); 217 if (buffer){ 218 memset(buffer, 0, sizeof(btstack_memory_l2cap_service_t)); 219 btstack_memory_tracking_add(&buffer->tracking); 220 return &buffer->data; 221 } else { 222 return NULL; 223 } 224 } 225 void btstack_memory_l2cap_service_free(l2cap_service_t *l2cap_service){ 226 // reconstruct buffer start 227 btstack_memory_buffer_t * buffer = &((btstack_memory_buffer_t *) l2cap_service)[-1]; 228 btstack_memory_tracking_remove(buffer); 229 free(buffer); 230 } 231 #endif 232 233 234 // MARK: l2cap_channel_t 235 #if !defined(HAVE_MALLOC) && !defined(MAX_NR_L2CAP_CHANNELS) 236 #if defined(MAX_NO_L2CAP_CHANNELS) 237 #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." 238 #else 239 #define MAX_NR_L2CAP_CHANNELS 0 240 #endif 241 #endif 242 243 #ifdef MAX_NR_L2CAP_CHANNELS 244 #if MAX_NR_L2CAP_CHANNELS > 0 245 static l2cap_channel_t l2cap_channel_storage[MAX_NR_L2CAP_CHANNELS]; 246 static btstack_memory_pool_t l2cap_channel_pool; 247 l2cap_channel_t * btstack_memory_l2cap_channel_get(void){ 248 void * buffer = btstack_memory_pool_get(&l2cap_channel_pool); 249 if (buffer){ 250 memset(buffer, 0, sizeof(l2cap_channel_t)); 251 } 252 return (l2cap_channel_t *) buffer; 253 } 254 void btstack_memory_l2cap_channel_free(l2cap_channel_t *l2cap_channel){ 255 btstack_memory_pool_free(&l2cap_channel_pool, l2cap_channel); 256 } 257 #else 258 l2cap_channel_t * btstack_memory_l2cap_channel_get(void){ 259 return NULL; 260 } 261 void btstack_memory_l2cap_channel_free(l2cap_channel_t *l2cap_channel){ 262 UNUSED(l2cap_channel); 263 }; 264 #endif 265 #elif defined(HAVE_MALLOC) 266 267 typedef struct { 268 btstack_memory_buffer_t tracking; 269 l2cap_channel_t data; 270 } btstack_memory_l2cap_channel_t; 271 272 l2cap_channel_t * btstack_memory_l2cap_channel_get(void){ 273 btstack_memory_l2cap_channel_t * buffer = (btstack_memory_l2cap_channel_t *) malloc(sizeof(btstack_memory_l2cap_channel_t)); 274 if (buffer){ 275 memset(buffer, 0, sizeof(btstack_memory_l2cap_channel_t)); 276 btstack_memory_tracking_add(&buffer->tracking); 277 return &buffer->data; 278 } else { 279 return NULL; 280 } 281 } 282 void btstack_memory_l2cap_channel_free(l2cap_channel_t *l2cap_channel){ 283 // reconstruct buffer start 284 btstack_memory_buffer_t * buffer = &((btstack_memory_buffer_t *) l2cap_channel)[-1]; 285 btstack_memory_tracking_remove(buffer); 286 free(buffer); 287 } 288 #endif 289 290 291 #ifdef ENABLE_CLASSIC 292 293 // MARK: rfcomm_multiplexer_t 294 #if !defined(HAVE_MALLOC) && !defined(MAX_NR_RFCOMM_MULTIPLEXERS) 295 #if defined(MAX_NO_RFCOMM_MULTIPLEXERS) 296 #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." 297 #else 298 #define MAX_NR_RFCOMM_MULTIPLEXERS 0 299 #endif 300 #endif 301 302 #ifdef MAX_NR_RFCOMM_MULTIPLEXERS 303 #if MAX_NR_RFCOMM_MULTIPLEXERS > 0 304 static rfcomm_multiplexer_t rfcomm_multiplexer_storage[MAX_NR_RFCOMM_MULTIPLEXERS]; 305 static btstack_memory_pool_t rfcomm_multiplexer_pool; 306 rfcomm_multiplexer_t * btstack_memory_rfcomm_multiplexer_get(void){ 307 void * buffer = btstack_memory_pool_get(&rfcomm_multiplexer_pool); 308 if (buffer){ 309 memset(buffer, 0, sizeof(rfcomm_multiplexer_t)); 310 } 311 return (rfcomm_multiplexer_t *) buffer; 312 } 313 void btstack_memory_rfcomm_multiplexer_free(rfcomm_multiplexer_t *rfcomm_multiplexer){ 314 btstack_memory_pool_free(&rfcomm_multiplexer_pool, rfcomm_multiplexer); 315 } 316 #else 317 rfcomm_multiplexer_t * btstack_memory_rfcomm_multiplexer_get(void){ 318 return NULL; 319 } 320 void btstack_memory_rfcomm_multiplexer_free(rfcomm_multiplexer_t *rfcomm_multiplexer){ 321 UNUSED(rfcomm_multiplexer); 322 }; 323 #endif 324 #elif defined(HAVE_MALLOC) 325 326 typedef struct { 327 btstack_memory_buffer_t tracking; 328 rfcomm_multiplexer_t data; 329 } btstack_memory_rfcomm_multiplexer_t; 330 331 rfcomm_multiplexer_t * btstack_memory_rfcomm_multiplexer_get(void){ 332 btstack_memory_rfcomm_multiplexer_t * buffer = (btstack_memory_rfcomm_multiplexer_t *) malloc(sizeof(btstack_memory_rfcomm_multiplexer_t)); 333 if (buffer){ 334 memset(buffer, 0, sizeof(btstack_memory_rfcomm_multiplexer_t)); 335 btstack_memory_tracking_add(&buffer->tracking); 336 return &buffer->data; 337 } else { 338 return NULL; 339 } 340 } 341 void btstack_memory_rfcomm_multiplexer_free(rfcomm_multiplexer_t *rfcomm_multiplexer){ 342 // reconstruct buffer start 343 btstack_memory_buffer_t * buffer = &((btstack_memory_buffer_t *) rfcomm_multiplexer)[-1]; 344 btstack_memory_tracking_remove(buffer); 345 free(buffer); 346 } 347 #endif 348 349 350 // MARK: rfcomm_service_t 351 #if !defined(HAVE_MALLOC) && !defined(MAX_NR_RFCOMM_SERVICES) 352 #if defined(MAX_NO_RFCOMM_SERVICES) 353 #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." 354 #else 355 #define MAX_NR_RFCOMM_SERVICES 0 356 #endif 357 #endif 358 359 #ifdef MAX_NR_RFCOMM_SERVICES 360 #if MAX_NR_RFCOMM_SERVICES > 0 361 static rfcomm_service_t rfcomm_service_storage[MAX_NR_RFCOMM_SERVICES]; 362 static btstack_memory_pool_t rfcomm_service_pool; 363 rfcomm_service_t * btstack_memory_rfcomm_service_get(void){ 364 void * buffer = btstack_memory_pool_get(&rfcomm_service_pool); 365 if (buffer){ 366 memset(buffer, 0, sizeof(rfcomm_service_t)); 367 } 368 return (rfcomm_service_t *) buffer; 369 } 370 void btstack_memory_rfcomm_service_free(rfcomm_service_t *rfcomm_service){ 371 btstack_memory_pool_free(&rfcomm_service_pool, rfcomm_service); 372 } 373 #else 374 rfcomm_service_t * btstack_memory_rfcomm_service_get(void){ 375 return NULL; 376 } 377 void btstack_memory_rfcomm_service_free(rfcomm_service_t *rfcomm_service){ 378 UNUSED(rfcomm_service); 379 }; 380 #endif 381 #elif defined(HAVE_MALLOC) 382 383 typedef struct { 384 btstack_memory_buffer_t tracking; 385 rfcomm_service_t data; 386 } btstack_memory_rfcomm_service_t; 387 388 rfcomm_service_t * btstack_memory_rfcomm_service_get(void){ 389 btstack_memory_rfcomm_service_t * buffer = (btstack_memory_rfcomm_service_t *) malloc(sizeof(btstack_memory_rfcomm_service_t)); 390 if (buffer){ 391 memset(buffer, 0, sizeof(btstack_memory_rfcomm_service_t)); 392 btstack_memory_tracking_add(&buffer->tracking); 393 return &buffer->data; 394 } else { 395 return NULL; 396 } 397 } 398 void btstack_memory_rfcomm_service_free(rfcomm_service_t *rfcomm_service){ 399 // reconstruct buffer start 400 btstack_memory_buffer_t * buffer = &((btstack_memory_buffer_t *) rfcomm_service)[-1]; 401 btstack_memory_tracking_remove(buffer); 402 free(buffer); 403 } 404 #endif 405 406 407 // MARK: rfcomm_channel_t 408 #if !defined(HAVE_MALLOC) && !defined(MAX_NR_RFCOMM_CHANNELS) 409 #if defined(MAX_NO_RFCOMM_CHANNELS) 410 #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." 411 #else 412 #define MAX_NR_RFCOMM_CHANNELS 0 413 #endif 414 #endif 415 416 #ifdef MAX_NR_RFCOMM_CHANNELS 417 #if MAX_NR_RFCOMM_CHANNELS > 0 418 static rfcomm_channel_t rfcomm_channel_storage[MAX_NR_RFCOMM_CHANNELS]; 419 static btstack_memory_pool_t rfcomm_channel_pool; 420 rfcomm_channel_t * btstack_memory_rfcomm_channel_get(void){ 421 void * buffer = btstack_memory_pool_get(&rfcomm_channel_pool); 422 if (buffer){ 423 memset(buffer, 0, sizeof(rfcomm_channel_t)); 424 } 425 return (rfcomm_channel_t *) buffer; 426 } 427 void btstack_memory_rfcomm_channel_free(rfcomm_channel_t *rfcomm_channel){ 428 btstack_memory_pool_free(&rfcomm_channel_pool, rfcomm_channel); 429 } 430 #else 431 rfcomm_channel_t * btstack_memory_rfcomm_channel_get(void){ 432 return NULL; 433 } 434 void btstack_memory_rfcomm_channel_free(rfcomm_channel_t *rfcomm_channel){ 435 UNUSED(rfcomm_channel); 436 }; 437 #endif 438 #elif defined(HAVE_MALLOC) 439 440 typedef struct { 441 btstack_memory_buffer_t tracking; 442 rfcomm_channel_t data; 443 } btstack_memory_rfcomm_channel_t; 444 445 rfcomm_channel_t * btstack_memory_rfcomm_channel_get(void){ 446 btstack_memory_rfcomm_channel_t * buffer = (btstack_memory_rfcomm_channel_t *) malloc(sizeof(btstack_memory_rfcomm_channel_t)); 447 if (buffer){ 448 memset(buffer, 0, sizeof(btstack_memory_rfcomm_channel_t)); 449 btstack_memory_tracking_add(&buffer->tracking); 450 return &buffer->data; 451 } else { 452 return NULL; 453 } 454 } 455 void btstack_memory_rfcomm_channel_free(rfcomm_channel_t *rfcomm_channel){ 456 // reconstruct buffer start 457 btstack_memory_buffer_t * buffer = &((btstack_memory_buffer_t *) rfcomm_channel)[-1]; 458 btstack_memory_tracking_remove(buffer); 459 free(buffer); 460 } 461 #endif 462 463 464 465 // MARK: btstack_link_key_db_memory_entry_t 466 #if !defined(HAVE_MALLOC) && !defined(MAX_NR_BTSTACK_LINK_KEY_DB_MEMORY_ENTRIES) 467 #if defined(MAX_NO_BTSTACK_LINK_KEY_DB_MEMORY_ENTRIES) 468 #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." 469 #else 470 #define MAX_NR_BTSTACK_LINK_KEY_DB_MEMORY_ENTRIES 0 471 #endif 472 #endif 473 474 #ifdef MAX_NR_BTSTACK_LINK_KEY_DB_MEMORY_ENTRIES 475 #if MAX_NR_BTSTACK_LINK_KEY_DB_MEMORY_ENTRIES > 0 476 static btstack_link_key_db_memory_entry_t btstack_link_key_db_memory_entry_storage[MAX_NR_BTSTACK_LINK_KEY_DB_MEMORY_ENTRIES]; 477 static btstack_memory_pool_t btstack_link_key_db_memory_entry_pool; 478 btstack_link_key_db_memory_entry_t * btstack_memory_btstack_link_key_db_memory_entry_get(void){ 479 void * buffer = btstack_memory_pool_get(&btstack_link_key_db_memory_entry_pool); 480 if (buffer){ 481 memset(buffer, 0, sizeof(btstack_link_key_db_memory_entry_t)); 482 } 483 return (btstack_link_key_db_memory_entry_t *) buffer; 484 } 485 void btstack_memory_btstack_link_key_db_memory_entry_free(btstack_link_key_db_memory_entry_t *btstack_link_key_db_memory_entry){ 486 btstack_memory_pool_free(&btstack_link_key_db_memory_entry_pool, btstack_link_key_db_memory_entry); 487 } 488 #else 489 btstack_link_key_db_memory_entry_t * btstack_memory_btstack_link_key_db_memory_entry_get(void){ 490 return NULL; 491 } 492 void btstack_memory_btstack_link_key_db_memory_entry_free(btstack_link_key_db_memory_entry_t *btstack_link_key_db_memory_entry){ 493 UNUSED(btstack_link_key_db_memory_entry); 494 }; 495 #endif 496 #elif defined(HAVE_MALLOC) 497 498 typedef struct { 499 btstack_memory_buffer_t tracking; 500 btstack_link_key_db_memory_entry_t data; 501 } btstack_memory_btstack_link_key_db_memory_entry_t; 502 503 btstack_link_key_db_memory_entry_t * btstack_memory_btstack_link_key_db_memory_entry_get(void){ 504 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)); 505 if (buffer){ 506 memset(buffer, 0, sizeof(btstack_memory_btstack_link_key_db_memory_entry_t)); 507 btstack_memory_tracking_add(&buffer->tracking); 508 return &buffer->data; 509 } else { 510 return NULL; 511 } 512 } 513 void btstack_memory_btstack_link_key_db_memory_entry_free(btstack_link_key_db_memory_entry_t *btstack_link_key_db_memory_entry){ 514 // reconstruct buffer start 515 btstack_memory_buffer_t * buffer = &((btstack_memory_buffer_t *) btstack_link_key_db_memory_entry)[-1]; 516 btstack_memory_tracking_remove(buffer); 517 free(buffer); 518 } 519 #endif 520 521 522 523 // MARK: bnep_service_t 524 #if !defined(HAVE_MALLOC) && !defined(MAX_NR_BNEP_SERVICES) 525 #if defined(MAX_NO_BNEP_SERVICES) 526 #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." 527 #else 528 #define MAX_NR_BNEP_SERVICES 0 529 #endif 530 #endif 531 532 #ifdef MAX_NR_BNEP_SERVICES 533 #if MAX_NR_BNEP_SERVICES > 0 534 static bnep_service_t bnep_service_storage[MAX_NR_BNEP_SERVICES]; 535 static btstack_memory_pool_t bnep_service_pool; 536 bnep_service_t * btstack_memory_bnep_service_get(void){ 537 void * buffer = btstack_memory_pool_get(&bnep_service_pool); 538 if (buffer){ 539 memset(buffer, 0, sizeof(bnep_service_t)); 540 } 541 return (bnep_service_t *) buffer; 542 } 543 void btstack_memory_bnep_service_free(bnep_service_t *bnep_service){ 544 btstack_memory_pool_free(&bnep_service_pool, bnep_service); 545 } 546 #else 547 bnep_service_t * btstack_memory_bnep_service_get(void){ 548 return NULL; 549 } 550 void btstack_memory_bnep_service_free(bnep_service_t *bnep_service){ 551 UNUSED(bnep_service); 552 }; 553 #endif 554 #elif defined(HAVE_MALLOC) 555 556 typedef struct { 557 btstack_memory_buffer_t tracking; 558 bnep_service_t data; 559 } btstack_memory_bnep_service_t; 560 561 bnep_service_t * btstack_memory_bnep_service_get(void){ 562 btstack_memory_bnep_service_t * buffer = (btstack_memory_bnep_service_t *) malloc(sizeof(btstack_memory_bnep_service_t)); 563 if (buffer){ 564 memset(buffer, 0, sizeof(btstack_memory_bnep_service_t)); 565 btstack_memory_tracking_add(&buffer->tracking); 566 return &buffer->data; 567 } else { 568 return NULL; 569 } 570 } 571 void btstack_memory_bnep_service_free(bnep_service_t *bnep_service){ 572 // reconstruct buffer start 573 btstack_memory_buffer_t * buffer = &((btstack_memory_buffer_t *) bnep_service)[-1]; 574 btstack_memory_tracking_remove(buffer); 575 free(buffer); 576 } 577 #endif 578 579 580 // MARK: bnep_channel_t 581 #if !defined(HAVE_MALLOC) && !defined(MAX_NR_BNEP_CHANNELS) 582 #if defined(MAX_NO_BNEP_CHANNELS) 583 #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." 584 #else 585 #define MAX_NR_BNEP_CHANNELS 0 586 #endif 587 #endif 588 589 #ifdef MAX_NR_BNEP_CHANNELS 590 #if MAX_NR_BNEP_CHANNELS > 0 591 static bnep_channel_t bnep_channel_storage[MAX_NR_BNEP_CHANNELS]; 592 static btstack_memory_pool_t bnep_channel_pool; 593 bnep_channel_t * btstack_memory_bnep_channel_get(void){ 594 void * buffer = btstack_memory_pool_get(&bnep_channel_pool); 595 if (buffer){ 596 memset(buffer, 0, sizeof(bnep_channel_t)); 597 } 598 return (bnep_channel_t *) buffer; 599 } 600 void btstack_memory_bnep_channel_free(bnep_channel_t *bnep_channel){ 601 btstack_memory_pool_free(&bnep_channel_pool, bnep_channel); 602 } 603 #else 604 bnep_channel_t * btstack_memory_bnep_channel_get(void){ 605 return NULL; 606 } 607 void btstack_memory_bnep_channel_free(bnep_channel_t *bnep_channel){ 608 UNUSED(bnep_channel); 609 }; 610 #endif 611 #elif defined(HAVE_MALLOC) 612 613 typedef struct { 614 btstack_memory_buffer_t tracking; 615 bnep_channel_t data; 616 } btstack_memory_bnep_channel_t; 617 618 bnep_channel_t * btstack_memory_bnep_channel_get(void){ 619 btstack_memory_bnep_channel_t * buffer = (btstack_memory_bnep_channel_t *) malloc(sizeof(btstack_memory_bnep_channel_t)); 620 if (buffer){ 621 memset(buffer, 0, sizeof(btstack_memory_bnep_channel_t)); 622 btstack_memory_tracking_add(&buffer->tracking); 623 return &buffer->data; 624 } else { 625 return NULL; 626 } 627 } 628 void btstack_memory_bnep_channel_free(bnep_channel_t *bnep_channel){ 629 // reconstruct buffer start 630 btstack_memory_buffer_t * buffer = &((btstack_memory_buffer_t *) bnep_channel)[-1]; 631 btstack_memory_tracking_remove(buffer); 632 free(buffer); 633 } 634 #endif 635 636 637 638 // MARK: hfp_connection_t 639 #if !defined(HAVE_MALLOC) && !defined(MAX_NR_HFP_CONNECTIONS) 640 #if defined(MAX_NO_HFP_CONNECTIONS) 641 #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." 642 #else 643 #define MAX_NR_HFP_CONNECTIONS 0 644 #endif 645 #endif 646 647 #ifdef MAX_NR_HFP_CONNECTIONS 648 #if MAX_NR_HFP_CONNECTIONS > 0 649 static hfp_connection_t hfp_connection_storage[MAX_NR_HFP_CONNECTIONS]; 650 static btstack_memory_pool_t hfp_connection_pool; 651 hfp_connection_t * btstack_memory_hfp_connection_get(void){ 652 void * buffer = btstack_memory_pool_get(&hfp_connection_pool); 653 if (buffer){ 654 memset(buffer, 0, sizeof(hfp_connection_t)); 655 } 656 return (hfp_connection_t *) buffer; 657 } 658 void btstack_memory_hfp_connection_free(hfp_connection_t *hfp_connection){ 659 btstack_memory_pool_free(&hfp_connection_pool, hfp_connection); 660 } 661 #else 662 hfp_connection_t * btstack_memory_hfp_connection_get(void){ 663 return NULL; 664 } 665 void btstack_memory_hfp_connection_free(hfp_connection_t *hfp_connection){ 666 UNUSED(hfp_connection); 667 }; 668 #endif 669 #elif defined(HAVE_MALLOC) 670 671 typedef struct { 672 btstack_memory_buffer_t tracking; 673 hfp_connection_t data; 674 } btstack_memory_hfp_connection_t; 675 676 hfp_connection_t * btstack_memory_hfp_connection_get(void){ 677 btstack_memory_hfp_connection_t * buffer = (btstack_memory_hfp_connection_t *) malloc(sizeof(btstack_memory_hfp_connection_t)); 678 if (buffer){ 679 memset(buffer, 0, sizeof(btstack_memory_hfp_connection_t)); 680 btstack_memory_tracking_add(&buffer->tracking); 681 return &buffer->data; 682 } else { 683 return NULL; 684 } 685 } 686 void btstack_memory_hfp_connection_free(hfp_connection_t *hfp_connection){ 687 // reconstruct buffer start 688 btstack_memory_buffer_t * buffer = &((btstack_memory_buffer_t *) hfp_connection)[-1]; 689 btstack_memory_tracking_remove(buffer); 690 free(buffer); 691 } 692 #endif 693 694 695 696 // MARK: hid_host_connection_t 697 #if !defined(HAVE_MALLOC) && !defined(MAX_NR_HID_HOST_CONNECTIONS) 698 #if defined(MAX_NO_HID_HOST_CONNECTIONS) 699 #error "Deprecated MAX_NO_HID_HOST_CONNECTIONS defined instead of MAX_NR_HID_HOST_CONNECTIONS. Please update your btstack_config.h to use MAX_NR_HID_HOST_CONNECTIONS." 700 #else 701 #define MAX_NR_HID_HOST_CONNECTIONS 0 702 #endif 703 #endif 704 705 #ifdef MAX_NR_HID_HOST_CONNECTIONS 706 #if MAX_NR_HID_HOST_CONNECTIONS > 0 707 static hid_host_connection_t hid_host_connection_storage[MAX_NR_HID_HOST_CONNECTIONS]; 708 static btstack_memory_pool_t hid_host_connection_pool; 709 hid_host_connection_t * btstack_memory_hid_host_connection_get(void){ 710 void * buffer = btstack_memory_pool_get(&hid_host_connection_pool); 711 if (buffer){ 712 memset(buffer, 0, sizeof(hid_host_connection_t)); 713 } 714 return (hid_host_connection_t *) buffer; 715 } 716 void btstack_memory_hid_host_connection_free(hid_host_connection_t *hid_host_connection){ 717 btstack_memory_pool_free(&hid_host_connection_pool, hid_host_connection); 718 } 719 #else 720 hid_host_connection_t * btstack_memory_hid_host_connection_get(void){ 721 return NULL; 722 } 723 void btstack_memory_hid_host_connection_free(hid_host_connection_t *hid_host_connection){ 724 UNUSED(hid_host_connection); 725 }; 726 #endif 727 #elif defined(HAVE_MALLOC) 728 729 typedef struct { 730 btstack_memory_buffer_t tracking; 731 hid_host_connection_t data; 732 } btstack_memory_hid_host_connection_t; 733 734 hid_host_connection_t * btstack_memory_hid_host_connection_get(void){ 735 btstack_memory_hid_host_connection_t * buffer = (btstack_memory_hid_host_connection_t *) malloc(sizeof(btstack_memory_hid_host_connection_t)); 736 if (buffer){ 737 memset(buffer, 0, sizeof(btstack_memory_hid_host_connection_t)); 738 btstack_memory_tracking_add(&buffer->tracking); 739 return &buffer->data; 740 } else { 741 return NULL; 742 } 743 } 744 void btstack_memory_hid_host_connection_free(hid_host_connection_t *hid_host_connection){ 745 // reconstruct buffer start 746 btstack_memory_buffer_t * buffer = &((btstack_memory_buffer_t *) hid_host_connection)[-1]; 747 btstack_memory_tracking_remove(buffer); 748 free(buffer); 749 } 750 #endif 751 752 753 754 // MARK: service_record_item_t 755 #if !defined(HAVE_MALLOC) && !defined(MAX_NR_SERVICE_RECORD_ITEMS) 756 #if defined(MAX_NO_SERVICE_RECORD_ITEMS) 757 #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." 758 #else 759 #define MAX_NR_SERVICE_RECORD_ITEMS 0 760 #endif 761 #endif 762 763 #ifdef MAX_NR_SERVICE_RECORD_ITEMS 764 #if MAX_NR_SERVICE_RECORD_ITEMS > 0 765 static service_record_item_t service_record_item_storage[MAX_NR_SERVICE_RECORD_ITEMS]; 766 static btstack_memory_pool_t service_record_item_pool; 767 service_record_item_t * btstack_memory_service_record_item_get(void){ 768 void * buffer = btstack_memory_pool_get(&service_record_item_pool); 769 if (buffer){ 770 memset(buffer, 0, sizeof(service_record_item_t)); 771 } 772 return (service_record_item_t *) buffer; 773 } 774 void btstack_memory_service_record_item_free(service_record_item_t *service_record_item){ 775 btstack_memory_pool_free(&service_record_item_pool, service_record_item); 776 } 777 #else 778 service_record_item_t * btstack_memory_service_record_item_get(void){ 779 return NULL; 780 } 781 void btstack_memory_service_record_item_free(service_record_item_t *service_record_item){ 782 UNUSED(service_record_item); 783 }; 784 #endif 785 #elif defined(HAVE_MALLOC) 786 787 typedef struct { 788 btstack_memory_buffer_t tracking; 789 service_record_item_t data; 790 } btstack_memory_service_record_item_t; 791 792 service_record_item_t * btstack_memory_service_record_item_get(void){ 793 btstack_memory_service_record_item_t * buffer = (btstack_memory_service_record_item_t *) malloc(sizeof(btstack_memory_service_record_item_t)); 794 if (buffer){ 795 memset(buffer, 0, sizeof(btstack_memory_service_record_item_t)); 796 btstack_memory_tracking_add(&buffer->tracking); 797 return &buffer->data; 798 } else { 799 return NULL; 800 } 801 } 802 void btstack_memory_service_record_item_free(service_record_item_t *service_record_item){ 803 // reconstruct buffer start 804 btstack_memory_buffer_t * buffer = &((btstack_memory_buffer_t *) service_record_item)[-1]; 805 btstack_memory_tracking_remove(buffer); 806 free(buffer); 807 } 808 #endif 809 810 811 812 // MARK: avdtp_stream_endpoint_t 813 #if !defined(HAVE_MALLOC) && !defined(MAX_NR_AVDTP_STREAM_ENDPOINTS) 814 #if defined(MAX_NO_AVDTP_STREAM_ENDPOINTS) 815 #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." 816 #else 817 #define MAX_NR_AVDTP_STREAM_ENDPOINTS 0 818 #endif 819 #endif 820 821 #ifdef MAX_NR_AVDTP_STREAM_ENDPOINTS 822 #if MAX_NR_AVDTP_STREAM_ENDPOINTS > 0 823 static avdtp_stream_endpoint_t avdtp_stream_endpoint_storage[MAX_NR_AVDTP_STREAM_ENDPOINTS]; 824 static btstack_memory_pool_t avdtp_stream_endpoint_pool; 825 avdtp_stream_endpoint_t * btstack_memory_avdtp_stream_endpoint_get(void){ 826 void * buffer = btstack_memory_pool_get(&avdtp_stream_endpoint_pool); 827 if (buffer){ 828 memset(buffer, 0, sizeof(avdtp_stream_endpoint_t)); 829 } 830 return (avdtp_stream_endpoint_t *) buffer; 831 } 832 void btstack_memory_avdtp_stream_endpoint_free(avdtp_stream_endpoint_t *avdtp_stream_endpoint){ 833 btstack_memory_pool_free(&avdtp_stream_endpoint_pool, avdtp_stream_endpoint); 834 } 835 #else 836 avdtp_stream_endpoint_t * btstack_memory_avdtp_stream_endpoint_get(void){ 837 return NULL; 838 } 839 void btstack_memory_avdtp_stream_endpoint_free(avdtp_stream_endpoint_t *avdtp_stream_endpoint){ 840 UNUSED(avdtp_stream_endpoint); 841 }; 842 #endif 843 #elif defined(HAVE_MALLOC) 844 845 typedef struct { 846 btstack_memory_buffer_t tracking; 847 avdtp_stream_endpoint_t data; 848 } btstack_memory_avdtp_stream_endpoint_t; 849 850 avdtp_stream_endpoint_t * btstack_memory_avdtp_stream_endpoint_get(void){ 851 btstack_memory_avdtp_stream_endpoint_t * buffer = (btstack_memory_avdtp_stream_endpoint_t *) malloc(sizeof(btstack_memory_avdtp_stream_endpoint_t)); 852 if (buffer){ 853 memset(buffer, 0, sizeof(btstack_memory_avdtp_stream_endpoint_t)); 854 btstack_memory_tracking_add(&buffer->tracking); 855 return &buffer->data; 856 } else { 857 return NULL; 858 } 859 } 860 void btstack_memory_avdtp_stream_endpoint_free(avdtp_stream_endpoint_t *avdtp_stream_endpoint){ 861 // reconstruct buffer start 862 btstack_memory_buffer_t * buffer = &((btstack_memory_buffer_t *) avdtp_stream_endpoint)[-1]; 863 btstack_memory_tracking_remove(buffer); 864 free(buffer); 865 } 866 #endif 867 868 869 870 // MARK: avdtp_connection_t 871 #if !defined(HAVE_MALLOC) && !defined(MAX_NR_AVDTP_CONNECTIONS) 872 #if defined(MAX_NO_AVDTP_CONNECTIONS) 873 #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." 874 #else 875 #define MAX_NR_AVDTP_CONNECTIONS 0 876 #endif 877 #endif 878 879 #ifdef MAX_NR_AVDTP_CONNECTIONS 880 #if MAX_NR_AVDTP_CONNECTIONS > 0 881 static avdtp_connection_t avdtp_connection_storage[MAX_NR_AVDTP_CONNECTIONS]; 882 static btstack_memory_pool_t avdtp_connection_pool; 883 avdtp_connection_t * btstack_memory_avdtp_connection_get(void){ 884 void * buffer = btstack_memory_pool_get(&avdtp_connection_pool); 885 if (buffer){ 886 memset(buffer, 0, sizeof(avdtp_connection_t)); 887 } 888 return (avdtp_connection_t *) buffer; 889 } 890 void btstack_memory_avdtp_connection_free(avdtp_connection_t *avdtp_connection){ 891 btstack_memory_pool_free(&avdtp_connection_pool, avdtp_connection); 892 } 893 #else 894 avdtp_connection_t * btstack_memory_avdtp_connection_get(void){ 895 return NULL; 896 } 897 void btstack_memory_avdtp_connection_free(avdtp_connection_t *avdtp_connection){ 898 UNUSED(avdtp_connection); 899 }; 900 #endif 901 #elif defined(HAVE_MALLOC) 902 903 typedef struct { 904 btstack_memory_buffer_t tracking; 905 avdtp_connection_t data; 906 } btstack_memory_avdtp_connection_t; 907 908 avdtp_connection_t * btstack_memory_avdtp_connection_get(void){ 909 btstack_memory_avdtp_connection_t * buffer = (btstack_memory_avdtp_connection_t *) malloc(sizeof(btstack_memory_avdtp_connection_t)); 910 if (buffer){ 911 memset(buffer, 0, sizeof(btstack_memory_avdtp_connection_t)); 912 btstack_memory_tracking_add(&buffer->tracking); 913 return &buffer->data; 914 } else { 915 return NULL; 916 } 917 } 918 void btstack_memory_avdtp_connection_free(avdtp_connection_t *avdtp_connection){ 919 // reconstruct buffer start 920 btstack_memory_buffer_t * buffer = &((btstack_memory_buffer_t *) avdtp_connection)[-1]; 921 btstack_memory_tracking_remove(buffer); 922 free(buffer); 923 } 924 #endif 925 926 927 928 // MARK: avrcp_connection_t 929 #if !defined(HAVE_MALLOC) && !defined(MAX_NR_AVRCP_CONNECTIONS) 930 #if defined(MAX_NO_AVRCP_CONNECTIONS) 931 #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." 932 #else 933 #define MAX_NR_AVRCP_CONNECTIONS 0 934 #endif 935 #endif 936 937 #ifdef MAX_NR_AVRCP_CONNECTIONS 938 #if MAX_NR_AVRCP_CONNECTIONS > 0 939 static avrcp_connection_t avrcp_connection_storage[MAX_NR_AVRCP_CONNECTIONS]; 940 static btstack_memory_pool_t avrcp_connection_pool; 941 avrcp_connection_t * btstack_memory_avrcp_connection_get(void){ 942 void * buffer = btstack_memory_pool_get(&avrcp_connection_pool); 943 if (buffer){ 944 memset(buffer, 0, sizeof(avrcp_connection_t)); 945 } 946 return (avrcp_connection_t *) buffer; 947 } 948 void btstack_memory_avrcp_connection_free(avrcp_connection_t *avrcp_connection){ 949 btstack_memory_pool_free(&avrcp_connection_pool, avrcp_connection); 950 } 951 #else 952 avrcp_connection_t * btstack_memory_avrcp_connection_get(void){ 953 return NULL; 954 } 955 void btstack_memory_avrcp_connection_free(avrcp_connection_t *avrcp_connection){ 956 UNUSED(avrcp_connection); 957 }; 958 #endif 959 #elif defined(HAVE_MALLOC) 960 961 typedef struct { 962 btstack_memory_buffer_t tracking; 963 avrcp_connection_t data; 964 } btstack_memory_avrcp_connection_t; 965 966 avrcp_connection_t * btstack_memory_avrcp_connection_get(void){ 967 btstack_memory_avrcp_connection_t * buffer = (btstack_memory_avrcp_connection_t *) malloc(sizeof(btstack_memory_avrcp_connection_t)); 968 if (buffer){ 969 memset(buffer, 0, sizeof(btstack_memory_avrcp_connection_t)); 970 btstack_memory_tracking_add(&buffer->tracking); 971 return &buffer->data; 972 } else { 973 return NULL; 974 } 975 } 976 void btstack_memory_avrcp_connection_free(avrcp_connection_t *avrcp_connection){ 977 // reconstruct buffer start 978 btstack_memory_buffer_t * buffer = &((btstack_memory_buffer_t *) avrcp_connection)[-1]; 979 btstack_memory_tracking_remove(buffer); 980 free(buffer); 981 } 982 #endif 983 984 985 986 // MARK: avrcp_browsing_connection_t 987 #if !defined(HAVE_MALLOC) && !defined(MAX_NR_AVRCP_BROWSING_CONNECTIONS) 988 #if defined(MAX_NO_AVRCP_BROWSING_CONNECTIONS) 989 #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." 990 #else 991 #define MAX_NR_AVRCP_BROWSING_CONNECTIONS 0 992 #endif 993 #endif 994 995 #ifdef MAX_NR_AVRCP_BROWSING_CONNECTIONS 996 #if MAX_NR_AVRCP_BROWSING_CONNECTIONS > 0 997 static avrcp_browsing_connection_t avrcp_browsing_connection_storage[MAX_NR_AVRCP_BROWSING_CONNECTIONS]; 998 static btstack_memory_pool_t avrcp_browsing_connection_pool; 999 avrcp_browsing_connection_t * btstack_memory_avrcp_browsing_connection_get(void){ 1000 void * buffer = btstack_memory_pool_get(&avrcp_browsing_connection_pool); 1001 if (buffer){ 1002 memset(buffer, 0, sizeof(avrcp_browsing_connection_t)); 1003 } 1004 return (avrcp_browsing_connection_t *) buffer; 1005 } 1006 void btstack_memory_avrcp_browsing_connection_free(avrcp_browsing_connection_t *avrcp_browsing_connection){ 1007 btstack_memory_pool_free(&avrcp_browsing_connection_pool, avrcp_browsing_connection); 1008 } 1009 #else 1010 avrcp_browsing_connection_t * btstack_memory_avrcp_browsing_connection_get(void){ 1011 return NULL; 1012 } 1013 void btstack_memory_avrcp_browsing_connection_free(avrcp_browsing_connection_t *avrcp_browsing_connection){ 1014 UNUSED(avrcp_browsing_connection); 1015 }; 1016 #endif 1017 #elif defined(HAVE_MALLOC) 1018 1019 typedef struct { 1020 btstack_memory_buffer_t tracking; 1021 avrcp_browsing_connection_t data; 1022 } btstack_memory_avrcp_browsing_connection_t; 1023 1024 avrcp_browsing_connection_t * btstack_memory_avrcp_browsing_connection_get(void){ 1025 btstack_memory_avrcp_browsing_connection_t * buffer = (btstack_memory_avrcp_browsing_connection_t *) malloc(sizeof(btstack_memory_avrcp_browsing_connection_t)); 1026 if (buffer){ 1027 memset(buffer, 0, sizeof(btstack_memory_avrcp_browsing_connection_t)); 1028 btstack_memory_tracking_add(&buffer->tracking); 1029 return &buffer->data; 1030 } else { 1031 return NULL; 1032 } 1033 } 1034 void btstack_memory_avrcp_browsing_connection_free(avrcp_browsing_connection_t *avrcp_browsing_connection){ 1035 // reconstruct buffer start 1036 btstack_memory_buffer_t * buffer = &((btstack_memory_buffer_t *) avrcp_browsing_connection)[-1]; 1037 btstack_memory_tracking_remove(buffer); 1038 free(buffer); 1039 } 1040 #endif 1041 1042 1043 #endif 1044 #ifdef ENABLE_BLE 1045 1046 // MARK: battery_service_client_t 1047 #if !defined(HAVE_MALLOC) && !defined(MAX_NR_BATTERY_SERVICE_CLIENTS) 1048 #if defined(MAX_NO_BATTERY_SERVICE_CLIENTS) 1049 #error "Deprecated MAX_NO_BATTERY_SERVICE_CLIENTS defined instead of MAX_NR_BATTERY_SERVICE_CLIENTS. Please update your btstack_config.h to use MAX_NR_BATTERY_SERVICE_CLIENTS." 1050 #else 1051 #define MAX_NR_BATTERY_SERVICE_CLIENTS 0 1052 #endif 1053 #endif 1054 1055 #ifdef MAX_NR_BATTERY_SERVICE_CLIENTS 1056 #if MAX_NR_BATTERY_SERVICE_CLIENTS > 0 1057 static battery_service_client_t battery_service_client_storage[MAX_NR_BATTERY_SERVICE_CLIENTS]; 1058 static btstack_memory_pool_t battery_service_client_pool; 1059 battery_service_client_t * btstack_memory_battery_service_client_get(void){ 1060 void * buffer = btstack_memory_pool_get(&battery_service_client_pool); 1061 if (buffer){ 1062 memset(buffer, 0, sizeof(battery_service_client_t)); 1063 } 1064 return (battery_service_client_t *) buffer; 1065 } 1066 void btstack_memory_battery_service_client_free(battery_service_client_t *battery_service_client){ 1067 btstack_memory_pool_free(&battery_service_client_pool, battery_service_client); 1068 } 1069 #else 1070 battery_service_client_t * btstack_memory_battery_service_client_get(void){ 1071 return NULL; 1072 } 1073 void btstack_memory_battery_service_client_free(battery_service_client_t *battery_service_client){ 1074 UNUSED(battery_service_client); 1075 }; 1076 #endif 1077 #elif defined(HAVE_MALLOC) 1078 1079 typedef struct { 1080 btstack_memory_buffer_t tracking; 1081 battery_service_client_t data; 1082 } btstack_memory_battery_service_client_t; 1083 1084 battery_service_client_t * btstack_memory_battery_service_client_get(void){ 1085 btstack_memory_battery_service_client_t * buffer = (btstack_memory_battery_service_client_t *) malloc(sizeof(btstack_memory_battery_service_client_t)); 1086 if (buffer){ 1087 memset(buffer, 0, sizeof(btstack_memory_battery_service_client_t)); 1088 btstack_memory_tracking_add(&buffer->tracking); 1089 return &buffer->data; 1090 } else { 1091 return NULL; 1092 } 1093 } 1094 void btstack_memory_battery_service_client_free(battery_service_client_t *battery_service_client){ 1095 // reconstruct buffer start 1096 btstack_memory_buffer_t * buffer = &((btstack_memory_buffer_t *) battery_service_client)[-1]; 1097 btstack_memory_tracking_remove(buffer); 1098 free(buffer); 1099 } 1100 #endif 1101 1102 1103 // MARK: gatt_client_t 1104 #if !defined(HAVE_MALLOC) && !defined(MAX_NR_GATT_CLIENTS) 1105 #if defined(MAX_NO_GATT_CLIENTS) 1106 #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." 1107 #else 1108 #define MAX_NR_GATT_CLIENTS 0 1109 #endif 1110 #endif 1111 1112 #ifdef MAX_NR_GATT_CLIENTS 1113 #if MAX_NR_GATT_CLIENTS > 0 1114 static gatt_client_t gatt_client_storage[MAX_NR_GATT_CLIENTS]; 1115 static btstack_memory_pool_t gatt_client_pool; 1116 gatt_client_t * btstack_memory_gatt_client_get(void){ 1117 void * buffer = btstack_memory_pool_get(&gatt_client_pool); 1118 if (buffer){ 1119 memset(buffer, 0, sizeof(gatt_client_t)); 1120 } 1121 return (gatt_client_t *) buffer; 1122 } 1123 void btstack_memory_gatt_client_free(gatt_client_t *gatt_client){ 1124 btstack_memory_pool_free(&gatt_client_pool, gatt_client); 1125 } 1126 #else 1127 gatt_client_t * btstack_memory_gatt_client_get(void){ 1128 return NULL; 1129 } 1130 void btstack_memory_gatt_client_free(gatt_client_t *gatt_client){ 1131 UNUSED(gatt_client); 1132 }; 1133 #endif 1134 #elif defined(HAVE_MALLOC) 1135 1136 typedef struct { 1137 btstack_memory_buffer_t tracking; 1138 gatt_client_t data; 1139 } btstack_memory_gatt_client_t; 1140 1141 gatt_client_t * btstack_memory_gatt_client_get(void){ 1142 btstack_memory_gatt_client_t * buffer = (btstack_memory_gatt_client_t *) malloc(sizeof(btstack_memory_gatt_client_t)); 1143 if (buffer){ 1144 memset(buffer, 0, sizeof(btstack_memory_gatt_client_t)); 1145 btstack_memory_tracking_add(&buffer->tracking); 1146 return &buffer->data; 1147 } else { 1148 return NULL; 1149 } 1150 } 1151 void btstack_memory_gatt_client_free(gatt_client_t *gatt_client){ 1152 // reconstruct buffer start 1153 btstack_memory_buffer_t * buffer = &((btstack_memory_buffer_t *) gatt_client)[-1]; 1154 btstack_memory_tracking_remove(buffer); 1155 free(buffer); 1156 } 1157 #endif 1158 1159 1160 // MARK: hids_client_t 1161 #if !defined(HAVE_MALLOC) && !defined(MAX_NR_HIDS_CLIENTS) 1162 #if defined(MAX_NO_HIDS_CLIENTS) 1163 #error "Deprecated MAX_NO_HIDS_CLIENTS defined instead of MAX_NR_HIDS_CLIENTS. Please update your btstack_config.h to use MAX_NR_HIDS_CLIENTS." 1164 #else 1165 #define MAX_NR_HIDS_CLIENTS 0 1166 #endif 1167 #endif 1168 1169 #ifdef MAX_NR_HIDS_CLIENTS 1170 #if MAX_NR_HIDS_CLIENTS > 0 1171 static hids_client_t hids_client_storage[MAX_NR_HIDS_CLIENTS]; 1172 static btstack_memory_pool_t hids_client_pool; 1173 hids_client_t * btstack_memory_hids_client_get(void){ 1174 void * buffer = btstack_memory_pool_get(&hids_client_pool); 1175 if (buffer){ 1176 memset(buffer, 0, sizeof(hids_client_t)); 1177 } 1178 return (hids_client_t *) buffer; 1179 } 1180 void btstack_memory_hids_client_free(hids_client_t *hids_client){ 1181 btstack_memory_pool_free(&hids_client_pool, hids_client); 1182 } 1183 #else 1184 hids_client_t * btstack_memory_hids_client_get(void){ 1185 return NULL; 1186 } 1187 void btstack_memory_hids_client_free(hids_client_t *hids_client){ 1188 UNUSED(hids_client); 1189 }; 1190 #endif 1191 #elif defined(HAVE_MALLOC) 1192 1193 typedef struct { 1194 btstack_memory_buffer_t tracking; 1195 hids_client_t data; 1196 } btstack_memory_hids_client_t; 1197 1198 hids_client_t * btstack_memory_hids_client_get(void){ 1199 btstack_memory_hids_client_t * buffer = (btstack_memory_hids_client_t *) malloc(sizeof(btstack_memory_hids_client_t)); 1200 if (buffer){ 1201 memset(buffer, 0, sizeof(btstack_memory_hids_client_t)); 1202 btstack_memory_tracking_add(&buffer->tracking); 1203 return &buffer->data; 1204 } else { 1205 return NULL; 1206 } 1207 } 1208 void btstack_memory_hids_client_free(hids_client_t *hids_client){ 1209 // reconstruct buffer start 1210 btstack_memory_buffer_t * buffer = &((btstack_memory_buffer_t *) hids_client)[-1]; 1211 btstack_memory_tracking_remove(buffer); 1212 free(buffer); 1213 } 1214 #endif 1215 1216 1217 // MARK: scan_parameters_service_client_t 1218 #if !defined(HAVE_MALLOC) && !defined(MAX_NR_SCAN_PARAMETERS_SERVICE_CLIENTS) 1219 #if defined(MAX_NO_SCAN_PARAMETERS_SERVICE_CLIENTS) 1220 #error "Deprecated MAX_NO_SCAN_PARAMETERS_SERVICE_CLIENTS defined instead of MAX_NR_SCAN_PARAMETERS_SERVICE_CLIENTS. Please update your btstack_config.h to use MAX_NR_SCAN_PARAMETERS_SERVICE_CLIENTS." 1221 #else 1222 #define MAX_NR_SCAN_PARAMETERS_SERVICE_CLIENTS 0 1223 #endif 1224 #endif 1225 1226 #ifdef MAX_NR_SCAN_PARAMETERS_SERVICE_CLIENTS 1227 #if MAX_NR_SCAN_PARAMETERS_SERVICE_CLIENTS > 0 1228 static scan_parameters_service_client_t scan_parameters_service_client_storage[MAX_NR_SCAN_PARAMETERS_SERVICE_CLIENTS]; 1229 static btstack_memory_pool_t scan_parameters_service_client_pool; 1230 scan_parameters_service_client_t * btstack_memory_scan_parameters_service_client_get(void){ 1231 void * buffer = btstack_memory_pool_get(&scan_parameters_service_client_pool); 1232 if (buffer){ 1233 memset(buffer, 0, sizeof(scan_parameters_service_client_t)); 1234 } 1235 return (scan_parameters_service_client_t *) buffer; 1236 } 1237 void btstack_memory_scan_parameters_service_client_free(scan_parameters_service_client_t *scan_parameters_service_client){ 1238 btstack_memory_pool_free(&scan_parameters_service_client_pool, scan_parameters_service_client); 1239 } 1240 #else 1241 scan_parameters_service_client_t * btstack_memory_scan_parameters_service_client_get(void){ 1242 return NULL; 1243 } 1244 void btstack_memory_scan_parameters_service_client_free(scan_parameters_service_client_t *scan_parameters_service_client){ 1245 UNUSED(scan_parameters_service_client); 1246 }; 1247 #endif 1248 #elif defined(HAVE_MALLOC) 1249 1250 typedef struct { 1251 btstack_memory_buffer_t tracking; 1252 scan_parameters_service_client_t data; 1253 } btstack_memory_scan_parameters_service_client_t; 1254 1255 scan_parameters_service_client_t * btstack_memory_scan_parameters_service_client_get(void){ 1256 btstack_memory_scan_parameters_service_client_t * buffer = (btstack_memory_scan_parameters_service_client_t *) malloc(sizeof(btstack_memory_scan_parameters_service_client_t)); 1257 if (buffer){ 1258 memset(buffer, 0, sizeof(btstack_memory_scan_parameters_service_client_t)); 1259 btstack_memory_tracking_add(&buffer->tracking); 1260 return &buffer->data; 1261 } else { 1262 return NULL; 1263 } 1264 } 1265 void btstack_memory_scan_parameters_service_client_free(scan_parameters_service_client_t *scan_parameters_service_client){ 1266 // reconstruct buffer start 1267 btstack_memory_buffer_t * buffer = &((btstack_memory_buffer_t *) scan_parameters_service_client)[-1]; 1268 btstack_memory_tracking_remove(buffer); 1269 free(buffer); 1270 } 1271 #endif 1272 1273 1274 // MARK: sm_lookup_entry_t 1275 #if !defined(HAVE_MALLOC) && !defined(MAX_NR_SM_LOOKUP_ENTRIES) 1276 #if defined(MAX_NO_SM_LOOKUP_ENTRIES) 1277 #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." 1278 #else 1279 #define MAX_NR_SM_LOOKUP_ENTRIES 0 1280 #endif 1281 #endif 1282 1283 #ifdef MAX_NR_SM_LOOKUP_ENTRIES 1284 #if MAX_NR_SM_LOOKUP_ENTRIES > 0 1285 static sm_lookup_entry_t sm_lookup_entry_storage[MAX_NR_SM_LOOKUP_ENTRIES]; 1286 static btstack_memory_pool_t sm_lookup_entry_pool; 1287 sm_lookup_entry_t * btstack_memory_sm_lookup_entry_get(void){ 1288 void * buffer = btstack_memory_pool_get(&sm_lookup_entry_pool); 1289 if (buffer){ 1290 memset(buffer, 0, sizeof(sm_lookup_entry_t)); 1291 } 1292 return (sm_lookup_entry_t *) buffer; 1293 } 1294 void btstack_memory_sm_lookup_entry_free(sm_lookup_entry_t *sm_lookup_entry){ 1295 btstack_memory_pool_free(&sm_lookup_entry_pool, sm_lookup_entry); 1296 } 1297 #else 1298 sm_lookup_entry_t * btstack_memory_sm_lookup_entry_get(void){ 1299 return NULL; 1300 } 1301 void btstack_memory_sm_lookup_entry_free(sm_lookup_entry_t *sm_lookup_entry){ 1302 UNUSED(sm_lookup_entry); 1303 }; 1304 #endif 1305 #elif defined(HAVE_MALLOC) 1306 1307 typedef struct { 1308 btstack_memory_buffer_t tracking; 1309 sm_lookup_entry_t data; 1310 } btstack_memory_sm_lookup_entry_t; 1311 1312 sm_lookup_entry_t * btstack_memory_sm_lookup_entry_get(void){ 1313 btstack_memory_sm_lookup_entry_t * buffer = (btstack_memory_sm_lookup_entry_t *) malloc(sizeof(btstack_memory_sm_lookup_entry_t)); 1314 if (buffer){ 1315 memset(buffer, 0, sizeof(btstack_memory_sm_lookup_entry_t)); 1316 btstack_memory_tracking_add(&buffer->tracking); 1317 return &buffer->data; 1318 } else { 1319 return NULL; 1320 } 1321 } 1322 void btstack_memory_sm_lookup_entry_free(sm_lookup_entry_t *sm_lookup_entry){ 1323 // reconstruct buffer start 1324 btstack_memory_buffer_t * buffer = &((btstack_memory_buffer_t *) sm_lookup_entry)[-1]; 1325 btstack_memory_tracking_remove(buffer); 1326 free(buffer); 1327 } 1328 #endif 1329 1330 1331 // MARK: whitelist_entry_t 1332 #if !defined(HAVE_MALLOC) && !defined(MAX_NR_WHITELIST_ENTRIES) 1333 #if defined(MAX_NO_WHITELIST_ENTRIES) 1334 #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." 1335 #else 1336 #define MAX_NR_WHITELIST_ENTRIES 0 1337 #endif 1338 #endif 1339 1340 #ifdef MAX_NR_WHITELIST_ENTRIES 1341 #if MAX_NR_WHITELIST_ENTRIES > 0 1342 static whitelist_entry_t whitelist_entry_storage[MAX_NR_WHITELIST_ENTRIES]; 1343 static btstack_memory_pool_t whitelist_entry_pool; 1344 whitelist_entry_t * btstack_memory_whitelist_entry_get(void){ 1345 void * buffer = btstack_memory_pool_get(&whitelist_entry_pool); 1346 if (buffer){ 1347 memset(buffer, 0, sizeof(whitelist_entry_t)); 1348 } 1349 return (whitelist_entry_t *) buffer; 1350 } 1351 void btstack_memory_whitelist_entry_free(whitelist_entry_t *whitelist_entry){ 1352 btstack_memory_pool_free(&whitelist_entry_pool, whitelist_entry); 1353 } 1354 #else 1355 whitelist_entry_t * btstack_memory_whitelist_entry_get(void){ 1356 return NULL; 1357 } 1358 void btstack_memory_whitelist_entry_free(whitelist_entry_t *whitelist_entry){ 1359 UNUSED(whitelist_entry); 1360 }; 1361 #endif 1362 #elif defined(HAVE_MALLOC) 1363 1364 typedef struct { 1365 btstack_memory_buffer_t tracking; 1366 whitelist_entry_t data; 1367 } btstack_memory_whitelist_entry_t; 1368 1369 whitelist_entry_t * btstack_memory_whitelist_entry_get(void){ 1370 btstack_memory_whitelist_entry_t * buffer = (btstack_memory_whitelist_entry_t *) malloc(sizeof(btstack_memory_whitelist_entry_t)); 1371 if (buffer){ 1372 memset(buffer, 0, sizeof(btstack_memory_whitelist_entry_t)); 1373 btstack_memory_tracking_add(&buffer->tracking); 1374 return &buffer->data; 1375 } else { 1376 return NULL; 1377 } 1378 } 1379 void btstack_memory_whitelist_entry_free(whitelist_entry_t *whitelist_entry){ 1380 // reconstruct buffer start 1381 btstack_memory_buffer_t * buffer = &((btstack_memory_buffer_t *) whitelist_entry)[-1]; 1382 btstack_memory_tracking_remove(buffer); 1383 free(buffer); 1384 } 1385 #endif 1386 1387 1388 // MARK: periodic_advertiser_list_entry_t 1389 #if !defined(HAVE_MALLOC) && !defined(MAX_NR_PERIODIC_ADVERTISER_LIST_ENTRIES) 1390 #if defined(MAX_NO_PERIODIC_ADVERTISER_LIST_ENTRIES) 1391 #error "Deprecated MAX_NO_PERIODIC_ADVERTISER_LIST_ENTRIES defined instead of MAX_NR_PERIODIC_ADVERTISER_LIST_ENTRIES. Please update your btstack_config.h to use MAX_NR_PERIODIC_ADVERTISER_LIST_ENTRIES." 1392 #else 1393 #define MAX_NR_PERIODIC_ADVERTISER_LIST_ENTRIES 0 1394 #endif 1395 #endif 1396 1397 #ifdef MAX_NR_PERIODIC_ADVERTISER_LIST_ENTRIES 1398 #if MAX_NR_PERIODIC_ADVERTISER_LIST_ENTRIES > 0 1399 static periodic_advertiser_list_entry_t periodic_advertiser_list_entry_storage[MAX_NR_PERIODIC_ADVERTISER_LIST_ENTRIES]; 1400 static btstack_memory_pool_t periodic_advertiser_list_entry_pool; 1401 periodic_advertiser_list_entry_t * btstack_memory_periodic_advertiser_list_entry_get(void){ 1402 void * buffer = btstack_memory_pool_get(&periodic_advertiser_list_entry_pool); 1403 if (buffer){ 1404 memset(buffer, 0, sizeof(periodic_advertiser_list_entry_t)); 1405 } 1406 return (periodic_advertiser_list_entry_t *) buffer; 1407 } 1408 void btstack_memory_periodic_advertiser_list_entry_free(periodic_advertiser_list_entry_t *periodic_advertiser_list_entry){ 1409 btstack_memory_pool_free(&periodic_advertiser_list_entry_pool, periodic_advertiser_list_entry); 1410 } 1411 #else 1412 periodic_advertiser_list_entry_t * btstack_memory_periodic_advertiser_list_entry_get(void){ 1413 return NULL; 1414 } 1415 void btstack_memory_periodic_advertiser_list_entry_free(periodic_advertiser_list_entry_t *periodic_advertiser_list_entry){ 1416 UNUSED(periodic_advertiser_list_entry); 1417 }; 1418 #endif 1419 #elif defined(HAVE_MALLOC) 1420 1421 typedef struct { 1422 btstack_memory_buffer_t tracking; 1423 periodic_advertiser_list_entry_t data; 1424 } btstack_memory_periodic_advertiser_list_entry_t; 1425 1426 periodic_advertiser_list_entry_t * btstack_memory_periodic_advertiser_list_entry_get(void){ 1427 btstack_memory_periodic_advertiser_list_entry_t * buffer = (btstack_memory_periodic_advertiser_list_entry_t *) malloc(sizeof(btstack_memory_periodic_advertiser_list_entry_t)); 1428 if (buffer){ 1429 memset(buffer, 0, sizeof(btstack_memory_periodic_advertiser_list_entry_t)); 1430 btstack_memory_tracking_add(&buffer->tracking); 1431 return &buffer->data; 1432 } else { 1433 return NULL; 1434 } 1435 } 1436 void btstack_memory_periodic_advertiser_list_entry_free(periodic_advertiser_list_entry_t *periodic_advertiser_list_entry){ 1437 // reconstruct buffer start 1438 btstack_memory_buffer_t * buffer = &((btstack_memory_buffer_t *) periodic_advertiser_list_entry)[-1]; 1439 btstack_memory_tracking_remove(buffer); 1440 free(buffer); 1441 } 1442 #endif 1443 1444 1445 #endif 1446 #ifdef ENABLE_MESH 1447 1448 // MARK: mesh_network_pdu_t 1449 #if !defined(HAVE_MALLOC) && !defined(MAX_NR_MESH_NETWORK_PDUS) 1450 #if defined(MAX_NO_MESH_NETWORK_PDUS) 1451 #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." 1452 #else 1453 #define MAX_NR_MESH_NETWORK_PDUS 0 1454 #endif 1455 #endif 1456 1457 #ifdef MAX_NR_MESH_NETWORK_PDUS 1458 #if MAX_NR_MESH_NETWORK_PDUS > 0 1459 static mesh_network_pdu_t mesh_network_pdu_storage[MAX_NR_MESH_NETWORK_PDUS]; 1460 static btstack_memory_pool_t mesh_network_pdu_pool; 1461 mesh_network_pdu_t * btstack_memory_mesh_network_pdu_get(void){ 1462 void * buffer = btstack_memory_pool_get(&mesh_network_pdu_pool); 1463 if (buffer){ 1464 memset(buffer, 0, sizeof(mesh_network_pdu_t)); 1465 } 1466 return (mesh_network_pdu_t *) buffer; 1467 } 1468 void btstack_memory_mesh_network_pdu_free(mesh_network_pdu_t *mesh_network_pdu){ 1469 btstack_memory_pool_free(&mesh_network_pdu_pool, mesh_network_pdu); 1470 } 1471 #else 1472 mesh_network_pdu_t * btstack_memory_mesh_network_pdu_get(void){ 1473 return NULL; 1474 } 1475 void btstack_memory_mesh_network_pdu_free(mesh_network_pdu_t *mesh_network_pdu){ 1476 UNUSED(mesh_network_pdu); 1477 }; 1478 #endif 1479 #elif defined(HAVE_MALLOC) 1480 1481 typedef struct { 1482 btstack_memory_buffer_t tracking; 1483 mesh_network_pdu_t data; 1484 } btstack_memory_mesh_network_pdu_t; 1485 1486 mesh_network_pdu_t * btstack_memory_mesh_network_pdu_get(void){ 1487 btstack_memory_mesh_network_pdu_t * buffer = (btstack_memory_mesh_network_pdu_t *) malloc(sizeof(btstack_memory_mesh_network_pdu_t)); 1488 if (buffer){ 1489 memset(buffer, 0, sizeof(btstack_memory_mesh_network_pdu_t)); 1490 btstack_memory_tracking_add(&buffer->tracking); 1491 return &buffer->data; 1492 } else { 1493 return NULL; 1494 } 1495 } 1496 void btstack_memory_mesh_network_pdu_free(mesh_network_pdu_t *mesh_network_pdu){ 1497 // reconstruct buffer start 1498 btstack_memory_buffer_t * buffer = &((btstack_memory_buffer_t *) mesh_network_pdu)[-1]; 1499 btstack_memory_tracking_remove(buffer); 1500 free(buffer); 1501 } 1502 #endif 1503 1504 1505 // MARK: mesh_segmented_pdu_t 1506 #if !defined(HAVE_MALLOC) && !defined(MAX_NR_MESH_SEGMENTED_PDUS) 1507 #if defined(MAX_NO_MESH_SEGMENTED_PDUS) 1508 #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." 1509 #else 1510 #define MAX_NR_MESH_SEGMENTED_PDUS 0 1511 #endif 1512 #endif 1513 1514 #ifdef MAX_NR_MESH_SEGMENTED_PDUS 1515 #if MAX_NR_MESH_SEGMENTED_PDUS > 0 1516 static mesh_segmented_pdu_t mesh_segmented_pdu_storage[MAX_NR_MESH_SEGMENTED_PDUS]; 1517 static btstack_memory_pool_t mesh_segmented_pdu_pool; 1518 mesh_segmented_pdu_t * btstack_memory_mesh_segmented_pdu_get(void){ 1519 void * buffer = btstack_memory_pool_get(&mesh_segmented_pdu_pool); 1520 if (buffer){ 1521 memset(buffer, 0, sizeof(mesh_segmented_pdu_t)); 1522 } 1523 return (mesh_segmented_pdu_t *) buffer; 1524 } 1525 void btstack_memory_mesh_segmented_pdu_free(mesh_segmented_pdu_t *mesh_segmented_pdu){ 1526 btstack_memory_pool_free(&mesh_segmented_pdu_pool, mesh_segmented_pdu); 1527 } 1528 #else 1529 mesh_segmented_pdu_t * btstack_memory_mesh_segmented_pdu_get(void){ 1530 return NULL; 1531 } 1532 void btstack_memory_mesh_segmented_pdu_free(mesh_segmented_pdu_t *mesh_segmented_pdu){ 1533 UNUSED(mesh_segmented_pdu); 1534 }; 1535 #endif 1536 #elif defined(HAVE_MALLOC) 1537 1538 typedef struct { 1539 btstack_memory_buffer_t tracking; 1540 mesh_segmented_pdu_t data; 1541 } btstack_memory_mesh_segmented_pdu_t; 1542 1543 mesh_segmented_pdu_t * btstack_memory_mesh_segmented_pdu_get(void){ 1544 btstack_memory_mesh_segmented_pdu_t * buffer = (btstack_memory_mesh_segmented_pdu_t *) malloc(sizeof(btstack_memory_mesh_segmented_pdu_t)); 1545 if (buffer){ 1546 memset(buffer, 0, sizeof(btstack_memory_mesh_segmented_pdu_t)); 1547 btstack_memory_tracking_add(&buffer->tracking); 1548 return &buffer->data; 1549 } else { 1550 return NULL; 1551 } 1552 } 1553 void btstack_memory_mesh_segmented_pdu_free(mesh_segmented_pdu_t *mesh_segmented_pdu){ 1554 // reconstruct buffer start 1555 btstack_memory_buffer_t * buffer = &((btstack_memory_buffer_t *) mesh_segmented_pdu)[-1]; 1556 btstack_memory_tracking_remove(buffer); 1557 free(buffer); 1558 } 1559 #endif 1560 1561 1562 // MARK: mesh_upper_transport_pdu_t 1563 #if !defined(HAVE_MALLOC) && !defined(MAX_NR_MESH_UPPER_TRANSPORT_PDUS) 1564 #if defined(MAX_NO_MESH_UPPER_TRANSPORT_PDUS) 1565 #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." 1566 #else 1567 #define MAX_NR_MESH_UPPER_TRANSPORT_PDUS 0 1568 #endif 1569 #endif 1570 1571 #ifdef MAX_NR_MESH_UPPER_TRANSPORT_PDUS 1572 #if MAX_NR_MESH_UPPER_TRANSPORT_PDUS > 0 1573 static mesh_upper_transport_pdu_t mesh_upper_transport_pdu_storage[MAX_NR_MESH_UPPER_TRANSPORT_PDUS]; 1574 static btstack_memory_pool_t mesh_upper_transport_pdu_pool; 1575 mesh_upper_transport_pdu_t * btstack_memory_mesh_upper_transport_pdu_get(void){ 1576 void * buffer = btstack_memory_pool_get(&mesh_upper_transport_pdu_pool); 1577 if (buffer){ 1578 memset(buffer, 0, sizeof(mesh_upper_transport_pdu_t)); 1579 } 1580 return (mesh_upper_transport_pdu_t *) buffer; 1581 } 1582 void btstack_memory_mesh_upper_transport_pdu_free(mesh_upper_transport_pdu_t *mesh_upper_transport_pdu){ 1583 btstack_memory_pool_free(&mesh_upper_transport_pdu_pool, mesh_upper_transport_pdu); 1584 } 1585 #else 1586 mesh_upper_transport_pdu_t * btstack_memory_mesh_upper_transport_pdu_get(void){ 1587 return NULL; 1588 } 1589 void btstack_memory_mesh_upper_transport_pdu_free(mesh_upper_transport_pdu_t *mesh_upper_transport_pdu){ 1590 UNUSED(mesh_upper_transport_pdu); 1591 }; 1592 #endif 1593 #elif defined(HAVE_MALLOC) 1594 1595 typedef struct { 1596 btstack_memory_buffer_t tracking; 1597 mesh_upper_transport_pdu_t data; 1598 } btstack_memory_mesh_upper_transport_pdu_t; 1599 1600 mesh_upper_transport_pdu_t * btstack_memory_mesh_upper_transport_pdu_get(void){ 1601 btstack_memory_mesh_upper_transport_pdu_t * buffer = (btstack_memory_mesh_upper_transport_pdu_t *) malloc(sizeof(btstack_memory_mesh_upper_transport_pdu_t)); 1602 if (buffer){ 1603 memset(buffer, 0, sizeof(btstack_memory_mesh_upper_transport_pdu_t)); 1604 btstack_memory_tracking_add(&buffer->tracking); 1605 return &buffer->data; 1606 } else { 1607 return NULL; 1608 } 1609 } 1610 void btstack_memory_mesh_upper_transport_pdu_free(mesh_upper_transport_pdu_t *mesh_upper_transport_pdu){ 1611 // reconstruct buffer start 1612 btstack_memory_buffer_t * buffer = &((btstack_memory_buffer_t *) mesh_upper_transport_pdu)[-1]; 1613 btstack_memory_tracking_remove(buffer); 1614 free(buffer); 1615 } 1616 #endif 1617 1618 1619 // MARK: mesh_network_key_t 1620 #if !defined(HAVE_MALLOC) && !defined(MAX_NR_MESH_NETWORK_KEYS) 1621 #if defined(MAX_NO_MESH_NETWORK_KEYS) 1622 #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." 1623 #else 1624 #define MAX_NR_MESH_NETWORK_KEYS 0 1625 #endif 1626 #endif 1627 1628 #ifdef MAX_NR_MESH_NETWORK_KEYS 1629 #if MAX_NR_MESH_NETWORK_KEYS > 0 1630 static mesh_network_key_t mesh_network_key_storage[MAX_NR_MESH_NETWORK_KEYS]; 1631 static btstack_memory_pool_t mesh_network_key_pool; 1632 mesh_network_key_t * btstack_memory_mesh_network_key_get(void){ 1633 void * buffer = btstack_memory_pool_get(&mesh_network_key_pool); 1634 if (buffer){ 1635 memset(buffer, 0, sizeof(mesh_network_key_t)); 1636 } 1637 return (mesh_network_key_t *) buffer; 1638 } 1639 void btstack_memory_mesh_network_key_free(mesh_network_key_t *mesh_network_key){ 1640 btstack_memory_pool_free(&mesh_network_key_pool, mesh_network_key); 1641 } 1642 #else 1643 mesh_network_key_t * btstack_memory_mesh_network_key_get(void){ 1644 return NULL; 1645 } 1646 void btstack_memory_mesh_network_key_free(mesh_network_key_t *mesh_network_key){ 1647 UNUSED(mesh_network_key); 1648 }; 1649 #endif 1650 #elif defined(HAVE_MALLOC) 1651 1652 typedef struct { 1653 btstack_memory_buffer_t tracking; 1654 mesh_network_key_t data; 1655 } btstack_memory_mesh_network_key_t; 1656 1657 mesh_network_key_t * btstack_memory_mesh_network_key_get(void){ 1658 btstack_memory_mesh_network_key_t * buffer = (btstack_memory_mesh_network_key_t *) malloc(sizeof(btstack_memory_mesh_network_key_t)); 1659 if (buffer){ 1660 memset(buffer, 0, sizeof(btstack_memory_mesh_network_key_t)); 1661 btstack_memory_tracking_add(&buffer->tracking); 1662 return &buffer->data; 1663 } else { 1664 return NULL; 1665 } 1666 } 1667 void btstack_memory_mesh_network_key_free(mesh_network_key_t *mesh_network_key){ 1668 // reconstruct buffer start 1669 btstack_memory_buffer_t * buffer = &((btstack_memory_buffer_t *) mesh_network_key)[-1]; 1670 btstack_memory_tracking_remove(buffer); 1671 free(buffer); 1672 } 1673 #endif 1674 1675 1676 // MARK: mesh_transport_key_t 1677 #if !defined(HAVE_MALLOC) && !defined(MAX_NR_MESH_TRANSPORT_KEYS) 1678 #if defined(MAX_NO_MESH_TRANSPORT_KEYS) 1679 #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." 1680 #else 1681 #define MAX_NR_MESH_TRANSPORT_KEYS 0 1682 #endif 1683 #endif 1684 1685 #ifdef MAX_NR_MESH_TRANSPORT_KEYS 1686 #if MAX_NR_MESH_TRANSPORT_KEYS > 0 1687 static mesh_transport_key_t mesh_transport_key_storage[MAX_NR_MESH_TRANSPORT_KEYS]; 1688 static btstack_memory_pool_t mesh_transport_key_pool; 1689 mesh_transport_key_t * btstack_memory_mesh_transport_key_get(void){ 1690 void * buffer = btstack_memory_pool_get(&mesh_transport_key_pool); 1691 if (buffer){ 1692 memset(buffer, 0, sizeof(mesh_transport_key_t)); 1693 } 1694 return (mesh_transport_key_t *) buffer; 1695 } 1696 void btstack_memory_mesh_transport_key_free(mesh_transport_key_t *mesh_transport_key){ 1697 btstack_memory_pool_free(&mesh_transport_key_pool, mesh_transport_key); 1698 } 1699 #else 1700 mesh_transport_key_t * btstack_memory_mesh_transport_key_get(void){ 1701 return NULL; 1702 } 1703 void btstack_memory_mesh_transport_key_free(mesh_transport_key_t *mesh_transport_key){ 1704 UNUSED(mesh_transport_key); 1705 }; 1706 #endif 1707 #elif defined(HAVE_MALLOC) 1708 1709 typedef struct { 1710 btstack_memory_buffer_t tracking; 1711 mesh_transport_key_t data; 1712 } btstack_memory_mesh_transport_key_t; 1713 1714 mesh_transport_key_t * btstack_memory_mesh_transport_key_get(void){ 1715 btstack_memory_mesh_transport_key_t * buffer = (btstack_memory_mesh_transport_key_t *) malloc(sizeof(btstack_memory_mesh_transport_key_t)); 1716 if (buffer){ 1717 memset(buffer, 0, sizeof(btstack_memory_mesh_transport_key_t)); 1718 btstack_memory_tracking_add(&buffer->tracking); 1719 return &buffer->data; 1720 } else { 1721 return NULL; 1722 } 1723 } 1724 void btstack_memory_mesh_transport_key_free(mesh_transport_key_t *mesh_transport_key){ 1725 // reconstruct buffer start 1726 btstack_memory_buffer_t * buffer = &((btstack_memory_buffer_t *) mesh_transport_key)[-1]; 1727 btstack_memory_tracking_remove(buffer); 1728 free(buffer); 1729 } 1730 #endif 1731 1732 1733 // MARK: mesh_virtual_address_t 1734 #if !defined(HAVE_MALLOC) && !defined(MAX_NR_MESH_VIRTUAL_ADDRESSS) 1735 #if defined(MAX_NO_MESH_VIRTUAL_ADDRESSS) 1736 #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." 1737 #else 1738 #define MAX_NR_MESH_VIRTUAL_ADDRESSS 0 1739 #endif 1740 #endif 1741 1742 #ifdef MAX_NR_MESH_VIRTUAL_ADDRESSS 1743 #if MAX_NR_MESH_VIRTUAL_ADDRESSS > 0 1744 static mesh_virtual_address_t mesh_virtual_address_storage[MAX_NR_MESH_VIRTUAL_ADDRESSS]; 1745 static btstack_memory_pool_t mesh_virtual_address_pool; 1746 mesh_virtual_address_t * btstack_memory_mesh_virtual_address_get(void){ 1747 void * buffer = btstack_memory_pool_get(&mesh_virtual_address_pool); 1748 if (buffer){ 1749 memset(buffer, 0, sizeof(mesh_virtual_address_t)); 1750 } 1751 return (mesh_virtual_address_t *) buffer; 1752 } 1753 void btstack_memory_mesh_virtual_address_free(mesh_virtual_address_t *mesh_virtual_address){ 1754 btstack_memory_pool_free(&mesh_virtual_address_pool, mesh_virtual_address); 1755 } 1756 #else 1757 mesh_virtual_address_t * btstack_memory_mesh_virtual_address_get(void){ 1758 return NULL; 1759 } 1760 void btstack_memory_mesh_virtual_address_free(mesh_virtual_address_t *mesh_virtual_address){ 1761 UNUSED(mesh_virtual_address); 1762 }; 1763 #endif 1764 #elif defined(HAVE_MALLOC) 1765 1766 typedef struct { 1767 btstack_memory_buffer_t tracking; 1768 mesh_virtual_address_t data; 1769 } btstack_memory_mesh_virtual_address_t; 1770 1771 mesh_virtual_address_t * btstack_memory_mesh_virtual_address_get(void){ 1772 btstack_memory_mesh_virtual_address_t * buffer = (btstack_memory_mesh_virtual_address_t *) malloc(sizeof(btstack_memory_mesh_virtual_address_t)); 1773 if (buffer){ 1774 memset(buffer, 0, sizeof(btstack_memory_mesh_virtual_address_t)); 1775 btstack_memory_tracking_add(&buffer->tracking); 1776 return &buffer->data; 1777 } else { 1778 return NULL; 1779 } 1780 } 1781 void btstack_memory_mesh_virtual_address_free(mesh_virtual_address_t *mesh_virtual_address){ 1782 // reconstruct buffer start 1783 btstack_memory_buffer_t * buffer = &((btstack_memory_buffer_t *) mesh_virtual_address)[-1]; 1784 btstack_memory_tracking_remove(buffer); 1785 free(buffer); 1786 } 1787 #endif 1788 1789 1790 // MARK: mesh_subnet_t 1791 #if !defined(HAVE_MALLOC) && !defined(MAX_NR_MESH_SUBNETS) 1792 #if defined(MAX_NO_MESH_SUBNETS) 1793 #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." 1794 #else 1795 #define MAX_NR_MESH_SUBNETS 0 1796 #endif 1797 #endif 1798 1799 #ifdef MAX_NR_MESH_SUBNETS 1800 #if MAX_NR_MESH_SUBNETS > 0 1801 static mesh_subnet_t mesh_subnet_storage[MAX_NR_MESH_SUBNETS]; 1802 static btstack_memory_pool_t mesh_subnet_pool; 1803 mesh_subnet_t * btstack_memory_mesh_subnet_get(void){ 1804 void * buffer = btstack_memory_pool_get(&mesh_subnet_pool); 1805 if (buffer){ 1806 memset(buffer, 0, sizeof(mesh_subnet_t)); 1807 } 1808 return (mesh_subnet_t *) buffer; 1809 } 1810 void btstack_memory_mesh_subnet_free(mesh_subnet_t *mesh_subnet){ 1811 btstack_memory_pool_free(&mesh_subnet_pool, mesh_subnet); 1812 } 1813 #else 1814 mesh_subnet_t * btstack_memory_mesh_subnet_get(void){ 1815 return NULL; 1816 } 1817 void btstack_memory_mesh_subnet_free(mesh_subnet_t *mesh_subnet){ 1818 UNUSED(mesh_subnet); 1819 }; 1820 #endif 1821 #elif defined(HAVE_MALLOC) 1822 1823 typedef struct { 1824 btstack_memory_buffer_t tracking; 1825 mesh_subnet_t data; 1826 } btstack_memory_mesh_subnet_t; 1827 1828 mesh_subnet_t * btstack_memory_mesh_subnet_get(void){ 1829 btstack_memory_mesh_subnet_t * buffer = (btstack_memory_mesh_subnet_t *) malloc(sizeof(btstack_memory_mesh_subnet_t)); 1830 if (buffer){ 1831 memset(buffer, 0, sizeof(btstack_memory_mesh_subnet_t)); 1832 btstack_memory_tracking_add(&buffer->tracking); 1833 return &buffer->data; 1834 } else { 1835 return NULL; 1836 } 1837 } 1838 void btstack_memory_mesh_subnet_free(mesh_subnet_t *mesh_subnet){ 1839 // reconstruct buffer start 1840 btstack_memory_buffer_t * buffer = &((btstack_memory_buffer_t *) mesh_subnet)[-1]; 1841 btstack_memory_tracking_remove(buffer); 1842 free(buffer); 1843 } 1844 #endif 1845 1846 1847 #endif 1848 1849 // init 1850 void btstack_memory_init(void){ 1851 #ifdef HAVE_MALLOC 1852 // assert that there is no unexpected padding for combined buffer 1853 btstack_assert(sizeof(test_buffer_t) == sizeof(btstack_memory_buffer_t) + sizeof(void *)); 1854 #endif 1855 1856 #if MAX_NR_HCI_CONNECTIONS > 0 1857 btstack_memory_pool_create(&hci_connection_pool, hci_connection_storage, MAX_NR_HCI_CONNECTIONS, sizeof(hci_connection_t)); 1858 #endif 1859 #if MAX_NR_L2CAP_SERVICES > 0 1860 btstack_memory_pool_create(&l2cap_service_pool, l2cap_service_storage, MAX_NR_L2CAP_SERVICES, sizeof(l2cap_service_t)); 1861 #endif 1862 #if MAX_NR_L2CAP_CHANNELS > 0 1863 btstack_memory_pool_create(&l2cap_channel_pool, l2cap_channel_storage, MAX_NR_L2CAP_CHANNELS, sizeof(l2cap_channel_t)); 1864 #endif 1865 #ifdef ENABLE_CLASSIC 1866 #if MAX_NR_RFCOMM_MULTIPLEXERS > 0 1867 btstack_memory_pool_create(&rfcomm_multiplexer_pool, rfcomm_multiplexer_storage, MAX_NR_RFCOMM_MULTIPLEXERS, sizeof(rfcomm_multiplexer_t)); 1868 #endif 1869 #if MAX_NR_RFCOMM_SERVICES > 0 1870 btstack_memory_pool_create(&rfcomm_service_pool, rfcomm_service_storage, MAX_NR_RFCOMM_SERVICES, sizeof(rfcomm_service_t)); 1871 #endif 1872 #if MAX_NR_RFCOMM_CHANNELS > 0 1873 btstack_memory_pool_create(&rfcomm_channel_pool, rfcomm_channel_storage, MAX_NR_RFCOMM_CHANNELS, sizeof(rfcomm_channel_t)); 1874 #endif 1875 #if MAX_NR_BTSTACK_LINK_KEY_DB_MEMORY_ENTRIES > 0 1876 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)); 1877 #endif 1878 #if MAX_NR_BNEP_SERVICES > 0 1879 btstack_memory_pool_create(&bnep_service_pool, bnep_service_storage, MAX_NR_BNEP_SERVICES, sizeof(bnep_service_t)); 1880 #endif 1881 #if MAX_NR_BNEP_CHANNELS > 0 1882 btstack_memory_pool_create(&bnep_channel_pool, bnep_channel_storage, MAX_NR_BNEP_CHANNELS, sizeof(bnep_channel_t)); 1883 #endif 1884 #if MAX_NR_HFP_CONNECTIONS > 0 1885 btstack_memory_pool_create(&hfp_connection_pool, hfp_connection_storage, MAX_NR_HFP_CONNECTIONS, sizeof(hfp_connection_t)); 1886 #endif 1887 #if MAX_NR_HID_HOST_CONNECTIONS > 0 1888 btstack_memory_pool_create(&hid_host_connection_pool, hid_host_connection_storage, MAX_NR_HID_HOST_CONNECTIONS, sizeof(hid_host_connection_t)); 1889 #endif 1890 #if MAX_NR_SERVICE_RECORD_ITEMS > 0 1891 btstack_memory_pool_create(&service_record_item_pool, service_record_item_storage, MAX_NR_SERVICE_RECORD_ITEMS, sizeof(service_record_item_t)); 1892 #endif 1893 #if MAX_NR_AVDTP_STREAM_ENDPOINTS > 0 1894 btstack_memory_pool_create(&avdtp_stream_endpoint_pool, avdtp_stream_endpoint_storage, MAX_NR_AVDTP_STREAM_ENDPOINTS, sizeof(avdtp_stream_endpoint_t)); 1895 #endif 1896 #if MAX_NR_AVDTP_CONNECTIONS > 0 1897 btstack_memory_pool_create(&avdtp_connection_pool, avdtp_connection_storage, MAX_NR_AVDTP_CONNECTIONS, sizeof(avdtp_connection_t)); 1898 #endif 1899 #if MAX_NR_AVRCP_CONNECTIONS > 0 1900 btstack_memory_pool_create(&avrcp_connection_pool, avrcp_connection_storage, MAX_NR_AVRCP_CONNECTIONS, sizeof(avrcp_connection_t)); 1901 #endif 1902 #if MAX_NR_AVRCP_BROWSING_CONNECTIONS > 0 1903 btstack_memory_pool_create(&avrcp_browsing_connection_pool, avrcp_browsing_connection_storage, MAX_NR_AVRCP_BROWSING_CONNECTIONS, sizeof(avrcp_browsing_connection_t)); 1904 #endif 1905 #endif 1906 #ifdef ENABLE_BLE 1907 #if MAX_NR_BATTERY_SERVICE_CLIENTS > 0 1908 btstack_memory_pool_create(&battery_service_client_pool, battery_service_client_storage, MAX_NR_BATTERY_SERVICE_CLIENTS, sizeof(battery_service_client_t)); 1909 #endif 1910 #if MAX_NR_GATT_CLIENTS > 0 1911 btstack_memory_pool_create(&gatt_client_pool, gatt_client_storage, MAX_NR_GATT_CLIENTS, sizeof(gatt_client_t)); 1912 #endif 1913 #if MAX_NR_HIDS_CLIENTS > 0 1914 btstack_memory_pool_create(&hids_client_pool, hids_client_storage, MAX_NR_HIDS_CLIENTS, sizeof(hids_client_t)); 1915 #endif 1916 #if MAX_NR_SCAN_PARAMETERS_SERVICE_CLIENTS > 0 1917 btstack_memory_pool_create(&scan_parameters_service_client_pool, scan_parameters_service_client_storage, MAX_NR_SCAN_PARAMETERS_SERVICE_CLIENTS, sizeof(scan_parameters_service_client_t)); 1918 #endif 1919 #if MAX_NR_SM_LOOKUP_ENTRIES > 0 1920 btstack_memory_pool_create(&sm_lookup_entry_pool, sm_lookup_entry_storage, MAX_NR_SM_LOOKUP_ENTRIES, sizeof(sm_lookup_entry_t)); 1921 #endif 1922 #if MAX_NR_WHITELIST_ENTRIES > 0 1923 btstack_memory_pool_create(&whitelist_entry_pool, whitelist_entry_storage, MAX_NR_WHITELIST_ENTRIES, sizeof(whitelist_entry_t)); 1924 #endif 1925 #if MAX_NR_PERIODIC_ADVERTISER_LIST_ENTRIES > 0 1926 btstack_memory_pool_create(&periodic_advertiser_list_entry_pool, periodic_advertiser_list_entry_storage, MAX_NR_PERIODIC_ADVERTISER_LIST_ENTRIES, sizeof(periodic_advertiser_list_entry_t)); 1927 #endif 1928 #endif 1929 #ifdef ENABLE_MESH 1930 #if MAX_NR_MESH_NETWORK_PDUS > 0 1931 btstack_memory_pool_create(&mesh_network_pdu_pool, mesh_network_pdu_storage, MAX_NR_MESH_NETWORK_PDUS, sizeof(mesh_network_pdu_t)); 1932 #endif 1933 #if MAX_NR_MESH_SEGMENTED_PDUS > 0 1934 btstack_memory_pool_create(&mesh_segmented_pdu_pool, mesh_segmented_pdu_storage, MAX_NR_MESH_SEGMENTED_PDUS, sizeof(mesh_segmented_pdu_t)); 1935 #endif 1936 #if MAX_NR_MESH_UPPER_TRANSPORT_PDUS > 0 1937 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)); 1938 #endif 1939 #if MAX_NR_MESH_NETWORK_KEYS > 0 1940 btstack_memory_pool_create(&mesh_network_key_pool, mesh_network_key_storage, MAX_NR_MESH_NETWORK_KEYS, sizeof(mesh_network_key_t)); 1941 #endif 1942 #if MAX_NR_MESH_TRANSPORT_KEYS > 0 1943 btstack_memory_pool_create(&mesh_transport_key_pool, mesh_transport_key_storage, MAX_NR_MESH_TRANSPORT_KEYS, sizeof(mesh_transport_key_t)); 1944 #endif 1945 #if MAX_NR_MESH_VIRTUAL_ADDRESSS > 0 1946 btstack_memory_pool_create(&mesh_virtual_address_pool, mesh_virtual_address_storage, MAX_NR_MESH_VIRTUAL_ADDRESSS, sizeof(mesh_virtual_address_t)); 1947 #endif 1948 #if MAX_NR_MESH_SUBNETS > 0 1949 btstack_memory_pool_create(&mesh_subnet_pool, mesh_subnet_storage, MAX_NR_MESH_SUBNETS, sizeof(mesh_subnet_t)); 1950 #endif 1951 #endif 1952 } 1953