Nanostack EMAC implementation

Make Nanostack an OnboardNetworkInterface, implementing
add_ethernet_interface so it can use EMAC drivers.

Can now be used via EthernetInterface, and be the system's default
network stack.

Legacy support for NanostackEthernetInterface retained. Some
restructuring of mesh interface code to fit into the
OnboardNetworkStack:::Interface system.

Author: kjbracey

features/nanostack/FEATURE_NANOSTACK/mbed-mesh-api/mbed-mesh-api/LoWPANNDInterface.h

@@ -26,22 +26,16 @@ class LoWPANNDInterface : public MeshInterfaceNanostack {
      *
      *  Must initialize to initialize the mesh on a phy.
      */
-    LoWPANNDInterface() : MeshInterfaceNanostack() { }
+    LoWPANNDInterface() { }
 
-    /** Create an initialized MeshInterface
+    /** Create an initialized LoWPANNDInterface
      *
      */
     LoWPANNDInterface(NanostackRfPhy *phy) : MeshInterfaceNanostack(phy) { }
 
-    nsapi_error_t initialize(NanostackRfPhy *phy);
     virtual int connect();
     virtual int disconnect();
-    virtual bool getOwnIpAddress(char *address, int8_t len);
     bool getRouterIpAddress(char *address, int8_t len);
-private:
-    mesh_error_t init();
-    mesh_error_t mesh_connect();
-    mesh_error_t mesh_disconnect();
 };
 
 #endif

features/nanostack/FEATURE_NANOSTACK/mbed-mesh-api/mbed-mesh-api/MeshInterfaceNanostack.h

@@ -20,32 +20,42 @@
 
 #include "MeshInterface.h"
 #include "NanostackRfPhy.h"
+#include "Nanostack.h"
 #include "mesh_interface_types.h"
 
