Merge tag 'mbed-os-5.3.0-rc3' into feature_cmsis5_mbed_53

Release mbed OS 5.3.0-rc3

Ports for Upcoming Targets

Fixes and Changes

3373: Fix DEBUG target keyword for GCC_ARM #3373
3374: Don't send events on close() #3374

Author: bulislaw

.travis.yml

@@ -2,6 +2,7 @@ python:
   - "2.7"
 
 script:
+  - make -C events/equeue test clean
   - PYTHONPATH=. python tools/test/config_test/config_test.py
   - PYTHONPATH=. python tools/test/build_api/build_api_test.py
   - python tools/test/pylint.py

TESTS/mbed_functional/callback/main.cpp

@@ -233,6 +233,11 @@ template <typename T>
 T const_volatile_void_func5(const volatile void *t, T a0, T a1, T a2, T a3, T a4)
     { return static_cast<const volatile Thing<T>*>(t)->t | a0 | a1 | a2 | a3 | a4; }
 
+// Inheriting class
+template <typename T>
+class Thing2 : public Thing<T> {
+};
+
 
 // function call and result verification
 template <typename T>
@@ -315,15 +320,18 @@ struct Verifier {
 template <typename T>
 void test_dispatch0() {
     Thing<T> thing;
+    Thing2<T> thing2;
     Verifier<T>::verify0(static_func0<T>);
     Verifier<T>::verify0(&thing, &Thing<T>::member_func0);
     Verifier<T>::verify0((const Thing<T>*)&thing, &Thing<T>::const_member_func0);
     Verifier<T>::verify0((volatile Thing<T>*)&thing, &Thing<T>::volatile_member_func0);
     Verifier<T>::verify0((const volatile Thing<T>*)&thing, &Thing<T>::const_volatile_member_func0);
+    Verifier<T>::verify0(&thing2, &Thing2<T>::member_func0);
     Verifier<T>::verify0(&bound_func0<T>, &thing);
     Verifier<T>::verify0(&const_bound_func0<T>, (const Thing<T>*)&thing);
     Verifier<T>::verify0(&volatile_bound_func0<T>, (volatile Thing<T>*)&thing);
     Verifier<T>::verify0(&const_volatile_bound_func0<T>, (const volatile Thing<T>*)&thing);
+    Verifier<T>::verify0(&bound_func0<T>, &thing2);
     Verifier<T>::verify0(&void_func0<T>, &thing);
     Verifier<T>::verify0(&const_void_func0<T>, (const Thing<T>*)&thing);
     Verifier<T>::verify0(&volatile_void_func0<T>, (volatile Thing<T>*)&thing);
@@ -342,15 +350,18 @@ void test_dispatch0() {
 template <typename T>
 void test_dispatch1() {
     Thing<T> thing;
+    Thing2<T> thing2;
     Verifier<T>::verify1(static_func1<T>);
     Verifier<T>::verify1(&thing, &Thing<T>::member_func1);
     Verifier<T>::verify1((const Thing<T>*)&thing, &Thing<T>::const_member_func1);
     Verifier<T>::verify1((volatile Thing<T>*)&thing, &Thing<T>::volatile_member_func1);
     Verifier<T>::verify1((const volatile Thing<T>*)&thing, &Thing<T>::const_volatile_member_func1);
+    Verifier<T>::verify1(&thing2, &Thing2<T>::member_func1);
     Verifier<T>::verify1(&bound_func1<T>, &thing);
     Verifier<T>::verify1(&const_bound_func1<T>, (const Thing<T>*)&thing);
     Verifier<T>::verify1(&volatile_bound_func1<T>, (volatile Thing<T>*)&thing);
     Verifier<T>::verify1(&const_volatile_bound_func1<T>, (const volatile Thing<T>*)&thing);
+    Verifier<T>::verify1(&bound_func1<T>, &thing2);
     Verifier<T>::verify1(&void_func1<T>, &thing);
     Verifier<T>::verify1(&const_void_func1<T>, (const Thing<T>*)&thing);
     Verifier<T>::verify1(&volatile_void_func1<T>, (volatile Thing<T>*)&thing);
@@ -369,15 +380,18 @@ void test_dispatch1() {
 template <typename T>
 void test_dispatch2() {
     Thing<T> thing;
+    Thing2<T> thing2;
     Verifier<T>::verify2(static_func2<T>);
     Verifier<T>::verify2(&thing, &Thing<T>::member_func2);
     Verifier<T>::verify2((const Thing<T>*)&thing, &Thing<T>::const_member_func2);
     Verifier<T>::verify2((volatile Thing<T>*)&thing, &Thing<T>::volatile_member_func2);
     Verifier<T>::verify2((const volatile Thing<T>*)&thing, &Thing<T>::const_volatile_member_func2);
+    Verifier<T>::verify2(&thing2, &Thing2<T>::member_func2);
     Verifier<T>::verify2(&bound_func2<T>, &thing);
     Verifier<T>::verify2(&const_bound_func2<T>, (const Thing<T>*)&thing);
     Verifier<T>::verify2(&volatile_bound_func2<T>, (volatile Thing<T>*)&thing);
     Verifier<T>::verify2(&const_volatile_bound_func2<T>, (const volatile Thing<T>*)&thing);
+    Verifier<T>::verify2(&bound_func2<T>, &thing2);
     Verifier<T>::verify2(&void_func2<T>, &thing);
     Verifier<T>::verify2(&const_void_func2<T>, (const Thing<T>*)&thing);
     Verifier<T>::verify2(&volatile_void_func2<T>, (volatile Thing<T>*)&thing);
@@ -396,15 +410,18 @@ void test_dispatch2() {
 template <typename T>
 void test_dispatch3() {
     Thing<T> thing;
+    Thing2<T> thing2;
     Verifier<T>::verify3(static_func3<T>);
     Verifier<T>::verify3(&thing, &Thing<T>::member_func3);
     Verifier<T>::verify3((const Thing<T>*)&thing, &Thing<T>::const_member_func3);
     Verifier<T>::verify3((volatile Thing<T>*)&thing, &Thing<T>::volatile_member_func3);
     Verifier<T>::verify3((const volatile Thing<T>*)&thing, &Thing<T>::const_volatile_member_func3);
+    Verifier<T>::verify3(&thing2, &Thing2<T>::member_func3);
     Verifier<T>::verify3(&bound_func3<T>, &thing);
     Verifier<T>::verify3(&const_bound_func3<T>, (const Thing<T>*)&thing);
     Verifier<T>::verify3(&volatile_bound_func3<T>, (volatile Thing<T>*)&thing);
     Verifier<T>::verify3(&const_volatile_bound_func3<T>, (const volatile Thing<T>*)&thing);
+    Verifier<T>::verify3(&bound_func3<T>, &thing2);
     Verifier<T>::verify3(&void_func3<T>, &thing);
     Verifier<T>::verify3(&const_void_func3<T>, (const Thing<T>*)&thing);
     Verifier<T>::verify3(&volatile_void_func3<T>, (volatile Thing<T>*)&thing);
@@ -423,15 +440,18 @@ void test_dispatch3() {
 template <typename T>
 void test_dispatch4() {
     Thing<T> thing;
+    Thing2<T> thing2;
     Verifier<T>::verify4(static_func4<T>);
     Verifier<T>::verify4(&thing, &Thing<T>::member_func4);
     Verifier<T>::verify4((const Thing<T>*)&thing, &Thing<T>::const_member_func4);
     Verifier<T>::verify4((volatile Thing<T>*)&thing, &Thing<T>::volatile_member_func4);
     Verifier<T>::verify4((const volatile Thing<T>*)&thing, &Thing<T>::const_volatile_member_func4);
+    Verifier<T>::verify4(&thing2, &Thing2<T>::member_func4);
     Verifier<T>::verify4(&bound_func4<T>, &thing);
     Verifier<T>::verify4(&const_bound_func4<T>, (const Thing<T>*)&thing);
     Verifier<T>::verify4(&volatile_bound_func4<T>, (volatile Thing<T>*)&thing);
     Verifier<T>::verify4(&const_volatile_bound_func4<T>, (const volatile Thing<T>*)&thing);
+    Verifier<T>::verify4(&bound_func4<T>, &thing2);
     Verifier<T>::verify4(&void_func4<T>, &thing);
     Verifier<T>::verify4(&const_void_func4<T>, (const Thing<T>*)&thing);
     Verifier<T>::verify4(&volatile_void_func4<T>, (volatile Thing<T>*)&thing);
@@ -450,15 +470,18 @@ void test_dispatch4() {
 template <typename T>
 void test_dispatch5() {
     Thing<T> thing;
+    Thing2<T> thing2;
     Verifier<T>::verify5(static_func5<T>);
     Verifier<T>::verify5(&thing, &Thing<T>::member_func5);
     Verifier<T>::verify5((const Thing<T>*)&thing, &Thing<T>::const_member_func5);
     Verifier<T>::verify5((volatile Thing<T>*)&thing, &Thing<T>::volatile_member_func5);
     Verifier<T>::verify5((const volatile Thing<T>*)&thing, &Thing<T>::const_volatile_member_func5);
+    Verifier<T>::verify5(&thing2, &Thing2<T>::member_func5);
     Verifier<T>::verify5(&bound_func5<T>, &thing);
     Verifier<T>::verify5(&const_bound_func5<T>, (const Thing<T>*)&thing);
     Verifier<T>::verify5(&volatile_bound_func5<T>, (volatile Thing<T>*)&thing);
     Verifier<T>::verify5(&const_volatile_bound_func5<T>, (const volatile Thing<T>*)&thing);
+    Verifier<T>::verify5(&bound_func5<T>, &thing2);
     Verifier<T>::verify5(&void_func5<T>, &thing);
     Verifier<T>::verify5(&const_void_func5<T>, (const Thing<T>*)&thing);
     Verifier<T>::verify5(&volatile_void_func5<T>, (volatile Thing<T>*)&thing);

TESTS/network/wifi/main.cpp

@@ -0,0 +1,196 @@
+/* mbed Microcontroller Library
+ * Copyright (c) 2016 ARM Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "utest/utest.h"
+#include "unity/unity.h"
+#include "greentea-client/test_env.h"
+
+#include "mbed.h"
+
+#if TARGET_UBLOX_EVK_ODIN_W2
+#include "OdinWiFiInterface.h"
+#else
+#error [NOT_SUPPORTED] Only built in WiFi modules are supported at this time.
+#endif
+
+using namespace utest::v1;
+
+/**
+ * WiFi tests require following macros to be defined:
+ * - MBED_CONF_APP_WIFI_SSID - SSID of a network the test will try connecting to
+ * - MBED_CONF_APP_WIFI_PASSWORD - Passphrase that will be used to connecting to the network
+ * - WIFI_TEST_NETWORKS - List of network that presence will be asserted e.g. "net1", "net2", "net3"
+ */
+#if !defined(MBED_CONF_APP_WIFI_SSID) || !defined(MBED_CONF_APP_WIFI_PASSWORD) || !defined(MBED_CONF_APP_WIFI_NETWORKS)
+#error [NOT_SUPPORTED] MBED_CONF_APP_WIFI_SSID, MBED_CONF_APP_WIFI_PASSWORD and MBED_CONF_APP_WIFI_NETWORKS have to be defined for this test.
+#endif
+
+const char *networks[] = {MBED_CONF_APP_WIFI_NETWORKS, NULL};
+
+WiFiInterface *wifi;
+
+/* In normal circumstances the WiFi object could be global, but the delay introduced by WiFi initialization is an issue
+   for the tests. It causes Greentea to timeout on syncing with the board. To solve it we defer the actual object
+   creation till we actually need it.
+ */
+WiFiInterface *get_wifi()
+{
+    if (wifi == NULL) {
+        /* We don't really care about freeing this, as its lifetime is through the full test suit run. */
+#if TARGET_UBLOX_EVK_ODIN_W2
+        wifi = new OdinWiFiInterface;
+#endif
+    }
+
+    return wifi;
+}
+
+void check_wifi(const char *ssid, bool *net_stat)
+{
+    int i = 0;
+    while(networks[i]) {
+        if (strcmp(networks[i], ssid) == 0) {
+            net_stat[i] = true;
+            break;
+        }
+        i++;
+    }
+}
+
+void wifi_scan()
+{
+    int count;
+    WiFiAccessPoint *aps;
+    const int net_len = sizeof(networks)/sizeof(networks[0]);
+    bool net_stat[net_len - 1];
+
+    memset(net_stat, 0, sizeof(net_stat));
+
+    count = get_wifi()->scan(NULL, 0);
+    TEST_ASSERT_MESSAGE(count >= 0, "WiFi interface returned error");
+    TEST_ASSERT_MESSAGE(count > 0, "Scan result empty");
+
+    aps = new WiFiAccessPoint[count];
+    count = get_wifi()->scan(aps, count);
+    for(int i = 0; i < count; i++) {
+        check_wifi(aps[i].get_ssid(), net_stat);
+    }
+
+    delete[] aps;
+
+    for (unsigned i = 0; i < sizeof(net_stat); i++) {
+        TEST_ASSERT_MESSAGE(net_stat[i] == true, "Not all required WiFi network detected");
+    }
+}
+
+void wifi_connect()
+{
+    int ret;
+
+    ret = get_wifi()->connect(MBED_CONF_APP_WIFI_SSID, MBED_CONF_APP_WIFI_PASSWORD, NSAPI_SECURITY_WPA_WPA2);
+    TEST_ASSERT_MESSAGE(ret == 0, "Connect failed");
+
+    ret = get_wifi()->disconnect();
+    TEST_ASSERT_MESSAGE(ret == 0, "Disconnect failed");
+}
+
+void wifi_connect_scan()
+{
+    int ret;
+    int count;
+    WiFiAccessPoint *aps;
+    const int net_len = sizeof(networks)/sizeof(networks[0]);
+    bool net_stat[net_len - 1];
+
+    memset(net_stat, 0, sizeof(net_stat));
+
+    ret = get_wifi()->connect(MBED_CONF_APP_WIFI_SSID, MBED_CONF_APP_WIFI_PASSWORD, NSAPI_SECURITY_WPA_WPA2);
+    TEST_ASSERT_MESSAGE(ret == 0, "Connect failed");
+
+    count = get_wifi()->scan(NULL, 0);
+    TEST_ASSERT_MESSAGE(count >= 0, "WiFi interface returned error");
+    TEST_ASSERT_MESSAGE(count > 0, "Scan result empty");
+
+    aps = new WiFiAccessPoint[count];
+    count = get_wifi()->scan(aps, count);
+    for(int i = 0; i < count; i++) {
+        check_wifi(aps[i].get_ssid(), net_stat);
+    }
+
+    delete[] aps;
+
+    ret = get_wifi()->disconnect();
+    TEST_ASSERT_MESSAGE(ret == 0, "Disconnect failed");
+
+    for (unsigned i = 0; i < sizeof(net_stat); i++) {
+        TEST_ASSERT_MESSAGE(net_stat[i] == true, "Not all required WiFi network detected");
+    }
+}
+
+void wifi_http()
+{
+    TCPSocket socket;
+    int ret;
+
+    ret = get_wifi()->connect(MBED_CONF_APP_WIFI_SSID, MBED_CONF_APP_WIFI_PASSWORD, NSAPI_SECURITY_WPA_WPA2);
+    TEST_ASSERT_MESSAGE(ret == 0, "Connect failed");
+
+    // Open a socket on the network interface, and create a TCP connection to www.arm.com
+    ret = socket.open(get_wifi());
+    TEST_ASSERT_MESSAGE(ret == 0, "Socket open failed");
+    ret = socket.connect("www.arm.com", 80);
+    TEST_ASSERT_MESSAGE(ret == 0, "Socket connect failed");
+
+    // Send a simple http request
+    char sbuffer[] = "GET / HTTP/1.1\r\nHost: www.arm.com\r\n\r\n";
+    int scount = socket.send(sbuffer, sizeof sbuffer);
+    TEST_ASSERT_MESSAGE(scount >= 0, "Socket send failed");
+
+    // Recieve a simple http response and check if it's not empty
+    char rbuffer[64];
+    int rcount = socket.recv(rbuffer, sizeof rbuffer);
+    TEST_ASSERT_MESSAGE(rcount >= 0, "Socket recv error");
+    TEST_ASSERT_MESSAGE(rcount > 0, "No data received");
+
+    ret = socket.close();
+    TEST_ASSERT_MESSAGE(ret == 0, "Socket close failed");
+
+    ret = get_wifi()->disconnect();
+    TEST_ASSERT_MESSAGE(ret == 0, "Disconnect failed");
+}
+
+status_t greentea_failure_handler(const Case *const source, const failure_t reason) {
+    greentea_case_failure_abort_handler(source, reason);
+    return STATUS_CONTINUE;
+}
+
+Case cases[] = {
+    Case("Scan test", wifi_scan, greentea_failure_handler),
+    Case("Connect test", wifi_connect, greentea_failure_handler),
+    Case("Scan while connected test", wifi_connect_scan, greentea_failure_handler),
+    Case("HTTP test", wifi_http, greentea_failure_handler),
+};
+
+status_t greentea_test_setup(const size_t number_of_cases) {
+    GREENTEA_SETUP(90, "default_auto");
+    return greentea_test_setup_handler(number_of_cases);
+}
+
+
+int main() {
+    Specification specification(greentea_test_setup, cases, greentea_test_teardown_handler);
+    Harness::run(specification);
+}

TESTS/network/wifi/template_mbed_app.txt

@@ -0,0 +1,21 @@
+{
+    "config": {
+        "wifi-ssid": {
+            "help": "WiFi SSID",
+            "value": "\"SSID\""
+        },
+        "wifi-password": {
+            "help": "WiFi Password",
+            "value": "\"PASS\""
+        },
+        "wifi-networks": {
+            "help": "WiFi SSIDs which presence will be asserted in the test",
+            "value": "\"SSID1\",\"SSID2\",\"SSID3\""
+        }
+    },
+    "target_overrides": {
+        "UBLOX_EVK_ODIN_W2": {
+            "target.device_has": ["EMAC"]
+        }
+    }
+}

cmsis/core_caFunc.h

@@ -811,6 +811,23 @@ __asm(
 __STATIC_INLINE void __v7_inv_dcache_all(void) {
     __v7_all_cache(0);
 }
+/** \brief  Clean the whole D$
+
+    DCCSW. Clean by Set/Way
+ */
+
+__STATIC_INLINE void __v7_clean_dcache_all(void) {
+    __v7_all_cache(1);
+}
+
+/** \brief  Clean and invalidate the whole D$
+
+    DCCISW. Clean and Invalidate by Set/Way
+ */
+
+__STATIC_INLINE void __v7_clean_inv_dcache_all(void) {
+    __v7_all_cache(2);
+}
 /** \brief  Clean and Invalidate D$ by MVA
 
     DCCIMVAC. Data cache clean and invalidate by MVA to PoC

cmsis/core_cm0.h

@@ -625,7 +625,9 @@ __STATIC_INLINE void NVIC_DisableIRQ(IRQn_Type IRQn)
 {
   if ((int32_t)(IRQn) >= 0)
   {
-    NVIC->ICER[0U] = (uint32_t)(1UL << (((uint32_t)(int32_t)IRQn) & 0x1FUL));
+    NVIC->ICER[0] = (uint32_t)(1UL << (((uint32_t)(int32_t)IRQn) & 0x1FUL));
+    __DSB();
+    __ISB();
   }
 }
 

cmsis/core_cm0plus.h

@@ -742,6 +742,8 @@ __STATIC_INLINE void NVIC_DisableIRQ(IRQn_Type IRQn)
   if ((int32_t)(IRQn) >= 0)
   {
     NVIC->ICER[0U] = (uint32_t)(1UL << (((uint32_t)(int32_t)IRQn) & 0x1FUL));
+    __DSB();
+    __ISB();
   }
 }