Merge pull request #7122 from ARMmbed/5.9-release-candidate

Release candidate 2 for mbed-os-5.9.0

Author: 0xc0170

TESTS/mbed_drivers/timer/main.cpp

@@ -45,9 +45,15 @@ extern uint32_t SystemCoreClock;
  * 1000 ms delay: tolerance = 20500 us
  *
  *  */
-#define DELTA_US(delay_ms) (500 + (delay_ms) * US_PER_MSEC / 50)
-#define DELTA_MS(delay_ms) (1 + ((delay_ms) * US_PER_MSEC / 50 / US_PER_MSEC))
-#define DELTA_S(delay_ms) (0.000500f + (((float)(delay_ms)) / MSEC_PER_SEC / 50))
+#ifdef NO_SYSTICK
+#define TOLERANCE 5
+#else
+#define TOLERANCE 2
+#endif
+
+#define DELTA_US(delay_ms) (500 + (delay_ms) * US_PER_MSEC  * TOLERANCE / 100)
+#define DELTA_MS(delay_ms) (1 + (delay_ms) * TOLERANCE / 100)
+#define DELTA_S(delay_ms) (0.000500f + ((float)(delay_ms)) * ((float)(TOLERANCE) / 100.f) / MSEC_PER_SEC)
 
 #define TICKER_FREQ_1MHZ 1000000
 #define TICKER_BITS 32

TESTS/mbed_hal/common_tickers/main.cpp

