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   NET_MGMT_LAYER_CODE_WIFI
#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)
 
#ifdef CONFIG_WIFI_NM_WPA_SUPPLICANT_NAN
#define WIFI_NAN_MAX_SSI_LEN            CONFIG_WIFI_NAN_MAX_SSI_LEN
#define WIFI_NAN_MAX_SERVICE_NAME_LEN   64
/* Holds multi-line NAN_STATUS output from hostap. */
#define WIFI_NAN_RESP_SIZE              512
#define WIFI_NAN_MAX_SET_PARAM_LEN      32
#define WIFI_NAN_MAX_SET_VALUE_LEN      256
#endif /* CONFIG_WIFI_NM_WPA_SUPPLICANT_NAN */

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_CONFIG_PARAM,
        NET_REQUEST_WIFI_CMD_DPP,
        NET_REQUEST_WIFI_CMD_NAN,
        NET_REQUEST_WIFI_CMD_BTM_QUERY,
        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_BSS_MAX_IDLE_PERIOD,
        NET_REQUEST_WIFI_CMD_BGSCAN,
        NET_REQUEST_WIFI_CMD_P2P_OPER,
        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);

#define NET_REQUEST_WIFI_CONFIG_PARAM         \
        (NET_WIFI_BASE | NET_REQUEST_WIFI_CMD_CONFIG_PARAM)
 
