/*
 * Copyright 2016 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package android.hardware.wifi@1.0;

/**
 * Enum values indicating the status of operation.
 */
enum WifiStatusCode : uint32_t {
  /** No errors. */
  SUCCESS,
  /** Method invoked on an invalid |IWifiChip| object. */
  ERROR_WIFI_CHIP_INVALID,
  /** Method invoked on an invalid |IWifiIface| object. */
  ERROR_WIFI_IFACE_INVALID,
  /** Method invoked on an invalid |IWifiRttController| object. */
  ERROR_WIFI_RTT_CONTROLLER_INVALID,
  ERROR_NOT_SUPPORTED,
  ERROR_NOT_AVAILABLE,
  ERROR_NOT_STARTED,
  ERROR_INVALID_ARGS,
  ERROR_BUSY,
  ERROR_UNKNOWN
};

/**
 * Generic structure to return the status of an operation.
 */
struct WifiStatus {
  WifiStatusCode code;
  /**
   * A vendor specific error message from the vendor to provide more
   * information beyond the reason code.
   */
  string description;
};

/**
 * List of Iface types supported.
 */
enum IfaceType : uint32_t {
  STA,
  AP,
  P2P,
  /**
   * NAN control interface. Datapath support must be queried and created
   * through this interface.
   */
  NAN,
};

/**
 * An identifier assigned to every chip on the device.
 */
typedef uint32_t ChipId;

/**
 * An identifier for a mode that the chip can be put in.
 */
typedef uint32_t ChipModeId;

/**
 * A unique handle provided by the client to identify individual invocations of
 * certain API's like |IWifiStaIface.startBackgroundScan|,
 * |IWifiStaIface.installApfPacketFilter|, etc.
 */
typedef uint32_t CommandId;

/**
 * Channel frequency in Mhz.
 */
typedef uint32_t WifiChannelInMhz;

/**
 * Channel operating width in Mhz.
 */
enum WifiChannelWidthInMhz : uint32_t {
  WIDTH_20    = 0,
  WIDTH_40    = 1,
  WIDTH_80    = 2,
  WIDTH_160   = 3,
  WIDTH_80P80 = 4,
  WIDTH_5     = 5,
  WIDTH_10    = 6,
  WIDTH_INVALID = -1
};

/**
 * Channel information.
 */
struct WifiChannelInfo {
  /**
   * Channel width (20, 40, 80, 80+80, 160).
   */
  WifiChannelWidthInMhz width;
  /**
   * Primary 20 MHz channel.
   */
  WifiChannelInMhz centerFreq;
  /**
   * Center frequency (MHz) first segment.
   */
  WifiChannelInMhz centerFreq0;
  /**
   * Center frequency (MHz) second segment.
   */
  WifiChannelInMhz centerFreq1;
};

/**
 * RSSI information.
 */
typedef int32_t Rssi;

/**
 * Mac Address type. 6 octets representing physical address of a device.
 */
typedef uint8_t[6] MacAddress;

/**
 * SSID type. 32 octets representing the network.
 */
typedef uint8_t[32] Ssid;

/**
 * BSSID type. 6 octets representing the physical address of an AP.
 */
typedef MacAddress Bssid;

/**
 * TimeStamp in milliseconds (ms).
 */
typedef uint64_t TimeStampInMs;

/**
 * TimeStamp in microseconds (us).
 */
typedef uint64_t TimeStampInUs;

/**
 * TimeStamp in picoseconds (ps).
 */
typedef uint64_t TimeSpanInPs;

/**
 * Information elements contained within the |ScanResult| structure.
 * These elements correspond to the IEEE_802.11 standard.
 */
struct WifiInformationElement {
  uint8_t id;
  vec<uint8_t> data;
};

enum WifiRatePreamble : uint32_t {
  OFDM = 0,
  CCK = 1,
  HT = 2,
  VHT = 3,
  RESERVED = 4
};

/**
 * Number of spatial streams in VHT/HT.
 */
enum WifiRateNss : uint32_t {
  NSS_1x1 = 0,
  NSS_2x2 = 1,
  NSS_3x3 = 2,
  NSS_4x4 = 3
};

/**
 * Wifi rate info.
 */
struct WifiRateInfo {
  /**
   * Preamble used for RTT measurements.
   */
  WifiRatePreamble preamble;
  /**
   * Number of spatial streams.
   */
  WifiRateNss nss;
  /**
   * Bandwidth of channel.
   */
  WifiChannelWidthInMhz bw;
  /**
   * OFDM/CCK rate code would be as per ieee std in the units of 0.5mbps.
   * HT/VHT it would be mcs index.
   */
  uint8_t rateMcsIdx;
  /**
   * Bitrate in units of 100 Kbps.
   */
  uint32_t bitRateInKbps;
};

/**
 * Wifi bands defined in 80211 spec.
 */
enum WifiBand : uint32_t {
  BAND_UNSPECIFIED = 0,
  /**
   * 2.4 GHz.
   */
  BAND_24GHZ = 1,
  /**
   * 5 GHz without DFS.
   */
  BAND_5GHZ = 2,
  /**
   * 5 GHz DFS only.
   */
  BAND_5GHZ_DFS = 4,
  /**
   * 5 GHz with DFS.
   */
  BAND_5GHZ_WITH_DFS = 6,
  /**
   * 2.4 GHz + 5 GHz; no DFS.
   */
  BAND_24GHZ_5GHZ = 3,
  /**
   * 2.4 GHz + 5 GHz with DFS
   */
  BAND_24GHZ_5GHZ_WITH_DFS = 7
};

/**
 * STA specific types.
 * TODO(b/32159498): Move to a separate sta_types.hal.
 */
/**
 * Parameters to specify the APF capabilities of this iface.
 */
struct StaApfPacketFilterCapabilities {
  /**
   * Version of the packet filter interpreter supported
   */
  uint32_t version;
  /**
   * Maximum size of the filter bytecodes in byte for an iface.
   */
  uint32_t maxLength;
};

/**
 * Parameters to specify the Background Scan capabilities of this iface.
 */
struct StaBackgroundScanCapabilities {
  /**
   * Maximum number of byte available for cached scan results
   */
  uint32_t maxCacheSize;
  /**
   * Maximum number of buckets that can be supplied for a scan
   */
  uint32_t maxBuckets;
  /**
   * Maximum number of APs that must be stored for each scan.
   */
  uint32_t maxApCachePerScan;
  /**
   * Max reporting number of scans threshold that can be specified in the scan
   * parameters.
   */
  int32_t maxReportingThreshold;
};

/**
 * Mask of event reporting schemes that can be specified in background scan
 * requests.
 */
enum StaBackgroundScanBucketEventReportSchemeMask : uint32_t {
  /**
   * Report a scan completion event after scan. If this is not set then scan
   * completion events must be reported if report_threshold_percent or
   * report_threshold_num_scans is reached.
   */
  EACH_SCAN = 1 << 0,
  /**
   * Forward scan results (beacons/probe responses + IEs) in real time to HAL,
   * in addition to completion events.
   * Note: To keep backward compatibility, fire completion events regardless
   * of REPORT_EVENTS_EACH_SCAN.
   */
  FULL_RESULTS = 1 << 1,
  /**
   * Controls if scans for this bucket must be placed in the results buffer.
   */
  NO_BATCH = 1 << 2,
};

/**
 * Max limits for background scan.
 */
enum StaScanLimits : uint32_t {
  MAX_CHANNELS = 16,
  MAX_BUCKETS = 16,
  MAX_AP_CACHE_PER_SCAN = 32
};

/**
 * Background Scan parameters per bucket that can be specified in background
 * scan requests.
 */
struct StaBackgroundScanBucketParameters {
  /**
   * Bucket index. This index is used to report results in
   * |StaScanData.bucketsScanned|.
   */
  uint32_t bucketIdx;
  /**
   * Bands to scan or |BAND_UNSPECIFIED| if frequencies list must be used
   * instead.
   */
  WifiBand band;
  /**
   * Channel frequencies (in Mhz) to scan if |band| is set to
   * |BAND_UNSPECIFIED|.
   * Max length: |StaScanLimits.MAX_CHANNELS|.
   */
  vec<WifiChannelInMhz> frequencies;
  /**
   * Period at which this bucket must be scanned (in milliseconds). Must be an integer
   * multiple of the |basePeriodInMs| specified in the BackgroundScanParameters.
   */
  uint32_t periodInMs;
  /**
   * Bitset of |StaBackgroundScanBucketEventReportSchemeMask| values controlling
   * when events for this bucket must be reported.
   */
  bitfield<StaBackgroundScanBucketEventReportSchemeMask> eventReportScheme;
  /**
   * For exponential back off. If |exponentialMaxPeriodInMs| is non zero or
   * different than period, then this bucket is an exponential backoff bucket
   * and the scan period must grow exponentially as per formula:
   *   actual_period(N) = period * (base ^ (N/step_count))
   * to this maximum period (in milliseconds).
   */
  uint32_t exponentialMaxPeriodInMs;
  /**
   * For exponential back off. multiplier: new_period=old_period * base
   */
  uint32_t exponentialBase;
  /**
   * For exponential back off. Number of scans to perform for a given
   * period.
   */
  uint32_t exponentialStepCount;
};

/**
 * Background Scan parameters that can be specified in background scan
 * requests.
 */
struct StaBackgroundScanParameters {
  /**
   * GCD of all bucket periods (in milliseconds).
   */
  uint32_t basePeriodInMs;
  /**
   * Maximum number of APs that must be stored for each scan. If the maximum
   * is reached the highest RSSI results must be returned.
   * Max length: |StaScanLimits.MAX_AP_CACHE_PER_SCAN|.
   */
  uint32_t maxApPerScan;
  /**
   * % cache buffer filled threshold at which the host must be notified of
   * batched scan results.
   */
  uint32_t reportThresholdPercent;
  /**
   * Threshold at which the AP must be woken up, in number of scans.
   */
  uint32_t reportThresholdNumScans;
  /**
   * List of buckets to be scheduled.
   * Max length: |StaScanLimits.MAX_BUCKETS|.
   */
  vec<StaBackgroundScanBucketParameters> buckets;
};

