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

// Copyright 2021 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.wlan.info;
using fuchsia.wlan.internal;
using fuchsia.wlan.ieee80211 as ieee80211;
using zx;

type WlanScanType = strict enum : uint8 {
    ACTIVE = 1;
    PASSIVE = 2;
};

const WLAN_SCAN_MAX_SSIDS_PER_REQUEST uint32 = 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 WLAN_WMM_PARAM_LEN uint32 = 18;
// LINT.ThenChange(//sdk/fidl/fuchsia.wlan.mlme/wlan_mlme.fidl)

type WlanifScanReq = struct {
    txn_id uint64;
    bss_type_selector fuchsia.wlan.internal.BssTypeSelector;
    bssid ieee80211.MacAddr;
    ssid ieee80211.CSsid;
    scan_type WlanScanType;
    probe_delay uint32;
    num_channels uint64;
    channel_list array<uint8, ddk.hw.wlan.wlaninfo.WLAN_INFO_CHANNEL_LIST_MAX_CHANNELS>;
    min_channel_time uint32;
    max_channel_time uint32;
    num_ssids uint64;
    ssid_list array<ieee80211.CSsid, WLAN_SCAN_MAX_SSIDS_PER_REQUEST>;
};

/// IEEE Std 802.11-2016, Table 9-19
const WLAN_MSDU_MAX_LEN uint32 = 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 WLAN_IE_BODY_MAX_LEN uint32 = 255;

const WLAN_VIE_MAX_LEN uint32 = 510; // max length for two elements (WPA and WSC)
const WLAN_MAX_OP_RATES uint32 = 12;

type WlanifJoinReq = struct {
    selected_bss fuchsia.wlan.internal.BssDescription;
    join_failure_timeout uint32;
    nav_sync_delay uint32;
    num_op_rates uint64;
    op_rates array<uint8, WLAN_MAX_OP_RATES>;
};

type WlanAuthType = strict enum : uint8 {
    OPEN_SYSTEM = 1;
    SHARED_KEY = 2;
    FAST_BSS_TRANSITION = 3;
    SAE = 4;
};

type WlanifAuthReq = struct {
    peer_sta_address ieee80211.MacAddr;
    auth_type WlanAuthType;
    auth_failure_timeout uint32;

    // Used to pass an SAE password when SAE_DRIVER_AUTH is in use.
    @mutable
    sae_password vector<uint8>:MAX;
};

type WlanifAuthInd = struct {
    peer_sta_address ieee80211.MacAddr;
    auth_type WlanAuthType;
};

type WlanifDeauthReq = struct {
    peer_sta_address ieee80211.MacAddr;
    reason_code ddk.hw.wlan.ieee80211.ReasonCode;
};

type WlanifAssocReq = struct {
    peer_sta_address ieee80211.MacAddr;
    rsne_len uint64;
    rsne array<uint8, WLAN_IE_BODY_MAX_LEN>;
    vendor_ie_len uint64;
    vendor_ie array<uint8, WLAN_VIE_MAX_LEN>;
};

type WlanifAssocInd = struct {
    peer_sta_address ieee80211.MacAddr;
    listen_interval uint16;
    ssid ieee80211.CSsid;
    rsne_len uint64;
    rsne array<uint8, WLAN_IE_BODY_MAX_LEN>;
    vendor_ie_len uint64;
    vendor_ie array<uint8, WLAN_VIE_MAX_LEN>;
};

type WlanifDisassocReq = struct {
    peer_sta_address ieee80211.MacAddr;
    reason_code uint16;
};

type WlanifResetReq = struct {
    sta_address ieee80211.MacAddr;
    set_default_mib bool;
};

type WlanifStartReq = struct {
    ssid ieee80211.CSsid;
    bss_type fuchsia.wlan.internal.BssType;
    beacon_period uint32;
    dtim_period uint32;
    channel uint8;
    rsne_len uint64;
    rsne array<uint8, WLAN_IE_BODY_MAX_LEN>;
    vendor_ie_len uint64;
    vendor_ie array<uint8, WLAN_VIE_MAX_LEN>;
};