-class MeshInterfaceNanostack : public MeshInterface {
+class Nanostack::Interface : public OnboardNetworkStack::Interface, private mbed::NonCopyable<Nanostack::Interface> {
 public:
+    virtual char *get_ip_address(char *buf, nsapi_size_t buflen);
+    virtual char *get_mac_address(char *buf, nsapi_size_t buflen);
+    virtual char *get_netmask(char *buf, nsapi_size_t buflen);
+    virtual char *get_gateway(char *buf, nsapi_size_t buflen);
 
-    /** Attach phy and initialize the mesh
-     *
-     *  Initializes a mesh interface on the given phy. Not needed if
-     *  the phy is passed to the mesh's constructor.
-     *
-     *  @return     0 on success, negative on failure
-     */
-    nsapi_error_t initialize(NanostackPhy *phy);
+    /**
+     * \brief Callback from C-layer
+     * \param state state of the network
+     * */
+    void network_handler(mesh_connection_status_t status);
 
-    /** Start the interface
-     *
-     *  @return     0 on success, negative on failure
-     */
-    virtual nsapi_error_t connect() = 0;
+private:
+    NanostackPhy &interface_phy;
+protected:
+    Interface(NanostackPhy &phy);
+    virtual nsapi_error_t register_phy();
+    NanostackPhy &get_phy() const { return interface_phy; }
+    int8_t interface_id;
+    int8_t _device_id;
+    Semaphore connect_semaphore;
+};
+
+class Nanostack::MeshInterface : public Nanostack::Interface {
+protected:
+    MeshInterface(NanostackRfPhy &phy) : Interface(phy) { }
+    NanostackRfPhy &get_phy() const { return static_cast<NanostackRfPhy &>(Interface::get_phy()); }
+};
 
-    /** Stop the interface
-     *
-     *  @return     0 on success, negative on failure
-     */
-    virtual nsapi_error_t disconnect() = 0;
 
+class InterfaceNanostack : public virtual NetworkInterface {
+public:
     /** Get the internally stored IP address
     /return     IP address of the interface or null if not yet connected
     */
@@ -56,36 +66,34 @@ class MeshInterfaceNanostack : public MeshInterface {
     */
     virtual const char *get_mac_address();
 
-    /**
-     * \brief Callback from C-layer
-     * \param state state of the network
-     * */
-    void mesh_network_handler(mesh_connection_status_t status);
-
 protected:
-    MeshInterfaceNanostack();
-    MeshInterfaceNanostack(NanostackPhy *phy);
-    nsapi_error_t register_phy();
-    virtual NetworkStack * get_stack(void);
+    InterfaceNanostack();
+    virtual Nanostack *get_stack(void);
+    Nanostack::Interface *get_interface() const { return _interface; }
 
-    /**
-     * \brief Read own global IP address
-     *
-     * \param address is where the IP address will be copied
-     * \param len is the length of the address buffer, must be at least 40 bytes
-     * \return true if address is read successfully, false otherwise
-     */
-    virtual bool getOwnIpAddress(char *address, int8_t len) = 0;
+    Nanostack::Interface *_interface;
 
-    NanostackPhy *phy;
-    /** Network interface ID */
-    int8_t _network_interface_id;
-    /** Registered device ID */
-    int8_t _device_id;
-    uint8_t _eui64[8];
     char ip_addr_str[40];
     char mac_addr_str[24];
-    Semaphore connect_semaphore;
+};
+
+class MeshInterfaceNanostack : public InterfaceNanostack, public MeshInterface, private mbed::NonCopyable<MeshInterfaceNanostack> {
+public:
+
+    /** Attach phy and initialize the mesh
+     *
+     *  Initializes a mesh interface on the given phy. Not needed if
+     *  the phy is passed to the mesh's constructor.
+     *
+     *  @return     0 on success, negative on failure
+     */
+    nsapi_error_t initialize(NanostackRfPhy *phy);
+
+protected:
+    MeshInterfaceNanostack() : _phy(NULL) { }
+    MeshInterfaceNanostack(NanostackRfPhy *phy) : _phy(phy) { }
+    Nanostack::MeshInterface *get_interface() const { return static_cast<Nanostack::MeshInterface *>(_interface); }
+    NanostackRfPhy *_phy;
 };
 
 #endif /* MESHINTERFACENANOSTACK_H */

features/nanostack/FEATURE_NANOSTACK/mbed-mesh-api/mbed-mesh-api/NanostackEMACInterface.h

@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2016 ARM Limited. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ * 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.
+ */
+
+#ifndef NANOSTACKETHERNETINTERFACE_H
+#define NANOSTACKETHERNETINTERFACE_H
+
+#include "MeshInterfaceNanostack.h"
+#include "NanostackEthernetPhy.h"
+
+class NanostackEMACInterface : public Nanostack::Interface {
+public:
+
+    NanostackEMACInterface(EMAC &emac);
+};
+
+#endif // NANOSTACKETHERNETINTERFACE_H

features/nanostack/FEATURE_NANOSTACK/mbed-mesh-api/mbed-mesh-api/NanostackEthernetInterface.h

@@ -17,20 +17,48 @@
 #ifndef NANOSTACKETHERNETINTERFACE_H
 #define NANOSTACKETHERNETINTERFACE_H
 
+#include "EthInterface.h"
 #include "MeshInterfaceNanostack.h"
 #include "NanostackEthernetPhy.h"
 
-class NanostackEthernetInterface : public MeshInterfaceNanostack {
+class Nanostack::EthernetInterface : public Nanostack::Interface {
 public:
+    virtual nsapi_error_t bringup(bool dhcp, const char *ip,
+                                  const char *netmask, const char *gw,
+                                  nsapi_ip_stack_t stack = DEFAULT_STACK);
+    virtual nsapi_error_t bringdown();
 
-    NanostackEthernetInterface() : MeshInterfaceNanostack() { }
-    NanostackEthernetInterface(NanostackEthernetPhy *phy) : MeshInterfaceNanostack(phy) { }
+private:
+    friend Nanostack;
+    friend class NanostackEthernetInterface;
+    EthernetInterface(NanostackEthernetPhy &phy) : Interface(phy) {}
+    nsapi_error_t initialize();
+protected:
+    NanostackEthernetPhy &get_phy() const { return static_cast<NanostackEthernetPhy &>(Interface::get_phy()); }
+};
+
+class NanostackEthernetInterface : public InterfaceNanostack, public EthInterface, private mbed::NonCopyable<NanostackEthernetInterface> {
+public:
+    NanostackEthernetInterface() { }
+    //NanostackEthernetInterface(NanostackEthernetPhy *phy);
 
     nsapi_error_t initialize(NanostackEthernetPhy *phy);
-    virtual int connect();
-    virtual int disconnect();
-    virtual bool getOwnIpAddress(char *address, int8_t len);
-    bool getRouterIpAddress(char *address, int8_t len);
+
+    /** Start the interface
+     *
+     *  @return     0 on success, negative on failure
+     */
+    virtual nsapi_error_t connect();
+
+    /** Stop the interface
+     *
+     *  @return     0 on success, negative on failure
+     */
+    virtual nsapi_error_t disconnect();
+
+protected:
+    Nanostack::EthernetInterface *get_interface() const { return static_cast<Nanostack::EthernetInterface *>(_interface); }
+
 };
 
 #endif // NANOSTACKETHERNETINTERFACE_H

features/nanostack/FEATURE_NANOSTACK/mbed-mesh-api/mbed-mesh-api/NanostackRfInterface.h

@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2016 ARM Limited. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ * 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.
+ */
+
+#ifndef NANOSTACKRFINTERFACE_H
+#define NANOSTACKRFINTERFACE_H
+
+#include "MeshInterfaceNanostack.h"
+#include "NanostackRfPhy.h"
+
+class NanostackRfInterface : public Nanostack::Interface {
+public:
+
+    NanostackRfInterface(NanostackRfPhy &phy);
+};
+
+#endif // NANOSTACKRFINTERFACE_H

features/nanostack/FEATURE_NANOSTACK/mbed-mesh-api/mbed-mesh-api/ThreadInterface.h

@@ -22,18 +22,16 @@
 class ThreadInterface : public MeshInterfaceNanostack {
 public:
 
-    /** Create an uninitialized LoWPANNDInterface
+    /** Create an uninitialized ThreadInterface
      *
      *  Must initialize to initialize the mesh on a phy.
      */
-    ThreadInterface() : MeshInterfaceNanostack() { }
+    ThreadInterface() : user_set_eui64(false) { }
 
-    /** Create an initialized MeshInterface
+    /** Create an initialized ThreadInterface
      *
      */
-    ThreadInterface(NanostackRfPhy *phy) : MeshInterfaceNanostack(phy) { }
-
-    nsapi_error_t initialize(NanostackRfPhy *phy);
+    ThreadInterface(NanostackRfPhy *phy) : MeshInterfaceNanostack(phy), user_set_eui64(false) { }
 
     /**
      * \brief Sets the eui64 for the device configuration.
@@ -55,40 +53,11 @@ class ThreadInterface : public MeshInterfaceNanostack {
 
     virtual int connect();
     virtual int disconnect();
-private:
-    /*
-     * \brief Initialization of the interface.
-     * \return MESH_ERROR_NONE on success.
-     * \return MESH_ERROR_PARAM when input parameters are illegal (also in case when RF device is already associated to other interface)
-     * \return MESH_ERROR_MEMORY in case of memory error
-     * \return MESH_ERROR_UNKNOWN in other error cases
-     */
-    mesh_error_t init();
-    /**
-     * \brief Connect interface to the mesh network
-     * \return MESH_ERROR_NONE on success.
-     * \return MESH_ERROR_PARAM in case of illegal parameters.
-     * \return MESH_ERROR_MEMORY in case of memory error.
-     * \return MESH_ERROR_STATE if interface is already connected to network.
-     * \return MESH_ERROR_UNKNOWN in case of unspecified error.
-     * */
-    mesh_error_t mesh_connect();
+protected:
+    Nanostack::ThreadInterface *get_interface() const;
 
-    /**
-     * \brief Disconnect interface from the mesh network
-     * \return MESH_ERROR_NONE on success.
-     * \return MESH_ERROR_UNKNOWN in case of error.
-     * */
-    mesh_error_t mesh_disconnect();
-
-    /**
-     * \brief Read own global IP address
-     *
-     * \param address is where the IP address will be copied
-     * \param len is the length of the address buffer, must be at least 40 bytes
-     * \return true if address is read successfully, false otherwise
-     */
-    virtual bool getOwnIpAddress(char *address, int8_t len);
+private:
+    bool user_set_eui64;
 };
 
 #endif // THREADINTERFACE_H

features/nanostack/FEATURE_NANOSTACK/mbed-mesh-api/source/CallbackHandler.cpp

@@ -14,20 +14,21 @@
  * limitations under the License.
  */
 
-#include "include/callback_handler.h"
+#include "MeshInterfaceNanostack.h"
 
+#include "include/callback_handler.h"
 
-static MeshInterfaceNanostack *_handler = NULL;
+static Nanostack::Interface *_handler = NULL;
 
 void __mesh_handler_c_callback(mesh_connection_status_t state)
 {
 
     if (_handler) {
-        _handler->mesh_network_handler(state);
+        _handler->network_handler(state);
     }
 }
 
-void __mesh_handler_set_callback(MeshInterfaceNanostack *handler)
+void __mesh_handler_set_callback(Nanostack::Interface *handler)
 {
     _handler = handler;
 }