/**
 * Packet stats for different traffic categories.
 */
struct StaLinkLayerIfacePacketStats {
  /**
   * Number of received unicast data packets.
   */
  uint64_t rxMpdu;
  /**
   * Number of successfully transmitted unicast data pkts (ACK rcvd).
   */
  uint64_t txMpdu;
  /**
   * Number of transmitted unicast data pkt losses (no ACK).
   */
  uint64_t lostMpdu;
  /**
   * Number of transmitted unicast data retry pkts.
   */
  uint64_t retries;
};

/**
 * Iface statistics for the current connection.
 */
struct StaLinkLayerIfaceStats {
  /**
   * Number beacons received from the connected AP.
   */
  uint32_t beaconRx;
  /**
   * Access Point Beacon and Management frames RSSI (averaged).
   */
  int32_t avgRssiMgmt;
  /**
   * WME Best Effort Access Category packet counters.
   */
  StaLinkLayerIfacePacketStats wmeBePktStats;
  /**
   * WME Background Access Category packet counters.
   */
  StaLinkLayerIfacePacketStats wmeBkPktStats;
  /**
   * WME Video Access Category packet counters.
   */
  StaLinkLayerIfacePacketStats wmeViPktStats;
  /**
   * WME Voice Access Category packet counters.
   */
  StaLinkLayerIfacePacketStats wmeVoPktStats;
};

/**
 * Cumulative radio statistics since collection was enabled.
 */
struct StaLinkLayerRadioStats {
  /**
   * Time for which the radio is awake.
   */
  uint32_t onTimeInMs;
  /**
   * Total time for which the radio is in active transmission.
   */
  uint32_t txTimeInMs;
  /**
   * Time for which the radio is in active tranmission per tx level.
   */
  vec<uint32_t> txTimeInMsPerLevel;
  /**
   * Time for which the radio is in active receive.
   */
  uint32_t rxTimeInMs;
  /**
   *  Total time for which the radio is awake due to scan.
   */
  uint32_t onTimeInMsForScan;
};

/**
 * Link layer stats retrieved via |getLinkLayerStats|.
 */
struct StaLinkLayerStats {
  StaLinkLayerIfaceStats iface;
  vec<StaLinkLayerRadioStats> radios;
  /**
   * TimeStamp for each stats sample.
   * This is the absolute milliseconds from boot when these stats were
   * sampled.
   */
  TimeStampInMs timeStampInMs;
};

/**
 * Structure describing all the information about a single access point seen
 * during the scan.
 */
struct StaScanResult {
  TimeStampInUs timeStampInUs;
  vec<uint8_t> ssid;
  Bssid bssid;
  Rssi rssi;
  WifiChannelInMhz frequency;
  uint16_t beaconPeriodInMs;
  uint16_t capability;
  vec<WifiInformationElement> informationElements;
};

/**
 * Mask of flags set in the |ScanData| instance.
 */
enum StaScanDataFlagMask : int32_t {
  /**
   * Indicates that a scan was interrupted/did not occur so results may be
   * incomplete.
   */
  INTERRUPTED = 1 << 0,
};

/**
 * Structure describing all the information about all the access points seen during
 * the scan.
 */
struct StaScanData {
  /**
   * Bitset containing |ScanDataFlagMask| values.
   */
  bitfield<StaScanDataFlagMask> flags;
  /**
   * Bitset where each bit indicates if the bucket with that index (starting at
   * 0) was scanned.
   */
  uint32_t bucketsScanned;
  /**
   * List of scan results.
   */
  vec<StaScanResult> results;
};

/**
 * Structure describing the roaming control capabilities supported.
 */
struct StaRoamingCapabilities {
  /**
   * Maximum number of BSSID's that may be blacklisted.
   */
  uint32_t maxBlacklistSize;
  /**
   * Maximum number of SSID's that may be whitelisted.
   */
  uint32_t maxWhitelistSize;
};

/**
 * Structure describing the roaming control configuration.
 */
struct StaRoamingConfig {
  /**
   * List of BSSID's that are blacklisted for roaming.
   */
  vec<Bssid> bssidBlacklist;
  /**
   * List of SSID's that are whitelisted for roaming.
   */
  vec<Ssid> ssidWhitelist;
};

/**
 * Enum describing the various states to set the roaming
 * control to.
 */
enum StaRoamingState : uint8_t {
  /**
   * Driver/Firmware must not perform any roaming.
   */
  DISABLED = 0,
  /**
   * Driver/Firmware is allowed to perform roaming respecting
   * the |StaRoamingConfig| parameters set using |configureRoaming|.
   */
  ENABLED = 1
};

/**
 * NAN specific types.
 * TODO(b/32159498): Move to a separate nan_types.hal.
 *
 * References to "NAN Spec" are to the Wi-Fi Alliance "Wi-Fi Neighbor Awareness
 * Networking (NAN) Technical Specification".
 */

/**
 * Size limits for parameters used in the NAN interface.
 */
@export
enum NanParamSizeLimits : uint32_t {
  /** Minimum length of Passphrase argument for data-path configuration */
  MIN_PASSPHRASE_LENGTH = 8,

  /** Maximum length of Passphrase argument for data-path configuration */
  MAX_PASSPHRASE_LENGTH = 63,
};

/**
 * A unique short handle provided by the client to identify individual invocations of
 * certain API's like |IWifiNanIface.*|.
 */
typedef uint16_t CommandIdShort;

/**
 * NAN API response codes used in request notifications and events.
 */
enum NanStatusType : uint32_t {
  SUCCESS = 0,
  /** NAN Discovery Engine/Host driver failures */
  INTERNAL_FAILURE = 1,
  /** NAN OTA failures */
  PROTOCOL_FAILURE = 2,
  /** The publish/subscribe discovery session id is invalid */
  INVALID_SESSION_ID = 3,
  /** Out of resources to fufill request */
  NO_RESOURCES_AVAILABLE = 4,
  /** Invalid arguments passed */
  INVALID_ARGS = 5,
  /** Invalid peer id */
  INVALID_PEER_ID = 6,
  /** Invalid NAN data-path (ndp) id */
  INVALID_NDP_ID = 7,
  /** Attempting to enable NAN when not available, e.g. wifi is disabled */
  NAN_NOT_ALLOWED = 8,
  /** Over the air ACK not received */
  NO_OTA_ACK = 9,
  /** Attempting to enable NAN when already enabled */
  ALREADY_ENABLED = 10,
  /** Can't queue tx followup message foor transmission */
  FOLLOWUP_TX_QUEUE_FULL = 11,
  /** Unsupported concurrency of NAN and another feature - NAN disabled */
  UNSUPPORTED_CONCURRENCY_NAN_DISABLED = 12
};

/**
 * The discovery bands supported by NAN.
 */
enum NanBandIndex : uint32_t {
  NAN_BAND_24GHZ = 0,
  NAN_BAND_5GHZ
};

/**
 * The status information returned in NAN notifications.
 */
struct WifiNanStatus {
  /**
   * Status of the command request.
   */
  NanStatusType status;
  /**
   * Further description of the issue causing a failure.
   */
  string description;
};

/**
 * NAN Match indication type: control how often to trigger |IWifiNanIfaceEventCallback.eventMatch|
 * for a single discovery session - i.e. continuously discovering the same publisher with no new
 * data.
 */
enum NanMatchAlg : uint32_t {
  MATCH_ONCE = 0,   // Only trigger |IWifiNanIfaceEventCallback.eventMatch| once
  MATCH_CONTINUOUS, // Trigger |IWifiNanIfaceEventCallback.eventMatch| every time
  MATCH_NEVER,      // Never trigger |IWifiNanIfaceEventCallback.eventMatch|
};

/**
 * NAN publish discovery session types.
 */
enum NanPublishType : uint32_t {
  UNSOLICITED = 0,       // Publish session broadcasts discovery packets
  SOLICITED,             // Publish session silent, responds to active subscribes queries
  UNSOLICITED_SOLICITED, // Both
};

/**
 * NAN transmit type used in |NanPublishType.SOLICITED| or |NanPublishType.UNSOLICITED_SOLICITED|
 * publish discovery sessions. Describes the addressing of the packet responding to an ACTIVE
 * subscribe query.
 */
enum NanTxType : uint32_t {
  BROADCAST = 0, // Respond with a broadcast packet
  UNICAST,       // Respond with a unicast packet
};

/**
 * NAN subscribe discovery session types.
 */
enum NanSubscribeType : uint32_t {
  PASSIVE = 0, // Subscribe session scans for |NanPublishType.UNSOLICITED| publish sessions.
  ACTIVE,      // Subscribe session probes for |NanPublishType.SOLICITED| publish sessions.
};

/**
 * NAN Service Response Filter Attribute Bit.
 */
enum NanSrfType : uint32_t {
  BLOOM_FILTER = 0, // Use a Bloom filter.
  PARTIAL_MAC_ADDR, // Use a list of MAC addresses.
};

/**
 * NAN DP (data-path) channel config options.
 */
enum NanDataPathChannelCfg : uint32_t {
  CHANNEL_NOT_REQUESTED = 0, // No channel request is specified.
  REQUEST_CHANNEL_SETUP,     // Channel request is specified - but may be overridden by firmware.
  FORCE_CHANNEL_SETUP,       // Channel request is specified and must be respected. If the firmware
                             // cannot honor the request then the data-path request is rejected.
};

