ieee802154_radio.h

Go to the documentation of this file.

/*
 * Copyright (c) 2016 Intel Corporation.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_INCLUDE_NET_IEEE802154_RADIO_H_
#define ZEPHYR_INCLUDE_NET_IEEE802154_RADIO_H_
 
#include <zephyr/device.h>
#include <zephyr/net/net_if.h>
#include <zephyr/net/net_pkt.h>
#include <zephyr/net/ieee802154.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
enum ieee802154_channel {
        IEEE802154_SUB_GHZ_CHANNEL_MIN = 0,
        IEEE802154_SUB_GHZ_CHANNEL_MAX = 10,
        IEEE802154_2_4_GHZ_CHANNEL_MIN = 11,
        IEEE802154_2_4_GHZ_CHANNEL_MAX = 26,
};
 
enum ieee802154_hw_caps {
        IEEE802154_HW_FCS         = BIT(0), /* Frame Check-Sum supported */
        IEEE802154_HW_PROMISC     = BIT(1), /* Promiscuous mode supported */
        IEEE802154_HW_FILTER      = BIT(2), /* Filter PAN ID, long/short addr */
        IEEE802154_HW_CSMA        = BIT(3), /* CSMA-CA supported */
        IEEE802154_HW_2_4_GHZ     = BIT(4), /* 2.4Ghz radio supported */
        IEEE802154_HW_TX_RX_ACK   = BIT(5), /* Handles ACK request on TX */
        IEEE802154_HW_SUB_GHZ     = BIT(6), /* Sub-GHz radio supported */
        IEEE802154_HW_ENERGY_SCAN = BIT(7), /* Energy scan supported */
        IEEE802154_HW_TXTIME      = BIT(8), /* TX at specified time supported */
        IEEE802154_HW_SLEEP_TO_TX = BIT(9), /* TX directly from sleep supported */
        IEEE802154_HW_TX_SEC      = BIT(10), /* TX security handling supported */
        IEEE802154_HW_RXTIME      = BIT(11), /* RX at specified time supported */
};
 
enum ieee802154_filter_type {
        IEEE802154_FILTER_TYPE_IEEE_ADDR,
        IEEE802154_FILTER_TYPE_SHORT_ADDR,
        IEEE802154_FILTER_TYPE_PAN_ID,
        IEEE802154_FILTER_TYPE_SRC_IEEE_ADDR,
        IEEE802154_FILTER_TYPE_SRC_SHORT_ADDR,
};
 
enum ieee802154_event {
        IEEE802154_EVENT_TX_STARTED, /* Data transmission started */
        IEEE802154_EVENT_RX_FAILED, /* Data reception failed */
        IEEE802154_EVENT_SLEEP, /* Sleep pending */
};
 
enum ieee802154_rx_fail_reason {
        IEEE802154_RX_FAIL_NOT_RECEIVED,  /* Nothing received */
        IEEE802154_RX_FAIL_INVALID_FCS,   /* Frame had invalid checksum */
        IEEE802154_RX_FAIL_ADDR_FILTERED, /* Address did not match */
        IEEE802154_RX_FAIL_OTHER          /* General reason */
};
 
typedef void (*energy_scan_done_cb_t)(const struct device *dev,
                                      int16_t max_ed);
 
typedef void (*ieee802154_event_cb_t)(const struct device *dev,
                                      enum ieee802154_event evt,
                                      void *event_params);
 
struct ieee802154_filter {
        union {
                uint8_t *ieee_addr; /* in little endian */
                uint16_t short_addr; /* in CPU byte order */
                uint16_t pan_id; /* in CPU byte order */
        };
/* @endcond */
};
 
struct ieee802154_key {
        uint8_t *key_value;
        uint32_t key_frame_counter;
        bool frame_counter_per_key;
        uint8_t key_id_mode;
        uint8_t key_index;
};
 
enum ieee802154_tx_mode {
        IEEE802154_TX_MODE_DIRECT,
 
        IEEE802154_TX_MODE_CCA,
 
        IEEE802154_TX_MODE_CSMA_CA,
 
        IEEE802154_TX_MODE_TXTIME,
 
        IEEE802154_TX_MODE_TXTIME_CCA,
};
 
enum ieee802154_fpb_mode {
        IEEE802154_FPB_ADDR_MATCH_THREAD,
 
