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_WAPI,
 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_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",
};
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_ */