NET_MGMT_DEFINE_REQUEST_HANDLER(NET_REQUEST_WIFI_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_NAN
#define NET_REQUEST_WIFI_NAN                    \
        (NET_WIFI_BASE | NET_REQUEST_WIFI_CMD_NAN)
 
NET_MGMT_DEFINE_REQUEST_HANDLER(NET_REQUEST_WIFI_NAN);
#endif /* CONFIG_WIFI_NM_WPA_SUPPLICANT_NAN */

#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);

#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);

#define NET_REQUEST_WIFI_BSS_MAX_IDLE_PERIOD                            \
        (NET_WIFI_BASE | NET_REQUEST_WIFI_CMD_BSS_MAX_IDLE_PERIOD)
 
NET_MGMT_DEFINE_REQUEST_HANDLER(NET_REQUEST_WIFI_BSS_MAX_IDLE_PERIOD);

#define NET_REQUEST_WIFI_BGSCAN                                 \
        (NET_WIFI_BASE | NET_REQUEST_WIFI_CMD_BGSCAN)
 
NET_MGMT_DEFINE_REQUEST_HANDLER(NET_REQUEST_WIFI_BGSCAN);

#define NET_REQUEST_WIFI_P2P_OPER                                               \
        (NET_WIFI_BASE | NET_REQUEST_WIFI_CMD_P2P_OPER)
 
NET_MGMT_DEFINE_REQUEST_HANDLER(NET_REQUEST_WIFI_P2P_OPER);

 
enum {
        NET_EVENT_WIFI_CMD_SCAN_RESULT_VAL,
        NET_EVENT_WIFI_CMD_SCAN_DONE_VAL,
        NET_EVENT_WIFI_CMD_CONNECT_RESULT_VAL,
        NET_EVENT_WIFI_CMD_DISCONNECT_RESULT_VAL,
        NET_EVENT_WIFI_CMD_IFACE_STATUS_VAL,
        NET_EVENT_WIFI_CMD_TWT_VAL,
        NET_EVENT_WIFI_CMD_TWT_SLEEP_STATE_VAL,
        NET_EVENT_WIFI_CMD_RAW_SCAN_RESULT_VAL,
        NET_EVENT_WIFI_CMD_DISCONNECT_COMPLETE_VAL,
        NET_EVENT_WIFI_CMD_SIGNAL_CHANGE_VAL,
        NET_EVENT_WIFI_CMD_NEIGHBOR_REP_RECEIVED_VAL,
        NET_EVENT_WIFI_CMD_NEIGHBOR_REP_COMPLETE_VAL,
        NET_EVENT_WIFI_CMD_AP_ENABLE_RESULT_VAL,
        NET_EVENT_WIFI_CMD_AP_DISABLE_RESULT_VAL,
        NET_EVENT_WIFI_CMD_AP_STA_CONNECTED_VAL,
        NET_EVENT_WIFI_CMD_AP_STA_DISCONNECTED_VAL,
        NET_EVENT_WIFI_CMD_SUPPLICANT_VAL,
        NET_EVENT_WIFI_CMD_P2P_DEVICE_FOUND_VAL,
        NET_EVENT_WIFI_CMD_NAN_DISCOVERY_RESULT_VAL,
        NET_EVENT_WIFI_CMD_NAN_REPLIED_VAL,
        NET_EVENT_WIFI_CMD_NAN_PUBLISH_TERMINATED_VAL,
        NET_EVENT_WIFI_CMD_NAN_SUBSCRIBE_TERMINATED_VAL,
        NET_EVENT_WIFI_CMD_NAN_RECEIVE_VAL,
 
        NET_EVENT_WIFI_CMD_MAX,
};
 
BUILD_ASSERT(NET_EVENT_WIFI_CMD_MAX <= NET_MGMT_MAX_COMMANDS,
             "Number of events in net_event_wifi_cmd exceeds the limit");


enum net_event_wifi_cmd {
        NET_MGMT_CMD(NET_EVENT_WIFI_CMD_SCAN_RESULT),
        NET_MGMT_CMD(NET_EVENT_WIFI_CMD_SCAN_DONE),
        NET_MGMT_CMD(NET_EVENT_WIFI_CMD_CONNECT_RESULT),
        NET_MGMT_CMD(NET_EVENT_WIFI_CMD_DISCONNECT_RESULT),
        NET_MGMT_CMD(NET_EVENT_WIFI_CMD_IFACE_STATUS),
        NET_MGMT_CMD(NET_EVENT_WIFI_CMD_TWT),
        NET_MGMT_CMD(NET_EVENT_WIFI_CMD_TWT_SLEEP_STATE),
        NET_MGMT_CMD(NET_EVENT_WIFI_CMD_RAW_SCAN_RESULT),
        NET_MGMT_CMD(NET_EVENT_WIFI_CMD_DISCONNECT_COMPLETE),
        NET_MGMT_CMD(NET_EVENT_WIFI_CMD_SIGNAL_CHANGE),
        NET_MGMT_CMD(NET_EVENT_WIFI_CMD_NEIGHBOR_REP_RECEIVED),
        NET_MGMT_CMD(NET_EVENT_WIFI_CMD_NEIGHBOR_REP_COMPLETE),
        NET_MGMT_CMD(NET_EVENT_WIFI_CMD_AP_ENABLE_RESULT),
        NET_MGMT_CMD(NET_EVENT_WIFI_CMD_AP_DISABLE_RESULT),
        NET_MGMT_CMD(NET_EVENT_WIFI_CMD_AP_STA_CONNECTED),
        NET_MGMT_CMD(NET_EVENT_WIFI_CMD_AP_STA_DISCONNECTED),
        NET_MGMT_CMD(NET_EVENT_WIFI_CMD_SUPPLICANT),
        NET_MGMT_CMD(NET_EVENT_WIFI_CMD_P2P_DEVICE_FOUND),
#ifdef CONFIG_WIFI_NM_WPA_SUPPLICANT_NAN
        NET_MGMT_CMD(NET_EVENT_WIFI_CMD_NAN_DISCOVERY_RESULT),
        NET_MGMT_CMD(NET_EVENT_WIFI_CMD_NAN_REPLIED),
        NET_MGMT_CMD(NET_EVENT_WIFI_CMD_NAN_PUBLISH_TERMINATED),
        NET_MGMT_CMD(NET_EVENT_WIFI_CMD_NAN_SUBSCRIBE_TERMINATED),
        NET_MGMT_CMD(NET_EVENT_WIFI_CMD_NAN_RECEIVE),
#endif
};

#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)

#define NET_EVENT_WIFI_P2P_DEVICE_FOUND                         \
        (NET_WIFI_EVENT | NET_EVENT_WIFI_CMD_P2P_DEVICE_FOUND)
 
#ifdef CONFIG_WIFI_NM_WPA_SUPPLICANT_P2P
#define WIFI_P2P_DEVICE_NAME_MAX_LEN 32
#define WIFI_P2P_PRI_DEV_TYPE_SIZE 8
#define WIFI_P2P_PRI_DEV_TYPE_STR_MAX_LEN 32
#define WIFI_P2P_CONFIG_METHODS_STR_MAX_LEN 16
#define WIFI_P2P_MANUFACTURER_MAX_LEN 64
#define WIFI_P2P_MODEL_NAME_MAX_LEN 32

struct wifi_p2p_device_info {
        uint8_t mac[WIFI_MAC_ADDR_LEN];
        char device_name[WIFI_P2P_DEVICE_NAME_MAX_LEN + 1];
        uint8_t pri_dev_type[WIFI_P2P_PRI_DEV_TYPE_SIZE];
        char pri_dev_type_str[WIFI_P2P_PRI_DEV_TYPE_STR_MAX_LEN];
        int8_t rssi;
        uint16_t config_methods;
        char config_methods_str[WIFI_P2P_CONFIG_METHODS_STR_MAX_LEN];
        uint8_t dev_capab;
        uint8_t group_capab;
        char manufacturer[WIFI_P2P_MANUFACTURER_MAX_LEN + 1];
        char model_name[WIFI_P2P_MODEL_NAME_MAX_LEN + 1];
};
#endif /* CONFIG_WIFI_NM_WPA_SUPPLICANT_P2P */
 
#ifdef CONFIG_WIFI_NM_WPA_SUPPLICANT_NAN
#define NET_EVENT_WIFI_NAN_DISCOVERY_RESULT                     \
        (NET_WIFI_EVENT | NET_EVENT_WIFI_CMD_NAN_DISCOVERY_RESULT)

#define NET_EVENT_WIFI_NAN_REPLIED                              \
        (NET_WIFI_EVENT | NET_EVENT_WIFI_CMD_NAN_REPLIED)

#define NET_EVENT_WIFI_NAN_PUBLISH_TERMINATED                   \
        (NET_WIFI_EVENT | NET_EVENT_WIFI_CMD_NAN_PUBLISH_TERMINATED)

#define NET_EVENT_WIFI_NAN_SUBSCRIBE_TERMINATED                 \
        (NET_WIFI_EVENT | NET_EVENT_WIFI_CMD_NAN_SUBSCRIBE_TERMINATED)

#define NET_EVENT_WIFI_NAN_RECEIVE                              \
        (NET_WIFI_EVENT | NET_EVENT_WIFI_CMD_NAN_RECEIVE)
#endif /* CONFIG_WIFI_NM_WPA_SUPPLICANT_NAN */

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_wpa3_enterprise_type wpa3_ent_type;
        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 */
        bool psk_is_pbkdf2;
        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;

        enum wifi_wpa3_enterprise_type wpa3_ent_mode;

        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 verify_peer_cert;

        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;

        const uint8_t *server_cert_domain_exact;
        uint8_t server_cert_domain_exact_len;

        const uint8_t *server_cert_domain_suffix;
        uint8_t server_cert_domain_suffix_len;
        uint8_t ssid_protection;
        uint8_t transition_disable;
};

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,
};

