rtl8195am - fix ci-test issues with ARM compiler

TESTS/mbed_drivers/flashiap/main.cpp

@@ -81,6 +81,56 @@ void flashiap_program_test()
     TEST_ASSERT_EQUAL_INT32(0, ret);
 }
 
+void flashiap_cross_sector_program_test()
+{
+    FlashIAP flash_device;
+    uint32_t ret = flash_device.init();
+    TEST_ASSERT_EQUAL_INT32(0, ret);
+
+    uint32_t page_size = flash_device.get_page_size();
+
+    // Erase last two sectors
+    uint32_t address = flash_device.get_flash_start() + flash_device.get_flash_size();
+    uint32_t sector_size, agg_size = 0;
+    for (uint32_t i = 0; i < 2; i++) {
+        sector_size = flash_device.get_sector_size(address - 1UL);
+        TEST_ASSERT_NOT_EQUAL(0, sector_size);
+        TEST_ASSERT_TRUE(sector_size % page_size == 0);
+        agg_size += sector_size;
+        address -= sector_size;
+    }
+    ret = flash_device.erase(address, agg_size);
+    TEST_ASSERT_EQUAL_INT32(0, ret);
+
+    address += sector_size - page_size;
+    uint32_t aligned_prog_size = 2 * page_size;
+    uint32_t prog_size = aligned_prog_size;
+    if (page_size > 1) {
+        prog_size--;
+    }
+    uint8_t *data = new uint8_t[aligned_prog_size];
+    for (uint32_t i = 0; i < prog_size; i++) {
+        data[i] = rand() % 256;
+    }
+    for (uint32_t i = prog_size; i < aligned_prog_size; i++) {
+        data[i] = 0xFF;
+    }
+
+    ret = flash_device.program(data, address, prog_size);
+    TEST_ASSERT_EQUAL_INT32(0, ret);
+
+    uint8_t *data_flashed = new uint8_t[aligned_prog_size];
+    ret = flash_device.read(data_flashed, address, aligned_prog_size);
+    TEST_ASSERT_EQUAL_INT32(0, ret);
+    TEST_ASSERT_EQUAL_UINT8_ARRAY(data, data_flashed, aligned_prog_size);
+
+    delete[] data;
+    delete[] data_flashed;
+
+    ret = flash_device.deinit();
+    TEST_ASSERT_EQUAL_INT32(0, ret);
+}
+
 void flashiap_program_error_test()
 {
     FlashIAP flash_device;
@@ -111,12 +161,6 @@ void flashiap_program_error_test()
         TEST_ASSERT_EQUAL_INT32(-1, ret);
     }
 
-    if (flash_device.get_page_size() > 1) {
-        // unaligned page size
-        ret = flash_device.program(data, address, page_size + 1);
-        TEST_ASSERT_EQUAL_INT32(-1, ret);
-    }
-
     delete[] data;
 
     ret = flash_device.deinit();
@@ -126,6 +170,7 @@ void flashiap_program_error_test()
 Case cases[] = {
     Case("FlashIAP - init", flashiap_init_test),
     Case("FlashIAP - program", flashiap_program_test),
+    Case("FlashIAP - program across sectors", flashiap_cross_sector_program_test),
     Case("FlashIAP - program errors", flashiap_program_error_test),
 };
 

TESTS/mbed_hal/sleep_manager_racecondition/main.cpp

@@ -67,12 +67,12 @@ void sleep_manager_irq_test()
         Ticker ticker1;
         Timer timer;
 
-        ticker1.attach_us(&sleep_manager_locking_irq_test, 500);
+        ticker1.attach_us(&sleep_manager_locking_irq_test, 1000);
 
-        // run this for 5 seconds
+        // run this for 10 seconds
         timer.start();
         int start = timer.read();
-        int end = start + 5;
+        int end = start + 10;
         while (timer.read() < end) {
             sleep_manager_locking_irq_test();
         }

