diff --git a/.astyleignore b/.astyleignore index 90f137f81f..85d2551aa2 100644 --- a/.astyleignore +++ b/.astyleignore @@ -31,3 +31,4 @@ ^TESTS/mbed_hal/trng/pithy ^TESTS/mbed_hal/trng/pithy ^tools +^UNITTESTS diff --git a/UNITTESTS/CMakeLists.txt b/UNITTESTS/CMakeLists.txt index 9b395daaca..f39dab41bf 100644 --- a/UNITTESTS/CMakeLists.txt +++ b/UNITTESTS/CMakeLists.txt @@ -76,7 +76,7 @@ if (COVERAGE) endif() # Append coverage compiler flags - set(COVERAGE_COMPILER_FLAGS "-g -O0 --coverage -fprofile-arcs -ftest-coverage") + set(COVERAGE_COMPILER_FLAGS "-g -O0 --coverage") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${COVERAGE_COMPILER_FLAGS}") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${COVERAGE_COMPILER_FLAGS}") diff --git a/UNITTESTS/empty_baseline/empty_baseline.cpp b/UNITTESTS/empty_baseline/empty_baseline.cpp new file mode 100644 index 0000000000..a44075c7da --- /dev/null +++ b/UNITTESTS/empty_baseline/empty_baseline.cpp @@ -0,0 +1,39 @@ +/* Copyright (c) 2019 ARM Limited + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "gtest/gtest.h" + +/* + * Purpose of this test is just to be empty baseline + * that does nothing, but includes all source files + * in the build. + * Do not add any tests here + */ + +class EmptyBaseline : public testing::Test { + virtual void SetUp() + { + } + + virtual void TearDown() + { + } +}; + +TEST_F(EmptyBaseline, constructor) +{ + EXPECT_TRUE(true); +} diff --git a/UNITTESTS/empty_baseline/unittest.cmake b/UNITTESTS/empty_baseline/unittest.cmake new file mode 100644 index 0000000000..ce761c11b2 --- /dev/null +++ b/UNITTESTS/empty_baseline/unittest.cmake @@ -0,0 +1,54 @@ + +#################### +# UNIT TESTS +#################### + +set(unittest-includes ${unittest-includes} + . + .. + ../features/mbedtls/mbed-crypto/inc/mbedtls/ + ../features/mbedtls/platform/inc/ + ../features/frameworks/mbed-trace/mbed-trace/ +) + +set(unittest-sources + ../features/device_key/source/DeviceKey.cpp + ../components/storage/blockdevice/COMPONENT_SPIF/SPIFBlockDevice.cpp + ../components/storage/blockdevice/COMPONENT_I2CEE/I2CEEBlockDevice.cpp + ../components/storage/blockdevice/COMPONENT_DATAFLASH/DataFlashBlockDevice.cpp + ../components/storage/blockdevice/COMPONENT_FLASHIAP/FlashIAPBlockDevice.cpp + ../components/storage/blockdevice/COMPONENT_RSPIF/SPIFReducedBlockDevice.cpp + ../components/storage/blockdevice/COMPONENT_SD/SDBlockDevice.cpp + ../components/storage/blockdevice/COMPONENT_QSPIF/QSPIFBlockDevice.cpp + ../features/storage/filesystem/Dir.cpp + ../features/storage/filesystem/FileSystem.cpp + ../features/storage/filesystem/File.cpp + ../features/storage/kvstore/global_api/kvstore_global_api.cpp + ../features/storage/kvstore/securestore/SecureStore.cpp + ../features/storage/kvstore/kv_map/KVMap.cpp + ../features/storage/kvstore/tdbstore/TDBStore.cpp + ../features/storage/kvstore/direct_access_devicekey/DirectAccessDevicekey.cpp + ../features/storage/kvstore/conf/kv_config.cpp + ../features/storage/kvstore/filesystemstore/FileSystemStore.cpp + ../features/storage/system_storage/SystemStorage.cpp + ../features/storage/nvstore/source/nvstore.cpp + ../features/storage/blockdevice/ChainingBlockDevice.cpp + ../features/storage/blockdevice/ReadOnlyBlockDevice.cpp + ../features/storage/blockdevice/SlicingBlockDevice.cpp + ../features/storage/blockdevice/MBRBlockDevice.cpp + ../features/storage/blockdevice/HeapBlockDevice.cpp + ../features/storage/blockdevice/FlashSimBlockDevice.cpp + ../features/storage/blockdevice/ObservingBlockDevice.cpp + ../features/storage/blockdevice/ProfilingBlockDevice.cpp + ../features/storage/blockdevice/BufferedBlockDevice.cpp + ../features/storage/blockdevice/ExhaustibleBlockDevice.cpp +) + +set(unittest-test-sources + empty_baseline/empty_baseline.cpp +) + +set(DEVICE_FLAGS "-DDEVICE_ANALOGIN -DDEVICE_ANALOGOUT -DDEVICE_CAN -DDEVICE_CRC -DDEVICE_ETHERNET -DDEVICE_FLASH -DDEVICE_I2C -DDEVICE_I2CSLAVE -DDEVICE_I2C_ASYNCH -DDEVICE_INTERRUPTIN -DDEVICE_LPTICKER -DDEVICE_PORTIN -DDEVICE_PORTINOUT -DDEVICE_PORTOUT -DDEVICE_PWMOUT -DDEVICE_QSPI -DDEVICE_SERIAL -DDEVICE_SERIAL_ASYNCH -DDEVICE_SERIAL_FC -DDEVICE_SPI -DDEVICE_SPISLAVE -DDEVICE_SPI_ASYNCH -DDEVICE_FLASH -DCOMPONENT_FLASHIAP") +set(CONF_FLAGS "-DMBED_CONF_PLATFORM_CTHUNK_COUNT_MAX=10 -DMBED_CONF_DATAFLASH_SPI_FREQ=1 -DMBED_CONF_FLASHIAP_BLOCK_DEVICE_BASE_ADDRESS=0 -DMBED_CONF_FLASHIAP_BLOCK_DEVICE_SIZE=0 -DMBED_CONF_QSPIF_QSPI_FREQ=1 -DMBED_CONF_QSPIF_QSPI_MIN_READ_SIZE=1 -DMBED_CONF_QSPIF_QSPI_MIN_PROG_SIZE=1 -DMBED_LFS_READ_SIZE=64 -DMBED_LFS_PROG_SIZE=64 -DMBED_LFS_BLOCK_SIZE=512 -DMBED_LFS_LOOKAHEAD=512 -DFLASHIAP_APP_ROM_END_ADDR=0x80000 -DMBED_CONF_STORAGE_TDB_INTERNAL_INTERNAL_SIZE=1024 -DMBED_CONF_STORAGE_TDB_INTERNAL_INTERNAL_BASE_ADDRESS=0x80000 -DMBED_CONF_STORAGE_STORAGE_TYPE=default") +set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${DEVICE_FLAGS} ${CONF_FLAGS}") +set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${DEVICE_FLAGS} ${CONF_FLAGS}") diff --git a/UNITTESTS/features/storage/blockdevice/HeapBlockDevice/test.cpp b/UNITTESTS/features/storage/blockdevice/HeapBlockDevice/test.cpp new file mode 100644 index 0000000000..659b47b462 --- /dev/null +++ b/UNITTESTS/features/storage/blockdevice/HeapBlockDevice/test.cpp @@ -0,0 +1,120 @@ +/* Copyright (c) 2019 ARM Limited + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "gtest/gtest.h" +#include "features/storage/blockdevice/HeapBlockDevice.h" +#include +#include "mbed_assert.h" + +#define BLOCK_SIZE (512) +#define DEVICE_SIZE (BLOCK_SIZE*10) + +class HeapBlockDeviceTest : public testing::Test { +protected: + virtual void SetUp() + { + bd.init(); + } + + virtual void TearDown() + { + bd.deinit(); + } + + mbed::HeapBlockDevice bd{DEVICE_SIZE}; +}; + +TEST_F(HeapBlockDeviceTest, constructor) +{ + // HeapBlockDevice(bd_size_t size, bd_size_t read, bd_size_t program, bd_size_t erase); + mbed::HeapBlockDevice one{3000, 100, 200, 300}; + EXPECT_EQ(one.init(), BD_ERROR_OK); + EXPECT_EQ(one.size(), 3000); + EXPECT_EQ(one.get_read_size(), 100); + EXPECT_EQ(one.get_program_size(), 200); + EXPECT_EQ(one.get_erase_size(), 300); + EXPECT_EQ(one.get_erase_size(0), 300); + EXPECT_EQ(one.deinit(), BD_ERROR_OK); +} + +TEST_F(HeapBlockDeviceTest, double_init) +{ + mbed::HeapBlockDevice one{DEVICE_SIZE}; + EXPECT_EQ(one.init(), BD_ERROR_OK); + EXPECT_EQ(one.init(), BD_ERROR_OK); + EXPECT_EQ(one.deinit(), BD_ERROR_OK); // First de-init does only decrement the counter + EXPECT_EQ(one.deinit(), BD_ERROR_OK); + EXPECT_EQ(one.deinit(), BD_ERROR_OK); //Third one does not de-init, but return immediately +} + +TEST_F(HeapBlockDeviceTest, get_type) +{ + EXPECT_EQ(0, strcmp(bd.get_type(), "HEAP")); +} + +TEST_F(HeapBlockDeviceTest, erase_program_read) +{ + uint8_t *block = new uint8_t[BLOCK_SIZE] {0xaa,0xbb,0xcc}; + uint8_t *buf = new uint8_t[BLOCK_SIZE]; + EXPECT_EQ(bd.erase(0, BLOCK_SIZE), BD_ERROR_OK); + EXPECT_EQ(bd.program(block, 0, BLOCK_SIZE), BD_ERROR_OK); + EXPECT_EQ(bd.read(buf, 0, BLOCK_SIZE), BD_ERROR_OK); + EXPECT_EQ(0, memcmp(block, buf, BLOCK_SIZE)); + delete[] block; + delete[] buf; +} + +TEST_F(HeapBlockDeviceTest, use_uninitialized) +{ + mbed::HeapBlockDevice one{DEVICE_SIZE}; + uint8_t *buf = new uint8_t[BLOCK_SIZE]; + EXPECT_EQ(one.read(buf, 0, BLOCK_SIZE), BD_ERROR_DEVICE_ERROR); + EXPECT_EQ(one.program(buf, 0, BLOCK_SIZE), BD_ERROR_DEVICE_ERROR); + delete[] buf; +} + +TEST_F(HeapBlockDeviceTest, over_read) +{ + uint8_t *buf = new uint8_t[BLOCK_SIZE]; + EXPECT_EQ(bd.read(buf, DEVICE_SIZE, BLOCK_SIZE), BD_ERROR_DEVICE_ERROR); + delete[] buf; +} + +TEST_F(HeapBlockDeviceTest, over_write) +{ + uint8_t *buf = new uint8_t[BLOCK_SIZE] {0xaa,0xbb,0xcc}; + EXPECT_EQ(bd.program(buf, DEVICE_SIZE, BLOCK_SIZE), BD_ERROR_DEVICE_ERROR); + delete[] buf; +} + +TEST_F(HeapBlockDeviceTest, over_erase) +{ + EXPECT_EQ(bd.erase(DEVICE_SIZE, BLOCK_SIZE), BD_ERROR_DEVICE_ERROR); +} + +TEST_F(HeapBlockDeviceTest, erase_uninitialized) +{ + mbed::HeapBlockDevice one{DEVICE_SIZE}; + EXPECT_EQ(one.erase(DEVICE_SIZE, BLOCK_SIZE), BD_ERROR_DEVICE_ERROR); +} + +TEST_F(HeapBlockDeviceTest, read_unprogrammed) +{ + uint8_t *buf = new uint8_t[BLOCK_SIZE]; + EXPECT_EQ(bd.read(buf, DEVICE_SIZE - BLOCK_SIZE, BLOCK_SIZE), BD_ERROR_OK); + // Ignore the content, it is now zero, but does not need to be. + delete[] buf; +} diff --git a/UNITTESTS/features/storage/blockdevice/HeapBlockDevice/unittest.cmake b/UNITTESTS/features/storage/blockdevice/HeapBlockDevice/unittest.cmake new file mode 100644 index 0000000000..1fa05847f3 --- /dev/null +++ b/UNITTESTS/features/storage/blockdevice/HeapBlockDevice/unittest.cmake @@ -0,0 +1,19 @@ + +#################### +# UNIT TESTS +#################### + +set(unittest-includes ${unittest-includes} + . + .. +) + +set(unittest-sources + ../features/storage/blockdevice/HeapBlockDevice.cpp + stubs/mbed_atomic_stub.c + stubs/mbed_assert_stub.c +) + +set(unittest-test-sources + features/storage/blockdevice/HeapBlockDevice/test.cpp +) diff --git a/UNITTESTS/moduletests/storage/blockdevice/SlicingBlockDevice/moduletest.cpp b/UNITTESTS/moduletests/storage/blockdevice/SlicingBlockDevice/moduletest.cpp new file mode 100644 index 0000000000..ff4c995761 --- /dev/null +++ b/UNITTESTS/moduletests/storage/blockdevice/SlicingBlockDevice/moduletest.cpp @@ -0,0 +1,161 @@ +/* Copyright (c) 2019 ARM Limited + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "gtest/gtest.h" +#include "features/storage/blockdevice/HeapBlockDevice.h" +#include "features/storage/blockdevice/SlicingBlockDevice.h" + +#define BLOCK_SIZE (512) +#define DEVICE_SIZE (BLOCK_SIZE*10) + +class VerifyBorders_HeapBlockDevice : public mbed::HeapBlockDevice { +public: + mutable bool borders_crossed; + mutable bd_size_t lower_limit; + mutable bd_size_t upper_limit; + + VerifyBorders_HeapBlockDevice(bd_size_t size) + : HeapBlockDevice(size) + { + borders_crossed = false; + lower_limit = 0; + upper_limit = size; + } + + virtual bool is_valid_read(bd_addr_t addr, bd_size_t size) const + { + borders_crossed |= addr < lower_limit; + borders_crossed |= addr + size > upper_limit; + return BlockDevice::is_valid_read(addr, size); + } + + virtual bool is_valid_program(bd_addr_t addr, bd_size_t size) const + { + borders_crossed |= addr < lower_limit; + borders_crossed |= addr + size > upper_limit; + return BlockDevice::is_valid_program(addr, size); + } + + virtual bool is_valid_erase(bd_addr_t addr, bd_size_t size) const + { + borders_crossed |= addr < lower_limit; + borders_crossed |= addr + size > upper_limit; + return BlockDevice::is_valid_erase(addr, size); + } +}; + +class SlicingBlockModuleTest : public testing::Test { +protected: + VerifyBorders_HeapBlockDevice bd{DEVICE_SIZE}; + uint8_t *magic; + uint8_t *buf; + virtual void SetUp() + { + bd.init(); + magic = new uint8_t[BLOCK_SIZE]; + buf = new uint8_t[BLOCK_SIZE]; + // Generate simple pattern to verify against + for (int i = 0; i < BLOCK_SIZE; i++) { + magic[i] = 0xaa + i; + } + } + + virtual void TearDown() + { + bd.deinit(); + delete[] magic; + delete[] buf; + } +}; + +TEST_F(SlicingBlockModuleTest, constructor) +{ + mbed::SlicingBlockDevice slice(&bd, 0, bd.size()); + EXPECT_EQ(slice.init(), BD_ERROR_OK); + EXPECT_EQ(slice.get_read_size(), bd.get_read_size()); + EXPECT_EQ(slice.get_program_size(), bd.get_read_size()); + EXPECT_EQ(slice.get_erase_size(), bd.get_read_size()); + EXPECT_EQ(slice.get_erase_size(0), bd.get_read_size()); + EXPECT_EQ(slice.deinit(), BD_ERROR_OK); +} + +TEST_F(SlicingBlockModuleTest, slice_in_middle) +{ + uint8_t *program = new uint8_t[BLOCK_SIZE] {0xbb,0xbb,0xbb}; + + //Write magic value to heap block before and after the space for slice + bd.program(magic, 0, BLOCK_SIZE); + bd.program(magic, BLOCK_SIZE * 3, BLOCK_SIZE); + + bd.upper_limit = BLOCK_SIZE * 3; + bd.lower_limit = BLOCK_SIZE; + bd.borders_crossed = false; + + //Skip first block, then create sclicing device, with size of 2 blocks + mbed::SlicingBlockDevice slice(&bd, BLOCK_SIZE, BLOCK_SIZE * 3); + EXPECT_EQ(slice.init(), BD_ERROR_OK); + EXPECT_EQ(BLOCK_SIZE * 2, slice.size()); + EXPECT_EQ(bd.borders_crossed, false); + + //Program a test value + EXPECT_EQ(slice.program(program, 0, BLOCK_SIZE), BD_ERROR_OK); + EXPECT_EQ(slice.program(program, BLOCK_SIZE, BLOCK_SIZE), BD_ERROR_OK); + EXPECT_EQ(bd.borders_crossed, false); + + //Verify that blocks before and after the slicing blocks are not touched + bd.read(buf, 0, BLOCK_SIZE); + EXPECT_EQ(0, memcmp(buf, magic, BLOCK_SIZE)); + bd.read(buf, BLOCK_SIZE * 3, BLOCK_SIZE); + EXPECT_EQ(0, memcmp(buf, magic, BLOCK_SIZE)); +} + +TEST_F(SlicingBlockModuleTest, slice_at_the_end) +{ + uint8_t *program = new uint8_t[BLOCK_SIZE] {0xbb,0xbb,0xbb}; + + //Write magic value to heap block before the space for slice + // our bd is 10*BLOCK_SIZE, so sector 7 + bd.program(magic, BLOCK_SIZE * 7, BLOCK_SIZE); + + //Screate sclicing device, with size of 2 blocks + // Use negative index + mbed::SlicingBlockDevice slice(&bd, -BLOCK_SIZE*2); + EXPECT_EQ(slice.init(), BD_ERROR_OK); + EXPECT_EQ(BLOCK_SIZE * 2, slice.size()); + + //Program a test value + EXPECT_EQ(slice.program(program, 0, BLOCK_SIZE), BD_ERROR_OK); + EXPECT_EQ(slice.program(program, BLOCK_SIZE, BLOCK_SIZE), BD_ERROR_OK); + + //Verify that blocks before and after the slicing blocks are not touched + bd.read(buf, BLOCK_SIZE * 7, BLOCK_SIZE); + EXPECT_EQ(0, memcmp(buf, magic, BLOCK_SIZE)); +} + +TEST_F(SlicingBlockModuleTest, over_write) +{ + uint8_t *program = new uint8_t[BLOCK_SIZE] {0xbb,0xbb,0xbb}; + + //Screate sclicing device, with size of 2 blocks + mbed::SlicingBlockDevice slice(&bd, BLOCK_SIZE, BLOCK_SIZE * 3); + EXPECT_EQ(slice.init(), BD_ERROR_OK); + + EXPECT_EQ(slice.program(program, 0, BLOCK_SIZE), BD_ERROR_OK); + EXPECT_EQ(slice.program(program, BLOCK_SIZE, BLOCK_SIZE), BD_ERROR_OK); + //Program a test value to address that is one pass the device size + EXPECT_EQ(slice.program(program, 2 * BLOCK_SIZE, BLOCK_SIZE), BD_ERROR_DEVICE_ERROR); + delete[] program; +} diff --git a/UNITTESTS/moduletests/storage/blockdevice/SlicingBlockDevice/unittest.cmake b/UNITTESTS/moduletests/storage/blockdevice/SlicingBlockDevice/unittest.cmake new file mode 100644 index 0000000000..93285d0a13 --- /dev/null +++ b/UNITTESTS/moduletests/storage/blockdevice/SlicingBlockDevice/unittest.cmake @@ -0,0 +1,20 @@ + +#################### +# UNIT TESTS +#################### + +set(unittest-includes ${unittest-includes} + . + .. +) + +set(unittest-sources + ../features/storage/blockdevice/SlicingBlockDevice.cpp + ../features/storage/blockdevice/HeapBlockDevice.cpp + stubs/mbed_atomic_stub.c + stubs/mbed_assert_stub.c +) + +set(unittest-test-sources + moduletests/storage/blockdevice/SlicingBlockDevice/moduletest.cpp +) diff --git a/UNITTESTS/stubs/mbed_atomic_stub.c b/UNITTESTS/stubs/mbed_atomic_stub.c index 819a6ed4d4..3767101b04 100644 --- a/UNITTESTS/stubs/mbed_atomic_stub.c +++ b/UNITTESTS/stubs/mbed_atomic_stub.c @@ -57,113 +57,143 @@ uint32_t core_util_atomic_exchange_u32(volatile uint32_t *ptr, uint32_t desiredV uint8_t core_util_atomic_incr_u8(volatile uint8_t *valuePtr, uint8_t delta) { - return 0; + return *valuePtr += delta; } uint16_t core_util_atomic_incr_u16(volatile uint16_t *valuePtr, uint16_t delta) { - return 0; + return *valuePtr += delta; } uint32_t core_util_atomic_incr_u32(volatile uint32_t *valuePtr, uint32_t delta) { - return 0; + return *valuePtr += delta; } uint8_t core_util_atomic_decr_u8(volatile uint8_t *valuePtr, uint8_t delta) { - return 0; + return *valuePtr -= delta; } uint16_t core_util_atomic_decr_u16(volatile uint16_t *valuePtr, uint16_t delta) { - return 0; + return *valuePtr -= delta; } uint32_t core_util_atomic_decr_u32(volatile uint32_t *valuePtr, uint32_t delta) { - return 0; + return *valuePtr -= delta; } uint8_t core_util_atomic_fetch_add_u8(volatile uint8_t *valuePtr, uint8_t arg) { - return 0; + uint8_t v = *valuePtr; + *valuePtr += arg; + return v; } uint16_t core_util_atomic_fetch_add_u16(volatile uint16_t *valuePtr, uint16_t arg) { - return 0; + uint16_t v = *valuePtr; + *valuePtr += arg; + return v; } uint32_t core_util_atomic_fetch_add_u32(volatile uint32_t *valuePtr, uint32_t arg) { - return 0; + uint32_t v = *valuePtr; + *valuePtr += arg; + return v; } uint8_t core_util_atomic_fetch_sub_u8(volatile uint8_t *valuePtr, uint8_t arg) { - return 0; + uint8_t v = *valuePtr; + *valuePtr -= arg; + return v; } uint16_t core_util_atomic_fetch_sub_u16(volatile uint16_t *valuePtr, uint16_t arg) { - return 0; + uint16_t v = *valuePtr; + *valuePtr -= arg; + return v; } uint32_t core_util_atomic_fetch_sub_u32(volatile uint32_t *valuePtr, uint32_t arg) { - return 0; + uint32_t v = *valuePtr; + *valuePtr -= arg; + return v; } uint8_t core_util_atomic_fetch_and_u8(volatile uint8_t *valuePtr, uint8_t arg) { - return 0; + uint8_t v = *valuePtr; + *valuePtr &= arg; + return v; } uint16_t core_util_atomic_fetch_and_u16(volatile uint16_t *valuePtr, uint16_t arg) { - return 0; + uint16_t v = *valuePtr; + *valuePtr &= arg; + return v; } uint32_t core_util_atomic_fetch_and_u32(volatile uint32_t *valuePtr, uint32_t arg) { - return 0; + uint32_t v = *valuePtr; + *valuePtr &= arg; + return v; } uint8_t core_util_atomic_fetch_or_u8(volatile uint8_t *valuePtr, uint8_t arg) { - return 0; + uint8_t v = *valuePtr; + *valuePtr |= arg; + return v; } uint16_t core_util_atomic_fetch_or_u16(volatile uint16_t *valuePtr, uint16_t arg) { - return 0; + uint16_t v = *valuePtr; + *valuePtr |= arg; + return v; } uint32_t core_util_atomic_fetch_or_u32(volatile uint32_t *valuePtr, uint32_t arg) { - return 0; + uint32_t v = *valuePtr; + *valuePtr |= arg; + return v; } uint8_t core_util_atomic_fetch_xor_u8(volatile uint8_t *valuePtr, uint8_t arg) { - return 0; + uint8_t v = *valuePtr; + *valuePtr ^= arg; + return v; } uint16_t core_util_atomic_fetch_xor_u16(volatile uint16_t *valuePtr, uint16_t arg) { - return 0; + uint16_t v = *valuePtr; + *valuePtr ^= arg; + return v; } uint32_t core_util_atomic_fetch_xor_u32(volatile uint32_t *valuePtr, uint32_t arg) { - return 0; + uint32_t v = *valuePtr; + *valuePtr ^= arg; + return v; } diff --git a/UNITTESTS/target_h/PinNames.h b/UNITTESTS/target_h/PinNames.h index f580d15ae6..745ddda119 100644 --- a/UNITTESTS/target_h/PinNames.h +++ b/UNITTESTS/target_h/PinNames.h @@ -40,8 +40,13 @@ typedef enum { PullDefault = PullUp } PinMode; +typedef enum { + PortA = 0, +} PortName; + #ifdef __cplusplus } #endif +#include "pinmap.h" #endif diff --git a/UNITTESTS/target_h/cmsis_os2.h b/UNITTESTS/target_h/cmsis_os2.h index bb05b7dc99..6c7d6d3059 100644 --- a/UNITTESTS/target_h/cmsis_os2.h +++ b/UNITTESTS/target_h/cmsis_os2.h @@ -64,6 +64,7 @@ typedef void *osEventFlagsId_t; /// Attributes structure for thread. typedef struct { + int unused; } osThreadAttr_t; #define osWaitForever 0xFFFFFFFFU ///< Wait forever timeout value. diff --git a/UNITTESTS/target_h/device.h b/UNITTESTS/target_h/device.h index 80d55afd91..c052aa04bd 100644 --- a/UNITTESTS/target_h/device.h +++ b/UNITTESTS/target_h/device.h @@ -19,5 +19,6 @@ #define MBED_DEVICE_H #include "objects.h" +#include "PinNames.h" #endif diff --git a/UNITTESTS/target_h/gpio_object.h b/UNITTESTS/target_h/gpio_object.h index a344bb316b..9f31aeb9b3 100644 --- a/UNITTESTS/target_h/gpio_object.h +++ b/UNITTESTS/target_h/gpio_object.h @@ -27,6 +27,7 @@ extern "C" { #endif typedef struct { + int unused; } gpio_t; #ifdef __cplusplus diff --git a/UNITTESTS/target_h/objects.h b/UNITTESTS/target_h/objects.h index 13f95e1992..23a634db26 100644 --- a/UNITTESTS/target_h/objects.h +++ b/UNITTESTS/target_h/objects.h @@ -34,11 +34,41 @@ struct serial_s { int x; }; -struct pwmout_s { - int pwm_name; +struct dac_s { + int unused; }; +struct i2c_s { + int unused; +}; +struct qspi_s { + int unused; +}; + +struct spi_s { + int unused; +}; + +struct analogin_s { + int unused; +}; + +struct port_s { + int unused; +}; + +struct pwmout_s { + int unused; +}; + +struct flash_s { + int unused; +}; + +struct can_s { + int unused; +}; #include "gpio_object.h" diff --git a/UNITTESTS/target_h/platform/CThunk.h b/UNITTESTS/target_h/platform/CThunk.h new file mode 100644 index 0000000000..79e19aa72e --- /dev/null +++ b/UNITTESTS/target_h/platform/CThunk.h @@ -0,0 +1,52 @@ +/* Copyright (c) 2019 ARM Limited + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef __CTHUNK_H__ +#define __CTHUNK_H__ + +/** + * Class for created a pointer with data bound to it + * + * @note Synchronization level: Not protected + */ +template +class CThunk { +public: + typedef void (T::*CCallbackSimple)(void); + typedef void (T::*CCallback)(void *context); + CThunk() + {} + CThunk(T *instance) + {} + CThunk(T &instance) + {} + void callback(CCallback callback) + {} + + void callback(CCallbackSimple callback) + { + } + uint32_t entry(void) + { + + return 0; + } +}; + + +#endif/*__CTHUNK_H__*/ + + diff --git a/UNITTESTS/target_h/platform/mbed_power_mgmt.h b/UNITTESTS/target_h/platform/mbed_power_mgmt.h index 5ebb18c095..a8e83f756b 100644 --- a/UNITTESTS/target_h/platform/mbed_power_mgmt.h +++ b/UNITTESTS/target_h/platform/mbed_power_mgmt.h @@ -24,7 +24,7 @@ extern void mock_system_reset(); -MBED_NORETURN static inline void system_reset(void) +static inline void system_reset(void) { mock_system_reset(); } diff --git a/UNITTESTS/target_h/rtos/Semaphore.h b/UNITTESTS/target_h/rtos/Semaphore.h index 34e472dea6..e0051f2b0e 100644 --- a/UNITTESTS/target_h/rtos/Semaphore.h +++ b/UNITTESTS/target_h/rtos/Semaphore.h @@ -1,5 +1,4 @@ -/* - * Copyright (c) , Arm Limited and affiliates. +/* Copyright (c) 2019 ARM Limited * SPDX-License-Identifier: Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -15,4 +14,23 @@ * limitations under the License. */ -typedef void *Semaphore; +#ifndef SEMAPHORE_H +#define SEMAPHORE_H + +#include +#include "cmsis_os2.h" + +namespace rtos { +class Semaphore { +public: + Semaphore(int32_t count = 0) {}; + Semaphore(int32_t count, uint16_t max_count) {}; + void acquire() {}; + bool try_acquire() { return false; }; + bool try_acquire_for(uint32_t millisec) { return false; }; + bool try_acquire_until(uint64_t millisec) { return false; }; + osStatus release(void) {return 0;}; +}; +} + +#endif diff --git a/UNITTESTS/target_h/rtos/Thread.h b/UNITTESTS/target_h/rtos/Thread.h new file mode 100644 index 0000000000..c0e3ba9d74 --- /dev/null +++ b/UNITTESTS/target_h/rtos/Thread.h @@ -0,0 +1,101 @@ +/* + * Copyright (c) 2019 ARM Limited + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +#ifndef THREAD_H +#define THREAD_H + +#include +#include "cmsis_os.h" + +namespace rtos { + +class Thread { +public: + + Thread(osPriority priority = osPriorityNormal, + uint32_t stack_size = OS_STACK_SIZE, + unsigned char *stack_mem = nullptr, const char *name = nullptr) + { + } + + Thread(uint32_t tz_module, osPriority priority = osPriorityNormal, + uint32_t stack_size = OS_STACK_SIZE, + unsigned char *stack_mem = nullptr, const char *name = nullptr) + { + } + + osStatus start(mbed::Callback task) { + return 0; + } + + osStatus join() {return 0;}; + osStatus terminate(){return 0;}; + osStatus set_priority(osPriority priority){return 0;}; + osPriority get_priority() const{return osPriorityNormal;}; + uint32_t flags_set(uint32_t flags){return 0;}; + + /** State of the Thread */ + enum State { + Inactive, /**< NOT USED */ + Ready, /**< Ready to run */ + Running, /**< Running */ + WaitingDelay, /**< Waiting for a delay to occur */ + WaitingJoin, /**< Waiting for thread to join. Only happens when using RTX directly. */ + WaitingThreadFlag, /**< Waiting for a thread flag to be set */ + WaitingEventFlag, /**< Waiting for a event flag to be set */ + WaitingMutex, /**< Waiting for a mutex event to occur */ + WaitingSemaphore, /**< Waiting for a semaphore event to occur */ + WaitingMemoryPool, /**< Waiting for a memory pool */ + WaitingMessageGet, /**< Waiting for message to arrive */ + WaitingMessagePut, /**< Waiting for message to be send */ + WaitingInterval, /**< NOT USED */ + WaitingOr, /**< NOT USED */ + WaitingAnd, /**< NOT USED */ + WaitingMailbox, /**< NOT USED (Mail is implemented as MemoryPool and Queue) */ + + /* Not in sync with RTX below here */ + Deleted, /**< The task has been deleted or not started */ + }; + + State get_state() const { + return Ready; + }; + uint32_t stack_size() const { + return 0; + }; + uint32_t free_stack() const { + return 0; + }; + uint32_t used_stack() const { + return 0; + }; + uint32_t max_stack() const { + return 0; + }; + const char *get_name() const { + return ""; + }; + osThreadId_t get_id() const { + return 0; + }; +}; +} +#endif diff --git a/components/storage/blockdevice/COMPONENT_DATAFLASH/DataFlashBlockDevice.cpp b/components/storage/blockdevice/COMPONENT_DATAFLASH/DataFlashBlockDevice.cpp index 4309233fcf..df859bc7f4 100644 --- a/components/storage/blockdevice/COMPONENT_DATAFLASH/DataFlashBlockDevice.cpp +++ b/components/storage/blockdevice/COMPONENT_DATAFLASH/DataFlashBlockDevice.cpp @@ -16,7 +16,7 @@ #include "DataFlashBlockDevice.h" #include "mbed_atomic.h" - +#include "rtos/ThisThread.h" #include using namespace mbed; diff --git a/components/storage/blockdevice/COMPONENT_DATAFLASH/DataFlashBlockDevice.h b/components/storage/blockdevice/COMPONENT_DATAFLASH/DataFlashBlockDevice.h index 9d0e7dbeda..9bb4d82513 100644 --- a/components/storage/blockdevice/COMPONENT_DATAFLASH/DataFlashBlockDevice.h +++ b/components/storage/blockdevice/COMPONENT_DATAFLASH/DataFlashBlockDevice.h @@ -17,8 +17,11 @@ #ifndef MBED_DATAFLASH_BLOCK_DEVICE_H #define MBED_DATAFLASH_BLOCK_DEVICE_H -#include -#include "BlockDevice.h" +#include "platform/PlatformMutex.h" +#include "PinNames.h" +#include "features/storage/blockdevice/BlockDevice.h" +#include "drivers/SPI.h" +#include "drivers/DigitalOut.h" /** BlockDevice for DataFlash flash devices diff --git a/components/storage/blockdevice/COMPONENT_FLASHIAP/FlashIAPBlockDevice.h b/components/storage/blockdevice/COMPONENT_FLASHIAP/FlashIAPBlockDevice.h index 4cb1486dc7..98cd805612 100644 --- a/components/storage/blockdevice/COMPONENT_FLASHIAP/FlashIAPBlockDevice.h +++ b/components/storage/blockdevice/COMPONENT_FLASHIAP/FlashIAPBlockDevice.h @@ -20,7 +20,7 @@ #if DEVICE_FLASH #include "FlashIAP.h" -#include "BlockDevice.h" +#include "features/storage/blockdevice/BlockDevice.h" #include "platform/mbed_toolchain.h" /** BlockDevice using the FlashIAP API diff --git a/components/storage/blockdevice/COMPONENT_I2CEE/I2CEEBlockDevice.h b/components/storage/blockdevice/COMPONENT_I2CEE/I2CEEBlockDevice.h index dbaf71b51a..4ba286676f 100644 --- a/components/storage/blockdevice/COMPONENT_I2CEE/I2CEEBlockDevice.h +++ b/components/storage/blockdevice/COMPONENT_I2CEE/I2CEEBlockDevice.h @@ -16,8 +16,8 @@ #ifndef MBED_I2CEEPROM_BLOCK_DEVICE_H #define MBED_I2CEEPROM_BLOCK_DEVICE_H -#include "BlockDevice.h" -#include "I2C.h" +#include "features/storage/blockdevice/BlockDevice.h" +#include "drivers/I2C.h" /** BlockDevice for I2C based flash device such as * Microchip's 24LC or ATMEL's AT24C ranges diff --git a/components/storage/blockdevice/COMPONENT_QSPIF/QSPIFBlockDevice.cpp b/components/storage/blockdevice/COMPONENT_QSPIF/QSPIFBlockDevice.cpp index dc1dd9e5bc..4ae242c9d5 100644 --- a/components/storage/blockdevice/COMPONENT_QSPIF/QSPIFBlockDevice.cpp +++ b/components/storage/blockdevice/COMPONENT_QSPIF/QSPIFBlockDevice.cpp @@ -119,11 +119,11 @@ QSPIFBlockDevice::QSPIFBlockDevice(PinName io0, PinName io1, PinName io2, PinNam _unique_device_status = add_new_csel_instance(csel); if (_unique_device_status == 0) { - tr_debug("Adding a new QSPIFBlockDevice csel: %d\n", (int)csel); + tr_debug("Adding a new QSPIFBlockDevice csel: %d", (int)csel); } else if (_unique_device_status == -1) { - tr_error("QSPIFBlockDevice with the same csel(%d) already exists\n", (int)csel); + tr_error("QSPIFBlockDevice with the same csel(%d) already exists", (int)csel); } else { - tr_error("Too many different QSPIFBlockDevice devices - max allowed: %d\n", QSPIF_MAX_ACTIVE_FLASH_DEVICES); + tr_error("Too many different QSPIFBlockDevice devices - max allowed: %d", QSPIF_MAX_ACTIVE_FLASH_DEVICES); } } @@ -199,7 +199,7 @@ int QSPIFBlockDevice::init() goto exit_point; } - tr_debug("Vendor device ID = 0x%x 0x%x 0x%x 0x%x \n", vendor_device_ids[0], + tr_debug("Vendor device ID = 0x%x 0x%x 0x%x 0x%x", vendor_device_ids[0], vendor_device_ids[1], vendor_device_ids[2], vendor_device_ids[3]); switch (vendor_device_ids[0]) { case 0xbf: diff --git a/components/storage/blockdevice/COMPONENT_QSPIF/QSPIFBlockDevice.h b/components/storage/blockdevice/COMPONENT_QSPIF/QSPIFBlockDevice.h index 2de80a5054..907d13135f 100644 --- a/components/storage/blockdevice/COMPONENT_QSPIF/QSPIFBlockDevice.h +++ b/components/storage/blockdevice/COMPONENT_QSPIF/QSPIFBlockDevice.h @@ -16,8 +16,8 @@ #ifndef MBED_QSPIF_BLOCK_DEVICE_H #define MBED_QSPIF_BLOCK_DEVICE_H -#include "QSPI.h" -#include "BlockDevice.h" +#include "drivers/QSPI.h" +#include "features/storage/blockdevice/BlockDevice.h" /** Enum qspif standard error codes * diff --git a/components/storage/blockdevice/COMPONENT_RSPIF/SPIFReducedBlockDevice.h b/components/storage/blockdevice/COMPONENT_RSPIF/SPIFReducedBlockDevice.h index f7dda1fe07..53bf7d83c7 100644 --- a/components/storage/blockdevice/COMPONENT_RSPIF/SPIFReducedBlockDevice.h +++ b/components/storage/blockdevice/COMPONENT_RSPIF/SPIFReducedBlockDevice.h @@ -16,9 +16,9 @@ #ifndef MBED_RSPIF_BLOCK_DEVICE_H #define MBED_RSPIF_BLOCK_DEVICE_H -#include "SPI.h" -#include "DigitalOut.h" -#include "BlockDevice.h" +#include "drivers/SPI.h" +#include "drivers/DigitalOut.h" +#include "features/storage/blockdevice/BlockDevice.h" /** Reduced BlockDevice for SPI based flash devices * *Should only be used by Boot Loader* diff --git a/components/storage/blockdevice/COMPONENT_SD/SDBlockDevice.h b/components/storage/blockdevice/COMPONENT_SD/SDBlockDevice.h index 0a19194163..08caa4fea7 100644 --- a/components/storage/blockdevice/COMPONENT_SD/SDBlockDevice.h +++ b/components/storage/blockdevice/COMPONENT_SD/SDBlockDevice.h @@ -20,7 +20,7 @@ /* If the target has no SPI support, then SD Card is not supported. */ #if DEVICE_SPI -#include "BlockDevice.h" +#include "features/storage/blockdevice/BlockDevice.h" #include "drivers/SPI.h" #include "drivers/Timer.h" #include "drivers/MbedCRC.h" diff --git a/components/storage/blockdevice/COMPONENT_SPIF/SPIFBlockDevice.cpp b/components/storage/blockdevice/COMPONENT_SPIF/SPIFBlockDevice.cpp index 6cca2538a0..b90f21e54a 100644 --- a/components/storage/blockdevice/COMPONENT_SPIF/SPIFBlockDevice.cpp +++ b/components/storage/blockdevice/COMPONENT_SPIF/SPIFBlockDevice.cpp @@ -22,7 +22,6 @@ #include #include "mbed_trace.h" -#include "mbed_debug.h" #define TRACE_GROUP "SPIF" using namespace mbed; @@ -158,7 +157,7 @@ int SPIFBlockDevice::init() status = SPIF_BD_ERROR_DEVICE_ERROR; goto exit_point; } else { - debug_if(MBED_CONF_SPIF_DRIVER_DEBUG, "DEBUG: Initialize flash memory OK\n"); + tr_debug("Initialize flash memory OK"); } /* Read Manufacturer ID (1byte), and Device ID (2bytes)*/ @@ -207,7 +206,7 @@ int SPIFBlockDevice::init() _region_high_boundary[0] = _device_size_bytes - 1; if ((sector_map_table_addr != 0) && (0 != sector_map_table_size)) { - debug_if(MBED_CONF_SPIF_DRIVER_DEBUG, "DEBUG: init - Parsing Sector Map Table - addr: 0x%" PRIx32 "h, Size: %d", sector_map_table_addr, + tr_debug("init - Parsing Sector Map Table - addr: 0x%" PRIx32 "h, Size: %d", sector_map_table_addr, sector_map_table_size); if (0 != _sfdp_parse_sector_map_table(sector_map_table_addr, sector_map_table_size)) { tr_error("init - Parse Sector Map Table Failed"); @@ -272,7 +271,7 @@ int SPIFBlockDevice::read(void *buffer, bd_addr_t addr, bd_size_t size) } int status = SPIF_BD_ERROR_OK; - debug_if(MBED_CONF_SPIF_DRIVER_DEBUG, "DEBUG Read - Inst: 0x%xh", _read_instruction); + tr_debug("Read - Inst: 0x%xh", _read_instruction); _mutex->lock(); // Set Dummy Cycles for Specific Read Command Mode @@ -298,7 +297,7 @@ int SPIFBlockDevice::program(const void *buffer, bd_addr_t addr, bd_size_t size) uint32_t offset = 0; uint32_t chunk = 0; - debug_if(MBED_CONF_SPIF_DRIVER_DEBUG, "DEBUG: program - Buff: 0x%" PRIx32 "h, addr: %llu, size: %llu", (uint32_t)buffer, addr, size); + tr_debug("program - Buff: 0x%" PRIx32 "h, addr: %llu, size: %llu", (uint32_t)buffer, addr, size); while (size > 0) { @@ -361,7 +360,7 @@ int SPIFBlockDevice::erase(bd_addr_t addr, bd_size_t in_size) // Erase Types of selected region uint8_t bitfield = _region_erase_types_bitfield[region]; - debug_if(MBED_CONF_SPIF_DRIVER_DEBUG, "DEBUG: erase - addr: %llu, in_size: %llu", addr, in_size); + tr_debug("erase - addr: %llu, in_size: %llu", addr, in_size); if ((addr + in_size) > _device_size_bytes) { tr_error("erase exceeds flash device size"); @@ -383,9 +382,9 @@ int SPIFBlockDevice::erase(bd_addr_t addr, bd_size_t in_size) offset = addr % _erase_type_size_arr[type]; chunk = ((offset + size) < _erase_type_size_arr[type]) ? size : (_erase_type_size_arr[type] - offset); - debug_if(MBED_CONF_SPIF_DRIVER_DEBUG, "DEBUG: erase - addr: %llu, size:%d, Inst: 0x%xh, chunk: %" PRIu32 " , ", + tr_debug("erase - addr: %llu, size:%d, Inst: 0x%xh, chunk: %" PRIu32 " , ", addr, size, cur_erase_inst, chunk); - debug_if(MBED_CONF_SPIF_DRIVER_DEBUG, "DEBUG: erase - Region: %d, Type:%d", + tr_debug("erase - Region: %d, Type:%d", region, type); _mutex->lock(); @@ -571,7 +570,7 @@ spif_bd_error SPIFBlockDevice::_spi_send_program_command(int prog_inst, const vo spif_bd_error SPIFBlockDevice::_spi_send_erase_command(int erase_inst, bd_addr_t addr, bd_size_t size) { - debug_if(MBED_CONF_SPIF_DRIVER_DEBUG, "DEBUG: Erase Inst: 0x%xh, addr: %llu, size: %llu", erase_inst, addr, size); + tr_debug("Erase Inst: 0x%xh, addr: %llu, size: %llu", erase_inst, addr, size); addr = (((int)addr) & 0xFFFFF000); _spi_send_general_command(erase_inst, addr, NULL, 0, NULL, 0); return SPIF_BD_ERROR_OK; @@ -745,12 +744,12 @@ int SPIFBlockDevice::_sfdp_parse_sfdp_headers(uint32_t &basic_table_addr, size_t tr_error("init - _verify SFDP signature and version Failed"); return -1; } else { - debug_if(MBED_CONF_SPIF_DRIVER_DEBUG, "DEBUG: init - verified SFDP Signature and version Successfully"); + tr_debug("init - verified SFDP Signature and version Successfully"); } // Discover Number of Parameter Headers int number_of_param_headers = (int)(sfdp_header[6]) + 1; - debug_if(MBED_CONF_SPIF_DRIVER_DEBUG, "DEBUG: number of Param Headers: %d", number_of_param_headers); + tr_debug("number of Param Headers: %d", number_of_param_headers); addr += SPIF_SFDP_HEADER_SIZE; data_length = SPIF_PARAM_HEADER_SIZE; @@ -773,14 +772,14 @@ int SPIFBlockDevice::_sfdp_parse_sfdp_headers(uint32_t &basic_table_addr, size_t if ((param_header[0] == 0) && (param_header[7] == 0xFF)) { // Found Basic Params Table: LSB=0x00, MSB=0xFF - debug_if(MBED_CONF_SPIF_DRIVER_DEBUG, "DEBUG: Found Basic Param Table at Table: %d", i_ind + 1); + tr_debug("Found Basic Param Table at Table: %d", i_ind + 1); basic_table_addr = ((param_header[6] << 16) | (param_header[5] << 8) | (param_header[4])); // Supporting up to 64 Bytes Table (16 DWORDS) basic_table_size = ((param_header[3] * 4) < SFDP_DEFAULT_BASIC_PARAMS_TABLE_SIZE_BYTES) ? (param_header[3] * 4) : 64; } else if ((param_header[0] == 81) && (param_header[7] == 0xFF)) { // Found Sector Map Table: LSB=0x81, MSB=0xFF - debug_if(MBED_CONF_SPIF_DRIVER_DEBUG, "DEBUG: Found Sector Map Table at Table: %d", i_ind + 1); + tr_debug("Found Sector Map Table at Table: %d", i_ind + 1); sector_map_table_addr = ((param_header[6] << 16) | (param_header[5] << 8) | (param_header[4])); sector_map_table_size = param_header[3] * 4; @@ -799,9 +798,9 @@ unsigned int SPIFBlockDevice::_sfdp_detect_page_size(uint8_t *basic_param_table_ // Page Size is specified by 4 Bits (N), calculated by 2^N int page_to_power_size = ((int)basic_param_table_ptr[SPIF_BASIC_PARAM_TABLE_PAGE_SIZE_BYTE]) >> 4; page_size = local_math_power(2, page_to_power_size); - debug_if(MBED_CONF_SPIF_DRIVER_DEBUG, "DEBUG: Detected Page Size: %d", page_size); + tr_debug("Detected Page Size: %d", page_size); } else { - debug_if(MBED_CONF_SPIF_DRIVER_DEBUG, "DEBUG: Using Default Page Size: %d", page_size); + tr_debug("Using Default Page Size: %d", page_size); } return page_size; } @@ -823,7 +822,7 @@ int SPIFBlockDevice::_sfdp_detect_erase_types_inst_and_size(uint8_t *basic_param erase_type_inst_arr[i_ind] = 0xff; //0xFF default for unsupported type erase_type_size_arr[i_ind] = local_math_power(2, basic_param_table_ptr[SPIF_BASIC_PARAM_ERASE_TYPE_1_SIZE_BYTE + 2 * i_ind]); // Size given as 2^N - debug_if(MBED_CONF_SPIF_DRIVER_DEBUG, "DEBUG: Erase Type(A) %d - Inst: 0x%xh, Size: %d", (i_ind + 1), erase_type_inst_arr[i_ind], + tr_debug("Erase Type(A) %d - Inst: 0x%xh, Size: %d", (i_ind + 1), erase_type_inst_arr[i_ind], erase_type_size_arr[i_ind]); if (erase_type_size_arr[i_ind] > 1) { // if size==1 type is not supported @@ -846,8 +845,8 @@ int SPIFBlockDevice::_sfdp_detect_erase_types_inst_and_size(uint8_t *basic_param } _region_erase_types_bitfield[0] |= bitfield; // If there's no region map, set region "0" types bitfield as defualt; } - debug_if(MBED_CONF_SPIF_DRIVER_DEBUG, "INFO: Erase Type %d - Inst: 0x%xh, Size: %d", (i_ind + 1), - erase_type_inst_arr[i_ind], erase_type_size_arr[i_ind]); + tr_info("Erase Type %d - Inst: 0x%xh, Size: %d", (i_ind + 1), + erase_type_inst_arr[i_ind], erase_type_size_arr[i_ind]); bitfield = bitfield << 1; } } @@ -864,40 +863,8 @@ int SPIFBlockDevice::_sfdp_detect_best_bus_read_mode(uint8_t *basic_param_table_ do { // TBD - SPIF Dual Read Modes Require SPI driver support - /* - uint8_t examined_byte; - - if (basic_param_table_size > SPIF_BASIC_PARAM_TABLE_QPI_READ_SUPPORT_BYTE) { - examined_byte = basic_param_table_ptr[SPIF_BASIC_PARAM_TABLE_QPI_READ_SUPPORT_BYTE]; - if (examined_byte & 0x01) { - // Fast Read 2-2-2 Supported - read_inst = basic_param_table_ptr[SPIF_BASIC_PARAM_TABLE_222_READ_INST_BYTE]; - _read_dummy_and_mode_cycles = (basic_param_table_ptr[SPIF_BASIC_PARAM_TABLE_222_READ_INST_BYTE - 1] >> 5) - + (basic_param_table_ptr[SPIF_BASIC_PARAM_TABLE_222_READ_INST_BYTE - 1] & 0x1F); - debug_if(MBED_CONF_SPIF_DRIVER_DEBUG, "\nDEBUG: Read Bus Mode set to 2-2-2, Instruction: 0x%xh", read_inst); - break; - } - } - examined_byte = basic_param_table_ptr[SPIF_BASIC_PARAM_TABLE_FAST_READ_SUPPORT_BYTE]; - if (examined_byte & 0x20) { - // Fast Read 1-2-2 Supported - read_inst = basic_param_table_ptr[SPIF_BASIC_PARAM_TABLE_122_READ_INST_BYTE]; - _read_dummy_and_mode_cycles = (basic_param_table_ptr[SPIF_BASIC_PARAM_TABLE_122_READ_INST_BYTE - 1] >> 5) - + (basic_param_table_ptr[SPIF_BASIC_PARAM_TABLE_122_READ_INST_BYTE - 1] & 0x1F); - debug_if(MBED_CONF_SPIF_DRIVER_DEBUG, "\nDEBUG: Read Bus Mode set to 1-2-2, Instruction: 0x%xh", read_inst); - break; - } - if (examined_byte & 0x01) { - // Fast Read 1-1-2 Supported - read_inst = basic_param_table_ptr[SPIF_BASIC_PARAM_TABLE_112_READ_INST_BYTE]; - _read_dummy_and_mode_cycles = (basic_param_table_ptr[SPIF_BASIC_PARAM_TABLE_112_READ_INST_BYTE - 1] >> 5) - + (basic_param_table_ptr[SPIF_BASIC_PARAM_TABLE_112_READ_INST_BYTE - 1] & 0x1F); - debug_if(MBED_CONF_SPIF_DRIVER_DEBUG, "\nDEBUG: Read Bus Mode set to 1-1-2, Instruction: 0x%xh", _read_instruction); - break; - } - */ _read_dummy_and_mode_cycles = 0; - debug_if(MBED_CONF_SPIF_DRIVER_DEBUG, "\nDEBUG: Read Bus Mode set to 1-1-1, Instruction: 0x%xh", read_inst); + tr_debug("Read Bus Mode set to 1-1-1, Instruction: 0x%xh", read_inst); } while (false); return 0; @@ -908,13 +875,13 @@ int SPIFBlockDevice::_reset_flash_mem() // Perform Soft Reset of the Device prior to initialization int status = 0; char status_value[2] = {0}; - debug_if(MBED_CONF_SPIF_DRIVER_DEBUG, "INFO: _reset_flash_mem:\n"); + tr_info("_reset_flash_mem:"); //Read the Status Register from device if (SPIF_BD_ERROR_OK == _spi_send_general_command(SPIF_RDSR, SPI_NO_ADDRESS_COMMAND, NULL, 0, status_value, 1)) { // store received values in status_value - debug_if(MBED_CONF_SPIF_DRIVER_DEBUG, "DEBUG: Reading Status Register Success: value = 0x%x\n", (int)status_value[0]); + tr_debug("Reading Status Register Success: value = 0x%x", (int)status_value[0]); } else { - debug_if(MBED_CONF_SPIF_DRIVER_DEBUG, "ERROR: Reading Status Register failed\n"); + tr_error("Reading Status Register failed"); status = -1; } @@ -922,7 +889,7 @@ int SPIFBlockDevice::_reset_flash_mem() //Send Reset Enable if (SPIF_BD_ERROR_OK == _spi_send_general_command(SPIF_RSTEN, SPI_NO_ADDRESS_COMMAND, NULL, 0, NULL, 0)) { // store received values in status_value - debug_if(MBED_CONF_SPIF_DRIVER_DEBUG, "DEBUG: Sending RSTEN Success\n"); + tr_debug("Sending RSTEN Success"); } else { tr_error("Sending RSTEN failed"); status = -1; @@ -932,7 +899,7 @@ int SPIFBlockDevice::_reset_flash_mem() //Send Reset if (SPIF_BD_ERROR_OK == _spi_send_general_command(SPIF_RST, SPI_NO_ADDRESS_COMMAND, NULL, 0, NULL, 0)) { // store received values in status_value - debug_if(MBED_CONF_SPIF_DRIVER_DEBUG, "DEBUG: Sending RST Success\n"); + tr_debug("Sending RST Success"); } else { tr_error("Sending RST failed"); status = -1; diff --git a/components/storage/blockdevice/COMPONENT_SPIF/SPIFBlockDevice.h b/components/storage/blockdevice/COMPONENT_SPIF/SPIFBlockDevice.h index c7ab3b3987..821de04eab 100644 --- a/components/storage/blockdevice/COMPONENT_SPIF/SPIFBlockDevice.h +++ b/components/storage/blockdevice/COMPONENT_SPIF/SPIFBlockDevice.h @@ -17,9 +17,9 @@ #define MBED_SPIF_BLOCK_DEVICE_H #include "platform/SingletonPtr.h" -#include "SPI.h" -#include "DigitalOut.h" -#include "BlockDevice.h" +#include "drivers/SPI.h" +#include "drivers/DigitalOut.h" +#include "features/storage/blockdevice/BlockDevice.h" /** Enum spif standard error codes * diff --git a/features/device_key/source/DeviceKey.cpp b/features/device_key/source/DeviceKey.cpp index 05e69e8d1b..591dac28d1 100644 --- a/features/device_key/source/DeviceKey.cpp +++ b/features/device_key/source/DeviceKey.cpp @@ -20,18 +20,16 @@ #include "mbedtls/config.h" #include "mbedtls/cmac.h" #include "mbedtls/platform.h" -#include "KVStore.h" -#include "TDBStore.h" -#include "KVMap.h" -#include "kv_config.h" +#include "features/storage/kvstore/include/KVStore.h" +#include "features/storage/kvstore/tdbstore/TDBStore.h" +#include "features/storage/kvstore/kv_map/KVMap.h" +#include "features/storage/kvstore/conf/kv_config.h" #include "mbed_wait_api.h" -#include "stdlib.h" +#include #include "platform/mbed_error.h" #include #include "entropy.h" -#include "platform_mbed.h" #include "mbed_trace.h" -#include "ssl_internal.h" #define TRACE_GROUP "DEVKEY" @@ -272,14 +270,12 @@ int DeviceKey::generate_key_by_random(uint32_t *output, size_t size) } #if defined(DEVICE_TRNG) || defined(MBEDTLS_ENTROPY_NV_SEED) || defined(MBEDTLS_ENTROPY_HARDWARE_ALT) - uint32_t test_buff[DEVICE_KEY_32BYTE / sizeof(int)]; mbedtls_entropy_context *entropy = new mbedtls_entropy_context; mbedtls_entropy_init(entropy); memset(output, 0, size); - memset(test_buff, 0, size); ret = mbedtls_entropy_func(entropy, (unsigned char *)output, size); - if (ret != MBED_SUCCESS || mbedtls_ssl_safer_memcmp(test_buff, (unsigned char *)output, size) == 0) { + if (ret != MBED_SUCCESS) { ret = DEVICEKEY_GENERATE_RANDOM_ERROR; } else { ret = DEVICEKEY_SUCCESS; diff --git a/features/storage/blockdevice/HeapBlockDevice.cpp b/features/storage/blockdevice/HeapBlockDevice.cpp index 8dddb7e6dc..5dcd772b59 100644 --- a/features/storage/blockdevice/HeapBlockDevice.cpp +++ b/features/storage/blockdevice/HeapBlockDevice.cpp @@ -117,11 +117,12 @@ bd_size_t HeapBlockDevice::size() const int HeapBlockDevice::read(void *b, bd_addr_t addr, bd_size_t size) { - MBED_ASSERT(_blocks != NULL); - MBED_ASSERT(is_valid_read(addr, size)); if (!_is_initialized) { return BD_ERROR_DEVICE_ERROR; } + if (!is_valid_read(addr, size)) { + return BD_ERROR_DEVICE_ERROR; + } uint8_t *buffer = static_cast(b); @@ -145,11 +146,12 @@ int HeapBlockDevice::read(void *b, bd_addr_t addr, bd_size_t size) int HeapBlockDevice::program(const void *b, bd_addr_t addr, bd_size_t size) { - MBED_ASSERT(_blocks != NULL); - MBED_ASSERT(is_valid_program(addr, size)); if (!_is_initialized) { return BD_ERROR_DEVICE_ERROR; } + if (!is_valid_program(addr, size)) { + return BD_ERROR_DEVICE_ERROR; + } const uint8_t *buffer = static_cast(b); @@ -176,10 +178,12 @@ int HeapBlockDevice::program(const void *b, bd_addr_t addr, bd_size_t size) int HeapBlockDevice::erase(bd_addr_t addr, bd_size_t size) { - MBED_ASSERT(_blocks != NULL); - MBED_ASSERT(is_valid_erase(addr, size)); - // TODO assert on programming unerased blocks - + if (!_is_initialized) { + return BD_ERROR_DEVICE_ERROR; + } + if (!is_valid_erase(addr, size)) { + return BD_ERROR_DEVICE_ERROR; + } return 0; } diff --git a/features/storage/blockdevice/SlicingBlockDevice.cpp b/features/storage/blockdevice/SlicingBlockDevice.cpp index 5ff3d23cc7..58f6c5e0a6 100644 --- a/features/storage/blockdevice/SlicingBlockDevice.cpp +++ b/features/storage/blockdevice/SlicingBlockDevice.cpp @@ -17,6 +17,7 @@ #include "SlicingBlockDevice.h" #include "platform/mbed_assert.h" #include "stddef.h" +#include namespace mbed { @@ -58,7 +59,9 @@ int SlicingBlockDevice::init() } // Check that block addresses are valid - MBED_ASSERT(is_valid_erase(_start, _stop - _start)); + if (!is_valid_erase(0, _stop - _start)) { + return BD_ERROR_DEVICE_ERROR; + } return 0; } @@ -75,44 +78,41 @@ int SlicingBlockDevice::sync() int SlicingBlockDevice::read(void *b, bd_addr_t addr, bd_size_t size) { - MBED_ASSERT(is_valid_read(addr + _start, size)); + if (!is_valid_read(addr, size)) { + return BD_ERROR_DEVICE_ERROR; + } return _bd->read(b, addr + _start, size); } int SlicingBlockDevice::program(const void *b, bd_addr_t addr, bd_size_t size) { - MBED_ASSERT(is_valid_program(addr + _start, size)); + if (!is_valid_program(addr, size)) { + return BD_ERROR_DEVICE_ERROR; + } return _bd->program(b, addr + _start, size); } int SlicingBlockDevice::erase(bd_addr_t addr, bd_size_t size) { - MBED_ASSERT(is_valid_erase(addr + _start, size)); + if (!is_valid_erase(addr, size)) { + return BD_ERROR_DEVICE_ERROR; + } return _bd->erase(addr + _start, size); } bool SlicingBlockDevice::is_valid_read(bd_addr_t addr, bd_size_t size) const { - return ( - addr % get_read_size() == 0 && - size % get_read_size() == 0 && - addr + size <= (this->size() + _start)); + return _bd->is_valid_read(_start + addr, size) && _start + addr + size <= _stop; } bool SlicingBlockDevice::is_valid_program(bd_addr_t addr, bd_size_t size) const { - return ( - addr % get_program_size() == 0 && - size % get_program_size() == 0 && - addr + size <= (this->size() + _start)); + return _bd->is_valid_program(_start + addr, size) && _start + addr + size <= _stop; } bool SlicingBlockDevice::is_valid_erase(bd_addr_t addr, bd_size_t size) const { - return ( - addr % get_erase_size(addr) == 0 && - (addr + size) % get_erase_size(addr + size - 1) == 0 && - addr + size <= (this->size() + _start)); + return _bd->is_valid_erase(_start + addr, size) && _start + addr + size <= _stop; } bd_size_t SlicingBlockDevice::get_read_size() const @@ -127,7 +127,7 @@ bd_size_t SlicingBlockDevice::get_program_size() const bd_size_t SlicingBlockDevice::get_erase_size() const { - return _bd->get_erase_size(); + return _bd->get_erase_size(_start); } bd_size_t SlicingBlockDevice::get_erase_size(bd_addr_t addr) const diff --git a/features/storage/filesystem/Dir.h b/features/storage/filesystem/Dir.h index 4e933bfa4b..6592c0fac4 100644 --- a/features/storage/filesystem/Dir.h +++ b/features/storage/filesystem/Dir.h @@ -17,7 +17,7 @@ #ifndef DIR_H #define DIR_H -#include "filesystem/FileSystem.h" +#include "features/storage/filesystem/FileSystem.h" #include "platform/DirHandle.h" namespace mbed { diff --git a/features/storage/filesystem/File.h b/features/storage/filesystem/File.h index 349c5926a5..b3f151f8e9 100644 --- a/features/storage/filesystem/File.h +++ b/features/storage/filesystem/File.h @@ -17,7 +17,7 @@ #ifndef FILE_H #define FILE_H -#include "filesystem/FileSystem.h" +#include "features/storage/filesystem/FileSystem.h" #include "platform/FileHandle.h" namespace mbed { diff --git a/features/storage/filesystem/FileSystem.cpp b/features/storage/filesystem/FileSystem.cpp index ad9c543947..bac78eb4e1 100644 --- a/features/storage/filesystem/FileSystem.cpp +++ b/features/storage/filesystem/FileSystem.cpp @@ -14,9 +14,9 @@ * limitations under the License. */ -#include "filesystem/Dir.h" -#include "filesystem/File.h" -#include "filesystem/FileSystem.h" +#include "features/storage/filesystem/Dir.h" +#include "features/storage/filesystem/File.h" +#include "features/storage/filesystem/FileSystem.h" #include namespace mbed { diff --git a/features/storage/filesystem/FileSystem.h b/features/storage/filesystem/FileSystem.h index 1b90b7ec77..7096810c45 100644 --- a/features/storage/filesystem/FileSystem.h +++ b/features/storage/filesystem/FileSystem.h @@ -23,7 +23,7 @@ #include "platform/FileHandle.h" #include "platform/DirHandle.h" #include "platform/FileSystemLike.h" -#include "BlockDevice.h" +#include "features/storage/blockdevice/BlockDevice.h" namespace mbed { /** \addtogroup file system */ diff --git a/features/storage/filesystem/fat/FATFileSystem.cpp b/features/storage/filesystem/fat/FATFileSystem.cpp index 90229131f2..1a77738e08 100644 --- a/features/storage/filesystem/fat/FATFileSystem.cpp +++ b/features/storage/filesystem/fat/FATFileSystem.cpp @@ -19,11 +19,12 @@ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ -#include "diskio.h" -#include "ffconf.h" +#include "features/storage/filesystem/fat/ChaN/diskio.h" +#include "features/storage/filesystem/fat/ChaN/ffconf.h" +#include "features/storage/filesystem/fat/ChaN/ff.h" #include "platform/mbed_debug.h" #include "platform/mbed_critical.h" -#include "filesystem/mbed_filesystem.h" +#include "features/storage/filesystem/mbed_filesystem.h" #include "FATFileSystem.h" #include diff --git a/features/storage/filesystem/fat/FATFileSystem.h b/features/storage/filesystem/fat/FATFileSystem.h index 9bc7b045b8..b5177063d9 100644 --- a/features/storage/filesystem/fat/FATFileSystem.h +++ b/features/storage/filesystem/fat/FATFileSystem.h @@ -26,12 +26,12 @@ #ifndef MBED_FATFILESYSTEM_H #define MBED_FATFILESYSTEM_H -#include "FileSystem.h" -#include "BlockDevice.h" +#include "features/storage/filesystem/FileSystem.h" +#include "features/storage/blockdevice/BlockDevice.h" #include "FileHandle.h" -#include "ff.h" #include #include "PlatformMutex.h" +#include "features/storage/filesystem/fat/ChaN/ff.h" namespace mbed { diff --git a/features/storage/filesystem/littlefs/LittleFileSystem.cpp b/features/storage/filesystem/littlefs/LittleFileSystem.cpp index fce176f65c..66e080b722 100644 --- a/features/storage/filesystem/littlefs/LittleFileSystem.cpp +++ b/features/storage/filesystem/littlefs/LittleFileSystem.cpp @@ -13,11 +13,11 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -#include "filesystem/mbed_filesystem.h" +#include "features/storage/filesystem/mbed_filesystem.h" #include "LittleFileSystem.h" #include "errno.h" -#include "lfs.h" -#include "lfs_util.h" +#include "features/storage/filesystem/littlefs/littlefs/lfs.h" +#include "features/storage/filesystem/littlefs/littlefs/lfs_util.h" #include "MbedCRC.h" namespace mbed { diff --git a/features/storage/filesystem/littlefs/LittleFileSystem.h b/features/storage/filesystem/littlefs/LittleFileSystem.h index c4fdaaee2d..8e34c794f4 100644 --- a/features/storage/filesystem/littlefs/LittleFileSystem.h +++ b/features/storage/filesystem/littlefs/LittleFileSystem.h @@ -20,10 +20,10 @@ #ifndef MBED_LFSFILESYSTEM_H #define MBED_LFSFILESYSTEM_H -#include "FileSystem.h" -#include "BlockDevice.h" -#include "PlatformMutex.h" -#include "lfs.h" +#include "features/storage/filesystem/FileSystem.h" +#include "features/storage/blockdevice/BlockDevice.h" +#include "platform/PlatformMutex.h" +#include "features/storage/filesystem/littlefs/littlefs/lfs.h" namespace mbed { diff --git a/features/storage/filesystem/mbed_filesystem.h b/features/storage/filesystem/mbed_filesystem.h index c002498a74..5ea5b724ca 100644 --- a/features/storage/filesystem/mbed_filesystem.h +++ b/features/storage/filesystem/mbed_filesystem.h @@ -23,16 +23,15 @@ #include "platform/platform.h" // FileSystem classes -#include "filesystem/FileSystem.h" -#include "filesystem/File.h" -#include "filesystem/Dir.h" +#include "features/storage/filesystem/FileSystem.h" +#include "features/storage/filesystem/File.h" +#include "features/storage/filesystem/Dir.h" // BlockDevice classes -#include "BlockDevice.h" -#include "BlockDevice.h" -#include "ChainingBlockDevice.h" -#include "SlicingBlockDevice.h" -#include "HeapBlockDevice.h" +#include "features/storage/blockdevice/BlockDevice.h" +#include "features/storage/blockdevice/ChainingBlockDevice.h" +#include "features/storage/blockdevice/SlicingBlockDevice.h" +#include "features/storage/blockdevice/HeapBlockDevice.h" /** @}*/ #endif diff --git a/features/storage/kvstore/conf/kv_config.cpp b/features/storage/kvstore/conf/kv_config.cpp index ffba5bcd82..84e21e6985 100644 --- a/features/storage/kvstore/conf/kv_config.cpp +++ b/features/storage/kvstore/conf/kv_config.cpp @@ -15,40 +15,40 @@ */ #include "kv_config.h" -#include "KVStore.h" -#include "KVMap.h" -#include "BlockDevice.h" -#include "FileSystem.h" -#include "FileSystemStore.h" -#include "SlicingBlockDevice.h" -#include "FATFileSystem.h" -#include "LittleFileSystem.h" -#include "TDBStore.h" +#include "features/storage/kvstore/include/KVStore.h" +#include "features/storage/kvstore/kv_map/KVMap.h" +#include "features/storage/blockdevice/BlockDevice.h" +#include "features/storage/filesystem/FileSystem.h" +#include "features/storage/kvstore/filesystemstore/FileSystemStore.h" +#include "features/storage/blockdevice/SlicingBlockDevice.h" +#include "features/storage/filesystem/fat/FATFileSystem.h" +#include "features/storage/filesystem/littlefs/LittleFileSystem.h" +#include "features/storage/kvstore/tdbstore/TDBStore.h" #include "mbed_error.h" -#include "FlashIAP.h" -#include "FlashSimBlockDevice.h" +#include "drivers/FlashIAP.h" +#include "features/storage/blockdevice/FlashSimBlockDevice.h" #include "mbed_trace.h" -#include "SecureStore.h" +#include "features/storage/kvstore/securestore/SecureStore.h" #define TRACE_GROUP "KVCFG" #if COMPONENT_FLASHIAP -#include "FlashIAPBlockDevice.h" +#include "components/storage/blockdevice/COMPONENT_FLASHIAP/FlashIAPBlockDevice.h" #endif #if COMPONENT_QSPIF -#include "QSPIFBlockDevice.h" +#include "components/storage/blockdevice/COMPONENT_QSPIF/QSPIFBlockDevice.h" #endif #if COMPONENT_SPIF -#include "SPIFBlockDevice.h" +#include "components/storage/blockdevice/COMPONENT_SPIF/SPIFBlockDevice.h" #endif #if COMPONENT_DATAFLASH -#include "DataFlashBlockDevice.h" +#include "components/storage/blockdevice/COMPONENT_DATAFLASH/DataFlashBlockDevice.h" #endif #if COMPONENT_SD -#include "SDBlockDevice.h" +#include "components/storage/blockdevice/COMPONENT_SD/SDBlockDevice.h" #endif /** diff --git a/features/storage/kvstore/direct_access_devicekey/DirectAccessDevicekey.cpp b/features/storage/kvstore/direct_access_devicekey/DirectAccessDevicekey.cpp index b38f78f702..0c6079dac9 100644 --- a/features/storage/kvstore/direct_access_devicekey/DirectAccessDevicekey.cpp +++ b/features/storage/kvstore/direct_access_devicekey/DirectAccessDevicekey.cpp @@ -17,6 +17,7 @@ // ----------------------------------------------------------- Includes ----------------------------------------------------------- #if DEVICE_FLASH #include "DirectAccessDevicekey.h" +#include "drivers/FlashIAP.h" #include #include #include "mbed_error.h" diff --git a/features/storage/kvstore/filesystemstore/FileSystemStore.cpp b/features/storage/kvstore/filesystemstore/FileSystemStore.cpp index c22746eb8b..1bd57acda0 100644 --- a/features/storage/kvstore/filesystemstore/FileSystemStore.cpp +++ b/features/storage/kvstore/filesystemstore/FileSystemStore.cpp @@ -17,10 +17,10 @@ */ #include "FileSystemStore.h" -#include "kv_config.h" -#include "Dir.h" -#include "File.h" -#include "BlockDevice.h" +#include "features/storage/kvstore/conf/kv_config.h" +#include "features/storage/filesystem/Dir.h" +#include "features/storage/filesystem/File.h" +#include "features/storage/blockdevice/BlockDevice.h" #include "mbed_error.h" #include #include diff --git a/features/storage/kvstore/filesystemstore/FileSystemStore.h b/features/storage/kvstore/filesystemstore/FileSystemStore.h index 2ea9590e40..a9e32aa678 100644 --- a/features/storage/kvstore/filesystemstore/FileSystemStore.h +++ b/features/storage/kvstore/filesystemstore/FileSystemStore.h @@ -18,8 +18,8 @@ #ifndef MBED_FILE_SYSTEM_STORE_H #define MBED_FILE_SYSTEM_STORE_H -#include "KVStore.h" -#include "FileSystem.h" +#include "features/storage/kvstore/include/KVStore.h" +#include "features/storage/filesystem/FileSystem.h" namespace mbed { diff --git a/features/storage/kvstore/global_api/kvstore_global_api.cpp b/features/storage/kvstore/global_api/kvstore_global_api.cpp index 7fb6a6c5ef..ce67a28fa7 100644 --- a/features/storage/kvstore/global_api/kvstore_global_api.cpp +++ b/features/storage/kvstore/global_api/kvstore_global_api.cpp @@ -15,9 +15,9 @@ */ #include "kvstore_global_api.h" -#include "kv_config.h" -#include "KVMap.h" -#include "KVStore.h" +#include "features/storage/kvstore/conf/kv_config.h" +#include "features/storage/kvstore/kv_map/KVMap.h" +#include "features/storage/kvstore/include/KVStore.h" #include "mbed_error.h" using namespace mbed; diff --git a/features/storage/kvstore/kv_map/KVMap.cpp b/features/storage/kvstore/kv_map/KVMap.cpp index 45ce0daa4d..a9dcb48980 100644 --- a/features/storage/kvstore/kv_map/KVMap.cpp +++ b/features/storage/kvstore/kv_map/KVMap.cpp @@ -14,9 +14,9 @@ * limitations under the License. */ -#include "KVStore.h" -#include "KVMap.h" -#include "kv_config.h" +#include "features/storage/kvstore/include/KVStore.h" +#include "features/storage/kvstore/kv_map/KVMap.h" +#include "features/storage/kvstore/conf/kv_config.h" #include #include "string.h" #include "mbed_error.h" diff --git a/features/storage/kvstore/kv_map/KVMap.h b/features/storage/kvstore/kv_map/KVMap.h index 14acbe152c..d45731ee3c 100644 --- a/features/storage/kvstore/kv_map/KVMap.h +++ b/features/storage/kvstore/kv_map/KVMap.h @@ -16,11 +16,11 @@ #ifndef _KV_MAP #define _KV_MAP -#include "KVStore.h" +#include "features/storage/kvstore/include/KVStore.h" #include "platform/PlatformMutex.h" #include "platform/SingletonPtr.h" -#include "BlockDevice.h" -#include "FileSystem.h" +#include "features/storage/blockdevice/BlockDevice.h" +#include "features/storage/filesystem/FileSystem.h" namespace mbed { diff --git a/features/storage/kvstore/securestore/SecureStore.h b/features/storage/kvstore/securestore/SecureStore.h index 2dbda2dd2f..c08eeff837 100644 --- a/features/storage/kvstore/securestore/SecureStore.h +++ b/features/storage/kvstore/securestore/SecureStore.h @@ -23,7 +23,7 @@ #include MBEDTLS_CONFIG_FILE #endif -#include "DeviceKey.h" +#include "features/device_key/source/DeviceKey.h" #define SECURESTORE_ENABLED 1 diff --git a/features/storage/kvstore/tdbstore/TDBStore.cpp b/features/storage/kvstore/tdbstore/TDBStore.cpp index 73e106a151..418c74fb9f 100644 --- a/features/storage/kvstore/tdbstore/TDBStore.cpp +++ b/features/storage/kvstore/tdbstore/TDBStore.cpp @@ -26,7 +26,7 @@ #include "MbedCRC.h" //Bypass the check of NVStore co existance if compiled for TARGET_TFM #if !(BYPASS_NVSTORE_CHECK) -#include "SystemStorage.h" +#include "features/storage/system_storage/SystemStorage.h" #endif using namespace mbed; @@ -251,7 +251,7 @@ int TDBStore::read_record(uint8_t area, uint32_t offset, char *key, return MBED_ERROR_INVALID_SIZE; } - actual_data_size = std::min(data_buf_size, data_size - data_offset); + actual_data_size = std::min((size_t)data_buf_size, (size_t)data_size - data_offset); if (copy_data && actual_data_size && !data_buf) { return MBED_ERROR_INVALID_ARGUMENT; @@ -295,7 +295,7 @@ int TDBStore::read_record(uint8_t area, uint32_t offset, char *key, // 3. After actual part is finished - read to work buffer // 4. Copy data flag not set - read to work buffer if (curr_data_offset < data_offset) { - chunk_size = std::min(work_buf_size, data_offset - curr_data_offset); + chunk_size = std::min((size_t)work_buf_size, (size_t)(data_offset - curr_data_offset)); dest_buf = _work_buf; } else if (copy_data && (curr_data_offset < data_offset + actual_data_size)) { chunk_size = actual_data_size; diff --git a/features/storage/kvstore/tdbstore/TDBStore.h b/features/storage/kvstore/tdbstore/TDBStore.h index d287718edc..a31dd0b501 100644 --- a/features/storage/kvstore/tdbstore/TDBStore.h +++ b/features/storage/kvstore/tdbstore/TDBStore.h @@ -19,9 +19,9 @@ #include #include -#include "KVStore.h" -#include "BlockDevice.h" -#include "BufferedBlockDevice.h" +#include "features/storage/kvstore/include/KVStore.h" +#include "features/storage/blockdevice/BlockDevice.h" +#include "features/storage/blockdevice/BufferedBlockDevice.h" #include "PlatformMutex.h" namespace mbed { diff --git a/features/storage/system_storage/SystemStorage.cpp b/features/storage/system_storage/SystemStorage.cpp index 8003a3c481..695197c7e4 100644 --- a/features/storage/system_storage/SystemStorage.cpp +++ b/features/storage/system_storage/SystemStorage.cpp @@ -14,35 +14,35 @@ * limitations under the License. */ #include "SystemStorage.h" -#include "BlockDevice.h" -#include "FileSystem.h" -#include "FATFileSystem.h" -#include "LittleFileSystem.h" +#include "features/storage/blockdevice/BlockDevice.h" +#include "features/storage/filesystem/FileSystem.h" +#include "features/storage/filesystem/fat/FATFileSystem.h" +#include "features/storage/filesystem/littlefs/LittleFileSystem.h" #include "mbed_error.h" #if COMPONENT_SPIF -#include "SPIFBlockDevice.h" +#include "components/storage/blockdevice/COMPONENT_SPIF/SPIFBlockDevice.h" #endif #if COMPONENT_RSPIF -#include "SPIFReducedBlockDevice.h" +#include "components/storage/blockdevice/COMPONENT_RSPIF/SPIFReducedBlockDevice.h" #endif #if COMPONENT_QSPIF -#include "QSPIFBlockDevice.h" +#include "components/storage/blockdevice/COMPONENT_QSPIF/QSPIFBlockDevice.h" #endif #if COMPONENT_DATAFLASH -#include "DataFlashBlockDevice.h" +#include "components/storage/blockdevice/COMPONENT_DATAFLASH/DataFlashBlockDevice.h" #endif #if COMPONENT_SD -#include "SDBlockDevice.h" +#include "components/storage/blockdevice/COMPONENT_SD/SDBlockDevice.h" #endif #if COMPONENT_FLASHIAP -#include "FlashIAPBlockDevice.h" +#include "components/storage/blockdevice/COMPONENT_FLASHIAP/FlashIAPBlockDevice.h" #endif using namespace mbed; diff --git a/hal/pinmap.h b/hal/pinmap.h index b2a8d560f0..4fc0ec3740 100644 --- a/hal/pinmap.h +++ b/hal/pinmap.h @@ -22,6 +22,7 @@ #include "PinNames.h" #include +#include #ifdef __cplusplus extern "C" {