wifi_mgmt.h

Go to the documentation of this file.

/*
 * Copyright (c) 2017 Intel Corporation.
 * Copyright 2024 NXP
 * Copyright (c) 2024 Nordic Semiconductor ASA
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_INCLUDE_NET_WIFI_MGMT_H_
#define ZEPHYR_INCLUDE_NET_WIFI_MGMT_H_
 
#include <zephyr/net/net_mgmt.h>
#include <zephyr/net/wifi.h>
#include <zephyr/net/ethernet.h>
#include <zephyr/net/offloaded_netdev.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* Management part definitions */
 
#define _NET_WIFI_LAYER NET_MGMT_LAYER_L2
#define _NET_WIFI_CODE  0x156
#define _NET_WIFI_BASE  (NET_MGMT_IFACE_BIT |                   \
                         NET_MGMT_LAYER(_NET_WIFI_LAYER) |      \
                         NET_MGMT_LAYER_CODE(_NET_WIFI_CODE))
#define _NET_WIFI_EVENT (_NET_WIFI_BASE | NET_MGMT_EVENT_BIT)
 
#ifdef CONFIG_WIFI_MGMT_SCAN_SSID_FILT_MAX
#define WIFI_MGMT_SCAN_SSID_FILT_MAX CONFIG_WIFI_MGMT_SCAN_SSID_FILT_MAX
#else
#define WIFI_MGMT_SCAN_SSID_FILT_MAX 1
#endif /* CONFIG_WIFI_MGMT_SCAN_SSID_FILT_MAX */
 
#ifdef CONFIG_WIFI_MGMT_SCAN_CHAN_MAX_MANUAL
#define WIFI_MGMT_SCAN_CHAN_MAX_MANUAL CONFIG_WIFI_MGMT_SCAN_CHAN_MAX_MANUAL
#else
#define WIFI_MGMT_SCAN_CHAN_MAX_MANUAL 1
#endif /* CONFIG_WIFI_MGMT_SCAN_CHAN_MAX_MANUAL */
 
#ifdef CONFIG_WIFI_ENT_IDENTITY_MAX_USERS
#define WIFI_ENT_IDENTITY_MAX_USERS CONFIG_WIFI_ENT_IDENTITY_MAX_USERS
#else
#define WIFI_ENT_IDENTITY_MAX_USERS 1
#endif /* CONFIG_WIFI_ENT_IDENTITY_MAX_USERS */
 
#define WIFI_MGMT_BAND_STR_SIZE_MAX 8
#define WIFI_MGMT_SCAN_MAX_BSS_CNT 65535
 
#define WIFI_MGMT_SKIP_INACTIVITY_POLL IS_ENABLED(CONFIG_WIFI_MGMT_AP_STA_SKIP_INACTIVITY_POLL)
enum net_request_wifi_cmd {
        NET_REQUEST_WIFI_CMD_SCAN = 1,
        NET_REQUEST_WIFI_CMD_CONNECT,
        NET_REQUEST_WIFI_CMD_DISCONNECT,
        NET_REQUEST_WIFI_CMD_AP_ENABLE,
        NET_REQUEST_WIFI_CMD_AP_DISABLE,
        NET_REQUEST_WIFI_CMD_AP_RTS_THRESHOLD,
        NET_REQUEST_WIFI_CMD_IFACE_STATUS,
        NET_REQUEST_WIFI_CMD_11K_CONFIG,
        NET_REQUEST_WIFI_CMD_11K_NEIGHBOR_REQUEST,
        NET_REQUEST_WIFI_CMD_PS,
        NET_REQUEST_WIFI_CMD_TWT,
        NET_REQUEST_WIFI_CMD_BTWT,
        NET_REQUEST_WIFI_CMD_PS_CONFIG,
        NET_REQUEST_WIFI_CMD_REG_DOMAIN,
        NET_REQUEST_WIFI_CMD_MODE,
        NET_REQUEST_WIFI_CMD_PACKET_FILTER,
        NET_REQUEST_WIFI_CMD_CHANNEL,
        NET_REQUEST_WIFI_CMD_AP_STA_DISCONNECT,
        NET_REQUEST_WIFI_CMD_VERSION,
        NET_REQUEST_WIFI_CMD_CONN_PARAMS,
        NET_REQUEST_WIFI_CMD_RTS_THRESHOLD,
        NET_REQUEST_WIFI_CMD_AP_CONFIG_PARAM,
        NET_REQUEST_WIFI_CMD_DPP,
#ifdef CONFIG_WIFI_NM_WPA_SUPPLICANT_WNM
        NET_REQUEST_WIFI_CMD_BTM_QUERY,
#endif
        NET_REQUEST_WIFI_CMD_PMKSA_FLUSH,
        NET_REQUEST_WIFI_CMD_ENTERPRISE_CREDS,
        NET_REQUEST_WIFI_CMD_RTS_THRESHOLD_CONFIG,
        NET_REQUEST_WIFI_CMD_WPS_CONFIG,
#ifdef CONFIG_WIFI_CREDENTIALS_CONNECT_STORED
        NET_REQUEST_WIFI_CMD_CONNECT_STORED,
#endif
        NET_REQUEST_WIFI_CMD_START_ROAMING,
        NET_REQUEST_WIFI_CMD_NEIGHBOR_REP_COMPLETE,
        NET_REQUEST_WIFI_CMD_CANDIDATE_SCAN,
        NET_REQUEST_WIFI_CMD_AP_WPS_CONFIG,
        NET_REQUEST_WIFI_CMD_MAX
};
 
