nrf_modem_dect_phy.h

Go to the documentation of this file.

/*
 * Copyright (c) 2022 Nordic Semiconductor ASA
 *
 * SPDX-License-Identifier: LicenseRef-Nordic-5-Clause
 */
 
#ifndef NRF_MODEM_DECT_PHY_H__
#define NRF_MODEM_DECT_PHY_H__
 
#include <stdint.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define NRF_MODEM_DECT_MODEM_TIME_TICK_RATE_KHZ 69120
#define NRF_MODEM_DECT_SYMBOL_DURATION 2880
 
#define NRF_MODEM_DECT_LBT_PERIOD_MAX (110 * NRF_MODEM_DECT_SYMBOL_DURATION)
#define NRF_MODEM_DECT_LBT_PERIOD_MIN (2 * NRF_MODEM_DECT_SYMBOL_DURATION)
 
#define NRF_MODEM_DECT_PHY_RSSI_NOT_MEASURED 0
#define NRF_MODEM_DECT_PHY_TEMP_NOT_MEASURED 999
#define NRF_MODEM_DECT_PHY_RSSI2_NOT_MEASURED -32768
#define NRF_MODEM_DECT_PHY_SNR_NOT_MEASURED -32768
 
#define NRF_MODEM_DECT_PHY_BS_CQI_NOT_USED 0
 
#define NRF_MODEM_DECT_PHY_LINK_UNSPECIFIED ((struct nrf_modem_dect_phy_link_id){ 0 })
 
enum nrf_modem_dect_phy_err {
        NRF_MODEM_DECT_PHY_SUCCESS = 0,
        NRF_MODEM_DECT_PHY_ERR_LBT_CHANNEL_BUSY = 0x1,
        NRF_MODEM_DECT_PHY_ERR_UNSUPPORTED_OP = 0x2,
        NRF_MODEM_DECT_PHY_ERR_NO_ONGOING_OP = 0x3,
        NRF_MODEM_DECT_PHY_ERR_NO_MEMORY = 0x4,
        NRF_MODEM_DECT_PHY_ERR_NOT_ALLOWED = 0x5,
        NRF_MODEM_DECT_PHY_OK_WITH_HARQ_RESET = 0x6,
        NRF_MODEM_DECT_PHY_ERR_OP_START_TIME_LATE = 0x1000,
        NRF_MODEM_DECT_PHY_ERR_LBT_START_TIME_LATE = 0x1001,
        NRF_MODEM_DECT_PHY_ERR_RF_START_TIME_LATE = 0x1002,
        NRF_MODEM_DECT_PHY_ERR_INVALID_START_TIME = 0x1003,
        NRF_MODEM_DECT_PHY_ERR_OP_SCHEDULING_CONFLICT = 0x1004,
        NRF_MODEM_DECT_PHY_ERR_OP_TIMEOUT = 0x1005,
        NRF_MODEM_DECT_PHY_ERR_NO_ONGOING_HARQ_RX = 0x1006,
        NRF_MODEM_DECT_PHY_ERR_PARAMETER_UNAVAILABLE = 0x1007,
        NRF_MODEM_DECT_PHY_ERR_PAYLOAD_UNAVAILABLE = 0x1008,
        NRF_MODEM_DECT_PHY_ERR_OP_CANCELED = 0x1009,
        NRF_MODEM_DECT_PHY_ERR_COMBINED_OP_FAILED = 0x100A,
        NRF_MODEM_DECT_PHY_ERR_UNSUPPORTED_CARRIER = 0x6000,
        NRF_MODEM_DECT_PHY_ERR_UNSUPPORTED_DATA_SIZE = 0x6001,
        NRF_MODEM_DECT_PHY_ERR_INVALID_NETWORK_ID = 0x6002,
        NRF_MODEM_DECT_PHY_ERR_INVALID_PHY_HEADER = 0x6003,
        NRF_MODEM_DECT_PHY_ERR_INVALID_DURATION = 0x6004,
        NRF_MODEM_DECT_PHY_ERR_INVALID_PARAMETER = 0x6005,
        NRF_MODEM_DECT_PHY_ERR_MODEM_ERROR = 0x7000,
        NRF_MODEM_DECT_PHY_ERR_MODEM_ERROR_RF_STATE = 0x7001,
        NRF_MODEM_DECT_PHY_ERR_TEMP_HIGH = 0x7002,
        NRF_MODEM_DECT_PHY_ERR_PROD_LOCK = 0x7003,
};
 
