mmwlan.h

/*
 * Copyright 2021-2024 Morse Micro
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#pragma once
 
#include <stdarg.h>
#include <stdint.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
 
#include "mmpkt.h"
 
#ifdef __cplusplus
extern "C"
{
#endif
 
enum mmwlan_status
{
    MMWLAN_SUCCESS,
    MMWLAN_ERROR,
    MMWLAN_INVALID_ARGUMENT,
    MMWLAN_UNAVAILABLE,
    MMWLAN_CHANNEL_LIST_NOT_SET,
    MMWLAN_NO_MEM,
    MMWLAN_TIMED_OUT,
    MMWLAN_SHUTDOWN_BLOCKED,
    MMWLAN_CHANNEL_INVALID,
    MMWLAN_NOT_FOUND,
    MMWLAN_NOT_RUNNING,
    MMWLAN_NOT_INITIALIZED,
    MMWLAN_VIF_ERROR,
    MMWLAN_NOT_SUPPORTED,
    MMWLAN_COMMAND_ERROR,
};
 
#define MMWLAN_SSID_MAXLEN (32)
 
#define MMWLAN_PASSPHRASE_MAXLEN (100)
 
#define MMWLAN_MAC_ADDR_LEN (6)
 
#define MMWLAN_MAX_EC_GROUPS (4)
 
#define MMWLAN_OUI_SIZE (3)
 
enum mmwlan_vif
{
    MMWLAN_VIF_UNSPECIFIED = 0,
    MMWLAN_VIF_STA = 1,
    MMWLAN_VIF_AP = 2,
};
 
enum mmwlan_security_type
{
    MMWLAN_OPEN,
    MMWLAN_OWE,
    MMWLAN_SAE,
};
 
enum mmwlan_pmf_mode
{
    MMWLAN_PMF_REQUIRED,
    MMWLAN_PMF_DISABLED
};
 
#define MMWLAN_SKIP_OP_CLASS_CHECK -1
 
struct mmwlan_s1g_channel
{
    uint32_t centre_freq_hz;
    uint16_t duty_cycle_sta;
    bool duty_cycle_omit_ctrl_resp;
    int16_t global_operating_class;
    int16_t s1g_operating_class;
    uint8_t s1g_chan_num;
    uint8_t bw_mhz;
    int8_t max_tx_eirp_dbm;
    uint32_t pkt_spacing_us;
    uint32_t airtime_min_us;
    uint32_t airtime_max_us;
};
 
#define MMWLAN_COUNTRY_CODE_LEN 3
 
struct mmwlan_s1g_channel_list
{
    uint8_t country_code[MMWLAN_COUNTRY_CODE_LEN];
    unsigned num_channels;
    const struct mmwlan_s1g_channel *channels;
};
 
struct mmwlan_regulatory_db
{
    unsigned num_domains;
 
    const struct mmwlan_s1g_channel_list **domains;
};
 
static inline const struct mmwlan_s1g_channel_list *mmwlan_lookup_regulatory_domain(
    const struct mmwlan_regulatory_db *db,
    const char *country_code)
{
    unsigned ii;
 
    if (db == NULL)
    {
        return NULL;
    }
 
    for (ii = 0; ii < db->num_domains; ii++)
    {
        const struct mmwlan_s1g_channel_list *channel_list = db->domains[ii];
        if (channel_list->country_code[0] == country_code[0] &&
            channel_list->country_code[1] == country_code[1])
        {
            return channel_list;
        }
    }
    return NULL;
}
 
enum mmwlan_status mmwlan_set_channel_list(const struct mmwlan_s1g_channel_list *channel_list);
 
enum mmwlan_duty_cycle_mode
{
    MMWLAN_DUTY_CYCLE_MODE_SPREAD = 0,
    MMWLAN_DUTY_CYCLE_MODE_BURST = 1,
};
 
enum mmwlan_status mmwlan_set_duty_cycle_mode(enum mmwlan_duty_cycle_mode duty_cycle_mode);
 
struct mmwlan_duty_cycle_stats
{
    uint32_t duty_cycle;
    enum mmwlan_duty_cycle_mode mode;
    uint32_t burst_airtime_remaining_us;
    uint32_t burst_window_duration_us;
};
 
enum mmwlan_status mmwlan_get_duty_cycle_stats(struct mmwlan_duty_cycle_stats *stats);
 
#define MMWLAN_MORSELIB_VERSION_MAXLEN (32)
#define MMWLAN_FW_VERSION_MAXLEN (32)
#define MMWLAN_CHIP_ID_STRING_MAXLEN (32)
 
struct mmwlan_version
{
    char morselib_version[MMWLAN_MORSELIB_VERSION_MAXLEN];
    char morse_fw_version[MMWLAN_FW_VERSION_MAXLEN];
    uint32_t morse_chip_id;
    char morse_chip_id_string[MMWLAN_CHIP_ID_STRING_MAXLEN];
};
 
enum mmwlan_status mmwlan_get_version(struct mmwlan_version *version);
 
#define MMWLAN_BCF_BOARD_DESC_MAXLEN (31)
#define MMWLAN_BCF_BUILD_VERSION_MAXLEN (31)
 
struct mmwlan_bcf_metadata
{
    struct
    {
        uint16_t major;
        uint8_t minor;
        uint8_t patch;
    } version;
 
    char board_desc[MMWLAN_BCF_BOARD_DESC_MAXLEN + 1];
 
    char build_version[MMWLAN_BCF_BUILD_VERSION_MAXLEN + 1];
};
 
enum mmwlan_status mmwlan_get_bcf_metadata(struct mmwlan_bcf_metadata *metadata);
 
enum mmwlan_status mmwlan_override_max_tx_power(uint16_t tx_power_dbm);
 
enum mmwlan_status mmwlan_set_rts_threshold(unsigned rts_threshold);
 
enum mmwlan_status mmwlan_set_sgi_enabled(bool sgi_enabled);
 
enum mmwlan_status mmwlan_set_subbands_enabled(bool subbands_enabled);
 
enum mmwlan_status mmwlan_set_ampdu_enabled(bool ampdu_enabled);
 
#define MMWLAN_MINIMUM_FRAGMENT_THRESHOLD (256)
 
enum mmwlan_status mmwlan_set_fragment_threshold(unsigned fragment_threshold);
 
#define MMWLAN_QOS_QUEUE_NUM_ACIS 4
 
struct mmwlan_qos_queue_params
{
    uint8_t aci;
    uint8_t aifs;
    uint16_t cw_min;
    uint16_t cw_max;
    uint32_t txop_max_us;
};
 
enum mmwlan_status mmwlan_set_default_qos_queue_params(const struct mmwlan_qos_queue_params *params,
                                                       size_t count);
 
enum mmwlan_mcs10_mode
{
    MMWLAN_MCS10_MODE_DISABLED = 0x00,
    MMWLAN_MCS10_MODE_FORCED = 0x01,
    MMWLAN_MCS10_MODE_AUTO = 0x02
};
 
enum mmwlan_status mmwlan_set_mcs10_mode(enum mmwlan_mcs10_mode mcs10_mode);
 
enum mmwlan_status mmwlan_set_control_response_preamble_1mhz_out_en(bool enabled);
 
#ifndef MMWLAN_DEFAULT_MIN_HEALTH_CHECK_INTERVAL_MS
#define MMWLAN_DEFAULT_MIN_HEALTH_CHECK_INTERVAL_MS 60000
#endif
 
#ifndef MMWLAN_DEFAULT_MAX_HEALTH_CHECK_INTERVAL_MS
#define MMWLAN_DEFAULT_MAX_HEALTH_CHECK_INTERVAL_MS 120000
#endif
 
enum mmwlan_status mmwlan_set_health_check_interval(uint32_t min_interval_ms,
                                                    uint32_t max_interval_ms);
 
struct mmwlan_boot_args
{
    const uint8_t *sta_mac_addr_override;
};
 
#define MMWLAN_BOOT_ARGS_INIT { NULL }
 
enum mmwlan_status mmwlan_boot(const struct mmwlan_boot_args *args);
 
enum mmwlan_status mmwlan_shutdown(void);
 
enum mmwlan_status mmwlan_get_vif_mac_addr(enum mmwlan_vif vif, uint8_t *mac_addr);
 
static inline enum mmwlan_status mmwlan_get_mac_addr(uint8_t *mac_addr)
{
    return mmwlan_get_vif_mac_addr(MMWLAN_VIF_STA, mac_addr);
}
 
struct mmwlan_scan_result
{
    int16_t rssi;
    const uint8_t *bssid;
    const uint8_t *ssid;
    const uint8_t *ies;
    uint16_t beacon_interval;
    uint16_t capability_info;
    uint16_t ies_len;
    uint8_t ssid_len;
    uint32_t channel_freq_hz;
    uint8_t bw_mhz;
    uint8_t op_bw_mhz;
    int8_t noise_dbm;
    uint64_t tsf;
};
 
typedef void (*mmwlan_scan_rx_cb_t)(const struct mmwlan_scan_result *result, void *arg);
 
struct mmwlan_scan_config
{
    uint32_t dwell_time_ms;
 
    bool ndp_probe_enabled;
 
    uint32_t home_channel_dwell_time_ms;
 
    uint8_t *selected_channels;
 
    uint8_t selected_channels_len;
 
    uint8_t selective_scan_attempts;
};
 
#define MMWLAN_SCAN_CONFIG_INIT                                             \
    {                                                                       \
        .dwell_time_ms = MMWLAN_SCAN_DEFAULT_DWELL_TIME_MS,                 \
        .ndp_probe_enabled = false,                                         \
        .home_channel_dwell_time_ms = MMWLAN_SCAN_DEFAULT_DWELL_ON_HOME_MS, \
        .selected_channels = NULL,                                          \
        .selected_channels_len = 0,                                         \
        .selective_scan_attempts = 0,                                       \
    }
 
enum mmwlan_status mmwlan_set_scan_config(const struct mmwlan_scan_config *config);
#define MMWLAN_SCAN_DEFAULT_DWELL_TIME_MS (30)
#define MMWLAN_SCAN_DEFAULT_DWELL_ON_HOME_MS (200)
 
#define MMWLAN_SCAN_MIN_DWELL_TIME_MS (15)
 
enum mmwlan_scan_state
{
    MMWLAN_SCAN_SUCCESSFUL,
    MMWLAN_SCAN_TERMINATED,
    MMWLAN_SCAN_RUNNING,
};
 
typedef void (*mmwlan_scan_complete_cb_t)(enum mmwlan_scan_state scan_state, void *arg);
 
struct mmwlan_scan_args
{
    uint32_t dwell_time_ms;
    uint8_t *extra_ies;
    size_t extra_ies_len;
    uint8_t ssid[MMWLAN_SSID_MAXLEN];
    uint16_t ssid_len;
    uint32_t dwell_on_home_ms;
    uint8_t *selected_channels;
    uint8_t selected_channels_len;
};
 
#define MMWLAN_SCAN_ARGS_INIT                                     \
    {                                                             \
        .dwell_time_ms = MMWLAN_SCAN_DEFAULT_DWELL_TIME_MS,       \
        .extra_ies = NULL,                                        \
        .extra_ies_len = 0,                                       \
        .ssid = { 0 },                                            \
        .ssid_len = 0,                                            \
        .dwell_on_home_ms = MMWLAN_SCAN_DEFAULT_DWELL_ON_HOME_MS, \
        .selected_channels = NULL,                                \
        .selected_channels_len = 0,                               \
    }
 
struct mmwlan_scan_req
{
    mmwlan_scan_rx_cb_t scan_rx_cb;
    mmwlan_scan_complete_cb_t scan_complete_cb;
    void *scan_cb_arg;
    struct mmwlan_scan_args args;
};
 
#define MMWLAN_SCAN_REQ_INIT { NULL, NULL, NULL, MMWLAN_SCAN_ARGS_INIT }
 
enum mmwlan_status mmwlan_scan_request(const struct mmwlan_scan_req *scan_req);
 
enum mmwlan_status mmwlan_scan_abort(void);
 
#define DEFAULT_BGSCAN_SHORT_INTERVAL_S (0)
 
#define DEFAULT_BGSCAN_THRESHOLD_DBM (0)
 
#define DEFAULT_BGSCAN_LONG_INTERVAL_S (0)
 
#define DEFAULT_TWT_WAKE_INTERVAL_US (300000000)
 
#define DEFAULT_TWT_MIN_WAKE_DURATION_US (65280)
 
#define MMWLAN_DEFAULT_SCAN_INTERVAL_BASE_S (2)
 
#define MMWLAN_DEFAULT_SCAN_INTERVAL_LIMIT_S (512)
 
#define MMWLAN_RAW_MAX_PRIORITY (7)
 
enum mmwlan_cac_mode
{
    MMWLAN_CAC_DISABLED,
    MMWLAN_CAC_ENABLED
};
 
enum mmwlan_4addr_mode
{
    MMWLAN_4ADDR_MODE_DISABLED,
    MMWLAN_4ADDR_MODE_ENABLED,
};
 
enum mmwlan_ps_mode
{
    MMWLAN_PS_DISABLED,
    MMWLAN_PS_ENABLED
};
 
enum mmwlan_station_type
{
    MMWLAN_STA_TYPE_SENSOR = 0x01,
    MMWLAN_STA_TYPE_NON_SENSOR = 0x02,
};
 
enum mmwlan_sta_state
{
    MMWLAN_STA_DISABLED,
    MMWLAN_STA_CONNECTING,
    MMWLAN_STA_CONNECTED,
};
 
typedef void (*mmwlan_sta_status_cb_t)(enum mmwlan_sta_state sta_state);
 
enum mmwlan_sta_event
{
    MMWLAN_STA_EVT_SCAN_REQUEST,
    MMWLAN_STA_EVT_SCAN_COMPLETE,
    MMWLAN_STA_EVT_SCAN_ABORT,
    MMWLAN_STA_EVT_AUTH_REQUEST,
    MMWLAN_STA_EVT_ASSOC_REQUEST,
    MMWLAN_STA_EVT_DEAUTH_TX,
    MMWLAN_STA_EVT_CTRL_PORT_OPEN,
    MMWLAN_STA_EVT_CTRL_PORT_CLOSED,
};
 
struct mmwlan_sta_event_cb_args
{
    enum mmwlan_sta_event event;
};
 
typedef void (*mmwlan_sta_event_cb_t)(const struct mmwlan_sta_event_cb_args *sta_event, void *arg);
 
struct mmwlan_sta_args
{
    uint8_t ssid[MMWLAN_SSID_MAXLEN];
    uint16_t ssid_len;
    uint8_t bssid[MMWLAN_MAC_ADDR_LEN];
    enum mmwlan_security_type security_type;
    char passphrase[MMWLAN_PASSPHRASE_MAXLEN + 1];
    uint16_t passphrase_len;
    enum mmwlan_pmf_mode pmf_mode;
    int16_t raw_sta_priority;
    enum mmwlan_station_type sta_type;
    int sae_owe_ec_groups[MMWLAN_MAX_EC_GROUPS];
    enum mmwlan_cac_mode cac_mode;
    uint16_t bgscan_short_interval_s;
    int bgscan_signal_threshold_dbm;
    uint16_t bgscan_long_interval_s;
    mmwlan_scan_rx_cb_t scan_rx_cb;
    void *scan_rx_cb_arg;
    uint16_t scan_interval_base_s;
    uint16_t scan_interval_limit_s;
    uint8_t *extra_assoc_ies;
    size_t extra_assoc_ies_len;
    mmwlan_sta_event_cb_t sta_evt_cb;
    void *sta_evt_cb_arg;
    enum mmwlan_4addr_mode use_4addr;
};
 
#define MMWLAN_STA_ARGS_INIT                                           \
    {                                                                  \
        .ssid = { 0 },                                                 \
        .ssid_len = 0,                                                 \
        .bssid = { 0 },                                                \
        .security_type = MMWLAN_OPEN,                                  \
        .passphrase = { 0 },                                           \
        .passphrase_len = 0,                                           \
        .pmf_mode = MMWLAN_PMF_REQUIRED,                               \
        .raw_sta_priority = -1,                                        \
        .sta_type = MMWLAN_STA_TYPE_NON_SENSOR,                        \
        .sae_owe_ec_groups = { 0 },                                    \
        .cac_mode = MMWLAN_CAC_DISABLED,                               \
        .bgscan_short_interval_s = DEFAULT_BGSCAN_SHORT_INTERVAL_S,    \
        .bgscan_signal_threshold_dbm = DEFAULT_BGSCAN_THRESHOLD_DBM,   \
        .bgscan_long_interval_s = DEFAULT_BGSCAN_LONG_INTERVAL_S,      \
        .scan_rx_cb = NULL,                                            \
        .scan_rx_cb_arg = NULL,                                        \
        .scan_interval_base_s = MMWLAN_DEFAULT_SCAN_INTERVAL_BASE_S,   \
        .scan_interval_limit_s = MMWLAN_DEFAULT_SCAN_INTERVAL_LIMIT_S, \
        .extra_assoc_ies = NULL,                                       \
        .extra_assoc_ies_len = 0,                                      \
        .sta_evt_cb = NULL,                                            \
        .sta_evt_cb_arg = NULL,                                        \
        .use_4addr = MMWLAN_4ADDR_MODE_DISABLED,                       \
    }
 
enum mmwlan_status mmwlan_sta_enable(const struct mmwlan_sta_args *args,
                                     mmwlan_sta_status_cb_t sta_status_cb);
 
enum mmwlan_status mmwlan_sta_disable(void);
 
enum mmwlan_sta_state mmwlan_get_sta_state(void);
 
enum mmwlan_status mmwlan_set_power_save_mode(enum mmwlan_ps_mode mode);
 
#define MMWLAN_DEFAULT_DYNAMIC_PS_TIMEOUT_MS 100;
 
enum mmwlan_status mmwlan_set_dynamic_ps_timeout(uint32_t timeout_ms);
 
enum mmwlan_status mmwlan_set_non_tim_mode_enabled(bool non_tim_mode_enabled);
 
enum mmwlan_twt_mode
{
    MMWLAN_TWT_DISABLED,
    MMWLAN_TWT_REQUESTER,
    MMWLAN_TWT_RESPONDER
};
 
enum mmwlan_twt_setup_command
{
    MMWLAN_TWT_SETUP_REQUEST,
    MMWLAN_TWT_SETUP_SUGGEST,
    MMWLAN_TWT_SETUP_DEMAND
};
 
struct mmwlan_twt_config_args
{
    enum mmwlan_twt_mode twt_mode;
    uint64_t twt_wake_interval_us;
    uint16_t twt_wake_interval_mantissa;
    uint8_t twt_wake_interval_exponent;
    uint32_t twt_min_wake_duration_us;
    enum mmwlan_twt_setup_command twt_setup_command;
};
 
#define MMWLAN_TWT_CONFIG_ARGS_INIT                                   \
    {                                                                 \
        .twt_mode = MMWLAN_TWT_DISABLED,                              \
        .twt_wake_interval_us = DEFAULT_TWT_WAKE_INTERVAL_US,         \
        .twt_wake_interval_mantissa = 0,                              \
        .twt_wake_interval_exponent = 0,                              \
        .twt_min_wake_duration_us = DEFAULT_TWT_MIN_WAKE_DURATION_US, \
        .twt_setup_command = MMWLAN_TWT_SETUP_REQUEST,                \
    }
 
enum mmwlan_status mmwlan_twt_add_configuration(
    const struct mmwlan_twt_config_args *twt_config_args);
 
uint16_t mmwlan_get_aid(void);
 
enum mmwlan_status mmwlan_get_bssid(uint8_t *bssid);
 
int32_t mmwlan_get_rssi(void);
 
enum mmwlan_status mmwlan_set_listen_interval(uint16_t interval);
 
enum mmwlan_status mmwlan_set_beacon_loss_threshold(uint8_t threshold);
 
struct mmwlan_set_wnm_sleep_enabled_args
{
    bool wnm_sleep_enabled;
    bool chip_powerdown_enabled;
};
 
#define MMWLAN_SET_WNM_SLEEP_ENABLED_ARGS_INIT { false, false }
 
enum mmwlan_status mmwlan_set_wnm_sleep_enabled_ext(
    const struct mmwlan_set_wnm_sleep_enabled_args *args);
 
static inline enum mmwlan_status mmwlan_set_wnm_sleep_enabled(bool wnm_sleep_enabled)
{
    struct mmwlan_set_wnm_sleep_enabled_args wnm_sleep_args =
        MMWLAN_SET_WNM_SLEEP_ENABLED_ARGS_INIT;
    wnm_sleep_args.wnm_sleep_enabled = wnm_sleep_enabled;
    return mmwlan_set_wnm_sleep_enabled_ext(&wnm_sleep_args);
}
 
enum mmwlan_dpp_mode
{
    MMWLAN_DPP_MODE_PUSH_BUTTON,
    MMWLAN_DPP_MODE_QR_ENROLLEE,
};
 
enum mmwlan_dpp_event
{
    /* QR code presence announcement (chirp) */
    MMWLAN_DPP_EVT_CHIRP_STARTED,
    MMWLAN_DPP_EVT_CHIRP_STOPPED,
 
    /* Push Button flow */
    MMWLAN_DPP_EVT_PB_STARTED,
    MMWLAN_DPP_EVT_PB_DISCOVERY,
    MMWLAN_DPP_EVT_PB_RESULT,
 
    /* DPP Authentication phase */
    MMWLAN_DPP_EVT_AUTH_REQ_RX,
    MMWLAN_DPP_EVT_AUTH_RESP_TX,
    MMWLAN_DPP_EVT_AUTH_SUCCESS,
    MMWLAN_DPP_EVT_AUTH_FAILURE,
 
    /* DPP Configuration phase */
    MMWLAN_DPP_EVT_CONF_REQ_TX,
    MMWLAN_DPP_EVT_CONF_RECEIVED,
    MMWLAN_DPP_EVT_CONF_RESULT_TX,
    MMWLAN_DPP_EVT_CONF_FAILED,
};
 