#define NET_REQUEST_WIFI_SCAN                                   \
        (_NET_WIFI_BASE | NET_REQUEST_WIFI_CMD_SCAN)
 
NET_MGMT_DEFINE_REQUEST_HANDLER(NET_REQUEST_WIFI_SCAN);
 
#define NET_REQUEST_WIFI_CONNECT                                \
        (_NET_WIFI_BASE | NET_REQUEST_WIFI_CMD_CONNECT)
 
NET_MGMT_DEFINE_REQUEST_HANDLER(NET_REQUEST_WIFI_CONNECT);
 
#define NET_REQUEST_WIFI_DISCONNECT                             \
        (_NET_WIFI_BASE | NET_REQUEST_WIFI_CMD_DISCONNECT)
 
NET_MGMT_DEFINE_REQUEST_HANDLER(NET_REQUEST_WIFI_DISCONNECT);
 
#define NET_REQUEST_WIFI_AP_ENABLE                              \
        (_NET_WIFI_BASE | NET_REQUEST_WIFI_CMD_AP_ENABLE)
 
NET_MGMT_DEFINE_REQUEST_HANDLER(NET_REQUEST_WIFI_AP_ENABLE);
 
#define NET_REQUEST_WIFI_AP_DISABLE                             \
        (_NET_WIFI_BASE | NET_REQUEST_WIFI_CMD_AP_DISABLE)
 
NET_MGMT_DEFINE_REQUEST_HANDLER(NET_REQUEST_WIFI_AP_DISABLE);
 
#define NET_REQUEST_WIFI_AP_RTS_THRESHOLD                               \
        (_NET_WIFI_BASE | NET_REQUEST_WIFI_CMD_AP_RTS_THRESHOLD)
 
NET_MGMT_DEFINE_REQUEST_HANDLER(NET_REQUEST_WIFI_AP_RTS_THRESHOLD);
 
#define NET_REQUEST_WIFI_IFACE_STATUS                           \
        (_NET_WIFI_BASE | NET_REQUEST_WIFI_CMD_IFACE_STATUS)
 
NET_MGMT_DEFINE_REQUEST_HANDLER(NET_REQUEST_WIFI_IFACE_STATUS);
 
#define NET_REQUEST_WIFI_11K_CONFIG                             \
        (_NET_WIFI_BASE | NET_REQUEST_WIFI_CMD_11K_CONFIG)
 
NET_MGMT_DEFINE_REQUEST_HANDLER(NET_REQUEST_WIFI_11K_CONFIG);
 
#define NET_REQUEST_WIFI_11K_NEIGHBOR_REQUEST                   \
        (_NET_WIFI_BASE | NET_REQUEST_WIFI_CMD_11K_NEIGHBOR_REQUEST)
 
NET_MGMT_DEFINE_REQUEST_HANDLER(NET_REQUEST_WIFI_11K_NEIGHBOR_REQUEST);
 
#define NET_REQUEST_WIFI_PS                                     \
        (_NET_WIFI_BASE | NET_REQUEST_WIFI_CMD_PS)
 
NET_MGMT_DEFINE_REQUEST_HANDLER(NET_REQUEST_WIFI_PS);
 
#define NET_REQUEST_WIFI_TWT                                    \
        (_NET_WIFI_BASE | NET_REQUEST_WIFI_CMD_TWT)
 
NET_MGMT_DEFINE_REQUEST_HANDLER(NET_REQUEST_WIFI_TWT);
 
#define NET_REQUEST_WIFI_BTWT                   \
        (_NET_WIFI_BASE | NET_REQUEST_WIFI_CMD_BTWT)
 
NET_MGMT_DEFINE_REQUEST_HANDLER(NET_REQUEST_WIFI_BTWT);
 
#define NET_REQUEST_WIFI_PS_CONFIG                              \
        (_NET_WIFI_BASE | NET_REQUEST_WIFI_CMD_PS_CONFIG)
 
NET_MGMT_DEFINE_REQUEST_HANDLER(NET_REQUEST_WIFI_PS_CONFIG);
 
#define NET_REQUEST_WIFI_REG_DOMAIN                             \
        (_NET_WIFI_BASE | NET_REQUEST_WIFI_CMD_REG_DOMAIN)
 
NET_MGMT_DEFINE_REQUEST_HANDLER(NET_REQUEST_WIFI_REG_DOMAIN);
 
#define NET_REQUEST_WIFI_MODE                                   \
        (_NET_WIFI_BASE | NET_REQUEST_WIFI_CMD_MODE)
 
NET_MGMT_DEFINE_REQUEST_HANDLER(NET_REQUEST_WIFI_MODE);
 
#define NET_REQUEST_WIFI_PACKET_FILTER                          \
        (_NET_WIFI_BASE | NET_REQUEST_WIFI_CMD_PACKET_FILTER)
 
NET_MGMT_DEFINE_REQUEST_HANDLER(NET_REQUEST_WIFI_PACKET_FILTER);
 
#define NET_REQUEST_WIFI_CHANNEL                                \
        (_NET_WIFI_BASE | NET_REQUEST_WIFI_CMD_CHANNEL)
 
NET_MGMT_DEFINE_REQUEST_HANDLER(NET_REQUEST_WIFI_CHANNEL);
 
