diff --git a/drivers/include/drivers/Watchdog.h b/drivers/include/drivers/Watchdog.h
index 6f44e347d05..816d89ca433 100644
--- a/drivers/include/drivers/Watchdog.h
+++ b/drivers/include/drivers/Watchdog.h
@@ -26,6 +26,7 @@
 #include "hal/watchdog_api.h"
 #include "platform/NonCopyable.h"
 #include <cstdio>
+#include <chrono>
 
 namespace mbed {
 /**
@@ -92,7 +93,7 @@ class Watchdog : private NonCopyable<Watchdog>  {
 
     /** Start the Watchdog timer.
      *
-     * @note Asset that the timeout param is supported by the target
+     * @note Asserts that the timeout param is supported by the target
      * (0 < timeout <= Watchdog::get_max_timeout).
      *
      * @param timeout Watchdog timeout in milliseconds.
@@ -103,6 +104,22 @@ class Watchdog : private NonCopyable<Watchdog>  {
      */
     bool start(uint32_t timeout);
 
+    /** Start the Watchdog timer.
+     *
+     * @note Asserts that the timeout param is supported by the target
+     * (0 < timeout <= Watchdog::get_max_timeout).
+     *
+     * @param timeout Watchdog timeout in chrono milliseconds.
+     *
+     * @return true if the Watchdog timer was started successfully;
+     *         false if Watchdog timer was not started or if setting
+     *         a new watchdog timeout was not possible.
+     */
+    bool start(std::chrono::milliseconds timeout)
+    {
+        return start(timeout.count());
+    }
+
     /** Stop the Watchdog timer.
      *
      * Calling this function disables a running Watchdog
diff --git a/drivers/tests/TESTS/CMakeLists.txt b/drivers/tests/TESTS/CMakeLists.txt
index ec9280fee98..c71439d9dfb 100644
--- a/drivers/tests/TESTS/CMakeLists.txt
+++ b/drivers/tests/TESTS/CMakeLists.txt
@@ -1,4 +1,4 @@
 # Copyright (c) 2021 ARM Limited. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 
-add_subdirectory(mbed_drivers/ticker)
+add_subdirectory(mbed_drivers)
diff --git a/drivers/tests/TESTS/mbed_drivers/CMakeLists.txt b/drivers/tests/TESTS/mbed_drivers/CMakeLists.txt
new file mode 100644
index 00000000000..d3cc62cfd16
--- /dev/null
+++ b/drivers/tests/TESTS/mbed_drivers/CMakeLists.txt
@@ -0,0 +1,20 @@
+add_subdirectory(buffered_serial)
+add_subdirectory(c_strings)
+add_subdirectory(crc)
+add_subdirectory(dev_null)
+add_subdirectory(echo)
+add_subdirectory(flashiap)
+add_subdirectory(generic_tests)
+add_subdirectory(lp_ticker)
+add_subdirectory(lp_timeout)
+add_subdirectory(lp_timer)
+add_subdirectory(mem_trace)
+add_subdirectory(race_test)
+add_subdirectory(reset_reason)
+add_subdirectory(sleep_lock)
+add_subdirectory(stl_features)
+add_subdirectory(ticker)
+add_subdirectory(timerevent)
+add_subdirectory(unbuffered_serial)
+add_subdirectory(watchdog)
+add_subdirectory(watchdog_reset)
\ No newline at end of file
diff --git a/drivers/tests/TESTS/mbed_drivers/buffered_serial/CMakeLists.txt b/drivers/tests/TESTS/mbed_drivers/buffered_serial/CMakeLists.txt
index cd90ed68e1c..dafa0744b50 100644
--- a/drivers/tests/TESTS/mbed_drivers/buffered_serial/CMakeLists.txt
+++ b/drivers/tests/TESTS/mbed_drivers/buffered_serial/CMakeLists.txt
@@ -1,18 +1,17 @@
 # Copyright (c) 2020 ARM Limited. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 
-cmake_minimum_required(VERSION 3.19.0 FATAL_ERROR)
-
-set(MBED_PATH ${CMAKE_CURRENT_SOURCE_DIR}/../../../../.. CACHE INTERNAL "")
-set(TEST_TARGET mbed-drivers-buffered-serial)
-
-include(${MBED_PATH}/tools/cmake/mbed_greentea.cmake)
-
-project(${TEST_TARGET})
+if(NOT "DEVICE_SERIAL=1" IN_LIST MBED_TARGET_DEFINITIONS)
+	set(TEST_SKIPPED "Serial communication not supported for this target")
+endif()
 
 mbed_greentea_add_test(
     TEST_NAME
-        ${TEST_TARGET}
+        mbed-drivers-buffered-serial
     TEST_SOURCES
         main.cpp
+	HOST_TESTS_DIR
+		../../host_tests
+    TEST_SKIPPED
+        ${TEST_SKIPPED}
 )
diff --git a/drivers/tests/TESTS/mbed_drivers/c_strings/CMakeLists.txt b/drivers/tests/TESTS/mbed_drivers/c_strings/CMakeLists.txt
index dfce13e5027..000a1d7139f 100644
--- a/drivers/tests/TESTS/mbed_drivers/c_strings/CMakeLists.txt
+++ b/drivers/tests/TESTS/mbed_drivers/c_strings/CMakeLists.txt
@@ -1,18 +1,9 @@
 # Copyright (c) 2020 ARM Limited. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 
-cmake_minimum_required(VERSION 3.19.0 FATAL_ERROR)
-
-set(MBED_PATH ${CMAKE_CURRENT_SOURCE_DIR}/../../../../.. CACHE INTERNAL "")
-set(TEST_TARGET mbed-drivers-c-strings)
-
-include(${MBED_PATH}/tools/cmake/mbed_greentea.cmake)
-
-project(${TEST_TARGET})
-
 mbed_greentea_add_test(
     TEST_NAME
-        ${TEST_TARGET}
+        mbed-drivers-c-strings
     TEST_SOURCES
         main.cpp
 )
diff --git a/drivers/tests/TESTS/mbed_drivers/crc/CMakeLists.txt b/drivers/tests/TESTS/mbed_drivers/crc/CMakeLists.txt
index 62a3d154ff4..6ee52c4f485 100644
--- a/drivers/tests/TESTS/mbed_drivers/crc/CMakeLists.txt
+++ b/drivers/tests/TESTS/mbed_drivers/crc/CMakeLists.txt
@@ -1,18 +1,9 @@
 # Copyright (c) 2020 ARM Limited. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 
-cmake_minimum_required(VERSION 3.19.0 FATAL_ERROR)
-
-set(MBED_PATH ${CMAKE_CURRENT_SOURCE_DIR}/../../../../.. CACHE INTERNAL "")
-set(TEST_TARGET mbed-drivers-crc)
-
-include(${MBED_PATH}/tools/cmake/mbed_greentea.cmake)
-
-project(${TEST_TARGET})
-
 mbed_greentea_add_test(
     TEST_NAME
-        ${TEST_TARGET}
+        mbed-drivers-crc
     TEST_SOURCES
         main.cpp
 )
diff --git a/drivers/tests/TESTS/mbed_drivers/dev_null/CMakeLists.txt b/drivers/tests/TESTS/mbed_drivers/dev_null/CMakeLists.txt
index 9f3b10b1367..11e2334f2eb 100644
--- a/drivers/tests/TESTS/mbed_drivers/dev_null/CMakeLists.txt
+++ b/drivers/tests/TESTS/mbed_drivers/dev_null/CMakeLists.txt
@@ -1,18 +1,11 @@
 # Copyright (c) 2020 ARM Limited. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 
-cmake_minimum_required(VERSION 3.19.0 FATAL_ERROR)
-
-set(MBED_PATH ${CMAKE_CURRENT_SOURCE_DIR}/../../../../.. CACHE INTERNAL "")
-set(TEST_TARGET mbed-drivers-dev-null)
-
-include(${MBED_PATH}/tools/cmake/mbed_greentea.cmake)
-
-project(${TEST_TARGET})
-
 mbed_greentea_add_test(
     TEST_NAME
-        ${TEST_TARGET}
+        mbed-drivers-dev-null
     TEST_SOURCES
         main.cpp
+    HOST_TESTS_DIR
+		../../host_tests
 )
diff --git a/drivers/tests/TESTS/mbed_drivers/echo/CMakeLists.txt b/drivers/tests/TESTS/mbed_drivers/echo/CMakeLists.txt
index 70e2e72b6ae..188c69aca21 100644
--- a/drivers/tests/TESTS/mbed_drivers/echo/CMakeLists.txt
+++ b/drivers/tests/TESTS/mbed_drivers/echo/CMakeLists.txt
@@ -15,4 +15,6 @@ mbed_greentea_add_test(
         ${TEST_TARGET}
     TEST_SOURCES
         main.cpp
+    HOST_TESTS_DIR
+		../../host_tests
 )
diff --git a/drivers/tests/TESTS/mbed_drivers/echo/main.cpp b/drivers/tests/TESTS/mbed_drivers/echo/main.cpp
index 7ea6e422b38..a1c231d0c92 100644
--- a/drivers/tests/TESTS/mbed_drivers/echo/main.cpp
+++ b/drivers/tests/TESTS/mbed_drivers/echo/main.cpp
@@ -29,7 +29,7 @@ using namespace utest::v1;
 void fill_buffer(char *buffer, unsigned int length, unsigned int index)
 {
     unsigned int start = length * index;
-    for (int i = 0; i < length - 1; i++) {
+    for (unsigned int i = 0; i < length - 1; i++) {
         buffer[i] = 'a' + ((start + i) % 26);
     }
     buffer[length - 1] = '\0';
diff --git a/drivers/tests/TESTS/mbed_drivers/flashiap/CMakeLists.txt b/drivers/tests/TESTS/mbed_drivers/flashiap/CMakeLists.txt
index 5fa36d2a083..71071e3f0a4 100644
--- a/drivers/tests/TESTS/mbed_drivers/flashiap/CMakeLists.txt
+++ b/drivers/tests/TESTS/mbed_drivers/flashiap/CMakeLists.txt
@@ -1,18 +1,15 @@
 # Copyright (c) 2020 ARM Limited. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 
-cmake_minimum_required(VERSION 3.19.0 FATAL_ERROR)
-
-set(MBED_PATH ${CMAKE_CURRENT_SOURCE_DIR}/../../../../.. CACHE INTERNAL "")
-set(TEST_TARGET mbed-drivers-flashiap)
-
-include(${MBED_PATH}/tools/cmake/mbed_greentea.cmake)
-
-project(${TEST_TARGET})
+if(NOT "DEVICE_FLASH=1" IN_LIST MBED_TARGET_DEFINITIONS)
+	set(TEST_SKIPPED "Flash API not supported for this target")
+endif()
 
 mbed_greentea_add_test(
     TEST_NAME
-        ${TEST_TARGET}
+        mbed-drivers-flashiap
     TEST_SOURCES
         main.cpp
+    TEST_SKIPPED
+        ${TEST_SKIPPED}
 )
diff --git a/drivers/tests/TESTS/mbed_drivers/flashiap/main.cpp b/drivers/tests/TESTS/mbed_drivers/flashiap/main.cpp
index e2c596c4ac1..7b649155ba4 100644
--- a/drivers/tests/TESTS/mbed_drivers/flashiap/main.cpp
+++ b/drivers/tests/TESTS/mbed_drivers/flashiap/main.cpp
@@ -27,6 +27,7 @@
 #include "FlashIAP.h"
 #include "unity.h"
 #include <algorithm>
+#include <cinttypes>
 
 #include "mbed.h"
 
@@ -43,6 +44,17 @@
 
 using namespace utest::v1;
 
+// Get the max of two microsecond values
+static std::chrono::microseconds us_max(std::chrono::microseconds time1, std::chrono::microseconds time2)
+{
+    return time1 > time2 ? time1 : time2;
+}
+
+// Get the min of two microsecond values
+static std::chrono::microseconds us_min(std::chrono::microseconds time1, std::chrono::microseconds time2)
+{
+    return time1 < time2 ? time1 : time2;
+}
 
 void flashiap_init_test()
 {
@@ -54,7 +66,6 @@ void flashiap_init_test()
     uint32_t flash_size = flash_device.get_flash_size();
     utest_printf("Flash address: 0x%08x, size: %d\n", flash_start, flash_size);
     uint32_t address = flash_start;
-    int num = 0;
     while (flash_size) {
         uint32_t sector_size = flash_device.get_sector_size(address);
         // Make sure all sectors sum up to the total flash size
@@ -234,10 +245,12 @@ void flashiap_timing_test()
     uint32_t ret = flash_device.init();
     TEST_ASSERT_EQUAL_INT32(0, ret);
     mbed::Timer timer;
+
+    std::chrono::microseconds curr_time{};
+    std::chrono::microseconds avg_erase_time{};
     unsigned int num_write_sizes;
-    unsigned int curr_time, byte_usec_ratio;
-    unsigned int avg_erase_time = 0;
-    unsigned int max_erase_time = 0, min_erase_time = (unsigned int) -1;
+    unsigned int byte_usec_ratio;
+    std::chrono::microseconds max_erase_time(0), min_erase_time(-1);
     const unsigned int max_writes = 128;
     const unsigned int max_write_sizes = 6;
     const unsigned int max_byte_usec_ratio = 200;
@@ -266,14 +279,14 @@ void flashiap_timing_test()
         memset(buf, 0x5A, write_size);
         timer.reset();
         ret = flash_device.erase(base_address, sector_size);
-        curr_time = timer.read_us();
+        curr_time = timer.elapsed_time();
         avg_erase_time += curr_time;
         TEST_ASSERT_EQUAL_INT32(0, ret);
-        max_erase_time = std::max(max_erase_time, curr_time);
-        min_erase_time = std::min(min_erase_time, curr_time);
+        max_erase_time = us_max(max_erase_time, curr_time);
+        min_erase_time = us_min(min_erase_time, curr_time);
         uint32_t address = base_address;
-        unsigned int avg_write_time = 0;
-        unsigned int max_write_time = 0, min_write_time = (unsigned int) -1;
+        std::chrono::microseconds avg_write_time(0);
+        std::chrono::microseconds max_write_time(0), min_write_time(-1);
         unsigned int num_writes;
         for (num_writes = 0; num_writes < max_writes; num_writes++) {
             if ((address + write_size) > end_address) {
@@ -281,27 +294,27 @@ void flashiap_timing_test()
             }
             timer.reset();
             ret = flash_device.program(buf, address, write_size);
-            curr_time = timer.read_us();
+            curr_time = timer.elapsed_time();
             avg_write_time += curr_time;
             TEST_ASSERT_EQUAL_INT32(0, ret);
-            max_write_time = std::max(max_write_time, curr_time);
-            min_write_time = std::min(min_write_time, curr_time);
+            max_write_time = us_max(max_write_time, curr_time);
+            min_write_time = us_min(min_write_time, curr_time);
             address += write_size;
         }
         delete[] buf;
         avg_write_time /= num_writes;
-        utest_printf("Write size %6u bytes: avg %10u, min %10u, max %10u (usec)\n",
-                     write_size, avg_write_time, min_write_time, max_write_time);
-        byte_usec_ratio = write_size / avg_write_time;
+        byte_usec_ratio = write_size / avg_write_time.count();
+        utest_printf("Write size %6u bytes: avg %10" PRIi64 ", min %10" PRIi64 ", max %10" PRIi64 " (usec), rate %10u bytes/usec\n",
+                     write_size, avg_write_time.count(), min_write_time.count(), max_write_time.count(), byte_usec_ratio);
         TEST_ASSERT(byte_usec_ratio < max_byte_usec_ratio);
         write_size *= 4;
     }
 
     if (num_write_sizes) {
         avg_erase_time /= num_write_sizes;
-        utest_printf("\nErase size %6u bytes: avg %10u, min %10u, max %10u (usec)\n\n",
-                     sector_size, avg_erase_time, min_erase_time, max_erase_time);
-        byte_usec_ratio = sector_size / avg_erase_time;
+        byte_usec_ratio = sector_size / avg_erase_time.count();
+        utest_printf("\nErase size %6u bytes: avg %10" PRIi64 ", min %10" PRIi64 ", max %10" PRIi64" (usec), rate %10u bytes/usec\n\n",
+                     sector_size, avg_erase_time.count(), min_erase_time.count(), max_erase_time.count(), byte_usec_ratio);
         TEST_ASSERT(byte_usec_ratio < max_byte_usec_ratio);
     }
 
diff --git a/drivers/tests/TESTS/mbed_drivers/generic_tests/CMakeLists.txt b/drivers/tests/TESTS/mbed_drivers/generic_tests/CMakeLists.txt
index 786ca1d05cd..ba64f74ee41 100644
--- a/drivers/tests/TESTS/mbed_drivers/generic_tests/CMakeLists.txt
+++ b/drivers/tests/TESTS/mbed_drivers/generic_tests/CMakeLists.txt
@@ -1,18 +1,9 @@
 # Copyright (c) 2020 ARM Limited. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 
-cmake_minimum_required(VERSION 3.19.0 FATAL_ERROR)
-
-set(MBED_PATH ${CMAKE_CURRENT_SOURCE_DIR}/../../../../.. CACHE INTERNAL "")
-set(TEST_TARGET mbed-drivers-generic-tests)
-
-include(${MBED_PATH}/tools/cmake/mbed_greentea.cmake)
-
-project(${TEST_TARGET})
-
 mbed_greentea_add_test(
     TEST_NAME
-        ${TEST_TARGET}
+        mbed-drivers-generic-tests
     TEST_SOURCES
         main.cpp
 )
diff --git a/drivers/tests/TESTS/mbed_drivers/generic_tests/main.cpp b/drivers/tests/TESTS/mbed_drivers/generic_tests/main.cpp
index d00d0e1f853..58342083dba 100644
--- a/drivers/tests/TESTS/mbed_drivers/generic_tests/main.cpp
+++ b/drivers/tests/TESTS/mbed_drivers/generic_tests/main.cpp
@@ -87,11 +87,11 @@ void test_case_blinky()
 }
 #endif
 
+// Check C++ start-up initialisation
+CppTestCaseHelperClass s("Static");
+
 void test_case_cpp_stack()
 {
-    // Check C++ start-up initialisation
-    CppTestCaseHelperClass s("Static");
-
     // Global stack object simple test
     s.stack_test();
     TEST_ASSERT_TRUE_MESSAGE(s.check_init(), "s.check_init() failed");
diff --git a/drivers/tests/TESTS/mbed_drivers/lp_ticker/CMakeLists.txt b/drivers/tests/TESTS/mbed_drivers/lp_ticker/CMakeLists.txt
index 11110b2b134..e46ec7479e3 100644
--- a/drivers/tests/TESTS/mbed_drivers/lp_ticker/CMakeLists.txt
+++ b/drivers/tests/TESTS/mbed_drivers/lp_ticker/CMakeLists.txt
@@ -1,18 +1,15 @@
 # Copyright (c) 2020 ARM Limited. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 
-cmake_minimum_required(VERSION 3.19.0 FATAL_ERROR)
-
-set(MBED_PATH ${CMAKE_CURRENT_SOURCE_DIR}/../../../../.. CACHE INTERNAL "")
-set(TEST_TARGET mbed-drivers-lp-ticker)
-
-include(${MBED_PATH}/tools/cmake/mbed_greentea.cmake)
-
-project(${TEST_TARGET})
+if(NOT "DEVICE_LPTICKER=1" IN_LIST MBED_TARGET_DEFINITIONS)
+	set(TEST_SKIPPED "Low power ticker not supported for this target")
+endif()
 
 mbed_greentea_add_test(
     TEST_NAME
-        ${TEST_TARGET}
+        mbed-drivers-lp-ticker
     TEST_SOURCES
         main.cpp
+    TEST_SKIPPED
+        ${TEST_SKIPPED}
 )
diff --git a/drivers/tests/TESTS/mbed_drivers/lp_timeout/CMakeLists.txt b/drivers/tests/TESTS/mbed_drivers/lp_timeout/CMakeLists.txt
index 3ee21630363..564c42966ba 100644
--- a/drivers/tests/TESTS/mbed_drivers/lp_timeout/CMakeLists.txt
+++ b/drivers/tests/TESTS/mbed_drivers/lp_timeout/CMakeLists.txt
@@ -1,18 +1,21 @@
 # Copyright (c) 2020 ARM Limited. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 
-cmake_minimum_required(VERSION 3.19.0 FATAL_ERROR)
+if(NOT "DEVICE_LPTICKER=1" IN_LIST MBED_TARGET_DEFINITIONS)
+	set(TEST_SKIPPED "Low power ticker not supported for this target")
+endif()
 
-set(MBED_PATH ${CMAKE_CURRENT_SOURCE_DIR}/../../../../.. CACHE INTERNAL "")
-set(TEST_TARGET mbed-drivers-lp-timeout)
-
-include(${MBED_PATH}/tools/cmake/mbed_greentea.cmake)
-
-project(${TEST_TARGET})
+if(MBED_GREENTEA_TEST_BAREMETAL)
+    set(TEST_SKIPPED "Low power timer not supported for this target")
+endif()
 
 mbed_greentea_add_test(
     TEST_NAME
-        ${TEST_TARGET}
+        mbed-drivers-lp-timeout
     TEST_SOURCES
         main.cpp
+    HOST_TESTS_DIR
+		../../host_tests
+    TEST_SKIPPED
+        ${TEST_SKIPPED}
 )
diff --git a/drivers/tests/TESTS/mbed_drivers/lp_timer/CMakeLists.txt b/drivers/tests/TESTS/mbed_drivers/lp_timer/CMakeLists.txt
index fad8a3a6be7..f797aeda7f9 100644
--- a/drivers/tests/TESTS/mbed_drivers/lp_timer/CMakeLists.txt
+++ b/drivers/tests/TESTS/mbed_drivers/lp_timer/CMakeLists.txt
@@ -1,18 +1,15 @@
 # Copyright (c) 2020 ARM Limited. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 
-cmake_minimum_required(VERSION 3.19.0 FATAL_ERROR)
-
-set(MBED_PATH ${CMAKE_CURRENT_SOURCE_DIR}/../../../../.. CACHE INTERNAL "")
-set(TEST_TARGET mbed-drivers-lp-timer)
-
-include(${MBED_PATH}/tools/cmake/mbed_greentea.cmake)
-
-project(${TEST_TARGET})
+if(NOT "DEVICE_LPTICKER=1" IN_LIST MBED_TARGET_DEFINITIONS)
+	set(TEST_SKIPPED "Low power ticker not supported for this target")
+endif()
 
 mbed_greentea_add_test(
     TEST_NAME
-        ${TEST_TARGET}
+        mbed-drivers-lp-timer
     TEST_SOURCES
         main.cpp
+    TEST_SKIPPED
+        ${TEST_SKIPPED}
 )
diff --git a/drivers/tests/TESTS/mbed_drivers/lp_timer/main.cpp b/drivers/tests/TESTS/mbed_drivers/lp_timer/main.cpp
index 5f40cd63bf6..729e66f0610 100644
--- a/drivers/tests/TESTS/mbed_drivers/lp_timer/main.cpp
+++ b/drivers/tests/TESTS/mbed_drivers/lp_timer/main.cpp
@@ -27,8 +27,6 @@
 
 using namespace utest::v1;
 
-extern uint32_t SystemCoreClock;
-
 /* This test is created based on the test for Timer class.
  * Since low power timer is less accurate than regular
  * timer we need to adjust delta.
@@ -44,15 +42,14 @@ extern uint32_t SystemCoreClock;
 * 100 ms delay: tolerance = 5500 us
 * 1000 ms delay: tolerance = 50500 us
 *
-*  */
+*/
 
-#define US_PER_SEC       1000000
-#define US_PER_MSEC      1000
-#define MSEC_PER_SEC     1000
+#define TEST_ASSERT_TIMES_EQUAL_WITHIN_TOLERANCE(expected, actual) \
+    TEST_ASSERT_UINT64_WITHIN(std::chrono::duration_cast<std::chrono::microseconds>(expected).count() / 20 + 500, \
+        std::chrono::duration_cast<std::chrono::microseconds>(expected).count(), \
+        std::chrono::duration_cast<std::chrono::microseconds>(actual).count())
 
-#define DELTA_US(delay_ms) (500 + (delay_ms) * US_PER_MSEC / 20)
-#define DELTA_MS(delay_ms) (1 + ((delay_ms) * US_PER_MSEC / 20 / US_PER_MSEC))
-#define DELTA_S(delay_ms) (0.000500f + (((float)(delay_ms)) / MSEC_PER_SEC / 20))
+#define US_PER_MSEC      1000
 
 void busy_wait_us(int us)
 {
@@ -78,20 +75,14 @@ void test_lptimer_creation()
     LowPowerTimer lp_timer;
 
     /* Check results. */
-    TEST_ASSERT_EQUAL_FLOAT(0, lp_timer.read());
-    TEST_ASSERT_EQUAL_INT32(0, lp_timer.read_ms());
-    TEST_ASSERT_EQUAL_INT32(0, lp_timer.read_us());
-    TEST_ASSERT_EQUAL_UINT64(0, lp_timer.read_high_resolution_us());
+     (0, lp_timer.elapsed_time().count());
 
     /* Wait 10 ms.
      * After that operation timer read routines should still return 0. */
     busy_wait_ms(10);
 
     /* Check results. */
-    TEST_ASSERT_EQUAL_FLOAT(0, lp_timer.read());
-    TEST_ASSERT_EQUAL_INT32(0, lp_timer.read_ms());
-    TEST_ASSERT_EQUAL_INT32(0, lp_timer.read_us());
-    TEST_ASSERT_EQUAL_UINT64(0, lp_timer.read_high_resolution_us());
+    TEST_ASSERT_EQUAL_UINT64(0, lp_timer.elapsed_time().count());
 }
 
 /* This test verifies if read(), read_us(), read_ms(),
@@ -119,10 +110,7 @@ void test_lptimer_time_accumulation()
     lp_timer.stop();
 
     /* Check results - totally 10 ms have elapsed. */
-    TEST_ASSERT_FLOAT_WITHIN(DELTA_S(10), 0.010f, lp_timer.read());
-    TEST_ASSERT_INT32_WITHIN(DELTA_MS(10), 10, lp_timer.read_ms());
-    TEST_ASSERT_INT32_WITHIN(DELTA_US(10), 10000, lp_timer.read_us());
-    TEST_ASSERT_UINT64_WITHIN(DELTA_US(10), 10000, lp_timer.read_high_resolution_us());
+    TEST_ASSERT_TIMES_EQUAL_WITHIN_TOLERANCE(10ms, lp_timer.elapsed_time());
 
     /* Wait 50 ms - this is done to show that time elapsed when
      * the timer is stopped does not have influence on the
@@ -141,10 +129,7 @@ void test_lptimer_time_accumulation()
     lp_timer.stop();
 
     /* Check results - totally 30 ms have elapsed. */
-    TEST_ASSERT_FLOAT_WITHIN(DELTA_S(30), 0.030f, lp_timer.read());
-    TEST_ASSERT_INT32_WITHIN(DELTA_MS(30), 30, lp_timer.read_ms());
-    TEST_ASSERT_INT32_WITHIN(DELTA_US(30), 30000, lp_timer.read_us());
-    TEST_ASSERT_UINT64_WITHIN(DELTA_US(30), 30000, lp_timer.read_high_resolution_us());
+    TEST_ASSERT_TIMES_EQUAL_WITHIN_TOLERANCE(30ms, lp_timer.elapsed_time());
 
     /* Wait 50 ms - this is done to show that time elapsed when
      * the timer is stopped does not have influence on the
@@ -162,10 +147,7 @@ void test_lptimer_time_accumulation()
     lp_timer.stop();
 
     /* Check results - totally 60 ms have elapsed. */
-    TEST_ASSERT_FLOAT_WITHIN(DELTA_S(60), 0.060f, lp_timer.read());
-    TEST_ASSERT_INT32_WITHIN(DELTA_MS(60), 60, lp_timer.read_ms());
-    TEST_ASSERT_INT32_WITHIN(DELTA_US(60), 60000, lp_timer.read_us());
-    TEST_ASSERT_UINT64_WITHIN(DELTA_US(60), 60000, lp_timer.read_high_resolution_us());
+    TEST_ASSERT_TIMES_EQUAL_WITHIN_TOLERANCE(60ms, lp_timer.elapsed_time());
 
     /* Wait 50 ms - this is done to show that time elapsed when
      * the timer is stopped does not have influence on the
@@ -184,10 +166,7 @@ void test_lptimer_time_accumulation()
     lp_timer.stop();
 
     /* Check results - totally 1060 ms have elapsed. */
-    TEST_ASSERT_FLOAT_WITHIN(DELTA_S(1060), 1.060f, lp_timer.read());
-    TEST_ASSERT_INT32_WITHIN(DELTA_MS(1060), 1060, lp_timer.read_ms());
-    TEST_ASSERT_INT32_WITHIN(DELTA_US(1060), 1060000, lp_timer.read_us());
-    TEST_ASSERT_UINT64_WITHIN(DELTA_US(1060), 1060000, lp_timer.read_high_resolution_us());
+    TEST_ASSERT_TIMES_EQUAL_WITHIN_TOLERANCE(1060ms, lp_timer.elapsed_time());
 }
 
 /* This test verifies if reset() function resets the
@@ -213,10 +192,7 @@ void test_lptimer_reset()
     lp_timer.stop();
 
     /* Check results - totally 10 ms elapsed. */