/**
 * NAN DP (data-path) security configuration options.
 */
enum NanDataPathSecurityType : uint32_t {
  OPEN,       // no security
  PMK,        // security: PMK
  PASSPHRASE, // security: passphrase
};

/**
 * NAN band-specific configuration.
 */
struct NanBandSpecificConfig {
  /**
   * RSSI values controlling clustering behavior per spec. RSSI values are specified without a sign,
   * e.g. a value of -65dBm would be specified as 65.
   */
  uint8_t rssiClose;  // NAN Spec: RSSI_close
  uint8_t rssiMiddle; // NAN Spec: RSSI_middle
  /**
   * RSSI value determining whether discovery is near (used if enabled in discovery by
   * |NanDiscoveryCommonConfig.useRssiThreshold|).
   * RSSI values are specified without a sign, e.g. a value of -65dBm would be specified as 65.
   * NAN Spec: RSSI_close_proximity
   */
  uint8_t rssiCloseProximity;
  /**
   * Dwell time of each discovery channel in milliseconds. If set to 0 then the firmware determines
   * the dwell time to use.
   */
  uint8_t dwellTimeMs;
  /**
   * Scan period of each discovery channel in seconds. If set to 0 then the firmware determines
   * the scan period to use.
   */
  uint16_t scanPeriodSec;
   /**
    * Specifies the discovery window interval for Sync beacons and SDF's.
    * Valid values of DW Interval are: 1, 2, 3, 4 and 5 corresponding to 1, 2, 4, 8, and 16 DWs.
    * Value of 0:
    *  - reserved in 2.4GHz band
    *  - no wakeup at all in 5GHz band
    * The publish/subscribe period values don't override this device level configurations if
    * it is specified.
    * Configuration is only used only if |validDiscoveryWindowIntervalVal| is set to true.
    * NAN Spec: Device Capability Attribute / 2.4 GHz DW, Device Capability Attribute / 5 GHz DW
    */
  bool validDiscoveryWindowIntervalVal;
  uint8_t discoveryWindowIntervalVal;
};

/**
 * Debug configuration parameters. Many of these allow non-standard-compliant operation and are
 * not intended for normal operational mode.
 */
struct NanDebugConfig {
  /**
   * Specification of the lower 2 bytes of the cluster ID. The cluster ID is 50-60-9a-01-00-00 to
   * 50-60-9a-01-FF-FF. Configuration of the bottom and top values of the range (which defaults to
   * 0x0000 and 0xFFFF respectively).
   * Configuration is only used if |validClusterIdVals| is set to true.
   */
  bool validClusterIdVals;
  uint16_t clusterIdBottomRangeVal;
  uint16_t clusterIdTopRangeVal;
  /**
   * NAN management interface address, if specified (|validIntfAddrVal| is true) then overrides any
   * other configuration (specifically the default randomization configured by
   * |NanConfigRequest.macAddressRandomizationIntervalSec|).
   */
  bool validIntfAddrVal;
  MacAddress intfAddrVal;
  /**
   * Combination of the 24 bit Organizationally Unique ID (OUI) and the 8 bit OUI Type.
   * Used if |validOuiVal| is set to true.
   */
  bool validOuiVal;
  uint32_t ouiVal;
  /**
   * Force the Random Factor to the specified value for all transmitted Sync/Discovery beacons.
   * Used if |validRandomFactorForceVal| is set to true.
   * NAN Spec: Master Indication Attribute / Random Factor
   */
  bool validRandomFactorForceVal;
  uint8_t randomFactorForceVal;
  /**
   * Forces the hop-count for all transmitted Sync and Discovery Beacons NO matter the real
   * hop-count being received over the air. Used if the |validHopCountForceVal}| flag is set to
   * true.
   * NAN Spec: Cluster Attribute / Anchor Master Information / Hop Count to Anchor Master
   */
  bool validHopCountForceVal;
  uint8_t hopCountForceVal;
  /**
   * Frequency in MHz to of the discovery channel in the specified band. Indexed by |NanBandIndex|.
   * Used if the |validDiscoveryChannelVal| is set to true.
   */
  bool validDiscoveryChannelVal;
  WifiChannelInMhz[2] discoveryChannelMhzVal;
  /**
   * Specifies whether sync/discovery beacons are transmitted in the specified band. Indexed by
   * |NanBandIndex|. Used if the |validUseBeaconsInBandVal| is set to true.
   */
  bool validUseBeaconsInBandVal;
  bool[2] useBeaconsInBandVal;
  /**
   * Specifies whether SDF (service discovery frames) are transmitted in the specified band. Indexed
   * by |NanBandIndex|. Used if the |validUseSdfInBandVal| is set to true.
   */
  bool validUseSdfInBandVal;
  bool[2] useSdfInBandVal;
};

/**
 * Configuration parameters of NAN: used when enabling and re-configuring a NAN cluster.
 */
struct NanConfigRequest {
  /**
   * Master preference of this device.
   * NAN Spec: Master Indication Attribute / Master Preference
   */
  uint8_t masterPref;
  /**
   * Controls whether or not the |IWifiNanIfaceEventCallback.eventClusterEvent| will be delivered
   * for |NanClusterEventType.DISCOVERY_MAC_ADDRESS_CHANGED|.
   */
  bool disableDiscoveryAddressChangeIndication;
  /**
   * Controls whether or not the |IWifiNanIfaceEventCallback.eventClusterEvent| will be delivered
   * for |NanClusterEventType.STARTED_CLUSTER|.
   */
  bool disableStartedClusterIndication;
  /**
   * Controls whether or not the |IWifiNanIfaceEventCallback.eventClusterEvent| will be delivered
   * for |NanClusterEventType.JOINED_CLUSTER|.
   */
  bool disableJoinedClusterIndication;
  /**
   * Control whether publish service IDs are included in Sync/Discovery beacons.
   * NAN Spec: Service ID List Attribute
   */
  bool includePublishServiceIdsInBeacon;
  /**
   * If |includePublishServiceIdsInBeacon| is true then specifies the number of publish service IDs
   * to include in the Sync/Discovery beacons:
   *  Value = 0: include as many service IDs as will fit into the maximum allowed beacon frame size.
   *  Value must fit within 7 bits - i.e. <= 127.
   */
  uint8_t numberOfPublishServiceIdsInBeacon;
  /**
   * Control whether subscribe service IDs are included in Sync/Discovery beacons.
   * Spec: Subscribe Service ID List Attribute
   */
  bool includeSubscribeServiceIdsInBeacon;
  /**
   * If |includeSubscribeServiceIdsInBeacon| is true then specifies the number of subscribe service
   * IDs to include in the Sync/Discovery beacons:
   *  Value = 0: include as many service IDs as will fit into the maximum allowed beacon frame size.
   *  Value must fit within 7 bits - i.e. <= 127.
   */
  uint8_t numberOfSubscribeServiceIdsInBeacon;
  /**
   * Number of samples used to calculate RSSI.
   */
  uint16_t rssiWindowSize;
  /**
   * Specifies the interval in seconds that the NAN management interface MAC address is randomized.
   * A value of 0 is used to disable the MAC address randomization
   */
  uint32_t macAddressRandomizationIntervalSec;
  /**
   * Additional configuration provided per band: indexed by |NanBandIndex|.
   */
  NanBandSpecificConfig[2] bandSpecificConfig;
};

/**
 * Enable requests for NAN: start-up configuration |IWifiNanIface.enableRequest|.
 */
struct NanEnableRequest {
  /**
   * Enable operation in a specific band: indexed by |NanBandIndex|.
   */
  bool[2] operateInBand;
  /**
   * Specify extent of cluster by specifying the max hop count.
   */
  uint8_t hopCountMax;
  /**
   * Configurations of NAN cluster operation. Can also be modified at run-time using
   * |IWifiNanIface.configRequest|.
   */
  NanConfigRequest configParams;
  /**
   * Non-standard configurations of NAN cluster operation - useful for debugging operations.
   */
  NanDebugConfig debugConfigs;
};

/**
 * Cipher suite flags.
 */
enum NanCipherSuiteType : uint32_t {
  NONE = 0, // No (open) security
  SHARED_KEY_128_MASK = 1 << 0, // NCS-SK-128
  SHARED_KEY_256_MASK = 1 << 1  // NCS-SK-256
};

/**
 * Ranging in the context of discovery sessions indication controls. Controls the frequency of
 * ranging-driven |IWifiNanIfaceEventCallback.eventMatch|.
 */
enum NanRangingIndication : uint32_t {
  CONTINUOUS_INDICATION_MASK = 1 << 0, // trigger event on every RTT measurement
  INGRESS_MET_MASK = 1 << 1,           // trigger event only when ingress conditions met
  EGRESS_MET_MASK = 1 << 2             // trigger event only when egress conditions met
};

/**
 * Configuration of NAN data-path security.
 */
struct NanDataPathSecurityConfig {
  /**
   * Security configuration of the data-path (NDP). Security is required if not equal to
   * |NanDataPathSecurityType.OPEN|.
   * NAN Spec: Service Discovery Extension Attribute (SDEA) / Control / Security Required
   */
  NanDataPathSecurityType securityType;
  /**
   * Cipher type for data-paths. If |securityType| is |NanDataPathSecurityType.OPEN| then must
   * be set to |NanCipherSuiteType.NONE|, otherwise a non-|NanCipherSuiteType.NONE| cipher suite
   * must be specified.
   */
  NanCipherSuiteType cipherType;
  /**
   * Optional Pairwise Master Key (PMK). Must be specified (and is only used) if |securityType| is
   * set to |NanDataPathSecurityType.PMK|.
   * Ref: IEEE 802.11i
   */
  uint8_t[32] pmk;
  /**
   * Optional Passphrase. Must be specified (and is only used) if |securityType| is set to
   * |NanDataPathSecurityType.PASSPHRASE|.
   * Min length: |MIN_PASSPHRASE_LENGTH|
   * Max length: |MAX_PASSPHRASE_LENGTH|
   * NAN Spec: Appendix: Mapping pass-phrase to PMK for NCS-SK Cipher Suites
   */
  vec<uint8_t> passphrase;
};