#define NET_REQUEST_WIFI_AP_STA_DISCONNECT                      \
        (_NET_WIFI_BASE | NET_REQUEST_WIFI_CMD_AP_STA_DISCONNECT)
 
NET_MGMT_DEFINE_REQUEST_HANDLER(NET_REQUEST_WIFI_AP_STA_DISCONNECT);
 
#define NET_REQUEST_WIFI_VERSION                                \
        (_NET_WIFI_BASE | NET_REQUEST_WIFI_CMD_VERSION)
 
NET_MGMT_DEFINE_REQUEST_HANDLER(NET_REQUEST_WIFI_VERSION);
 
#define NET_REQUEST_WIFI_CONN_PARAMS                           \
        (_NET_WIFI_BASE | NET_REQUEST_WIFI_CMD_CONN_PARAMS)
 
NET_MGMT_DEFINE_REQUEST_HANDLER(NET_REQUEST_WIFI_CONN_PARAMS);
 
#define NET_REQUEST_WIFI_RTS_THRESHOLD                          \
        (_NET_WIFI_BASE | NET_REQUEST_WIFI_CMD_RTS_THRESHOLD)
 
NET_MGMT_DEFINE_REQUEST_HANDLER(NET_REQUEST_WIFI_RTS_THRESHOLD);
 
#define NET_REQUEST_WIFI_AP_CONFIG_PARAM         \
        (_NET_WIFI_BASE | NET_REQUEST_WIFI_CMD_AP_CONFIG_PARAM)
 
NET_MGMT_DEFINE_REQUEST_HANDLER(NET_REQUEST_WIFI_AP_CONFIG_PARAM);
 
#ifdef CONFIG_WIFI_NM_WPA_SUPPLICANT_DPP
#define NET_REQUEST_WIFI_DPP                    \
        (_NET_WIFI_BASE | NET_REQUEST_WIFI_CMD_DPP)
 
NET_MGMT_DEFINE_REQUEST_HANDLER(NET_REQUEST_WIFI_DPP);
#endif /* CONFIG_WIFI_NM_WPA_SUPPLICANT_DPP */
 
#ifdef CONFIG_WIFI_NM_WPA_SUPPLICANT_WNM
#define NET_REQUEST_WIFI_BTM_QUERY (_NET_WIFI_BASE | NET_REQUEST_WIFI_CMD_BTM_QUERY)
 
NET_MGMT_DEFINE_REQUEST_HANDLER(NET_REQUEST_WIFI_BTM_QUERY);
#endif
 
#define NET_REQUEST_WIFI_PMKSA_FLUSH                           \
        (_NET_WIFI_BASE | NET_REQUEST_WIFI_CMD_PMKSA_FLUSH)
 
NET_MGMT_DEFINE_REQUEST_HANDLER(NET_REQUEST_WIFI_PMKSA_FLUSH);
 
#define NET_REQUEST_WIFI_ENTERPRISE_CREDS                               \
        (_NET_WIFI_BASE | NET_REQUEST_WIFI_CMD_ENTERPRISE_CREDS)
 
NET_MGMT_DEFINE_REQUEST_HANDLER(NET_REQUEST_WIFI_ENTERPRISE_CREDS);
 
#define NET_REQUEST_WIFI_RTS_THRESHOLD_CONFIG                           \
        (_NET_WIFI_BASE | NET_REQUEST_WIFI_CMD_RTS_THRESHOLD_CONFIG)
 
NET_MGMT_DEFINE_REQUEST_HANDLER(NET_REQUEST_WIFI_RTS_THRESHOLD_CONFIG);
 
#define NET_REQUEST_WIFI_WPS_CONFIG (_NET_WIFI_BASE | NET_REQUEST_WIFI_CMD_WPS_CONFIG)
 
NET_MGMT_DEFINE_REQUEST_HANDLER(NET_REQUEST_WIFI_WPS_CONFIG);
#ifdef CONFIG_WIFI_CREDENTIALS_CONNECT_STORED
#define NET_REQUEST_WIFI_CONNECT_STORED (_NET_WIFI_BASE | NET_REQUEST_WIFI_CMD_CONNECT_STORED)
 
NET_MGMT_DEFINE_REQUEST_HANDLER(NET_REQUEST_WIFI_CONNECT_STORED);
#endif
 
#define NET_REQUEST_WIFI_START_ROAMING                          \
        (_NET_WIFI_BASE | NET_REQUEST_WIFI_CMD_START_ROAMING)
 
NET_MGMT_DEFINE_REQUEST_HANDLER(NET_REQUEST_WIFI_START_ROAMING);
 
#define NET_REQUEST_WIFI_NEIGHBOR_REP_COMPLETE                  \
        (_NET_WIFI_BASE | NET_REQUEST_WIFI_CMD_NEIGHBOR_REP_COMPLETE)
 
NET_MGMT_DEFINE_REQUEST_HANDLER(NET_REQUEST_WIFI_NEIGHBOR_REP_COMPLETE);
 
