interface.h

Go to the documentation of this file.

 
#ifndef INFUSE_SDK_INCLUDE_INFUSE_EPACKET_INTERFACE_H_
#define INFUSE_SDK_INCLUDE_INFUSE_EPACKET_INTERFACE_H_
 
#include <zephyr/device.h>
#include <zephyr/net_buf.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* Maximum packet size on an interface, limited by CONFIG_EPACKET_PACKET_SIZE_MAX */
#define EPACKET_INTERFACE_MAX_PACKET(node_id)                                                      \
        (MIN(CONFIG_EPACKET_PACKET_SIZE_MAX,                                                       \
             DT_PROP_OR(node_id, max_packet_size, CONFIG_EPACKET_PACKET_SIZE_MAX)))
/* Overhead of the interface on packet size */
#define EPACKET_INTERFACE_PACKET_OVERHEAD(node_id)                                                 \
        (DT_PROP(node_id, header_size) + DT_PROP(node_id, footer_size))
/* Get the maximum payload size for a given packet size */
#define EPACKET_INTERFACE_PAYLOAD_FROM_PACKET(node_id, packet_size)                                \
        (MIN(packet_size, CONFIG_EPACKET_PACKET_SIZE_MAX) -                                        \
         EPACKET_INTERFACE_PACKET_OVERHEAD(node_id))
/* Maximum payload size on an interface */
#define EPACKET_INTERFACE_MAX_PAYLOAD(node_id)                                                     \
        (EPACKET_INTERFACE_PAYLOAD_FROM_PACKET(node_id, EPACKET_INTERFACE_MAX_PACKET(node_id)))
 
#define EPACKET_INTERFACE_IS_COMPILED_IN(node_id) IS_ENABLED(DT_STRING_TOKEN(node_id, depends_on))
 
/* Identifier for ePacket interface */
enum epacket_interface_id {
        EPACKET_INTERFACE_SERIAL = 0,
        EPACKET_INTERFACE_UDP = 1,
        EPACKET_INTERFACE_BT_ADV = 2,
        EPACKET_INTERFACE_BT_PERIPHERAL = 3,
        EPACKET_INTERFACE_BT_CENTRAL = 4,
        EPACKET_INTERFACE_HCI = 10,
        EPACKET_INTERFACE_DUMMY = 255,
};
 
struct epacket_interface_cb {
        void (*interface_state)(uint16_t current_max_payload, void *user_ctx);
 
        void (*tx_failure)(const struct net_buf *buf, int reason, void *user_ctx);
 
        bool (*packet_received)(struct net_buf *buf, bool decrypted, void *user_ctx);
 
        /* User provided context pointer */
        void *user_ctx;
 
        sys_snode_t node;
};
 
struct epacket_interface_api {
        void (*send)(const struct device *dev, struct net_buf *buf);
        void (*decrypt_result)(const struct device *dev, struct net_buf *buf, int decrypt_result);
        int (*receive_ctrl)(const struct device *dev, bool enable);
        uint16_t (*max_packet_size)(const struct device *dev);
};
 
typedef void (*epacket_receive_handler)(struct net_buf *packet);
 
struct epacket_interface_common_data {
        epacket_receive_handler receive_handler;
        struct k_work_delayable receive_timeout;
        struct k_spinlock callback_lock;
        sys_slist_t callback_list;
        const struct device *dev;
};
 
struct epacket_interface_common_config {
        uint16_t max_packet_size;
        uint8_t header_size;
        uint8_t footer_size;
};
 
void epacket_queue(const struct device *dev, struct net_buf *buf);
 
int epacket_receive(const struct device *dev, k_timeout_t timeout);
 
int epacket_send_key_ids(const struct device *dev, k_timeout_t timeout);
 
static inline uint16_t epacket_interface_max_packet_size(const struct device *dev)
{
        const struct epacket_interface_common_config *cfg = dev->config;
        const struct epacket_interface_api *api = dev->api;
 
        if (api->max_packet_size) {
                return api->max_packet_size(dev);
        } else {
                return cfg->max_packet_size;
        }
}
 
static inline void epacket_set_receive_handler(const struct device *dev,
                                               epacket_receive_handler handler)
{
        struct epacket_interface_common_data *data = dev->data;
 
        data->receive_handler = handler;
}
 
static inline void epacket_register_callback(const struct device *dev,
                                             struct epacket_interface_cb *cb)
{
        struct epacket_interface_common_data *data = dev->data;
 
        K_SPINLOCK(&data->callback_lock) {
                sys_slist_append(&data->callback_list, &cb->node);
        }
}
 
static inline bool epacket_unregister_callback(const struct device *dev,
                                               struct epacket_interface_cb *cb)
{
        struct epacket_interface_common_data *data = dev->data;
        bool ret = 0;
 
        K_SPINLOCK(&data->callback_lock) {
                ret = sys_slist_find_and_remove(&data->callback_list, &cb->node);
        }
 
        return ret;
}
 
void epacket_default_receive_handler(struct net_buf *buf);
 
void epacket_gateway_receive_handler(const struct device *backhaul, struct net_buf *buf);
 
#define GATEWAY_HANDLER_DEFINE(name, backhaul)                                                     \
        static void name(struct net_buf *buf)                                                      \
        {                                                                                          \
                epacket_gateway_receive_handler(backhaul, buf);                                    \
        }
 
#ifdef __cplusplus
}
#endif
 
#endif /* INFUSE_SDK_INCLUDE_INFUSE_EPACKET_INTERFACE_H_ */