-    TEST_ASSERT_FLOAT_WITHIN(DELTA_S(10), 0.010f, lp_timer.read());
-    TEST_ASSERT_INT32_WITHIN(DELTA_MS(10), 10, lp_timer.read_ms());
-    TEST_ASSERT_INT32_WITHIN(DELTA_US(10), 10000, lp_timer.read_us());
-    TEST_ASSERT_UINT64_WITHIN(DELTA_US(10), 10000, lp_timer.read_high_resolution_us());
+    TEST_ASSERT_TIMES_EQUAL_WITHIN_TOLERANCE(10ms, lp_timer.elapsed_time());
 
     /* Reset the timer - previous measured time should be lost now. */
     lp_timer.reset();
@@ -231,10 +207,7 @@ void test_lptimer_reset()
     lp_timer.stop();
 
     /* Check results - 20 ms elapsed since the reset. */
-    TEST_ASSERT_FLOAT_WITHIN(DELTA_S(20), 0.020f, lp_timer.read());
-    TEST_ASSERT_INT32_WITHIN(DELTA_MS(20), 20, lp_timer.read_ms());
-    TEST_ASSERT_INT32_WITHIN(DELTA_US(20), 20000, lp_timer.read_us());
-    TEST_ASSERT_UINT64_WITHIN(DELTA_US(20), 20000, lp_timer.read_high_resolution_us());
+    TEST_ASSERT_TIMES_EQUAL_WITHIN_TOLERANCE(20ms, lp_timer.elapsed_time());
 }
 
 /* This test verifies if calling start() for already
@@ -264,34 +237,7 @@ void test_lptimer_start_started_timer()
     lp_timer.stop();
 
     /* Check results - 30 ms have elapsed since the first start. */
