1 /* 2 * Copyright (C) 2017 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 * 17 * THIS SOFTWARE IS PROVIDED BY BLUEKITCHEN GMBH AND CONTRIBUTORS 18 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 19 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 20 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL BLUEKITCHEN 21 * GMBH OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 22 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 23 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS 24 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 25 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 26 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF 27 * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 28 * SUCH DAMAGE. 29 * 30 */ 31 32 #define BTSTACK_FILE__ "btstack_tlv_flash_bank.c" 33 34 #include "btstack_tlv.h" 35 #include "btstack_tlv_flash_bank.h" 36 #include "btstack_debug.h" 37 #include "btstack_util.h" 38 #include "btstack_debug.h" 39 40 #include <string.h> 41 #include <inttypes.h> 42 43 // Header: 44 // - Magic: 'BTstack' 45 // - Status: 46 // - bits 765432: reserved 47 // - bits 10: epoch 48 49 // Entries 50 // - Tag: 32 bit 51 // - Len: 32 bit 52 // - Delete: 32 delete field - only used with ENABLE_TLV_FLASH_EXPLICIT_DELETE_FIELD 53 // - Value: Len in bytes 54 55 // Alignment 56 // Tag and Delete (if it exists) are aligned to the alignment from hal_flash_bank_t 57 58 // ENABLE_TLV_FLASH_EXPLICIT_DELETE_FIELD 59 // 60 // Most Flash implementations allow to: 61 // - erase sector -> all values are 0xff 62 // - write value (1s -> 0s) 63 // - overwrite value with zero (remaining 1s -> 0s) 64 // 65 // We use the ability to overwrite a value with zeros to mark deleted enttries (by writing zero into the tag field). 66 // Some targets, E.g. Kinetix K64F, do enot allow for that. 67 // 68 // With ENABLE_TLV_FLASH_EXPLICIT_DELETE_FIELD an extra field is reserved to indicate a deleted tag, while keeping main logic 69 // 70 // With ENABLE_TLV_FLASH_WRITE_ONCE, tags are never marked as deleted. Instead, an emtpy tag will be written instead. 71 // Also, lookup and migrate requires to always search until the end of the valid bank 72 73 #if defined (ENABLE_TLV_FLASH_EXPLICIT_DELETE_FIELD) && defined (ENABLE_TLV_FLASH_WRITE_ONCE) 74 #error "Please define either ENABLE_TLV_FLASH_EXPLICIT_DELETE_FIELD or ENABLE_TLV_FLASH_WRITE_ONCE" 75 #endif 76 77 #define BTSTACK_TLV_BANK_HEADER_LEN 8 78 #define BTSTACK_TLV_ENTRY_HEADER_LEN 8 79 80 #ifndef BTSTACK_FLASH_ALIGNMENT_MAX 81 #define BTSTACK_FLASH_ALIGNMENT_MAX 8 82 #endif 83 84 static const char * btstack_tlv_header_magic = "BTstack"; 85 86 // TLV Iterator 87 typedef struct { 88 int bank; 89 uint32_t offset; 90 uint32_t size; 91 uint32_t tag; 92 uint32_t len; 93 } tlv_iterator_t; 94 95 static uint32_t btstack_tlv_flash_bank_align_size(btstack_tlv_flash_bank_t * self, uint32_t size){ 96 uint32_t alignment = self->hal_flash_bank_impl->get_alignment(self->hal_flash_bank_context); 97 return (size + alignment - 1) & ~(alignment - 1); 98 } 99 100 static uint32_t btstack_tlv_flash_bank_aligned_entry_size(btstack_tlv_flash_bank_t * self, uint32_t size){ 101 // entry_header_len is already padded 102 uint32_t aligned_size = self->entry_header_len + btstack_tlv_flash_bank_align_size(self, size); 103 #ifdef ENABLE_TLV_FLASH_EXPLICIT_DELETE_FIELD 104 // delete_tag_len is already padded 105 aligned_size += self->delete_tag_len; 106 #endif 107 return aligned_size; 108 } 109 110 // support unaligned flash read/writes 111 // strategy: increase size to meet alignment, perform unaligned read/write of last chunk with helper buffer 112 113 static void btstack_tlv_flash_bank_read(btstack_tlv_flash_bank_t * self, int bank, uint32_t offset, uint8_t * buffer, uint32_t size){ 114 115 // read main data 116 uint32_t alignment = self->hal_flash_bank_impl->get_alignment(self->hal_flash_bank_context); 117 uint32_t lower_bits = size & (alignment - 1); 118 uint32_t size_aligned = size - lower_bits; 119 if (size_aligned){ 120 self->hal_flash_bank_impl->read(self->hal_flash_bank_context, bank, offset, buffer, size_aligned); 121 buffer += size_aligned; 122 offset += size_aligned; 123 size -= size_aligned; 124 } 125 126 // read last part 127 if (size == 0) return; 128 uint8_t alignment_block[BTSTACK_FLASH_ALIGNMENT_MAX]; 129 self->hal_flash_bank_impl->read(self->hal_flash_bank_context, bank, offset, alignment_block, alignment); 130 uint32_t bytes_to_copy = btstack_min(alignment - lower_bits, size); 131 memcpy(buffer, alignment_block, bytes_to_copy); 132 } 133 134 static void btstack_tlv_flash_bank_write(btstack_tlv_flash_bank_t * self, int bank, uint32_t offset, const uint8_t * buffer, uint32_t size){ 135 136 // write main data 137 uint32_t alignment = self->hal_flash_bank_impl->get_alignment(self->hal_flash_bank_context); 138 uint32_t lower_bits = size & (alignment - 1); 139 uint32_t size_aligned = size - lower_bits; 140 if (size_aligned){ 141 self->hal_flash_bank_impl->write(self->hal_flash_bank_context, bank, offset, buffer, size_aligned); 142 buffer += size_aligned; 143 offset += size_aligned; 144 size -= size_aligned; 145 } 146 147 // write last part 148 if (size == 0) return; 149 uint8_t alignment_block[BTSTACK_FLASH_ALIGNMENT_MAX]; 150 memset(alignment_block, 0xff, alignment); 151 memcpy(alignment_block, buffer, lower_bits); 152 self->hal_flash_bank_impl->write(self->hal_flash_bank_context, bank, offset, alignment_block, alignment); 153 } 154 155 156 // iterator 157 158 static void btstack_tlv_flash_bank_iterator_fetch_tag_len(btstack_tlv_flash_bank_t * self, tlv_iterator_t * it){ 159 // abort if header doesn't fit into remaining space 160 if (it->offset + self->entry_header_len + self->delete_tag_len >= self->hal_flash_bank_impl->get_size(self->hal_flash_bank_context)){ 161 it->tag = 0xffffffff; 162 return; 163 } 164 165 uint8_t entry[BTSTACK_TLV_ENTRY_HEADER_LEN]; 166 btstack_tlv_flash_bank_read(self, it->bank, it->offset, entry, BTSTACK_TLV_ENTRY_HEADER_LEN); 167 it->tag = big_endian_read_32(entry, 0); 168 it->len = big_endian_read_32(entry, 4); 169 170 #ifdef ENABLE_TLV_FLASH_EXPLICIT_DELETE_FIELD 171 // clear tag, if delete field is set 172 uint32_t delete_tag; 173 btstack_tlv_flash_bank_read(self, it->bank, it->offset + self->entry_header_len, (uint8_t *) &delete_tag, 4); 174 if (delete_tag == 0){ 175 it->tag = 0; 176 } 177 #endif 178 } 179 180 static void btstack_tlv_flash_bank_iterator_init(btstack_tlv_flash_bank_t * self, tlv_iterator_t * it, int bank){ 181 memset(it, 0, sizeof(tlv_iterator_t)); 182 it->bank = bank; 183 it->offset = BTSTACK_TLV_BANK_HEADER_LEN; 184 it->size = self->hal_flash_bank_impl->get_size(self->hal_flash_bank_context); 185 btstack_tlv_flash_bank_iterator_fetch_tag_len(self, it); 186 } 187 188 static bool btstack_tlv_flash_bank_iterator_has_next(btstack_tlv_flash_bank_t * self, tlv_iterator_t * it){ 189 UNUSED(self); 190 return it->tag != 0xffffffff; 191 } 192 193 static void tlv_iterator_fetch_next(btstack_tlv_flash_bank_t * self, tlv_iterator_t * it){ 194 it->offset += btstack_tlv_flash_bank_aligned_entry_size(self, it->len); 195 196 #ifdef ENABLE_TLV_FLASH_EXPLICIT_DELETE_FIELD 197 // skip delete field 198 it->offset += self->delete_tag_len; 199 #endif 200 201 if (it->offset >= it->size) { 202 it->tag = 0xffffffff; 203 it->len = 0; 204 return; 205 } 206 btstack_tlv_flash_bank_iterator_fetch_tag_len(self, it); 207 } 208 209 // 210 211 // check both banks for headers and pick the one with the higher epoch % 4 212 // @returns bank or -1 if something is invalid 213 static int btstack_tlv_flash_bank_get_latest_bank(btstack_tlv_flash_bank_t * self){ 214 uint8_t header0[BTSTACK_TLV_BANK_HEADER_LEN]; 215 uint8_t header1[BTSTACK_TLV_BANK_HEADER_LEN]; 216 btstack_tlv_flash_bank_read(self, 0, 0, &header0[0], BTSTACK_TLV_BANK_HEADER_LEN); 217 btstack_tlv_flash_bank_read(self, 1, 0, &header1[0], BTSTACK_TLV_BANK_HEADER_LEN); 218 int valid0 = memcmp(header0, btstack_tlv_header_magic, BTSTACK_TLV_BANK_HEADER_LEN-1) == 0; 219 int valid1 = memcmp(header1, btstack_tlv_header_magic, BTSTACK_TLV_BANK_HEADER_LEN-1) == 0; 220 if (!valid0 && !valid1) return -1; 221 if ( valid0 && !valid1) return 0; 222 if (!valid0 && valid1) return 1; 223 int epoch0 = header0[BTSTACK_TLV_BANK_HEADER_LEN-1] & 0x03; 224 int epoch1 = header1[BTSTACK_TLV_BANK_HEADER_LEN-1] & 0x03; 225 if (epoch0 == ((epoch1 + 1) & 0x03)) return 0; 226 if (epoch1 == ((epoch0 + 1) & 0x03)) return 1; 227 return -1; // invalid, must not happen 228 } 229 230 static void btstack_tlv_flash_bank_write_header(btstack_tlv_flash_bank_t * self, int bank, int epoch){ 231 uint8_t header[BTSTACK_TLV_BANK_HEADER_LEN]; 232 memcpy(&header[0], btstack_tlv_header_magic, BTSTACK_TLV_BANK_HEADER_LEN-1); 233 header[BTSTACK_TLV_BANK_HEADER_LEN-1] = epoch; 234 btstack_tlv_flash_bank_write(self, bank, 0, header, BTSTACK_TLV_BANK_HEADER_LEN); 235 } 236 237 /** 238 * @brief Check if erased from offset 239 */ 240 static int btstack_tlv_flash_bank_test_erased(btstack_tlv_flash_bank_t * self, int bank, uint32_t offset){ 241 log_info("test erased: bank %u, offset %u", bank, (unsigned int) offset); 242 uint32_t size = self->hal_flash_bank_impl->get_size(self->hal_flash_bank_context); 243 uint8_t buffer[16]; 244 uint8_t empty16[16]; 245 memset(empty16, 0xff, sizeof(empty16)); 246 while (offset < size){ 247 uint32_t copy_size = (offset + sizeof(empty16) < size) ? sizeof(empty16) : (size - offset); 248 btstack_tlv_flash_bank_read(self, bank, offset, buffer, copy_size); 249 if (memcmp(buffer, empty16, copy_size) != 0) { 250 log_info("not erased %x - %x", (unsigned int) offset, (unsigned int) (offset + copy_size)); 251 return 0; 252 } 253 offset += copy_size; 254 } 255 return 1; 256 } 257 258 /** 259 * @brief erase bank (only if not already erased) 260 */ 261 static void btstack_tlv_flash_bank_erase_bank(btstack_tlv_flash_bank_t * self, int bank){ 262 if (btstack_tlv_flash_bank_test_erased(self, bank, 0)){ 263 log_info("bank %u already erased", bank); 264 } else { 265 log_info("bank %u not empty, erase bank", bank); 266 self->hal_flash_bank_impl->erase(self->hal_flash_bank_context, bank); 267 } 268 } 269 270 static void btstack_tlv_flash_bank_migrate(btstack_tlv_flash_bank_t * self){ 271 272 int next_bank = 1 - self->current_bank; 273 log_info("migrate bank %u -> bank %u", self->current_bank, next_bank); 274 // erase bank (if needed) 275 btstack_tlv_flash_bank_erase_bank(self, next_bank); 276 int next_write_pos = BTSTACK_TLV_BANK_HEADER_LEN; 277 278 tlv_iterator_t it; 279 btstack_tlv_flash_bank_iterator_init(self, &it, self->current_bank); 280 while (btstack_tlv_flash_bank_iterator_has_next(self, &it)){ 281 // skip deleted entries 282 if (it.tag) { 283 uint32_t tag_len = it.len; 284 uint32_t tag_index = it.offset; 285 286 bool tag_valid = true; 287 288 #ifdef ENABLE_TLV_FLASH_WRITE_ONCE 289 // search until end for newer entry of same tag 290 tlv_iterator_t it2; 291 memcpy(&it2, &it, sizeof(tlv_iterator_t)); 292 while (btstack_tlv_flash_bank_iterator_has_next(self, &it2)){ 293 if ((it2.offset != it.offset) && (it2.tag == it.tag)){ 294 tag_valid = false; 295 break; 296 } 297 tlv_iterator_fetch_next(self, &it2); 298 } 299 if (tag_valid == false){ 300 log_info("skip pos %u, tag '%x' as newer entry found at %u", (unsigned int) tag_index, (unsigned int) it.tag, 301 (unsigned int) it2.offset); 302 } 303 #endif 304 305 if (tag_valid) { 306 307 log_info("migrate pos %u, tag '%x' len %u -> new pos %u", 308 (unsigned int) tag_index, (unsigned int) it.tag, (unsigned int) tag_len, next_write_pos); 309 310 // copy header 311 uint8_t header_buffer[BTSTACK_TLV_ENTRY_HEADER_LEN]; 312 btstack_tlv_flash_bank_read(self, self->current_bank, tag_index, header_buffer, BTSTACK_TLV_ENTRY_HEADER_LEN); 313 btstack_tlv_flash_bank_write(self, next_bank, next_write_pos, header_buffer, BTSTACK_TLV_ENTRY_HEADER_LEN); 314 tag_index += self->entry_header_len; 315 uint32_t write_offset = next_write_pos + self->entry_header_len; 316 #ifdef ENABLE_TLV_FLASH_EXPLICIT_DELETE_FIELD 317 // skip delete field 318 tag_index += self->delete_tag_len; 319 #endif 320 // copy value 321 int bytes_to_copy = tag_len; 322 uint8_t copy_buffer[32]; 323 while (bytes_to_copy) { 324 int bytes_this_iteration = btstack_min(bytes_to_copy, sizeof(copy_buffer)); 325 btstack_tlv_flash_bank_read(self, self->current_bank, tag_index, copy_buffer, bytes_this_iteration); 326 btstack_tlv_flash_bank_write(self, next_bank, write_offset, copy_buffer, bytes_this_iteration); 327 tag_index += bytes_this_iteration; 328 write_offset += bytes_this_iteration; 329 bytes_to_copy -= bytes_this_iteration; 330 } 331 next_write_pos += btstack_tlv_flash_bank_aligned_entry_size(self, tag_len); 332 } 333 } 334 tlv_iterator_fetch_next(self, &it); 335 } 336 337 // prepare new one 338 uint8_t epoch_buffer; 339 btstack_tlv_flash_bank_read(self, self->current_bank, BTSTACK_TLV_BANK_HEADER_LEN-1, &epoch_buffer, 1); 340 btstack_tlv_flash_bank_write_header(self, next_bank, (epoch_buffer + 1) & 3); 341 self->current_bank = next_bank; 342 self->write_offset = next_write_pos; 343 } 344 345 #ifndef ENABLE_TLV_FLASH_WRITE_ONCE 346 static void btstack_tlv_flash_bank_delete_tag_until_offset(btstack_tlv_flash_bank_t * self, uint32_t tag, uint32_t offset){ 347 tlv_iterator_t it; 348 btstack_tlv_flash_bank_iterator_init(self, &it, self->current_bank); 349 while (btstack_tlv_flash_bank_iterator_has_next(self, &it) && it.offset < offset){ 350 if (it.tag == tag){ 351 log_info("Erase tag '%x' at position %u", (unsigned int) tag, (unsigned int) it.offset); 352 353 // mark entry as invalid 354 uint32_t zero_value = 0; 355 #ifdef ENABLE_TLV_FLASH_EXPLICIT_DELETE_FIELD 356 // write delete field after entry header 357 btstack_tlv_flash_bank_write(self, self->current_bank, it.offset+self->entry_header_len, (uint8_t*) &zero_value, sizeof(zero_value)); 358 #else 359 uint32_t alignment = self->hal_flash_bank_impl->get_alignment(self->hal_flash_bank_context); 360 if (alignment <= 4){ 361 // if alignment < 4, overwrite only tag with zero value 362 btstack_tlv_flash_bank_write(self, self->current_bank, it.offset, (uint8_t*) &zero_value, sizeof(zero_value)); 363 } else { 364 // otherwise, overwrite complete entry. This results in a sequence of { tag: 0, len: 0 } entries 365 uint8_t zero_buffer[32]; 366 memset(zero_buffer, 0, sizeof(zero_buffer)); 367 uint32_t entry_offset = 0; 368 uint32_t entry_size = btstack_tlv_flash_bank_aligned_entry_size(self, it.len); 369 while (entry_offset < entry_size) { 370 uint32_t bytes_to_write = btstack_min(entry_size - entry_offset, sizeof(zero_buffer)); 371 btstack_tlv_flash_bank_write(self, self->current_bank, it.offset + entry_offset, zero_buffer, bytes_to_write); 372 entry_offset += bytes_to_write; 373 } 374 } 375 #endif 376 } 377 tlv_iterator_fetch_next(self, &it); 378 } 379 } 380 #endif 381 382 /** 383 * Get Value for Tag 384 * @param tag 385 * @param buffer 386 * @param buffer_size 387 * @returns size of value 388 */ 389 static int btstack_tlv_flash_bank_get_tag(void * context, uint32_t tag, uint8_t * buffer, uint32_t buffer_size){ 390 391 btstack_tlv_flash_bank_t * self = (btstack_tlv_flash_bank_t *) context; 392 393 uint32_t tag_index = 0; 394 uint32_t tag_len = 0; 395 tlv_iterator_t it; 396 btstack_tlv_flash_bank_iterator_init(self, &it, self->current_bank); 397 while (btstack_tlv_flash_bank_iterator_has_next(self, &it)){ 398 if (it.tag == tag){ 399 log_info("Found tag '%x' at position %u", (unsigned int) tag, (unsigned int) it.offset); 400 tag_index = it.offset; 401 tag_len = it.len; 402 #ifndef ENABLE_TLV_FLASH_WRITE_ONCE 403 break; 404 #endif 405 } 406 tlv_iterator_fetch_next(self, &it); 407 } 408 if (tag_index == 0) return 0; 409 if (!buffer) return tag_len; 410 int copy_size = btstack_min(buffer_size, tag_len); 411 uint32_t value_offset = tag_index + self->entry_header_len; 412 #ifdef ENABLE_TLV_FLASH_EXPLICIT_DELETE_FIELD 413 // skip delete field 414 value_offset += self->delete_tag_len; 415 #endif 416 btstack_tlv_flash_bank_read(self, self->current_bank, value_offset, buffer, copy_size); 417 return copy_size; 418 } 419 420 /** 421 * Store Tag 422 * @param tag 423 * @param data 424 * @param data_size 425 */ 426 static int btstack_tlv_flash_bank_store_tag(void * context, uint32_t tag, const uint8_t * data, uint32_t data_size){ 427 428 btstack_tlv_flash_bank_t * self = (btstack_tlv_flash_bank_t *) context; 429 430 // trigger migration if not enough space 431 uint32_t required_space = self->entry_header_len + self->delete_tag_len + data_size; 432 if (self->write_offset + required_space > self->hal_flash_bank_impl->get_size(self->hal_flash_bank_context)){ 433 btstack_tlv_flash_bank_migrate(self); 434 } 435 436 if (self->write_offset + required_space > self->hal_flash_bank_impl->get_size(self->hal_flash_bank_context)){ 437 log_error("couldn't write entry, not enough space left"); 438 return 2; 439 } 440 441 // prepare entry 442 uint8_t entry[BTSTACK_TLV_ENTRY_HEADER_LEN]; 443 big_endian_store_32(entry, 0, tag); 444 big_endian_store_32(entry, 4, data_size); 445 446 log_info("write '%" PRIx32 "', len %" PRIu32 " at %" PRIx32, tag, data_size, self->write_offset); 447 448 uint32_t value_offset = self->write_offset + self->entry_header_len; 449 #ifdef ENABLE_TLV_FLASH_EXPLICIT_DELETE_FIELD 450 // skip delete field 451 value_offset += self->delete_tag_len; 452 #endif 453 454 // write value first 455 btstack_tlv_flash_bank_write(self, self->current_bank, value_offset, data, data_size); 456 457 // then entry 458 btstack_tlv_flash_bank_write(self, self->current_bank, self->write_offset, entry, sizeof(entry)); 459 460 #ifndef ENABLE_TLV_FLASH_WRITE_ONCE 461 // overwrite old entries (if exists) 462 btstack_tlv_flash_bank_delete_tag_until_offset(self, tag, self->write_offset); 463 #endif 464 465 // done 466 self->write_offset += sizeof(entry) + btstack_tlv_flash_bank_align_size(self, data_size); 467 468 #ifdef ENABLE_TLV_FLASH_EXPLICIT_DELETE_FIELD 469 // skip delete field 470 self->write_offset += self->delete_tag_len; 471 #endif 472 473 return 0; 474 } 475 476 /** 477 * Delete Tag 478 * @param tag 479 */ 480 static void btstack_tlv_flash_bank_delete_tag(void * context, uint32_t tag){ 481 #ifdef ENABLE_TLV_FLASH_WRITE_ONCE 482 btstack_tlv_flash_bank_store_tag(context, tag, NULL, 0); 483 #else 484 btstack_tlv_flash_bank_t * self = (btstack_tlv_flash_bank_t *) context; 485 btstack_tlv_flash_bank_delete_tag_until_offset(self, tag, self->write_offset); 486 #endif 487 } 488 489 static const btstack_tlv_t btstack_tlv_flash_bank = { 490 /* int (*get_tag)(..); */ &btstack_tlv_flash_bank_get_tag, 491 /* int (*store_tag)(..); */ &btstack_tlv_flash_bank_store_tag, 492 /* void (*delete_tag)(v..); */ &btstack_tlv_flash_bank_delete_tag, 493 }; 494 495 /** 496 * Init Tag Length Value Store 497 */ 498 const btstack_tlv_t * btstack_tlv_flash_bank_init_instance(btstack_tlv_flash_bank_t * self, const hal_flash_bank_t * hal_flash_bank_impl, void * hal_flash_bank_context){ 499 500 self->hal_flash_bank_impl = hal_flash_bank_impl; 501 self->hal_flash_bank_context = hal_flash_bank_context; 502 self->delete_tag_len = 0; 503 504 #ifdef ENABLE_TLV_FLASH_EXPLICIT_DELETE_FIELD 505 if (hal_flash_bank_impl->get_alignment(hal_flash_bank_context) > 8){ 506 log_error("Flash alignment > 8 with ENABLE_TLV_FLASH_EXPLICIT_DELETE_FIELD not supported"); 507 return NULL; 508 } 509 // set delete tag len 510 uint32_t alignment = self->hal_flash_bank_impl->get_alignment(self->hal_flash_bank_context); 511 self->delete_tag_len = (uint8_t) btstack_max(4, alignment); 512 log_info("delete tag len %u", self->delete_tag_len); 513 #endif 514 515 // set aligned entry header len 516 self->entry_header_len = btstack_tlv_flash_bank_align_size(self, BTSTACK_TLV_ENTRY_HEADER_LEN); 517 518 // try to find current bank 519 self->current_bank = btstack_tlv_flash_bank_get_latest_bank(self); 520 log_info("found bank %d", self->current_bank); 521 if (self->current_bank >= 0){ 522 523 // find last entry and write offset 524 tlv_iterator_t it; 525 #ifndef ENABLE_TLV_FLASH_WRITE_ONCE 526 uint32_t last_tag = 0; 527 uint32_t last_offset = 0; 528 #endif 529 btstack_tlv_flash_bank_iterator_init(self, &it, self->current_bank); 530 while (btstack_tlv_flash_bank_iterator_has_next(self, &it)){ 531 #ifndef ENABLE_TLV_FLASH_WRITE_ONCE 532 last_tag = it.tag; 533 last_offset = it.offset; 534 #endif 535 tlv_iterator_fetch_next(self, &it); 536 } 537 self->write_offset = it.offset; 538 539 if (self->write_offset <= self->hal_flash_bank_impl->get_size(self->hal_flash_bank_context)){ 540 541 #ifndef ENABLE_TLV_FLASH_WRITE_ONCE 542 // delete older instances of last_tag 543 // this handles the unlikely case where MCU did reset after new value + header was written but before delete did complete 544 if (last_tag){ 545 btstack_tlv_flash_bank_delete_tag_until_offset(self, last_tag, last_offset); 546 } 547 #endif 548 549 // verify that rest of bank is empty 550 // this handles the unlikely case where MCU did reset after new value was written, but not the tag 551 if (!btstack_tlv_flash_bank_test_erased(self, self->current_bank, self->write_offset)){ 552 log_info("Flash not empty after last found tag -> migrate"); 553 btstack_tlv_flash_bank_migrate(self); 554 } else { 555 log_info("Flash clean after last found tag"); 556 } 557 } else { 558 // failure! 559 self->current_bank = -1; 560 } 561 } 562 563 if (self->current_bank < 0) { 564 btstack_tlv_flash_bank_erase_bank(self, 0); 565 self->current_bank = 0; 566 btstack_tlv_flash_bank_write_header(self, self->current_bank, 0); // epoch = 0; 567 self->write_offset = BTSTACK_TLV_BANK_HEADER_LEN; 568 } 569 570 log_info("write offset %" PRIx32, self->write_offset); 571 return &btstack_tlv_flash_bank; 572 } 573 574