enum mmwlan_dpp_pb_result
{
    MMWLAN_DPP_PB_RESULT_SUCCESS,
    MMWLAN_DPP_PB_RESULT_ERROR,
    MMWLAN_DPP_PB_RESULT_SESSION_OVERLAP,
};
 
enum mmwlan_dpp_auth_failure_reason
{
    MMWLAN_DPP_AUTH_FAILURE_NO_RESPONSE,
    MMWLAN_DPP_AUTH_FAILURE_NO_CONFIRM,
    MMWLAN_DPP_AUTH_FAILURE_INIT_FAILED,
};
 
enum mmwlan_dpp_conf_failure_reason
{
    MMWLAN_DPP_CONF_FAILURE_RESPONSE_ERROR,
    MMWLAN_DPP_CONF_FAILURE_TIMEOUT,
    MMWLAN_DPP_CONF_FAILURE_RESULT_TIMEOUT,
};
 
struct mmwlan_dpp_cb_args
{
    enum mmwlan_dpp_event event;
 
    union
    {
        struct
        {
            enum mmwlan_dpp_pb_result result;
        } pb_result;
 
        struct
        {
            const uint8_t *ssid;
            uint16_t ssid_len;
            const char *passphrase;
        } conf_received;
 
        struct
        {
            const uint8_t *peer_mac;
        } pb_discovery;
 
