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

@@ -30,22 +30,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,36 +20,54 @@
 
 #include "MeshInterface.h"
 #include "NanostackRfPhy.h"
+#include "Nanostack.h"
 #include "mesh_interface_types.h"
 
-/** Nanostack's network interface class.
- *
- * Common class that is shared between mesh interface classes
- */
-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);
+    virtual void attach(mbed::Callback<void(nsapi_event_t, intptr_t)> status_cb);
+    virtual nsapi_connection_status_t get_connection_status() const;
+    virtual void set_blocking(bool blocking);
 
-    /** 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);
+    void get_mac_address(uint8_t *buf) const { interface_phy.get_mac_address(buf); }
 
-    /** Start the interface
-     *
-     *  @return     0 on success, negative on failure
-     */
-    virtual nsapi_error_t connect() = 0;
+    /**
+     * \brief Callback from C-layer
+     * \param status state of the network
+     * */
+    void network_handler(mesh_connection_status_t status);
 
-    /** Stop the interface
-     *
-     *  @return     0 on success, negative on failure
-     */
-    virtual nsapi_error_t disconnect() = 0;
+    int8_t get_interface_id() const { return interface_id; }
+    int8_t get_driver_id() const { return _device_id; }
 
+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;
+
+    Callback<void(nsapi_event_t, intptr_t)> _connection_status_cb;
+    nsapi_connection_status_t _connect_status;
+    bool _blocking;
+};
+
+class Nanostack::MeshInterface : public Nanostack::Interface {
+protected:
+    MeshInterface(NanostackRfPhy &phy) : Interface(phy) { }
+    NanostackRfPhy &get_phy() const { return static_cast<NanostackRfPhy &>(Interface::get_phy()); }
+};
+
+
+class InterfaceNanostack : public virtual NetworkInterface {
+public:
     /** Get the internally stored IP address
     /return     IP address of the interface or null if not yet connected
     */
@@ -60,18 +78,11 @@ class MeshInterfaceNanostack : public MeshInterface {
     */
     virtual const char *get_mac_address();
 
-    /** Get the interface ID
-    /return     Interface identifier
-    */
-    int8_t get_interface_id() const { return _network_interface_id; }
-
-    /**
-     * \brief Callback from C-layer
-     * \param status state of the network
-     * */
-    void mesh_network_handler(mesh_connection_status_t status);
-
     /** Register callback for status reporting
+     *
+     *  The specified status callback function will be called on status changes
+     *  on the network. The parameters on the callback are the event type and
+     *  event-type dependent reason parameter.
      *
      *  @param status_cb The callback for status changes
      */
@@ -90,34 +101,39 @@ class MeshInterfaceNanostack : public MeshInterface {
      */
     virtual nsapi_error_t set_blocking(bool blocking);
 
+    /** Get the interface ID
+    /return     Interface identifier
+    */
+    int8_t get_interface_id() const { return _interface->get_interface_id(); }
+
 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;
+};
 
-    Callback<void(nsapi_event_t, intptr_t)> _connection_status_cb;
-    nsapi_connection_status_t _connect_status;
-    bool _blocking;
+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,24 +17,52 @@
 #ifndef NANOSTACKETHERNETINTERFACE_H
 #define NANOSTACKETHERNETINTERFACE_H
 
+#include "EthInterface.h"
 #include "MeshInterfaceNanostack.h"
 #include "NanostackEthernetPhy.h"
 
+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();
+
+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()); }
+};
+
 /** Ethernet interface for Nanostack.
  *
  * Configure Nanostack to use Ethernet connectivity.
  */
-class NanostackEthernetInterface : public MeshInterfaceNanostack {
+class NanostackEthernetInterface : public InterfaceNanostack, public EthInterface, private mbed::NonCopyable<NanostackEthernetInterface> {
 public:
-
-    NanostackEthernetInterface() : MeshInterfaceNanostack() { }
-    NanostackEthernetInterface(NanostackEthernetPhy *phy) : MeshInterfaceNanostack(phy) { }
+    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

@@ -26,18 +26,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.
@@ -59,40 +57,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