struct nrf_modem_dect_phy_modem_cfg {
        int16_t temperature_limit;
        struct {
                uint32_t idle_to_rssi;
                uint32_t rssi_to_idle;
                uint32_t idle_to_rx;
                uint32_t rx_to_idle;
                uint32_t rx_rssi_to_idle;
                uint32_t rx_stop_to_rf_off;
                uint32_t rx_rssi_stop_to_rf_off;
                uint32_t idle_to_tx;
                uint32_t idle_to_tx_with_lbt;
                uint32_t tx_to_idle;
                uint32_t idle_to_txrx_with_lbt;
                uint32_t txrx_tx_to_rx;
        } latency;
};
 
struct nrf_modem_dect_phy_capability {
        uint8_t dect_version;
        uint8_t variant_count;
        struct {
                uint8_t power_class;
                uint8_t rx_spatial_streams;
                uint8_t rx_tx_diversity;
                int8_t rx_gain;
                uint8_t mcs_max;
                uint32_t harq_soft_buf_size;
                uint8_t harq_process_count_max;
                uint8_t harq_feedback_delay;
                uint8_t mu;
                uint8_t beta;
        } variant[];
};
 
enum nrf_modem_dect_phy_rx_mode {
        NRF_MODEM_DECT_PHY_RX_MODE_CONTINUOUS,
        NRF_MODEM_DECT_PHY_RX_MODE_SEMICONTINUOUS,
        NRF_MODEM_DECT_PHY_RX_MODE_SINGLE_SHOT,
};
 
enum nrf_modem_dect_phy_rssi_interval {
        NRF_MODEM_DECT_PHY_RSSI_INTERVAL_OFF = 0,
        NRF_MODEM_DECT_PHY_RSSI_INTERVAL_12_SLOTS = 12,
        NRF_MODEM_DECT_PHY_RSSI_INTERVAL_24_SLOTS = 24,
};
 
union nrf_modem_dect_phy_hdr {
        uint8_t type_1[5];
        uint8_t type_2[10];
};
 
enum nrf_modem_dect_phy_hdr_status {
        NRF_MODEM_DECT_PHY_HDR_STATUS_VALID = 0,
        NRF_MODEM_DECT_PHY_HDR_STATUS_INVALID = 1,
        NRF_MODEM_DECT_PHY_HDR_STATUS_VALID_RX_END = 2,
};
 
struct nrf_modem_dect_phy_link_id {
        uint8_t short_network_id;
        uint16_t short_rd_id;
};
 
struct nrf_modem_dect_phy_rx_filter {
        uint8_t short_network_id;
        uint8_t is_short_network_id_used;
        uint16_t receiver_identity;
};
 
struct nrf_modem_dect_phy_rx_pcc_status {
        uint64_t stf_start_time;
        uint8_t phy_type;
        enum nrf_modem_dect_phy_hdr_status header_status;
        int16_t rssi_2;
        int16_t snr;
};
 
struct nrf_modem_dect_phy_rx_pdc_status {
        int16_t rssi_2;
        int16_t snr;
};
 
struct nrf_modem_dect_phy_rx_pcc_crc_failure {
        uint64_t stf_start_time;
        int16_t rssi_2;
        int16_t snr;
};
 
struct nrf_modem_dect_phy_rx_pdc_crc_failure {
        int16_t rssi_2;
        int16_t snr;
};
 
struct nrf_modem_dect_phy_rssi_meas {
        uint64_t meas_start_time;
        uint32_t handle;
        uint16_t carrier;
        uint16_t meas_len;
        int8_t *meas;
};
 
struct nrf_modem_dect_phy_rx_params {
        uint64_t start_time;
        uint32_t handle;
        uint32_t network_id;
        enum nrf_modem_dect_phy_rx_mode mode;
        enum nrf_modem_dect_phy_rssi_interval rssi_interval;
        struct nrf_modem_dect_phy_link_id link_id;
        int8_t rssi_level;
        uint16_t carrier;
        uint32_t duration;
        struct nrf_modem_dect_phy_rx_filter filter;
};
 
