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,
};
 
#define MMWLAN_SSID_MAXLEN          (32)
 
#define MMWLAN_PASSPHRASE_MAXLEN    (100)
 
#define MMWLAN_RAW_MAX_PRIORITY     (7)
 
#define MMWLAN_MAC_ADDR_LEN         (6)
 
#define MMWLAN_MAX_EC_GROUPS        (4)
 
#define MMWLAN_OUI_SIZE             (3)
 
#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_DEFAULT_SOFTAP_BEACON_INTERVAL_TUS (100)
 
#define MMWLAN_DEFAULT_SOFTAP_DTIM_PERIOD (1)
 
 
#define MMWLAN_STANDBY_STATUS_FRAME_USER_PAYLOAD_MAXLEN   (64)
 
#define MMWLAN_STANDBY_WAKE_FRAME_USER_FILTER_MAXLEN      (64)
 
enum mmwlan_security_type
{
    MMWLAN_OPEN,
    MMWLAN_OWE,
    MMWLAN_SAE,
};
 
enum mmwlan_ps_mode
{
    MMWLAN_PS_DISABLED,
    MMWLAN_PS_ENABLED
};
 
enum mmwlan_pmf_mode
{
    MMWLAN_PMF_REQUIRED,
    MMWLAN_PMF_DISABLED
};
 
enum mmwlan_cac_mode
{
    MMWLAN_CAC_DISABLED,
    MMWLAN_CAC_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
};
 
enum mmwlan_duty_cycle_mode
{
    MMWLAN_DUTY_CYCLE_MODE_SPREAD = 0,
    MMWLAN_DUTY_CYCLE_MODE_BURST  = 1,
};
 
enum mmwlan_4addr_mode
{
    MMWLAN_4ADDR_MODE_DISABLED,
    MMWLAN_4ADDR_MODE_ENABLED,
};
 
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;
};
 
#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);
 
#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_power_save_mode(enum mmwlan_ps_mode mode);
 
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);
 
struct mmwlan_scan_config
{
    uint32_t dwell_time_ms;
 
    bool ndp_probe_enabled;
 
    uint32_t home_channel_dwell_time_ms;
};
 
#define MMWLAN_SCAN_CONFIG_INIT \
    { MMWLAN_SCAN_DEFAULT_DWELL_TIME_MS, false, MMWLAN_SCAN_DEFAULT_DWELL_ON_HOME_MS }
 
enum mmwlan_status mmwlan_set_scan_config(const struct mmwlan_scan_config *config);
 
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 { MMWLAN_TWT_DISABLED, DEFAULT_TWT_WAKE_INTERVAL_US, 0, 0,     \
                                      DEFAULT_TWT_MIN_WAKE_DURATION_US, MMWLAN_TWT_SETUP_REQUEST }
 
enum mmwlan_status mmwlan_twt_add_configuration(
    const struct mmwlan_twt_config_args *twt_config_args);
 
#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_duty_cycle_mode(enum mmwlan_duty_cycle_mode duty_cycle_mode);
 
enum mmwlan_status mmwlan_get_duty_cycle_stats(struct mmwlan_duty_cycle_stats *stats);
 
struct mmwlan_boot_args
{
    uint8_t reserved;
};
 
#define MMWLAN_BOOT_ARGS_INIT { 0 }
 
enum mmwlan_status mmwlan_boot(const struct mmwlan_boot_args *args);
 
enum mmwlan_status mmwlan_shutdown(void);
 
enum mmwlan_sta_state
{
    MMWLAN_STA_DISABLED,
    MMWLAN_STA_CONNECTING,
    MMWLAN_STA_CONNECTED,
};
 
enum mmwlan_station_type
{
    MMWLAN_STA_TYPE_SENSOR = 0x01,
    MMWLAN_STA_TYPE_NON_SENSOR = 0x02,
};
 
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;
    uint64_t tsf;
};
 
