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