        struct
        {
            const uint8_t *peer_mac;
        } auth_req_rx;
 
        struct
        {
            bool initiator;
        } auth_success;
 
        struct
        {
            enum mmwlan_dpp_auth_failure_reason reason;
        } auth_failure;
 
        struct
        {
            enum mmwlan_dpp_conf_failure_reason reason;
        } conf_failed;
    } args;
};
 
#define MMWLAN_DPP_BOOTSTRAP_KEY_MAX_LEN 128
 
struct mmwlan_dpp_qr_args
{
    const uint8_t *bootstrap_private_key;
    uint16_t bootstrap_private_key_len;
    uint16_t chirp_iterations;
};
 
struct mmwlan_dpp_args
{
    void (*dpp_event_cb)(const struct mmwlan_dpp_cb_args *dpp_event, void *arg);
    void *dpp_event_cb_arg;
    enum mmwlan_dpp_mode mode;
    struct mmwlan_dpp_qr_args qr;
};
 
#define MMWLAN_DPP_ARGS_INIT                 \
    {                                        \
        .dpp_event_cb = NULL,                \
        .dpp_event_cb_arg = NULL,            \
        .mode = MMWLAN_DPP_MODE_PUSH_BUTTON, \
        .qr = { 0 },                         \
    }
 
enum mmwlan_status mmwlan_dpp_start(const struct mmwlan_dpp_args *args);
 