/**
 * Configurations of NAN discovery sessions: common to publish and subscribe discovery.
 */
struct NanDiscoveryCommonConfig {
  /**
   * The ID of the discovery session being configured. A value of 0 specifies a request to create
   * a new discovery session. The new discovery session ID is returned with
   * |IWifiNanIfaceEventCallback.notifyStartPublishResponse| or
   * |IWifiNanIfaceEventCallback.notifyStartSubscribeResponse|.
   * NAN Spec: Service Descriptor Attribute (SDA) / Instance ID
   */
  uint8_t sessionId;
  /**
   * The lifetime of the discovery session in seconds. A value of 0 means run forever or until
   * canceled using |IWifiIface.stopPublishRequest| or |IWifiIface.stopSubscribeRequest|.
   */
  uint16_t ttlSec;
  /**
   * Indicates the interval between two Discovery Windows in which the device supporting the
   * service is awake to transmit or receive the Service Discovery frames. Valid values of Awake
   * DW Interval are: 1, 2, 4, 8 and 16. A value of 0 will default to 1. Does not override
   * |NanBandSpecificConfig.discoveryWindowIntervalVal| configurations if those are specified.
   */
  uint16_t discoveryWindowPeriod;
  /**
   * The lifetime of the discovery session in number of transmitted SDF discovery packets. A value
   * of 0 means forever or until canceled using |IWifiIface.stopPublishRequest| or
   * |IWifiIface.stopSubscribeRequest|.
   */
  uint8_t discoveryCount;
  /**
   * UTF-8 encoded string identifying the service.
   * Max length: |NanCapabilities.maxServiceNameLen|.
   * NAN Spec: The only acceptable single-byte UTF-8 symbols for a Service Name are alphanumeric
   * values (A-Z, a-z, 0-9), the hyphen ('-'), and the period ('.'). All valid multi-byte UTF-8
   * characters are acceptable in a Service Name.
   */
  vec<uint8_t> serviceName;
  /**
   * Specifies how often to trigger |IWifiNanIfaceEventCallback.eventMatch| when continuously
   * discovering the same discovery session (with no changes).
   */
  NanMatchAlg discoveryMatchIndicator;
  /**
   * Arbitrary information communicated in discovery packets - there is no semantic meaning to these
   * bytes. They are passed-through from publisher to subscriber as-is with no parsing.
   * Max length: |NanCapabilities.maxServiceSpecificInfoLen|.
   * NAN Spec: Service Descriptor Attribute (SDA) / Service Info
   */
  vec<uint8_t> serviceSpecificInfo;
  /**
   * Arbitrary information communicated in discovery packets - there is no semantic meaning to these
   * bytes. They are passed-through from publisher to subscriber as-is with no parsing.
   * Max length: |NanCapabilities.maxExtendedServiceSpecificInfoLen|.
   * Spec: Service Descriptor Extension Attribute (SDEA) / Service Info
   */
  vec<uint8_t> extendedServiceSpecificInfo;
  /**
   * Ordered sequence of <length, value> pairs (|length| uses 1 byte and contains the number of
   * bytes in the |value| field) which specify further match criteria (beyond the service name).
   * The match behavior is specified in details in the NAN spec.
   * Publisher: used in SOLICITED or SOLICITED_UNSOLICITED sessions.
   * Subscriber: used in ACTIVE or PASSIVE sessions.
   * Max length: |NanCapabilities.maxMatchFilterLen|.
   * NAN Spec: matching_filter_rx
   */
  vec<uint8_t> rxMatchFilter;
  /**
   * Ordered sequence of <length, value> pairs (|length| uses 1 byte and contains the number of
   * bytes in the |value| field) which specify further match criteria (beyond the service name).
   * The match behavior is specified in details in the NAN spec.
   * Publisher: used if provided.
   * Subscriber: used (if provided) only in ACTIVE sessions.
   * Max length: |NanCapabilities.maxMatchFilterLen|.
   * NAN Spec: matching_filter_tx and Service Descriptor Attribute (SDA) / Matching Filter
   */
  vec<uint8_t> txMatchFilter;
  /**
   * Specifies whether or not the discovery session uses the
   * |NanBandSpecificConfig.rssiCloseProximity| value (configured in enable/configure requests) to
   * filter out matched discovered peers.
   * NAN Spec: Service Descriptor Attribute / Service Control / Discovery Range Limited.
   */
  bool useRssiThreshold;
  /**
   * Controls whether or not the |IWifiNanIfaceEventCallback.eventPublishTerminated| (for publish
   * discovery sessions) or |IWifiNanIfaceEventCallback.eventSubscribeTerminated| (for subscribe
   * discovery sessions) will be delivered.
   */
  bool disableDiscoveryTerminationIndication;
  /**
   * Controls whether or not the |IWifiNanIfaceEventCallback.eventMatchExpired| will be delivered.
   */
  bool disableMatchExpirationIndication;
  /**
   * Controls whether or not the |IWifiNanIfaceEventCallback.eventFollowupReceived| will be
   * delivered.
   */
  bool disableFollowupReceivedIndication;
  /**
   * Security configuration of data-paths created in the context of this discovery session. Security
   * parameters can be overridden during the actual construction of the data-path - allowing
   * individual data-paths to have unique PMKs or Passphrases.
   */
  NanDataPathSecurityConfig securityConfig;
  /**
   * Specifies whether or not there is a ranging requirement in this discovery session.
   * Ranging is only performed if all other match criteria with the peer are met. Ranging must
   * be performed if both peers in the discovery session (publisher and subscriber) set this
   * flag to true. Otherwise, if either peer sets this flag to false, ranging must not be performed
   * and must not impact discovery decisions.
   * Note: specifying that ranging is required also implies that this device must automatically
   * accept ranging requests from peers.
   * NAN Spec: Service Discovery Extension Attribute (SDEA) / Control / Ranging Require.
   */
  bool rangingRequired;
   /**
    * Interval in msec between two ranging measurements. Only relevant if |rangingRequired| is true.
    * If the Awake DW interval specified either in |discoveryWindowPeriod| or in
    * |NanBandSpecificConfig.discoveryWindowIntervalVal| is larger than the ranging interval then
    * priority is given to Awake DW interval.
    */
  uint32_t rangingIntervalMsec;
  /**
   * The type of ranging feedback to be provided by discovery session matches
   * |IWifiNanIfaceEventCallback.eventMatch|. Only relevant if |rangingRequired| is true.
   */
   bitfield<NanRangingIndication> configRangingIndications;
   /**
    * The ingress and egress distance in cm. If ranging is enabled (|rangingEnabled| is true) then
    * |configRangingIndications| is used to determine whether ingress and/or egress (or neither)
    * are used to determine whether a match has occurred.
    * NAN Spec: Service Discovery Extension Attribute (SDEA) / Ingress & Egress Range Limit
    */
   uint16_t distanceIngressCm;
   uint16_t distanceEgressCm;
};

/**
 * Publish request: specifies a publish discovery operation.
 */
struct NanPublishRequest {
  /**
   * Common configuration of discovery sessions.
   */
  NanDiscoveryCommonConfig baseConfigs;
  /**
   * The type of the publish discovery session.
   */
  NanPublishType publishType;
  /**
   * For publishType of |NanPublishType.SOLICITED| or |NanPublishType.UNSOLICITED_SOLICITED|
   * specifies the type of transmission used for responding to the probing subscribe discovery
   * peer.
   */
  NanTxType txType;
  /**
   * Specifies whether data-path requests |IWifiNanIfaceEventCallback.eventDataPathRequest| (in
   * the context of this discovery session) are automatically accepted (if true) - in which case
   * the Responder must not call the |IWifiNanIface.respondToDataPathIndicationRequest| method and
   * the device must automatically accept the data-path request and complete the negotiation.
   */
  bool autoAcceptDataPathRequests;
};

/**
 * Subscribe request: specifies a subscribe discovery operation.
 */
struct NanSubscribeRequest {
  /**
   * Common configuration of discovery sessions.
   */
  NanDiscoveryCommonConfig baseConfigs;
  /**
   * The type of the subscribe discovery session.
   */
  NanSubscribeType subscribeType;
  /**
   * For |NanSubscribeType.ACTIVE| subscribe discovery sessions specify how the Service Response
   * Filter (SRF) attribute is populated. Relevant only if |shouldUseSrf| is set to true.
   * NAN Spec: Service Descriptor Attribute (SDA) / Service Response Filter / SRF Control / SRF Type
   */
  NanSrfType srfType;
  /**
   * Configure whether inclusion of an address in |intfAddr| indicates that those devices should
   * respond or the reverse. Relevant only if |shouldUseSrf| is set to true and |srfType| is set to
   * |NanSrfType.PARTIAL_MAC_ADDR|.
   * NAN Spec: Service Descriptor Attribute (SDA) / Service Response Filter / SRF Control / Include
   */
  bool srfRespondIfInAddressSet;
  /**
   * Control whether the Service Response Filter (SRF) is used.
   * NAN Spec: Service Descriptor Attribute (SDA) / Service Control /
   *           Service Response Filter Present
   */
  bool shouldUseSrf;
  /**
   * Control whether the presence of |NanDiscoveryCommonConfig.serviceSpecificInfo| data is needed
   * in the publisher in order to trigger service discovery, i.e. a
   * |IWifiNanIfaceEventCallback.eventMatch|. The test is for presence of data - not for the
   * specific contents of the data.
   */
  bool isSsiRequiredForMatch;
  /**
   * NAN Interface Addresses constituting the Service Response Filter (SRF).
   * Max length (number of addresses): |NanCapabilities.maxSubscribeInterfaceAddresses|.
   * NAN Spec: Service Descriptor Attribute (SDA) / Service Response Filter / Address Set
   */
  vec<MacAddress> intfAddr;
};

