wifi.h

Go to the documentation of this file.

/*
 * Copyright (c) 2018 Texas Instruments, Incorporated
 *
 * 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
 
/* Not having support for legacy types is deliberate to enforce
 * higher security.
 */
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_AFTER_LAST,
        WIFI_SECURITY_TYPE_MAX = __WIFI_SECURITY_TYPE_AFTER_LAST - 1,
        WIFI_SECURITY_TYPE_UNKNOWN
};
 
static inline const char *wifi_security_txt(enum wifi_security_type security)
{
        switch (security) {
        case WIFI_SECURITY_TYPE_NONE:
                return "OPEN";
        case WIFI_SECURITY_TYPE_WEP:
                return "WEP";
        case WIFI_SECURITY_TYPE_WPA_PSK:
                return "WPA-PSK";
        case WIFI_SECURITY_TYPE_PSK:
                return "WPA2-PSK";
        case WIFI_SECURITY_TYPE_PSK_SHA256:
                return "WPA2-PSK-SHA256";
        case WIFI_SECURITY_TYPE_SAE:
                return "WPA3-SAE";
        case WIFI_SECURITY_TYPE_WAPI:
                return "WAPI";
        case WIFI_SECURITY_TYPE_EAP:
                return "EAP";
        case WIFI_SECURITY_TYPE_UNKNOWN:
        default:
                return "UNKNOWN";
        }
}
 
/* Management frame protection (IEEE 802.11w) options */
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
};
 
static inline const char *wifi_mfp_txt(enum wifi_mfp_options mfp)
{
        switch (mfp) {
        case WIFI_MFP_DISABLE:
                return "Disable";
        case WIFI_MFP_OPTIONAL:
                return "Optional";
        case WIFI_MFP_REQUIRED:
                return "Required";
        case WIFI_MFP_UNKNOWN:
        default:
                return "UNKNOWN";
        }
}
 
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
};
 
static inline const char *wifi_band_txt(enum wifi_frequency_bands band)
{
        switch (band) {
        case WIFI_FREQ_BAND_2_4_GHZ:
                return "2.4GHz";
        case WIFI_FREQ_BAND_5_GHZ:
                return "5GHz";
        case WIFI_FREQ_BAND_6_GHZ:
                return "6GHz";
        case WIFI_FREQ_BAND_UNKNOWN:
        default:
                return "UNKNOWN";
        }
}
 
#define WIFI_SSID_MAX_LEN 32
#define WIFI_PSK_MAX_LEN 64
#define WIFI_MAC_ADDR_LEN 6
 
#define WIFI_CHANNEL_MAX 233
#define WIFI_CHANNEL_ANY 255
 
/* Based on https://w1.fi/wpa_supplicant/devel/defs_8h.html#a4aeb27c1e4abd046df3064ea9756f0bc */
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
};
 
static inline const char *wifi_state_txt(enum wifi_iface_state state)
{
        switch (state) {
        case WIFI_STATE_DISCONNECTED:
                return "DISCONNECTED";
        case WIFI_STATE_INACTIVE:
                return "INACTIVE";
        case WIFI_STATE_INTERFACE_DISABLED:
                return "INTERFACE_DISABLED";
        case WIFI_STATE_SCANNING:
                return "SCANNING";
        case WIFI_STATE_AUTHENTICATING:
                return "AUTHENTICATING";
        case WIFI_STATE_ASSOCIATING:
                return "ASSOCIATING";
        case WIFI_STATE_ASSOCIATED:
                return "ASSOCIATED";
        case WIFI_STATE_4WAY_HANDSHAKE:
                return "4WAY_HANDSHAKE";
        case WIFI_STATE_GROUP_HANDSHAKE:
                return "GROUP_HANDSHAKE";
        case WIFI_STATE_COMPLETED:
                return "COMPLETED";
        case WIFI_STATE_UNKNOWN:
        default:
                return "UNKNOWN";
        }
}
 
/* Based on https://w1.fi/wpa_supplicant/devel/structwpa__ssid.html#a625821e2acfc9014f3b3de6e6593ffb7 */
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
};
 
static inline const char *wifi_mode_txt(enum wifi_iface_mode mode)
{
        switch (mode) {
        case WIFI_MODE_INFRA:
                return "STATION";
        case WIFI_MODE_IBSS:
                return "ADHOC";
        case WIFI_MODE_AP:
                return "ACCESS POINT";
        case WIFI_MODE_P2P_GO:
                return "P2P GROUP OWNER";
        case WIFI_MODE_P2P_GROUP_FORMATION:
                return "P2P GROUP FORMATION";
        case WIFI_MODE_MESH:
                return "MESH";
        case WIFI_MODE_UNKNOWN:
        default:
                return "UNKNOWN";
        }
}
 
/* As per https://en.wikipedia.org/wiki/Wi-Fi#Versions_and_generations */
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
};
 
