| // Copyright 2019 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be found |
| // in the LICENSE file. |
| |
| library fuchsia.hardware.wlanif; |
| |
| using ddk.hw.wlan.ieee80211; |
| using ddk.hw.wlan.wlaninfo; |
| using fuchsia.hardware.ethernet; |
| using fuchsia.hardware.ethernet.mac; |
| using fuchsia.hardware.wlan.info; |
| using zx; |
| |
| enum WlanScanType : uint8 { |
| ACTIVE = 1; |
| PASSIVE = 2; |
| }; |
| |
| const uint32 WLAN_SCAN_MAX_SSIDS_PER_REQUEST = 32; |
| |
| // LINT.IfChange |
| /// WFA WMM v1.2, 2.2.2 Table 5 |
| /// Length of the WMM Parameter Element body. This does not include IE and vendor IE headers, |
| /// and only includes the QoS Info, reserved, and AC parameters fields. |
| const uint32 WLAN_WMM_PARAM_LEN = 18; |
| // LINT.ThenChange(//sdk/fidl/fuchsia.wlan.mlme/wlan_mlme.fidl) |
| |
| struct WlanifSsid { |
| uint8 len; |
| array<uint8>:ddk.hw.wlan.ieee80211.IEEE80211_MAX_SSID_LEN data; |
| }; |
| |
| struct WlanifScanReq { |
| uint64 txn_id; |
| fuchsia.hardware.wlan.info.WlanBssType bss_type; |
| array<uint8>:MAC_ARRAY_LENGTH bssid; |
| WlanifSsid ssid; |
| WlanScanType scan_type; |
| uint32 probe_delay; |
| uint64 num_channels; |
| array<uint8>:WLAN_INFO_CHANNEL_LIST_MAX_CHANNELS channel_list; |
| uint32 min_channel_time; |
| uint32 max_channel_time; |
| uint64 num_ssids; |
| array<WlanifSsid>:WLAN_SCAN_MAX_SSIDS_PER_REQUEST ssid_list; |
| }; |
| |
| /// IEEE Std 802.11-2016, Table 9-19 |
| const uint32 WLAN_MSDU_MAX_LEN = 2304; |
| |
| /// IEEE Std 802.11-2016, 9.4.2.25.1 |
| /// IEEE mentions that an element body maximum length is 255 octets in the RSN element |
| /// section, but not in a dedicated section. |
| const uint32 WLAN_IE_BODY_MAX_LEN = 255; |
| |
| const uint32 WLAN_VIE_MAX_LEN = 510; // max length for two elements (WPA and WSC) |
| |
| struct WlanifBssDescription { |
| array<uint8>:MAC_ARRAY_LENGTH bssid; |
| fuchsia.hardware.wlan.info.WlanBssType bss_type; |
| uint32 beacon_period; |
| uint64 timestamp; |
| uint64 local_time; |
| uint16 cap; |
| |
| vector<uint8> ies_bytes; |
| |
| fuchsia.hardware.wlan.info.WlanChannel chan; |
| int8 rssi_dbm; |
| int8 snr_db; |
| }; |
| |
| const uint32 WLAN_MAX_OP_RATES = 12; |
| |
| struct WlanifJoinReq { |
| WlanifBssDescription selected_bss; |
| uint32 join_failure_timeout; |
| uint32 nav_sync_delay; |
| uint64 num_op_rates; |
| array<uint8>:WLAN_MAX_OP_RATES op_rates; |
| }; |
| |
| enum WlanAuthType : uint8 { |
| OPEN_SYSTEM = 1; |
| SHARED_KEY = 2; |
| FAST_BSS_TRANSITION = 3; |
| SAE = 4; |
| }; |
| |
| struct WlanifAuthReq { |
| array<uint8>:MAC_ARRAY_LENGTH peer_sta_address; |
| WlanAuthType auth_type; |
| uint32 auth_failure_timeout; |
| |
| // Used to pass an SAE password when SAE_DRIVER_AUTH is in use. |
| [Mutable] vector<uint8> sae_password; |
| }; |
| |
| struct WlanifAuthInd { |
| array<uint8>:MAC_ARRAY_LENGTH peer_sta_address; |
| WlanAuthType auth_type; |
| }; |
| |
| struct WlanifDeauthReq { |
| array<uint8>:MAC_ARRAY_LENGTH peer_sta_address; |
| ddk.hw.wlan.ieee80211.ReasonCode reason_code; |
| }; |
| |
| struct WlanifAssocReq { |
| array<uint8>:MAC_ARRAY_LENGTH peer_sta_address; |
| uint64 rsne_len; |
| array<uint8>:WLAN_IE_BODY_MAX_LEN rsne; |
| uint64 vendor_ie_len; |
| array<uint8>:WLAN_VIE_MAX_LEN vendor_ie; |
| }; |
| |
| struct WlanifAssocInd { |
| array<uint8>:MAC_ARRAY_LENGTH peer_sta_address; |
| uint16 listen_interval; |
| WlanifSsid ssid; |
| uint64 rsne_len; |
| array<uint8>:WLAN_IE_BODY_MAX_LEN rsne; |
| uint64 vendor_ie_len; |
| array<uint8>:WLAN_VIE_MAX_LEN vendor_ie; |
| }; |
| |
| struct WlanifDisassocReq { |
| array<uint8>:MAC_ARRAY_LENGTH peer_sta_address; |
| uint16 reason_code; |
| }; |
| |
| struct WlanifResetReq { |
| array<uint8>:MAC_ARRAY_LENGTH sta_address; |
| bool set_default_mib; |
| }; |
| |
| struct WlanifStartReq { |
| WlanifSsid ssid; |
| fuchsia.hardware.wlan.info.WlanBssType bss_type; |
| uint32 beacon_period; |
| uint32 dtim_period; |
| uint8 channel; |
| uint64 rsne_len; |
| array<uint8>:WLAN_IE_BODY_MAX_LEN rsne; |
| uint64 vendor_ie_len; |
| array<uint8>:WLAN_VIE_MAX_LEN vendor_ie; |
| }; |
| |
| struct WlanifStopReq { |
| WlanifSsid ssid; |
| }; |
| |
| struct SetKeyDescriptor { |
| vector<uint8> key; |
| uint16 key_id; |
| fuchsia.hardware.wlan.info.WlanKeyType key_type; |
| array<uint8>:MAC_ARRAY_LENGTH address; |
| uint64 rsc; |
| array<uint8>:3 cipher_suite_oui; |
| uint8 cipher_suite_type; |
| }; |
| |
| const uint32 WLAN_MAX_KEYLIST_SIZE = 4; |
| |
| struct WlanifSetKeysReq { |
| uint64 num_keys; |
| array<SetKeyDescriptor>:WLAN_MAX_KEYLIST_SIZE keylist; |
| }; |
| |
| struct DeleteKeyDescriptor { |
| uint16 key_id; |
| fuchsia.hardware.wlan.info.WlanKeyType key_type; |
| array<uint8>:MAC_ARRAY_LENGTH address; |
| }; |
| |
| struct WlanifDelKeysReq { |
| uint64 num_keys; |
| array<DeleteKeyDescriptor>:WLAN_MAX_KEYLIST_SIZE keylist; |
| }; |
| |
| struct WlanifEapolReq { |
| array<uint8>:MAC_ARRAY_LENGTH src_addr; |
| array<uint8>:MAC_ARRAY_LENGTH dst_addr; |
| vector<uint8> data; |
| }; |
| |
| /// This struct is sent from SME to wlanif, indicating the result of SAE handshake process. |
| struct WlanifSaeHandshakeResp { |
| array<uint8>:MAC_ARRAY_LENGTH peer_sta_address; |
| ddk.hw.wlan.ieee80211.StatusCode status_code; |
| }; |
| |
| /// This struct is sent in both directions, containing the information of SAE authentication |
| /// frames, sae_fields maps to challenge text, see IEEE Std 802.11-2016, 9.3.3.12. |
| struct WlanifSaeFrame { |
| array<uint8>:MAC_ARRAY_LENGTH peer_sta_address; |
| ddk.hw.wlan.ieee80211.StatusCode status_code; |
| uint16 seq_num; |
| vector<uint8> sae_fields; |
| }; |
| |
| /// Bits used to request management frame subtypes to be captured. Also used by driver to indicate |
| /// which management frame subtypes are supported for capture. |
| /// |
| /// These values are set at `1 << MgmtFrameSubtypeValue` |
| /// See IEEE Std 802.11-2016, 9.2.4.1.3, for value of each management frame subtype |
| enum WlanMgmtCaptureFlag : uint32 { |
| ASSOC_REQ = 0x1; |
| ASSOC_RESP = 0x2; |
| REASSOC_REQ = 0x4; |
| REASSOC_RESP = 0x8; |
| PROBE_REQ = 0x10; |
| PROBE_RESP = 0x20; |
| TIMING_AD = 0x40; |
| |
| BEACON = 0x100; |
| ATIM = 0x200; |
| DISASSOC = 0x400; |
| AUTH = 0x800; |
| DEAUTH = 0x1000; |
| ACTION = 0x2000; |
| ACTION_NO_ACK = 0x4000; |
| }; |
| |
| struct WlanifStartCaptureFramesReq { |
| uint32 mgmt_frame_flags; |
| }; |
| |
| struct WlanifStartCaptureFramesResp { |
| int32 status; |
| uint32 supported_mgmt_frames; |
| }; |
| |
| struct WlanifScanResult { |
| uint64 txn_id; |
| WlanifBssDescription bss; |
| }; |
| |
| enum WlanScanResult : uint8 { |
| SUCCESS = 0; |
| NOT_SUPPORTED = 1; |
| INVALID_ARGS = 2; |
| INTERNAL_ERROR = 3; |
| SHOULD_WAIT = 4; |
| CANCELED_BY_DRIVER_OR_FIRMWARE = 5; |
| }; |
| |
| struct WlanifScanEnd { |
| uint64 txn_id; |
| WlanScanResult code; |
| }; |
| |
| enum WlanJoinResult : uint8 { |
| SUCCESS = 0; |
| FAILURE_TIMEOUT = 1; |
| INTERNAL_ERROR = 2; |
| }; |
| |
| struct WlanifJoinConfirm { |
| WlanJoinResult result_code; |
| }; |
| |
| enum WlanAuthResult : uint8 { |
| SUCCESS = 0; |
| REFUSED = 1; |
| ANTI_CLOGGING_TOKEN_REQUIRED = 2; |
| FINITE_CYCLIC_GROUP_NOT_SUPPORTED = 3; |
| REJECTED = 4; |
| FAILURE_TIMEOUT = 5; |
| }; |
| |
| struct WlanifAuthConfirm { |
| array<uint8>:MAC_ARRAY_LENGTH peer_sta_address; |
| WlanAuthType auth_type; |
| WlanAuthResult result_code; |
| }; |
| |
| struct WlanifAuthResp { |
| array<uint8>:MAC_ARRAY_LENGTH peer_sta_address; |
| WlanAuthResult result_code; |
| }; |
| |
| struct WlanifDeauthConfirm { |
| array<uint8>:MAC_ARRAY_LENGTH peer_sta_address; |
| }; |
| |
| struct WlanifDeauthIndication { |
| array<uint8>:MAC_ARRAY_LENGTH peer_sta_address; |
| ddk.hw.wlan.ieee80211.ReasonCode reason_code; |
| /// locally_initiated is true if deauth is initiated from the device, |
| /// and is false if it's initiated remotely (e.g. due to deauth frame) |
| bool locally_initiated; |
| }; |
| |
| enum WlanAssocResult : uint8 { |
| SUCCESS = 0; |
| REFUSED_REASON_UNSPECIFIED = 1; |
| REFUSED_NOT_AUTHENTICATED = 2; |
| REFUSED_CAPABILITIES_MISMATCH = 3; |
| REFUSED_EXTERNAL_REASON = 4; |
| REFUSED_AP_OUT_OF_MEMORY = 5; |
| REFUSED_BASIC_RATES_MISMATCH = 6; |
| REJECTED_EMERGENCY_SERVICES_NOT_SUPPORTED = 7; |
| REFUSED_TEMPORARILY = 8; |
| }; |
| |
| struct WlanifAssocConfirm { |
| WlanAssocResult result_code; |
| uint16 association_id; |
| bool wmm_param_present; |
| array<uint8>:WLAN_WMM_PARAM_LEN wmm_param; |
| }; |
| |
| struct WlanifAssocResp { |
| array<uint8>:MAC_ARRAY_LENGTH peer_sta_address; |
| WlanAssocResult result_code; |
| uint16 association_id; |
| }; |
| |
| struct WlanifDisassocConfirm { |
| int32 status; |
| }; |
| |
| struct WlanifDisassocIndication { |
| array<uint8>:MAC_ARRAY_LENGTH PeerStaAddress; |
| ddk.hw.wlan.ieee80211.ReasonCode reason_code; |
| /// locally_initiated is true if diassoc is initiated from the device, |
| /// and is false if it's initiated remotely (e.g. due to disassoc frame) |
| bool locally_initiated; |
| }; |
| |
| enum WlanStartResult : uint8 { |
| SUCCESS = 0; |
| BSS_ALREADY_STARTED_OR_JOINED = 1; |
| RESET_REQUIRED_BEFORE_START = 2; |
| NOT_SUPPORTED = 3; |
| }; |
| |
| struct WlanifStartConfirm { |
| WlanStartResult result_code; |
| }; |
| |
| enum WlanStopResult : uint8 { |
| SUCCESS = 0; |
| BSS_ALREADY_STOPPED = 1; |
| INTERNAL_ERROR = 2; |
| }; |
| |
| struct WlanifStopConfirm { |
| WlanStopResult result_code; |
| }; |
| |
| enum WlanEapolResult : uint8 { |
| SUCCESS = 0; |
| TRANSMISSION_FAILURE = 1; |
| }; |
| |
| struct WlanifEapolConfirm { |
| WlanEapolResult result_code; |
| /// This value corresponds to the dst_addr in the EapolRequest we're confirming. |
| /// IEEE 802.11-2016 does not include this field, but we need it to disambiguate |
| /// if multiple EAPoL handshakes are ongoing. |
| array<uint8>:MAC_ARRAY_LENGTH dst_addr; |
| }; |
| |
| struct WlanifSignalReportIndication { |
| int8 rssi_dbm; |
| int8 snr_db; |
| }; |
| |
| struct WlanifEapolIndication { |
| array<uint8>:MAC_ARRAY_LENGTH src_addr; |
| array<uint8>:MAC_ARRAY_LENGTH dst_addr; |
| vector<uint8> data; |
| }; |
| |
| struct WlanifSaeHandshakeInd { |
| array<uint8>:MAC_ARRAY_LENGTH peer_sta_address; |
| }; |
| |
| struct WlanifBandCapabilities { |
| /// Values from enum Band (WLAN_BAND_*) |
| uint8 band_id; |
| uint64 num_rates; |
| array<uint16>:WLAN_INFO_BAND_INFO_MAX_RATES rates; |
| uint16 base_frequency; |
| uint64 num_channels; |
| array<uint8>:WLAN_INFO_CHANNEL_LIST_MAX_CHANNELS channels; |
| bool ht_supported; |
| ddk.hw.wlan.ieee80211.Ieee80211HtCapabilities ht_caps; |
| bool vht_supported; |
| ddk.hw.wlan.ieee80211.Ieee80211VhtCapabilities vht_caps; |
| }; |
| |
| enum WlanifFeature : uint32 { |
| /// Supports DMA buffer transfer protocol |
| DMA = 0x1; |
| /// Synthetic (i.e., non-physical) device |
| SYNTH = 0x2; |
| }; |
| |
| struct WlanifQueryInfo { |
| array<uint8>:MAC_ARRAY_LENGTH mac_addr; |
| /// WLAN_MAC_ROLE_* |
| ddk.hw.wlan.wlaninfo.WlanInfoMacRole role; |
| /// WLANIF_FEATURE_* |
| uint32 features; |
| uint64 num_bands; |
| array<WlanifBandCapabilities>:WLAN_INFO_MAX_BANDS bands; |
| /// WLAN_DRIVER_FEATURE_* |
| uint32 driver_features; |
| }; |
| |
| struct WlanifCounter { |
| uint64 count; |
| string name; |
| }; |
| |
| struct WlanifPacketCounter { |
| WlanifCounter in; |
| WlanifCounter out; |
| WlanifCounter drop; |
| WlanifCounter in_bytes; |
| WlanifCounter out_bytes; |
| WlanifCounter drop_bytes; |
| }; |
| |
| struct WlanifDispatcherStats { |
| WlanifPacketCounter any_packet; |
| WlanifPacketCounter mgmt_frame; |
| WlanifPacketCounter ctrl_frame; |
| WlanifPacketCounter data_frame; |
| }; |
| |
| struct WlanifRssiStats { |
| vector<uint64> hist; |
| }; |
| |
| // LINT.IfChange |
| /// Histogram bucket. |
| struct WlanifHistBucket { |
| /// Index into a lookup table for each histogram type. The lookup table for each type is |
| /// described below in the comments for each type. |
| uint16 bucket_index; |
| /// The count of samples in the bucket. |
| uint64 num_samples; |
| }; |
| |
| /// All histograms have a fixed number of buckets. To save space, each histogram type |
| /// uses a vector to hold only non-empty buckets (a sparse histogram), with these constants as the |
| /// max size of each vector. |
| /// Noise floor values range from -255 to -1 dBm. |
| const uint8 WLANIF_MAX_NOISE_FLOOR_SAMPLES = 255; |
| /// Size of RX_RATE_INDEX lookup table (see comments in RxRateIndexHistogram). |
| const uint8 WLANIF_MAX_RX_RATE_INDEX_SAMPLES = 196; |
| /// RSSI values range from -255 to -1 dBm. |
| const uint8 WLANIF_MAX_RSSI_SAMPLES = 255; |
| /// SNR values range from 0 to 255 dB. |
| const uint16 WLANIF_MAX_SNR_SAMPLES = 256; |
| |
| /// Antenna frequency. |
| enum WlanifAntennaFreq : uint8 { |
| /// 2.4 GHz. |
| ANTENNA_2_G = 1; |
| /// 5 GHz. |
| ANTENNA_5_G = 2; |
| }; |
| |
| /// Identifier for antenna. |
| struct WlanifAntennaId { |
| WlanifAntennaFreq freq; |
| /// 0 indexed antenna number of freq. |
| uint8 index; |
| }; |
| |
| /// The scope of the histogram, e.g. if the histogram contains data for the entire station, or has |
| /// data for just a single antenna. |
| enum WlanifHistScope : uint8 { |
| STATION = 1; |
| PER_ANTENNA = 2; |
| }; |
| |
| /// Histogram for noise floor samples. |
| struct WlanifNoiseFloorHistogram { |
| WlanifHistScope hist_scope; |
| /// If hist_scope is PER_ANTENNA, antenna_id must be provided. |
| WlanifAntennaId antenna_id; |
| /// Sparse histogram of noise floor of current channel in dBm. Each sample's bucket_index is an |
| /// index into this list of dBm values: [-255, -254, ... -1]. For example, if |
| /// noise_floor_samples contains a WlanifHistBucket with bucket_index = 165 and num_samples = |
| /// 50, that means there were 50 frames counted that had a noise floor of -90 dBm. |
| vector<WlanifHistBucket>:WLANIF_MAX_NOISE_FLOOR_SAMPLES noise_floor_samples; |
| /// Count of invalid samples encountered, if any. |
| uint64 invalid_samples = 0; |
| }; |
| |
| /// Histogram for received data rate. |
| struct WlanifRxRateIndexHistogram { |
| WlanifHistScope hist_scope; |
| /// If hist_scope is PER_ANTENNA, antenna_id must be provided. |
| WlanifAntennaId antenna_id; |
| /// Sparse histogram of count of received frames for each rate. Each sample's bucket_index is an |
| /// index into this lookup table: |
| /// 0-3: B-MCS 0-3 |
| /// 4-11: G-MCS 0-7 |
| /// 12-27: N-MCS 0-15 (BW20) |
| /// 28-43: N-MCS 0-15 (BW40) |
| /// 44-59: N-MCS 0-15 (BW20:SGI) |
| /// 60-75: N-MCS 0-15 (BW40:SGI) |
| /// 76-85: AC-MCS 0-9 (VHT:BW20:NSS1) |
| /// 86-95: AC-MCS 0-9 (VHT:BW20:NSS2) |
| /// 96-105: AC-MCS 0-9 (VHT:BW40:NSS1) |
| /// 106-115: AC-MCS 0-9 (VHT:BW40:NSS2) |
| /// 116-125: AC-MCS 0-9 (VHT:BW80:NSS1) |
| /// 126-135: AC-MCS 0-9 (VHT:BW80:NSS2) |
| /// 136-145: AC-MCS 0-9 (VHT:BW20:NSS1:SGI) |
| /// 146-155: AC-MCS 0-9 (VHT:BW20:NSS2:SGI) |
| /// 156-165: AC-MCS 0-9 (VHT:BW40:NSS1:SGI) |
| /// 166-175: AC-MCS 0-9 (VHT:BW40:NSS2:SGI) |
| /// 176-185: AC-MCS 0-9 (VHT:BW80:NSS1:SGI) |
| /// 186-195: AC-MCS 0-9 (VHT:BW80:NSS2:SGI) |
| /// |
| /// For example, if rx_rate_index_samples contains a WlanifHistBucket with bucket_index = 75 |
| /// and num_samples = 50, that means there were 50 frames counted that had a rate corresponding |
| /// to N-MCS 15 (BW40:SGI). |
| vector<WlanifHistBucket>:WLANIF_MAX_RX_RATE_INDEX_SAMPLES rx_rate_index_samples; |
| /// Count of invalid samples encountered, if any. |
| uint64 invalid_samples = 0; |
| }; |
| |
| /// Histogram for received signal strength indicator (RSSI). |
| struct WlanifRssiHistogram { |
| WlanifHistScope hist_scope; |
| /// If hist_scope is PER_ANTENNA, antenna_id must be provided. |
| WlanifAntennaId antenna_id; |
| /// Sparse histogram of RSSI of AP in dBm. Each sample's bucket_index is an index |
| /// into this list of dBm values: [-255, -254, ... -1]. For example, if rssi_samples |
| /// contains a WlanifHistBucket with bucket_index = 225 and num_samples = 50, that means |
| /// there were 50 frames counted that had a signal level of -30 dBm. |
| vector<WlanifHistBucket>:WLANIF_MAX_RSSI_SAMPLES rssi_samples; |
| /// Count of invalid samples encountered, if any. |
| uint64 invalid_samples = 0; |
| }; |
| |
| /// Histogram for signal to noise ratio (SNR). |
| struct WlanifSnrHistogram { |
| WlanifHistScope hist_scope; |
| /// If hist_scope is PER_ANTENNA, antenna_id must be provided. |
| WlanifAntennaId antenna_id; |
| /// Sparse histogram of signal to noise ratio in dB. Each sample's bucket_index is an index |
| /// into this list of dB values: [0, 1, ... 255]. For example, if snr_samples contains a |
| /// WlanifHistBucket with value = 60 and num_samples = 50, that means there were 50 frames |
| /// counted that had a SNR of 60 dB. |
| vector<WlanifHistBucket>:WLANIF_MAX_SNR_SAMPLES snr_samples; |
| /// Count of invalid samples encountered, if any. |
| uint64 invalid_samples = 0; |
| }; |
| |
| /// For each histogram type (e.g. RSSI), there can be multiple histograms up to this limit. For |
| /// example, an interface might have 1 histogram for station-wide RSSI, but also 1 for each of the |
| /// antennas used by the interface. |
| const uint8 WLANIF_MAX_HISTOGRAMS_PER_TYPE = 8; |
| // LINT.ThenChange(//sdk/fidl/fuchsia.wlan.stats/wlan_stats.fidl) |
| |
| /// The number of 802.11B rates in the WlanifRxRateIndexHistogram lookup table. |
| const uint8 WLANIF_NUM_RATES_B = 4; |
| /// The number of 802.11G rates in the WlanifRxRateIndexHistogram lookup table. |
| const uint8 WLANIF_NUM_RATES_G = 8; |
| /// The number of 802.11N rates in the WlanifRxRateIndexHistogram lookup table. |
| const uint8 WLANIF_NUM_RATES_N = 64; |
| /// The number of 802.11AC rates in the WlanifRxRateIndexHistogram lookup table. |
| const uint8 WLANIF_NUM_RATES_AC = 120; |
| |
| enum WlanifMlmeStatsType : uint8 { |
| CLIENT = 0; |
| AP = 1; |
| }; |
| |
| struct WlanifClientMlmeStats { |
| WlanifPacketCounter svc_msg; |
| WlanifPacketCounter data_frame; |
| WlanifPacketCounter mgmt_frame; |
| WlanifPacketCounter tx_frame; |
| WlanifPacketCounter rx_frame; |
| WlanifRssiStats assoc_data_rssi; |
| WlanifRssiStats beacon_rssi; |
| /// Noise floor histogram(s). |
| vector<WlanifNoiseFloorHistogram>:WLANIF_MAX_HISTOGRAMS_PER_TYPE noise_floor_histograms; |
| /// Received signal strength indicator (RSSI) histogram(s). |
| vector<WlanifRssiHistogram>:WLANIF_MAX_HISTOGRAMS_PER_TYPE rssi_histograms; |
| /// Received rate index histogram(s). |
| vector<WlanifRxRateIndexHistogram>:WLANIF_MAX_HISTOGRAMS_PER_TYPE rx_rate_index_histograms; |
| /// Signal to noise ratio (SNR) histogram(s). |
| vector<WlanifSnrHistogram>:WLANIF_MAX_HISTOGRAMS_PER_TYPE snr_histograms; |
| }; |
| |
| struct WlanifApMlmeStats { |
| WlanifPacketCounter not_used; |
| }; |
| |
| union StatsUnion { |
| 1: WlanifClientMlmeStats client_mlme_stats; |
| 2: WlanifApMlmeStats ap_mlme_stats; |
| }; |
| |
| struct WlanifMlmeStats { |
| WlanifMlmeStatsType tag; |
| StatsUnion stats; |
| }; |
| |
| struct WlanifStats { |
| WlanifDispatcherStats dispatcher_stats; |
| vector<WlanifMlmeStats> mlme_stats; |
| }; |
| |
| struct WlanifStatsQueryResponse { |
| WlanifStats stats; |
| }; |
| |
| struct WlanifCapturedFrameResult { |
| vector<uint8> data; |
| }; |
| |
| struct WlanifChannelSwitchInfo { |
| uint8 new_channel; |
| }; |
| |
| struct WlanifPmkInfo { |
| vector<uint8> pmk; |
| vector<uint8> pmkid; |
| }; |
| |
| [Transport = "Banjo", BanjoLayout = "ddk-interface"] |
| protocol WlanifImplIfc { |
| // MLME operations |
| OnScanResult(WlanifScanResult result) -> (); |
| OnScanEnd(WlanifScanEnd end) -> (); |
| JoinConf(WlanifJoinConfirm resp) -> (); |
| AuthConf(WlanifAuthConfirm resp) -> (); |
| AuthInd(WlanifAuthInd resp) -> (); |
| DeauthConf(WlanifDeauthConfirm resp) -> (); |
| DeauthInd(WlanifDeauthIndication ind) -> (); |
| AssocConf(WlanifAssocConfirm resp) -> (); |
| AssocInd(WlanifAssocInd resp) -> (); |
| DisassocConf(WlanifDisassocConfirm resp) -> (); |
| DisassocInd(WlanifDisassocIndication ind) -> (); |
| StartConf(WlanifStartConfirm resp) -> (); |
| StopConf(WlanifStopConfirm resp) -> (); |
| EapolConf(WlanifEapolConfirm resp) -> (); |
| OnChannelSwitch(WlanifChannelSwitchInfo ind) -> (); |
| |
| // MLME extensions |
| SignalReport(WlanifSignalReportIndication ind) -> (); |
| EapolInd(WlanifEapolIndication ind) -> (); |
| StatsQueryResp(WlanifStatsQueryResponse resp) -> (); |
| RelayCapturedFrame(WlanifCapturedFrameResult result) -> (); |
| OnPmkAvailable(WlanifPmkInfo info) -> (); |
| SaeHandshakeInd(WlanifSaeHandshakeInd ind) -> (); |
| SaeFrameRx(WlanifSaeFrame frame) -> (); |
| OnWmmStatusResp(zx.status s, fuchsia.hardware.wlan.info.WlanWmmParams wmm_params) -> (); |
| |
| // Data operations |
| DataRecv([Buffer] vector<uint8> data, uint32 flags) -> (); |
| }; |
| |
| [Transport = "Banjo", BanjoLayout = "ddk-protocol"] |
| protocol WlanifImpl { |
| // Lifecycle operations |
| Start(WlanifImplIfc ifc) -> (zx.status status, zx.handle:CHANNEL sme_channel); |
| Stop() -> (); |
| |
| // State operation |
| Query() -> (WlanifQueryInfo info); |
| |
| // MLME operations |
| StartScan(WlanifScanReq req) -> (); |
| JoinReq(WlanifJoinReq req) -> (); |
| AuthReq(WlanifAuthReq req) -> (); |
| AuthResp(WlanifAuthResp resp) -> (); |
| DeauthReq(WlanifDeauthReq req) -> (); |
| AssocReq(WlanifAssocReq req) -> (); |
| AssocResp(WlanifAssocResp resp) -> (); |
| DisassocReq(WlanifDisassocReq req) -> (); |
| ResetReq(WlanifResetReq req) -> (); |
| StartReq(WlanifStartReq req) -> (); |
| StopReq(WlanifStopReq req) -> (); |
| SetKeysReq(WlanifSetKeysReq req) -> (); |
| DelKeysReq(WlanifDelKeysReq req) -> (); |
| EapolReq(WlanifEapolReq req) -> (); |
| |
| // MLME extensions |
| StatsQueryReq() -> (); |
| StartCaptureFrames(WlanifStartCaptureFramesReq req) -> (WlanifStartCaptureFramesResp resp); |
| StopCaptureFrames() -> (); |
| SaeHandshakeResp(WlanifSaeHandshakeResp resp) -> (); |
| SaeFrameTx(WlanifSaeFrame frame) -> (); |
| WmmStatusReq() -> (); |
| |
| // Configuration operations |
| SetMulticastPromisc(bool enable) -> (zx.status status); |
| |
| // Data operations |
| [Async] |
| DataQueueTx(uint32 options, [InOut] fuchsia.hardware.ethernet.EthernetNetbuf netbuf) -> |
| (zx.status status, [Mutable] fuchsia.hardware.ethernet.EthernetNetbuf netbuf); |
| |
| }; |