MOZ-2554: Merge fixes from mbed-os-6.13.0-jfd-fixes (#14)

* Changed to C++20

* applied patch from fep low power

* Changed to C++20

* Updated compile options

* Added more fixes

* Added event queue changes

* Changed to hard float and fixed sleep

* Added werror

* Corrected compile warnings/errors

* Updated system clock settings

* Reverted change

* Downgraded STM32Cube to 1.23.0

* Corrected build issues

* Corrected mimimal printf compile warning

* Revert "Downgraded STM32Cube to 1.23.0"

This reverts commit ae19071.

* Corrected build issues

* Added I2C slave changes

* Updated from old branch

* Corrected I2C slave command

* Minor rename

* Corrected name

* Virtual i2c read write

Made i2c read/write functions virtual so that they can be overridden.

* Removed obsolete file

* Corrected unused variable in mbed_board.c

* Added maybe_unused to validate_errno_values

* Fix build errors

Co-authored-by: Jeppe Frandsen <[email protected]>
Co-authored-by: Hans Binderup <[email protected]>
Co-authored-by: Michael Jakobsen Højgaard <[email protected]>

Author: 4 people

drivers/include/drivers/I2C.h

@@ -25,7 +25,6 @@
 #include "hal/i2c_api.h"
 #include "platform/SingletonPtr.h"
 #include "platform/PlatformMutex.h"
-#include "platform/NonCopyable.h"
 
 #if DEVICE_I2C_ASYNCH
 #include "platform/CThunk.h"
@@ -79,7 +78,7 @@ namespace mbed {
  * }
  * @endcode
  */
-class I2C : private NonCopyable<I2C> {
+class I2C {
 
 public:
     enum RxStatus {
@@ -108,6 +107,10 @@ class I2C : private NonCopyable<I2C> {
     I2C(const i2c_pinmap_t &static_pinmap);
     I2C(const i2c_pinmap_t &&) = delete; // prevent passing of temporary objects
 
+    /** Create an I2C Master interface from an existing object
+     */
+    I2C(const I2C&) = default;
+
     /** Set the frequency of the I2C interface
      *
      *  @param hz The bus frequency in hertz
@@ -129,7 +132,7 @@ class I2C : private NonCopyable<I2C> {
      *       0 on success (ack),
      *       nonzero on failure (nack)
      */
-    int read(int address, char *data, int length, bool repeated = false);
+    virtual int read(int address, char *data, int length, bool repeated = false);
 
     /** Read a single byte from the I2C bus
      *
@@ -155,7 +158,7 @@ class I2C : private NonCopyable<I2C> {
      *       0 on success (ack),
      *       nonzero on failure (nack)
      */
-    int write(int address, const char *data, int length, bool repeated = false);
+    virtual int write(int address, const char *data, int length, bool repeated = false);
 
     /** Write single byte out on the I2C bus
      *
@@ -176,6 +179,14 @@ class I2C : private NonCopyable<I2C> {
      */
     void stop(void);
 
+    /** Recover I2C bus, when stuck with SDA low
+     * 
+     *  @returns
+     *    '0' - Successfully recovered
+     *    'I2C_ERROR_BUS_BUSY' - In case of failure
+     */
+    int recover(void);
+
     /** Acquire exclusive access to this I2C bus
      */
     virtual void lock(void);

drivers/source/I2C.cpp

@@ -149,6 +149,15 @@ void I2C::stop(void)
     unlock();
 }
 
+int I2C::recover(void)
+{
+    lock();
+    int ret = recover(_sda, _scl);
+    i2c_init(&_i2c, _sda, _scl);
+    unlock();
+    return ret;
+}
+
 void I2C::lock()
 {
     _mutex->lock();

drivers/source/SerialBase.cpp

@@ -95,17 +95,9 @@ void SerialBase::attach(Callback<void()> func, IrqType type)
         // Disable interrupts when attaching interrupt handler
         core_util_critical_section_enter();
         if (func) {
-            // lock deep sleep only the first time
-            if (!_irq[type]) {
-                sleep_manager_lock_deep_sleep();
-            }
             _irq[type] = func;
             serial_irq_set(&_serial, (SerialIrq)type, 1);
         } else {
-            // unlock deep sleep only the first time
-            if (_irq[type]) {
-                sleep_manager_unlock_deep_sleep();
-            }
             _irq[type] = nullptr;
             serial_irq_set(&_serial, (SerialIrq)type, 0);
         }

events/include/events/EventQueue.h

@@ -775,12 +775,16 @@ class EventQueue : private mbed::NonCopyable<EventQueue> {
     {
         void *p = equeue_alloc(&_equeue, sizeof(F));
         if (!p) {
+            queue_full(QUEUE_FULL_CALL, sizeof(F));
             return 0;
         }
 
         F *e = new (p) F(std::move(f));
         equeue_event_dtor(e, &EventQueue::function_dtor<F>);
-        return equeue_post(&_equeue, &EventQueue::function_call<F>, e);
+        int id = equeue_post(&_equeue, &EventQueue::function_call<F>, e);
+        if (!id)
+            queue_full(QUEUE_FULL_CALL, sizeof(F));
+        return id;
     }
 
 
@@ -850,13 +854,17 @@ class EventQueue : private mbed::NonCopyable<EventQueue> {
     {
         void *p = equeue_alloc(&_equeue, sizeof(F));
         if (!p) {
+            queue_full(QUEUE_FULL_CALL_IN, sizeof(F));
             return 0;
         }
 
         F *e = new (p) F(std::move(f));
         equeue_event_delay(e, ms.count());
         equeue_event_dtor(e, &EventQueue::function_dtor<F>);
-        return equeue_post(&_equeue, &EventQueue::function_call<F>, e);
+        int id = equeue_post(&_equeue, &EventQueue::function_call<F>, e);
+        if (!id)
+            queue_full(QUEUE_FULL_CALL_IN, sizeof(F));
+        return id;
     }
 
     /** Calls an event on the queue after a specified delay
@@ -1003,14 +1011,18 @@ class EventQueue : private mbed::NonCopyable<EventQueue> {
     {
         void *p = equeue_alloc(&_equeue, sizeof(F));
         if (!p) {
+            queue_full(QUEUE_FULL_CALL_EVERY, sizeof(F));
             return 0;
         }
 
         F *e = new (p) F(std::move(f));
         equeue_event_delay(e, ms.count());
         equeue_event_period(e, ms.count());
         equeue_event_dtor(e, &EventQueue::function_dtor<F>);
-        return equeue_post(&_equeue, &EventQueue::function_call<F>, e);
+        int id = equeue_post(&_equeue, &EventQueue::function_call<F>, e);
+        if (!id)
+            queue_full(QUEUE_FULL_CALL_EVERY, sizeof(F));
+        return id;
     }
 
     /** Calls an event on the queue periodically
@@ -1398,6 +1410,18 @@ class EventQueue : private mbed::NonCopyable<EventQueue> {
 #endif
 
 protected:
+    enum queue_full_call_type {
+        QUEUE_FULL_CALL,
+        QUEUE_FULL_CALL_IN,
+        QUEUE_FULL_CALL_EVERY,
+    };
+
+    /** Error callback. Called when task is rejected because queue is full */
+    virtual void queue_full(queue_full_call_type call_type, size_t function_size) const
+    {
+        // Can be overridden in subclass
+    }
+
 #if !defined(DOXYGEN_ONLY)
     template <typename F>
     friend class Event;

platform/include/platform/mbed_rtc_time.h

@@ -18,7 +18,7 @@
 #ifndef __MBED_RTC_TIME_H__
 #define __MBED_RTC_TIME_H__
 
-#include <time.h>
+#include <sys/time.h>
 
 #ifdef __cplusplus
 extern "C" {

platform/source/mbed_board.c

@@ -28,8 +28,8 @@ WEAK MBED_NORETURN void mbed_die(void)
 #if !defined(TARGET_EFM32)
     core_util_critical_section_enter();
 #endif
-    gpio_t led_err;
 #ifdef LED1
+    gpio_t led_err;
     gpio_init_out(&led_err, LED1);
 #endif
 

platform/source/mbed_error.c

@@ -65,6 +65,36 @@ static mbed_error_status_t handle_error(mbed_error_status_t error_status, unsign
 #if MBED_CONF_PLATFORM_CRASH_CAPTURE_ENABLED
 #define report_error_ctx MBED_CRASH_DATA.error.context
 static bool is_reboot_error_valid = false;
+
+//Helper function to calculate CRC
+//NOTE: It would have been better to use MbedCRC implementation. But
+//MbedCRC uses table based calculation and we dont want to keep that table memory
+//used up for this purpose. Also we cannot force bitwise calculation in MbedCRC
+//and it also requires a new wrapper to be called from C implementation. Since
+//we dont have many uses cases to create a C wrapper for MbedCRC and the data
+//we calculate CRC on in this context is very less we will use a local
+//implementation here.
+__attribute__ ((unused)) static unsigned int compute_crc32(const void *data, int datalen)
+{
+    const unsigned int polynomial = 0x04C11DB7; /* divisor is 32bit */
+    unsigned int crc = 0; /* CRC value is 32bit */
+    unsigned char *buf = (unsigned char *)data;//use a temp variable to make code readable and to avoid typecasting issues.
+
+    for (; datalen > 0; datalen--) {
+        unsigned char b = *buf++;
+        crc ^= (unsigned int)(b << 24); /* move byte into upper 8bit */
+        for (int i = 0; i < 8; i++) {
+            /* is MSB 1 */
+            if ((crc & 0x80000000) != 0) {
+                crc = (unsigned int)((crc << 1) ^ polynomial);
+            } else {
+                crc <<= 1;
+            }
+        }
+    }
+
+    return crc;
+}
 #endif
 
 extern uint32_t __INITIAL_SP;
@@ -119,6 +149,7 @@ static inline bool mbed_error_is_hw_fault(mbed_error_status_t error_status)
             error_status == MBED_ERROR_HARDFAULT_EXCEPTION);
 }
 
+#if MBED_CONF_PLATFORM_ERROR_ALL_THREADS_INFO && defined(MBED_CONF_RTOS_PRESENT)
 static bool mbed_error_is_handler(const mbed_error_ctx *ctx)
 {
     bool is_handler = false;
@@ -136,6 +167,7 @@ static bool mbed_error_is_handler(const mbed_error_ctx *ctx)
     }
     return is_handler;
 }
+#endif
 
 //Set an error status with the error handling system
 static mbed_error_status_t handle_error(mbed_error_status_t error_status, unsigned int error_value, const char *filename, int line_number, void *caller)
@@ -179,7 +211,13 @@ static mbed_error_status_t handle_error(mbed_error_status_t error_status, unsign
 #if MBED_CONF_PLATFORM_ERROR_FILENAME_CAPTURE_ENABLED
     //Capture filename/linenumber if provided
     //Index for tracking error_filename
-    strncpy(current_error_ctx.error_filename, filename, MBED_CONF_PLATFORM_MAX_ERROR_FILENAME_LEN);
+    const char* copy_from = strrchr(filename, '/');
+    if (!copy_from) {
+        copy_from = filename;
+    } else {
+        ++copy_from; // Skip the '/'
+    }
+    strncpy(current_error_ctx.error_filename, copy_from, MBED_CONF_PLATFORM_MAX_ERROR_FILENAME_LEN);
     current_error_ctx.error_line_number = line_number;
 #endif
 

platform/source/mbed_os_timer.cpp

@@ -38,7 +38,7 @@ namespace internal {
 OsTimer *os_timer;
 
 namespace {
-uint64_t os_timer_data[(sizeof(OsTimer) + 7) / 8];
+[[maybe_unused]] uint64_t os_timer_data[(sizeof(OsTimer) + 7) / 8];
 }
 
 OsTimer *init_os_timer()

platform/source/mbed_power_mgmt.c

@@ -28,6 +28,7 @@
 #include "platform/mbed_wait_api.h"
 
 #include <stdio.h>
+#include <string.h>
 
 #if DEVICE_SLEEP
 

platform/source/mbed_retarget.cpp

@@ -1935,7 +1935,7 @@ extern "C" MBED_WEAK long int _scanf_mbtowc(
     return 0;
 }
 
-static  void validate_errno_values(int value)
+[[maybe_unused]] static  void validate_errno_values(int value)
 {
 
     switch (value) {