1 /* 2 * Copyright (C) 2009-2012 by Matthias Ringwald 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 MATTHIAS RINGWALD 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 [email protected] 34 * 35 */ 36 37 /* 38 * btstsack_memory.h 39 * 40 * @brief BTstack memory management via configurable memory pools 41 * 42 * @note code semi-atuomatically generated by btstack_memory_generator.py 43 * 44 */ 45 46 #include "btstack_memory.h" 47 #include <btstack/memory_pool.h> 48 49 #include <stdlib.h> 50 51 #include "config.h" 52 #include "hci.h" 53 #include "l2cap.h" 54 #include "rfcomm.h" 55 56 // MARK: hci_connection_t 57 #ifdef MAX_NO_HCI_CONNECTIONS 58 #if MAX_NO_HCI_CONNECTIONS > 0 59 static hci_connection_t hci_connection_storage[MAX_NO_HCI_CONNECTIONS]; 60 static memory_pool_t hci_connection_pool; 61 void * btstack_memory_hci_connection_get(void){ 62 return memory_pool_get(&hci_connection_pool); 63 } 64 void btstack_memory_hci_connection_free(void *hci_connection){ 65 memory_pool_free(&hci_connection_pool, hci_connection); 66 } 67 #else 68 void * btstack_memory_hci_connection_get(void){ 69 return NULL; 70 } 71 void btstack_memory_hci_connection_free(void *hci_connection){ 72 }; 73 #endif 74 #elif defined(HAVE_MALLOC) 75 void * btstack_memory_hci_connection_get(void){ 76 return malloc(sizeof(hci_connection_t)); 77 } 78 void btstack_memory_hci_connection_free(void *hci_connection){ 79 free(hci_connection); 80 } 81 #endif 82 83 84 // MARK: l2cap_service_t 85 #ifdef MAX_NO_L2CAP_SERVICES 86 #if MAX_NO_L2CAP_SERVICES > 0 87 static l2cap_service_t l2cap_service_storage[MAX_NO_L2CAP_SERVICES]; 88 static memory_pool_t l2cap_service_pool; 89 void * btstack_memory_l2cap_service_get(void){ 90 return memory_pool_get(&l2cap_service_pool); 91 } 92 void btstack_memory_l2cap_service_free(void *l2cap_service){ 93 memory_pool_free(&l2cap_service_pool, l2cap_service); 94 } 95 #else 96 void * btstack_memory_l2cap_service_get(void){ 97 return NULL; 98 } 99 void btstack_memory_l2cap_service_free(void *l2cap_service){ 100 }; 101 #endif 102 #elif defined(HAVE_MALLOC) 103 void * btstack_memory_l2cap_service_get(void){ 104 return malloc(sizeof(l2cap_service_t)); 105 } 106 void btstack_memory_l2cap_service_free(void *l2cap_service){ 107 free(l2cap_service); 108 } 109 #endif 110 111 112 // MARK: l2cap_channel_t 113 #ifdef MAX_NO_L2CAP_CHANNELS 114 #if MAX_NO_L2CAP_CHANNELS > 0 115 static l2cap_channel_t l2cap_channel_storage[MAX_NO_L2CAP_CHANNELS]; 116 static memory_pool_t l2cap_channel_pool; 117 void * btstack_memory_l2cap_channel_get(void){ 118 return memory_pool_get(&l2cap_channel_pool); 119 } 120 void btstack_memory_l2cap_channel_free(void *l2cap_channel){ 121 memory_pool_free(&l2cap_channel_pool, l2cap_channel); 122 } 123 #else 124 void * btstack_memory_l2cap_channel_get(void){ 125 return NULL; 126 } 127 void btstack_memory_l2cap_channel_free(void *l2cap_channel){ 128 }; 129 #endif 130 #elif defined(HAVE_MALLOC) 131 void * btstack_memory_l2cap_channel_get(void){ 132 return malloc(sizeof(l2cap_channel_t)); 133 } 134 void btstack_memory_l2cap_channel_free(void *l2cap_channel){ 135 free(l2cap_channel); 136 } 137 #endif 138 139 140 // MARK: rfcomm_multiplexer_t 141 #ifdef MAX_NO_RFCOMM_MULTIPLEXERS 142 #if MAX_NO_RFCOMM_MULTIPLEXERS > 0 143 static rfcomm_multiplexer_t rfcomm_multiplexer_storage[MAX_NO_RFCOMM_MULTIPLEXERS]; 144 static memory_pool_t rfcomm_multiplexer_pool; 145 void * btstack_memory_rfcomm_multiplexer_get(void){ 146 return memory_pool_get(&rfcomm_multiplexer_pool); 147 } 148 void btstack_memory_rfcomm_multiplexer_free(void *rfcomm_multiplexer){ 149 memory_pool_free(&rfcomm_multiplexer_pool, rfcomm_multiplexer); 150 } 151 #else 152 void * btstack_memory_rfcomm_multiplexer_get(void){ 153 return NULL; 154 } 155 void btstack_memory_rfcomm_multiplexer_free(void *rfcomm_multiplexer){ 156 }; 157 #endif 158 #elif defined(HAVE_MALLOC) 159 void * btstack_memory_rfcomm_multiplexer_get(void){ 160 return malloc(sizeof(rfcomm_multiplexer_t)); 161 } 162 void btstack_memory_rfcomm_multiplexer_free(void *rfcomm_multiplexer){ 163 free(rfcomm_multiplexer); 164 } 165 #endif 166 167 168 // MARK: rfcomm_service_t 169 #ifdef MAX_NO_RFCOMM_SERVICES 170 #if MAX_NO_RFCOMM_SERVICES > 0 171 static rfcomm_service_t rfcomm_service_storage[MAX_NO_RFCOMM_SERVICES]; 172 static memory_pool_t rfcomm_service_pool; 173 void * btstack_memory_rfcomm_service_get(void){ 174 return memory_pool_get(&rfcomm_service_pool); 175 } 176 void btstack_memory_rfcomm_service_free(void *rfcomm_service){ 177 memory_pool_free(&rfcomm_service_pool, rfcomm_service); 178 } 179 #else 180 void * btstack_memory_rfcomm_service_get(void){ 181 return NULL; 182 } 183 void btstack_memory_rfcomm_service_free(void *rfcomm_service){ 184 }; 185 #endif 186 #elif defined(HAVE_MALLOC) 187 void * btstack_memory_rfcomm_service_get(void){ 188 return malloc(sizeof(rfcomm_service_t)); 189 } 190 void btstack_memory_rfcomm_service_free(void *rfcomm_service){ 191 free(rfcomm_service); 192 } 193 #endif 194 195 196 // MARK: rfcomm_channel_t 197 #ifdef MAX_NO_RFCOMM_CHANNELS 198 #if MAX_NO_RFCOMM_CHANNELS > 0 199 static rfcomm_channel_t rfcomm_channel_storage[MAX_NO_RFCOMM_CHANNELS]; 200 static memory_pool_t rfcomm_channel_pool; 201 void * btstack_memory_rfcomm_channel_get(void){ 202 return memory_pool_get(&rfcomm_channel_pool); 203 } 204 void btstack_memory_rfcomm_channel_free(void *rfcomm_channel){ 205 memory_pool_free(&rfcomm_channel_pool, rfcomm_channel); 206 } 207 #else 208 void * btstack_memory_rfcomm_channel_get(void){ 209 return NULL; 210 } 211 void btstack_memory_rfcomm_channel_free(void *rfcomm_channel){ 212 }; 213 #endif 214 #elif defined(HAVE_MALLOC) 215 void * btstack_memory_rfcomm_channel_get(void){ 216 return malloc(sizeof(rfcomm_channel_t)); 217 } 218 void btstack_memory_rfcomm_channel_free(void *rfcomm_channel){ 219 free(rfcomm_channel); 220 } 221 #endif 222 223 224 // MARK: db_mem_device_name_t 225 #ifdef MAX_NO_DB_MEM_DEVICE_NAMES 226 #if MAX_NO_DB_MEM_DEVICE_NAMES > 0 227 static db_mem_device_name_t db_mem_device_name_storage[MAX_NO_DB_MEM_DEVICE_NAMES]; 228 static memory_pool_t db_mem_device_name_pool; 229 void * btstack_memory_db_mem_device_name_get(void){ 230 return memory_pool_get(&db_mem_device_name_pool); 231 } 232 void btstack_memory_db_mem_device_name_free(void *db_mem_device_name){ 233 memory_pool_free(&db_mem_device_name_pool, db_mem_device_name); 234 } 235 #else 236 void * btstack_memory_db_mem_device_name_get(void){ 237 return NULL; 238 } 239 void btstack_memory_db_mem_device_name_free(void *db_mem_device_name){ 240 }; 241 #endif 242 #elif defined(HAVE_MALLOC) 243 void * btstack_memory_db_mem_device_name_get(void){ 244 return malloc(sizeof(db_mem_device_name_t)); 245 } 246 void btstack_memory_db_mem_device_name_free(void *db_mem_device_name){ 247 free(db_mem_device_name); 248 } 249 #endif 250 251 252 // MARK: db_mem_device_link_key_t 253 #ifdef MAX_NO_DB_MEM_DEVICE_LINK_KEYS 254 #if MAX_NO_DB_MEM_DEVICE_LINK_KEYS > 0 255 static db_mem_device_link_key_t db_mem_device_link_key_storage[MAX_NO_DB_MEM_DEVICE_LINK_KEYS]; 256 static memory_pool_t db_mem_device_link_key_pool; 257 void * btstack_memory_db_mem_device_link_key_get(void){ 258 return memory_pool_get(&db_mem_device_link_key_pool); 259 } 260 void btstack_memory_db_mem_device_link_key_free(void *db_mem_device_link_key){ 261 memory_pool_free(&db_mem_device_link_key_pool, db_mem_device_link_key); 262 } 263 #else 264 void * btstack_memory_db_mem_device_link_key_get(void){ 265 return NULL; 266 } 267 void btstack_memory_db_mem_device_link_key_free(void *db_mem_device_link_key){ 268 }; 269 #endif 270 #elif defined(HAVE_MALLOC) 271 void * btstack_memory_db_mem_device_link_key_get(void){ 272 return malloc(sizeof(db_mem_device_link_key_t)); 273 } 274 void btstack_memory_db_mem_device_link_key_free(void *db_mem_device_link_key){ 275 free(db_mem_device_link_key); 276 } 277 #endif 278 279 280 // MARK: db_mem_service_t 281 #ifdef MAX_NO_DB_MEM_SERVICES 282 #if MAX_NO_DB_MEM_SERVICES > 0 283 static db_mem_service_t db_mem_service_storage[MAX_NO_DB_MEM_SERVICES]; 284 static memory_pool_t db_mem_service_pool; 285 void * btstack_memory_db_mem_service_get(void){ 286 return memory_pool_get(&db_mem_service_pool); 287 } 288 void btstack_memory_db_mem_service_free(void *db_mem_service){ 289 memory_pool_free(&db_mem_service_pool, db_mem_service); 290 } 291 #else 292 void * btstack_memory_db_mem_service_get(void){ 293 return NULL; 294 } 295 void btstack_memory_db_mem_service_free(void *db_mem_service){ 296 }; 297 #endif 298 #elif defined(HAVE_MALLOC) 299 void * btstack_memory_db_mem_service_get(void){ 300 return malloc(sizeof(db_mem_service_t)); 301 } 302 void btstack_memory_db_mem_service_free(void *db_mem_service){ 303 free(db_mem_service); 304 } 305 #endif 306 307 // init 308 void btstack_memory_init(void){ 309 #if MAX_NO_HCI_CONNECTIONS > 0 310 memory_pool_create(&hci_connection_pool, hci_connection_storage, MAX_NO_HCI_CONNECTIONS, sizeof(hci_connection_t)); 311 #endif 312 #if MAX_NO_L2CAP_SERVICES > 0 313 memory_pool_create(&l2cap_service_pool, l2cap_service_storage, MAX_NO_L2CAP_SERVICES, sizeof(l2cap_service_t)); 314 #endif 315 #if MAX_NO_L2CAP_CHANNELS > 0 316 memory_pool_create(&l2cap_channel_pool, l2cap_channel_storage, MAX_NO_L2CAP_CHANNELS, sizeof(l2cap_channel_t)); 317 #endif 318 #if MAX_NO_RFCOMM_MULTIPLEXERS > 0 319 memory_pool_create(&rfcomm_multiplexer_pool, rfcomm_multiplexer_storage, MAX_NO_RFCOMM_MULTIPLEXERS, sizeof(rfcomm_multiplexer_t)); 320 #endif 321 #if MAX_NO_RFCOMM_SERVICES > 0 322 memory_pool_create(&rfcomm_service_pool, rfcomm_service_storage, MAX_NO_RFCOMM_SERVICES, sizeof(rfcomm_service_t)); 323 #endif 324 #if MAX_NO_RFCOMM_CHANNELS > 0 325 memory_pool_create(&rfcomm_channel_pool, rfcomm_channel_storage, MAX_NO_RFCOMM_CHANNELS, sizeof(rfcomm_channel_t)); 326 #endif 327 #if MAX_NO_DB_MEM_DEVICE_NAMES > 0 328 memory_pool_create(&db_mem_device_name_pool, db_mem_device_name_storage, MAX_NO_DB_MEM_DEVICE_NAMES, sizeof(db_mem_device_name_t)); 329 #endif 330 #if MAX_NO_DB_MEM_DEVICE_LINK_KEYS > 0 331 memory_pool_create(&db_mem_device_link_key_pool, db_mem_device_link_key_storage, MAX_NO_DB_MEM_DEVICE_LINK_KEYS, sizeof(db_mem_device_link_key_t)); 332 #endif 333 #if MAX_NO_DB_MEM_SERVICES > 0 334 memory_pool_create(&db_mem_service_pool, db_mem_service_storage, MAX_NO_DB_MEM_SERVICES, sizeof(db_mem_service_t)); 335 #endif 336 } 337