wifi_mgmt.h

Go to the documentation of this file.

/*
 * Copyright (c) 2017 Intel Corporation.
 *
 * 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 */
 
#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_IFACE_STATUS,
        NET_REQUEST_WIFI_CMD_PS,
        NET_REQUEST_WIFI_CMD_TWT,
        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_RTS_THRESHOLD,
        NET_REQUEST_WIFI_CMD_AP_CONFIG_PARAM,
        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_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_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_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_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);
 
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_AP_ENABLE_RESULT,
        NET_EVENT_WIFI_CMD_AP_DISABLE_RESULT,
        NET_EVENT_WIFI_CMD_AP_STA_CONNECTED,
        NET_EVENT_WIFI_CMD_AP_STA_DISCONNECTED,
};
 
#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_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];
        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;
};
 
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];
        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;
};
 
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;
};
 
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;
                } setup;
                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)
 
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_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,
};
 
#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)
struct wifi_ap_config_params {
        enum wifi_ap_config_param type;
        uint32_t max_inactivity;
        uint32_t max_num_sta;
};
 
#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);
#endif /* CONFIG_NET_STATISTICS_WIFI */
        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 (*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);
        int (*get_version)(const struct device *dev, struct wifi_version *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);
};
 
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__)
        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);
 
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_ */