enum net_event_wifi_cmd {
        NET_EVENT_WIFI_CMD_SCAN_RESULT = 1,
        NET_EVENT_WIFI_CMD_SCAN_DONE,
        NET_EVENT_WIFI_CMD_CONNECT_RESULT,
        NET_EVENT_WIFI_CMD_DISCONNECT_RESULT,
        NET_EVENT_WIFI_CMD_IFACE_STATUS,
        NET_EVENT_WIFI_CMD_TWT,
        NET_EVENT_WIFI_CMD_TWT_SLEEP_STATE,
        NET_EVENT_WIFI_CMD_RAW_SCAN_RESULT,
        NET_EVENT_WIFI_CMD_DISCONNECT_COMPLETE,
        NET_EVENT_WIFI_CMD_SIGNAL_CHANGE,
        NET_EVENT_WIFI_CMD_NEIGHBOR_REP_RECEIVED,
        NET_EVENT_WIFI_CMD_NEIGHBOR_REP_COMPLETE,
        NET_EVENT_WIFI_CMD_AP_ENABLE_RESULT,
        NET_EVENT_WIFI_CMD_AP_DISABLE_RESULT,
        NET_EVENT_WIFI_CMD_AP_STA_CONNECTED,
        NET_EVENT_WIFI_CMD_AP_STA_DISCONNECTED,
        NET_EVENT_WIFI_CMD_SUPPLICANT,
};
 
#define NET_EVENT_WIFI_SCAN_RESULT                              \
        (_NET_WIFI_EVENT | NET_EVENT_WIFI_CMD_SCAN_RESULT)
 
#define NET_EVENT_WIFI_SCAN_DONE                                \
        (_NET_WIFI_EVENT | NET_EVENT_WIFI_CMD_SCAN_DONE)
 
#define NET_EVENT_WIFI_CONNECT_RESULT                           \
        (_NET_WIFI_EVENT | NET_EVENT_WIFI_CMD_CONNECT_RESULT)
 
#define NET_EVENT_WIFI_DISCONNECT_RESULT                        \
        (_NET_WIFI_EVENT | NET_EVENT_WIFI_CMD_DISCONNECT_RESULT)
 
#define NET_EVENT_WIFI_IFACE_STATUS                             \
        (_NET_WIFI_EVENT | NET_EVENT_WIFI_CMD_IFACE_STATUS)
 
#define NET_EVENT_WIFI_TWT                                      \
        (_NET_WIFI_EVENT | NET_EVENT_WIFI_CMD_TWT)
 
#define NET_EVENT_WIFI_TWT_SLEEP_STATE                          \
        (_NET_WIFI_EVENT | NET_EVENT_WIFI_CMD_TWT_SLEEP_STATE)
 
#define NET_EVENT_WIFI_RAW_SCAN_RESULT                          \
        (_NET_WIFI_EVENT | NET_EVENT_WIFI_CMD_RAW_SCAN_RESULT)
 
#define NET_EVENT_WIFI_DISCONNECT_COMPLETE                      \
        (_NET_WIFI_EVENT | NET_EVENT_WIFI_CMD_DISCONNECT_COMPLETE)
 
#define NET_EVENT_WIFI_SIGNAL_CHANGE                            \
        (_NET_WIFI_EVENT | NET_EVENT_WIFI_CMD_SIGNAL_CHANGE)
 
#define NET_EVENT_WIFI_NEIGHBOR_REP_COMP                        \
        (_NET_WIFI_EVENT | NET_EVENT_WIFI_CMD_NEIGHBOR_REP_COMPLETE)
 
#define NET_EVENT_WIFI_AP_ENABLE_RESULT                         \
        (_NET_WIFI_EVENT | NET_EVENT_WIFI_CMD_AP_ENABLE_RESULT)
 
#define NET_EVENT_WIFI_AP_DISABLE_RESULT                        \
        (_NET_WIFI_EVENT | NET_EVENT_WIFI_CMD_AP_DISABLE_RESULT)
 
#define NET_EVENT_WIFI_AP_STA_CONNECTED                         \
        (_NET_WIFI_EVENT | NET_EVENT_WIFI_CMD_AP_STA_CONNECTED)
 
#define NET_EVENT_WIFI_AP_STA_DISCONNECTED                      \
        (_NET_WIFI_EVENT | NET_EVENT_WIFI_CMD_AP_STA_DISCONNECTED)
 
struct wifi_version {
        const char *drv_version;
        const char *fw_version;
};
 
struct wifi_band_channel {
        uint8_t band;
        uint8_t channel;
};
 
struct wifi_scan_params {
        enum wifi_scan_type scan_type;
        uint8_t bands;
        uint16_t dwell_time_active;
        uint16_t dwell_time_passive;
        const char *ssids[WIFI_MGMT_SCAN_SSID_FILT_MAX];
        uint16_t max_bss_cnt;
        struct wifi_band_channel band_chan[WIFI_MGMT_SCAN_CHAN_MAX_MANUAL];
};
 
struct wifi_scan_result {
        uint8_t ssid[WIFI_SSID_MAX_LEN + 1];
        uint8_t ssid_length;
        uint8_t band;
        uint8_t channel;
        enum wifi_security_type security;
        enum wifi_mfp_options mfp;
        int8_t rssi;
        uint8_t mac[WIFI_MAC_ADDR_LEN];
        uint8_t mac_length;
};
 
