radio.h

/*
 * SPDX-FileCopyrightText: 2020 HAW Hamburg
 * SPDX-License-Identifier: LGPL-2.1-only
 */
 
#pragma once

 
#ifdef __cplusplus
extern "C" {
#endif
 
#include <stdbool.h>
#include "iolist.h"
#include "sys/uio.h"
#include "bitarithm.h"
#include "byteorder.h"
#include "net/eui64.h"
#include "net/ieee802154.h"
#include "errno.h"

typedef struct ieee802154_radio_ops ieee802154_radio_ops_t;

struct ieee802154_radio_cipher_ops;

typedef enum {
    IEEE802154_CAP_FRAME_RETRANS        = BIT0,
    IEEE802154_CAP_AUTO_CSMA            = BIT1,
    IEEE802154_CAP_AUTO_ACK             = BIT2,
    IEEE802154_CAP_IRQ_ACK_TIMEOUT      = BIT3,
    IEEE802154_CAP_24_GHZ               = BIT4,
    IEEE802154_CAP_SUB_GHZ              = BIT5,
    IEEE802154_CAP_IRQ_CRC_ERROR        = BIT6,
    IEEE802154_CAP_IRQ_TX_DONE          = BIT7,
    IEEE802154_CAP_IRQ_RX_START         = BIT8,
    IEEE802154_CAP_IRQ_TX_START         = BIT9,
    IEEE802154_CAP_IRQ_CCA_DONE         = BIT10,
    IEEE802154_CAP_FRAME_RETRANS_INFO   = BIT11,
    IEEE802154_CAP_REG_RETENTION        = BIT12,
    IEEE802154_CAP_PHY_BPSK             = BIT13,
    IEEE802154_CAP_PHY_ASK              = BIT14,
    IEEE802154_CAP_PHY_OQPSK            = BIT15,
    IEEE802154_CAP_PHY_MR_OQPSK         = BIT16,
    IEEE802154_CAP_PHY_MR_OFDM          = BIT17,
    IEEE802154_CAP_PHY_MR_FSK           = BIT18,
    IEEE802154_CAP_SRC_ADDR_MATCH       = BIT19,
    IEEE802154_CAP_RX_TIMESTAMP         = BIT20,
    IEEE802154_CAP_FRAME_RETENTION      = BIT21,
} ieee802154_rf_caps_t;

#define IEEE802154_RF_CAPS_PHY_MASK \
    (IEEE802154_CAP_PHY_BPSK        \
    | IEEE802154_CAP_PHY_ASK        \
    | IEEE802154_CAP_PHY_OQPSK      \
    | IEEE802154_CAP_PHY_MR_OQPSK   \
    | IEEE802154_CAP_PHY_MR_OFDM    \
    | IEEE802154_CAP_PHY_MR_FSK)    \


typedef enum {
    TX_STATUS_SUCCESS,
    TX_STATUS_FRAME_PENDING,
    TX_STATUS_NO_ACK,
    TX_STATUS_MEDIUM_BUSY,
} ieee802154_tx_status_t;

typedef enum {
    IEEE802154_RADIO_INDICATION_RX_START,

    IEEE802154_RADIO_INDICATION_CRC_ERROR,

    IEEE802154_RADIO_INDICATION_TX_START,

    IEEE802154_RADIO_INDICATION_RX_DONE,

    IEEE802154_RADIO_CONFIRM_TX_DONE,
    IEEE802154_RADIO_CONFIRM_CCA,
} ieee802154_trx_ev_t;

typedef enum {
    IEEE802154_SRC_MATCH_EN,
    IEEE802154_SRC_MATCH_SHORT_ADD,
    IEEE802154_SRC_MATCH_SHORT_CLEAR,
    IEEE802154_SRC_MATCH_EXT_ADD,
    IEEE802154_SRC_MATCH_EXT_CLEAR,
} ieee802154_src_match_t;

typedef enum {
    IEEE802154_AF_SHORT_ADDR, 
    IEEE802154_AF_EXT_ADDR,   
    IEEE802154_AF_PANID,      
    IEEE802154_AF_PAN_COORD,  
} ieee802154_af_cmd_t;

typedef enum {
    IEEE802154_FILTER_ACCEPT,
    IEEE802154_FILTER_ACK_ONLY,
    IEEE802154_FILTER_PROMISC,
    IEEE802154_FILTER_SNIFFER,
} ieee802154_filter_mode_t;

typedef struct {
    uint8_t min;    
    uint8_t max;    
} ieee802154_csma_be_t;

typedef struct {
    uint8_t rssi;
    uint8_t lqi;            
    uint64_t timestamp;     
} ieee802154_rx_info_t;

typedef struct {
    ieee802154_tx_status_t status;      
    int8_t retrans;                     
} ieee802154_tx_info_t;

typedef struct ieee802154_dev ieee802154_dev_t;

typedef void (*ieee802154_cb_t)(ieee802154_dev_t *dev,
                                ieee802154_trx_ev_t status);

struct ieee802154_dev {
    const ieee802154_radio_ops_t *driver;
    void *priv;
    ieee802154_cb_t cb;
};

typedef enum {
    IEEE802154_CCA_MODE_ED_THRESHOLD,
    IEEE802154_CCA_MODE_CARRIER_SENSING,
    IEEE802154_CCA_MODE_ED_THRESH_AND_CS,
    IEEE802154_CCA_MODE_ED_THRESH_OR_CS,
} ieee802154_cca_mode_t;

typedef struct {
    ieee802154_phy_mode_t phy_mode; 
    uint16_t channel;               
    int8_t pow;                     
} ieee802154_phy_conf_t;

typedef struct {
    ieee802154_phy_conf_t super;        
    ieee802154_mr_oqpsk_chips_t chips;  
    uint8_t rate_mode;                  
} ieee802154_mr_oqpsk_conf_t;

typedef struct {
    ieee802154_phy_conf_t super;        
    uint8_t option;                     
    uint8_t scheme;                     
} ieee802154_mr_ofdm_conf_t;

typedef struct {
    ieee802154_phy_conf_t super;        
    ieee802154_mr_fsk_srate_t srate;    
    uint8_t mod_ord;                    
    uint8_t mod_idx;                    
    ieee802154_mr_fsk_fec_t fec;        
} ieee802154_mr_fsk_conf_t;

typedef enum {
    IEEE802154_HAL_OP_TRANSMIT,
    IEEE802154_HAL_OP_SET_RX,
    IEEE802154_HAL_OP_SET_IDLE,
    IEEE802154_HAL_OP_CCA,
 
    /* add more as needed (e.g Energy Scanning, transmit slotted ACK) */
} ieee802154_hal_op_t;

struct ieee802154_radio_ops {
    const uint32_t caps;

    int (*write)(ieee802154_dev_t *dev, const iolist_t *psdu);

    int (*len)(ieee802154_dev_t *dev);

    int (*read)(ieee802154_dev_t *dev, void *buf, size_t size, ieee802154_rx_info_t *info);

    int (*peek)(ieee802154_dev_t *dev, void *buf, size_t offset, size_t size);

    int (*off)(ieee802154_dev_t *dev);

    int (*request_on)(ieee802154_dev_t *dev);

    int (*confirm_on)(ieee802154_dev_t *dev);

    int (*request_op)(ieee802154_dev_t *dev, ieee802154_hal_op_t op, void *ctx);

    int (*confirm_op)(ieee802154_dev_t *dev, ieee802154_hal_op_t op, void *ctx);

    int (*set_cca_threshold)(ieee802154_dev_t *dev, int8_t threshold);

    int (*set_cca_mode)(ieee802154_dev_t *dev, ieee802154_cca_mode_t mode);

    int (*config_phy)(ieee802154_dev_t *dev, const ieee802154_phy_conf_t *conf);

    int (*set_frame_retrans)(ieee802154_dev_t *dev, uint8_t retrans);

    int (*set_csma_params)(ieee802154_dev_t *dev, const ieee802154_csma_be_t *bd,
                           int8_t retries);

    int (*set_frame_filter_mode)(ieee802154_dev_t *dev, ieee802154_filter_mode_t mode);

    int (*get_frame_filter_mode)(ieee802154_dev_t *dev, ieee802154_filter_mode_t *mode);

    int (*config_addr_filter)(ieee802154_dev_t *dev, ieee802154_af_cmd_t cmd, const void *value);

    int (*config_src_addr_match)(ieee802154_dev_t *dev, ieee802154_src_match_t cmd,
                                 const void *value);

    const struct ieee802154_radio_cipher_ops *cipher_ops;
};

static inline bool ieee802154_radio_has_capability(ieee802154_dev_t *dev, uint32_t cap)
{
    return (dev->driver->caps & cap) == cap;
}

static inline bool ieee802154_radio_has_peek(ieee802154_dev_t *dev)
{
    return dev->driver->peek != NULL;
}

static inline int ieee802154_radio_write(ieee802154_dev_t *dev, const iolist_t *psdu)
{
    return dev->driver->write(dev, psdu);
}

static inline int ieee802154_radio_request_transmit(ieee802154_dev_t *dev)
{
    return dev->driver->request_op(dev, IEEE802154_HAL_OP_TRANSMIT, NULL);
}

static inline int ieee802154_radio_confirm_transmit(ieee802154_dev_t *dev,
                                                    ieee802154_tx_info_t *info)
{
    return dev->driver->confirm_op(dev, IEEE802154_HAL_OP_TRANSMIT, info);
}

static inline int ieee802154_radio_len(ieee802154_dev_t *dev)
{
    return dev->driver->len(dev);
}

static inline int ieee802154_radio_read(ieee802154_dev_t *dev,
                                                 void *buf,
                                                 size_t size,
                                                 ieee802154_rx_info_t *info)
{
    return dev->driver->read(dev, buf, size, info);
}

static inline int ieee802154_radio_peek(ieee802154_dev_t *dev,
                                        void *buf, size_t offset, size_t size)
{
    return dev->driver->peek(dev, buf, offset, size);
}

static inline int ieee802154_radio_set_cca_threshold(ieee802154_dev_t *dev,
                                                     int8_t threshold)
{
    return dev->driver->set_cca_threshold(dev, threshold);
}

static inline int ieee802154_radio_set_cca_mode(ieee802154_dev_t *dev,
                                                ieee802154_cca_mode_t mode)
{
    return dev->driver->set_cca_mode(dev, mode);
}

static inline int ieee802154_radio_config_phy(ieee802154_dev_t *dev,
                                              const ieee802154_phy_conf_t *conf)
{
    return dev->driver->config_phy(dev, conf);
}

static inline int ieee802154_radio_config_src_address_match(ieee802154_dev_t *dev,
                                                            ieee802154_src_match_t cmd,
                                                            const void *value)
{
    return dev->driver->config_src_addr_match(dev, cmd, value);
}

static inline int ieee802154_radio_off(ieee802154_dev_t *dev)
{
    return dev->driver->off(dev);
}

static inline int ieee802154_radio_config_addr_filter(ieee802154_dev_t *dev,
                                                  ieee802154_af_cmd_t cmd,
                                                  const void* value)
{
    return dev->driver->config_addr_filter(dev, cmd, value);
}

static inline int ieee802154_radio_set_frame_filter_mode(ieee802154_dev_t *dev,
                                                    ieee802154_filter_mode_t mode)
{
    return dev->driver->set_frame_filter_mode(dev, mode);
}

static inline int ieee802154_radio_get_frame_filter_mode(ieee802154_dev_t *dev,
                                                         ieee802154_filter_mode_t *mode)
{
    if (dev->driver->get_frame_filter_mode) {
        return dev->driver->get_frame_filter_mode(dev, mode);
    }
    return -ENOTSUP;
}

static inline int ieee802154_radio_set_frame_retrans(ieee802154_dev_t *dev,
                                                     uint8_t retrans)
{
    return dev->driver->set_frame_retrans(dev, retrans);
}

static inline int ieee802154_radio_set_csma_params(ieee802154_dev_t *dev,
                                                   const ieee802154_csma_be_t *bd,
                                                   int8_t retries)
{
    return dev->driver->set_csma_params(dev, bd, retries);
}

static inline int ieee802154_radio_request_on(ieee802154_dev_t *dev)
{
    return dev->driver->request_on(dev);
}

static inline int ieee802154_radio_confirm_on(ieee802154_dev_t *dev)
{
    return dev->driver->confirm_on(dev);
}

static inline int ieee802154_radio_request_set_idle(ieee802154_dev_t *dev, bool force)
{
    return dev->driver->request_op(dev, IEEE802154_HAL_OP_SET_IDLE, &force);
}

static inline int ieee802154_radio_confirm_set_idle(ieee802154_dev_t *dev)
{
    return dev->driver->confirm_op(dev, IEEE802154_HAL_OP_SET_IDLE, NULL);
}

static inline int ieee802154_radio_request_set_rx(ieee802154_dev_t *dev)
{
    return dev->driver->request_op(dev, IEEE802154_HAL_OP_SET_RX, NULL);
}

static inline int ieee802154_radio_confirm_set_rx(ieee802154_dev_t *dev)
{
    return dev->driver->confirm_op(dev, IEEE802154_HAL_OP_SET_RX, NULL);
}

static inline int ieee802154_radio_set_idle(ieee802154_dev_t *dev, bool force)
{
    int res = ieee802154_radio_request_set_idle(dev, force);
    if (res < 0) {
        return res;
    }
    while (ieee802154_radio_confirm_set_idle(dev) == -EAGAIN) {}
 
    return 0;
}

static inline int ieee802154_radio_set_rx(ieee802154_dev_t *dev)
{
    int res = ieee802154_radio_request_set_rx(dev);
    if (res < 0) {
        return res;
    }
    while (ieee802154_radio_confirm_set_rx(dev) == -EAGAIN) {}
 
    return 0;
}

static inline int ieee802154_radio_request_cca(ieee802154_dev_t *dev)
{
    return dev->driver->request_op(dev, IEEE802154_HAL_OP_CCA, NULL);
}

static inline int ieee802154_radio_confirm_cca(ieee802154_dev_t *dev)
{
    bool clear;
    int res = dev->driver->confirm_op(dev, IEEE802154_HAL_OP_CCA, &clear);
    if (res < 0) {
        return res;
    }
    return clear;
}

static inline int ieee802154_radio_cca(ieee802154_dev_t *dev)
{
    int res = ieee802154_radio_request_cca(dev);
    if (res < 0) {
        return res;
    }
    while ((res = ieee802154_radio_confirm_cca(dev)) == -EAGAIN) {}
 
    return res;
}

static inline const struct ieee802154_radio_cipher_ops *ieee802154_radio_get_cipher_ops(const ieee802154_dev_t *dev)
{
    return dev->driver->cipher_ops;
}

static inline bool ieee802154_radio_has_irq_ack_timeout(ieee802154_dev_t *dev)
{
    return (dev->driver->caps & IEEE802154_CAP_IRQ_ACK_TIMEOUT);
}

static inline bool ieee802154_radio_has_frame_retrans(ieee802154_dev_t *dev)
{
    return (dev->driver->caps & IEEE802154_CAP_FRAME_RETRANS);
}

static inline bool ieee802154_radio_has_auto_csma(ieee802154_dev_t *dev)
{
    return (dev->driver->caps & IEEE802154_CAP_AUTO_CSMA);
}

static inline bool ieee802154_radio_has_sub_ghz(ieee802154_dev_t *dev)
{
    return (dev->driver->caps & IEEE802154_CAP_SUB_GHZ);
}

static inline bool ieee802154_radio_has_24_ghz(ieee802154_dev_t *dev)
{
    return (dev->driver->caps & IEEE802154_CAP_24_GHZ);
}

static inline bool ieee802154_radio_has_irq_tx_done(ieee802154_dev_t *dev)
{
    return (dev->driver->caps & IEEE802154_CAP_IRQ_TX_DONE);
}

static inline bool ieee802154_radio_has_irq_rx_start(ieee802154_dev_t *dev)
{
    return (dev->driver->caps & IEEE802154_CAP_IRQ_RX_START);
}

static inline bool ieee802154_radio_has_irq_tx_start(ieee802154_dev_t *dev)
{
    return (dev->driver->caps & IEEE802154_CAP_IRQ_TX_START);
}

static inline bool ieee802154_radio_has_irq_cca_done(ieee802154_dev_t *dev)
{
    return (dev->driver->caps & IEEE802154_CAP_IRQ_CCA_DONE);
}

static inline bool ieee802154_radio_has_frame_retrans_info(
    ieee802154_dev_t *dev)
{
    return (dev->driver->caps & IEEE802154_CAP_FRAME_RETRANS_INFO);
}

static inline bool ieee802154_radio_has_phy_bpsk(ieee802154_dev_t *dev)
{
    return (dev->driver->caps & IEEE802154_CAP_PHY_BPSK);
}

static inline bool ieee802154_radio_has_phy_ask(ieee802154_dev_t *dev)
{
    return (dev->driver->caps & IEEE802154_CAP_PHY_ASK);
}

static inline bool ieee802154_radio_has_phy_oqpsk(ieee802154_dev_t *dev)
{
    return (dev->driver->caps & IEEE802154_CAP_PHY_OQPSK);
}

static inline bool ieee802154_radio_has_phy_mr_oqpsk(ieee802154_dev_t *dev)
{
    return (dev->driver->caps & IEEE802154_CAP_PHY_MR_OQPSK);
}

static inline bool ieee802154_radio_has_phy_mr_ofdm(ieee802154_dev_t *dev)
{
    return (dev->driver->caps & IEEE802154_CAP_PHY_MR_OFDM);
}

static inline bool ieee802154_radio_has_phy_mr_fsk(ieee802154_dev_t *dev)
{
    return (dev->driver->caps & IEEE802154_CAP_PHY_MR_FSK);
}

static inline uint32_t ieee802154_radio_get_phy_modes(ieee802154_dev_t *dev)
{
    return (dev->driver->caps & IEEE802154_RF_CAPS_PHY_MASK);
}

static inline uint32_t ieee802154_phy_mode_to_cap(
    ieee802154_phy_mode_t phy_mode)
{
    switch (phy_mode) {
        case IEEE802154_PHY_BPSK:
            return IEEE802154_CAP_PHY_BPSK;
        case IEEE802154_PHY_ASK:
            return IEEE802154_CAP_PHY_ASK;
        case IEEE802154_PHY_OQPSK:
            return IEEE802154_CAP_PHY_OQPSK;
        case IEEE802154_PHY_MR_OQPSK:
            return IEEE802154_CAP_PHY_MR_OQPSK;
        case IEEE802154_PHY_MR_OFDM:
            return IEEE802154_CAP_PHY_MR_OFDM;
        case IEEE802154_PHY_MR_FSK:
            return IEEE802154_CAP_PHY_MR_FSK;
 
        case IEEE802154_PHY_DISABLED:
        default:
            break;
    }
 
    return 0;
}

static inline ieee802154_phy_mode_t ieee802154_cap_to_phy_mode(uint32_t cap)
{
    switch (cap) {
        case IEEE802154_CAP_PHY_BPSK:
            return IEEE802154_PHY_BPSK;
        case IEEE802154_CAP_PHY_ASK:
            return IEEE802154_PHY_ASK;
        case IEEE802154_CAP_PHY_OQPSK:
            return IEEE802154_PHY_OQPSK;
        case IEEE802154_CAP_PHY_MR_OQPSK:
            return IEEE802154_PHY_MR_OQPSK;
        case IEEE802154_PHY_MR_OFDM:
            return IEEE802154_PHY_MR_OFDM;
        case IEEE802154_CAP_PHY_MR_FSK:
            return IEEE802154_PHY_MR_FSK;
 
        default:
            break;
    }
 
    return IEEE802154_PHY_DISABLED;
}
 
#ifdef __cplusplus
}
#endif