enum mmwlan_status mmwlan_dpp_stop(void);
 
enum mmwlan_status mmwlan_dpp_get_uri(char *uri_buf, size_t buf_len);
 
#define MMWLAN_DEFAULT_AP_BEACON_INTERVAL_TUS (100)
 
#define MMWLAN_DEFAULT_AP_DTIM_PERIOD (1)
 
#define MMWLAN_DEFAULT_AP_MAX_STAS (4)
 
#define MMWLAN_AP_MAX_STAS_LIMIT (20)
 
enum mmwlan_ap_sta_state
{
    MMWLAN_AP_STA_UNKNOWN,
    MMWLAN_AP_STA_AUTHENTICATED,
    MMWLAN_AP_STA_ASSOCIATED,
    MMWLAN_AP_STA_AUTHORIZED,
};
 
struct mmwlan_ap_sta_status
{
    enum mmwlan_ap_sta_state state;
    uint16_t aid;
    uint8_t mac_addr[MMWLAN_MAC_ADDR_LEN];
};
 
typedef void (*mmwlan_ap_sta_status_cb_t)(const struct mmwlan_ap_sta_status *sta_status, void *arg);
 
enum mmwlan_status mmwlan_ap_get_sta_status(const uint8_t *sta_addr,
                                            struct mmwlan_ap_sta_status *sta_status);
 