struct wifi_connect_req_params {
        const uint8_t *ssid;
        uint8_t ssid_length; /* Max 32 */
        const uint8_t *psk;
        uint8_t psk_length; /* Min 8 - Max 64 */
        const uint8_t *sae_password;
        uint8_t sae_password_length; /* No length restrictions */
        uint8_t band;
        uint8_t channel;
        enum wifi_security_type security;
        enum wifi_mfp_options mfp;
        uint8_t bssid[WIFI_MAC_ADDR_LEN];
        int timeout;
        const uint8_t *anon_id;
        uint8_t aid_length;
        const uint8_t *key_passwd;
        uint8_t key_passwd_length;
        const uint8_t *key2_passwd;
        uint8_t key2_passwd_length;
        uint8_t suiteb_type;
        uint8_t TLS_cipher;
        int eap_ver;
        const uint8_t *eap_identity;
        uint8_t eap_id_length;
        const uint8_t *eap_password;
        uint8_t eap_passwd_length;
        bool ft_used;
        int nusers;
        uint8_t passwds;
        const uint8_t *identities[WIFI_ENT_IDENTITY_MAX_USERS];
        const uint8_t *passwords[WIFI_ENT_IDENTITY_MAX_USERS];
        uint8_t ignore_broadcast_ssid;
        enum wifi_frequency_bandwidths bandwidth;
};
 
enum wifi_conn_status {
        WIFI_STATUS_CONN_SUCCESS = 0,
        WIFI_STATUS_CONN_FAIL,
        WIFI_STATUS_CONN_WRONG_PASSWORD,
        WIFI_STATUS_CONN_TIMEOUT,
        WIFI_STATUS_CONN_AP_NOT_FOUND,
        WIFI_STATUS_CONN_LAST_STATUS,
        WIFI_STATUS_DISCONN_FIRST_STATUS = WIFI_STATUS_CONN_LAST_STATUS,
};
 
enum wifi_disconn_reason {
        WIFI_REASON_DISCONN_SUCCESS = 0,
        WIFI_REASON_DISCONN_UNSPECIFIED,
        WIFI_REASON_DISCONN_USER_REQUEST,
        WIFI_REASON_DISCONN_AP_LEAVING,
        WIFI_REASON_DISCONN_INACTIVITY,
};
 
enum wifi_ap_status {
        WIFI_STATUS_AP_SUCCESS = 0,
        WIFI_STATUS_AP_FAIL,
        WIFI_STATUS_AP_CHANNEL_NOT_SUPPORTED,
        WIFI_STATUS_AP_CHANNEL_NOT_ALLOWED,
        WIFI_STATUS_AP_SSID_NOT_ALLOWED,
        WIFI_STATUS_AP_AUTH_TYPE_NOT_SUPPORTED,
        WIFI_STATUS_AP_OP_NOT_SUPPORTED,
        WIFI_STATUS_AP_OP_NOT_PERMITTED,
};
 
struct wifi_status {
        union {
                int status;
                enum wifi_conn_status conn_status;
                enum wifi_disconn_reason disconn_reason;
                enum wifi_ap_status ap_status;
        };
};
 
struct wifi_iface_status {
        int state;
        unsigned int ssid_len;
        char ssid[WIFI_SSID_MAX_LEN + 1];
        char bssid[WIFI_MAC_ADDR_LEN];
        enum wifi_frequency_bands band;
        unsigned int channel;
        enum wifi_iface_mode iface_mode;
        enum wifi_link_mode link_mode;
        enum wifi_security_type security;
        enum wifi_mfp_options mfp;
        int rssi;
        unsigned char dtim_period;
        unsigned short beacon_interval;
        bool twt_capable;
        int current_phy_tx_rate;
};
 
struct wifi_ps_params {
        enum wifi_ps enabled;
        unsigned short listen_interval;
        enum wifi_ps_wakeup_mode wakeup_mode;
        enum wifi_ps_mode mode;
        unsigned int timeout_ms;
        enum wifi_ps_param_type type;
        enum wifi_config_ps_param_fail_reason fail_reason;
        enum wifi_ps_exit_strategy exit_strategy;
};
 
struct wifi_twt_params {
        enum wifi_twt_operation operation;
        enum wifi_twt_negotiation_type negotiation_type;
        enum wifi_twt_setup_cmd setup_cmd;
        enum wifi_twt_setup_resp_status resp_status;
        enum wifi_twt_teardown_status teardown_status;
        uint8_t dialog_token;
        uint8_t flow_id;
        union {
                struct {
                        uint64_t twt_interval;
                        bool responder;
                        bool trigger;
                        bool implicit;
                        bool announce;
                        uint32_t twt_wake_interval;
                        uint32_t twt_wake_ahead_duration;
                        bool twt_info_disable;
                        uint8_t twt_exponent;
                        uint16_t twt_mantissa;
                } setup;
                struct {
                        uint16_t sub_id;
                        uint8_t nominal_wake;
                        uint8_t max_sta_support;
                        uint16_t twt_mantissa;
                        uint16_t twt_offset;
                        uint8_t twt_exponent;
                        uint8_t sp_gap;
                } btwt;
                struct {
                        bool teardown_all;
                } teardown;
        };
        enum wifi_twt_fail_reason fail_reason;
};
 
/* Flow ID is only 3 bits */
#define WIFI_MAX_TWT_FLOWS 8
#define WIFI_MAX_TWT_INTERVAL_US (LONG_MAX - 1)
/* 256 (u8) * 1TU */
#define WIFI_MAX_TWT_WAKE_INTERVAL_US 262144
#define WIFI_MAX_TWT_WAKE_AHEAD_DURATION_US (LONG_MAX - 1)
#define WIFI_MAX_TWT_EXPONENT 31
 
struct wifi_twt_flow_info {
        uint64_t  twt_interval;
        uint8_t dialog_token;
        uint8_t flow_id;
        enum wifi_twt_negotiation_type negotiation_type;
        bool responder;
        bool trigger;
        bool implicit;
        bool announce;
        uint32_t twt_wake_interval;
        uint32_t twt_wake_ahead_duration;
};
 