        IEEE802154_FPB_ADDR_MATCH_ZIGBEE,
};
 
enum ieee802154_config_type {
        IEEE802154_CONFIG_AUTO_ACK_FPB,
 
        IEEE802154_CONFIG_ACK_FPB,
 
        IEEE802154_CONFIG_PAN_COORDINATOR,
 
        IEEE802154_CONFIG_PROMISCUOUS,
 
        IEEE802154_CONFIG_EVENT_HANDLER,
 
        IEEE802154_CONFIG_MAC_KEYS,
 
        IEEE802154_CONFIG_FRAME_COUNTER,
 
        IEEE802154_CONFIG_RX_SLOT,
 
        IEEE802154_CONFIG_CSL_PERIOD,
 
        IEEE802154_CONFIG_CSL_RX_TIME,
 
        IEEE802154_CONFIG_ENH_ACK_HEADER_IE,
};
 
struct ieee802154_config {
        union {
                struct {
                        bool enabled;
                        enum ieee802154_fpb_mode mode;
                } auto_ack_fpb;
 
                struct {
                        uint8_t *addr; /* in little endian for both, short and extended address */
                        bool extended;
                        bool enabled;
                } ack_fpb;
 
                bool pan_coordinator;
 
                bool promiscuous;
 
                ieee802154_event_cb_t event_handler;
 
                struct ieee802154_key *mac_keys;
 
                uint32_t frame_counter;
 
                struct {
                        uint8_t channel;
                        uint32_t start;
                        uint32_t duration;
                } rx_slot;
 
                uint32_t csl_period; /* in CPU byte order */
 
                uint32_t csl_rx_time; /* in microseconds,
                                       * based on ieee802154_radio_api.get_time()
                                       */
 
                struct {
                        const uint8_t *data; /* header IEs to be added to the Enh-Ack frame in
                                              * little endian byte order
                                              */
                        uint16_t data_len;
                        uint16_t short_addr; /* in CPU byte order */
                        const uint8_t *ext_addr; /* in big endian */
                } ack_ie;
        };
};
 
struct ieee802154_radio_api {
        struct net_if_api iface_api;
 
        enum ieee802154_hw_caps (*get_capabilities)(const struct device *dev);
 
        int (*cca)(const struct device *dev);
 
        int (*set_channel)(const struct device *dev, uint16_t channel);
 
        int (*filter)(const struct device *dev,
                      bool set,
                      enum ieee802154_filter_type type,
                      const struct ieee802154_filter *filter);
 
        int (*set_txpower)(const struct device *dev, int16_t dbm);
 
        int (*tx)(const struct device *dev, enum ieee802154_tx_mode mode,
                  struct net_pkt *pkt, struct net_buf *frag);
 
        int (*start)(const struct device *dev);
 
        int (*stop)(const struct device *dev);
 
        int (*configure)(const struct device *dev,
                         enum ieee802154_config_type type,
                         const struct ieee802154_config *config);
 
        uint16_t (*get_subg_channel_count)(const struct device *dev);
 
        int (*ed_scan)(const struct device *dev,
                       uint16_t duration,
                       energy_scan_done_cb_t done_cb);
 
        uint64_t (*get_time)(const struct device *dev);
 
        uint8_t (*get_sch_acc)(const struct device *dev);
};
 
/* Make sure that the network interface API is properly setup inside
 * IEEE 802154 radio API struct (it is the first one).
 */
BUILD_ASSERT(offsetof(struct ieee802154_radio_api, iface_api) == 0);
 
#define IEEE802154_AR_FLAG_SET (0x20)
 
static inline bool ieee802154_is_ar_flag_set(struct net_buf *frag)
{
        return (*frag->data & IEEE802154_AR_FLAG_SET);
}
 
extern enum net_verdict ieee802154_radio_handle_ack(struct net_if *iface,
                                                    struct net_pkt *pkt);
 
#ifndef CONFIG_IEEE802154_RAW_MODE
void ieee802154_init(struct net_if *iface);
#else
#define ieee802154_init(_iface_)
#endif /* CONFIG_IEEE802154_RAW_MODE */
 
#ifdef __cplusplus
}
#endif
 
#endif /* ZEPHYR_INCLUDE_NET_IEEE802154_RADIO_H_ */