struct mmwlan_ap_args
{
    uint8_t ssid[MMWLAN_SSID_MAXLEN];
    uint16_t ssid_len;
    uint8_t bssid[MMWLAN_MAC_ADDR_LEN];
    enum mmwlan_security_type security_type;
    char passphrase[MMWLAN_PASSPHRASE_MAXLEN + 1];
    uint16_t passphrase_len;
    enum mmwlan_pmf_mode pmf_mode;
    int sae_owe_ec_groups[MMWLAN_MAX_EC_GROUPS];
    uint16_t op_class;
    uint16_t s1g_chan_num;
    uint16_t beacon_interval_tus;
    uint16_t dtim_period;
    uint8_t pri_bw_mhz;
    uint8_t pri_1mhz_chan_idx;
    mmwlan_ap_sta_status_cb_t sta_status_cb;
    void *sta_status_cb_arg;
    uint8_t max_stas;
    bool async_start;
};
 
#define MMWLAN_AP_ARGS_INIT              \
    {                                    \
        .ssid = { 0 },                   \
        .ssid_len = 0,                   \
        .bssid = { 0 },                  \
        .security_type = MMWLAN_OPEN,    \
        .passphrase = { 0 },             \
        .passphrase_len = 0,             \
        .pmf_mode = MMWLAN_PMF_REQUIRED, \
        .sae_owe_ec_groups = { 0 },      \
        .op_class = 0,                   \
        .s1g_chan_num = 0,               \
        .beacon_interval_tus = 0,        \
        .dtim_period = 0,                \
        .pri_bw_mhz = 0,                 \
        .pri_1mhz_chan_idx = 0,          \
        .sta_status_cb = NULL,           \
        .sta_status_cb_arg = NULL,       \
        .max_stas = 0,                   \
        .async_start = false,            \
    }
 