struct wifi_enterprise_creds_params {
        uint8_t *ca_cert;
        uint32_t ca_cert_len;
        uint8_t *client_cert;
        uint32_t client_cert_len;
        uint8_t *client_key;
        uint32_t client_key_len;
        uint8_t *ca_cert2;
        uint32_t ca_cert2_len;
        uint8_t *client_cert2;
        uint32_t client_cert2_len;
        uint8_t *client_key2;
        uint32_t client_key2_len;
        uint8_t *server_cert;
        uint32_t server_cert_len;
        uint8_t *server_key;
        uint32_t server_key_len;
        uint8_t *dh_param;
        uint32_t dh_param_len;
};
 
struct wifi_ps_config {
        char num_twt_flows;
        struct wifi_twt_flow_info twt_flows[WIFI_MAX_TWT_FLOWS];
        struct wifi_ps_params ps_params;
};
 
enum wifi_mgmt_op {
        WIFI_MGMT_GET = 0,
        WIFI_MGMT_SET = 1,
};
 
struct wifi_11k_params {
        enum wifi_mgmt_op oper;
        bool enable_11k;
        uint8_t ssid[WIFI_SSID_MAX_LEN + 1];
};
 
#define MAX_REG_CHAN_NUM  42
 
struct wifi_reg_chan_info {
        unsigned short center_frequency;
        unsigned short max_power:8;
        unsigned short supported:1;
        unsigned short passive_only:1;
        unsigned short dfs:1;
} __packed;
 
struct wifi_reg_domain {
        enum wifi_mgmt_op oper;
        bool force;
        uint8_t country_code[WIFI_COUNTRY_CODE_LEN];
        unsigned int num_channels;
        struct wifi_reg_chan_info *chan_info;
};
 
enum wifi_twt_sleep_state {
        WIFI_TWT_STATE_SLEEP = 0,
        WIFI_TWT_STATE_AWAKE = 1,
};
 
#if defined(CONFIG_WIFI_MGMT_RAW_SCAN_RESULTS) || defined(__DOXYGEN__)
struct wifi_raw_scan_result {
        int8_t rssi;
        int frame_length;
        unsigned short frequency;
        uint8_t data[CONFIG_WIFI_MGMT_RAW_SCAN_RESULT_LENGTH];
};
#endif /* CONFIG_WIFI_MGMT_RAW_SCAN_RESULTS */
 
struct wifi_ap_sta_info {
        enum wifi_link_mode link_mode;
        uint8_t mac[WIFI_MAC_ADDR_LEN];
        uint8_t mac_length;
        bool twt_capable;
};
 
/* for use in max info size calculations */
union wifi_mgmt_events {
        struct wifi_scan_result scan_result;
        struct wifi_status connect_status;
        struct wifi_iface_status iface_status;
#ifdef CONFIG_WIFI_MGMT_RAW_SCAN_RESULTS
        struct wifi_raw_scan_result raw_scan_result;
#endif /* CONFIG_WIFI_MGMT_RAW_SCAN_RESULTS */
        struct wifi_twt_params twt_params;
        struct wifi_ap_sta_info ap_sta_info;
};
 
struct wifi_mode_info {
        uint8_t mode;
        uint8_t if_index;
        enum wifi_mgmt_op oper;
};
 
struct wifi_filter_info {
        uint8_t filter;
        uint8_t if_index;
        uint16_t buffer_size;
        enum wifi_mgmt_op oper;
};
 
struct wifi_channel_info {
        uint16_t channel;
        uint8_t if_index;
        enum wifi_mgmt_op oper;
};
 
#define WIFI_AP_STA_MAX_INACTIVITY (LONG_MAX - 1)
#define WIFI_AP_IEEE_80211_CAPAB_MAX_LEN 64
struct wifi_ap_config_params {
        enum wifi_ap_config_param type;
        uint32_t max_inactivity;
        uint32_t max_num_sta;
        enum wifi_frequency_bandwidths bandwidth;
#if defined(CONFIG_WIFI_NM_HOSTAPD_AP)
        char ht_capab[WIFI_AP_IEEE_80211_CAPAB_MAX_LEN + 1];
        char vht_capab[WIFI_AP_IEEE_80211_CAPAB_MAX_LEN + 1];
#endif
};
 
#ifdef CONFIG_WIFI_NM_WPA_SUPPLICANT_DPP
#define WIFI_DPP_QRCODE_MAX_LEN 255
 
enum wifi_dpp_op {
        WIFI_DPP_OP_INVALID = 0,
        WIFI_DPP_CONFIGURATOR_ADD,
        WIFI_DPP_AUTH_INIT,
        WIFI_DPP_QR_CODE,
        WIFI_DPP_CHIRP,
        WIFI_DPP_LISTEN,
        WIFI_DPP_BOOTSTRAP_GEN,
        WIFI_DPP_BOOTSTRAP_GET_URI,
        WIFI_DPP_SET_CONF_PARAM,
        WIFI_DPP_SET_WAIT_RESP_TIME,
        WIFI_DPP_RECONFIG
};
 
enum wifi_dpp_curves {
        WIFI_DPP_CURVES_DEFAULT = 0,
        WIFI_DPP_CURVES_P_256,
        WIFI_DPP_CURVES_P_384,
        WIFI_DPP_CURVES_P_512,
        WIFI_DPP_CURVES_BP_256,
        WIFI_DPP_CURVES_BP_384,
        WIFI_DPP_CURVES_BP_512
};
 