@@ -344,20 +344,34 @@ void ticker_increment_test(void)
     } else {  // high frequency tickers
 
         uint32_t num_of_cycles = NUM_OF_CYCLES;
+        const uint32_t repeat_count = 20;
+        const uint32_t max_inc_val = 100;
 
         uint32_t base_tick_count = count_ticks(num_of_cycles, 1);
         uint32_t next_tick_count = base_tick_count;
         uint32_t inc_val = 0;
+        uint32_t repeat_cnt = 0;
 
-        while (inc_val < 100) {
-
+        while (inc_val < max_inc_val) {
             next_tick_count = count_ticks(num_of_cycles + inc_val, 1);
 
             if (next_tick_count == base_tick_count) {
 
-                /* Same tick count, so increase num of cycles. */
-                inc_val++;
+                /* Same tick count, so repeat 20 times and than
+                 * increase num of cycles by 1.
+                 */
+                if (repeat_cnt == repeat_count) {
+                    inc_val++;
+                    repeat_cnt = 0;
+                }
+
+                repeat_cnt++;
             } else {
+                /* Check if we got 1 tick diff. */
+                if (next_tick_count - base_tick_count == 1 ||
+                    base_tick_count - next_tick_count == 1) {
+                    break;
+                }
 
                 /* It is possible that the difference between base and next
                  * tick count on some platforms is greater that 1, in this case we need
@@ -366,12 +380,8 @@ void ticker_increment_test(void)
                  */
                 num_of_cycles /= 2;
                 inc_val = 0;
+                repeat_cnt = 0;
                 base_tick_count = count_ticks(num_of_cycles, 1);
-
-                if (next_tick_count - base_tick_count == 1 ||
-                    base_tick_count - next_tick_count == 1) {
-                    break;
-                }
             }
         }
 

TESTS/mbed_platform/stats_sys/main.cpp

@@ -32,10 +32,6 @@ void test_sys_info()
     mbed_stats_sys_t stats;
     mbed_stats_sys_get(&stats);
 
-#if defined(MBED_VERSION)
-    TEST_ASSERT_NOT_EQUAL(0, stats.os_version);
-#endif
-
 #if defined(__CORTEX_M)
     TEST_ASSERT_NOT_EQUAL(0, stats.cpu_id);
 #endif

cmsis/RTE_Components.h

@@ -18,7 +18,9 @@
 
 #define CMSIS_device_header <cmsis.h>
 
+#if defined(MBED_CONF_RTOS_PRESENT)
 #include "mbed_rtx_conf.h"
+#endif
 #include "mbed_cmsis_conf.h"
 
 #endif

features/FEATURE_BLE/ble/generic/SecurityDb.h

@@ -584,28 +584,32 @@ class SecurityDb {
         WhitelistDbCb_t cb,
         ::Gap::Whitelist_t *whitelist
     ) {
-        for (size_t i = 0; i < get_entry_count() && i < whitelist->capacity; i++) {
+        for (size_t i = 0; i < get_entry_count() && whitelist->size < whitelist->capacity; i++) {
             entry_handle_t db_handle = get_entry_handle_by_index(i);
             SecurityDistributionFlags_t* flags = get_distribution_flags(db_handle);
 
             if (!flags) {
                 continue;
             }
 
+            SecurityEntryIdentity_t* identity = read_in_entry_peer_identity(db_handle);
+            if (!identity) {
+                continue;
+            }
+
+            memcpy(
+                whitelist->addresses[whitelist->size].address,
+                identity->identity_address.data(),
+                sizeof(BLEProtocol::AddressBytes_t)
+            );
+
             if (flags->peer_address_is_public) {
-                whitelist->addresses[i].type = BLEProtocol::AddressType::PUBLIC;
+                whitelist->addresses[whitelist->size].type = BLEProtocol::AddressType::PUBLIC;
             } else {
-                whitelist->addresses[i].type = BLEProtocol::AddressType::RANDOM_STATIC;
+                whitelist->addresses[whitelist->size].type = BLEProtocol::AddressType::RANDOM_STATIC;
             }
 
-            SecurityEntryIdentity_t* identity = read_in_entry_peer_identity(db_handle);
-            if (identity) {
-                memcpy(
-                    whitelist->addresses[i].address,
-                    identity->identity_address.data(),
-                    sizeof(BLEProtocol::AddressBytes_t)
-                );
-            }
+            whitelist->size++;
         }
 
         cb(whitelist);

features/FEATURE_BLE/source/generic/GenericSecurityManager.cpp

@@ -142,6 +142,9 @@ ble_error_t GenericSecurityManager::purgeAllBondingState(void) {
 ble_error_t GenericSecurityManager::generateWhitelistFromBondTable(Gap::Whitelist_t *whitelist) const {
     if (!_db) return BLE_ERROR_INITIALIZATION_INCOMPLETE;
     if (eventHandler) {
+        if (!whitelist) {
+            return BLE_ERROR_INVALID_PARAM;
+        }
         _db->generate_whitelist_from_bond_table(
             mbed::callback(eventHandler, &::SecurityManager::EventHandler::whitelistFromBondTable),
             whitelist

features/FEATURE_BLE/targets/TARGET_NORDIC/TARGET_NRF51/source/nRF5xGap.cpp

@@ -1266,7 +1266,7 @@ void nRF5xGap::on_connection(Gap::Handle_t handle, const ble_gap_evt_connected_t
         const resolving_list_entry_t* entry = get_sm().resolve_address(
             evt.peer_addr.addr
         );
-        MBED_ASSERT(entry == NULL);
+        MBED_ASSERT(entry != NULL);
 
         peer_addr_type = convert_identity_address(entry->peer_identity_address_type);
         peer_address = entry->peer_identity_address.data();

features/FEATURE_BLE/targets/TARGET_NORDIC/TARGET_NRF52/source/nRF5xCrypto.cpp

@@ -47,6 +47,7 @@ namespace vendor {
 namespace nordic {
 
 CryptoToolbox::CryptoToolbox() : _initialized(false) {
+    mbedtls_platform_setup(&_platform_context);
     mbedtls_entropy_init(&_entropy_context);
     mbedtls_ecp_group_init(&_group);
     int err = mbedtls_ecp_group_load(
@@ -59,6 +60,7 @@ CryptoToolbox::CryptoToolbox() : _initialized(false) {
 CryptoToolbox::~CryptoToolbox() {
     mbedtls_ecp_group_free(&_group);
     mbedtls_entropy_free(&_entropy_context);
+    mbedtls_platform_teardown(&_platform_context);
 }
 
 bool CryptoToolbox::generate_keys(

features/FEATURE_BLE/targets/TARGET_NORDIC/TARGET_NRF52/source/nRF5xCrypto.h

@@ -132,6 +132,7 @@ class CryptoToolbox : mbed::NonCopyable<CryptoToolbox> {
     void swap_endian(uint8_t* buf, size_t len);
 
     bool _initialized;
+    mbedtls_platform_context _platform_context;
     mbedtls_entropy_context _entropy_context;
     mbedtls_ecp_group _group;
 };

features/FEATURE_UVISOR/includes/uvisor/api/inc/uvisor_deprecation.h

@@ -18,7 +18,8 @@
 #define __UVISOR_DEPRECATION_H__
 
 #if defined(UVISOR_PRESENT) && UVISOR_PRESENT == 1
-#warning "Warning: You are using FEATURE_UVISOR, which is unsupported as of Mbed OS 5.9."
+#warning "Warning: uVisor is superseded by the Secure Partition Manager (SPM) defined in the ARM Platform Security Architecture (PSA). \
+          uVisor is deprecated as of Mbed OS 5.10, and being replaced by a native PSA-compliant implementation of SPM."
 #endif
 
 #endif  // __UVISOR_DEPRECATION_H__