enum mmwlan_status mmwlan_ap_enable(const struct mmwlan_ap_args *args);
 
enum mmwlan_status mmwlan_ap_disable(void);
 
static inline enum mmwlan_status mmwlan_ap_get_bssid(uint8_t *bssid)
{
    return mmwlan_get_vif_mac_addr(MMWLAN_VIF_AP, bssid);
}
 
#define MMWLAN_RELAY_DEFAULT_FORWARDING_TABLE_SIZE (64)
 
typedef void (*mmwlan_relay_depth_change_cb_t)(uint8_t new_depth, void *arg);
 
enum mmwlan_status mmwlan_register_depth_change_cb(mmwlan_relay_depth_change_cb_t callback,
                                                   void *arg);
 
struct mmwlan_relay_args
{
    unsigned forwarding_table_size;
 
    bool is_root_node;
};
 
#define MMWLAN_RELAY_ARGS_INIT      \
    {                               \
        .forwarding_table_size = 0, \
        .is_root_node = false,      \
    }
 
enum mmwlan_status mmwlan_relay_enable(const struct mmwlan_relay_args *args);
 
#define MMWLAN_RELAY_MAX_DEPTH 8
 
enum mmwlan_status mmwlan_relay_set_depth_override(uint8_t depth);
 
enum mmwlan_status mmwlan_relay_disable(void);
 
enum mmwlan_relay_state
{
    MMWLAN_RELAY_STATE_DISABLED,
    MMWLAN_RELAY_STATE_STA,
    MMWLAN_RELAY_STATE_RELAY,
    MMWLAN_RELAY_STATE_ROOT,
};
 
enum mmwlan_relay_state mmwlan_relay_get_state(void);
 
#define MMWLAN_RELAY_DEPTH_UNKNOWN UINT8_MAX
 
uint8_t mmwlan_relay_get_depth(void);
 
#define MMWLAN_BEACON_VENDOR_IE_MAX_OUI_FILTERS (5)
 
