conn_mgr_connectivity.h

Go to the documentation of this file.

/*
 * Copyright (c) 2023 Nordic Semiconductor ASA
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_INCLUDE_CONN_MGR_CONNECTIVITY_H_
#define ZEPHYR_INCLUDE_CONN_MGR_CONNECTIVITY_H_
 
#include <zephyr/device.h>
#include <zephyr/net/net_if.h>
#include <zephyr/sys/iterable_sections.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* Connectivity Events */
#define _NET_MGMT_CONN_LAYER                    NET_MGMT_LAYER(NET_MGMT_LAYER_L2)
#define _NET_MGMT_CONN_CODE                     NET_MGMT_LAYER_CODE(0x207)
#define _NET_MGMT_CONN_BASE                     (_NET_MGMT_CONN_LAYER | _NET_MGMT_CONN_CODE)
#define _NET_MGMT_CONN_IF_EVENT                 (NET_MGMT_IFACE_BIT | _NET_MGMT_CONN_BASE)
 
enum net_event_ethernet_cmd {
        NET_EVENT_CONN_CMD_IF_TIMEOUT = 1,
        NET_EVENT_CONN_CMD_IF_FATAL_ERROR,
};
 
#define NET_EVENT_CONN_IF_TIMEOUT                                       \
        (_NET_MGMT_CONN_IF_EVENT | NET_EVENT_CONN_CMD_IF_TIMEOUT)
 
#define NET_EVENT_CONN_IF_FATAL_ERROR                                   \
        (_NET_MGMT_CONN_IF_EVENT | NET_EVENT_CONN_CMD_IF_FATAL_ERROR)
 
struct conn_mgr_conn_binding;
struct conn_mgr_conn_api {
        int (*connect)(struct conn_mgr_conn_binding *const binding);
 
        int (*disconnect)(struct conn_mgr_conn_binding *const binding);
 
        void (*init)(struct conn_mgr_conn_binding *const binding);
 
        int (*set_opt)(struct conn_mgr_conn_binding *const binding,
                       int optname, const void *optval, size_t optlen);
 
        int (*get_opt)(struct conn_mgr_conn_binding *const binding,
                       int optname, void *optval, size_t *optlen);
};
 
#define CONN_MGR_CONN_IMPL_GET_NAME(conn_id)            __conn_mgr_conn_##conn_id
#define CONN_MGR_CONN_IMPL_GET_CTX_TYPE(conn_id)        conn_id##_CTX_TYPE
struct conn_mgr_conn_impl {
        /* The connectivity API used by the implementation */
        struct conn_mgr_conn_api *api;
};
 
#define CONN_MGR_CONN_DEFINE(conn_id, conn_api)                                         \
        const struct conn_mgr_conn_impl CONN_MGR_CONN_IMPL_GET_NAME(conn_id) = {        \
                .api = conn_api,                                                        \
        };
 
#define CONN_MGR_CONN_DECLARE_PUBLIC(conn_id)                                           \
        extern const struct conn_mgr_conn_impl CONN_MGR_CONN_IMPL_GET_NAME(conn_id)
 
#define CONN_MGR_CONN_BINDING_GET_NAME(dev_id, sfx)     __conn_mgr_bndg_##dev_id##_##sfx
#define CONN_MGR_CONN_BINDING_GET_DATA(dev_id, sfx)     __conn_mgr_bndg_data_##dev_id##_##sfx
#define CONN_MGR_CONN_BINDING_GET_MUTEX(dev_id, sfx)    __conn_mgr_bndg_mutex_##dev_id##_##sfx
enum conn_mgr_if_flag {
        /* Persistent
         * When set, indicates that the connectivity implementation bound to this iface should
         * attempt to persist connectivity by automatically reconnecting after connection loss.
         */
        CONN_MGR_IF_PERSISTENT,
 
        /* Total number of flags - must be at the end of the enum */
        CONN_MGR_NUM_IF_FLAGS,
};
 
/* Value to use with conn_mgr_conn_binding->timeout to indicate no timeout */
#define CONN_MGR_IF_NO_TIMEOUT 0
 
struct conn_mgr_conn_binding {
        /* The network interface the connectivity implementation is bound to */
        struct net_if *iface;
 
        /* The connectivity implementation the network device is bound to */
        const struct conn_mgr_conn_impl *impl;
 
        /* Pointer to private, per-iface connectivity context */
        void *ctx;
 
        /* Generic connectivity state - Flags
         * Public boolean state and configuration values supported by all bindings.
         * See conn_mgr_if_flag for options.
         */
        uint32_t flags;
 
        /* Generic connectivity state - Timeout (seconds)
         * Indicates to the connectivity implementation how long it should attempt to
         * establish connectivity for during a connection attempt before giving up.
         *
         * The connectivity implementation should give up on establishing connectivity after this
         * timeout, even if persistence is enabled.
         *
         * Set to CONN_MGR_IF_NO_TIMEOUT to indicate that no timeout should be used.
         */
        int timeout;
 
        /* Internal-use mutex for protecting access to the binding and API functions. */
        struct k_mutex *mutex;
};
 
#define CONN_MGR_BIND_CONN_INST(dev_id, inst, conn_id)                                          \
        K_MUTEX_DEFINE(CONN_MGR_CONN_BINDING_GET_MUTEX(dev_id, inst));                          \
        static CONN_MGR_CONN_IMPL_GET_CTX_TYPE(conn_id)                                         \
                                        CONN_MGR_CONN_BINDING_GET_DATA(dev_id, inst);           \
        static STRUCT_SECTION_ITERABLE(conn_mgr_conn_binding,                                   \
                                        CONN_MGR_CONN_BINDING_GET_NAME(dev_id, inst)) = {       \
                .iface = NET_IF_GET(dev_id, inst),                                              \
                .impl = &(CONN_MGR_CONN_IMPL_GET_NAME(conn_id)),                                \
                .ctx = &(CONN_MGR_CONN_BINDING_GET_DATA(dev_id, inst)),                         \
                .mutex = &(CONN_MGR_CONN_BINDING_GET_MUTEX(dev_id, inst))                       \
        };
 
#define CONN_MGR_BIND_CONN(dev_id, conn_id)             \
        CONN_MGR_BIND_CONN_INST(dev_id, 0, conn_id)
 
int conn_mgr_if_connect(struct net_if *iface);
 
int conn_mgr_if_disconnect(struct net_if *iface);
 
bool conn_mgr_if_is_bound(struct net_if *iface);
 
int conn_mgr_if_set_opt(struct net_if *iface, int optname, const void *optval, size_t optlen);
 
int conn_mgr_if_get_opt(struct net_if *iface, int optname, void *optval, size_t *optlen);
 
bool conn_mgr_if_get_flag(struct net_if *iface, enum conn_mgr_if_flag flag);
 
int conn_mgr_if_set_flag(struct net_if *iface, enum conn_mgr_if_flag flag, bool value);
 
int conn_mgr_if_get_timeout(struct net_if *iface);
 
int conn_mgr_if_set_timeout(struct net_if *iface, int timeout);
 
void conn_mgr_conn_init(void);
 
#ifdef __cplusplus
}
#endif
 
#endif /* ZEPHYR_INCLUDE_CONN_MGR_CONNECTIVITY_H_ */