type WlanifStopReq = struct {
    ssid ieee80211.CSsid;
};

type SetKeyDescriptor = struct {
    key vector<uint8>:MAX;
    key_id uint16;
    key_type fuchsia.hardware.wlan.info.WlanKeyType;
    address ieee80211.MacAddr;
    rsc uint64;
    cipher_suite_oui array<uint8, 3>;
    cipher_suite_type uint8;
};

const WLAN_MAX_KEYLIST_SIZE uint32 = 4;

type WlanifSetKeysReq = struct {
    num_keys uint64;
    keylist array<SetKeyDescriptor, WLAN_MAX_KEYLIST_SIZE>;
};

type DeleteKeyDescriptor = struct {
    key_id uint16;
    key_type fuchsia.hardware.wlan.info.WlanKeyType;
    address ieee80211.MacAddr;
};

type WlanifDelKeysReq = struct {
    num_keys uint64;
    keylist array<DeleteKeyDescriptor, WLAN_MAX_KEYLIST_SIZE>;
};

type WlanifEapolReq = struct {
    src_addr ieee80211.MacAddr;
    dst_addr ieee80211.MacAddr;
    data vector<uint8>:MAX;
};

/// This struct is sent from SME to wlanif, indicating the result of SAE handshake process.
type WlanifSaeHandshakeResp = struct {
    peer_sta_address ieee80211.MacAddr;
    status_code ddk.hw.wlan.ieee80211.StatusCode;
};

/// 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.
type WlanifSaeFrame = struct {
    peer_sta_address ieee80211.MacAddr;
    status_code ddk.hw.wlan.ieee80211.StatusCode;
    seq_num uint16;
    sae_fields vector<uint8>:MAX;
};

/// 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
type WlanMgmtCaptureFlag = strict enum : 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;
};

type WlanifStartCaptureFramesReq = struct {
    mgmt_frame_flags uint32;
};

type WlanifStartCaptureFramesResp = struct {
    status int32;
    supported_mgmt_frames uint32;
};

type WlanifScanResult = struct {
    txn_id uint64;
    // Time of the scan result relative to when the system was powered on.
    // See https://fuchsia.dev/fuchsia-src/concepts/time/language_support#monotonic_time
    timestamp_nanos zx.time;
    bss fuchsia.wlan.internal.BssDescription;
};

type WlanScanResult = strict enum : uint8 {
    SUCCESS = 0;
    NOT_SUPPORTED = 1;
    INVALID_ARGS = 2;
    INTERNAL_ERROR = 3;
    SHOULD_WAIT = 4;
    CANCELED_BY_DRIVER_OR_FIRMWARE = 5;
};

type WlanifScanEnd = struct {
    txn_id uint64;
    code WlanScanResult;
};

type WlanJoinResult = strict enum : uint8 {
    SUCCESS = 0;
    FAILURE_TIMEOUT = 1;
    INTERNAL_ERROR = 2;
};

type WlanifJoinConfirm = struct {
    result_code ieee80211.StatusCode;
};

type WlanAuthResult = strict enum : uint8 {
    SUCCESS = 0;
    REFUSED = 1;
    ANTI_CLOGGING_TOKEN_REQUIRED = 2;
    FINITE_CYCLIC_GROUP_NOT_SUPPORTED = 3;
    REJECTED = 4;
    FAILURE_TIMEOUT = 5;
};

type WlanifAuthConfirm = struct {
    peer_sta_address ieee80211.MacAddr;
    auth_type WlanAuthType;
    result_code ieee80211.StatusCode;
};

type WlanifAuthResp = struct {
    peer_sta_address ieee80211.MacAddr;
    result_code WlanAuthResult;
};

type WlanifDeauthConfirm = struct {
    peer_sta_address ieee80211.MacAddr;
};

type WlanifDeauthIndication = struct {
    peer_sta_address ieee80211.MacAddr;
    reason_code ddk.hw.wlan.ieee80211.ReasonCode;
    /// 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)
    locally_initiated bool;
};

type WlanAssocResult = strict enum : 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;
};