typedef void (*mmwlan_scan_rx_cb_t)(const struct mmwlan_scan_result *result, void *arg);
 
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                                                                       \
    { { 0 }, 0, { 0 }, MMWLAN_OPEN, { 0 }, 0, MMWLAN_PMF_REQUIRED, -1, MMWLAN_STA_TYPE_NON_SENSOR, \
      { 0 }, MMWLAN_CAC_DISABLED, DEFAULT_BGSCAN_SHORT_INTERVAL_S, DEFAULT_BGSCAN_THRESHOLD_DBM,   \
      DEFAULT_BGSCAN_LONG_INTERVAL_S, NULL, NULL,                                                  \
      MMWLAN_DEFAULT_SCAN_INTERVAL_BASE_S, MMWLAN_DEFAULT_SCAN_INTERVAL_LIMIT_S,                   \
      NULL, 0, NULL, NULL, 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_dpp_event
{
    MMWLAN_DPP_EVT_PB_RESULT,
};
 
enum mmwlan_dpp_pb_result
{
    MMWLAN_DPP_PB_RESULT_SUCCESS,
    MMWLAN_DPP_PB_RESULT_ERROR,
    MMWLAN_DPP_PB_RESULT_SESSION_OVERLAP,
};
 
struct mmwlan_dpp_cb_args
{
    enum mmwlan_dpp_event event;
    union
    {
        struct
        {
            enum mmwlan_dpp_pb_result result;
            const uint8_t *ssid;
            uint16_t ssid_len;
            const char *passphrase;
        } pb_result;
    } args;
};
 
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_status mmwlan_dpp_start(const struct mmwlan_dpp_args *args);
 
enum mmwlan_status mmwlan_dpp_stop(void);
 
enum mmwlan_sta_state mmwlan_get_sta_state(void);
 
#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;
};
 
#define MMWLAN_SCAN_ARGS_INIT \
    { MMWLAN_SCAN_DEFAULT_DWELL_TIME_MS, NULL, 0, { 0 }, 0, MMWLAN_SCAN_DEFAULT_DWELL_ON_HOME_MS }
 
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);
 
struct mmwlan_softap_sta_status
{
    uint8_t reserved;
};
 
typedef void (*mmwlan_softap_sta_status_cb_t)(const struct mmwlan_softap_sta_status *sta_status,
                                              void *arg);
 
struct mmwlan_softap_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_softap_sta_status_cb_t sta_status_cb;
    void *sta_status_cb_arg;
};
 
#define MMWLAN_SOFTAP_ARGS_INIT                                                                  \
    { { 0 }, 0, { 0 }, MMWLAN_OPEN, { 0 }, 0, MMWLAN_PMF_REQUIRED,                               \
      { 0 }, 0, 0, 0, 0, 0, 0, NULL, NULL }
 
 
enum mmwlan_status mmwlan_softap_enable(const struct mmwlan_softap_args *args);
 
enum mmwlan_status mmwlan_softap_disable(void);
 
enum mmwlan_status mmwlan_get_mac_addr(uint8_t *mac_addr);
 
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_enable_arp_response_offload(uint32_t arp_addr);
 
enum mmwlan_status mmwlan_enable_arp_refresh_offload(uint32_t interval_s, uint32_t dest_ip,
                                                     bool send_as_garp);
 
struct mmwlan_dhcp_lease_info
{
    uint32_t ip4_addr;
    uint32_t mask4_addr;
    uint32_t gw4_addr;
    uint32_t dns4_addr;
};
 
typedef void (*mmwlan_dhcp_lease_update_cb_t)(const struct mmwlan_dhcp_lease_info *lease_info,
                                              void *arg);
 
enum mmwlan_status mmwlan_enable_dhcp_offload(mmwlan_dhcp_lease_update_cb_t dhcp_lease_update_cb,
                                              void *arg);
 
enum mmwlan_tcp_keepalive_offload_cfg
{
    MMWLAN_TCP_KEEPALIVE_SET_CFG_PERIOD         = (0x01),
    MMWLAN_TCP_KEEPALIVE_SET_CFG_RETRY_COUNT    = (0x02),
    MMWLAN_TCP_KEEPALIVE_SET_CFG_RETRY_INTERVAL = (0x04),
    MMWLAN_TCP_KEEPALIVE_SET_CFG_SRC_IP_ADDR    = (0x08),
    MMWLAN_TCP_KEEPALIVE_SET_CFG_DEST_IP_ADDR   = (0x10),
    MMWLAN_TCP_KEEPALIVE_SET_CFG_SRC_PORT       = (0x20),
    MMWLAN_TCP_KEEPALIVE_SET_CFG_DEST_PORT      = (0x40),
    MMWLAN_TCP_KEEPALIVE_SET_CFG_TIMING_ONLY    = (0x07),
    MMWLAN_TCP_KEEPALIVE_SET_CFG_ALL            = (0x7F),
};
 