static inline const char *wifi_link_mode_txt(enum wifi_link_mode link_mode)
{
        switch (link_mode) {
        case WIFI_0:
                return "WIFI 0 (802.11)";
        case WIFI_1:
                return "WIFI 1 (802.11b)";
        case WIFI_2:
                return "WIFI 2 (802.11a)";
        case WIFI_3:
                return "WIFI 3 (802.11g)";
        case WIFI_4:
                return "WIFI 4 (802.11n/HT)";
        case WIFI_5:
                return "WIFI 5 (802.11ac/VHT)";
        case WIFI_6:
                return "WIFI 6 (802.11ax/HE)";
        case WIFI_6E:
                return "WIFI 6E (802.11ax 6GHz/HE)";
        case WIFI_7:
                return "WIFI 7 (802.11be/EHT)";
        case WIFI_LINK_MODE_UNKNOWN:
        default:
                return "UNKNOWN";
        }
}
 
enum wifi_ps {
        WIFI_PS_DISABLED = 0,
        WIFI_PS_ENABLED,
};
 
static const char * const wifi_ps2str[] = {
        [WIFI_PS_DISABLED] = "Power save disabled",
        [WIFI_PS_ENABLED] = "Power save enabled",
};
 
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,
};
 
static const char * const wifi_ps_mode2str[] = {
        [WIFI_PS_MODE_LEGACY] = "Legacy power save",
        [WIFI_PS_MODE_WMM] = "WMM power save",
};
 
enum wifi_twt_operation {
        WIFI_TWT_SETUP = 0,
        WIFI_TWT_TEARDOWN,
};
 
static const char * const wifi_twt_operation2str[] = {
        [WIFI_TWT_SETUP] = "TWT setup",
        [WIFI_TWT_TEARDOWN] = "TWT teardown",
};
 
enum wifi_twt_negotiation_type {
        WIFI_TWT_INDIVIDUAL = 0,
        WIFI_TWT_BROADCAST,
        WIFI_TWT_WAKE_TBTT
};
 
static const char * const wifi_twt_negotiation_type2str[] = {
        [WIFI_TWT_INDIVIDUAL] = "TWT individual negotiation",
        [WIFI_TWT_BROADCAST] = "TWT broadcast negotiation",
        [WIFI_TWT_WAKE_TBTT] = "TWT wake TBTT negotiation",
};
 
enum wifi_twt_setup_cmd {
        /* TWT Requests */
        WIFI_TWT_SETUP_CMD_REQUEST = 0,
        WIFI_TWT_SETUP_CMD_SUGGEST,
        WIFI_TWT_SETUP_CMD_DEMAND,
        /* TWT Responses */
        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,
};
 
static const char * const wifi_twt_setup_cmd2str[] = {
        /* TWT Requests */
        [WIFI_TWT_SETUP_CMD_REQUEST] = "TWT request",
        [WIFI_TWT_SETUP_CMD_SUGGEST] = "TWT suggest",
        [WIFI_TWT_SETUP_CMD_DEMAND] = "TWT demand",
        /* TWT Responses */
        [WIFI_TWT_SETUP_CMD_GROUPING] = "TWT grouping",
        [WIFI_TWT_SETUP_CMD_ACCEPT] = "TWT accept",
        [WIFI_TWT_SETUP_CMD_ALTERNATE] = "TWT alternate",
        [WIFI_TWT_SETUP_CMD_DICTATE] = "TWT dictate",
        [WIFI_TWT_SETUP_CMD_REJECT] = "TWT reject",
};
 
enum wifi_twt_setup_resp_status {
        /* TWT Setup response 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,
};
 
static const char * const twt_err_code_tbl[] = {
        [WIFI_TWT_FAIL_UNSPECIFIED] = "Unspecfied",
        [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",
};
 
static inline const char *get_twt_err_code_str(int16_t err_no)
{
        if ((err_no) < (int16_t)ARRAY_SIZE(twt_err_code_tbl)) {
                return twt_err_code_tbl[err_no];
        }
 
        return "<unknown>";
}
 
enum 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,
};
 
static const char * const wifi_ps_wakeup_mode2str[] = {
        [WIFI_PS_WAKEUP_MODE_DTIM] = "PS wakeup mode DTIM",
        [WIFI_PS_WAKEUP_MODE_LISTEN_INTERVAL] = "PS wakeup mode listen interval",
};
 
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 ps_param_config_err_code_tbl[] = {
        [WIFI_PS_PARAM_FAIL_UNSPECIFIED] = "Unspecfied",
        [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] =
                "Can not set while device not connected",
        [WIFI_PS_PARAM_FAIL_DEVICE_CONNECTED] =
                "Can not set while device already connected",
        [WIFI_PS_PARAM_LISTEN_INTERVAL_RANGE_INVALID] =
                "Can not set due to invalid range",
};
 
static inline const char *get_ps_config_err_code_str(int16_t err_no)
{
        if ((err_no) < (int16_t)ARRAY_SIZE(ps_param_config_err_code_tbl)) {
                return ps_param_config_err_code_tbl[err_no];
        }
 
        return "<unknown>";
}
#endif /* ZEPHYR_INCLUDE_NET_WIFI_H_ */