const char *wifi_disconn_reason_txt(enum wifi_disconn_reason reason);

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;
        };
        uint16_t status_code;
        uint16_t reason_code;
};

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_wpa3_enterprise_type wpa3_ent_type;
        enum wifi_security_type security;
        enum wifi_wep_key_type wep_key_type;
        enum wifi_mfp_options mfp;
        int rssi;
        unsigned char dtim_period;
        unsigned short beacon_interval;
        bool twt_capable;
        float 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;
};

#define WIFI_BTWT_AGREEMENT_MAX 5

struct wifi_btwt_params {
        uint8_t btwt_id;
        uint16_t btwt_mantissa;
        uint8_t btwt_exponent;
        uint8_t btwt_nominal_wake;
};

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 {
                        uint8_t btwt_sta_wait;
                        uint16_t btwt_offset;
                        uint8_t btwt_li;
                        uint8_t btwt_count;
                        struct wifi_btwt_params btwt_set_cfg[WIFI_BTWT_AGREEMENT_MAX];
                } 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
/* The TWT interval is encoded per IEEE 802.11 as mantissa * 2^exponent
 * micro-seconds, with a 16-bit mantissa and a 5-bit exponent. The maximum
 * representable interval is therefore UINT16_MAX * 2^WIFI_MAX_TWT_EXPONENT us.
 */