type WlanifAssocConfirm = struct {
    result_code ieee80211.StatusCode;
    association_id uint16;
    wmm_param_present bool;
    wmm_param array<uint8, WLAN_WMM_PARAM_LEN>;
};

type WlanifAssocResp = struct {
    peer_sta_address ieee80211.MacAddr;
    result_code WlanAssocResult;
    association_id uint16;
};

type WlanifDisassocConfirm = struct {
    status int32;
};

type WlanifDisassocIndication = struct {
    peer_sta_address ieee80211.MacAddr;
    reason_code ddk.hw.wlan.ieee80211.ReasonCode;
    /// 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)
    locally_initiated bool;
};

type WlanStartResult = strict enum : uint8 {
    SUCCESS = 0;
    BSS_ALREADY_STARTED_OR_JOINED = 1;
    RESET_REQUIRED_BEFORE_START = 2;
    NOT_SUPPORTED = 3;
};

type WlanifStartConfirm = struct {
    result_code WlanStartResult;
};

type WlanStopResult = strict enum : uint8 {
    SUCCESS = 0;
    BSS_ALREADY_STOPPED = 1;
    INTERNAL_ERROR = 2;
};

type WlanifStopConfirm = struct {
    result_code WlanStopResult;
};

type WlanEapolResult = strict enum : uint8 {
    SUCCESS = 0;
    TRANSMISSION_FAILURE = 1;
};

type WlanifEapolConfirm = struct {
    result_code WlanEapolResult;
    /// 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.
    dst_addr ieee80211.MacAddr;
};

type WlanifSignalReportIndication = struct {
    rssi_dbm int8;
    snr_db int8;
};

type WlanifEapolIndication = struct {
    src_addr ieee80211.MacAddr;
    dst_addr ieee80211.MacAddr;
    data vector<uint8>:MAX;
};

type WlanifSaeHandshakeInd = struct {
    peer_sta_address ieee80211.MacAddr;
};

type WlanifBandCapabilities = struct {
    /// Values from enum Band (WLAN_BAND_*)
    band_id uint8;
    num_rates uint64;
    rates array<uint16, ddk.hw.wlan.wlaninfo.WLAN_INFO_BAND_INFO_MAX_RATES>;
    base_frequency uint16;
    num_channels uint64;
    channels array<uint8, ddk.hw.wlan.wlaninfo.WLAN_INFO_CHANNEL_LIST_MAX_CHANNELS>;
    ht_supported bool;
    ht_caps ddk.hw.wlan.ieee80211.Ieee80211HtCapabilities;
    vht_supported bool;
    vht_caps ddk.hw.wlan.ieee80211.Ieee80211VhtCapabilities;
};

type WlanifFeature = strict enum : uint32 {
    /// Supports DMA buffer transfer protocol
    DMA = 0x1;
    /// Synthetic (i.e., non-physical) device
    SYNTH = 0x2;
};

type WlanifQueryInfo = struct {
    sta_addr ieee80211.MacAddr;
    /// WLAN_MAC_ROLE_*
    role ddk.hw.wlan.wlaninfo.WlanInfoMacRole;
    /// WLANIF_FEATURE_*
    features uint32;
    num_bands uint64;
    bands array<WlanifBandCapabilities, ddk.hw.wlan.wlaninfo.WLAN_INFO_MAX_BANDS>;
    /// WLAN_DRIVER_FEATURE_*
    driver_features uint32;
};

type WlanifCounter = struct {
    count uint64;
    name string:MAX;
};

type WlanifPacketCounter = struct {
    in WlanifCounter;
    out WlanifCounter;
    drop WlanifCounter;
    in_bytes WlanifCounter;
    out_bytes WlanifCounter;
    drop_bytes WlanifCounter;
};

type WlanifDispatcherStats = struct {
    any_packet WlanifPacketCounter;
    mgmt_frame WlanifPacketCounter;
    ctrl_frame WlanifPacketCounter;
    data_frame WlanifPacketCounter;
};

type WlanifRssiStats = struct {
    hist vector<uint64>:MAX;
};