/**
 * Transmit follow up message request.
 */
struct NanTransmitFollowupRequest {
  /**
   * ID of an active publish or subscribe discovery session. Follow-up message is transmitted in the
   * context of the discovery session.
   * NAN Spec: Service Descriptor Attribute (SDA) / Instance ID
   */
  uint8_t discoverySessionId;
  /**
   * ID of the peer. Obtained as part of an earlier |IWifiNanIfaceEventCallback.eventMatch| or
   * |IWifiNanIfaceEventCallback.eventFollowupReceived|.
   */
  uint32_t peerId;
  /**
   * MAC address of the peer. Obtained as part of an earlier |IWifiNanIfaceEventCallback.eventMatch|
   * or |IWifiNanIfaceEventCallback.eventFollowupReceived|.
   */
  MacAddress addr;
  /**
   * Should the follow-up message be transmitted with a high priority.
   */
  bool isHighPriority;
  /**
   * Should the follow-up message be transmitted in a discovery window (true) or a further
   * availability window (false).
   */
  bool shouldUseDiscoveryWindow;
  /**
   * Arbitrary information communicated to the peer - there is no semantic meaning to these
   * bytes. They are passed-through from sender to receiver as-is with no parsing.
   * Max length: |NanCapabilities.maxServiceSpecificInfoLen|.
   * NAN Spec: Service Descriptor Attribute (SDA) / Service Info
   */
  vec<uint8_t> serviceSpecificInfo;
  /**
   * Arbitrary information communicated in discovery packets - there is no semantic meaning to these
   * bytes. They are passed-through from publisher to subscriber as-is with no parsing.
   * Max length: |NanCapabilities.maxExtendedServiceSpecificInfoLen|.
   * Spec: Service Descriptor Extension Attribute (SDEA) / Service Info
   */
  vec<uint8_t> extendedServiceSpecificInfo;
  /**
   * Disable |IWifiNanIfaceEventCallback.eventTransmitFollowup| - i.e. do not get indication on
   * whether the follow-up was transmitted and received successfully.
   */
  bool disableFollowupResultIndication;
};

/**
 *  Data Path Initiator requesting a data-path.
 */
struct NanInitiateDataPathRequest {
  /**
   * ID of the peer. Obtained as part of an earlier |IWifiNanIfaceEventCallback.eventMatch| or
   * |IWifiNanIfaceEventCallback.eventFollowupReceived|.
   */
  uint32_t peerId;
  /**
   * NAN management interface MAC address of the peer. Obtained as part of an earlier
   * |IWifiNanIfaceEventCallback.eventMatch| or |IWifiNanIfaceEventCallback.eventFollowupReceived|.
   */
  MacAddress peerDiscMacAddr;
  /**
   * Config flag for channel request.
   */
  NanDataPathChannelCfg channelRequestType;
  /**
   * Channel frequency in MHz to start data-path. Not relevant if |channelRequestType| is
   * |NanDataPathChannelCfg.CHANNEL_NOT_REQUESTED|.
   */
  WifiChannelInMhz channel;
  /**
   * NAN data interface name on which this data-path session is to be initiated.
   * This must be an interface created using |IWifiNanIface.createDataInterfaceRequest|.
   */
  string ifaceName;
  /**
   * Security configuration of the requested data-path.
   */
  NanDataPathSecurityConfig securityConfig;
  /**
   * Arbitrary information communicated to the peer as part of the data-path setup process - there
   * is no semantic meaning to these bytes. They are passed-through from sender to receiver as-is
   * with no parsing.
   * Max length: |NanCapabilities.maxAppInfoLen|.
   * NAN Spec: Data Path Attributes / NDP Attribute / NDP Specific Info
   */
  vec<uint8_t> appInfo;
  /**
   * A service name to be used with |passphrase| to construct a Pairwise Master Key (PMK) for the
   * data-path. Only relevant when a data-path is requested which is not associated with a NAN
   * discovery session - e.g. using out-of-band discovery.
   * Constraints: same as |NanDiscoveryCommonConfig.serviceName|
   * NAN Spec: Appendix: Mapping pass-phrase to PMK for NCS-SK Cipher Suites
   */
  vec<uint8_t> serviceNameOutOfBand;
};

/**
 * Response to a data-path request from a peer.
 */
struct NanRespondToDataPathIndicationRequest {
  /**
   * Accept (true) or reject (false) the request.
   * NAN Spec: Data Path Attributes / NDP Attribute / Type and Status
   */
  bool acceptRequest;
  /**
   * ID of the data-path (NDP) for which we're responding - obtained as part of the request in
   * |IWifiNanIfaceEventCallback.eventDataPathRequest|.
   */
  uint32_t ndpInstanceId;
  /**
   * NAN data interface name on which this data-path session is to be started.
   * This must be an interface created using |IWifiNanIface.createDataInterfaceRequest|.
   */
  string ifaceName;
  /**
   * Security configuration of the requested data-path.
   */
  NanDataPathSecurityConfig securityConfig;
  /**
   * Arbitrary information communicated to the peer as part of the data-path setup process - there
   * is no semantic meaning to these bytes. They are passed-through from sender to receiver as-is
   * with no parsing.
   * Max length: |NanCapabilities.maxAppInfoLen|.
   * NAN Spec: Data Path Attributes / NDP Attribute / NDP Specific Info
   */
  vec<uint8_t> appInfo;
  /**
   * A service name to be used with |passphrase| to construct a Pairwise Master Key (PMK) for the
   * data-path. Only relevant when a data-path is requested which is not associated with a NAN
   * discovery session - e.g. using out-of-band discovery.
   * Constraints: same as |NanDiscoveryCommonConfig.serviceName|
   * NAN Spec: Appendix: Mapping pass-phrase to PMK for NCS-SK Cipher Suites
   */
  vec<uint8_t> serviceNameOutOfBand;
};

/**
 * NDP Capabilities response.
 */
struct NanCapabilities {
  /**
   * Maximum number of clusters which the device can join concurrently.
   */
  uint32_t maxConcurrentClusters;
  /**
   * Maximum number of concurrent publish discovery sessions.
   */
  uint32_t maxPublishes;
  /**
   * Maximum number of concurrent subscribe discovery sessions.
   */
  uint32_t maxSubscribes;
  /**
   * Maximum length (in bytes) of service name.
   */
  uint32_t maxServiceNameLen;
  /**
   * Maximum length (in bytes) of individual match filters.
   */
  uint32_t maxMatchFilterLen;
  /**
   * Maximum length (in bytes) of aggregate match filters across all active sessions.
   */
  uint32_t maxTotalMatchFilterLen;
  /**
   * Maximum length (in bytes) of the service specific info field.
   */
  uint32_t maxServiceSpecificInfoLen;
  /**
   * Maximum length (in bytes) of the extended service specific info field.
   */
  uint32_t maxExtendedServiceSpecificInfoLen;
  /**
   * Maximum number of data interfaces (NDI) which can be created concurrently on the device.
   */
  uint32_t maxNdiInterfaces;
  /**
   * Maximum number of data paths (NDP) which can be created concurrently on the device, across all
   * data interfaces (NDI).
   */
  uint32_t maxNdpSessions;
  /**
   * Maximum length (in bytes) of application info field (used in data-path negotiations).
   */
  uint32_t maxAppInfoLen;
  /**
   * Maximum number of transmitted followup messages which can be queued by the firmware.
   */
  uint32_t maxQueuedTransmitFollowupMsgs;
  /**
   * Maximum number MAC interface addresses which can be specified to a subscribe discovery session.
   */
  uint32_t maxSubscribeInterfaceAddresses;
  /**
   * The set of supported Cipher suites. The |NanCipherSuiteType| bit fields are used.
   */
  bitfield<NanCipherSuiteType> supportedCipherSuites;
};

/**
 * Match indication structure
 */
