conn_mgr_connectivity_impl.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_IMPL_H_
#define ZEPHYR_INCLUDE_CONN_MGR_CONNECTIVITY_IMPL_H_
 
#include <zephyr/device.h>
#include <zephyr/net/net_if.h>
#include <zephyr/sys/iterable_sections.h>
#include <zephyr/net/net_mgmt.h>
#include <zephyr/net/conn_mgr_connectivity.h>
 
#ifdef __cplusplus
extern "C" {
#endif

 
/* Forward declaration */
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 {
        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

struct conn_mgr_conn_binding {
        struct net_if *iface;

        const struct conn_mgr_conn_impl *impl;

        void *ctx;


        uint32_t flags;

        int timeout;

        int idle_timeout;


        /* Internal-use work item for tracking interface idle timeouts */
        struct k_work_delayable idle_worker;
 
        /* 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)

static inline struct conn_mgr_conn_binding *conn_mgr_if_get_binding(struct net_if *iface)
{
        STRUCT_SECTION_FOREACH(conn_mgr_conn_binding, binding) {
                if (iface == binding->iface) {
                        if (binding->impl->api) {
                                return binding;
                        }
                        return NULL;
                }
        }
        return NULL;
}

static inline void conn_mgr_binding_lock(struct conn_mgr_conn_binding *binding)
{
        (void)k_mutex_lock(binding->mutex, K_FOREVER);
}

static inline void conn_mgr_binding_unlock(struct conn_mgr_conn_binding *binding)
{
        (void)k_mutex_unlock(binding->mutex);
}

static inline void conn_mgr_binding_set_flag(struct conn_mgr_conn_binding *binding,
                                             enum conn_mgr_if_flag flag, bool value)
{
        conn_mgr_binding_lock(binding);
 
        binding->flags &= ~BIT(flag);
        if (value) {
                binding->flags |= BIT(flag);
        }
 
        conn_mgr_binding_unlock(binding);
}

static inline bool conn_mgr_binding_get_flag(struct conn_mgr_conn_binding *binding,
                                             enum conn_mgr_if_flag flag)
{
        bool value = false;
 
        conn_mgr_binding_lock(binding);
 
        value = !!(binding->flags & BIT(flag));
 
        conn_mgr_binding_unlock(binding);
 
        return value;
}

 
#ifdef __cplusplus
}
#endif
 
#endif /* ZEPHYR_INCLUDE_CONN_MGR_CONNECTIVITY_IMPL_H_ */