typedef void (
    *mmwlan_beacon_vendor_ie_filter_cb_t)(const uint8_t *ies, uint32_t ies_len, void *arg);
 
typedef uint8_t mmwlan_oui_t[MMWLAN_OUI_SIZE];
 
struct mmwlan_beacon_vendor_ie_filter
{
    mmwlan_beacon_vendor_ie_filter_cb_t cb;
    void *cb_arg;
    uint8_t n_ouis;
    mmwlan_oui_t ouis[MMWLAN_BEACON_VENDOR_IE_MAX_OUI_FILTERS];
};
 
enum mmwlan_status mmwlan_update_beacon_vendor_ie_filter(
    const struct mmwlan_beacon_vendor_ie_filter *filter);
 
#define MMWLAN_VENDOR_IE_TOTAL_MAX_BYTES (2 * (UINT8_MAX + 2))
 
#define MMWLAN_VENDOR_IE_MAX_SIZE (UINT8_MAX)
 
#define MMWLAN_VENDOR_IE_MIN_SIZE (3)
 
enum mmwlan_vendor_ie_mgmt_type
{
    MMWLAN_VENDOR_IE_MGMT_BEACON = (1u << 0), 
    MMWLAN_VENDOR_IE_MGMT_PROBE_RESP = (1u << 1), 
    MMWLAN_VENDOR_IE_MGMT_ALL = 0b111,
};
 
struct mmwlan_vendor_ie
{
    const uint8_t *data;
    uint8_t data_len;
    uint8_t mgmt_type_mask;
};
 
enum mmwlan_status mmwlan_add_vendor_ie(const struct mmwlan_vendor_ie *ie);
 
enum mmwlan_status mmwlan_clear_vendor_ies(uint8_t mgmt_type_mask);
 
/*
 * ---------------------------------------------------------------------------------------------
 */
 
void mmwlan_init(void);
 
void mmwlan_deinit(void);
 
/*
 * ---------------------------------------------------------------------------------------------
 */
 
enum mmwlan_link_state
{
    MMWLAN_LINK_DOWN, 
    MMWLAN_LINK_UP, 
};
 
typedef void (*mmwlan_link_state_cb_t)(enum mmwlan_link_state link_state, void *arg);
 
enum mmwlan_status mmwlan_register_link_state_cb(mmwlan_link_state_cb_t callback, void *arg);
 
struct mmwlan_vif_state
{
    enum mmwlan_vif vif;
    enum mmwlan_link_state link_state;
};
 
typedef void (*mmwlan_vif_state_cb_t)(const struct mmwlan_vif_state *state, void *arg);
 
enum mmwlan_status mmwlan_register_vif_state_cb(enum mmwlan_vif vif,
                                                mmwlan_vif_state_cb_t callback,
                                                void *arg);
 
struct mmwlan_vif_channel_info
{
    uint16_t op_class;
    uint16_t s1g_chan_num;
    uint8_t pri_bw_mhz;
    uint8_t pri_1mhz_chan_idx;
};
 
enum mmwlan_status mmwlan_get_vif_channel_info(enum mmwlan_vif vif,
                                               struct mmwlan_vif_channel_info *info);
 
typedef void (*mmwlan_rx_cb_t)(uint8_t *header,
                               unsigned header_len,
                               uint8_t *payload,
                               unsigned payload_len,
                               void *arg);
 
enum mmwlan_status mmwlan_register_rx_cb(mmwlan_rx_cb_t callback, void *arg);
 
typedef void (*mmwlan_rx_pkt_cb_t)(struct mmpkt *mmpkt, void *arg);
 
enum mmwlan_status mmwlan_register_rx_pkt_cb(mmwlan_rx_pkt_cb_t callback, void *arg);
 
struct mmwlan_rx_metadata
{
    enum mmwlan_vif vif;
 
    uint8_t tid;
 
    const uint8_t *ta;
};
 
typedef void (*mmwlan_rx_pkt_ext_cb_t)(struct mmpkt *mmpkt,
                                       const struct mmwlan_rx_metadata *metadata,
                                       void *arg);
 
enum mmwlan_status mmwlan_register_rx_pkt_ext_cb(enum mmwlan_vif vif,
                                                 mmwlan_rx_pkt_ext_cb_t callback,
                                                 void *arg);
 
enum mmwlan_status mmwlan_tx_wait_until_ready(uint32_t timeout_ms);
 
struct mmpkt *mmwlan_alloc_mmpkt_for_tx(uint32_t payload_len, uint8_t tid);
 
#define MMWLAN_TX_DEFAULT_TIMEOUT_MS (1000)
 
#define MMWLAN_TX_DEFAULT_QOS_TID (0)
 
#define MMWLAN_MAX_QOS_TID (7)
 
struct mmwlan_tx_metadata
{
    uint8_t tid;
 
    enum mmwlan_vif vif;
 
    const uint8_t *ra;
};
 
#define MMWLAN_TX_METADATA_INIT { MMWLAN_TX_DEFAULT_QOS_TID, MMWLAN_VIF_UNSPECIFIED, NULL }
 
enum mmwlan_status mmwlan_tx_pkt(struct mmpkt *pkt, const struct mmwlan_tx_metadata *metadata);
 