struct NanMatchInd {
  /**
   * Publish or subscribe discovery session ID of an existing discovery session.
   * NAN Spec: Service Descriptor Attribute (SDA) / Instance ID
   */
  uint8_t discoverySessionId;
  /**
   * A unique ID of the peer. Can be subsequently used in |IWifiNanIface.transmitFollowupRequest| or
   * to set up a data-path.
   */
  uint32_t peerId;
  /**
   * The NAN Discovery (management) MAC address of the peer.
   */
  MacAddress addr;
  /**
   * The arbitrary information contained in the |NanDiscoveryCommonConfig.serviceSpecificInfo| of
   * the peer's discovery session configuration.
   * Max length: |NanCapabilities.maxServiceSpecificInfoLen|.
   * NAN Spec: Service Descriptor Attribute (SDA) / Service Info
   */
  vec<uint8_t> serviceSpecificInfo;
  /**
   * Arbitrary information communicated in discovery packets - there is no semantic meaning to these
   * bytes. They are passed-through from publisher to subscriber as-is with no parsing.
   * Max length: |NanCapabilities.maxExtendedServiceSpecificInfoLen|.
   * Spec: Service Descriptor Extension Attribute (SDEA) / Service Info
   */
  vec<uint8_t> extendedServiceSpecificInfo;
  /**
   * The match filter from the discovery packet (publish or subscribe) which caused service
   * discovery. Matches the |NanDiscoveryCommonConfig.txMatchFilter| of the peer's Unsolicited
   * publish message or of the local device's Active subscribe message.
   * Max length: |NanCapabilities.maxMatchFilterLen|.
   * NAN Spec: Service Descriptor Attribute (SDA) / Matching Filter
   */
  vec<uint8_t> matchFilter;
  /**
   * Indicates the type of discovery: true if match occurred on a Beacon frame, false if the match
   * occurred on a Service Discovery Frames (SDF).
   */
  bool matchOccuredInBeaconFlag;
  /**
   * Flag to indicate firmware is out of resource and that it can no longer track this Service Name.
   * Indicates that while |IWifiNanIfaceEventCallback.eventMatch| will be received, the
   * |NanDiscoveryCommonConfig.discoveryMatchIndicator| configuration will not be honored.
   */
  bool outOfResourceFlag;
  /**
   * If RSSI filtering was enabled using |NanDiscoveryCommonConfig.useRssiThreshold| in discovery
   * session setup then this field contains the received RSSI value. It will contain 0 if RSSI
   * filtering was not enabled.
   * RSSI values are returned without sign, e.g. -70dBm will be returned as 70.
   */
  uint8_t rssiValue;
  /**
   * Cipher type for data-paths constructed in the context of this discovery session. Valid if
   * |peerRequiresSecurityEnabledInNdp| is true.
   */
  NanCipherSuiteType peerCipherType;
  /**
   * Indicates whether or not the peer requires security enabled in any data-path (NDP) constructed
   * in the context of this discovery session. The |cipherType| specifies the cipher type for such
   * data-paths.
   * NAN Spec: Service Discovery Extension Attribute (SDEA) / Control / Security Required
   */
  bool peerRequiresSecurityEnabledInNdp;
  /**
   * Indicates whether or not the peer requires (and hence allows) ranging in the context of this
   * discovery session.
   * Note that ranging is only performed if all other match criteria with the peer are met.
   * NAN Spec: Service Discovery Extension Attribute (SDEA) / Control / Ranging Require.
   */
  bool peerRequiresRanging;
  /**
   * Ranging indication supersedes the NanMatchAlg specification.
   * Ex: If NanMatchAlg is MATCH_ONCE, but ranging indications is continuous then continuous
   * match notifications will be received (with ranging information).
   * Ranging indication data is provided if Ranging required is enabled in the discovery
   * specification and:
   *   1) continuous ranging specified.
   *   2) ingress/egress specified and:
   *       - notify once for ingress >= ingress_distance and egress <= egress_distance,
   *       - same for ingress_egress_both
   * If the Awake DW intervals are larger than the ranging intervals then priority is given to the
   * device DW intervals.
   *
   * If ranging was required and executed contains the distance to the peer in CM. The
   * |rangingIndicationType| field specifies the event which triggered ranging.
   */
  uint32_t rangingMeasurementInCm;
  /**
   * The ranging event(s) which triggered the ranging. E.g. can indicate that continuous ranging was
   * requested, or else that an ingress event occurred.
   */
   bitfield<NanRangingIndication> rangingIndicationType;
};

/**
 * Followup message received from peer indication structure.
 */
struct NanFollowupReceivedInd {
  /**
   * Discovery session (publish or subscribe) ID of a previously created discovery session. The
   * message is received in the context of this discovery session.
   * NAN Spec: Service Descriptor Attribute (SDA) / Instance ID
   */
  uint8_t discoverySessionId;
  /**
   * A unique ID of the peer. Can be subsequently used in |IWifiNanIface.transmitFollowupRequest| or
   * to set up a data-path.
   */
  uint32_t peerId;
  /**
   * The NAN Discovery (management) MAC address of the peer.
   */
  MacAddress addr;
  /**
   * Indicates whether received in a further availability window (FAW) if true, or in a discovery
   * window (DW) if false.
   */
  bool receivedInFaw;
  /**
   * Received message from the peer - there is no semantic meaning to these bytes. They are
   * passed-through from sender to receiver as-is with no parsing.
   * Max length: |NanCapabilities.maxServiceSpecificInfoLen|.
   * NAN Spec: Service Descriptor Attribute (SDA) / Service Info
   */
  vec<uint8_t> serviceSpecificInfo;
  /**
   * Arbitrary information communicated in discovery packets - there is no semantic meaning to these
   * bytes. They are passed-through from publisher to subscriber as-is with no parsing.
   * Max length: |NanCapabilities.maxExtendedServiceSpecificInfoLen|.
   * Spec: Service Descriptor Extension Attribute (SDEA) / Service Info
   */
  vec<uint8_t> extendedServiceSpecificInfo;
};

/**
 * Event types for a cluster event indication.
 */
enum NanClusterEventType : uint32_t {
  /**
   * Management/discovery interface MAC address has changed (e.g. due to randomization or at
   * startup).
   */
  DISCOVERY_MAC_ADDRESS_CHANGED = 0,
  /**
   * A new cluster has been formed by this device.
   */
  STARTED_CLUSTER,
  /**
   * This device has joined an existing cluster.
   */
  JOINED_CLUSTER,
};

/**
 * Cluster event indication structure: triggered on events impacting how this device is
 * visible to peers - cluster forming, joining a new cluster, or changing of the MAC address.
 */
struct NanClusterEventInd {
  /**
   * Event type causing the cluster event indication to be triggered.
   */
  NanClusterEventType eventType;
  /**
   * MAC Address associated with the corresponding event.
   */
  MacAddress addr;
};

/**
 * NAN Data path request Indication Message structure.
 * Event indication received by an intended Responder when a Nan Data request initiated by an
 * Initiator.
 */
struct NanDataPathRequestInd {
  /**
   * ID of an active publish or subscribe discovery session - the data-path request is in the
   * context of this discovery session.
   * NAN Spec: Data Path Attributes / NDP Attribute / Publish ID
   */
  uint8_t discoverySessionId;
  /**
   * MAC address of the Initiator peer. This is the MAC address of the peer's management/discovery
   * NAN interface.
   */
  MacAddress peerDiscMacAddr;
  /**
   * ID of the data-path - used to identify the data-path in further negotiation/APIs.
   */
  uint32_t ndpInstanceId;
  /**
   * Specifies whether or not security is required by the peer for the data-path being created.
   * NAN Spec: Data Path Attributes / NDP Attribute / NDP Control / Security Present
   */
  bool securityRequired;
  /**
   * Arbitrary information communicated from the peer as part of the data-path setup process - there
   * is no semantic meaning to these bytes. They are passed-through from sender to receiver as-is
   * with no parsing.
   * Max length: |NanCapabilities.maxAppInfoLen|.
   * NAN Spec: Data Path Attributes / NDP Attribute / NDP Specific Info
   */
  vec<uint8_t> appInfo;
};

/**
 * NAN Data path confirmation Indication structure.
 * Event indication is received on both initiator and responder side when negotiation for a
 * data-path finish: on success or failure.
 */
struct NanDataPathConfirmInd {
  /**
   * ID of the data-path.
   */
  uint32_t ndpInstanceId;
  /**
   * Indicates whether the data-path setup succeeded (true) or failed (false).
   */
  bool dataPathSetupSuccess;
  /**
   * MAC address of the peer's data-interface (not it's management/discovery interface).
   */
  MacAddress peerNdiMacAddr;
  /**
   * Arbitrary information communicated from the peer as part of the data-path setup process - there
   * is no semantic meaning to these bytes. They are passed-through from sender to receiver as-is
   * with no parsing.
   * Max length: |NanCapabilities.maxAppInfoLen|.
   * NAN Spec: Data Path Attributes / NDP Attribute / NDP Specific Info
   */
  vec<uint8_t> appInfo;
  /**
   * Failure reason if |dataPathSetupSuccess| is false.
   */
  WifiNanStatus status;
};

/**
 * RTT specific types.
 * TODO(b/32159498): Move to a separate rtt_types.hal.
 */
/**
 * Ranging status.
 */
enum RttStatus : uint32_t {
  SUCCESS = 0,
  /** General failure status */
  FAILURE = 1,
  /** Target STA does not respond to request */
  FAIL_NO_RSP = 2,
  /** Request rejected. Applies to 2-sided RTT only */
  FAIL_REJECTED = 3,
  FAIL_NOT_SCHEDULED_YET = 4,
  /** Timing measurement times out */
  FAIL_TM_TIMEOUT = 5,
  /** Target on different channel, cannot range */
  FAIL_AP_ON_DIFF_CHANNEL = 6,
  /** Ranging not supported */
  FAIL_NO_CAPABILITY = 7,
  /** Request aborted for unknown reason */
  ABORTED = 8,
  /** Invalid T1-T4 timestamp */
  FAIL_INVALID_TS = 9,
  /** 11mc protocol failed */
  FAIL_PROTOCOL = 10,
  /** Request could not be scheduled */
  FAIL_SCHEDULE = 11,
  /** Responder cannot collaborate at time of request */
  FAIL_BUSY_TRY_LATER = 12,
  /** Bad request args */
  INVALID_REQ = 13,
  /** WiFi not enabled. */
  NO_WIFI = 14,
  /** Responder overrides param info, cannot range with new params */
  FAIL_FTM_PARAM_OVERRIDE = 15,
};

/**
 * RTT peer types.
 */
enum RttPeerType : uint32_t {
  AP = 0x1,
  STA = 0x2,
  P2P_GO = 0x3,
  P2P_CLIENT = 0x4,
  NAN = 0x5,
};

/**
 * RTT Measurement Bandwidth.
 */
enum RttBw : uint32_t {
  BW_5MHZ = 0x01,
  BW_10MHZ = 0x02,
  BW_20MHZ = 0x04,
  BW_40MHZ = 0x08,
  BW_80MHZ = 0x10,
  BW_160MHZ = 0x20,
};

/**
 * RTT Measurement Preamble.
 */
enum RttPreamble : uint32_t {
  LEGACY = 0x1,
  HT = 0x2,
  VHT = 0x4,
};