-    TEST_ASSERT_FLOAT_WITHIN(DELTA_S(30), 0.030f, lp_timer.read());
-    TEST_ASSERT_INT32_WITHIN(DELTA_MS(30), 30, lp_timer.read_ms());
-    TEST_ASSERT_INT32_WITHIN(DELTA_US(30), 30000, lp_timer.read_us());
-    TEST_ASSERT_UINT64_WITHIN(DELTA_US(30), 30000, lp_timer.read_high_resolution_us());
-}
-
-/* This test verifies low power timer float operator.
- *
- * Given timer is created and a time period time is counted.
- * When timer object is casted on float type.
- * Then counted type in seconds is returned by means of
- * read() function.
- */
-void test_lptimer_float_operator()
-{
-    LowPowerTimer lp_timer;
-
-    /* Start the timer. */
-    lp_timer.start();
-
-    /* Wait 10 ms. */
-    busy_wait_ms(10);
-
-    /* Stop the timer. */
-    lp_timer.stop();
-
-    /* Check result - 10 ms elapsed. */
-    TEST_ASSERT_FLOAT_WITHIN(DELTA_S(10), 0.010f, (float)(lp_timer));
+    TEST_ASSERT_TIMES_EQUAL_WITHIN_TOLERANCE(30ms, lp_timer.elapsed_time());
 }
 
 /* This test verifies if time counted by the low power timer is
@@ -307,22 +253,19 @@ void test_lptimer_time_measurement()
 {
     LowPowerTimer lp_timer;
 
-    const int delta_ms = (wait_val_us / US_PER_MSEC);
+    std::chrono::microseconds wait_val(wait_val_us);
 
     /* Start the timer. */
     lp_timer.start();
 
     /* Wait <wait_val_us> us. */
