sdk/banjo/fuchsia.hardware.wlanif/wlanif.banjo

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

};