enum wifi_dpp_role {
        WIFI_DPP_ROLE_UNSET = 0,
        WIFI_DPP_ROLE_CONFIGURATOR,
        WIFI_DPP_ROLE_ENROLLEE,
        WIFI_DPP_ROLE_EITHER
};
 
enum wifi_dpp_conf {
        WIFI_DPP_CONF_UNSET = 0,
        WIFI_DPP_CONF_STA,
        WIFI_DPP_CONF_AP,
        WIFI_DPP_CONF_QUERY
};
 
enum wifi_dpp_bootstrap_type {
        WIFI_DPP_BOOTSTRAP_TYPE_UNSET = 0,
        WIFI_DPP_BOOTSTRAP_TYPE_QRCODE,
        WIFI_DPP_BOOTSTRAP_TYPE_PKEX,
        WIFI_DPP_BOOTSTRAP_TYPE_NFC_URI
};
 
struct wifi_dpp_configurator_add_params {
        int curve;
        int net_access_key_curve;
};
 
struct wifi_dpp_auth_init_params {
        int peer;
        int configurator;
        int role;
        int conf;
        char ssid[WIFI_SSID_MAX_LEN + 1];
};
 
struct wifi_dpp_chirp_params {
        int id;
        int freq;
};
 
struct wifi_dpp_listen_params {
        int freq;
        int role;
};
 
struct wifi_dpp_bootstrap_gen_params {
        int type;
        int op_class;
        int chan;
        int curve;
        uint8_t mac[WIFI_MAC_ADDR_LEN];
};
 
struct wifi_dpp_configurator_set_params {
        int peer;
        int configurator;
        int role;
        int conf;
        int curve;
        int net_access_key_curve;
        char ssid[WIFI_SSID_MAX_LEN + 1];
};
 
struct wifi_dpp_params {
        int action;
        union {
                struct wifi_dpp_configurator_add_params configurator_add;
                struct wifi_dpp_auth_init_params auth_init;
                struct wifi_dpp_chirp_params chirp;
                struct wifi_dpp_listen_params listen;
                struct wifi_dpp_bootstrap_gen_params bootstrap_gen;
                struct wifi_dpp_configurator_set_params configurator_set;
                int id;
                int dpp_resp_wait_time;
                int network_id;
                uint8_t dpp_qr_code[WIFI_DPP_QRCODE_MAX_LEN + 1];
                char resp[WIFI_DPP_QRCODE_MAX_LEN + 1];
        };
};
#endif /* CONFIG_WIFI_NM_WPA_SUPPLICANT_DPP */
 
#define WIFI_WPS_PIN_MAX_LEN 8
 
enum wifi_wps_op {
        WIFI_WPS_PBC = 0,
        WIFI_WPS_PIN_GET = 1,
        WIFI_WPS_PIN_SET = 2,
};
 
struct wifi_wps_config_params {
        enum wifi_wps_op oper;
        char pin[WIFI_WPS_PIN_MAX_LEN + 1];
};
 
enum wifi_sap_iface_state {
        WIFI_SAP_IFACE_UNINITIALIZED,
        WIFI_SAP_IFACE_DISABLED,
        WIFI_SAP_IFACE_COUNTRY_UPDATE,
        WIFI_SAP_IFACE_ACS,
        WIFI_SAP_IFACE_HT_SCAN,
        WIFI_SAP_IFACE_DFS,
        WIFI_SAP_IFACE_NO_IR,
        WIFI_SAP_IFACE_ENABLED
};
 
/* Extended Capabilities */
enum wifi_ext_capab {
        WIFI_EXT_CAPAB_20_40_COEX = 0,
        WIFI_EXT_CAPAB_GLK = 1,
        WIFI_EXT_CAPAB_EXT_CHAN_SWITCH = 2,
        WIFI_EXT_CAPAB_TIM_BROADCAST = 18,
        WIFI_EXT_CAPAB_BSS_TRANSITION = 19,
};
 
#include <zephyr/net/net_if.h>
 
typedef void (*scan_result_cb_t)(struct net_if *iface, int status,
                                 struct wifi_scan_result *entry);
 
#ifdef CONFIG_WIFI_MGMT_RAW_SCAN_RESULTS
typedef void (*raw_scan_result_cb_t)(struct net_if *iface, int status,
                                     struct wifi_raw_scan_result *entry);
#endif /* CONFIG_WIFI_MGMT_RAW_SCAN_RESULTS */
 