TESTS/mbedtls/multi/main.cpp

@@ -23,67 +23,6 @@
 
 #include "mbedtls/sha256.h"
 
-/**
- * \name SECTION: Compatibility code
- *
- * Depending on whether the alternative (hatdware accelerated) hashing
- * functions are provided or not, different API should be used for hashing.
- * \{
- */
-
-#if defined(MBEDTLS_SHA256_ALT)
-
-/**
- * \brief          This function starts a SHA-256 checksum calculation.
- *
- * \deprecated     Superseded by mbedtls_sha256_starts_ret() in 2.7.0.
- *
- * \param ctx      The SHA-256 context to initialize.
- * \param is224    Determines which function to use.
- *                 <ul><li>0: Use SHA-256.</li>
- *                 <li>1: Use SHA-224.</li></ul>
- */
-void mbedtls_sha256_starts( mbedtls_sha256_context *ctx,
-                            int is224 )
-{
-    mbedtls_sha256_starts_ret( ctx, is224 );
-}
-
-/**
- * \brief          This function feeds an input buffer into an ongoing
- *                 SHA-256 checksum calculation.
- *
- * \deprecated     Superseded by mbedtls_sha256_update_ret() in 2.7.0.
- *
- * \param ctx      The SHA-256 context to initialize.
- * \param input    The buffer holding the data.
- * \param ilen     The length of the input data.
- */
-void mbedtls_sha256_update( mbedtls_sha256_context *ctx,
-                            const unsigned char *input,
-                            size_t ilen )
-{
-    mbedtls_sha256_update_ret( ctx, input, ilen );
-}
-
-/**
- * \brief          This function finishes the SHA-256 operation, and writes
- *                 the result to the output buffer.
- *
- * \deprecated     Superseded by mbedtls_sha256_finish_ret() in 2.7.0.
- *
- * \param ctx      The SHA-256 context.
- * \param output   The SHA-224or SHA-256 checksum result.
- */
-void mbedtls_sha256_finish( mbedtls_sha256_context *ctx,
-                            unsigned char output[32] )
-{
-    mbedtls_sha256_finish_ret( ctx, output );
-}
-
-#endif /* defined(MBEDTLS_SHA256_ALT) */
-
-/* \} name SECTION: Compatibility code */
 
 using namespace utest::v1;
 

drivers/FlashIAP.cpp

@@ -20,7 +20,9 @@
  * SOFTWARE.
  */
 
+#include <stdio.h>
 #include <string.h>
+#include <algorithm>
 #include "FlashIAP.h"
 #include "mbed_assert.h"
 
@@ -57,6 +59,9 @@ int FlashIAP::init()
     if (flash_init(&_flash)) {
         ret = -1;
     }
+    uint32_t page_size = get_page_size();
+    _page_buf = new uint8_t[page_size];
+
     _mutex->unlock();
     return ret;
 }
@@ -68,6 +73,7 @@ int FlashIAP::deinit()
     if (flash_free(&_flash)) {
         ret = -1;
     }
+    delete[] _page_buf;
     _mutex->unlock();
     return ret;
 }