struct nrf_modem_dect_phy_tx_params {
        uint64_t start_time;
        uint32_t handle;
        uint32_t network_id;
        uint8_t phy_type;
        int8_t lbt_rssi_threshold_max;
        uint16_t carrier;
        uint32_t lbt_period;
        union nrf_modem_dect_phy_hdr *phy_header;
        uint8_t bs_cqi;
        uint8_t *data;
        uint32_t data_size;
};
 
struct nrf_modem_dect_phy_tx_rx_params {
        struct nrf_modem_dect_phy_tx_params tx;
        struct nrf_modem_dect_phy_rx_params rx;
};
 
struct nrf_modem_dect_phy_rssi_params {
        uint64_t start_time;
        uint32_t handle;
        uint16_t carrier;
        uint32_t duration;
        enum nrf_modem_dect_phy_rssi_interval reporting_interval;
};
 
struct nrf_modem_dect_phy_link_config_params {
        struct nrf_modem_dect_phy_link_id primary_link_id;
        uint8_t secondary_link_count;
        struct nrf_modem_dect_phy_link_id secondary_link_ids[];
};
 
struct nrf_modem_dect_phy_callbacks {
        void (*init)(const uint64_t *time, int16_t temp, enum nrf_modem_dect_phy_err err,
                     const struct nrf_modem_dect_phy_modem_cfg *cfg);
 
        void (*op_complete)(const uint64_t *time, int16_t temperature,
                            enum nrf_modem_dect_phy_err err, uint32_t handle);
 
        void (*rssi)(const uint64_t *time, const struct nrf_modem_dect_phy_rssi_meas *meas);
 
        void (*rx_stop)(const uint64_t *time, enum nrf_modem_dect_phy_err err, uint32_t handle);
 
        void (*pcc)(const uint64_t *time, const struct nrf_modem_dect_phy_rx_pcc_status *status,
                    const union nrf_modem_dect_phy_hdr *hdr);
 
        void (*pcc_crc_err)(const uint64_t *time,
                            const struct nrf_modem_dect_phy_rx_pcc_crc_failure *crc_failure);
 
        void (*pdc)(const uint64_t *time, const struct nrf_modem_dect_phy_rx_pdc_status *status,
                    const void *data, uint32_t len);
 
        void (*pdc_crc_err)(const uint64_t *time,
                            const struct nrf_modem_dect_phy_rx_pdc_crc_failure *crc_failure);
 
        void (*link_config)(const uint64_t *time, enum nrf_modem_dect_phy_err err);
 
        void (*time_get)(const uint64_t *time, enum nrf_modem_dect_phy_err err);
 
        void (*capability_get)(const uint64_t *time, enum nrf_modem_dect_phy_err err,
                               const struct nrf_modem_dect_phy_capability *capability);
 
        void (*deinit)(const uint64_t *time, enum nrf_modem_dect_phy_err err);
};
 
struct nrf_modem_dect_phy_init_params {
        uint32_t harq_rx_expiry_time_us;
        uint8_t harq_rx_process_count;
};
 
int nrf_modem_dect_phy_callback_set(const struct nrf_modem_dect_phy_callbacks *cb);
 
int nrf_modem_dect_phy_capability_get(void);
 
int nrf_modem_dect_phy_init(const struct nrf_modem_dect_phy_init_params *params);
 
int nrf_modem_dect_phy_deinit(void);
 
int nrf_modem_dect_phy_rx(const struct nrf_modem_dect_phy_rx_params *params);
 
int nrf_modem_dect_phy_tx(const struct nrf_modem_dect_phy_tx_params *params);
 
int nrf_modem_dect_phy_tx_harq(const struct nrf_modem_dect_phy_tx_params *params);
 
int nrf_modem_dect_phy_tx_rx(const struct nrf_modem_dect_phy_tx_rx_params *params);
 
int nrf_modem_dect_phy_rssi(const struct nrf_modem_dect_phy_rssi_params *params);
 
int nrf_modem_dect_phy_rx_stop(uint32_t handle);
 
int nrf_modem_dect_phy_link_config(const struct nrf_modem_dect_phy_link_config_params *params);
 
int nrf_modem_dect_phy_time_get(void);
 
#ifdef __cplusplus
}
#endif
 
#endif /* NRF_MODEM_DECT_PHY_H__ */