#define WIFI_MAX_TWT_EXPONENT 31
#define WIFI_MAX_TWT_INTERVAL_US ((uint64_t)UINT16_MAX << WIFI_MAX_TWT_EXPONENT)
/* 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_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;
};
 
#ifdef CONFIG_WIFI_NM_WPA_SUPPLICANT_NAN
struct wifi_nan_discovery_result_event {
        uint8_t subscribe_id;
        uint8_t publish_id;
        uint8_t peer_addr[WIFI_MAC_ADDR_LEN];
        bool fsd;
        bool fsd_gas;
        uint8_t srv_proto_type;
        size_t ssi_len;
        uint8_t ssi[WIFI_NAN_MAX_SSI_LEN];
};

struct wifi_nan_replied_event {
        uint8_t publish_id;
        uint8_t peer_addr[WIFI_MAC_ADDR_LEN];
        uint8_t subscribe_id;
        uint8_t srv_proto_type;
        size_t ssi_len;
        uint8_t ssi[WIFI_NAN_MAX_SSI_LEN];
};

struct wifi_nan_terminated_event {
        uint8_t id;
        char reason[32];
};

struct wifi_nan_receive_event {
        uint8_t id;
        uint8_t peer_instance_id;
        uint8_t peer_addr[WIFI_MAC_ADDR_LEN];
        uint8_t ssi[WIFI_NAN_MAX_SSI_LEN];
        size_t ssi_len;
};
#endif /* CONFIG_WIFI_NM_WPA_SUPPLICANT_NAN */

 
/* 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;
#ifdef CONFIG_WIFI_NM_WPA_SUPPLICANT_P2P
        struct wifi_p2p_device_info p2p_device_info;
#endif
#ifdef CONFIG_WIFI_NM_WPA_SUPPLICANT_NAN
        struct wifi_nan_discovery_result_event nan_discovery_result;
        struct wifi_nan_replied_event nan_replied;
        struct wifi_nan_terminated_event nan_publish_terminated;
        struct wifi_nan_terminated_event nan_subscribe_terminated;
        struct wifi_nan_receive_event nan_receive;
#endif /* CONFIG_WIFI_NM_WPA_SUPPLICANT_NAN */
};


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;
        enum wifi_frequency_bands band;
        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
};

struct wifi_config_params {
        enum wifi_config_param type;
        int okc;
};
 
#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 */
 
#ifdef CONFIG_WIFI_NM_WPA_SUPPLICANT_NAN
enum wifi_nan_operation {
        WIFI_NAN_OP_START,
        WIFI_NAN_OP_STOP,
        WIFI_NAN_OP_SET,
        WIFI_NAN_OP_UPDATE_CONF,
        WIFI_NAN_OP_STATUS,
        WIFI_NAN_OP_PUBLISH,
        WIFI_NAN_OP_CANCEL_PUBLISH,
        WIFI_NAN_OP_UPDATE_PUBLISH,
        WIFI_NAN_OP_SUBSCRIBE,
        WIFI_NAN_OP_CANCEL_SUBSCRIBE,
        WIFI_NAN_OP_TRANSMIT,
};

enum wifi_nan_service_protocol_type {
        WIFI_NAN_SRV_PROTO_BONJOUR = 1,
        WIFI_NAN_SRV_PROTO_GENERIC = 2,
        WIFI_NAN_SRV_PROTO_CSA_MATTER = 3,
};

struct wifi_nan_publish_params {
        /* Service name for NAN */
        char service_name[WIFI_NAN_MAX_SERVICE_NAME_LEN];
        /* NAN service protocol type */
        enum wifi_nan_service_protocol_type srv_proto_type;
        /* Time to live (in seconds); 0 = one TX only */
        uint32_t ttl;
        /* Default frequency in MHz (defaultPublishChannel) */
        uint32_t freq;
        /* Multi-channel frequencies */
        char freq_list[64];
        /* Service specific information (binary data) */
        uint8_t ssi[WIFI_NAN_MAX_SSI_LEN];
        /* Actual length of SSI data */
        uint16_t ssi_len;
        /* Unsolicited transmission (true by default) */
        bool unsolicited;
        /* Solicited transmission (true by default) */
        bool solicited;
        /* Further Service Discovery (true by default) */
        bool fsd;
};
 