@@ -85,22 +91,43 @@ int FlashIAP::read(void *buffer, uint32_t addr, uint32_t size)
 int FlashIAP::program(const void *buffer, uint32_t addr, uint32_t size)
 {
     uint32_t page_size = get_page_size();
-    uint32_t current_sector_size = flash_get_sector_size(&_flash, addr);
-    // addr and size should be aligned to page size, and multiple of page size
-    // page program should not cross sector boundaries
-    if (!is_aligned(addr, page_size) ||
-        !is_aligned(size, page_size) ||
-        (size < page_size) ||
-        (((addr % current_sector_size) + size) > current_sector_size)) {
+    uint32_t flash_size = flash_get_size(&_flash);
+    uint32_t flash_start_addr = flash_get_start_address(&_flash);
+    uint32_t chunk, prog_size;
+    const uint8_t *buf = (uint8_t *) buffer;
+    const uint8_t *prog_buf;
+
+    // addr should be aligned to page size
+    if (!is_aligned(addr, page_size) || (!buffer) ||
+        ((addr + size) > (flash_start_addr + flash_size))) {
         return -1;
     }
 
     int ret = 0;
     _mutex->lock();
-    if (flash_program_page(&_flash, addr, (const uint8_t *)buffer, size)) {
-        ret = -1;
+    while (size) {
+        uint32_t current_sector_size = flash_get_sector_size(&_flash, addr);
+        chunk = std::min(current_sector_size - (addr % current_sector_size), size);
+        if (chunk < page_size) {
+            memcpy(_page_buf, buf, chunk);
+            memset(_page_buf + chunk, 0xFF, page_size - chunk);
+            prog_buf = _page_buf;
+            prog_size = page_size;
+        } else {
+            chunk = chunk / page_size * page_size;
+            prog_buf = buf;
+            prog_size = chunk;
+        }
+        if (flash_program_page(&_flash, addr, prog_buf, prog_size)) {
+            ret = -1;
+            break;
+        }
+        size -= chunk;
+        addr += chunk;
+        buf += chunk;
     }
     _mutex->unlock();
+
     return ret;
 }
 
@@ -117,10 +144,19 @@ bool FlashIAP::is_aligned_to_sector(uint32_t addr, uint32_t size)
 
 int FlashIAP::erase(uint32_t addr, uint32_t size)
 {
-    uint32_t current_sector_size = 0UL;
+    uint32_t current_sector_size;
+    uint32_t flash_size = flash_get_size(&_flash);
+    uint32_t flash_start_addr = flash_get_start_address(&_flash);
+    uint32_t flash_end_addr = flash_start_addr + flash_size;
+    uint32_t erase_end_addr = addr + size;
 
-    if (!is_aligned_to_sector(addr, size)) {
+    if (erase_end_addr > flash_end_addr) {
         return -1;
+    } else if (erase_end_addr < flash_end_addr){
+        uint32_t following_sector_size = flash_get_sector_size(&_flash, erase_end_addr);
+        if (!is_aligned(erase_end_addr, following_sector_size)) {
+            return -1;
+        }
     }
 
     int32_t ret = 0;
@@ -132,10 +168,6 @@ int FlashIAP::erase(uint32_t addr, uint32_t size)
             break;
         }
         current_sector_size = flash_get_sector_size(&_flash, addr);
-        if (!is_aligned_to_sector(addr, size)) {
-            ret = -1;
-            break;
-        }
         size -= current_sector_size;
         addr += current_sector_size;
     }

drivers/FlashIAP.h

@@ -72,8 +72,8 @@ class FlashIAP : private NonCopyable<FlashIAP> {
      *  The sectors must have been erased prior to being programmed
      *
      *  @param buffer Buffer of data to be written
-     *  @param addr   Address of a page to begin writing to, must be a multiple of program and sector sizes
-     *  @param size   Size to write in bytes, must be a multiple of program and sector sizes
+     *  @param addr   Address of a page to begin writing to
+     *  @param size   Size to write in bytes, must be a multiple of program size
      *  @return       0 on success, negative error code on failure
      */
     int program(const void *buffer, uint32_t addr, uint32_t size);
@@ -128,6 +128,7 @@ class FlashIAP : private NonCopyable<FlashIAP> {
     bool is_aligned_to_sector(uint32_t addr, uint32_t size);
 
     flash_t _flash;
+    uint8_t *_page_buf;
     static SingletonPtr<PlatformMutex> _mutex;
 };
 

features/FEATURE_LWIP/lwip-interface/lwip_stack.c

@@ -444,9 +444,7 @@ static bool lwip_ppp = false;
 
 static nsapi_error_t mbed_set_dhcp(struct netif *lwip_netif)
 {
-    if (!lwip_ppp) {
-        netif_set_up(lwip_netif);
-    }
+    netif_set_up(lwip_netif);
 
 #if LWIP_DHCP
     if (lwip_dhcp && lwip_dhcp_has_to_be_set) {

features/mbedtls/targets/TARGET_NUVOTON/TARGET_M480/sha/sha1_alt.c

@@ -103,40 +103,37 @@ void mbedtls_sha1_clone(mbedtls_sha1_context *dst,
 /*
  * SHA-1 context setup
  */
-int mbedtls_sha1_starts_ret(mbedtls_sha1_context *ctx)
+void mbedtls_sha1_starts(mbedtls_sha1_context *ctx)
 {
     if (ctx->active_ctx == &ctx->hw_ctx) {
         mbedtls_sha1_hw_starts(&ctx->hw_ctx);
     } else if (ctx->active_ctx == &ctx->sw_ctx) {
         mbedtls_sha1_sw_starts(&ctx->sw_ctx);
     }
-    return 0;
 }
 
 /*
  * SHA-1 process buffer
  */
-int mbedtls_sha1_update_ret(mbedtls_sha1_context *ctx, const unsigned char *input, size_t ilen)
+void mbedtls_sha1_update(mbedtls_sha1_context *ctx, const unsigned char *input, size_t ilen)
 {
     if (ctx->active_ctx == &ctx->hw_ctx) {
         mbedtls_sha1_hw_update(&ctx->hw_ctx, input, ilen);
     } else if (ctx->active_ctx == &ctx->sw_ctx) {
         mbedtls_sha1_sw_update(&ctx->sw_ctx, input, ilen);
     }
-    return 0;
 }
 
 /*
  * SHA-1 final digest
  */
-int mbedtls_sha1_finish_ret(mbedtls_sha1_context *ctx, unsigned char output[20])
+void mbedtls_sha1_finish(mbedtls_sha1_context *ctx, unsigned char output[20])
 {
     if (ctx->active_ctx == &ctx->hw_ctx) {
         mbedtls_sha1_hw_finish(&ctx->hw_ctx, output);
     } else if (ctx->active_ctx == &ctx->sw_ctx) {
         mbedtls_sha1_sw_finish(&ctx->sw_ctx, output);
     }
-    return 0;
 }
 
 void mbedtls_sha1_process(mbedtls_sha1_context *ctx, const unsigned char data[64])

features/mbedtls/targets/TARGET_NUVOTON/TARGET_M480/sha/sha1_alt.h

@@ -66,31 +66,25 @@ void mbedtls_sha1_clone( mbedtls_sha1_context *dst,
  * \brief          SHA-1 context setup
  *
  * \param ctx      context to be initialized
- *
- * \return         0 if successful
  */
-int mbedtls_sha1_starts_ret( mbedtls_sha1_context *ctx );
+void mbedtls_sha1_starts( mbedtls_sha1_context *ctx );
 
 /**
  * \brief          SHA-1 process buffer
  *
  * \param ctx      SHA-1 context
  * \param input    buffer holding the  data
  * \param ilen     length of the input data
- *
- * \return         0 if successful
  */
-int mbedtls_sha1_update_ret( mbedtls_sha1_context *ctx, const unsigned char *input, size_t ilen );
+void mbedtls_sha1_update( mbedtls_sha1_context *ctx, const unsigned char *input, size_t ilen );
 
 /**
  * \brief          SHA-1 final digest
  *
  * \param ctx      SHA-1 context
  * \param output   SHA-1 checksum result
- *
- * \return         0 if successful
  */
-int mbedtls_sha1_finish_ret( mbedtls_sha1_context *ctx, unsigned char output[20] );
+void mbedtls_sha1_finish( mbedtls_sha1_context *ctx, unsigned char output[20] );
 
 /* Internal use */
 void mbedtls_sha1_process( mbedtls_sha1_context *ctx, const unsigned char data[64] );