Vekatech
SDHI_driver patch (mbedOS 5.11.5)
Embed:
(wiki syntax)
Show/hide line numbers
kv_config.cpp
00001 /* 00002 * Copyright (c) 2018 ARM Limited. All rights reserved. 00003 * SPDX-License-Identifier: Apache-2.0 00004 * Licensed under the Apache License, Version 2.0 (the License); you may 00005 * not use this file except in compliance with the License. 00006 * You may obtain a copy of the License at 00007 * 00008 * http://www.apache.org/licenses/LICENSE-2.0 00009 * 00010 * Unless required by applicable law or agreed to in writing, software 00011 * distributed under the License is distributed on an AS IS BASIS, WITHOUT 00012 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 00013 * See the License for the specific language governing permissions and 00014 * limitations under the License. 00015 */ 00016 00017 #include "kv_config.h" 00018 #include "KVStore.h" 00019 #include "KVMap.h" 00020 #include "BlockDevice.h" 00021 #include "FileSystem.h" 00022 #include "FileSystemStore.h" 00023 #include "SlicingBlockDevice.h" 00024 #include "FATFileSystem.h" 00025 #include "LittleFileSystem.h" 00026 #include "TDBStore.h" 00027 #include "mbed_error.h" 00028 #include "FlashIAP.h" 00029 #include "FlashSimBlockDevice.h" 00030 #include "mbed_trace.h" 00031 #include "SecureStore.h" 00032 #define TRACE_GROUP "KVCFG" 00033 00034 #if COMPONENT_FLASHIAP 00035 #include "FlashIAPBlockDevice.h" 00036 #endif 00037 00038 #if COMPONENT_QSPIF 00039 #include "QSPIFBlockDevice.h" 00040 #endif 00041 00042 #if COMPONENT_SPIF 00043 #include "SPIFBlockDevice.h" 00044 #endif 00045 00046 #if COMPONENT_DATAFLASH 00047 #include "DataFlashBlockDevice.h" 00048 #endif 00049 00050 #if COMPONENT_SD 00051 #include "SDBlockDevice.h" 00052 #endif 00053 00054 #if COMPONENT_RZ_SDHI 00055 #include "RZ_SDHIBlockDevice.hpp" 00056 #endif 00057 00058 /** 00059 * @brief This function initializes internal memory secure storage 00060 * This includes a TDBStore instance with a FlashIAPBlockdevice 00061 * as the supported storage. 00062 * The following is a list of configuration parameter 00063 * MBED_CONF_STORAGE_TDB_INTERNAL_SIZE - The size of the underlying FlashIAPBlockdevice 00064 * MBED_CONF_STORAGE_TDB_INTERNAL_BASE_ADDRESS - The start address of the underlying FlashIAPBlockdevice 00065 * @returns 0 on success or negative value on failure. 00066 */ 00067 int _storage_config_TDB_INTERNAL(); 00068 00069 /** 00070 * @brief This function initialize external memory secure storage 00071 * This includes a SecureStore class with TDBStore over FlashIAPBlockdevice 00072 * and an external TDBStore over a default blockdevice unless configured differently. 00073 * The following is a list of configuration parameter: 00074 * MBED_CONF_STORAGE_TDB_EXTERNAL_RBP_INTERNAL_SIZE - Size of the internal FlashIAPBlockDevice and by 00075 * default is set to from start address to the end of the flash. 00076 * If start address is 0 the start address will be set to end of 00077 * flash - rbp_internal_size. 00078 * MBED_CONF_STORAGE_TDB_EXTERNAL_INTERNAL_BASE_ADDRESS - The satrt address of the internal FlashIAPBlockDevice. 00079 * MBED_CONF_STORAGE_TDB_EXTERNAL_EXTERNAL_SIZE - Size of the external blockdevice in bytes or NULL for 00080 * max possible size. 00081 * MBED_CONF_STORAGE_TDB_EXTERNAL_EXTERNAL_BASE_ADDRESS - The block device start address. 00082 * MBED_CONF_STORAGE_TDB_EXTERNAL_EXTERNAL_BLOCK_DEVICE - Alowed vlaues are: default, SPIF, DATAFASH, QSPIF or SD 00083 * @returns 0 on success or negative value on failure. 00084 */ 00085 int _storage_config_TDB_EXTERNAL(); 00086 00087 /** 00088 * @brief This function initialize a external memory secure storage 00089 * This includes a SecureStore class with external TDBStore over a blockdevice or, 00090 * if no blockdevice was set the default blockdevice will be used. 00091 * The following is a list of configuration parameter: 00092 * MBED_CONF_STORAGE_TDB_EXTERNAL_NO_RBP_EXTERNAL_SIZE - Size of the external blockdevice in bytes 00093 * or NULL for max possible size. 00094 * MBED_CONF_STORAGE_TDB_EXTERNAL_NO_RBP_EXTERNAL_BASE_ADDRESS - The block device start address 00095 * MBED_CONF_STORAGE_TDB_EXTERNAL_NO_RBP_EXTERNAL_BLOCK_DEVICE - Alowed vlaues are: default, SPIF, DATAFASH, QSPIF or SD 00096 * @returns 0 on success or negative value on failure. 00097 */ 00098 int _storage_config_TDB_EXTERNAL_NO_RBP(); 00099 00100 /** 00101 * @brief This function initialize a FILESYSTEM memory secure storage 00102 * This includes a SecureStore class with TDBStore over FlashIAPBlockdevice 00103 * in the internal memory and an external FileSysteStore. If blockdevice and filesystem not set, 00104 * the system will use the default block device and default filesystem 00105 * The following is a list of configuration parameter: 00106 * MBED_CONF_STORAGE_FILESYSTEM_RBP_INTERNAL_SIZE - Size of the internal FlashIAPBlockDevice and by 00107 * default is set to from start address to the end of the flash. 00108 * If start address is 0 the start address will be set to end of 00109 * flash - rbp_internal_size. 00110 * MBED_CONF_STORAGE_FILESYSTEM_INTERNAL_BASE_ADDRESS - The satrt address of the internal FlashIAPBlockDevice. 00111 * MBED_CONF_STORAGE_FILESYSTEM_FILESYSTEM - Allowed values are: default, FAT or LITTLE 00112 * MBED_CONF_STORAGE_FILESYSTEM_BLOCKDEVICE - Allowed values are: default, SPIF, DATAFASH, QSPIF or SD 00113 * MBED_CONF_STORAGE_FILESYSTEM_EXTERNAL_SIZE - External Blockdevice size in bytes or NULL for max possible size. 00114 * MBED_CONF_STORAGE_FILESYSTEM_EXTERNAL_BASE_ADDRESS - The block device start address. 00115 * MBED_CONF_STORAGE_FILESYSTEM_MOUNT_POINT - Where to mount the filesystem 00116 * MBED_CONF_STORAGE_FILESYSTEM_FOLDER_PATH - The working folder paths 00117 * 00118 * @returns 0 on success or negative value on failure. 00119 */ 00120 int _storage_config_FILESYSTEM(); 00121 00122 /** 00123 * @brief This function initialize a FILESYSTEM_NO_RBP memory secure storage with no 00124 * rollback protection. This includes a SecureStore class an external FileSysteStore over a default 00125 * filesystem with default blockdevice unless differently configured. 00126 * The following is a list of configuration parameter: 00127 * MBED_CONF_STORAGE_FILESYSTEM_NO_RBP_FILESYSTEM - Allowed values are: default, FAT or LITTLE 00128 * MBED_CONF_STORAGE_FILESYSTEM_NO_RBP_BLOCKDEVICE - Allowed values are: default, SPIF, DATAFASH, QSPIF or SD 00129 * MBED_CONF_STORAGE_FILESYSTEM_NO_RBP_EXTERNAL_SIZE - Blockdevice size in bytes. or NULL for max possible size. 00130 * MBED_CONF_STORAGE_FILESYSTEM_NO_RBP_EXTERNAL_BASE_ADDRESS - The block device start address. 00131 * MBED_CONF_STORAGE_FILESYSTEM_NO_RBP_MOUNT_POINT - Where to mount the filesystem 00132 * MBED_CONF_STORAGE_FILESYSTEM_NO_RBP_FOLDER_PATH - The working folder paths 00133 * 00134 * @returns 0 on success or negative value on failure. 00135 */ 00136 int _storage_config_FILESYSTEM_NO_RBP(); 00137 00138 int _storage_config_tdb_external_common(); 00139 int _storage_config_filesystem_common(); 00140 00141 static const char *filesystemstore_folder_path = NULL; 00142 00143 using namespace mbed; 00144 00145 00146 static SingletonPtr<PlatformMutex> mutex; 00147 static bool is_kv_config_initialize = false; 00148 static kvstore_config_t kvstore_config; 00149 00150 #define INTERNAL_BLOCKDEVICE_NAME FLASHIAP 00151 00152 #define STR_EXPAND(tok) #tok 00153 #define STR(tok) STR_EXPAND(tok) 00154 00155 #define _GET_FILESYSTEM_concat(dev, ...) _get_filesystem_##dev(__VA_ARGS__) 00156 #define GET_FILESYSTEM(dev, ...) _GET_FILESYSTEM_concat(dev, __VA_ARGS__) 00157 00158 #define _GET_BLOCKDEVICE_concat(dev, ...) _get_blockdevice_##dev(__VA_ARGS__) 00159 #define GET_BLOCKDEVICE(dev, ...) _GET_BLOCKDEVICE_concat(dev, __VA_ARGS__) 00160 00161 static inline uint32_t align_up(uint64_t val, uint64_t size) 00162 { 00163 return (((val - 1) / size) + 1) * size; 00164 } 00165 00166 static inline uint32_t align_down(uint64_t val, uint64_t size) 00167 { 00168 return (((val) / size)) * size; 00169 } 00170 00171 int _calculate_blocksize_match_tdbstore(BlockDevice *bd) 00172 { 00173 bd_size_t size = bd->size(); 00174 bd_size_t erase_size = bd->get_erase_size(); 00175 bd_size_t number_of_sector = size / erase_size; 00176 00177 if (number_of_sector < 2) { 00178 tr_warning("KV Config: There are less than two sectors - TDBStore will not work."); 00179 return -1; 00180 } 00181 00182 00183 if (number_of_sector % 2 != 0) { 00184 tr_warning("KV Config: Number of sectors is not an even number. Consider changing the BlockDevice size"); 00185 } 00186 00187 return MBED_SUCCESS; 00188 } 00189 00190 int _get_addresses(BlockDevice *bd, bd_addr_t start_address, bd_size_t size, bd_addr_t *out_start_addr, 00191 bd_addr_t *out_end_addr) 00192 { 00193 bd_addr_t aligned_end_address; 00194 bd_addr_t end_address; 00195 bd_addr_t aligned_start_address; 00196 00197 aligned_start_address = align_down(start_address, bd->get_erase_size(start_address)); 00198 if (aligned_start_address != start_address) { 00199 tr_error("KV Config: Start address is not aligned. Better use %02llx", aligned_start_address); 00200 return -1; 00201 } 00202 00203 if (size == 0) { 00204 (*out_start_addr) = aligned_start_address; 00205 (*out_end_addr) = bd->size(); 00206 return 0; 00207 } 00208 00209 end_address = start_address + size; 00210 aligned_end_address = align_up(end_address, bd->get_erase_size(end_address)); 00211 if (aligned_end_address != end_address) { 00212 tr_error("KV Config: End address is not aligned. Consider changing the size parameter."); 00213 return -1; 00214 } 00215 00216 if (aligned_end_address > bd->size()) { 00217 tr_error("KV Config: End address is out of boundaries"); 00218 return -1; 00219 } 00220 00221 (*out_start_addr) = aligned_start_address; 00222 (*out_end_addr) = aligned_end_address; 00223 return 0; 00224 } 00225 00226 FileSystem *_get_filesystem_FAT(const char *mount) 00227 { 00228 static FATFileSystem sdcard(mount); 00229 return &sdcard; 00230 00231 } 00232 00233 FileSystem *_get_filesystem_LITTLE(const char *mount) 00234 { 00235 static LittleFileSystem flash(mount); 00236 return &flash; 00237 } 00238 00239 FileSystemStore *_get_file_system_store(FileSystem *fs) 00240 { 00241 static FileSystemStore fss(fs); 00242 return &fss; 00243 } 00244 00245 FileSystem *_get_filesystem_default(const char *mount) 00246 { 00247 #if COMPONENT_QSPIF || COMPONENT_SPIF || COMPONENT_DATAFLASH 00248 return _get_filesystem_LITTLE(mount); 00249 #elif (COMPONENT_SD || COMPONENT_RZ_SDHI) 00250 return _get_filesystem_FAT(mount); 00251 #else 00252 return NULL; 00253 #endif 00254 } 00255 00256 //Calculates the start address of FLASHIAP block device for TDB_INTERNAL profile. 00257 //If possible, the address will start 2 sectors after the end of code sector allowing 00258 //some space for an application update. 00259 int _get_flashiap_bd_default_addresses_tdb_internal(bd_addr_t *start_address, bd_size_t *size) 00260 { 00261 #if COMPONENT_FLASHIAP 00262 00263 FlashIAP flash; 00264 00265 if (*start_address != 0 || *size != 0) { 00266 return MBED_ERROR_INVALID_ARGUMENT; 00267 } 00268 00269 //If default values are set, we should get the maximum available size of internal bd. 00270 if (flash.init() != 0) { 00271 return MBED_ERROR_FAILED_OPERATION; 00272 } 00273 00274 *start_address = align_up(FLASHIAP_APP_ROM_END_ADDR, flash.get_sector_size(FLASHIAP_APP_ROM_END_ADDR)); 00275 00276 // Give the application a couple of spare sectors to grow (if there are such) 00277 bd_size_t spare_size_for_app = 0; 00278 bd_addr_t curr_addr = *start_address; 00279 bd_addr_t flash_end_address = flash.get_flash_start() + flash.get_flash_size(); 00280 00281 int spare_sectors_for_app = 2; 00282 int min_sectors_for_storage = 2; 00283 for (int i = 0; i < spare_sectors_for_app + min_sectors_for_storage - 1; i++) { 00284 bd_size_t sector_size = flash.get_sector_size(curr_addr); 00285 curr_addr += sector_size; 00286 if (curr_addr >= flash_end_address) { 00287 spare_size_for_app = 0; 00288 break; 00289 } 00290 00291 if (i < spare_sectors_for_app) { 00292 spare_size_for_app += sector_size; 00293 } 00294 } 00295 *start_address += spare_size_for_app; 00296 00297 flash.deinit(); 00298 00299 #endif 00300 00301 return MBED_SUCCESS; 00302 } 00303 00304 //Calculates address and size for FLASHIAP block device in TDB_EXTERNAL and FILESYSTEM profiles. 00305 //The size of the block device will be 2 sectors at the ends of the internal flash for 00306 //the use of the rbp internal TDBStore. 00307 int _get_flashiap_bd_default_addresses_rbp(bd_addr_t *start_address, bd_size_t *size) 00308 { 00309 #if COMPONENT_FLASHIAP 00310 00311 bd_addr_t flash_end_address; 00312 bd_addr_t flash_start_address; 00313 bd_addr_t aligned_start_address; 00314 bd_addr_t flash_first_writable_sector_address; 00315 FlashIAP flash; 00316 00317 if (*start_address != 0 || *size != 0) { 00318 return MBED_ERROR_INVALID_ARGUMENT; 00319 } 00320 00321 int ret = flash.init(); 00322 if (ret != 0) { 00323 return MBED_ERROR_INITIALIZATION_FAILED; 00324 } 00325 00326 flash_first_writable_sector_address = align_up(FLASHIAP_APP_ROM_END_ADDR, flash.get_sector_size(FLASHIAP_APP_ROM_END_ADDR)); 00327 flash_start_address = flash.get_flash_start(); 00328 flash_end_address = flash_start_address + flash.get_flash_size();; 00329 *start_address = flash_end_address - 1; 00330 aligned_start_address = align_down(*start_address, flash.get_sector_size(*start_address)); 00331 *size = (flash_end_address - aligned_start_address) * 2; 00332 *start_address = (flash_end_address - *size); 00333 aligned_start_address = align_down(*start_address, flash.get_sector_size(*start_address)); 00334 00335 flash.deinit(); 00336 00337 if (aligned_start_address < flash_first_writable_sector_address) { 00338 tr_error("KV Config: Internal block device start address overlapped ROM address "); 00339 return MBED_ERROR_INITIALIZATION_FAILED; 00340 } 00341 00342 #endif 00343 00344 return MBED_SUCCESS; 00345 00346 } 00347 00348 BlockDevice *_get_blockdevice_FLASHIAP(bd_addr_t start_address, bd_size_t size) 00349 { 00350 #if COMPONENT_FLASHIAP 00351 00352 bd_addr_t flash_end_address; 00353 bd_addr_t flash_start_address; 00354 bd_addr_t flash_first_writable_sector_address; 00355 bd_addr_t aligned_start_address; 00356 bd_addr_t aligned_end_address; 00357 bd_addr_t end_address; 00358 FlashIAP flash; 00359 00360 int ret = flash.init(); 00361 if (ret != 0) { 00362 return NULL; 00363 } 00364 00365 //Get flash parameters before starting 00366 flash_first_writable_sector_address = align_up(FLASHIAP_APP_ROM_END_ADDR, flash.get_sector_size(FLASHIAP_APP_ROM_END_ADDR)); 00367 flash_start_address = flash.get_flash_start(); 00368 flash_end_address = flash_start_address + flash.get_flash_size();; 00369 00370 //Non default configuration 00371 if (start_address != 0) { 00372 00373 aligned_start_address = align_down(start_address, flash.get_sector_size(start_address)); 00374 if (start_address != aligned_start_address) { 00375 tr_error("KV Config: Internal block device start address is not aligned. Better use %02llx", aligned_start_address); 00376 flash.deinit(); 00377 return NULL; 00378 } 00379 00380 if (size == 0) { 00381 //The block device will have all space form start address to the end of the flash 00382 size = (flash_end_address - start_address); 00383 00384 static FlashIAPBlockDevice bd(start_address, size); 00385 flash.deinit(); 00386 return &bd; 00387 } 00388 00389 if (size != 0) { 00390 end_address = start_address + size; 00391 if (end_address > flash_end_address) { 00392 tr_error("KV Config: Internal block device end address is out of boundaries"); 00393 flash.deinit(); 00394 return NULL; 00395 } 00396 00397 aligned_end_address = align_up(end_address, flash.get_sector_size(end_address - 1)); 00398 if (end_address != aligned_end_address) { 00399 tr_error("KV Config: Internal block device start address is not aligned. Consider changing the size parameter"); 00400 flash.deinit(); 00401 return NULL; 00402 } 00403 00404 static FlashIAPBlockDevice bd(start_address, size); 00405 flash.deinit(); 00406 return &bd; 00407 } 00408 } 00409 00410 //Non default configuration start_address = 0 00411 start_address = flash_end_address - size; 00412 aligned_start_address = align_down(start_address, flash.get_sector_size(start_address)); 00413 if (start_address != aligned_start_address) { 00414 tr_error("KV Config: Internal block device start address is not aligned. Consider changing the size parameter"); 00415 flash.deinit(); 00416 return NULL; 00417 } 00418 00419 flash.deinit(); 00420 00421 if (aligned_start_address < flash_first_writable_sector_address) { 00422 tr_error("KV Config: Internal block device start address overlapped ROM address "); 00423 return NULL; 00424 } 00425 static FlashIAPBlockDevice bd(aligned_start_address, size); 00426 return &bd; 00427 00428 #else 00429 return NULL; 00430 #endif 00431 } 00432 00433 BlockDevice *_get_blockdevice_SPIF(bd_addr_t start_address, bd_size_t size) 00434 { 00435 #if COMPONENT_SPIF 00436 00437 bd_addr_t aligned_end_address; 00438 bd_addr_t aligned_start_address; 00439 00440 static SPIFBlockDevice bd( 00441 MBED_CONF_SPIF_DRIVER_SPI_MOSI, 00442 MBED_CONF_SPIF_DRIVER_SPI_MISO, 00443 MBED_CONF_SPIF_DRIVER_SPI_CLK, 00444 MBED_CONF_SPIF_DRIVER_SPI_CS, 00445 MBED_CONF_SPIF_DRIVER_SPI_FREQ 00446 ); 00447 00448 if (bd.init() != MBED_SUCCESS) { 00449 tr_error("KV Config: SPIFBlockDevice init fail"); 00450 return NULL; 00451 } 00452 00453 if (start_address == 0 && size == 0) { 00454 return &bd; 00455 } 00456 00457 //If address and size were specified use SlicingBlockDevice to get the correct block device size and start address. 00458 if (_get_addresses(&bd, start_address, size, &aligned_start_address, &aligned_end_address) != 0) { 00459 tr_error("KV Config: Fail to get addresses for SlicingBlockDevice."); 00460 return NULL; 00461 } 00462 00463 static SlicingBlockDevice sbd(&bd, aligned_start_address, aligned_end_address); 00464 return &sbd; 00465 00466 #else 00467 return NULL; 00468 #endif 00469 } 00470 00471 BlockDevice *_get_blockdevice_QSPIF(bd_addr_t start_address, bd_size_t size) 00472 { 00473 #if COMPONENT_QSPIF 00474 00475 bd_addr_t aligned_end_address; 00476 bd_addr_t aligned_start_address; 00477 00478 static QSPIFBlockDevice bd( 00479 QSPI_FLASH1_IO0, 00480 QSPI_FLASH1_IO1, 00481 QSPI_FLASH1_IO2, 00482 QSPI_FLASH1_IO3, 00483 QSPI_FLASH1_SCK, 00484 QSPI_FLASH1_CSN, 00485 QSPIF_POLARITY_MODE_0, 00486 MBED_CONF_QSPIF_QSPI_FREQ 00487 ); 00488 00489 if (bd.init() != MBED_SUCCESS) { 00490 tr_error("KV Config: QSPIFBlockDevice init fail"); 00491 return NULL; 00492 } 00493 00494 if (start_address == 0 && size == 0) { 00495 return &bd; 00496 } 00497 00498 //If address and size were specified use SlicingBlockDevice to get the correct block device size and start address. 00499 if (_get_addresses(&bd, start_address, size, &aligned_start_address, &aligned_end_address) != 0) { 00500 tr_error("KV Config: Fail to get addresses for SlicingBlockDevice."); 00501 return NULL; 00502 } 00503 00504 static SlicingBlockDevice sbd(&bd, aligned_start_address, aligned_end_address); 00505 return &sbd; 00506 00507 #else 00508 return NULL; 00509 #endif 00510 } 00511 00512 BlockDevice *_get_blockdevice_DATAFLASH(bd_addr_t start_address, bd_size_t size) 00513 { 00514 #if COMPONENT_DATAFLASH 00515 00516 bd_addr_t aligned_end_address; 00517 bd_addr_t aligned_start_address; 00518 00519 static DataFlashBlockDevice bd( 00520 MBED_CONF_DATAFLASH_SPI_MOSI, 00521 MBED_CONF_DATAFLASH_SPI_MISO, 00522 MBED_CONF_DATAFLASH_SPI_CLK, 00523 MBED_CONF_DATAFLASH_SPI_CS 00524 ); 00525 00526 if (bd.init() != MBED_SUCCESS) { 00527 tr_error("KV Config: DataFlashBlockDevice init fail"); 00528 return NULL; 00529 } 00530 00531 if (start_address == 0 && size == 0) { 00532 return &bd; 00533 } 00534 00535 //If address and size were specified use SlicingBlockDevice to get the correct block device size and start address. 00536 if (_get_addresses(&bd, start_address, size, &aligned_start_address, &aligned_end_address) != 0) { 00537 tr_error("KV Config: Fail to get addresses for SlicingBlockDevice."); 00538 return NULL; 00539 } 00540 00541 static SlicingBlockDevice sbd(&bd, aligned_start_address, aligned_end_address); 00542 return &sbd; 00543 00544 00545 #else 00546 return NULL; 00547 #endif 00548 } 00549 00550 BlockDevice *_get_blockdevice_SD(bd_addr_t start_address, bd_size_t size) 00551 { 00552 #if COMPONENT_SD 00553 00554 bd_addr_t aligned_end_address; 00555 bd_addr_t aligned_start_address; 00556 00557 static SDBlockDevice bd( 00558 MBED_CONF_SD_SPI_MOSI, 00559 MBED_CONF_SD_SPI_MISO, 00560 MBED_CONF_SD_SPI_CLK, 00561 MBED_CONF_SD_SPI_CS 00562 ); 00563 00564 if (bd.init() != MBED_SUCCESS) { 00565 tr_error("KV Config: SDBlockDevice init fail"); 00566 return NULL; 00567 } 00568 00569 if (strcmp(STR(MBED_CONF_STORAGE_STORAGE_TYPE), "TDB_EXTERNAL_NO_RBP") == 0 || 00570 strcmp(STR(MBED_CONF_STORAGE_STORAGE_TYPE), "TDB_EXTERNAL") == 0) { 00571 //In TDBStore profile, we have a constraint of 4GByte 00572 if (start_address == 0 && size == 0 && bd.size() < (uint32_t)(-1)) { 00573 return &bd; 00574 } 00575 00576 //If the size of external storage is bigger than 4G we need to slice it. 00577 size = size != 0 ? size : align_down(bd.size(), bd.get_erase_size(bd.size() - 1)); 00578 00579 if (_get_addresses(&bd, start_address, size, &aligned_start_address, &aligned_end_address) != 0) { 00580 tr_error("KV Config: Fail to get addresses for SlicingBlockDevice."); 00581 return NULL; 00582 } 00583 00584 if (aligned_end_address - aligned_start_address != (uint32_t)(aligned_end_address - aligned_start_address)) { 00585 aligned_end_address = aligned_start_address + (uint32_t)(-1);//Support up to 4G only 00586 } 00587 } else { 00588 //For all other KVStore profiles beside TDBStore we take the entire external memory space. 00589 if (start_address == 0 && size == 0) { 00590 return &bd; 00591 } 00592 00593 if (_get_addresses(&bd, start_address, size, &aligned_start_address, &aligned_end_address) != 0) { 00594 tr_error("KV Config: Fail to get addresses for SlicingBlockDevice."); 00595 return NULL; 00596 } 00597 } 00598 00599 aligned_end_address = align_down(aligned_end_address, bd.get_erase_size(aligned_end_address)); 00600 static SlicingBlockDevice sbd(&bd, aligned_start_address, aligned_end_address); 00601 return &sbd; 00602 00603 #else 00604 return NULL; 00605 #endif 00606 } 00607 00608 BlockDevice *_get_blockdevice_RZ_SDHI(bd_addr_t start_address, bd_size_t size) 00609 { 00610 #if COMPONENT_RZ_SDHI 00611 00612 bd_addr_t aligned_end_address; 00613 bd_addr_t aligned_start_address; 00614 00615 static SDHIBlockDevice bd(MBED_CONF_RZ_SDHI_CH); 00616 00617 if (bd.init() != MBED_SUCCESS) { 00618 tr_error("KV Config: SDBlockDevice init fail"); 00619 return NULL; 00620 } 00621 00622 if (strcmp(STR(MBED_CONF_STORAGE_STORAGE_TYPE), "TDB_EXTERNAL_NO_RBP") == 0 || 00623 strcmp(STR(MBED_CONF_STORAGE_STORAGE_TYPE), "TDB_EXTERNAL") == 0) { 00624 //In TDBStore profile, we have a constraint of 4GByte 00625 if (start_address == 0 && size == 0 && bd.size() < (uint32_t)(-1)) { 00626 return &bd; 00627 } 00628 00629 //If the size of external storage is bigger than 4G we need to slice it. 00630 size = size != 0 ? size : align_down(bd.size(), bd.get_erase_size(bd.size() - 1)); 00631 00632 if (_get_addresses(&bd, start_address, size, &aligned_start_address, &aligned_end_address) != 0) { 00633 tr_error("KV Config: Fail to get addresses for SlicingBlockDevice."); 00634 return NULL; 00635 } 00636 00637 if (aligned_end_address - aligned_start_address != (uint32_t)(aligned_end_address - aligned_start_address)) { 00638 aligned_end_address = aligned_start_address + (uint32_t)(-1);//Support up to 4G only 00639 } 00640 } else { 00641 //For all other KVStore profiles beside TDBStore we take the entire external memory space. 00642 if (start_address == 0 && size == 0) { 00643 return &bd; 00644 } 00645 00646 if (_get_addresses(&bd, start_address, size, &aligned_start_address, &aligned_end_address) != 0) { 00647 tr_error("KV Config: Fail to get addresses for SlicingBlockDevice."); 00648 return NULL; 00649 } 00650 } 00651 00652 aligned_end_address = align_down(aligned_end_address, bd.get_erase_size(aligned_end_address)); 00653 static SlicingBlockDevice sbd(&bd, aligned_start_address, aligned_end_address); 00654 return &sbd; 00655 00656 #else 00657 return NULL; 00658 #endif 00659 } 00660 00661 BlockDevice *_get_blockdevice_default(bd_addr_t start_address, bd_size_t size) 00662 { 00663 #if COMPONENT_QSPIF 00664 return _get_blockdevice_QSPIF(start_address, size); 00665 #elif COMPONENT_SPIF 00666 return _get_blockdevice_SPIF(start_address, size); 00667 #elif COMPONENT_DATAFLASH 00668 return _get_blockdevice_DATAFLASH(start_address, size); 00669 #elif COMPONENT_SD 00670 return _get_blockdevice_SD(start_address, size); 00671 #elif COMPONENT_RZ_SDHI 00672 return _get_blockdevice_RZ_SDHI(start_address, size); 00673 #else 00674 tr_error("KV Config: No default component define in target.json for this target."); 00675 return NULL; 00676 #endif 00677 } 00678 00679 int _storage_config_TDB_INTERNAL() 00680 { 00681 #if COMPONENT_FLASHIAP 00682 bd_size_t internal_size = MBED_CONF_STORAGE_TDB_INTERNAL_INTERNAL_SIZE; 00683 bd_addr_t internal_start_address = MBED_CONF_STORAGE_TDB_INTERNAL_INTERNAL_BASE_ADDRESS; 00684 00685 if (internal_size == 0 && internal_start_address == 0) { 00686 //Calculate the block device size and start address in case default values are used. 00687 if (_get_flashiap_bd_default_addresses_tdb_internal(&internal_start_address, &internal_size) != MBED_SUCCESS) { 00688 return MBED_ERROR_FAILED_OPERATION; 00689 } 00690 } 00691 00692 //Get internal memory FLASHIAP block device. 00693 kvstore_config.internal_bd = GET_BLOCKDEVICE(INTERNAL_BLOCKDEVICE_NAME, internal_start_address, internal_size); 00694 if (kvstore_config.internal_bd == NULL) { 00695 tr_error("KV Config: Fail to get internal BlockDevice."); 00696 return MBED_ERROR_FAILED_OPERATION; 00697 } 00698 00699 00700 int ret = kvstore_config.internal_bd->init(); 00701 if (ret != MBED_SUCCESS) { 00702 tr_error("KV Config: Fail to init internal BlockDevice."); 00703 return MBED_ERROR_FAILED_OPERATION; 00704 } 00705 00706 //Check that internal flash has 2 or more sectors 00707 if (_calculate_blocksize_match_tdbstore(kvstore_config.internal_bd) != MBED_SUCCESS) { 00708 tr_error("KV Config: Can not create TDBStore with less then 2 sector."); 00709 return MBED_ERROR_INVALID_ARGUMENT; 00710 } 00711 00712 //Deinitialize internal block device and TDB will reinitialize and take control on it. 00713 ret = kvstore_config.internal_bd->deinit(); 00714 if (ret != MBED_SUCCESS) { 00715 tr_error("KV Config: Fail to deinit internal BlockDevice."); 00716 return MBED_ERROR_FAILED_OPERATION; 00717 } 00718 00719 //Create a TDBStore in the internal FLASHIAP block device. 00720 static TDBStore tdb_internal(kvstore_config.internal_bd); 00721 kvstore_config.internal_store = &tdb_internal; 00722 00723 ret = kvstore_config.internal_store->init(); 00724 if (ret != MBED_SUCCESS) { 00725 tr_error("KV Config: Fail to init internal TDBStore."); 00726 return ret; 00727 } 00728 kvstore_config.kvstore_main_instance = 00729 kvstore_config.internal_store; 00730 00731 //Masking flag - Actually used to remove any KVStore flag which is not supported 00732 //in the chosen KVStore profile. 00733 kvstore_config.flags_mask = ~(KVStore::REQUIRE_CONFIDENTIALITY_FLAG | 00734 KVStore::REQUIRE_REPLAY_PROTECTION_FLAG); 00735 00736 //Initialize kv_map and add the configuration struct to KVStore map. 00737 KVMap &kv_map = KVMap::get_instance(); 00738 ret = kv_map.init(); 00739 if (MBED_SUCCESS != ret) { 00740 tr_error("KV Config: Fail to init KVStore global API."); 00741 return ret; 00742 } 00743 00744 ret = kv_map.attach(STR(MBED_CONF_STORAGE_DEFAULT_KV), &kvstore_config); 00745 if (MBED_SUCCESS != ret) { 00746 tr_error("KV Config: Fail to attach KVStore main instance to KVStore global API."); 00747 return ret; 00748 } 00749 return MBED_SUCCESS; 00750 #else 00751 return MBED_ERROR_UNSUPPORTED; 00752 #endif 00753 00754 } 00755 00756 int _storage_config_TDB_EXTERNAL() 00757 { 00758 #if !SECURESTORE_ENABLED 00759 return MBED_ERROR_UNSUPPORTED; 00760 #endif 00761 00762 bd_size_t internal_rbp_size = MBED_CONF_STORAGE_TDB_EXTERNAL_RBP_INTERNAL_SIZE; 00763 bd_addr_t internal_start_address = MBED_CONF_STORAGE_TDB_EXTERNAL_INTERNAL_BASE_ADDRESS; 00764 00765 //Get the default address and size for internal rbp TDBStore 00766 if (internal_rbp_size == 0 && internal_start_address == 0) { 00767 //Calculate the block device size and start address in case default values are used. 00768 if (_get_flashiap_bd_default_addresses_rbp(&internal_start_address, &internal_rbp_size) != MBED_SUCCESS) { 00769 return MBED_ERROR_FAILED_OPERATION; 00770 } 00771 } 00772 00773 //Create internal FLASHIAP block device 00774 kvstore_config.internal_bd = GET_BLOCKDEVICE(INTERNAL_BLOCKDEVICE_NAME, internal_start_address, internal_rbp_size); 00775 if (kvstore_config.internal_bd == NULL) { 00776 tr_error("KV Config: Fail to get internal BlockDevice."); 00777 return MBED_ERROR_FAILED_OPERATION ; 00778 } 00779 00780 int ret = kvstore_config.internal_bd->init(); 00781 if (ret != MBED_SUCCESS) { 00782 tr_error("KV Config: Fail to init internal BlockDevice."); 00783 return MBED_ERROR_FAILED_OPERATION ; 00784 } 00785 00786 //Check if TDBStore has at least 2 sector. 00787 if (_calculate_blocksize_match_tdbstore(kvstore_config.internal_bd) != MBED_SUCCESS) { 00788 tr_error("KV Config: Can not create TDBStore with less then 2 sector."); 00789 return MBED_ERROR_INVALID_ARGUMENT; 00790 } 00791 00792 //Create internal TDBStore 00793 static TDBStore tdb_internal(kvstore_config.internal_bd); 00794 kvstore_config.internal_store = &tdb_internal; 00795 00796 ret = kvstore_config.internal_store->init(); 00797 if (ret != MBED_SUCCESS) { 00798 tr_error("KV Config: Fail to init internal TDBStore."); 00799 return ret; 00800 } 00801 00802 bd_size_t size = MBED_CONF_STORAGE_TDB_EXTERNAL_EXTERNAL_SIZE; 00803 bd_addr_t address = MBED_CONF_STORAGE_TDB_EXTERNAL_EXTERNAL_BASE_ADDRESS; 00804 00805 //Get external BlockDevice for TDBStore 00806 BlockDevice *bd = GET_BLOCKDEVICE(MBED_CONF_STORAGE_TDB_EXTERNAL_BLOCKDEVICE, address, size); 00807 if (bd == NULL) { 00808 tr_error("KV Config: Fail to get external BlockDevice."); 00809 return MBED_ERROR_FAILED_OPERATION ; 00810 } 00811 00812 //TDBStore needs a block device base on flash. so if this is SD block device or the default block device is SD 00813 //add FlashSimBlockDevice on top of the SDBlockDevice 00814 #if defined(COMPONENT_SD) || defined(COMPONENT_RZ_SDHI) 00815 if (strcmp(STR(MBED_CONF_STORAGE_TDB_EXTERNAL_BLOCKDEVICE), "SD") == 0 00816 #if (defined(COMPONENT_SD) || defined(COMPONENT_RZ_SDHI))&& !defined(COMPONENT_SPIF) && !defined(COMPONENT_QSPIF) && !defined(COMPONENT_DATAFLASH) 00817 || strcmp(STR(MBED_CONF_STORAGE_TDB_EXTERNAL_BLOCKDEVICE), "default") == 0) { 00818 #else 00819 ) { 00820 00821 #endif 00822 //TDBStore need FlashSimBlockDevice when working with SD block device 00823 if (bd->init() != MBED_SUCCESS) { 00824 tr_error("KV Config: Fail to init external BlockDevice."); 00825 return MBED_ERROR_FAILED_OPERATION ; 00826 } 00827 00828 static FlashSimBlockDevice flash_bd(bd); 00829 kvstore_config.external_bd = &flash_bd; 00830 } else { 00831 kvstore_config.external_bd = bd; 00832 } 00833 #else 00834 kvstore_config.external_bd = bd; 00835 #endif 00836 00837 kvstore_config.flags_mask = ~(0); 00838 00839 return _storage_config_tdb_external_common(); 00840 } 00841 00842 int _storage_config_TDB_EXTERNAL_NO_RBP() 00843 { 00844 #if !SECURESTORE_ENABLED 00845 return MBED_ERROR_UNSUPPORTED; 00846 #endif 00847 bd_size_t size = MBED_CONF_STORAGE_TDB_EXTERNAL_NO_RBP_EXTERNAL_SIZE; 00848 bd_addr_t address = MBED_CONF_STORAGE_TDB_EXTERNAL_NO_RBP_EXTERNAL_BASE_ADDRESS; 00849 00850 //Get external block device 00851 BlockDevice *bd = GET_BLOCKDEVICE(MBED_CONF_STORAGE_TDB_EXTERNAL_NO_RBP_BLOCKDEVICE, address, size); 00852 if (bd == NULL) { 00853 tr_error("KV Config: Fail to get external BlockDevice."); 00854 return MBED_ERROR_FAILED_OPERATION ; 00855 } 00856 00857 //TDBStore needs a block device base on flash. so if this is SD block device or the default block device is SD 00858 //add FlashSimBlockDevice on top of the SDBlockDevice 00859 #if defined(COMPONENT_SD) || defined(COMPONENT_RZ_SDHI) 00860 if (strcmp(STR(MBED_CONF_STORAGE_TDB_EXTERNAL_NO_RBP_BLOCKDEVICE), "SD") == 0 00861 #if (defined(COMPONENT_SD) || defined(COMPONENT_RZ_SDHI)) && !defined(COMPONENT_SPIF) && !defined(COMPONENT_QSPIF) && !defined(COMPONENT_DATAFLASH) 00862 || strcmp(STR(MBED_CONF_STORAGE_TDB_EXTERNAL_NO_RBP_BLOCKDEVICE), "default") == 0) { 00863 #else 00864 ) { 00865 00866 #endif 00867 //TDBStore need FlashSimBlockDevice when working with SD block device 00868 if (bd->init() != MBED_SUCCESS) { 00869 tr_error("KV Config: Fail to init external BlockDevice."); 00870 return MBED_ERROR_FAILED_OPERATION ; 00871 } 00872 00873 static FlashSimBlockDevice flash_bd(bd); 00874 kvstore_config.external_bd = &flash_bd; 00875 } else { 00876 kvstore_config.external_bd = bd; 00877 } 00878 #else 00879 kvstore_config.external_bd = bd; 00880 #endif 00881 00882 //Masking flag - Actually used to remove any KVStore flag which is not supported 00883 //in the chosen KVStore profile. 00884 kvstore_config.flags_mask = ~(KVStore::REQUIRE_REPLAY_PROTECTION_FLAG); 00885 00886 return _storage_config_tdb_external_common(); 00887 } 00888 00889 int _storage_config_tdb_external_common() 00890 { 00891 #if SECURESTORE_ENABLED 00892 //Initialize external block device 00893 int ret = kvstore_config.external_bd->init(); 00894 if (ret != MBED_SUCCESS) { 00895 tr_error("KV Config: Fail to init external BlockDevice."); 00896 return MBED_ERROR_FAILED_OPERATION ; 00897 } 00898 00899 //Check that there is at least 2 sector for the external TDBStore 00900 if (_calculate_blocksize_match_tdbstore(kvstore_config.external_bd) != MBED_SUCCESS) { 00901 tr_error("KV Config: Can not create TDBStore with less then 2 sector."); 00902 return MBED_ERROR_INVALID_SIZE; 00903 } 00904 00905 //Create external TDBStore 00906 static TDBStore tdb_external(kvstore_config.external_bd); 00907 kvstore_config.external_store = &tdb_external; 00908 00909 //Create SecureStore and initialize it 00910 static SecureStore secst(kvstore_config.external_store, kvstore_config.internal_store); 00911 00912 ret = secst.init(); 00913 if (ret != MBED_SUCCESS) { 00914 tr_error("KV Config: Fail to init SecureStore."); 00915 return ret ; 00916 } 00917 00918 kvstore_config.kvstore_main_instance = &secst; 00919 00920 //Init kv_map and add the configuration struct to KVStore map. 00921 KVMap &kv_map = KVMap::get_instance(); 00922 ret = kv_map.init(); 00923 if (MBED_SUCCESS != ret) { 00924 tr_error("KV Config: Fail to init KVStore global API"); 00925 return ret; 00926 } 00927 00928 ret = kv_map.attach(STR(MBED_CONF_STORAGE_DEFAULT_KV), &kvstore_config); 00929 if (MBED_SUCCESS != ret) { 00930 tr_error("KV Config: Fail to attach KvStore main instance to KVStore global API"); 00931 return ret; 00932 } 00933 00934 return MBED_SUCCESS; 00935 #else 00936 return MBED_ERROR_UNSUPPORTED; 00937 #endif 00938 } 00939 00940 int _storage_config_FILESYSTEM() 00941 { 00942 #if !SECURESTORE_ENABLED 00943 return MBED_ERROR_UNSUPPORTED; 00944 #endif 00945 00946 filesystemstore_folder_path = STR(MBED_CONF_STORAGE_FILESYSTEM_FOLDER_PATH); 00947 00948 bd_size_t internal_rbp_size = MBED_CONF_STORAGE_FILESYSTEM_RBP_INTERNAL_SIZE; 00949 bd_addr_t internal_start_address = MBED_CONF_STORAGE_FILESYSTEM_INTERNAL_BASE_ADDRESS; 00950 00951 //Get the default address and size for internal rbp TDBStore 00952 if (internal_rbp_size == 0 && internal_start_address == 0) { 00953 //Calculate the block device size and start address in case default values are used. 00954 if (_get_flashiap_bd_default_addresses_rbp(&internal_start_address, &internal_rbp_size) != MBED_SUCCESS) { 00955 return MBED_ERROR_FAILED_OPERATION; 00956 } 00957 } 00958 00959 //Get internal FLASHIAP block device 00960 kvstore_config.internal_bd = GET_BLOCKDEVICE(INTERNAL_BLOCKDEVICE_NAME, internal_start_address, internal_rbp_size); 00961 if (kvstore_config.internal_bd == NULL) { 00962 tr_error("KV Config: Fail to get internal BlockDevice "); 00963 return MBED_ERROR_FAILED_OPERATION ; 00964 } 00965 00966 int ret = kvstore_config.internal_bd->init(); 00967 if (ret != MBED_SUCCESS) { 00968 tr_error("KV Config: Fail to init internal BlockDevice "); 00969 return MBED_ERROR_FAILED_OPERATION ; 00970 } 00971 00972 //Check that internal flash has 2 or more sectors 00973 if (_calculate_blocksize_match_tdbstore(kvstore_config.internal_bd) != MBED_SUCCESS) { 00974 tr_error("KV Config: Can not create TDBStore with less then 2 sector."); 00975 return MBED_ERROR_INVALID_ARGUMENT; 00976 } 00977 00978 //Deinitialize internal block device and TDB will reinitialize and take control on it. 00979 ret = kvstore_config.internal_bd->deinit(); 00980 if (ret != MBED_SUCCESS) { 00981 tr_error("KV Config: Fail to deinit internal BlockDevice."); 00982 return MBED_ERROR_FAILED_OPERATION; 00983 } 00984 00985 //Create internal TDBStore for rbp 00986 static TDBStore tdb_internal(kvstore_config.internal_bd); 00987 kvstore_config.internal_store = &tdb_internal; 00988 00989 ret = kvstore_config.internal_store->init(); 00990 if (ret != MBED_SUCCESS) { 00991 tr_error("KV Config: Fail to init internal TDBStore"); 00992 return ret; 00993 } 00994 00995 bd_size_t size = MBED_CONF_STORAGE_FILESYSTEM_EXTERNAL_SIZE; 00996 bd_addr_t address = MBED_CONF_STORAGE_FILESYSTEM_EXTERNAL_BASE_ADDRESS; 00997 const char *mount_point = STR(MBED_CONF_STORAGE_FILESYSTEM_MOUNT_POINT); 00998 00999 //Get external block device for FileSystem. 01000 kvstore_config.external_bd = GET_BLOCKDEVICE(MBED_CONF_STORAGE_FILESYSTEM_BLOCKDEVICE, address, size); 01001 if (kvstore_config.external_bd == NULL) { 01002 tr_error("KV Config: Fail to get external BlockDevice "); 01003 return MBED_ERROR_FAILED_OPERATION ; 01004 } 01005 01006 ret = kvstore_config.external_bd->init(); 01007 if (MBED_SUCCESS != ret) { 01008 tr_error("KV Config: Fail to init external BlockDevice "); 01009 return MBED_ERROR_FAILED_OPERATION ; 01010 } 01011 01012 //Get FileSystem. Can be FAT, LITTLE or default. in case of default, the type will be decided base on the default 01013 //component block device configured in the system. The priority is: 01014 //QSPI -> SPI -> DATAFLASH == LITTLE 01015 //SD == FAT 01016 kvstore_config.external_fs = GET_FILESYSTEM(MBED_CONF_STORAGE_FILESYSTEM_FILESYSTEM, mount_point); 01017 if (kvstore_config.external_fs == NULL) { 01018 tr_error("KV Config: Fail to get FileSystem"); 01019 return MBED_ERROR_FAILED_OPERATION ; 01020 } 01021 01022 kvstore_config.flags_mask = ~(0); 01023 01024 return _storage_config_filesystem_common(); 01025 } 01026 01027 int _storage_config_FILESYSTEM_NO_RBP() 01028 { 01029 #if !SECURESTORE_ENABLED 01030 return MBED_ERROR_UNSUPPORTED; 01031 #endif 01032 01033 filesystemstore_folder_path = STR(MBED_CONF_STORAGE_FILESYSTEM_NO_RBP_FOLDER_PATH); 01034 01035 bd_size_t size = MBED_CONF_STORAGE_FILESYSTEM_NO_RBP_EXTERNAL_SIZE; 01036 bd_addr_t address = MBED_CONF_STORAGE_FILESYSTEM_NO_RBP_EXTERNAL_BASE_ADDRESS; 01037 const char *mount_point = STR(MBED_CONF_STORAGE_FILESYSTEM_NO_RBP_MOUNT_POINT); 01038 01039 //Get external block device for FileSystem. 01040 kvstore_config.external_bd = GET_BLOCKDEVICE(MBED_CONF_STORAGE_FILESYSTEM_NO_RBP_BLOCKDEVICE, address, size); 01041 if (kvstore_config.external_bd == NULL) { 01042 tr_error("KV Config: Fail to get external BlockDevice "); 01043 return MBED_ERROR_FAILED_OPERATION ; 01044 } 01045 01046 int ret = kvstore_config.external_bd->init(); 01047 if (MBED_SUCCESS != ret) { 01048 tr_error("KV Config: Fail to init external BlockDevice "); 01049 return MBED_ERROR_FAILED_OPERATION ; 01050 } 01051 01052 //Get FileSystem. Can be FAT, LITTLE or default. in case of default, the type will be decided base on the default 01053 //component block device configured in the system. The priority is: 01054 //QSPI -> SPI -> DATAFLASH == LITTLE 01055 //SD == FAT 01056 kvstore_config.external_fs = GET_FILESYSTEM(MBED_CONF_STORAGE_FILESYSTEM_NO_RBP_FILESYSTEM, mount_point); 01057 if (kvstore_config.external_fs == NULL) { 01058 tr_error("KV Config: Fail to get FileSystem"); 01059 return MBED_ERROR_FAILED_OPERATION ; 01060 } 01061 01062 //Masking flag - Actually used to remove any KVStore flag which is not supported 01063 //in the chosen KVStore profile. 01064 kvstore_config.flags_mask = ~(KVStore::REQUIRE_REPLAY_PROTECTION_FLAG); 01065 01066 return _storage_config_filesystem_common(); 01067 } 01068 01069 int _storage_config_filesystem_common() 01070 { 01071 #if SECURESTORE_ENABLED 01072 01073 //Mount file system. if it fails, try to reformat 01074 int ret = kvstore_config.external_fs->mount(kvstore_config.external_bd); 01075 if (ret != MBED_SUCCESS) { 01076 ret = kvstore_config.external_fs->reformat(kvstore_config.external_bd); 01077 if (ret != MBED_SUCCESS) { 01078 tr_error("KV Config: Fail to mount FileSystem to %s", 01079 STR(MBED_CONF_STORAGE_FILESYSTEM_NO_RBP_MOUNT_POINT)); 01080 return MBED_ERROR_FAILED_OPERATION ; 01081 } 01082 } 01083 01084 //Create FileSystemStore 01085 kvstore_config.external_store = _get_file_system_store(kvstore_config.external_fs); 01086 if (kvstore_config.external_store == NULL) { 01087 tr_error("KV Config: Fail to get FileSystemStore"); 01088 return MBED_ERROR_FAILED_OPERATION ; 01089 } 01090 01091 //Create SecureStore and set it as main KVStore 01092 static SecureStore secst(kvstore_config.external_store, kvstore_config.internal_store); 01093 01094 ret = secst.init(); 01095 if (ret != MBED_SUCCESS) { 01096 tr_error("KV Config: Fail to init SecureStore."); 01097 return ret; ; 01098 } 01099 01100 kvstore_config.kvstore_main_instance = &secst; 01101 01102 //Init kv_map and add the configuration struct to KVStore map. 01103 KVMap &kv_map = KVMap::get_instance(); 01104 ret = kv_map.init(); 01105 if (MBED_SUCCESS != ret) { 01106 tr_error("KV Config: Fail to init KVStore global API"); 01107 return ret; 01108 } 01109 01110 ret = kv_map.attach(STR(MBED_CONF_STORAGE_DEFAULT_KV), &kvstore_config); 01111 if (MBED_SUCCESS != ret) { 01112 tr_error("KV Config: Fail to attach KvStore main instance to KVStore global API"); 01113 return ret; 01114 } 01115 01116 return MBED_SUCCESS; 01117 #else 01118 return MBED_ERROR_UNSUPPORTED; 01119 #endif 01120 } 01121 01122 int _storage_config_default() 01123 { 01124 #if COMPONENT_QSPIF || COMPONENT_SPIF || COMPONENT_DATAFLASH 01125 return _storage_config_TDB_EXTERNAL(); 01126 #elif (COMPONENT_SD || COMPONENT_RZ_SDHI) 01127 return _storage_config_FILESYSTEM(); 01128 #elif COMPONENT_FLASHIAP 01129 return _storage_config_TDB_INTERNAL(); 01130 #else 01131 return MBED_ERROR_UNSUPPORTED; 01132 #endif 01133 } 01134 01135 const char *get_filesystemstore_folder_path() 01136 { 01137 return filesystemstore_folder_path; 01138 } 01139 01140 MBED_WEAK int kv_init_storage_config() 01141 { 01142 01143 int ret = MBED_SUCCESS; 01144 01145 // We currently have no supported configuration without internal storage 01146 #ifndef COMPONENT_FLASHIAP 01147 return MBED_ERROR_UNSUPPORTED; 01148 #endif 01149 01150 mutex->lock(); 01151 01152 if (is_kv_config_initialize) { 01153 goto exit; 01154 } 01155 01156 memset(&kvstore_config, 0, sizeof(kvstore_config_t)); 01157 01158 ret = _STORAGE_CONFIG(MBED_CONF_STORAGE_STORAGE_TYPE); 01159 01160 if (ret == MBED_SUCCESS) { 01161 is_kv_config_initialize = true; 01162 } 01163 01164 exit: 01165 mutex->unlock(); 01166 return ret; 01167 }
Generated on Sun Jul 17 2022 03:41:56 by
1.7.2