static inline enum mmwlan_status mmwlan_tx_tid(const uint8_t *data, unsigned len, uint8_t tid)
{
    enum mmwlan_status status;
    struct mmpkt *pkt;
    struct mmpktview *pktview;
    struct mmwlan_tx_metadata metadata = MMWLAN_TX_METADATA_INIT;
 
    status = mmwlan_tx_wait_until_ready(MMWLAN_TX_DEFAULT_TIMEOUT_MS);
    if (status != MMWLAN_SUCCESS)
    {
        return status;
    }
 
    pkt = mmwlan_alloc_mmpkt_for_tx(len, tid);
    if (pkt == NULL)
    {
        return MMWLAN_NO_MEM;
    }
 
    pktview = mmpkt_open(pkt);
    mmpkt_append_data(pktview, data, len);
    mmpkt_close(&pktview);
 
    metadata.tid = tid;
    return mmwlan_tx_pkt(pkt, &metadata);
}
 
static inline enum mmwlan_status mmwlan_tx(const uint8_t *data, unsigned len)
{
    return mmwlan_tx_tid(data, len, MMWLAN_TX_DEFAULT_QOS_TID);
}
 
enum mmwlan_tx_flow_control_state
{
    MMWLAN_TX_READY, 
    MMWLAN_TX_PAUSED, 
};
 
typedef void (*mmwlan_tx_flow_control_cb_t)(enum mmwlan_tx_flow_control_state state, void *arg);
 
enum mmwlan_status mmwlan_register_tx_flow_control_cb(mmwlan_tx_flow_control_cb_t cb, void *arg);
 
struct mmwlan_fatal_error_args
{
    void *arg;
    uint32_t fileid;
    uint32_t line;
};
 
typedef void (*mmwlan_fatal_error_handler_t)(struct mmwlan_fatal_error_args *args);
 
void mmwlan_register_fatal_error_handler(mmwlan_fatal_error_handler_t handler, void *arg);
 
/*
 * ---------------------------------------------------------------------------------------------
 */
 
struct mmwlan_rc_stats
{
    uint32_t n_entries;
    uint32_t *rate_info;
    uint32_t *total_sent;
    uint32_t *total_success;
};
 
enum mmwlan_rc_stats_rate_info_offsets
{
    MMWLAN_RC_STATS_RATE_INFO_BW_OFFSET = 0,
    MMWLAN_RC_STATS_RATE_INFO_RATE_OFFSET = 4,
    MMWLAN_RC_STATS_RATE_INFO_GUARD_OFFSET = 8,
};
 
struct mmwlan_rc_stats *mmwlan_get_rc_stats(void);
 
void mmwlan_free_rc_stats(struct mmwlan_rc_stats *stats);
 
struct mmwlan_morse_stats
{
    uint8_t *buf;
    uint32_t len;
};
 
struct mmwlan_morse_stats *mmwlan_get_morse_stats(uint32_t core_num, bool reset);
 
void mmwlan_free_morse_stats(struct mmwlan_morse_stats *stats);
 
struct mmwlan_stats_umac_data;
 
enum mmwlan_status mmwlan_get_umac_stats(struct mmwlan_stats_umac_data *stats_dest);
 
enum mmwlan_status mmwlan_clear_umac_stats(void);
 
/*
 * ---------------------------------------------------------------------------------------------
 */
 
enum mmwlan_mcs
{
    MMWLAN_MCS_NONE = -1, 
    MMWLAN_MCS_0 = 0, 
    MMWLAN_MCS_1, 
    MMWLAN_MCS_2, 
    MMWLAN_MCS_3, 
    MMWLAN_MCS_4, 
    MMWLAN_MCS_5, 
    MMWLAN_MCS_6, 
    MMWLAN_MCS_7, 
    MMWLAN_MCS_8, 
    MMWLAN_MCS_9, 
    MMWLAN_MCS_MAX = MMWLAN_MCS_9 
};
 
enum mmwlan_bw
{
    MMWLAN_BW_NONE = -1, 
    MMWLAN_BW_1MHZ = 1, 
    MMWLAN_BW_2MHZ = 2, 
    MMWLAN_BW_4MHZ = 4, 
    MMWLAN_BW_8MHZ = 8, 
    MMWLAN_BW_MAX = MMWLAN_BW_8MHZ, 
};
 
enum mmwlan_gi
{
    MMWLAN_GI_NONE = -1, 
    MMWLAN_GI_SHORT = 0, 
    MMWLAN_GI_LONG, 
    MMWLAN_GI_MAX = MMWLAN_GI_LONG, 
};
 
enum mmwlan_status mmwlan_ate_override_rate_control(enum mmwlan_mcs tx_rate_override,
                                                    enum mmwlan_bw bandwidth_override,
                                                    enum mmwlan_gi gi_override);
 
enum mmwlan_status mmwlan_ate_execute_command(uint8_t *command,
                                              uint32_t command_len,
                                              uint8_t *response,
                                              uint32_t *response_len);
 
#ifdef __cplusplus
}
#endif