struct wifi_mgmt_ops {
        int (*scan)(const struct device *dev,
                    struct wifi_scan_params *params,
                    scan_result_cb_t cb);
        int (*connect)(const struct device *dev,
                       struct wifi_connect_req_params *params);
        int (*disconnect)(const struct device *dev);
        int (*ap_enable)(const struct device *dev,
                         struct wifi_connect_req_params *params);
        int (*ap_disable)(const struct device *dev);
        int (*ap_sta_disconnect)(const struct device *dev, const uint8_t *mac);
        int (*iface_status)(const struct device *dev, struct wifi_iface_status *status);
#if defined(CONFIG_NET_STATISTICS_WIFI) || defined(__DOXYGEN__)
        int (*get_stats)(const struct device *dev, struct net_stats_wifi *stats);
        int (*reset_stats)(const struct device *dev);
#endif /* CONFIG_NET_STATISTICS_WIFI */
        int (*cfg_11k)(const struct device *dev, struct wifi_11k_params *params);
        int (*send_11k_neighbor_request)(const struct device *dev, struct wifi_11k_params *params);
        int (*set_power_save)(const struct device *dev, struct wifi_ps_params *params);
        int (*set_twt)(const struct device *dev, struct wifi_twt_params *params);
        int (*set_btwt)(const struct device *dev, struct wifi_twt_params *params);
        int (*get_power_save_config)(const struct device *dev, struct wifi_ps_config *config);
        int (*reg_domain)(const struct device *dev, struct wifi_reg_domain *reg_domain);
        int (*filter)(const struct device *dev, struct wifi_filter_info *filter);
        int (*mode)(const struct device *dev, struct wifi_mode_info *mode);
        int (*channel)(const struct device *dev, struct wifi_channel_info *channel);
#ifdef CONFIG_WIFI_NM_WPA_SUPPLICANT_WNM
        int (*btm_query)(const struct device *dev, uint8_t reason);
#endif
        int (*bss_ext_capab)(const struct device *dev, int capab);
 
        int (*legacy_roam)(const struct device *dev);
 
        int (*get_version)(const struct device *dev, struct wifi_version *params);
        int (*get_conn_params)(const struct device *dev, struct wifi_connect_req_params *params);
        int (*set_rts_threshold)(const struct device *dev, unsigned int rts_threshold);
        int (*ap_config_params)(const struct device *dev, struct wifi_ap_config_params *params);
 
#ifdef CONFIG_WIFI_NM_WPA_SUPPLICANT_DPP
        int (*dpp_dispatch)(const struct device *dev, struct wifi_dpp_params *params);
#endif /* CONFIG_WIFI_NM_WPA_SUPPLICANT_DPP */
        int (*pmksa_flush)(const struct device *dev);
#ifdef CONFIG_WIFI_NM_WPA_SUPPLICANT_CRYPTO_ENTERPRISE
        int (*enterprise_creds)(const struct device *dev,
                        struct wifi_enterprise_creds_params *creds);
#endif
        int (*get_rts_threshold)(const struct device *dev, unsigned int *rts_threshold);
        int (*wps_config)(const struct device *dev, struct wifi_wps_config_params *params);
        int (*candidate_scan)(const struct device *dev, struct wifi_scan_params *params);
        int (*start_11r_roaming)(const struct device *dev);
};
 
struct net_wifi_mgmt_offload {
#if defined(CONFIG_WIFI_USE_NATIVE_NETWORKING) || defined(__DOXYGEN__)
        struct ethernet_api wifi_iface;
#else
        struct offloaded_if_api wifi_iface;
#endif
        const struct wifi_mgmt_ops *const wifi_mgmt_api;
 
#if defined(CONFIG_WIFI_NM_WPA_SUPPLICANT) || defined(__DOXYGEN__)
        const void *wifi_drv_ops;
#endif
};
 
#if defined(CONFIG_WIFI_NM_WPA_SUPPLICANT)
/* Make sure wifi_drv_ops is after wifi_mgmt_api */
BUILD_ASSERT(offsetof(struct net_wifi_mgmt_offload, wifi_mgmt_api) <
             offsetof(struct net_wifi_mgmt_offload, wifi_drv_ops));
#endif
 
/* Make sure that the network interface API is properly setup inside
 * Wifi mgmt offload API struct (it is the first one).
 */
BUILD_ASSERT(offsetof(struct net_wifi_mgmt_offload, wifi_iface) == 0);
 
void wifi_mgmt_raise_connect_result_event(struct net_if *iface, int status);
 
void wifi_mgmt_raise_disconnect_result_event(struct net_if *iface, int status);
 
void wifi_mgmt_raise_iface_status_event(struct net_if *iface,
                struct wifi_iface_status *iface_status);
 
void wifi_mgmt_raise_twt_event(struct net_if *iface,
                struct wifi_twt_params *twt_params);
 
void wifi_mgmt_raise_twt_sleep_state(struct net_if *iface, int twt_sleep_state);
 
#if defined(CONFIG_WIFI_MGMT_RAW_SCAN_RESULTS) || defined(__DOXYGEN__)
void wifi_mgmt_raise_raw_scan_result_event(struct net_if *iface,
                struct wifi_raw_scan_result *raw_scan_info);
#endif /* CONFIG_WIFI_MGMT_RAW_SCAN_RESULTS */
 
void wifi_mgmt_raise_disconnect_complete_event(struct net_if *iface, int status);
 
#ifdef CONFIG_WIFI_NM_WPA_SUPPLICANT_ROAMING
void wifi_mgmt_raise_neighbor_rep_recv_event(struct net_if *iface,
                                             char *inbuf, size_t buf_len);
#endif
 
void wifi_mgmt_raise_ap_enable_result_event(struct net_if *iface, enum wifi_ap_status status);
 
void wifi_mgmt_raise_ap_disable_result_event(struct net_if *iface, enum wifi_ap_status status);
 
void wifi_mgmt_raise_ap_sta_connected_event(struct net_if *iface,
                struct wifi_ap_sta_info *sta_info);
 
void wifi_mgmt_raise_ap_sta_disconnected_event(struct net_if *iface,
                struct wifi_ap_sta_info *sta_info);
 
#ifdef __cplusplus
}
#endif
 
#endif /* ZEPHYR_INCLUDE_NET_WIFI_MGMT_H_ */