wifi.h

Go to the documentation of this file.

/*
 * Copyright (c) 2018 Texas Instruments, Incorporated
 * Copyright (c) 2023 Nordic Semiconductor ASA
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_INCLUDE_NET_WIFI_H_
#define ZEPHYR_INCLUDE_NET_WIFI_H_
 
#include <zephyr/sys/util.h>  /* for ARRAY_SIZE */
 
#define WIFI_COUNTRY_CODE_LEN 2
 
#define WIFI_LISTEN_INTERVAL_MIN 0
#define WIFI_LISTEN_INTERVAL_MAX 65535
 
#ifdef __cplusplus
extern "C" {
#endif
 
enum wifi_security_type {
        WIFI_SECURITY_TYPE_NONE = 0,
        WIFI_SECURITY_TYPE_PSK,
        WIFI_SECURITY_TYPE_PSK_SHA256,
        WIFI_SECURITY_TYPE_SAE,
        WIFI_SECURITY_TYPE_SAE_HNP = WIFI_SECURITY_TYPE_SAE,
        WIFI_SECURITY_TYPE_SAE_H2E,
        WIFI_SECURITY_TYPE_SAE_AUTO,
        WIFI_SECURITY_TYPE_WAPI,
        WIFI_SECURITY_TYPE_EAP,
        WIFI_SECURITY_TYPE_EAP_TLS = WIFI_SECURITY_TYPE_EAP,
        WIFI_SECURITY_TYPE_WEP,
        WIFI_SECURITY_TYPE_WPA_PSK,
        WIFI_SECURITY_TYPE_WPA_AUTO_PERSONAL,
 
        __WIFI_SECURITY_TYPE_AFTER_LAST,
        WIFI_SECURITY_TYPE_MAX = __WIFI_SECURITY_TYPE_AFTER_LAST - 1,
        WIFI_SECURITY_TYPE_UNKNOWN
};
 
const char *wifi_security_txt(enum wifi_security_type security);
 
enum wifi_mfp_options {
        WIFI_MFP_DISABLE = 0,
        WIFI_MFP_OPTIONAL,
        WIFI_MFP_REQUIRED,
 
        __WIFI_MFP_AFTER_LAST,
        WIFI_MFP_MAX = __WIFI_MFP_AFTER_LAST - 1,
        WIFI_MFP_UNKNOWN
};
 
const char *wifi_mfp_txt(enum wifi_mfp_options mfp);
 
enum wifi_frequency_bands {
        WIFI_FREQ_BAND_2_4_GHZ = 0,
        WIFI_FREQ_BAND_5_GHZ,
        WIFI_FREQ_BAND_6_GHZ,
 
        __WIFI_FREQ_BAND_AFTER_LAST,
        WIFI_FREQ_BAND_MAX = __WIFI_FREQ_BAND_AFTER_LAST - 1,
        WIFI_FREQ_BAND_UNKNOWN
};
 
const char *wifi_band_txt(enum wifi_frequency_bands band);
 
#define WIFI_SSID_MAX_LEN 32
#define WIFI_PSK_MIN_LEN 8
#define WIFI_PSK_MAX_LEN 64
#define WIFI_SAE_PSWD_MAX_LEN 128
#define WIFI_MAC_ADDR_LEN 6
#define WIFI_ENT_IDENTITY_MAX_LEN 64
#define WIFI_ENT_PSWD_MAX_LEN 128
 
#define WIFI_CHANNEL_MIN 1
#define WIFI_CHANNEL_MAX 233
#define WIFI_CHANNEL_ANY 255
 
enum wifi_iface_state {
        WIFI_STATE_DISCONNECTED = 0,
        WIFI_STATE_INTERFACE_DISABLED,
        WIFI_STATE_INACTIVE,
        WIFI_STATE_SCANNING,
        WIFI_STATE_AUTHENTICATING,
        WIFI_STATE_ASSOCIATING,
        WIFI_STATE_ASSOCIATED,
        WIFI_STATE_4WAY_HANDSHAKE,
        WIFI_STATE_GROUP_HANDSHAKE,
        WIFI_STATE_COMPLETED,
 
        __WIFI_STATE_AFTER_LAST,
        WIFI_STATE_MAX = __WIFI_STATE_AFTER_LAST - 1,
        WIFI_STATE_UNKNOWN
};
 
/* We rely on the strict order of the enum values, so, let's check it */
BUILD_ASSERT(WIFI_STATE_DISCONNECTED < WIFI_STATE_INTERFACE_DISABLED &&
             WIFI_STATE_INTERFACE_DISABLED < WIFI_STATE_INACTIVE &&
             WIFI_STATE_INACTIVE < WIFI_STATE_SCANNING &&
             WIFI_STATE_SCANNING < WIFI_STATE_AUTHENTICATING &&
             WIFI_STATE_AUTHENTICATING < WIFI_STATE_ASSOCIATING &&
             WIFI_STATE_ASSOCIATING < WIFI_STATE_ASSOCIATED &&
             WIFI_STATE_ASSOCIATED < WIFI_STATE_4WAY_HANDSHAKE &&
             WIFI_STATE_4WAY_HANDSHAKE < WIFI_STATE_GROUP_HANDSHAKE &&
             WIFI_STATE_GROUP_HANDSHAKE < WIFI_STATE_COMPLETED);
 
 
const char *wifi_state_txt(enum wifi_iface_state state);
 
enum wifi_iface_mode {
        WIFI_MODE_INFRA = 0,
        WIFI_MODE_IBSS = 1,
        WIFI_MODE_AP = 2,
        WIFI_MODE_P2P_GO = 3,
        WIFI_MODE_P2P_GROUP_FORMATION = 4,
        WIFI_MODE_MESH = 5,
 
        __WIFI_MODE_AFTER_LAST,
        WIFI_MODE_MAX = __WIFI_MODE_AFTER_LAST - 1,
        WIFI_MODE_UNKNOWN
};
 
const char *wifi_mode_txt(enum wifi_iface_mode mode);
 
enum wifi_link_mode {
        WIFI_0 = 0,
        WIFI_1,
        WIFI_2,
        WIFI_3,
        WIFI_4,
        WIFI_5,
        WIFI_6,
        WIFI_6E,
        WIFI_7,
 
        __WIFI_LINK_MODE_AFTER_LAST,
        WIFI_LINK_MODE_MAX = __WIFI_LINK_MODE_AFTER_LAST - 1,
        WIFI_LINK_MODE_UNKNOWN
};
 
const char *wifi_link_mode_txt(enum wifi_link_mode link_mode);
 
enum wifi_scan_type {
        WIFI_SCAN_TYPE_ACTIVE = 0,
        WIFI_SCAN_TYPE_PASSIVE,
};
 
enum wifi_ps {
        WIFI_PS_DISABLED = 0,
        WIFI_PS_ENABLED,
};
 
const char *wifi_ps_txt(enum wifi_ps ps_name);
 
enum wifi_ps_mode {
        WIFI_PS_MODE_LEGACY = 0,
        /* This has to be configured before connecting to the AP,
         * as support for ADDTS action frames is not available.
         */
        WIFI_PS_MODE_WMM,
};
 
const char *wifi_ps_mode_txt(enum wifi_ps_mode ps_mode);
 
#define WIFI_INTERFACE_INDEX_MIN 1
#define WIFI_INTERFACE_INDEX_MAX 255
 
enum wifi_operational_modes {
        WIFI_STA_MODE = BIT(0),
        WIFI_MONITOR_MODE = BIT(1),
        WIFI_TX_INJECTION_MODE = BIT(2),
        WIFI_PROMISCUOUS_MODE = BIT(3),
        WIFI_AP_MODE = BIT(4),
        WIFI_SOFTAP_MODE = BIT(5),
};
 
enum wifi_filter {
        WIFI_PACKET_FILTER_ALL = BIT(0),
        WIFI_PACKET_FILTER_MGMT = BIT(1),
        WIFI_PACKET_FILTER_DATA = BIT(2),
        WIFI_PACKET_FILTER_CTRL = BIT(3),
};
 
enum wifi_twt_operation {
        WIFI_TWT_SETUP = 0,
        WIFI_TWT_TEARDOWN,
};
 
const char *wifi_twt_operation_txt(enum wifi_twt_operation twt_operation);
 
enum wifi_twt_negotiation_type {
        WIFI_TWT_INDIVIDUAL = 0,
        WIFI_TWT_BROADCAST,
        WIFI_TWT_WAKE_TBTT
};
 
const char *wifi_twt_negotiation_type_txt(enum wifi_twt_negotiation_type twt_negotiation);
 
enum wifi_twt_setup_cmd {
        WIFI_TWT_SETUP_CMD_REQUEST = 0,
        WIFI_TWT_SETUP_CMD_SUGGEST,
        WIFI_TWT_SETUP_CMD_DEMAND,
        WIFI_TWT_SETUP_CMD_GROUPING,
        WIFI_TWT_SETUP_CMD_ACCEPT,
        WIFI_TWT_SETUP_CMD_ALTERNATE,
        WIFI_TWT_SETUP_CMD_DICTATE,
        WIFI_TWT_SETUP_CMD_REJECT,
};
 
const char *wifi_twt_setup_cmd_txt(enum wifi_twt_setup_cmd twt_setup);
 
enum wifi_twt_setup_resp_status {
        WIFI_TWT_RESP_RECEIVED = 0,
        WIFI_TWT_RESP_NOT_RECEIVED,
};
 
enum wifi_twt_fail_reason {
        WIFI_TWT_FAIL_UNSPECIFIED,
        WIFI_TWT_FAIL_CMD_EXEC_FAIL,
        WIFI_TWT_FAIL_OPERATION_NOT_SUPPORTED,
        WIFI_TWT_FAIL_UNABLE_TO_GET_IFACE_STATUS,
        WIFI_TWT_FAIL_DEVICE_NOT_CONNECTED,
        WIFI_TWT_FAIL_PEER_NOT_HE_CAPAB,
        WIFI_TWT_FAIL_PEER_NOT_TWT_CAPAB,
        WIFI_TWT_FAIL_OPERATION_IN_PROGRESS,
        WIFI_TWT_FAIL_INVALID_FLOW_ID,
        WIFI_TWT_FAIL_IP_NOT_ASSIGNED,
        WIFI_TWT_FAIL_FLOW_ALREADY_EXISTS,
};
 
enum wifi_twt_teardown_status {
        WIFI_TWT_TEARDOWN_SUCCESS = 0,
        WIFI_TWT_TEARDOWN_FAILED,
};
 
static const char * const wifi_twt_err_code_tbl[] = {
        [WIFI_TWT_FAIL_UNSPECIFIED] = "Unspecified",
        [WIFI_TWT_FAIL_CMD_EXEC_FAIL] = "Command Execution failed",
        [WIFI_TWT_FAIL_OPERATION_NOT_SUPPORTED] =
                "Operation not supported",
        [WIFI_TWT_FAIL_UNABLE_TO_GET_IFACE_STATUS] =
                "Unable to get iface status",
        [WIFI_TWT_FAIL_DEVICE_NOT_CONNECTED] =
                "Device not connected",
        [WIFI_TWT_FAIL_PEER_NOT_HE_CAPAB] = "Peer not HE capable",
        [WIFI_TWT_FAIL_PEER_NOT_TWT_CAPAB] = "Peer not TWT capable",
        [WIFI_TWT_FAIL_OPERATION_IN_PROGRESS] =
                "Operation already in progress",
        [WIFI_TWT_FAIL_INVALID_FLOW_ID] =
                "Invalid negotiated flow id",
        [WIFI_TWT_FAIL_IP_NOT_ASSIGNED] =
                "IP address not assigned",
        [WIFI_TWT_FAIL_FLOW_ALREADY_EXISTS] =
                "Flow already exists",
};
static inline const char *wifi_twt_get_err_code_str(int16_t err_no)
{
        if ((err_no) < (int16_t)ARRAY_SIZE(wifi_twt_err_code_tbl)) {
                return wifi_twt_err_code_tbl[err_no];
        }
 
        return "<unknown>";
}
 
enum wifi_ps_param_type {
        WIFI_PS_PARAM_STATE,
        WIFI_PS_PARAM_LISTEN_INTERVAL,
        WIFI_PS_PARAM_WAKEUP_MODE,
        WIFI_PS_PARAM_MODE,
        WIFI_PS_PARAM_TIMEOUT,
};
 
enum wifi_ps_wakeup_mode {
        WIFI_PS_WAKEUP_MODE_DTIM = 0,
        WIFI_PS_WAKEUP_MODE_LISTEN_INTERVAL,
};
 
const char *wifi_ps_wakeup_mode_txt(enum wifi_ps_wakeup_mode ps_wakeup_mode);
 
enum wifi_config_ps_param_fail_reason {
        WIFI_PS_PARAM_FAIL_UNSPECIFIED,
        WIFI_PS_PARAM_FAIL_CMD_EXEC_FAIL,
        WIFI_PS_PARAM_FAIL_OPERATION_NOT_SUPPORTED,
        WIFI_PS_PARAM_FAIL_UNABLE_TO_GET_IFACE_STATUS,
        WIFI_PS_PARAM_FAIL_DEVICE_NOT_CONNECTED,
        WIFI_PS_PARAM_FAIL_DEVICE_CONNECTED,
        WIFI_PS_PARAM_LISTEN_INTERVAL_RANGE_INVALID,
};
 
static const char * const wifi_ps_param_config_err_code_tbl[] = {
        [WIFI_PS_PARAM_FAIL_UNSPECIFIED] = "Unspecified",
        [WIFI_PS_PARAM_FAIL_CMD_EXEC_FAIL] = "Command Execution failed",
        [WIFI_PS_PARAM_FAIL_OPERATION_NOT_SUPPORTED] =
                "Operation not supported",
        [WIFI_PS_PARAM_FAIL_UNABLE_TO_GET_IFACE_STATUS] =
                "Unable to get iface status",
        [WIFI_PS_PARAM_FAIL_DEVICE_NOT_CONNECTED] =
                "Cannot set parameters while device not connected",
        [WIFI_PS_PARAM_FAIL_DEVICE_CONNECTED] =
                "Cannot set parameters while device connected",
        [WIFI_PS_PARAM_LISTEN_INTERVAL_RANGE_INVALID] =
                "Parameter out of range",
};
#ifdef CONFIG_WIFI_NM_WPA_SUPPLICANT_WNM
enum wifi_btm_query_reason {
        WIFI_BTM_QUERY_REASON_UNSPECIFIED = 0,
        WIFI_BTM_QUERY_REASON_LOW_RSSI = 16,
        WIFI_BTM_QUERY_REASON_LEAVING_ESS = 20,
};
#endif
 
static inline const char *wifi_ps_get_config_err_code_str(int16_t err_no)
{
        if ((err_no) < (int16_t)ARRAY_SIZE(wifi_ps_param_config_err_code_tbl)) {
                return wifi_ps_param_config_err_code_tbl[err_no];
        }
 
        return "<unknown>";
}
 
enum wifi_ap_config_param {
        WIFI_AP_CONFIG_PARAM_MAX_INACTIVITY = BIT(0),
        WIFI_AP_CONFIG_PARAM_MAX_NUM_STA = BIT(1),
};
 
#ifdef __cplusplus
}
#endif
 
#endif /* ZEPHYR_INCLUDE_NET_WIFI_H_ */