struct mmwlan_tcp_keepalive_offload_args
{
    uint8_t set_cfgs;
    uint16_t period_s;
    uint8_t retry_count;
    uint8_t retry_interval_s;
    uint32_t src_ip;
    uint16_t src_port;
    uint32_t dest_ip;
    uint16_t dest_port;
};
 
#define MMWLAN_TCP_KEEPALIVE_OFFLOAD_ARGS_INIT { 0 }
 
enum mmwlan_status mmwlan_enable_tcp_keepalive_offload(
    const struct mmwlan_tcp_keepalive_offload_args *args);
 
enum mmwlan_status mmwlan_disable_tcp_keepalive_offload(void);
 
#define MMWLAN_WHITELIST_FLAGS_CLEAR   0x01
 
struct mmwlan_config_whitelist
{
    uint8_t flags;
    uint8_t ip_protocol;
    uint16_t llc_protocol;
    uint32_t src_ip;
    uint32_t dest_ip;
    uint32_t netmask;
    uint16_t src_port;
    uint16_t dest_port;
};
 
enum mmwlan_status mmwlan_set_whitelist_filter(const struct mmwlan_config_whitelist *whitelist);
 
enum mmwlan_standby_exit_reason
{
    MMWLAN_STANDBY_EXIT_REASON_NONE,
    MMWLAN_STANDBY_EXIT_REASON_WAKEUP_FRAME,
    MMWLAN_STANDBY_EXIT_REASON_ASSOCIATE,
    MMWLAN_STANDBY_EXIT_REASON_EXT_INPUT,
    MMWLAN_STANDBY_EXIT_REASON_WHITELIST_PKT,
    MMWLAN_STANDBY_EXIT_REASON_TCP_CONNECTION_LOST,
    MMWLAN_STANDBY_EXIT_REASON_HW_SCAN_NOT_ENABLED,
    MMWLAN_STANDBY_EXIT_REASON_HW_SCAN_FAILED_TO_START,
};
 
typedef void (*mmwlan_standby_exit_cb_t)(uint8_t reason, void *arg);
 
struct mmwlan_standby_enter_args
{
    mmwlan_standby_exit_cb_t standby_exit_cb;
    void *standby_exit_arg;
};
 
enum mmwlan_status mmwlan_standby_enter(const struct mmwlan_standby_enter_args *args);
 
enum mmwlan_status mmwlan_standby_exit(void);
 
struct mmwlan_standby_set_status_payload_args
{
    uint8_t payload[MMWLAN_STANDBY_STATUS_FRAME_USER_PAYLOAD_MAXLEN];
    uint32_t payload_len;
};
 
enum mmwlan_status mmwlan_standby_set_status_payload(
    const struct mmwlan_standby_set_status_payload_args *args);
 
struct mmwlan_standby_set_wake_filter_args
{
    uint8_t filter[MMWLAN_STANDBY_WAKE_FRAME_USER_FILTER_MAXLEN];
    uint32_t      filter_len;
    uint32_t      offset;
};
 
enum mmwlan_status mmwlan_standby_set_wake_filter(
    const struct mmwlan_standby_set_wake_filter_args *args);
 
struct mmwlan_standby_config
{
    uint32_t notify_period_s;
    uint32_t src_ip;
    uint32_t dst_ip;
    uint16_t dst_port;
    uint32_t bss_inactivity_before_snooze_s;
    uint32_t snooze_period_s;
    uint32_t snooze_increment_s;
    uint32_t snooze_max_s;
};
 
enum mmwlan_status mmwlan_standby_set_config(const struct mmwlan_standby_config *config);
 
 
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);
}
 
#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);
 
 
/*
 * ---------------------------------------------------------------------------------------------
 */
 
void mmwlan_init(void);
 
 
void mmwlan_deinit(void);
 
#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);
 
/*
 * ---------------------------------------------------------------------------------------------
 */
 
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);
 
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);
 
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;
};
 
#define MMWLAN_TX_METADATA_INIT { MMWLAN_TX_DEFAULT_QOS_TID }
 
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_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