-    busy_wait_us(wait_val_us);
+    busy_wait_us(static_cast<int>(wait_val.count()));
 
     /* Stop the timer. */
     lp_timer.stop();
 
     /* Check results - wait_val_us us have elapsed. */
-    TEST_ASSERT_FLOAT_WITHIN(DELTA_S(delta_ms), (float)wait_val_us / 1000000, lp_timer.read());
-    TEST_ASSERT_INT32_WITHIN(DELTA_MS(delta_ms), wait_val_us / 1000, lp_timer.read_ms());
-    TEST_ASSERT_INT32_WITHIN(DELTA_US(delta_ms), wait_val_us, lp_timer.read_us());
-    TEST_ASSERT_UINT64_WITHIN(DELTA_US(delta_ms), wait_val_us, lp_timer.read_high_resolution_us());
+    TEST_ASSERT_TIMES_EQUAL_WITHIN_TOLERANCE(wait_val, lp_timer.elapsed_time());
 }
 
 utest::v1::status_t test_setup(const size_t number_of_cases)
@@ -336,7 +279,6 @@ Case cases[] = {
     Case("Test: LowPowerTimer - measure time accumulation.", test_lptimer_time_accumulation),
     Case("Test: LowPowerTimer - reset.", test_lptimer_reset),
     Case("Test: LowPowerTimer - start started timer.", test_lptimer_start_started_timer),
-    Case("Test: LowPowerTimer - float operator.", test_lptimer_float_operator),
     Case("Test: LowPowerTimer - time measurement 1 ms.", test_lptimer_time_measurement<1000>),
     Case("Test: LowPowerTimer - time measurement 10 ms.", test_lptimer_time_measurement<10000>),
     Case("Test: LowPowerTimer - time measurement 100 ms.", test_lptimer_time_measurement<100000>),
diff --git a/drivers/tests/TESTS/mbed_drivers/mem_trace/CMakeLists.txt b/drivers/tests/TESTS/mbed_drivers/mem_trace/CMakeLists.txt
index ec44253c407..3a5d945f6d8 100644
--- a/drivers/tests/TESTS/mbed_drivers/mem_trace/CMakeLists.txt
+++ b/drivers/tests/TESTS/mbed_drivers/mem_trace/CMakeLists.txt
@@ -10,9 +10,15 @@ include(${MBED_PATH}/tools/cmake/mbed_greentea.cmake)
 
 project(${TEST_TARGET})
 
+if(NOT "MBED_MEM_TRACING_ENABLED=1" IN_LIST MBED_CONFIG_DEFINITIONS)
+    set(TEST_SKIPPED "Memory tracing not enabled")
+endif()
+
 mbed_greentea_add_test(
     TEST_NAME
         ${TEST_TARGET}
     TEST_SOURCES
         main.cpp
+    TEST_SKIPPED
+        ${TEST_SKIPPED}
 )
diff --git a/drivers/tests/TESTS/mbed_drivers/race_test/CMakeLists.txt b/drivers/tests/TESTS/mbed_drivers/race_test/CMakeLists.txt
index 4e95b2be791..ccce698f811 100644
--- a/drivers/tests/TESTS/mbed_drivers/race_test/CMakeLists.txt
+++ b/drivers/tests/TESTS/mbed_drivers/race_test/CMakeLists.txt
@@ -1,18 +1,15 @@
 # Copyright (c) 2020 ARM Limited. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 
-cmake_minimum_required(VERSION 3.19.0 FATAL_ERROR)
-
-set(MBED_PATH ${CMAKE_CURRENT_SOURCE_DIR}/../../../../.. CACHE INTERNAL "")
-set(TEST_TARGET mbed-drivers-race-test)
-
-include(${MBED_PATH}/tools/cmake/mbed_greentea.cmake)
-
-project(${TEST_TARGET})
+if(${MBED_C_LIB} STREQUAL "small" OR MBED_GREENTEA_TEST_BAREMETAL)
+    set(TEST_SKIPPED "Mutex test cases require RTOS with multithread to run")
+endif()
 
 mbed_greentea_add_test(
     TEST_NAME
-        ${TEST_TARGET}
+        mbed-drivers-race-test
     TEST_SOURCES
         main.cpp
+    TEST_SKIPPED
+        ${TEST_SKIPPED}
 )
diff --git a/drivers/tests/TESTS/mbed_drivers/race_test/main.cpp b/drivers/tests/TESTS/mbed_drivers/race_test/main.cpp
index d5f54d87dca..2065f3c5bad 100644
--- a/drivers/tests/TESTS/mbed_drivers/race_test/main.cpp
+++ b/drivers/tests/TESTS/mbed_drivers/race_test/main.cpp
@@ -39,13 +39,13 @@ class TestClass {
 public:
     TestClass()
     {
-        ThisThread::sleep_for(500);
+        ThisThread::sleep_for(500ms);
         instance_count++;
     }
 
     void do_something()
     {
-        ThisThread::sleep_for(100);
+        ThisThread::sleep_for(100ms);
     }
 
     ~TestClass()
@@ -83,7 +83,7 @@ void test_case_func_race()
     // Start start first thread
     t1.start(cb);
     // Start second thread while the first is inside the constructor
-    ThisThread::sleep_for(250);
+    ThisThread::sleep_for(250ms);
     t2.start(cb);
 
     // Wait for the threads to finish
@@ -105,7 +105,7 @@ void test_case_class_race()
     // Start start first thread
     t1.start(cb);
     // Start second thread while the first is inside the constructor
-    ThisThread::sleep_for(250);
+    ThisThread::sleep_for(250ms);
     t2.start(cb);
 
     // Wait for the threads to finish
diff --git a/drivers/tests/TESTS/mbed_drivers/reset_reason/CMakeLists.txt b/drivers/tests/TESTS/mbed_drivers/reset_reason/CMakeLists.txt
index 3a9dea44f15..605c69a5760 100644
--- a/drivers/tests/TESTS/mbed_drivers/reset_reason/CMakeLists.txt
+++ b/drivers/tests/TESTS/mbed_drivers/reset_reason/CMakeLists.txt
@@ -1,18 +1,22 @@
 # Copyright (c) 2020 ARM Limited. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 
-cmake_minimum_required(VERSION 3.19.0 FATAL_ERROR)
+if(NOT "DEVICE_RESET_REASON=1" IN_LIST MBED_TARGET_DEFINITIONS)
+	set(TEST_SKIPPED "Reset Reason is not supported for this target")
+endif()
 
-set(MBED_PATH ${CMAKE_CURRENT_SOURCE_DIR}/../../../../.. CACHE INTERNAL "")
-set(TEST_TARGET mbed-drivers-reset-reason)
-
-include(${MBED_PATH}/tools/cmake/mbed_greentea.cmake)
-
-project(${TEST_TARGET})
+if("TARGET_MIMXRT105X" IN_LIST MBED_TARGET_DEFINITIONS)
+	# This test causes this target to die.  See https://github.com/mbed-ce/mbed-os/issues/83
+	set(TEST_SKIPPED "Temporarily disabled for this target, see #83")
+endif()
 
 mbed_greentea_add_test(
     TEST_NAME
-        ${TEST_TARGET}
+        mbed-drivers-reset-reason
     TEST_SOURCES
         main.cpp
+    HOST_TESTS_DIR
+		../../host_tests
+    TEST_SKIPPED
+        ${TEST_SKIPPED}
 )
diff --git a/drivers/tests/TESTS/mbed_drivers/rtc/CMakeLists.txt b/drivers/tests/TESTS/mbed_drivers/rtc/CMakeLists.txt
index e9ae3f128d7..6314be1f01b 100644
--- a/drivers/tests/TESTS/mbed_drivers/rtc/CMakeLists.txt
+++ b/drivers/tests/TESTS/mbed_drivers/rtc/CMakeLists.txt
@@ -1,18 +1,19 @@
 # Copyright (c) 2020 ARM Limited. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 
-cmake_minimum_required(VERSION 3.19.0 FATAL_ERROR)
+if(NOT "DEVICE_RTC=1" IN_LIST MBED_TARGET_DEFINITIONS)
+	set(TEST_SKIPPED "RTC is not supported for this target")
+endif()
 
-set(MBED_PATH ${CMAKE_CURRENT_SOURCE_DIR}/../../../../.. CACHE INTERNAL "")
-set(TEST_TARGET mbed-drivers-rtc)
-
-include(${MBED_PATH}/tools/cmake/mbed_greentea.cmake)
-
-project(${TEST_TARGET})
+if(NOT "DEVICE_USTICKER=1" IN_LIST MBED_TARGET_DEFINITIONS)
+    set(TEST_SKIPPED "Microsecond ticker required")
+endif()
 
 mbed_greentea_add_test(
     TEST_NAME
-        ${TEST_TARGET}
+        mbed-drivers-rtc
     TEST_SOURCES
         main.cpp
+    TEST_SKIPPED
+        ${TEST_SKIPPED}
 )
diff --git a/drivers/tests/TESTS/mbed_drivers/sleep_lock/CMakeLists.txt b/drivers/tests/TESTS/mbed_drivers/sleep_lock/CMakeLists.txt
index 0ca00992ab4..0c182898cb6 100644
--- a/drivers/tests/TESTS/mbed_drivers/sleep_lock/CMakeLists.txt
+++ b/drivers/tests/TESTS/mbed_drivers/sleep_lock/CMakeLists.txt
@@ -1,18 +1,15 @@
 # Copyright (c) 2020 ARM Limited. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 
-cmake_minimum_required(VERSION 3.19.0 FATAL_ERROR)
-
-set(MBED_PATH ${CMAKE_CURRENT_SOURCE_DIR}/../../../../.. CACHE INTERNAL "")
-set(TEST_TARGET mbed-drivers-sleep-lock)
-
-include(${MBED_PATH}/tools/cmake/mbed_greentea.cmake)
-
-project(${TEST_TARGET})
+if(NOT "DEVICE_SLEEP=1" IN_LIST MBED_TARGET_DEFINITIONS)
+	set(TEST_SKIPPED "Sleep is not supported for this target")
+endif()
 
 mbed_greentea_add_test(
     TEST_NAME
-        ${TEST_TARGET}
+        mbed-drivers-sleep-lock
     TEST_SOURCES
         main.cpp
+    TEST_SKIPPED
+        ${TEST_SKIPPED}
 )
diff --git a/drivers/tests/TESTS/mbed_drivers/stl_features/CMakeLists.txt b/drivers/tests/TESTS/mbed_drivers/stl_features/CMakeLists.txt
index 1c0d49499b4..dd60b26ef3c 100644
--- a/drivers/tests/TESTS/mbed_drivers/stl_features/CMakeLists.txt
+++ b/drivers/tests/TESTS/mbed_drivers/stl_features/CMakeLists.txt
@@ -1,18 +1,9 @@
 # Copyright (c) 2020 ARM Limited. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 
-cmake_minimum_required(VERSION 3.19.0 FATAL_ERROR)
-
-set(MBED_PATH ${CMAKE_CURRENT_SOURCE_DIR}/../../../../.. CACHE INTERNAL "")
-set(TEST_TARGET mbed-drivers-stl-features)
-
-include(${MBED_PATH}/tools/cmake/mbed_greentea.cmake)
-
-project(${TEST_TARGET})
-
 mbed_greentea_add_test(
     TEST_NAME
-        ${TEST_TARGET}
+        mbed-drivers-stl-features
     TEST_SOURCES
         main.cpp
 )
diff --git a/drivers/tests/TESTS/mbed_drivers/timeout/CMakeLists.txt b/drivers/tests/TESTS/mbed_drivers/timeout/CMakeLists.txt
index 58e37b1372b..7737004c4b2 100644
--- a/drivers/tests/TESTS/mbed_drivers/timeout/CMakeLists.txt
+++ b/drivers/tests/TESTS/mbed_drivers/timeout/CMakeLists.txt
@@ -1,18 +1,15 @@
 # Copyright (c) 2020 ARM Limited. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 
-cmake_minimum_required(VERSION 3.19.0 FATAL_ERROR)
-
-set(MBED_PATH ${CMAKE_CURRENT_SOURCE_DIR}/../../../../.. CACHE INTERNAL "")
-set(TEST_TARGET mbed-drivers-timeout)
-
-include(${MBED_PATH}/tools/cmake/mbed_greentea.cmake)
-
-project(${TEST_TARGET})
+if(NOT "DEVICE_USTICKER=1" IN_LIST MBED_TARGET_DEFINITIONS)
+    set(TEST_SKIPPED "Microsecond ticker required")
+endif()
 
 mbed_greentea_add_test(
     TEST_NAME
-        ${TEST_TARGET}
+        mbed-drivers-timeout
     TEST_SOURCES
         main.cpp
+    TEST_SKIPPED
+        ${TEST_SKIPPED}
 )
diff --git a/drivers/tests/TESTS/mbed_drivers/timer/CMakeLists.txt b/drivers/tests/TESTS/mbed_drivers/timer/CMakeLists.txt
index 983f213c8e5..0510ecf6db9 100644
--- a/drivers/tests/TESTS/mbed_drivers/timer/CMakeLists.txt
+++ b/drivers/tests/TESTS/mbed_drivers/timer/CMakeLists.txt
@@ -1,18 +1,15 @@
 # Copyright (c) 2020 ARM Limited. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 
-cmake_minimum_required(VERSION 3.19.0 FATAL_ERROR)
-
-set(MBED_PATH ${CMAKE_CURRENT_SOURCE_DIR}/../../../../.. CACHE INTERNAL "")
-set(TEST_TARGET mbed-drivers-timer)
-
-include(${MBED_PATH}/tools/cmake/mbed_greentea.cmake)
-
-project(${TEST_TARGET})
+if(NOT "DEVICE_USTICKER=1" IN_LIST MBED_TARGET_DEFINITIONS)
+    set(TEST_SKIPPED "Microsecond ticker required")
+endif()
 
 mbed_greentea_add_test(
     TEST_NAME
-        ${TEST_TARGET}
+        mbed-drivers-timer
     TEST_SOURCES
         main.cpp
+    TEST_SKIPPED
+        ${TEST_SKIPPED}
 )
diff --git a/drivers/tests/TESTS/mbed_drivers/timerevent/CMakeLists.txt b/drivers/tests/TESTS/mbed_drivers/timerevent/CMakeLists.txt
index cb36315bb2e..c4fe068b92d 100644
--- a/drivers/tests/TESTS/mbed_drivers/timerevent/CMakeLists.txt
+++ b/drivers/tests/TESTS/mbed_drivers/timerevent/CMakeLists.txt
@@ -1,18 +1,17 @@
 # Copyright (c) 2020 ARM Limited. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 
-cmake_minimum_required(VERSION 3.19.0 FATAL_ERROR)
-
-set(MBED_PATH ${CMAKE_CURRENT_SOURCE_DIR}/../../../../.. CACHE INTERNAL "")
-set(TEST_TARGET mbed-drivers-timerevent)
-
-include(${MBED_PATH}/tools/cmake/mbed_greentea.cmake)
-
-project(${TEST_TARGET})
+if(NOT "DEVICE_USTICKER=1" IN_LIST MBED_TARGET_DEFINITIONS)
+    set(TEST_SKIPPED "Microsecond ticker required")
+endif()
 
 mbed_greentea_add_test(
     TEST_NAME
-        ${TEST_TARGET}
+        mbed-drivers-timerevent
     TEST_SOURCES
         main.cpp
+    HOST_TESTS_DIR
+		../../host_tests
+    TEST_SKIPPED
+        ${TEST_SKIPPED}
 )
diff --git a/drivers/tests/TESTS/mbed_drivers/timerevent/main.cpp b/drivers/tests/TESTS/mbed_drivers/timerevent/main.cpp
index 99c429b2eff..9248a90b844 100644
--- a/drivers/tests/TESTS/mbed_drivers/timerevent/main.cpp
+++ b/drivers/tests/TESTS/mbed_drivers/timerevent/main.cpp
@@ -29,7 +29,9 @@
 using namespace utest::v1;
 
 #define TEST_DELAY_US 50000ULL
-#define DELTA         2
+#define TEST_DELAY_CHRONO std::chrono::microseconds(TEST_DELAY_US)
+#define TEST_DELAY_CHRONO_MS std::chrono::duration_cast<std::chrono::milliseconds>(TEST_DELAY_CHRONO)
+#define DELTA 2ms
 
 class TestTimerEvent: public TimerEvent {
 private:
@@ -62,12 +64,17 @@ class TestTimerEvent: public TimerEvent {
     using TimerEvent::insert_absolute;
     using TimerEvent::remove;
 
-    bool sem_try_acquire(uint32_t millisec)
+    bool sem_try_acquire(std::chrono::milliseconds millisec)
     {
         return sem.try_acquire_for(millisec);
     }
 };
 
+// TestTimerEventRelative tests the deprecated insert() function, so
+// don't warn about it being deprecated
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
 class TestTimerEventRelative: public TestTimerEvent {
 public:
     static const bool SEM_ACQUIRED_AFTER_PAST_TS_INSERTED = false;
@@ -93,6 +100,8 @@ class TestTimerEventRelative: public TestTimerEvent {
     }
 };
 
+#pragma GCC diagnostic pop
+
 class TestTimerEventAbsolute: public TestTimerEvent {
 public:
     static const bool SEM_ACQUIRED_AFTER_PAST_TS_INSERTED = true;
@@ -109,12 +118,12 @@ class TestTimerEventAbsolute: public TestTimerEvent {
     // Set absolute timestamp of internal event to present_time + ts
     void set_future_timestamp(us_timestamp_t ts)
     {
-        insert_absolute(::ticker_read_us(_ticker_data) + ts);
+        insert_absolute(_ticker_data.now() + std::chrono::microseconds(ts));
     }
 
-    void set_past_timestamp(void)
+    void set_past_timestamp()
     {
-        insert_absolute(::ticker_read_us(_ticker_data) - 1ULL);
+        insert_absolute(_ticker_data.now() - 1us);
     }
 };
 
@@ -138,10 +147,10 @@ void test_insert(void)
     T tte;
 
     tte.set_future_timestamp(TEST_DELAY_US);
-    bool acquired = tte.sem_try_acquire(0);
+    bool acquired = tte.sem_try_acquire(0ms);
     TEST_ASSERT_FALSE(acquired);
 
-    acquired = tte.sem_try_acquire(TEST_DELAY_US / 1000 + DELTA);
+    acquired = tte.sem_try_acquire(TEST_DELAY_CHRONO_MS + DELTA);
     TEST_ASSERT_TRUE(acquired);
 
     tte.remove();
@@ -167,11 +176,11 @@ void test_remove(void)
     T tte;
 
     tte.set_future_timestamp(TEST_DELAY_US * 2);
-    bool acquired = tte.sem_try_acquire(TEST_DELAY_US / 1000);
+    bool acquired = tte.sem_try_acquire(TEST_DELAY_CHRONO_MS);
     TEST_ASSERT_FALSE(acquired);
     tte.remove();
 
-    acquired = tte.sem_try_acquire(TEST_DELAY_US * 2 / 1000 + DELTA);
+    acquired = tte.sem_try_acquire(TEST_DELAY_CHRONO_MS * 2 + DELTA);
     TEST_ASSERT_FALSE(acquired);
 }
 
@@ -184,8 +193,8 @@ void test_insert_zero(void)
 {
     TestTimerEvent tte;
 
-    tte.insert_absolute(0ULL);
-    bool acquired = tte.sem_try_acquire(0);
+    tte.insert_absolute(TickerDataClock::time_point(0us));
+    bool acquired = tte.sem_try_acquire(0ms);
     TEST_ASSERT_TRUE(acquired);
 
     tte.remove();
@@ -212,7 +221,7 @@ void test_insert_past(void)
     T tte;
 
     tte.set_past_timestamp();
-    bool acquired = tte.sem_try_acquire(0);
+    bool acquired = tte.sem_try_acquire(0ms);
     TEST_ASSERT_EQUAL(tte.SEM_ACQUIRED_AFTER_PAST_TS_INSERTED, acquired);
 
     tte.remove();
diff --git a/drivers/tests/TESTS/mbed_drivers/unbuffered_serial/CMakeLists.txt b/drivers/tests/TESTS/mbed_drivers/unbuffered_serial/CMakeLists.txt
index 08b37e0f7a3..ff3c000d870 100644
--- a/drivers/tests/TESTS/mbed_drivers/unbuffered_serial/CMakeLists.txt
+++ b/drivers/tests/TESTS/mbed_drivers/unbuffered_serial/CMakeLists.txt
@@ -1,18 +1,13 @@
 # Copyright (c) 2020 ARM Limited. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 
-cmake_minimum_required(VERSION 3.19.0 FATAL_ERROR)
-
-set(MBED_PATH ${CMAKE_CURRENT_SOURCE_DIR}/../../../../.. CACHE INTERNAL "")
-set(TEST_TARGET mbed-drivers-unbuffered-serial)
-
-include(${MBED_PATH}/tools/cmake/mbed_greentea.cmake)
-
-project(${TEST_TARGET})
-
 mbed_greentea_add_test(
     TEST_NAME
-        ${TEST_TARGET}
+        mbed-drivers-unbuffered-serial
     TEST_SOURCES
         main.cpp
+    HOST_TESTS_DIR
+		../../host_tests
+    TEST_SKIPPED
+        ${TEST_SKIPPED}
 )
diff --git a/drivers/tests/TESTS/mbed_drivers/watchdog/CMakeLists.txt b/drivers/tests/TESTS/mbed_drivers/watchdog/CMakeLists.txt
index 579c438e2c7..615d50411ee 100644
--- a/drivers/tests/TESTS/mbed_drivers/watchdog/CMakeLists.txt
+++ b/drivers/tests/TESTS/mbed_drivers/watchdog/CMakeLists.txt
@@ -1,18 +1,17 @@
 # Copyright (c) 2020 ARM Limited. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 
-cmake_minimum_required(VERSION 3.19.0 FATAL_ERROR)
-
-set(MBED_PATH ${CMAKE_CURRENT_SOURCE_DIR}/../../../../.. CACHE INTERNAL "")
-set(TEST_TARGET mbed-drivers-watchdog)
-
-include(${MBED_PATH}/tools/cmake/mbed_greentea.cmake)
-
-project(${TEST_TARGET})
+if(NOT "DEVICE_WATCHDOG=1" IN_LIST MBED_TARGET_DEFINITIONS)
+	set(TEST_SKIPPED "Watchdog is not supported for this target")
+endif()
 
 mbed_greentea_add_test(
     TEST_NAME
-        ${TEST_TARGET}
+        mbed-drivers-watchdog
     TEST_SOURCES
         main.cpp
+    HOST_TESTS_DIR
+		../../host_tests
+    TEST_SKIPPED
+        ${TEST_SKIPPED}
 )
diff --git a/drivers/tests/TESTS/mbed_drivers/watchdog/main.cpp b/drivers/tests/TESTS/mbed_drivers/watchdog/main.cpp
index c81444945b0..bf9add3c7f2 100644
--- a/drivers/tests/TESTS/mbed_drivers/watchdog/main.cpp
+++ b/drivers/tests/TESTS/mbed_drivers/watchdog/main.cpp
@@ -28,12 +28,12 @@
 #include <stdlib.h>
 
 /* The shortest timeout value, this test suite is able to handle correctly. */
-#define WDG_MIN_TIMEOUT_MS 50UL
+#define WDG_MIN_TIMEOUT_MS 50ms
 
 // Do not set watchdog timeout shorter than WDG_MIN_TIMEOUT_MS, as it may
 // cause the host-test-runner return 'TIMEOUT' instead of 'FAIL' / 'PASS'
 // if watchdog performs reset during test suite teardown.
-#define WDG_TIMEOUT_MS 100UL
+#define WDG_TIMEOUT_MS 100ms
 
 #define MSG_VALUE_DUMMY "0"
 #define MSG_VALUE_LEN 24
@@ -56,7 +56,7 @@
  * (1 start_bit + 8 data_bits + 1 stop_bit) * 128 * 1000 / 9600 = 133.3 ms.
  * To be on the safe side, set the wait time to 150 ms.
  */
-#define SERIAL_FLUSH_TIME_MS 150
+#define SERIAL_FLUSH_TIME_MS 150ms
 
 int CASE_INDEX_START;
 int CASE_INDEX_CURRENT;
@@ -116,12 +116,12 @@ void test_restart()
 
     Watchdog &watchdog = Watchdog::get_instance();
     uint32_t max_timeout = watchdog.get_max_timeout();
-    uint32_t timeouts[] = {
-        max_timeout / 4,
-        max_timeout / 8,
-        max_timeout / 16
+    std::chrono::milliseconds timeouts[] = {
+        max_timeout * 1ms / 4,
+        max_timeout * 1ms / 8,
+        max_timeout * 1ms / 16
     };
-    int num_timeouts = sizeof timeouts / sizeof timeouts[0];
+    size_t num_timeouts = sizeof timeouts / sizeof timeouts[0];
 
     for (size_t i = 0; i < num_timeouts; i++) {
         if (timeouts[i] < WDG_MIN_TIMEOUT_MS) {
@@ -132,7 +132,7 @@ void test_restart()
 
         TEST_ASSERT_TRUE(watchdog.start(timeouts[i]));
         TEST_ASSERT_TRUE(watchdog.is_running());
-        uint32_t actual_timeout = watchdog.get_timeout();
+        std::chrono::milliseconds actual_timeout = watchdog.get_timeout() * 1ms;
         TEST_ASSERT_TRUE(watchdog.stop());
         TEST_ASSERT_FALSE(watchdog.is_running());
         // The watchdog should trigger at, or after the timeout value.
@@ -158,7 +158,7 @@ utest::v1::status_t case_teardown_sync_on_reset(const Case *const source, const
     // Start kicking the watchdog during teardown.
     hal_watchdog_kick();
     Ticker wdg_kicking_ticker;
-    wdg_kicking_ticker.attach_us(mbed::callback(hal_watchdog_kick), 20000);
+    wdg_kicking_ticker.attach(mbed::callback(hal_watchdog_kick), 20ms);
     utest::v1::status_t status = utest::v1::greentea_case_teardown_handler(source, passed, failed, failure);
     if (failed) {
         /* Return immediately and skip the device reset, if the test case failed.
@@ -196,18 +196,19 @@ utest::v1::status_t case_teardown_wdg_stop_or_reset(const Case *const source, co
 template<uint32_t timeout_ms>
 void test_start()
 {
-    if (timeout_ms < WDG_MIN_TIMEOUT_MS) {
+    const std::chrono::milliseconds timeout(timeout_ms);
+    if (timeout < WDG_MIN_TIMEOUT_MS) {
         CASE_IGNORED = true;
         TEST_IGNORE_MESSAGE("Requested timeout value is too short -- ignoring test case.");
         return;
     }
     Watchdog &watchdog = Watchdog::get_instance();
-    TEST_ASSERT_TRUE(watchdog.start(timeout_ms));
-    uint32_t actual_timeout = watchdog.get_timeout();
+    TEST_ASSERT_TRUE(watchdog.start(timeout));
+    auto actual_timeout = watchdog.get_timeout() * 1ms;
     // The watchdog should trigger at, or after the timeout value.
-    TEST_ASSERT(actual_timeout >= timeout_ms);
+    TEST_ASSERT(actual_timeout >= timeout);
     // The watchdog should trigger before twice the timeout value.
-    TEST_ASSERT(actual_timeout < 2 * timeout_ms);
+    TEST_ASSERT(actual_timeout < 2 * timeout);
 }
 
 void test_start_max_timeout()
@@ -219,7 +220,7 @@ void test_start_max_timeout()
     TEST_ASSERT(watchdog.get_timeout() >= max_timeout);
 }
 
-int testsuite_setup_sync_on_reset(const size_t number_of_cases)
+utest::v1::status_t testsuite_setup_sync_on_reset(const size_t number_of_cases)
 {
     GREENTEA_SETUP(45, "sync_on_reset");
     utest::v1::status_t status = utest::v1::greentea_test_setup_handler(number_of_cases);
@@ -246,7 +247,7 @@ int testsuite_setup_sync_on_reset(const size_t number_of_cases)
     }
 
     utest_printf("Starting with test case index %i of all %i defined test cases.\n", CASE_INDEX_START, number_of_cases);
-    return CASE_INDEX_START;
+    return static_cast<utest::v1::status_t>(CASE_INDEX_START);
 }
 
 Case cases[] = {
@@ -261,7 +262,7 @@ Case cases[] = {
          test_start_max_timeout, (utest::v1::case_teardown_handler_t) case_teardown_sync_on_reset),
 };
 
-Specification specification((utest::v1::test_setup_handler_t) testsuite_setup_sync_on_reset, cases);
+Specification specification(testsuite_setup_sync_on_reset, cases);
 
 int main()
 {
diff --git a/drivers/tests/TESTS/mbed_drivers/watchdog_reset/CMakeLists.txt b/drivers/tests/TESTS/mbed_drivers/watchdog_reset/CMakeLists.txt
index 3313c0d5ab7..76f25128102 100644
--- a/drivers/tests/TESTS/mbed_drivers/watchdog_reset/CMakeLists.txt
+++ b/drivers/tests/TESTS/mbed_drivers/watchdog_reset/CMakeLists.txt
@@ -1,18 +1,22 @@
 # Copyright (c) 2020 ARM Limited. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 
-cmake_minimum_required(VERSION 3.19.0 FATAL_ERROR)
+if(NOT "DEVICE_WATCHDOG=1" IN_LIST MBED_TARGET_DEFINITIONS)
+	set(TEST_SKIPPED "Watchdog is not supported for this target")
+endif()
 
-set(MBED_PATH ${CMAKE_CURRENT_SOURCE_DIR}/../../../../.. CACHE INTERNAL "")
-set(TEST_TARGET mbed-drivers-watchdog-reset)
-
-include(${MBED_PATH}/tools/cmake/mbed_greentea.cmake)
-
-project(${TEST_TARGET})
+if("TARGET_MIMXRT105X" IN_LIST MBED_TARGET_DEFINITIONS)
+	# This test causes this target to die.  See https://github.com/mbed-ce/mbed-os/issues/83
+	set(TEST_SKIPPED "Temporarily disabled for this target, see #83")
+endif()
 
 mbed_greentea_add_test(
     TEST_NAME
-        ${TEST_TARGET}
+        mbed-drivers-watchdog-reset
     TEST_SOURCES
         main.cpp
+    HOST_TESTS_DIR
+		../../host_tests
+    TEST_SKIPPED
+        ${TEST_SKIPPED}
 )
diff --git a/drivers/tests/TESTS/mbed_drivers/watchdog_reset/main.cpp b/drivers/tests/TESTS/mbed_drivers/watchdog_reset/main.cpp
index a8311a6f0ae..c1cb7b90cb6 100644
--- a/drivers/tests/TESTS/mbed_drivers/watchdog_reset/main.cpp
+++ b/drivers/tests/TESTS/mbed_drivers/watchdog_reset/main.cpp
@@ -24,8 +24,9 @@
 #include "drivers/Watchdog.h"
 #include "Watchdog_reset_tests.h"
 #include "mbed.h"
+#include <cinttypes>
 
-#define TIMEOUT_MS 100UL
+#define TIMEOUT_MS 100ms
 
 /* This value is used to calculate the time to kick the watchdog.
  * Given the watchdog timeout is set to TIMEOUT_MS, the kick will be performed
@@ -40,7 +41,7 @@
  * and as short as 66 ms.
  * The value of 35 ms is used to cover the worst case scenario (66 ms).
  */
-#define KICK_ADVANCE_MS 35UL
+#define KICK_ADVANCE_MS 35ms
 
 #define MSG_VALUE_DUMMY "0"
 #define CASE_DATA_INVALID 0xffffffffUL
@@ -66,11 +67,11 @@
  * (1 start_bit + 8 data_bits + 1 stop_bit) * 128 * 1000 / 9600 = 133.3 ms.
  * To be on the safe side, set the wait time to 150 ms.
  */
-#define SERIAL_FLUSH_TIME_MS 150
+#define SERIAL_FLUSH_TIME_MS 150ms
 
-#define TIMEOUT_US (1000 * (TIMEOUT_MS))
-#define KICK_ADVANCE_US (1000 * (KICK_ADVANCE_MS))
-#define SERIAL_FLUSH_TIME_US (1000 * (SERIAL_FLUSH_TIME_MS))
+#define TIMEOUT_US std::chrono::duration_cast<std::chrono::microseconds>(TIMEOUT_MS).count()
+#define KICK_ADVANCE_US std::chrono::duration_cast<std::chrono::microseconds>(KICK_ADVANCE_MS).count()
+#define SERIAL_FLUSH_TIME_US std::chrono::duration_cast<std::chrono::microseconds>(SERIAL_FLUSH_TIME_MS).count()
 
 using utest::v1::Case;
 using utest::v1::Specification;
@@ -88,10 +89,10 @@ testcase_data current_case;
 
 Ticker wdg_kicking_ticker;
 
-bool send_reset_notification(testcase_data *tcdata, uint32_t delay_ms)
+bool send_reset_notification(testcase_data *tcdata, std::chrono::milliseconds delay_ms)
 {
     char msg_value[12];
-    int str_len = snprintf(msg_value, sizeof msg_value, "%02x,%08lx", tcdata->start_index + tcdata->index, delay_ms);
+    int str_len = snprintf(msg_value, sizeof msg_value, "%02x,%08" PRIi64, tcdata->start_index + tcdata->index, delay_ms.count());
     if (str_len < 0) {
         utest_printf("Failed to compose a value string to be sent to host.");
         return false;
@@ -112,7 +113,7 @@ void test_simple_reset()
 
     // Phase 1. -- run the test code.
     // Init the watchdog and wait for a device reset.
-    if (send_reset_notification(&current_case, 2 * TIMEOUT_MS + SERIAL_FLUSH_TIME_MS) == false) {
+    if (!send_reset_notification(&current_case, 2 * TIMEOUT_MS + SERIAL_FLUSH_TIME_MS)) {
         TEST_ASSERT_MESSAGE(0, "Dev-host communication error.");
         return;
     }
@@ -127,7 +128,7 @@ void test_simple_reset()
     // Watchdog reset should have occurred during a wait above.
 
     hal_watchdog_kick();
-    wdg_kicking_ticker.attach_us(mbed::callback(hal_watchdog_kick), 20000); // For testsuite failure handling.
+    wdg_kicking_ticker.attach(mbed::callback(hal_watchdog_kick), 20ms); // For testsuite failure handling.
     TEST_ASSERT_MESSAGE(0, "Watchdog did not reset the device as expected.");
 }
 
@@ -142,7 +143,7 @@ void test_sleep_reset()
     }
 
     // Phase 1. -- run the test code.
-    if (send_reset_notification(&current_case, 2 * TIMEOUT_MS + SERIAL_FLUSH_TIME_MS) == false) {
+    if (!send_reset_notification(&current_case, 2 * TIMEOUT_MS + SERIAL_FLUSH_TIME_MS)) {
         TEST_ASSERT_MESSAGE(0, "Dev-host communication error.");
         return;
     }
@@ -163,7 +164,7 @@ void test_sleep_reset()
     // Watchdog reset should have occurred during the sleep above.
 
     hal_watchdog_kick();
-    wdg_kicking_ticker.attach_us(mbed::callback(hal_watchdog_kick), 20000); // For testsuite failure handling.
+    wdg_kicking_ticker.attach(mbed::callback(hal_watchdog_kick), 20ms); // For testsuite failure handling.
     TEST_ASSERT_MESSAGE(0, "Watchdog did not reset the device as expected.");
 }
 
@@ -178,7 +179,7 @@ void test_deepsleep_reset()
     }
 
     // Phase 1. -- run the test code.
-    if (send_reset_notification(&current_case, 2 * TIMEOUT_MS + SERIAL_FLUSH_TIME_MS) == false) {
+    if (!send_reset_notification(&current_case, 2 * TIMEOUT_MS + SERIAL_FLUSH_TIME_MS)) {
         TEST_ASSERT_MESSAGE(0, "Dev-host communication error.");
         return;
     }
@@ -187,9 +188,13 @@ void test_deepsleep_reset()
     TEST_ASSERT_FALSE(watchdog.is_running());
     TEST_ASSERT_TRUE(watchdog.start(TIMEOUT_MS));
     TEST_ASSERT_TRUE(watchdog.is_running());
-    if (!sleep_manager_can_deep_sleep()) {
-        TEST_ASSERT_MESSAGE(0, "Deepsleep should be allowed.");
-    }
+
+    /* Some targets may forbid deep sleep immediately after the LP ticker is
+     * set to a new time (e.g. immediately after one scheduler tick happens
+     * and schedules the next scheduler tick).  Wait for that time to elapse
+     * if needed, then make sure we can deep sleep. */
+    TEST_ASSERT_TRUE_MESSAGE(sleep_manager_can_deep_sleep_test_check(),
+                             "Deepsleep should be allowed.");
 
     // The Watchdog reset is allowed to be delayed up to twice the timeout
     // value when the deepsleep mode is active.
@@ -200,7 +205,7 @@ void test_deepsleep_reset()
     // Watchdog reset should have occurred during the deepsleep above.
 
     hal_watchdog_kick();
-    wdg_kicking_ticker.attach_us(mbed::callback(hal_watchdog_kick), 20000); // For testsuite failure handling.
+    wdg_kicking_ticker.attach(mbed::callback(hal_watchdog_kick), 20ms); // For testsuite failure handling.
     TEST_ASSERT_MESSAGE(0, "Watchdog did not reset the device as expected.");
 }
 #endif
@@ -234,7 +239,7 @@ void test_restart_reset()
     // The watchdog should trigger before twice the timeout value.
     wait_us(TIMEOUT_US / 2 + TIMEOUT_US);
 
-    if (send_reset_notification(&current_case, 2 * TIMEOUT_MS + SERIAL_FLUSH_TIME_MS) == false) {
+    if (!send_reset_notification(&current_case, 2 * TIMEOUT_MS + SERIAL_FLUSH_TIME_MS)) {
         TEST_ASSERT_MESSAGE(0, "Dev-host communication error.");
         return;
     }
@@ -247,7 +252,7 @@ void test_restart_reset()
     // Watchdog reset should have occurred during a wait above.
 
     hal_watchdog_kick();
-    wdg_kicking_ticker.attach_us(mbed::callback(hal_watchdog_kick), 20000); // For testsuite failure handling.
+    wdg_kicking_ticker.attach(mbed::callback(hal_watchdog_kick), 20ms); // For testsuite failure handling.
     TEST_ASSERT_MESSAGE(0, "Watchdog did not reset the device as expected.");
 }
 
@@ -271,7 +276,7 @@ void test_kick_reset()
         wait_us(TIMEOUT_US - KICK_ADVANCE_US);
         watchdog.kick();
     }
-    if (send_reset_notification(&current_case, 2 * TIMEOUT_MS + SERIAL_FLUSH_TIME_MS) == false) {
+    if (!send_reset_notification(&current_case, 2 * TIMEOUT_MS + SERIAL_FLUSH_TIME_MS)) {
         TEST_ASSERT_MESSAGE(0, "Dev-host communication error.");
         return;
     }
@@ -282,7 +287,7 @@ void test_kick_reset()
     // Watchdog reset should have occurred during a wait above.
 
     hal_watchdog_kick();
-    wdg_kicking_ticker.attach_us(mbed::callback(hal_watchdog_kick), 20000); // For testsuite failure handling.
+    wdg_kicking_ticker.attach(mbed::callback(hal_watchdog_kick), 20ms); // For testsuite failure handling.
     TEST_ASSERT_MESSAGE(0, "Watchdog did not reset the device as expected.");
 }
 
@@ -292,7 +297,7 @@ utest::v1::status_t case_setup(const Case *const source, const size_t index_of_c
     return utest::v1::greentea_case_setup_handler(source, index_of_case);
 }
 
-int testsuite_setup(const size_t number_of_cases)
+utest::v1::status_t testsuite_setup(const size_t number_of_cases)
 {
     GREENTEA_SETUP(90, "watchdog_reset");
     utest::v1::status_t status = utest::v1::greentea_test_setup_handler(number_of_cases);
@@ -319,22 +324,22 @@ int testsuite_setup(const size_t number_of_cases)
 
     utest_printf("This test suite is composed of %i test cases. Starting at index %i.\n", number_of_cases,
                  current_case.start_index);
-    return current_case.start_index;
+    return static_cast<utest::v1::status_t>(current_case.start_index);
 }
 
 Case cases[] = {
-    Case("Watchdog reset", case_setup, test_simple_reset),
+    //Case("Watchdog reset", case_setup, test_simple_reset),
 #if DEVICE_SLEEP
-    Case("Watchdog reset in sleep mode", case_setup, test_sleep_reset),
+    //Case("Watchdog reset in sleep mode", case_setup, test_sleep_reset),
 #if DEVICE_LPTICKER
     Case("Watchdog reset in deepsleep mode", case_setup, test_deepsleep_reset),
 #endif
 #endif
-    Case("Watchdog started again", case_setup, test_restart_reset),
-    Case("Kicking the Watchdog prevents reset", case_setup, test_kick_reset),
+    //Case("Watchdog started again", case_setup, test_restart_reset),
+    //Case("Kicking the Watchdog prevents reset", case_setup, test_kick_reset),
 };
 
-Specification specification((utest::v1::test_setup_handler_t) testsuite_setup, cases);
+Specification specification( testsuite_setup, cases);
 
 int main()
 {
diff --git a/hal/tests/TESTS/mbed_hal/sleep/main.cpp b/hal/tests/TESTS/mbed_hal/sleep/main.cpp
index 06b0d416d5b..911328d392f 100644
--- a/hal/tests/TESTS/mbed_hal/sleep/main.cpp
+++ b/hal/tests/TESTS/mbed_hal/sleep/main.cpp
@@ -85,7 +85,7 @@ void sleep_usticker_test()
 
         const unsigned int wakeup_timestamp = us_ticker_read();
 
-        sprintf(info, "Delta ticks: %u, Ticker width: %u, Expected wake up tick: %d, Actual wake up tick: %d, delay ticks: %d, wake up after ticks: %d",
+        sprintf(info, "Delta ticks: %u, Ticker width: %u, Expected wake up tick: %" PRIu32 ", Actual wake up tick: %u, delay ticks: %u, wake up after ticks: %" PRIu32,
                 us_to_ticks(sleep_mode_delta_us, ticker_freq), ticker_width, next_match_timestamp, wakeup_timestamp, us_to_ticks(i, ticker_freq), wakeup_timestamp - start_timestamp);
 
         TEST_ASSERT_MESSAGE(compare_timestamps(us_to_ticks(sleep_mode_delta_us, ticker_freq),
diff --git a/hal/tests/TESTS/mbed_hal/us_ticker/CMakeLists.txt b/hal/tests/TESTS/mbed_hal/us_ticker/CMakeLists.txt
index 85578939bd3..d5115ac3cee 100644
--- a/hal/tests/TESTS/mbed_hal/us_ticker/CMakeLists.txt
+++ b/hal/tests/TESTS/mbed_hal/us_ticker/CMakeLists.txt
@@ -1,6 +1,10 @@
 # Copyright (c) 2020 ARM Limited. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 
+if(NOT "DEVICE_USTICKER=1" IN_LIST MBED_TARGET_DEFINITIONS)
+    set(TEST_SKIPPED "Microsecond ticker required")
+endif()
+
 mbed_greentea_add_test(
 	TEST_NAME
 		mbed-hal-us-ticker
@@ -8,4 +12,6 @@ mbed_greentea_add_test(
 		main.cpp
 	HOST_TESTS_DIR
 		${CMAKE_CURRENT_SOURCE_DIR}/../../host_tests
+	TEST_SKIPPED
+		${TEST_SKIPPED}
 )
diff --git a/tools/cmake/mbed_greentea.cmake b/tools/cmake/mbed_greentea.cmake
index 5695b84d640..bca67c94767 100644
--- a/tools/cmake/mbed_greentea.cmake
+++ b/tools/cmake/mbed_greentea.cmake
@@ -8,11 +8,12 @@ set(MBED_GREENTEA_SERIAL_PORT "" CACHE STRING "Serial port name to talk to the M
 
 # CMake Macro for generalizing CMake configuration across the greentea test suite with configurable parameters
 # Macro args:
-# TEST_NAME - Test suite name
+# TEST_NAME - Test suite name (will have "test-" prepended to it)
 # TEST_INCLUDE_DIRS - Test suite include directories for the test
 # TEST_SOURCES - Test suite sources
 # TEST_REQUIRED_LIBS - Test suite required libraries
-# HOST_TESTS_DIR - Path to the "host_tests" directory
+# HOST_TESTS_DIR - Path to the "host_tests" directory.  If a relative path is provided, it will be
+#    interpreted relative to the source directory.
 # TEST_SKIPPED - Reason if suite is skipped
 #
 # calling the macro:
@@ -59,6 +60,9 @@ function(mbed_greentea_add_test)
         message(FATAL_ERROR "Will not be able to run greentea tests without MBED_GREENTEA_SERIAL_PORT defined!")
     endif()
 
+    # Add a "test-" prefix to help distinguish test targets in the target list
+    set(MBED_GREENTEA_TEST_NAME "test-${MBED_GREENTEA_TEST_NAME}")
+
     if(NOT "${MBED_GREENTEA_TEST_SKIPPED}" STREQUAL "")
         add_test(
             NAME
@@ -116,6 +120,10 @@ function(mbed_greentea_add_test)
     endif()
 
     if(DEFINED MBED_GREENTEA_HOST_TESTS_DIR)
+
+        # Convert relative path into absolute if given
+        get_filename_component(MBED_GREENTEA_HOST_TESTS_DIR ${MBED_GREENTEA_HOST_TESTS_DIR} ABSOLUTE BASE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
+
         list(APPEND MBED_HTRUN_ARGUMENTS "-e;${MBED_GREENTEA_HOST_TESTS_DIR}")
     endif()