/**
 * RTT Types.
 */
enum RttType : uint32_t {
  ONE_SIDED = 0x1,
  TWO_SIDED = 0x2,
};

/**
 * RTT configuration.
 */
struct RttConfig {
  /**
   * Peer device mac address.
   */
  MacAddress addr;
  /**
   * 1-sided or 2-sided RTT.
   */
  RttType type;
  /**
   * Optional - peer device hint (STA, P2P, AP).
   */
  RttPeerType peer;
  /**
   * Required for STA-AP mode, optional for P2P, NBD etc.
   */
  WifiChannelInfo channel;
  /**
   * Time interval between bursts (units: 100 ms).
   * Applies to 1-sided and 2-sided RTT multi-burst requests.
   * Range: 0-31, 0: no preference by initiator (2-sided RTT).
   */
  uint32_t burstPeriod;
  /**
   * Total number of RTT bursts to be executed. It will be
   * specified in the same way as the parameter "Number of
   * Burst Exponent" found in the FTM frame format. It
   * applies to both: 1-sided RTT and 2-sided RTT. Valid
   * values are 0 to 15 as defined in 802.11mc std.
   * 0 means single shot
   * The implication of this parameter on the maximum
   * number of RTT results is the following:
   * for 1-sided RTT: max num of RTT results = (2^num_burst)*(num_frames_per_burst)
   * for 2-sided RTT: max num of RTT results = (2^num_burst)*(num_frames_per_burst - 1)
   */
  uint32_t numBurst;
  /**
   * Num of frames per burst.
   * Minimum value = 1, Maximum value = 31
   * For 2-sided this equals the number of FTM frames
   * to be attempted in a single burst. This also
   * equals the number of FTM frames that the
   * initiator will request that the responder send
   * in a single frame.
   */
  uint32_t numFramesPerBurst;
  /**
   * Number of retries for a failed RTT frame.
   * Applies to 1-sided RTT only. Minimum value = 0, Maximum value = 3
   */
  uint32_t numRetriesPerRttFrame;
  /** Following fields are only valid for 2-side RTT. */
  /**
   * Maximum number of retries that the initiator can
   * retry an FTMR frame.
   * Minimum value = 0, Maximum value = 3
   */
  uint32_t numRetriesPerFtmr;
  /**
   * Whether to request location civic info or not.
   */
  bool mustRequestLci;
  /**
   * Whether to request location civic records or not.
   */
  bool mustRequestLcr;
  /**
   * Applies to 1-sided and 2-sided RTT. Valid values will
   * be 2-11 and 15 as specified by the 802.11mc std for
   * the FTM parameter burst duration. In a multi-burst
   * request, if responder overrides with larger value,
   * the initiator will return failure. In a single-burst
   * request if responder overrides with larger value,
   * the initiator will sent TMR_STOP to terminate RTT
   * at the end of the burst_duration it requested.
   */
  uint32_t burstDuration;
  /**
   * RTT preamble to be used in the RTT frames.
   */
  RttPreamble preamble;
  /**
   * RTT BW to be used in the RTT frames.
   */
  RttBw bw;
};

/**
 * RTT results.
 */
struct RttResult {
  /**
   * Peer device mac address.
   */
  MacAddress addr;
  /**
   * Burst number in a multi-burst request.
   */
  uint32_t burstNum;
  /**
   * Total RTT measurement frames attempted.
   */
  uint32_t measurementNumber;
  /**
   * Total successful RTT measurement frames.
   */
  uint32_t successNumber;
  /**
   * Maximum number of "FTM frames per burst" supported by
   * the responder STA. Applies to 2-sided RTT only.
   * If reponder overrides with larger value:
   * - for single-burst request initiator will truncate the
   * larger value and send a TMR_STOP after receiving as
   * many frames as originally requested.
   * - for multi-burst request, initiator will return
   * failure right away.
   */
  uint8_t numberPerBurstPeer;
  /**
   * Ranging status.
   */
  RttStatus status;
  /**
   * When status == RTT_STATUS_FAIL_BUSY_TRY_LATER,
   * this will be the time provided by the responder as to
   * when the request can be tried again. Applies to 2-sided
   * RTT only. In sec, 1-31sec.
   */
  uint8_t retryAfterDuration;
  /**
   * RTT type.
   */
  RttType type;
  /**
   * Average rssi in 0.5 dB steps e.g. 143 implies -71.5 dB.
   */
  Rssi rssi;
  /**
   * Rssi spread in 0.5 dB steps e.g. 5 implies 2.5 dB spread (optional).
   */
  Rssi rssiSpread;
  /**
   * 1-sided RTT: TX rate of RTT frame.
   * 2-sided RTT: TX rate of initiator's Ack in response to FTM frame.
   */
  WifiRateInfo txRate;
  /**
   * 1-sided RTT: TX rate of Ack from other side.
   * 2-sided RTT: TX rate of FTM frame coming from responder.
   */
  WifiRateInfo rxRate;
  /**
   * Round trip time in picoseconds
   */
  TimeSpanInPs rtt;
  /**
   * Rtt standard deviation in picoseconds.
   */
  TimeSpanInPs rttSd;
  /**
   * Difference between max and min rtt times recorded in picoseconds.
   */
  TimeSpanInPs rttSpread;
  /**
   * Distance in mm (optional).
   */
  int32_t distanceInMm;
  /**
   * Standard deviation in mm (optional).
   */
  int32_t distanceSdInMm;
  /**
   * Difference between max and min distance recorded in mm (optional).
   */
  int32_t distanceSpreadInMm;
  /**
   * Time of the measurement (in microseconds since boot).
   */
  TimeStampInUs timeStampInUs;
  /**
   * in ms, actual time taken by the FW to finish one burst
   * measurement. Applies to 1-sided and 2-sided RTT.
   */
  uint32_t burstDurationInMs;
  /**
   * Number of bursts allowed by the responder. Applies
   * to 2-sided RTT only.
   */
  uint32_t negotiatedBurstNum;
  /**
   * for 11mc only.
   */
  WifiInformationElement lci;
  /**
   * for 11mc only.
   */
  WifiInformationElement lcr;
};

/**
 * RTT Capabilities.
 */
struct RttCapabilities {
  /**
   * if 1-sided rtt data collection is supported.
   */
  bool rttOneSidedSupported;
  /**
   * if ftm rtt data collection is supported.
   */
  bool rttFtmSupported;
  /**
   * if initiator supports LCI request. Applies to 2-sided RTT.
   */
  bool lciSupported;
  /**
   * if initiator supports LCR request. Applies to 2-sided RTT.
   */
  bool lcrSupported;
  /**
   * if 11mc responder mode is supported.
   */
  bool responderSupported;
  /**
   * Bit mask indicates what preamble is supported by initiator.
   * Combination of |RttPreamble| values.
   */
  bitfield<RttPreamble> preambleSupport;
  /**
   * Bit mask indicates what BW is supported by initiator.
   * Combination of |RttBw| values.
   */
  bitfield<RttBw> bwSupport;
  /**
   * Draft 11mc spec version supported by chip.
   * For instance, version 4.0 must be 40 and version 4.3 must be 43 etc.
   */
  uint8_t mcVersion;
};

/**
 * Structs for setting LCI/LCR information to be provided to a requestor.
 */
enum RttMotionPattern : uint32_t {
  /**
   * Not expected to change location.
   */
  NOT_EXPECTED = 0,
  /**
   * Expected to change location.
   */
  EXPECTED = 1,
  /**
   * Movement pattern unknown.
   */
  UNKNOWN = 2,
};

/**
 * Movement pattern unknown.
 */
struct RttLciInformation {
  /**
   * latitude in degrees * 2^25 , 2's complement.
   */
  int64_t latitude;
  /**
   * longitude in degrees * 2^25 , 2's complement.
   */
  int64_t longitude;
  /**
   * Altitude in units of 1/256 m.
   */
  int32_t altitude;
  /**
   * As defined in Section 2.3.2 of IETF RFC 6225.
   */
  uint8_t latitudeUnc;
  /**
   * As defined in Section 2.3.2 of IETF RFC 6225.
   */
  uint8_t longitudeUnc;
  /**
   * As defined in Section 2.4.5 from IETF RFC 6225.
   */
  uint8_t altitudeUnc;
  /** Following element for configuring the Z subelement. */
  /**
   * Motion pattern type.
   */
  RttMotionPattern motionPattern;
  /**
   * Floor in units of 1/16th of floor. 0x80000000 if unknown.
   */
  int32_t floor;
  /**
   * in units of 1/64 m.
   */
  int32_t heightAboveFloor;
  /**
   * in units of 1/64 m. 0 if unknown
   */
  int32_t heightUnc;
};

struct RttLcrInformation {
  /**
   * Country code symbol.
   */
  int8_t[2] countryCode;
  /**
   * Civic info to be copied in FTM frame.
   */
  string civicInfo;
};

/***
 * RTT Responder information
 */
struct RttResponder {
  WifiChannelInfo channel;
  RttPreamble preamble;
};

/**
 * Debug data specific types.
 * TODO(b/32159498): Move to a separate debug_types.hal.
 */
typedef uint32_t WifiRingBufferId;

/**
 * Flags describing each debug ring buffer.
 */
enum WifiDebugRingBufferFlags : uint32_t {
  HAS_BINARY_ENTRIES = 1 << 0,
  HAS_ASCII_ENTRIES = 1 << 1,
  HAS_PER_PACKET_ENTRIES = 1 << 2,
};

/**
 * Struct describing each debug ring buffer supported by
 * the device.
 */
