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