/* This structure is used to configure nan update publish parameters */
struct wifi_nan_update_publish_params {
        uint8_t publish_id;
        /* Service specific information (binary data) */
        uint8_t ssi[WIFI_NAN_MAX_SSI_LEN];
        /* Actual length of SSI data */
        uint16_t ssi_len;
};

struct wifi_nan_subscribe_params {
        /* Service name for NAN */
        char service_name[WIFI_NAN_MAX_SERVICE_NAME_LEN];
        /* NAN service protocol type */
        enum wifi_nan_service_protocol_type srv_proto_type;
        /* Subscribe type */
        bool active;
        /* Time to live (in seconds); 0 = until first result */
        unsigned int ttl;
        /* Selected frequency in MHz */
        unsigned int freq;
        /* Service specific information (binary data) */
        uint8_t ssi[WIFI_NAN_MAX_SSI_LEN];
        /* Actual length of SSI data */
        uint16_t ssi_len;
};

struct wifi_nan_transmit_params {
        /* publish_id or subscribe_id */
        uint8_t handle;
        /* peer publish_id or subscribe_id */
        uint8_t req_instance_id;
        /* peer MAC address */
        uint8_t peer_addr[WIFI_MAC_ADDR_LEN];
        /* Service specific information (binary data) */
        uint8_t ssi[WIFI_NAN_MAX_SSI_LEN];
        /* Actual length of SSI data */
        uint16_t ssi_len;
};

struct wifi_nan_set_params {
        char param[WIFI_NAN_MAX_SET_PARAM_LEN];
        char value[WIFI_NAN_MAX_SET_VALUE_LEN];
};

struct wifi_nan_params {
        enum wifi_nan_operation op;

        union {
                struct wifi_nan_publish_params publish;
                struct wifi_nan_update_publish_params update_publish;
                struct wifi_nan_subscribe_params subscribe;
                struct wifi_nan_transmit_params transmit;
                struct wifi_nan_set_params set;
                uint8_t cancel_id;
        };
 
        /* Operation response */
        char resp[WIFI_NAN_RESP_SIZE];
};
 
#endif /* CONFIG_WIFI_NM_WPA_SUPPLICANT_NAN */
 

#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];
};
 
#ifdef CONFIG_WIFI_NM_WPA_SUPPLICANT_P2P
enum wifi_p2p_op {
        WIFI_P2P_FIND = 0,
        WIFI_P2P_STOP_FIND,
        WIFI_P2P_PEER,
        WIFI_P2P_CONNECT,
        WIFI_P2P_GROUP_ADD,
        WIFI_P2P_GROUP_REMOVE,
        WIFI_P2P_INVITE,
        WIFI_P2P_POWER_SAVE,
        WIFI_P2P_LIST_NETWORKS,
        WIFI_P2P_PERSISTENT_REMOVE,
        WIFI_P2P_SET_DEV_NAME,
        WIFI_P2P_STATUS,
};

enum wifi_p2p_discovery_type {
        WIFI_P2P_FIND_START_WITH_FULL = 0,
        WIFI_P2P_FIND_ONLY_SOCIAL,
        WIFI_P2P_FIND_PROGRESSIVE,
};

enum wifi_p2p_connection_method {
        WIFI_P2P_METHOD_PBC = 0,
        WIFI_P2P_METHOD_DISPLAY,
        WIFI_P2P_METHOD_KEYPAD,
};

#define WIFI_P2P_MAX_PEERS CONFIG_WIFI_P2P_MAX_PEERS
#define WIFI_P2P_LIST_NETWORKS_BUF_SIZE 2048
#define WIFI_P2P_STATUS_BUF_SIZE 512