// LINT.IfChange
/// Histogram bucket.
type WlanifHistBucket = struct {
    /// Index into a lookup table for each histogram type. The lookup table for each type is
    /// described below in the comments for each type.
    bucket_index uint16;
    /// The count of samples in the bucket.
    num_samples uint64;
};

/// 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 WLANIF_MAX_NOISE_FLOOR_SAMPLES uint8 = 255;
/// Size of RX_RATE_INDEX lookup table (see comments in RxRateIndexHistogram).
const WLANIF_MAX_RX_RATE_INDEX_SAMPLES uint8 = 196;
/// RSSI values range from -255 to -1 dBm.
const WLANIF_MAX_RSSI_SAMPLES uint8 = 255;
/// SNR values range from 0 to 255 dB.
const WLANIF_MAX_SNR_SAMPLES uint16 = 256;

/// Antenna frequency.
type WlanifAntennaFreq = strict enum : uint8 {
    /// 2.4 GHz.
    ANTENNA_2_G = 1;
    /// 5 GHz.
    ANTENNA_5_G = 2;
};

/// Identifier for antenna.
type WlanifAntennaId = struct {
    freq WlanifAntennaFreq;
    /// 0 indexed antenna number of freq.
    index uint8;
};

/// The scope of the histogram, e.g. if the histogram contains data for the entire station, or has
/// data for just a single antenna.
type WlanifHistScope = strict enum : uint8 {
    STATION = 1;
    PER_ANTENNA = 2;
};

/// Histogram for noise floor samples.
type WlanifNoiseFloorHistogram = struct {
    hist_scope WlanifHistScope;
    /// If hist_scope is PER_ANTENNA, antenna_id must be provided.
    antenna_id WlanifAntennaId;
    /// 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.
    noise_floor_samples vector<WlanifHistBucket>:WLANIF_MAX_NOISE_FLOOR_SAMPLES;
    /// Count of invalid samples encountered, if any.
    invalid_samples uint64 = 0;
};

/// Histogram for received data rate.
type WlanifRxRateIndexHistogram = struct {
    hist_scope WlanifHistScope;
    /// If hist_scope is PER_ANTENNA, antenna_id must be provided.
    antenna_id WlanifAntennaId;
    /// 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).
    rx_rate_index_samples vector<WlanifHistBucket>:WLANIF_MAX_RX_RATE_INDEX_SAMPLES;
    /// Count of invalid samples encountered, if any.
    invalid_samples uint64 = 0;
};

/// Histogram for received signal strength indicator (RSSI).
type WlanifRssiHistogram = struct {
    hist_scope WlanifHistScope;
    /// If hist_scope is PER_ANTENNA, antenna_id must be provided.
    antenna_id WlanifAntennaId;
    /// 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.
    rssi_samples vector<WlanifHistBucket>:WLANIF_MAX_RSSI_SAMPLES;
    /// Count of invalid samples encountered, if any.
    invalid_samples uint64 = 0;
};

