Synchronize changes with Mbed upstream: July 2024 edition (#309)

* remove stdio checks in serial init if no console is available

* STM32WL fix set preamble length to 8

* Add target support for XDOT_MAX32670

* TARGET_STM: only mask CAN rx interrupt after rx interrupt, not all CAN interrupts

* Sleep Radio in between DC scheduled

* Nuvoton HUSBD support endpoint write ZLP

* USBCDC: support ZLP

* Don't overlap STM32 FDCAN RAM sections

* allow to override antenna gain

* TFM: Fix undeclared function tfm_ns_interface_init

ISO C99 and later do not support implicit function declarations [-Wimplicit-function-declaration]

* NUVOTON: CAN: Fix filter mask

NOTE: This fix only targets CAN (M453/M487), not CAN-FD (M467).
NOTE: NUC472 CAN doesn't support filter.

* NUVOTON: CAN: Fix Rx interrupt doesn't work

Major modifications:
1. Handle Rx interrupt based on Message Object interrupt (CAN_IIDR=0x0001~0x0020) instead of CAN_STATUS.RxOK
2. Also handle Tx interrupt following above for consistency

Other related modifications:
1. Fix signature type error in CAN_CLR_INT_PENDING_BIT()
2. Add CAN_CLR_INT_PENDING_ONLY_BIT() which doesn't clear NewDat flag so that user can fetch received message in thread context

NOTE: This fix only targets CAN (NUC472/M453/M487), not CAN-FD (M467).

* NUVOTON: CAN: Fix Message Object number for Tx and recognition of Rx interrupt

1.  The same Message Object number cannot use for both Tx and Rx simultaneously.
    For Tx, Message Object number 31 is reserved instead of 0.
    For Rx, Message Object numbers 0~30 are used and for filters.
2.  NewDat bit (CAN_IsNewDataReceived()) isn't exclusive to Rx.
    Recognize Rx interrupt by Message Object number other than 31.

NOTE: This fix only targets CAN (NUC472/M453/M487), not CAN-FD (M467).

* NUVOTON: CAN: Fix filter mask being zero

On mask being zero, it means any match, not exact match.

NOTE: This fix only targets CAN (M453/M487), not CAN-FD (M467).
NOTE: NUC472 CAN doesn't support filter.

* Allow custom TCXO control parameter

Allow custom TCXO control parameter

* NUVOTON: EMAC: Fix undeclared function mbed_error_printf

ISO C99 and later do not support implicit function declarations [-Wimplicit-function-declaration]

* NUVOTON: AnalogIn: Fix undeclared function gpio_set

ISO C99 and later do not support implicit function declarations [-Wimplicit-function-declaration]

* NUVOTON: CAN: Fix undeclared function gpio_set

ISO C99 and later do not support implicit function declarations [-Wimplicit-function-declaration]

* NUVOTON: AnalogOut: Fix undeclared function gpio_set

ISO C99 and later do not support implicit function declarations [-Wimplicit-function-declaration]

* NUVOTON: SPI: Fix undeclared function gpio_set

ISO C99 and later do not support implicit function declarations [-Wimplicit-function-declaration]

* NUVOTON: I2C: Fix undeclared function gpio_set

ISO C99 and later do not support implicit function declarations [-Wimplicit-function-declaration]

* NUVOTON: Serial: Fix undeclared function gpio_set

ISO C99 and later do not support implicit function declarations [-Wimplicit-function-declaration]

* Add separate flags for I2C slave transfer in progress

Fixes ARMmbed#15498

Adds 2 boolean flags to the STM32 `i2c_s` object
to indicate whether a transfer is in progress,
separate from the existing "transfer pending" flags.

`i2c_slave_write`, `i2c_slave_read` and their associated callbacks
are modified to use these flags in addition to the pending flags.
The original behavior of the pending flags is preserved.

* ESP8266: Fix accessing uninitialized variable

* Added missing delete

* Add ability to change number of status registers for macronix QSPIF devices

* correct scan parameters types

* skip CRC when initializing TDBStore

Problem: The build_ram_table() function of TDBStore loops over every entry, calculates the checksum and compares them to the stored checksum in the entry header to ensure integrity. For larger TDBStores (e.g. 8 MiB or more) in external single-SPI flash devices this check can take very long, thus rendering it unusable in some cases.

Solution: The suggested solution skips the time consuming CRC of the data. After reading the key and calculating its CRC, it sets next_offset to the beginning of the next entry, thereby skipping the data. While this skips the integrity check, it significantly reduces the initial building of the RAM table.

The data CRC can be enabled or disabled with a compiler flag.

Contribution is provided on behalf of BIOTRONIK.

* Added missing check for replay protection pointer before allocating new variable

Problem: If a key with write-once flag is being set in a SecureStore without rollback-protection store (i.e. _rbp_kv == NULL), additional memory will be allocated for the variable _ih->key. The memory will not be deleted, though, as the delete in line 434 only happens if a rollback-protection store exists (i.e. _rbp_kv != NULL)

Solution: Only allocate the memory if _rbp_kv != NULL

Contribution is provided on behalf of BIOTRONIK.

* Increase AT timeout to 10s in AT_CellularSMS::send_sms

For some devices sending can be slow (as an example see SIM800, it can be up to 60s), command is being run properly but default timeout is returning an invalid error.
See https://www.elecrow.com/wiki/images/2/20/SIM800_Series_AT_Command_Manual_V1.09.pdf

* Increase AT timeout to 10s in AT_CellularSMS::get_sms

When SMS list is big and baudrate is not fast enough, with default timeout we can suffer from timeout error while getting a sms because method is parsing the full list and this takes long.

* Fix AT_CellularSMS::list_messages breaking in text mode when CRLF is contained in SMS payload text

When parsing SMS, it can happen that we receive CRLF in the SMS payload (happened to me when receiving provider texts).
As an example, we can receive:

"""
Hello <CR><LF>
World!
"""

With previous implementation, second consume_to_stop_tag was stopping in <CR><LF> and rest of the code was failing for obvious reasons.
With this commit we consume the full payload as bytes.

* Add missing SPDX identifier to a bajillion Nuvoton source files + some others

* More license fixes, upgrade M451 legacy PinNames.h, add MCU description

* Fix some more legacy pin names

---------

Co-authored-by: Jost, Chris <[email protected]>
Co-authored-by: Charles <[email protected]>
Co-authored-by: Leon Lindenfelser <[email protected]>
Co-authored-by: Pavel Sorejs <[email protected]>
Co-authored-by: cyliang tw <[email protected]>
Co-authored-by: jmcloud <[email protected]>
Co-authored-by: Chun-Chieh Li <[email protected]>
Co-authored-by: Adam Gausmann <[email protected]>
Co-authored-by: Mingjie Shen <[email protected]>
Co-authored-by: Matthias Goebel <[email protected]>
Co-authored-by: danielzhang <[email protected]>
Co-authored-by: Mathieu Camélique <[email protected]>
Co-authored-by: David Alonso de la Torre <[email protected]>

Author: 14 people

connectivity/FEATURE_BLE/include/ble/gap/ScanParameters.h

@@ -82,15 +82,15 @@ class ScanParameters {
         /**
          * Get the scan interval.
          */
-        const scan_window_t &getInterval() const
+        const scan_interval_t &getInterval() const
         {
             return interval;
         }
 
         /**
          * Get the scan window.
          */
-        const scan_interval_t &getWindow() const
+        const scan_window_t &getWindow() const
         {
             return window;
         }
@@ -121,8 +121,8 @@ class ScanParameters {
      */
     ScanParameters(
         phy_t phy = phy_t::LE_1M,
-        scan_window_t scan_interval = scan_interval_t::min(),
-        scan_interval_t scan_window = scan_window_t::min(),
+        scan_interval_t scan_interval = scan_interval_t::min(),
+        scan_window_t scan_window = scan_window_t::min(),
         bool active_scanning = false,
         own_address_type_t own_address_type = own_address_type_t::RANDOM,
         scanning_filter_policy_t scanning_filter_policy = scanning_filter_policy_t::NO_FILTER

connectivity/cellular/include/cellular/framework/API/ATHandler.h

@@ -318,6 +318,13 @@ class ATHandler {
      */
     void skip_param(ssize_t len, uint32_t count);
 
+    /** Consumes the given length from the reading buffer even if the stop tag has been found
+     *
+     *  @param len length to be consumed from reading buffer
+     *  @param count number of parameters to be skipped
+     */
+    void skip_param_bytes(ssize_t len, uint32_t count);
+
     /** Reads given number of bytes from receiving buffer without checking any subparameter delimiters, such as comma.
      *
      *  @param buf output buffer for the read
@@ -408,6 +415,12 @@ class ATHandler {
      */
     bool consume_to_stop_tag();
 
+    /**  Consumes the received content until current stop tag is found even if stop tag has been found previously
+     *
+     *  @return true if stop tag is found, false otherwise
+     */
+    bool consume_to_stop_tag_even_found();
+
     /** Return the last 3GPP error code.
      *  @return last 3GPP error code
      */

connectivity/cellular/source/framework/AT/AT_CellularSMS.cpp

@@ -420,6 +420,7 @@ nsapi_size_or_error_t AT_CellularSMS::send_sms(const char *phone_number, const c
     }
 
     _at.lock();
+    _at.set_at_timeout(10s);
 
     int write_size = 0;
 
@@ -437,6 +438,7 @@ nsapi_size_or_error_t AT_CellularSMS::send_sms(const char *phone_number, const c
                 // sending can be cancelled by giving <ESC> character (IRA 27).
                 _at.cmd_start(ESC);
                 _at.cmd_stop();
+                _at.restore_at_timeout();
                 _at.unlock();
                 return write_size;
             }
@@ -482,6 +484,7 @@ nsapi_size_or_error_t AT_CellularSMS::send_sms(const char *phone_number, const c
             pdu_str = create_pdu(phone_number, message + i * concatenated_sms_length, pdu_len,
                                  sms_count, i + 1, header_len);
             if (!pdu_str) {
+                _at.restore_at_timeout();
                 _at.unlock();
                 return NSAPI_ERROR_NO_MEMORY;
             }
@@ -509,6 +512,7 @@ nsapi_size_or_error_t AT_CellularSMS::send_sms(const char *phone_number, const c
                     // sending can be cancelled by giving <ESC> character (IRA 27).
                     _at.cmd_start(ESC);
                     _at.cmd_stop();
+                    _at.restore_at_timeout();
                     _at.unlock();
                     delete [] pdu_str;
                     return msg_write_len;
@@ -523,13 +527,15 @@ nsapi_size_or_error_t AT_CellularSMS::send_sms(const char *phone_number, const c
             delete [] pdu_str;
             remaining_len -= concatenated_sms_length;
             if (_at.get_last_error() != NSAPI_ERROR_OK) {
+                _at.restore_at_timeout();
                 return _at.unlock_return_error();
             }
         }
     }
 
     _sms_message_ref_number++;
     nsapi_error_t ret = _at.get_last_error();
+    _at.restore_at_timeout();
     _at.unlock();
 
     return (ret == NSAPI_ERROR_OK) ? msg_len : ret;
@@ -697,6 +703,7 @@ nsapi_size_or_error_t AT_CellularSMS::get_sms(char *buf, uint16_t len, char *pho
     }
 
     _at.lock();
+    _at.set_at_timeout(10s);
 
     nsapi_size_or_error_t err = list_messages();
     if (err == NSAPI_ERROR_OK) {
@@ -710,6 +717,7 @@ nsapi_size_or_error_t AT_CellularSMS::get_sms(char *buf, uint16_t len, char *pho
                     *buf_size = info->msg_size;
                 }
                 free_linked_list();
+                _at.restore_at_timeout();
                 _at.unlock();
                 return NSAPI_ERROR_PARAMETER;
             }
@@ -734,6 +742,7 @@ nsapi_size_or_error_t AT_CellularSMS::get_sms(char *buf, uint16_t len, char *pho
 
     free_linked_list();
 
+    _at.restore_at_timeout();
     _at.unlock();
 
     // update error only when there really was an error, otherwise we return the length
@@ -1027,6 +1036,7 @@ nsapi_error_t AT_CellularSMS::list_messages()
     int index = 0;
     int length = 0;
     char *pdu = NULL;
+    char buffer[32]; // 32 > SMS_STATUS_SIZE, SMS_MAX_PHONE_NUMBER_SIZE, SMS_MAX_TIME_STAMP_SIZE
 
     _at.resp_start("+CMGL:");
     while (_at.info_resp()) {
@@ -1049,8 +1059,18 @@ nsapi_error_t AT_CellularSMS::list_messages()
             // +CMGL: <index>,<stat>,<oa/da>,[<alpha>],[<scts>][,<tooa/toda>,<length>]<CR><LF><data>[<CR><LF>
             // +CMGL: <index>,<stat>,<da/oa>,[<alpha>],[<scts>][,<tooa/toda>,<length>]<CR><LF><data>[...]]
             index = _at.read_int();
-            (void)_at.consume_to_stop_tag(); // consume until <CR><LF>
-            (void)_at.consume_to_stop_tag(); // consume until <CR><LF>
+            _at.read_string(buffer, SMS_STATUS_SIZE);
+            _at.read_string(buffer, SMS_MAX_PHONE_NUMBER_SIZE);
+            _at.skip_param(); // <alpha>
+            _at.read_string(buffer, SMS_MAX_TIME_STAMP_SIZE);
+            _at.read_int();
+            int size = _at.read_int(); // length
+            _at.consume_to_stop_tag(); //  consume until <CR><LF> end of header
+            if (size > 0) {
+                // we can not use skip param because we already consumed stop tag
+                _at.skip_param_bytes(size, 1);
+            }
+            _at.consume_to_stop_tag_even_found(); // consume until <CR><LF> -> data
         }
 
         if (index >= 0) {

connectivity/cellular/source/framework/device/ATHandler.cpp

@@ -484,6 +484,26 @@ void ATHandler::skip_param(ssize_t len, uint32_t count)
     return;
 }
 
+void ATHandler::skip_param_bytes(ssize_t len, uint32_t count)
+{
+    if (!ok_to_proceed()) {
+        return;
+    }
+
+    for (uint32_t i = 0; i < count; i++) {
+        ssize_t read_len = 0;
+        while (read_len < len) {
+            int c = get_char();
+            if (c == -1) {
+                set_error(NSAPI_ERROR_DEVICE_ERROR);
+                return;
+            }
+            read_len++;
+        }
+    }
+    return;
+}
+
 ssize_t ATHandler::read_bytes(uint8_t *buf, size_t len)
 {
     if (!ok_to_proceed()) {
@@ -1093,6 +1113,26 @@ bool ATHandler::consume_to_stop_tag()
     return false;
 }
 
+
+bool ATHandler::consume_to_stop_tag_even_found()
+{
+    if (_error_found) {
+        return true;
+    }
+
+    if (!_is_fh_usable) {
+        _last_err = NSAPI_ERROR_BUSY;
+        return true;
+    }
+
+    if (consume_to_tag((const char *)_stop_tag->tag, true)) {
+        return true;
+    }
+
+    clear_error();
+    return false;
+}
+
 // consume by size needed?
 
 void ATHandler::resp_stop()

connectivity/cellular/tests/UNITTESTS/doubles/ATHandler_stub.cpp

@@ -201,6 +201,10 @@ void ATHandler::skip_param(ssize_t len, uint32_t count)
 {
 }
 
+void ATHandler::skip_param_bytes(ssize_t len, uint32_t count)
+{
+}
+
 ssize_t ATHandler::read_bytes(uint8_t *buf, size_t len)
 {
     return ATHandler_stub::ssize_value;
@@ -301,6 +305,11 @@ bool ATHandler::consume_to_stop_tag()
     return ATHandler_stub::bool_value;
 }
 
+bool ATHandler::consume_to_stop_tag_even_found()
+{
+    return ATHandler_stub::bool_value;
+}
+
 void ATHandler::resp_stop()
 {
     if (ATHandler_stub::resp_stop_success_count > 0) {

connectivity/cellular/tests/UNITTESTS/framework/AT/at_cellularsms/at_cellularsmstest.cpp

@@ -155,8 +155,16 @@ TEST_F(TestAT_CellularSMS, test_AT_CellularSMS_get_sms)
     ATHandler_stub::resp_info_false_counter = 1;
     ATHandler_stub::resp_info_true_counter2 = 2;
     ATHandler_stub::int_value = 11;
-    ATHandler_stub::read_string_index = 4;
-    ATHandler_stub::read_string_table[4] = "";
+    ATHandler_stub::read_string_index = (3 * 2) + (2 * 2); // 3 read_string in list_messages + 2 read_string in read_sms_from_index
+    ATHandler_stub::read_string_table[10] = "";
+    // list_messages
+    ATHandler_stub::read_string_table[9] = "1"; // status
+    ATHandler_stub::read_string_table[8] = "+00611223344"; // phone
+    ATHandler_stub::read_string_table[7] = "24/12/12,11:15:00+04"; // timestamp
+    ATHandler_stub::read_string_table[6] = "1"; // status
+    ATHandler_stub::read_string_table[5] = "+00611223344"; // phone
+    ATHandler_stub::read_string_table[4] = "24/12/12,11:15:00+04"; // timestamp
+    // read_sms_from_index
     ATHandler_stub::read_string_table[3] = "REC READ";
     ATHandler_stub::read_string_table[2] = "09/01/12,11:15:00+04";
     ATHandler_stub::read_string_table[1] = "REC READ";

connectivity/drivers/emac/TARGET_NUVOTON_EMAC/TARGET_M460/m460_eth.c

@@ -20,6 +20,7 @@
 //#include <stdbool.h>
 #include "m460_eth.h"
 #include "mbed_toolchain.h"
+#include "mbed_interface.h"
 //#define NU_TRACE
 #include "numaker_eth_hal.h"
 

connectivity/drivers/emac/TARGET_NUVOTON_EMAC/TARGET_M480/m480_eth.c

@@ -20,6 +20,7 @@
 #include <stdbool.h>
 #include "m480_eth.h"
 #include "mbed_toolchain.h"
+#include "mbed_interface.h"
 //#define NU_TRACE
 #include "numaker_eth_hal.h"
 

connectivity/drivers/emac/TARGET_NUVOTON_EMAC/TARGET_NUC472/nuc472_eth.c

@@ -20,6 +20,7 @@
 #include <stdbool.h>
 #include "nuc472_eth.h"
 #include "mbed_toolchain.h"
+#include "mbed_interface.h"
 //#define NU_TRACE
 #include "numaker_eth_hal.h"
 

connectivity/drivers/lora/COMPONENT_SX126X/SX126X_LoRaRadio.cpp

@@ -437,7 +437,7 @@ void SX126X_LoRaRadio::cold_start_wakeup()
     if (MBED_CONF_SX126X_LORA_DRIVER_XTAL == 0) {
 #endif
         caliberation_params_t calib_param;
-        set_dio3_as_tcxo_ctrl(TCXO_CTRL_1_7V, 320); //5 ms
+        set_dio3_as_tcxo_ctrl(MBED_CONF_SX126X_LORA_DRIVER_TCXO_CTRL, 320); //5 ms
         calib_param.value = 0x7F;
         write_opmode_command(RADIO_CALIBRATE, &calib_param.value, 1);
     }