struct wifi_p2p_params {
        enum wifi_p2p_op oper;
        char device_name[WIFI_P2P_DEVICE_NAME_MAX_LEN + 1];
        enum wifi_p2p_discovery_type discovery_type;
        uint16_t timeout;
        uint8_t peer_addr[WIFI_MAC_ADDR_LEN];
        bool discovered_only;
        struct wifi_p2p_device_info *peers;
        uint16_t peer_count;
        bool power_save;
        struct {
                enum wifi_p2p_connection_method method;
                char pin[WIFI_WPS_PIN_MAX_LEN + 1];
                uint8_t go_intent;
                unsigned int freq;
                bool join;
                bool persistent_set;
        } connect;
        struct {
                int freq;
                int persistent;
                bool persistent_set;
                bool ht40;
                bool vht;
                bool he;
                bool edmg;
                uint8_t go_bssid[WIFI_MAC_ADDR_LEN];
                uint8_t go_bssid_length;
        } group_add;
        struct {
                char ifname[CONFIG_NET_INTERFACE_NAME_LEN + 1];
        } group_remove;
        struct {
                enum {
                        WIFI_P2P_INVITE_PERSISTENT = 0,
                        WIFI_P2P_INVITE_GROUP,
                } type;
                int persistent_id;
                char group_ifname[CONFIG_NET_INTERFACE_NAME_LEN + 1];
                uint8_t peer_addr[WIFI_MAC_ADDR_LEN];
                int freq;
                uint8_t go_dev_addr[WIFI_MAC_ADDR_LEN];
                uint8_t go_dev_addr_length;
        } invite;
        struct {
                char *buf;
                size_t buf_size;
        } list_networks;
        struct {
                int id;
        } persistent_remove;
        struct {
                char *buf;
                size_t buf_size;
        } status;
};
#endif /* CONFIG_WIFI_NM_WPA_SUPPLICANT_P2P */

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
};
 
#if defined(CONFIG_WIFI_NM_WPA_SUPPLICANT_BGSCAN) || defined(__DOXYGEN__)
enum wifi_bgscan_type {
        WIFI_BGSCAN_NONE = 0,
        WIFI_BGSCAN_SIMPLE,
        WIFI_BGSCAN_LEARN,
};

struct wifi_bgscan_params {
        enum wifi_bgscan_type type;
        uint16_t short_interval;
        uint16_t long_interval;
        int8_t rssi_threshold;
        uint16_t btm_queries;
};
#endif

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 net_if *iface,
                    struct wifi_scan_params *params,
                    scan_result_cb_t cb);
        int (*connect)(const struct device *dev,
                       struct net_if *iface,
                       struct wifi_connect_req_params *params);
        int (*disconnect)(const struct device *dev,
                          struct net_if *iface);
        int (*ap_enable)(const struct device *dev,
                         struct net_if *iface,
                         struct wifi_connect_req_params *params);
        int (*ap_disable)(const struct device *dev, struct net_if *iface);
        int (*ap_sta_disconnect)(const struct device *dev, struct net_if *iface,
                                 const uint8_t *mac);
        int (*iface_status)(const struct device *dev,
                            struct net_if *iface,
                            struct wifi_iface_status *status);
#if defined(CONFIG_NET_STATISTICS_WIFI) || defined(__DOXYGEN__)
        int (*get_stats)(const struct device *dev,
                         struct net_if *iface,
                         struct net_stats_wifi *stats);
        int (*reset_stats)(const struct device *dev, struct net_if *iface);