struct WifiDebugRingBufferStatus {
  /**
   * Name of this debug ring buffer.
   */
  string ringName;
  /**
   * Combination of |WifiDebugRingBufferFlags| values.
   */
  uint32_t flags;
  /**
   * Unique integer representing the ring.
   */
  WifiRingBufferId ringId;
  /**
   * Total memory size allocated for the buffer.
   */
  uint32_t sizeInBytes;
  /**
   * Amount of free space in the buffer.
   */
  uint32_t freeSizeInBytes;
  /**
   * Verbose level for ring buffer.
   */
  uint32_t verboseLevel;
};

/**
 * Verbose logging level to set for each debug ring buffer supported
 * by the device.
 */
enum WifiDebugRingBufferVerboseLevel : uint32_t {
  /**
   * Level 0 corresponds to no collection, and it makes log handler
   * stop by no more events from driver.
   */
  NONE = 0,
  /**
   * Level 1 correspond to normal log level, with minimal user impact.
   * This is the default value.
   */
  DEFAULT = 1,
  /**
   * Level 2 is enabled when user is lazily trying to reproduce a problem,
   * wifi performances and power can be impacted but device should not
   * otherwise be significantly impacted.
   */
  VERBOSE = 2,
  /**
   * Level 3 is used when trying to actively debug a problem.
   * This will cause sever performance degradation.
   */
  EXCESSIVE = 3
};

/**
 * Enum describing the fate of the TX packets.
 */
enum WifiDebugTxPacketFate : uint32_t {
  /**
   * Sent over air and ACKed.
   */
  ACKED,
  /**
   * Sent over air but not ACKed. (Normal for broadcast/multicast.)
   */
  SENT,
  /**
   * Queued within firmware, but not yet sent over air.
   */
  FW_QUEUED,
  /**
   * Dropped by firmware as invalid. E.g. bad source address, bad checksum,
   * or invalid for current state.
   */
  FW_DROP_INVALID,
  /**
   * Dropped by firmware due to lack of buffer space.
   */
  FW_DROP_NOBUFS,
  /**
   * Dropped by firmware for any other reason. Includes frames that  were sent
   * by driver to firmware, but unaccounted for by  firmware.
   */
  FW_DROP_OTHER,
  /**
   * Queued within driver, not yet sent to firmware.
   */
  DRV_QUEUED,
  /**
   * Dropped by driver as invalid. E.g. bad source address, or invalid for
   * current state.
   */
  DRV_DROP_INVALID,
  /**
   * Dropped by driver due to lack of buffer space.
   */
  DRV_DROP_NOBUFS,
  /**
   * Dropped by driver for any other reason.
   */
  DRV_DROP_OTHER,
};

/**
 * Enum describing the fate of the TX packets.
 */
enum WifiDebugRxPacketFate : uint32_t {
  /**
   * Valid and delivered to network stack (e.g., netif_rx()).
   */
  SUCCESS,
  /**
   * Queued within firmware, but not yet sent to driver.
   */
  FW_QUEUED,
  /**
   * Dropped by firmware due to host-programmable filters.
   */
  FW_DROP_FILTER,
  /**
   * Dropped by firmware as invalid. E.g. bad checksum, decrypt failed,
   * or invalid for current state.
   */
  FW_DROP_INVALID,
  /**
   * Dropped by firmware due to lack of buffer space.
   */
  FW_DROP_NOBUFS,
  /**
   * Dropped by firmware for any other reason.
   */
  FW_DROP_OTHER,
  /**
   * Queued within driver, not yet delivered to network stack.
   */
  DRV_QUEUED,
  /**
   * Dropped by driver due to filter rules.
   */
  DRV_DROP_FILTER,
  /**
   * Dropped by driver as invalid. E.g. not permitted in current state.
   */
  DRV_DROP_INVALID,
  /**
   * Dropped by driver due to lack of buffer space.
   */
  DRV_DROP_NOBUFS,
  /**
   * Dropped by driver for any other reason.
   */
  DRV_DROP_OTHER,
};

/**
 * Type of frame transmitted/received.
 */
enum WifiDebugPacketFateFrameType : uint32_t {
  UNKNOWN,
  ETHERNET_II,
  MGMT_80211,
};

/**
 * Information regarding the frame transmitted/received.
 */
struct WifiDebugPacketFateFrameInfo {
  /**
   * The type of MAC-layer frame that this frame_info holds.
   * - For data frames, use FRAME_TYPE_ETHERNET_II.
   * - For management frames, use FRAME_TYPE_80211_MGMT.
   * - If the type of the frame is unknown, use FRAME_TYPE_UNKNOWN.
   */
  WifiDebugPacketFateFrameType frameType;
  /**
   * The number of bytes included in |frameContent|.
   * If the frame  contents are missing (e.g. RX frame dropped in firmware),
   * |frameLen| must be set to 0.
   */
  uint64_t frameLen;
  /**
   * Host clock when this frame was received by the driver (either  outbound
   * from the host network stack, or inbound from the firmware).
   * - The timestamp must be taken from a clock which includes time the host
   *   spent suspended (e.g. ktime_get_boottime()).
   * - If no host timestamp is available (e.g. RX frame was dropped in firmware),
   *   this field must be set to 0.
   */
  TimeStampInUs driverTimestampUsec;
  /**
   * Firmware clock when this frame was received by the firmware
   * (either outbound from the host, or inbound from a remote  station).
   * - The timestamp must be taken from a clock which includes time firmware
   *   spent suspended (if applicable).
   * - If no firmware timestamp is available (e.g. TX frame was dropped by
   *   driver), this field must be set to 0.
   * - Consumers of |frameInfo| must not assume any synchronization between
   *   driver and firmware clocks.
   */
  TimeStampInUs firmwareTimestampUsec;
  /**
   * Actual frame content. This is the raw bytes of the corresponding packet.
   * - Should be provided for TX frames originated by the host.
   * - Should be provided for RX frames received by the driver.
   * - Optionally provided for TX frames originated by firmware.
   *   (At discretion of HAL implementation.)
   * - Optionally provided for RX frames dropped in firmware.
   *   (At discretion of HAL implementation.)
   * - If frame content is not provided, |frameLen| must be set to 0.
   */
  vec<uint8_t> frameContent;
};

/**
 * Struct describing packet fate report for each Tx frame.
 */
struct WifiDebugTxPacketFateReport {
  WifiDebugTxPacketFate fate;
  WifiDebugPacketFateFrameInfo frameInfo;
};

/**
 * Struct describing packet fate report for each Rx frame.
 */
struct WifiDebugRxPacketFateReport {
  WifiDebugRxPacketFate fate;
  WifiDebugPacketFateFrameInfo frameInfo;
};

/**
 * Struct capturing the count of all rx packets that caused
 * host wakeup.
 */
struct WifiDebugHostWakeReasonRxPacketDetails {
  /**
   * Total rx unicast packet which woke up host.
   */
  uint32_t rxUnicastCnt;
  /**
   * Total rx multicast packet which woke up host.
   */
  uint32_t rxMulticastCnt;
  /**
   * Total rx broadcast packet which woke up host.
   */
  uint32_t rxBroadcastCnt;
};

/**
 * Struct capturing the count of all rx multicast packets that caused
 * host wakeup.
 */
struct WifiDebugHostWakeReasonRxMulticastPacketDetails {
  /**
   * Rx wake packet was ipv4 multicast.
   */
  uint32_t ipv4RxMulticastAddrCnt;
  /**
   * Rx wake packet was ipv6 multicast.
   */
  uint32_t ipv6RxMulticastAddrCnt;
  /**
   * Rx wake packet was non-ipv4 and non-ipv6.
   */
  uint32_t otherRxMulticastAddrCnt;
};

/**
 * Struct capturing the count of all rx ICMP packets that caused
 * host wakeup.
 */
struct WifiDebugHostWakeReasonRxIcmpPacketDetails {
  /**
   * Wake icmp packet count.
   */
  uint32_t icmpPkt;
  /**
   * Wake icmp6 packet count.
   */
  uint32_t icmp6Pkt;
  /**
   * Wake icmp6 RA packet count.
   */
  uint32_t icmp6Ra;
  /**
   * Wake icmp6 NA packet count.
   */
  uint32_t icmp6Na;
  /**
   * Wake icmp6 NS packet count.
   */
  uint32_t icmp6Ns;
};

/**
 * Structure capturing the count of all the wireless related host wakeup.
 * This is used to capture all the reasons why the host processor
 * (WLAN driver) was woken up by the WLAN firmware.
 * These stats may be used to debug any power issues caused due to frequent
 * wakeup of the host processor by the WLAN firmware.
 */
struct WifiDebugHostWakeReasonStats {
  /**
   * Total count of cmd/event wakes.
   * These must account for all wakeups due to WLAN management
   * commands/events received over the air.
   */
  uint32_t totalCmdEventWakeCnt;
  /**
   * Vector of wake counts per cmd/event type.
   * The number of command types and their meaning is only understood by the
   * vendor.
   */
  vec<uint32_t> cmdEventWakeCntPerType;
  /**
   * Total count of drive/fw wakes.
   * These must account for all wakeups due to local driver/firmware
   * interactions. These include all vendor implementation specific
   * interactions like any heart-beat monitoring, Bus management, etc.
   */
  uint32_t totalDriverFwLocalWakeCnt;
  /**
   * Vector of wake counts per driver/firmware interaction type.
   * The number of command types and their meaning is only understood by the
   * vendor.
   */
  vec<uint32_t> driverFwLocalWakeCntPerType;
  /**
   * Total data rx packets, that woke up host.
   */
  uint32_t totalRxPacketWakeCnt;
  WifiDebugHostWakeReasonRxPacketDetails rxPktWakeDetails;
  WifiDebugHostWakeReasonRxMulticastPacketDetails rxMulticastPkWakeDetails;
  WifiDebugHostWakeReasonRxIcmpPacketDetails rxIcmpPkWakeDetails;
};