/// Histogram for signal to noise ratio (SNR).
type WlanifSnrHistogram = struct {
    hist_scope WlanifHistScope;
    /// If hist_scope is PER_ANTENNA, antenna_id must be provided.
    antenna_id WlanifAntennaId;
    /// 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.
    snr_samples vector<WlanifHistBucket>:WLANIF_MAX_SNR_SAMPLES;
    /// Count of invalid samples encountered, if any.
    invalid_samples uint64 = 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 WLANIF_MAX_HISTOGRAMS_PER_TYPE uint8 = 8;
// LINT.ThenChange(//sdk/fidl/fuchsia.wlan.stats/wlan_stats.fidl)

/// The number of 802.11B rates in the WlanifRxRateIndexHistogram lookup table.
const WLANIF_NUM_RATES_B uint8 = 4;
/// The number of 802.11G rates in the WlanifRxRateIndexHistogram lookup table.
const WLANIF_NUM_RATES_G uint8 = 8;
/// The number of 802.11N rates in the WlanifRxRateIndexHistogram lookup table.
const WLANIF_NUM_RATES_N uint8 = 64;
/// The number of 802.11AC rates in the WlanifRxRateIndexHistogram lookup table.
const WLANIF_NUM_RATES_AC uint8 = 120;

type WlanifMlmeStatsType = strict enum : uint8 {
    CLIENT = 0;
    AP = 1;
};

type WlanifClientMlmeStats = struct {
    svc_msg WlanifPacketCounter;
    data_frame WlanifPacketCounter;
    mgmt_frame WlanifPacketCounter;
    tx_frame WlanifPacketCounter;
    rx_frame WlanifPacketCounter;
    assoc_data_rssi WlanifRssiStats;
    beacon_rssi WlanifRssiStats;
    /// Noise floor histogram(s).
    noise_floor_histograms vector<WlanifNoiseFloorHistogram>:WLANIF_MAX_HISTOGRAMS_PER_TYPE;
    /// Received signal strength indicator (RSSI) histogram(s).
    rssi_histograms vector<WlanifRssiHistogram>:WLANIF_MAX_HISTOGRAMS_PER_TYPE;
    /// Received rate index histogram(s).
    rx_rate_index_histograms vector<WlanifRxRateIndexHistogram>:WLANIF_MAX_HISTOGRAMS_PER_TYPE;
    /// Signal to noise ratio (SNR) histogram(s).
    snr_histograms vector<WlanifSnrHistogram>:WLANIF_MAX_HISTOGRAMS_PER_TYPE;
};

type WlanifApMlmeStats = struct {
    not_used WlanifPacketCounter;
};

type StatsUnion = strict union {
    1: client_mlme_stats WlanifClientMlmeStats;
    2: ap_mlme_stats WlanifApMlmeStats;
};

type WlanifMlmeStats = struct {
    tag WlanifMlmeStatsType;
    stats StatsUnion;
};

type WlanifStats = struct {
    dispatcher_stats WlanifDispatcherStats;
    mlme_stats vector<WlanifMlmeStats>:MAX;
};

type WlanifStatsQueryResponse = struct {
    stats WlanifStats;
};

type WlanifCapturedFrameResult = struct {
    data vector<uint8>:MAX;
};

type WlanifChannelSwitchInfo = struct {
    new_channel uint8;
};

type WlanifPmkInfo = struct {
    pmk vector<uint8>:MAX;
    pmkid vector<uint8>:MAX;
};

@transport("Banjo")
@banjo_layout("ddk-interface")
protocol WlanifImplIfc {
    // MLME operations
    OnScanResult(struct {
        result WlanifScanResult;
    }) -> ();
    OnScanEnd(struct {
        end WlanifScanEnd;
    }) -> ();
    JoinConf(struct {
        resp WlanifJoinConfirm;
    }) -> ();
    AuthConf(struct {
        resp WlanifAuthConfirm;
    }) -> ();
    AuthInd(struct {
        resp WlanifAuthInd;
    }) -> ();
    DeauthConf(struct {
        resp WlanifDeauthConfirm;
    }) -> ();
    DeauthInd(struct {
        ind WlanifDeauthIndication;
    }) -> ();
    AssocConf(struct {
        resp WlanifAssocConfirm;
    }) -> ();
    AssocInd(struct {
        resp WlanifAssocInd;
    }) -> ();
    DisassocConf(struct {
        resp WlanifDisassocConfirm;
    }) -> ();
    DisassocInd(struct {
        ind WlanifDisassocIndication;
    }) -> ();
    StartConf(struct {
        resp WlanifStartConfirm;
    }) -> ();
    StopConf(struct {
        resp WlanifStopConfirm;
    }) -> ();
    EapolConf(struct {
        resp WlanifEapolConfirm;
    }) -> ();
    OnChannelSwitch(struct {
        ind WlanifChannelSwitchInfo;
    }) -> ();

    // MLME extensions
    SignalReport(struct {
        ind WlanifSignalReportIndication;
    }) -> ();
    EapolInd(struct {
        ind WlanifEapolIndication;
    }) -> ();
    StatsQueryResp(struct {
        resp WlanifStatsQueryResponse;
    }) -> ();
    RelayCapturedFrame(struct {
        result WlanifCapturedFrameResult;
    }) -> ();
    OnPmkAvailable(struct {
        info WlanifPmkInfo;
    }) -> ();
    SaeHandshakeInd(struct {
        ind WlanifSaeHandshakeInd;
    }) -> ();
    SaeFrameRx(struct {
        frame WlanifSaeFrame;
    }) -> ();
    OnWmmStatusResp(struct {
        s zx.status;
        wmm_params fuchsia.hardware.wlan.info.WlanWmmParams;
    }) -> ();

    // Data operations
    DataRecv(struct {
        @buffer
        data vector<uint8>:MAX;
        flags uint32;
    }) -> ();
};

@transport("Banjo")
@banjo_layout("ddk-protocol")
protocol WlanifImpl {
    // Lifecycle operations
    Start(resource struct {
        ifc client_end:WlanifImplIfc;
    }) -> (resource struct {
        status zx.status;
        sme_channel zx.handle:CHANNEL;
    });
    Stop() -> ();

    // State operation
    Query() -> (struct {
        info WlanifQueryInfo;
    });

    // MLME operations
    StartScan(struct {
        req WlanifScanReq;
    }) -> ();
    JoinReq(struct {
        req WlanifJoinReq;
    }) -> ();
    AuthReq(struct {
        req WlanifAuthReq;
    }) -> ();
    AuthResp(struct {
        resp WlanifAuthResp;
    }) -> ();
    DeauthReq(struct {
        req WlanifDeauthReq;
    }) -> ();
    AssocReq(struct {
        req WlanifAssocReq;
    }) -> ();
    AssocResp(struct {
        resp WlanifAssocResp;
    }) -> ();
    DisassocReq(struct {
        req WlanifDisassocReq;
    }) -> ();
    ResetReq(struct {
        req WlanifResetReq;
    }) -> ();
    StartReq(struct {
        req WlanifStartReq;
    }) -> ();
    StopReq(struct {
        req WlanifStopReq;
    }) -> ();
    SetKeysReq(struct {
        req WlanifSetKeysReq;
    }) -> ();
    DelKeysReq(struct {
        req WlanifDelKeysReq;
    }) -> ();
    EapolReq(struct {
        req WlanifEapolReq;
    }) -> ();

    // MLME extensions
    StatsQueryReq() -> ();
    StartCaptureFrames(struct {
        req WlanifStartCaptureFramesReq;
    }) -> (struct {
        resp WlanifStartCaptureFramesResp;
    });
    StopCaptureFrames() -> ();
    SaeHandshakeResp(struct {
        resp WlanifSaeHandshakeResp;
    }) -> ();
    SaeFrameTx(struct {
        frame WlanifSaeFrame;
    }) -> ();
    WmmStatusReq() -> ();

    // Configuration operations
    SetMulticastPromisc(struct {
        enable bool;
    }) -> (struct {
        status zx.status;
    });

    // Data operations
    @async
    DataQueueTx(struct {
        options uint32;
        @in_out
        netbuf fuchsia.hardware.ethernet.EthernetNetbuf;
    }) -> (struct {
        status zx.status;
        @mutable
        netbuf fuchsia.hardware.ethernet.EthernetNetbuf;
    });

    // Notify the interface whether it's online or offline. For client interfaces the online status
    // changes based on such things as being associated/disassociated with an AP. For encrypted
    // connections this will be regulated by MLME calls to SetControlledPort, for open connections
    // the interface is considered online as soon as association is confirmed.
    //
    // A SoftAP interface is set to online when:
    // 1) The driver confirms that a request to start a SoftAP succeeded.
    // A SoftAP interface is set to offline when:
    // 1) A request to stop a SoftAP is received.
    // 2) The driver indicates that the SoftAP has stopped (possibly already offline because of 1).
    //
    // The call will ONLY be made when the state actually changes. For example in the situation
    // above where a call to stop an AP has been made there will be a call to OnLinkStateChanged.
    // However when the driver confirms this there will be no additional call to OnLinkStateChanged
    // because it was already offline.
    OnLinkStateChanged(struct {
        online bool;
    }) -> ();
};