#endif /* CONFIG_NET_STATISTICS_WIFI */
        int (*cfg_11k)(const struct device *dev,
                       struct net_if *iface,
                       struct wifi_11k_params *params);
        int (*send_11k_neighbor_request)(const struct device *dev,
                                         struct net_if *iface,
                                         struct wifi_11k_params *params);
        int (*set_power_save)(const struct device *dev,
                              struct net_if *iface,
                              struct wifi_ps_params *params);
        int (*set_twt)(const struct device *dev,
                       struct net_if *iface,
                       struct wifi_twt_params *params);
        int (*set_btwt)(const struct device *dev,
                        struct net_if *iface,
                        struct wifi_twt_params *params);
        int (*get_power_save_config)(const struct device *dev,
                                     struct net_if *iface,
                                     struct wifi_ps_config *config);
        int (*reg_domain)(const struct device *dev,
                          struct net_if *iface,
                          struct wifi_reg_domain *reg_domain);
        int (*filter)(const struct device *dev,
                      struct net_if *iface,
                      struct wifi_filter_info *filter);
        int (*mode)(const struct device *dev, struct net_if *iface, struct wifi_mode_info *mode);
        int (*channel)(const struct device *dev,
                       struct net_if *iface,
                       struct wifi_channel_info *channel);

        int (*btm_query)(const struct device *dev, struct net_if *iface, uint8_t reason);

        bool (*bss_support_neighbor_rep)(const struct device *dev, struct net_if *iface);

        int (*bss_ext_capab)(const struct device *dev, struct net_if *iface, int capab);

        int (*legacy_roam)(const struct device *dev, struct net_if *iface);

        int (*get_version)(const struct device *dev,
                           struct net_if *iface,
                           struct wifi_version *params);
        int (*get_conn_params)(const struct device *dev,
                               struct net_if *iface,
                               struct wifi_connect_req_params *params);
        int (*set_rts_threshold)(const struct device *dev,
                                 struct net_if *iface,
                                 unsigned int rts_threshold);
        int (*ap_config_params)(const struct device *dev,
                                struct net_if *iface,
                                struct wifi_ap_config_params *params);
        int (*config_params)(const struct device *dev,
                             struct net_if *iface,
                             struct wifi_config_params *params);
#ifdef CONFIG_WIFI_NM_WPA_SUPPLICANT_DPP
        int (*dpp_dispatch)(const struct device *dev,
                            struct net_if *iface,
                            struct wifi_dpp_params *params);
#endif /* CONFIG_WIFI_NM_WPA_SUPPLICANT_DPP */
#ifdef CONFIG_WIFI_NM_WPA_SUPPLICANT_NAN
        int (*nan_cfg)(const struct device *dev,
                       struct net_if *iface,
                       struct wifi_nan_params *params);
#endif /* CONFIG_WIFI_NM_WPA_SUPPLICANT_NAN */

        int (*pmksa_flush)(const struct device *dev, struct net_if *iface);
#ifdef CONFIG_WIFI_CERTIFICATE_LIB
        int (*enterprise_creds)(const struct device *dev,
                                struct net_if *iface,
                                struct wifi_enterprise_creds_params *creds);
#endif
        int (*get_rts_threshold)(const struct device *dev,
                                 struct net_if *iface,
                                 unsigned int *rts_threshold);
        int (*wps_config)(const struct device *dev,
                          struct net_if *iface,
                          struct wifi_wps_config_params *params);
        int (*candidate_scan)(const struct device *dev,
                              struct net_if *iface,
                              struct wifi_scan_params *params);
        __deprecated int (*start_11r_roaming)(const struct device *dev, struct net_if *iface);
        int (*set_bss_max_idle_period)(const struct device *dev,
                                       struct net_if *iface,
                                       unsigned short bss_max_idle_period);
#if defined(CONFIG_WIFI_NM_WPA_SUPPLICANT_BGSCAN) || defined(__DOXYGEN__)
        int (*set_bgscan)(const struct device *dev,
                          struct net_if *iface,
                          struct wifi_bgscan_params *params);
#endif
#ifdef CONFIG_WIFI_NM_WPA_SUPPLICANT_P2P
        int (*p2p_oper)(const struct device *dev,
                        struct net_if *iface,
                        struct wifi_p2p_params *params);
#endif
         uint32_t (*get_iface_caps)(const struct device *dev, struct net_if *iface);
};

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_connect_result_status_event(struct net_if *iface,
                                                 const struct wifi_status *status);

void wifi_mgmt_raise_disconnect_result_event(struct net_if *iface, int status);

void wifi_mgmt_raise_disconnect_result_status_event(struct net_if *iface,
                                                    const struct wifi_status *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 CONFIG_WIFI_NM_WPA_SUPPLICANT_P2P
void wifi_mgmt_raise_p2p_device_found_event(struct net_if *iface,
                struct wifi_p2p_device_info *peer_info);
#endif /* CONFIG_WIFI_NM_WPA_SUPPLICANT_P2P */

#ifdef __cplusplus
}
#endif
 
#endif /* ZEPHYR_INCLUDE_NET_WIFI_MGMT_H_ */