diff --git a/wifi/legacy_headers/Android.bp b/wifi/legacy_headers/Android.bp new file mode 100644 index 0000000000..725d42c585 --- /dev/null +++ b/wifi/legacy_headers/Android.bp @@ -0,0 +1,40 @@ +// Copyright (C) 2024 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. + +cc_library_headers { + name: "wifi_legacy_headers", + vendor_available: true, + export_include_dirs: ["include"], + + header_libs: ["libcutils_headers"], + export_header_lib_headers: ["libcutils_headers"], +} + +cc_library_shared { + name: "wifi_legacy", + vendor_available: true, + + header_libs: [ + "wifi_legacy_headers", + ], + export_header_lib_headers: ["wifi_legacy_headers"], + + export_include_dirs: ["include"], + + cflags: [ + "-DQEMU_HARDWARE", + "-Wall", + "-Werror", + ], +} diff --git a/wifi/legacy_headers/include/hardware_legacy/gscan.h b/wifi/legacy_headers/include/hardware_legacy/gscan.h new file mode 100644 index 0000000000..d5d8b9c733 --- /dev/null +++ b/wifi/legacy_headers/include/hardware_legacy/gscan.h @@ -0,0 +1,430 @@ +#include "wifi_hal.h" + +#ifndef __WIFI_HAL_GSCAN_H__ +#define __WIFI_HAL_GSCAN_H__ + +// Define static_assert() unless already defined by compiler. +#ifndef __has_feature + #define __has_feature(__x) 0 +#endif +#if !(__has_feature(cxx_static_assert)) && !defined(static_assert) + #define static_assert(__b, __m) \ + extern int compile_time_assert_failed[ ( __b ) ? 1 : -1 ] \ + __attribute__( ( unused ) ); +#endif + +/* AP Scans */ + +typedef enum { + WIFI_BAND_UNSPECIFIED, + WIFI_BAND_BG = 1, // 2.4 GHz + WIFI_BAND_A = 2, // 5 GHz without DFS + WIFI_BAND_A_DFS = 4, // 5 GHz DFS only + WIFI_BAND_A_WITH_DFS = 6, // 5 GHz with DFS + WIFI_BAND_ABG = 3, // 2.4 GHz + 5 GHz; no DFS + WIFI_BAND_ABG_WITH_DFS = 7, // 2.4 GHz + 5 GHz with DFS +} wifi_band; + +#define MAX_CHANNELS 16 +#define MAX_BUCKETS 16 +#define MAX_HOTLIST_APS 128 +#define MAX_SIGNIFICANT_CHANGE_APS 64 +#define MAX_EPNO_NETWORKS 64 +#define MAX_HOTLIST_SSID 8 +#define MAX_AP_CACHE_PER_SCAN 32 + +wifi_error wifi_get_valid_channels(wifi_interface_handle handle, + int band, int max_channels, wifi_channel *channels, int *num_channels); + +typedef struct { + int max_scan_cache_size; // total space allocated for scan (in bytes) + int max_scan_buckets; // maximum number of channel buckets + int max_ap_cache_per_scan; // maximum number of APs that can be stored per scan + int max_rssi_sample_size; // number of RSSI samples used for averaging RSSI + int max_scan_reporting_threshold; // max possible report_threshold as described + // in wifi_scan_cmd_params + int max_hotlist_bssids; // maximum number of entries for hotlist BSSIDs + int max_hotlist_ssids; // maximum number of entries for hotlist SSIDs + int max_significant_wifi_change_aps; // maximum number of entries for + // significant wifi change APs + int max_bssid_history_entries; // number of BSSID/RSSI entries that device can hold + int max_number_epno_networks; // max number of epno entries + int max_number_epno_networks_by_ssid; // max number of epno entries if ssid is specified, + // that is, epno entries for which an exact match is + // required, or entries corresponding to hidden ssids + int max_number_of_white_listed_ssid; // max number of white listed SSIDs, M target is 2 to 4 +} wifi_gscan_capabilities; + +wifi_error wifi_get_gscan_capabilities(wifi_interface_handle handle, + wifi_gscan_capabilities *capabilities); + +typedef enum { + WIFI_SCAN_RESULTS_AVAILABLE, // reported when REPORT_EVENTS_EACH_SCAN is set and a scan + // completes. WIFI_SCAN_THRESHOLD_NUM_SCANS or + // WIFI_SCAN_THRESHOLD_PERCENT can be reported instead if the + // reason for the event is available; however, at most one of + // these events should be reported per scan. If there are + // multiple buckets that were scanned this period and one has the + // EACH_SCAN flag set then this event should be prefered. + WIFI_SCAN_THRESHOLD_NUM_SCANS, // can be reported when REPORT_EVENTS_EACH_SCAN is not set and + // report_threshold_num_scans is reached. + WIFI_SCAN_THRESHOLD_PERCENT, // can be reported when REPORT_EVENTS_EACH_SCAN is not set and + // report_threshold_percent is reached. + WIFI_SCAN_FAILED, // reported when currently executing gscans have failed. + // start_gscan will need to be called again in order to continue + // scanning. This is intended to indicate abnormal scan + // terminations (not those as a result of stop_gscan). +} wifi_scan_event; + + +/* Format of information elements found in the beacon */ +typedef struct { + byte id; // element identifier + byte len; // number of bytes to follow + byte data[]; +} wifi_information_element; + +typedef struct { + wifi_timestamp ts; // time since boot (in microsecond) when the result was + // retrieved + char ssid[32+1]; // null terminated + mac_addr bssid; + wifi_channel channel; // channel frequency in MHz + wifi_rssi rssi; // in db + wifi_timespan rtt; // in nanoseconds + wifi_timespan rtt_sd; // standard deviation in rtt + unsigned short beacon_period; // period advertised in the beacon + unsigned short capability; // capabilities advertised in the beacon + unsigned int ie_length; // size of the ie_data blob + char ie_data[1]; // blob of all the information elements found in the + // beacon; this data should be a packed list of + // wifi_information_element objects, one after the other. + // other fields +} wifi_scan_result; + +static_assert(MAX_BUCKETS <= 8 * sizeof(unsigned), + "The buckets_scanned bitset is represented by an unsigned int and cannot support this many " + "buckets on this platform."); +typedef struct { + /* reported when each probe response is received, if report_events + * enabled in wifi_scan_cmd_params. buckets_scanned is a bitset of the + * buckets that are currently being scanned. See the buckets_scanned field + * in the wifi_cached_scan_results struct for more details. + */ + void (*on_full_scan_result) (wifi_request_id id, wifi_scan_result *result, + unsigned buckets_scanned); + + /* indicates progress of scanning statemachine */ + void (*on_scan_event) (wifi_request_id id, wifi_scan_event event); + +} wifi_scan_result_handler; + +typedef struct { + wifi_channel channel; // frequency + int dwellTimeMs; // dwell time hint + int passive; // 0 => active, 1 => passive scan; ignored for DFS + /* Add channel class */ +} wifi_scan_channel_spec; + +#define REPORT_EVENTS_EACH_SCAN (1 << 0) +#define REPORT_EVENTS_FULL_RESULTS (1 << 1) +#define REPORT_EVENTS_NO_BATCH (1 << 2) + +typedef struct { + int bucket; // bucket index, 0 based + wifi_band band; // when UNSPECIFIED, use channel list + int period; // desired period, in millisecond; if this is too + // low, the firmware should choose to generate results as + // fast as it can instead of failing the command. + // for exponential backoff bucket this is the min_period + /* report_events semantics - + * This is a bit field; which defines following bits - + * REPORT_EVENTS_EACH_SCAN => report a scan completion event after scan. If this is not set + * then scan completion events should be reported if + * report_threshold_percent or report_threshold_num_scans is + * reached. + * REPORT_EVENTS_FULL_RESULTS => 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. + * REPORT_EVENTS_NO_BATCH => controls if scans for this bucket should be placed in the + * history buffer + */ + byte report_events; + int max_period; // if max_period is non zero or different than period, then this bucket is + // an exponential backoff bucket and the scan period will grow exponentially + // as per formula: actual_period(N) = period * (base ^ (N/step_count)) + // to a maximum period of max_period + int base; // for exponential back off bucket: multiplier: new_period=old_period*base + int step_count; // for exponential back off bucket, number of scans to perform for a given + // period + + int num_channels; + // channels to scan; these may include DFS channels + // Note that a given channel may appear in multiple buckets + wifi_scan_channel_spec channels[MAX_CHANNELS]; +} wifi_scan_bucket_spec; + +typedef struct { + int base_period; // base timer period in ms + int max_ap_per_scan; // number of access points to store in each scan entry in + // the BSSID/RSSI history buffer (keep the highest RSSI + // access points) + int report_threshold_percent; // in %, when scan buffer is this much full, wake up apps + // processor + int report_threshold_num_scans; // in number of scans, wake up AP after these many scans + int num_buckets; + wifi_scan_bucket_spec buckets[MAX_BUCKETS]; +} wifi_scan_cmd_params; + +/* + * Start periodic GSCAN + * When this is called all requested buckets should be scanned, starting the beginning of the cycle + * + * For example: + * If there are two buckets specified + * - Bucket 1: period=10s + * - Bucket 2: period=20s + * - Bucket 3: period=30s + * Then the following scans should occur + * - t=0 buckets 1, 2, and 3 are scanned + * - t=10 bucket 1 is scanned + * - t=20 bucket 1 and 2 are scanned + * - t=30 bucket 1 and 3 are scanned + * - t=40 bucket 1 and 2 are scanned + * - t=50 bucket 1 is scanned + * - t=60 buckets 1, 2, and 3 are scanned + * - and the patter repeats + * + * If any scan does not occur or is incomplete (error, interrupted, etc) then a cached scan result + * should still be recorded with the WIFI_SCAN_FLAG_INTERRUPTED flag set. + */ +wifi_error wifi_start_gscan(wifi_request_id id, wifi_interface_handle iface, + wifi_scan_cmd_params params, wifi_scan_result_handler handler); + +/* Stop periodic GSCAN */ +wifi_error wifi_stop_gscan(wifi_request_id id, wifi_interface_handle iface); + +typedef enum { + WIFI_SCAN_FLAG_INTERRUPTED = 1 // Indicates that scan results are not complete because + // probes were not sent on some channels +} wifi_scan_flags; + +/* Get the GSCAN cached scan results */ +typedef struct { + int scan_id; // a unique identifier for the scan unit + int flags; // a bitmask with additional + // information about scan. + unsigned buckets_scanned; // a bitset of the buckets that were scanned. + // for example a value of 13 (0b1101) would + // indicate that buckets 0, 2 and 3 were + // scanned to produce this list of results. + // should be set to 0 if this information is + // not available. + int num_results; // number of bssids retrieved by the scan + wifi_scan_result results[MAX_AP_CACHE_PER_SCAN]; // scan results - one for each bssid +} wifi_cached_scan_results; + +wifi_error wifi_get_cached_gscan_results(wifi_interface_handle iface, byte flush, + int max, wifi_cached_scan_results *results, int *num); + +/* BSSID Hotlist */ +typedef struct { + void (*on_hotlist_ap_found)(wifi_request_id id, + unsigned num_results, wifi_scan_result *results); + void (*on_hotlist_ap_lost)(wifi_request_id id, + unsigned num_results, wifi_scan_result *results); +} wifi_hotlist_ap_found_handler; + +typedef struct { + mac_addr bssid; // AP BSSID + wifi_rssi low; // low threshold + wifi_rssi high; // high threshold +} ap_threshold_param; + +typedef struct { + int lost_ap_sample_size; + int num_bssid; // number of hotlist APs + ap_threshold_param ap[MAX_HOTLIST_APS]; // hotlist APs +} wifi_bssid_hotlist_params; + +/* Set the BSSID Hotlist */ +wifi_error wifi_set_bssid_hotlist(wifi_request_id id, wifi_interface_handle iface, + wifi_bssid_hotlist_params params, wifi_hotlist_ap_found_handler handler); + +/* Clear the BSSID Hotlist */ +wifi_error wifi_reset_bssid_hotlist(wifi_request_id id, wifi_interface_handle iface); + +/* SSID Hotlist */ +typedef struct { + void (*on_hotlist_ssid_found)(wifi_request_id id, + unsigned num_results, wifi_scan_result *results); + void (*on_hotlist_ssid_lost)(wifi_request_id id, + unsigned num_results, wifi_scan_result *results); +} wifi_hotlist_ssid_handler; + +typedef struct { + char ssid[32+1]; // SSID + wifi_band band; // band for this set of threshold params + wifi_rssi low; // low threshold + wifi_rssi high; // high threshold +} ssid_threshold_param; + +typedef struct { + int lost_ssid_sample_size; + int num_ssid; // number of hotlist SSIDs + ssid_threshold_param ssid[MAX_HOTLIST_SSID]; // hotlist SSIDs +} wifi_ssid_hotlist_params; + +/* Significant wifi change */ +typedef struct { + mac_addr bssid; // BSSID + wifi_channel channel; // channel frequency in MHz + int num_rssi; // number of rssi samples + wifi_rssi rssi[]; // RSSI history in db +} wifi_significant_change_result; + +typedef struct { + void (*on_significant_change)(wifi_request_id id, + unsigned num_results, wifi_significant_change_result **results); +} wifi_significant_change_handler; + +// The sample size parameters in the wifi_significant_change_params structure +// represent the number of occurence of a g-scan where the BSSID was seen and RSSI was +// collected for that BSSID, or, the BSSID was expected to be seen and didn't. +// for instance: lost_ap_sample_size : number of time a g-scan was performed on the +// channel the BSSID was seen last, and the BSSID was not seen during those g-scans +typedef struct { + int rssi_sample_size; // number of samples for averaging RSSI + int lost_ap_sample_size; // number of samples to confirm AP loss + int min_breaching; // number of APs breaching threshold + int num_bssid; // max 64 + ap_threshold_param ap[MAX_SIGNIFICANT_CHANGE_APS]; +} wifi_significant_change_params; + +/* Set the Signifcant AP change list */ +wifi_error wifi_set_significant_change_handler(wifi_request_id id, wifi_interface_handle iface, + wifi_significant_change_params params, wifi_significant_change_handler handler); + +/* Clear the Signifcant AP change list */ +wifi_error wifi_reset_significant_change_handler(wifi_request_id id, wifi_interface_handle iface); + +/* Random MAC OUI for PNO */ +wifi_error wifi_set_scanning_mac_oui(wifi_interface_handle handle, oui scan_oui); + + +// Enhanced PNO: +// Enhanced PNO feature is expected to be enabled all of the time (e.g. screen lit) and may thus +// require firmware to store a large number of networks, covering the whole list of known networks. +// Therefore, it is acceptable for firmware to store a crc24, crc32 or other short hash of the SSID, +// such that a low but non-zero probability of collision exist. With that scheme it should be +// possible for firmware to keep an entry as small as 4 bytes for each pno network. +// For instance, a firmware pn0 entry can be implemented in the form of: +// PNO ENTRY = crc24(3 bytes) | flags>>3 (5 bits) | auth flags(3 bits) +// +// No scans should be automatically performed by the chip. Instead all scan results from gscan +// should be scored and the wifi_epno_handler on_network_found callback should be called with +// the scan results. +// +// A PNO network shall be reported once, that is, once a network is reported by firmware +// its entry shall be marked as "done" until framework calls wifi_set_epno_list again. +// Calling wifi_set_epno_list shall reset the "done" status of pno networks in firmware. +// +// A network should only be considered found if its RSSI is above the minimum RSSI for its +// frequency range (min5GHz_rssi and min24GHz_rssi for 5GHz and 2.4GHz networks respectively). +// When disconnected the list of scan results should be returned if any network is found. +// When connected the scan results shall be reported only if the score of any network in the scan +// is greater than that of the currently connected BSSID. +// +// The FW should calculate the score of all the candidates (including currently connected one) +// with following equation: +// RSSI score = (RSSI + 85) * 4; +// If RSSI score > initial_score_max , RSSI score = initial_score_max; +// final score = RSSI score +// + current_connection_bonus (if currently connected BSSID) +// + same_network_bonus (if network has SAME_NETWORK flag) +// + secure_bonus (if the network is not open) +// + band5GHz_bonus (if BSSID is on 5G) +// If there is a BSSID’s score > current BSSID’s score, then report the cached scan results +// at the end of the scan (excluding the ones on blacklist) to the upper layer. +// Additionally, all BSSIDs that are in the BSSID blacklist should be ignored by Enhanced PNO + +// Whether directed scan needs to be performed (for hidden SSIDs) +#define WIFI_PNO_FLAG_DIRECTED_SCAN (1 << 0) +// Whether PNO event shall be triggered if the network is found on A band +#define WIFI_PNO_FLAG_A_BAND (1 << 1) +// Whether PNO event shall be triggered if the network is found on G band +#define WIFI_PNO_FLAG_G_BAND (1 << 2) +// Whether strict matching is required +// If required then the firmware must store the network's SSID and not just a hash +#define WIFI_PNO_FLAG_STRICT_MATCH (1 << 3) +// If this SSID should be considered the same network as the currently connected one for scoring +#define WIFI_PNO_FLAG_SAME_NETWORK (1 << 4) + +// Code for matching the beacon AUTH IE - additional codes TBD +#define WIFI_PNO_AUTH_CODE_OPEN (1 << 0) // open +#define WIFI_PNO_AUTH_CODE_PSK (1 << 1) // WPA_PSK or WPA2PSK +#define WIFI_PNO_AUTH_CODE_EAPOL (1 << 2) // any EAPOL + +typedef struct { + char ssid[32+1]; // null terminated + byte flags; // WIFI_PNO_FLAG_XXX + byte auth_bit_field; // auth bit field for matching WPA IE +} wifi_epno_network; + +/* ePNO Parameters */ +typedef struct { + int min5GHz_rssi; // minimum 5GHz RSSI for a BSSID to be considered + int min24GHz_rssi; // minimum 2.4GHz RSSI for a BSSID to be considered + int initial_score_max; // the maximum score that a network can have before bonuses + int current_connection_bonus; // only report when there is a network's score this much higher + // than the current connection. + int same_network_bonus; // score bonus for all networks with the same network flag + int secure_bonus; // score bonus for networks that are not open + int band5GHz_bonus; // 5GHz RSSI score bonus (applied to all 5GHz networks) + int num_networks; // number of wifi_epno_network objects + wifi_epno_network networks[MAX_EPNO_NETWORKS]; // PNO networks +} wifi_epno_params; + +typedef struct { + // on results + void (*on_network_found)(wifi_request_id id, + unsigned num_results, wifi_scan_result *results); +} wifi_epno_handler; + + +/* Set the ePNO list - enable ePNO with the given parameters */ +wifi_error wifi_set_epno_list(wifi_request_id id, wifi_interface_handle iface, + const wifi_epno_params *epno_params, wifi_epno_handler handler); + +/* Reset the ePNO list - no ePNO networks should be matched after this */ +wifi_error wifi_reset_epno_list(wifi_request_id id, wifi_interface_handle iface); + + +typedef struct { + int id; // identifier of this network block, report this in event + char realm[256]; // null terminated UTF8 encoded realm, 0 if unspecified + int64_t roamingConsortiumIds[16]; // roaming consortium ids to match, 0s if unspecified + byte plmn[3]; // mcc/mnc combination as per rules, 0s if unspecified +} wifi_passpoint_network; + +typedef struct { + void (*on_passpoint_network_found)( + wifi_request_id id, + int net_id, // network block identifier for the matched network + wifi_scan_result *result, // scan result, with channel and beacon information + int anqp_len, // length of ANQP blob + byte *anqp // ANQP data, in the information_element format + ); +} wifi_passpoint_event_handler; + +/* Sets a list for passpoint networks for PNO purposes; it should be matched + * against any passpoint networks (designated by Interworking element) found + * during regular PNO scan. */ +wifi_error wifi_set_passpoint_list(wifi_request_id id, wifi_interface_handle iface, int num, + wifi_passpoint_network *networks, wifi_passpoint_event_handler handler); + +/* Reset passpoint network list - no Passpoint networks should be matched after this */ +wifi_error wifi_reset_passpoint_list(wifi_request_id id, wifi_interface_handle iface); + +#endif diff --git a/wifi/legacy_headers/include/hardware_legacy/link_layer_stats.h b/wifi/legacy_headers/include/hardware_legacy/link_layer_stats.h new file mode 100644 index 0000000000..f4e16c636f --- /dev/null +++ b/wifi/legacy_headers/include/hardware_legacy/link_layer_stats.h @@ -0,0 +1,342 @@ +#include "wifi_hal.h" + +#ifndef __WIFI_HAL_STATS_H +#define __WIFI_HAL_STATS_H + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + +#define STATS_MAJOR_VERSION 1 +#define STATS_MINOR_VERSION 0 +#define STATS_MICRO_VERSION 0 + +typedef enum { + WIFI_DISCONNECTED = 0, + WIFI_AUTHENTICATING = 1, + WIFI_ASSOCIATING = 2, + WIFI_ASSOCIATED = 3, + WIFI_EAPOL_STARTED = 4, // if done by firmware/driver + WIFI_EAPOL_COMPLETED = 5, // if done by firmware/driver +} wifi_connection_state; + +typedef enum { + WIFI_ROAMING_IDLE = 0, + WIFI_ROAMING_ACTIVE = 1, +} wifi_roam_state; + +typedef enum { + WIFI_INTERFACE_STA = 0, + WIFI_INTERFACE_SOFTAP = 1, + WIFI_INTERFACE_IBSS = 2, + WIFI_INTERFACE_P2P_CLIENT = 3, + WIFI_INTERFACE_P2P_GO = 4, + WIFI_INTERFACE_NAN = 5, + WIFI_INTERFACE_MESH = 6, + WIFI_INTERFACE_TDLS = 7, + WIFI_INTERFACE_UNKNOWN = -1 + } wifi_interface_mode; + +#define WIFI_CAPABILITY_QOS 0x00000001 // set for QOS association +#define WIFI_CAPABILITY_PROTECTED 0x00000002 // set for protected association (802.11 beacon frame control protected bit set) +#define WIFI_CAPABILITY_INTERWORKING 0x00000004 // set if 802.11 Extended Capabilities element interworking bit is set +#define WIFI_CAPABILITY_HS20 0x00000008 // set for HS20 association +#define WIFI_CAPABILITY_SSID_UTF8 0x00000010 // set is 802.11 Extended Capabilities element UTF-8 SSID bit is set +#define WIFI_CAPABILITY_COUNTRY 0x00000020 // set is 802.11 Country Element is present + +typedef struct { + wifi_interface_mode mode; // interface mode + u8 mac_addr[6]; // interface mac address (self) + wifi_connection_state state; // connection state (valid for STA, CLI only) + wifi_roam_state roaming; // roaming state + u32 capabilities; // WIFI_CAPABILITY_XXX (self) + u8 ssid[33]; // null terminated SSID + u8 bssid[6]; // bssid + u8 ap_country_str[3]; // country string advertised by AP + u8 country_str[3]; // country string for this association + u8 time_slicing_duty_cycle_percent;// if this iface is being served using time slicing on a radio with one or more ifaces (i.e MCC), then the duty cycle assigned to this iface in %. + // If not using time slicing (i.e SCC or DBS), set to 100. +} wifi_interface_link_layer_info; + +/* channel information */ +typedef struct { + wifi_channel_width width; // channel width (20, 40, 80, 80+80, 160, 320) + wifi_channel center_freq; // primary 20 MHz channel + wifi_channel center_freq0; // center frequency (MHz) first segment + wifi_channel center_freq1; // center frequency (MHz) second segment +} wifi_channel_info; + +/* wifi rate */ +typedef struct { + u32 preamble :3; // 0: OFDM, 1:CCK, 2:HT 3:VHT 4:HE 5:EHT 6..7 reserved + u32 nss :2; // 0:1x1, 1:2x2, 3:3x3, 4:4x4 + u32 bw :3; // 0:20MHz, 1:40Mhz, 2:80Mhz, 3:160Mhz 4:320Mhz + u32 rateMcsIdx :8; // OFDM/CCK rate code would be as per ieee std in the units of 0.5mbps + // HT/VHT/HE/EHT it would be mcs index + u32 reserved :16; // reserved + u32 bitrate; // units of 100 Kbps +} wifi_rate; + +/* channel statistics */ +typedef struct { + wifi_channel_info channel; // channel + u32 on_time; // msecs the radio is awake (32 bits number accruing over time) + u32 cca_busy_time; // msecs the CCA register is busy (32 bits number accruing over time) +} wifi_channel_stat; + +// Max number of tx power levels. The actual number vary per device and is specified by |num_tx_levels| +#define RADIO_STAT_MAX_TX_LEVELS 256 + +/* radio statistics */ +typedef struct { + wifi_radio radio; // wifi radio (if multiple radio supported) + u32 on_time; // msecs the radio is awake (32 bits number accruing over time) + u32 tx_time; // msecs the radio is transmitting (32 bits number accruing over time) + u32 num_tx_levels; // number of radio transmit power levels + u32 *tx_time_per_levels; // pointer to an array of radio transmit per power levels in + // msecs accured over time + u32 rx_time; // msecs the radio is in active receive (32 bits number accruing over time) + u32 on_time_scan; // msecs the radio is awake due to all scan (32 bits number accruing over time) + u32 on_time_nbd; // msecs the radio is awake due to NAN (32 bits number accruing over time) + u32 on_time_gscan; // msecs the radio is awake due to G?scan (32 bits number accruing over time) + u32 on_time_roam_scan; // msecs the radio is awake due to roam?scan (32 bits number accruing over time) + u32 on_time_pno_scan; // msecs the radio is awake due to PNO scan (32 bits number accruing over time) + u32 on_time_hs20; // msecs the radio is awake due to HS2.0 scans and GAS exchange (32 bits number accruing over time) + u32 num_channels; // number of channels + wifi_channel_stat channels[]; // channel statistics +} wifi_radio_stat; + +/** + * Packet statistics reporting by firmware is performed on MPDU basi (i.e. counters increase by 1 for each MPDU) + * As well, "data packet" in associated comments, shall be interpreted as 802.11 data packet, + * that is, 802.11 frame control subtype == 2 and excluding management and control frames. + * + * As an example, in the case of transmission of an MSDU fragmented in 16 MPDUs which are transmitted + * OTA in a 16 units long a-mpdu, for which a block ack is received with 5 bits set: + * tx_mpdu : shall increase by 5 + * retries : shall increase by 16 + * tx_ampdu : shall increase by 1 + * data packet counters shall not increase regardless of the number of BAR potentially sent by device for this a-mpdu + * data packet counters shall not increase regardless of the number of BA received by device for this a-mpdu + * + * For each subsequent retransmission of the 11 remaining non ACK'ed mpdus + * (regardless of the fact that they are transmitted in a-mpdu or not) + * retries : shall increase by 1 + * + * If no subsequent BA or ACK are received from AP, until packet lifetime expires for those 11 packet that were not ACK'ed + * mpdu_lost : shall increase by 11 + */ + +/* per rate statistics */ +typedef struct { + wifi_rate rate; // rate information + u32 tx_mpdu; // number of successfully transmitted data pkts (ACK rcvd) + u32 rx_mpdu; // number of received data pkts + u32 mpdu_lost; // number of data packet losses (no ACK) + u32 retries; // total number of data pkt retries + u32 retries_short; // number of short data pkt retries + u32 retries_long; // number of long data pkt retries +} wifi_rate_stat; + +/* access categories */ +typedef enum { + WIFI_AC_VO = 0, + WIFI_AC_VI = 1, + WIFI_AC_BE = 2, + WIFI_AC_BK = 3, + WIFI_AC_MAX = 4, +} wifi_traffic_ac; + +/* wifi peer type */ +typedef enum +{ + WIFI_PEER_STA, + WIFI_PEER_AP, + WIFI_PEER_P2P_GO, + WIFI_PEER_P2P_CLIENT, + WIFI_PEER_NAN, + WIFI_PEER_TDLS, + WIFI_PEER_INVALID, +} wifi_peer_type; + +/* per peer statistics */ +typedef struct bssload_info { + u16 sta_count; // station count + u16 chan_util; // channel utilization + u8 PAD[4]; +} bssload_info_t; + +typedef struct { + wifi_peer_type type; // peer type (AP, TDLS, GO etc.) + u8 peer_mac_address[6]; // mac address + u32 capabilities; // peer WIFI_CAPABILITY_XXX + bssload_info_t bssload; // STA count and CU + u32 num_rate; // number of rates + wifi_rate_stat rate_stats[]; // per rate statistics, number of entries = num_rate +} wifi_peer_info; + +/* Per access category statistics */ +typedef struct { + wifi_traffic_ac ac; // access category (VI, VO, BE, BK) + u32 tx_mpdu; // number of successfully transmitted unicast data pkts (ACK rcvd) + u32 rx_mpdu; // number of received unicast data packets + u32 tx_mcast; // number of succesfully transmitted multicast data packets + // STA case: implies ACK received from AP for the unicast packet in which mcast pkt was sent + u32 rx_mcast; // number of received multicast data packets + u32 rx_ampdu; // number of received unicast a-mpdus; support of this counter is optional + u32 tx_ampdu; // number of transmitted unicast a-mpdus; support of this counter is optional + u32 mpdu_lost; // number of data pkt losses (no ACK) + u32 retries; // total number of data pkt retries + u32 retries_short; // number of short data pkt retries + u32 retries_long; // number of long data pkt retries + u32 contention_time_min; // data pkt min contention time (usecs) + u32 contention_time_max; // data pkt max contention time (usecs) + u32 contention_time_avg; // data pkt avg contention time (usecs) + u32 contention_num_samples; // num of data pkts used for contention statistics +} wifi_wmm_ac_stat; + +/* interface statistics */ +typedef struct { + wifi_interface_handle iface; // wifi interface + wifi_interface_link_layer_info info; // current state of the interface + u32 beacon_rx; // access point beacon received count from connected AP + u64 average_tsf_offset; // average beacon offset encountered (beacon_TSF - TBTT) + // The average_tsf_offset field is used so as to calculate the + // typical beacon contention time on the channel as well may be + // used to debug beacon synchronization and related power consumption issue + u32 leaky_ap_detected; // indicate that this AP typically leaks packets beyond the driver guard time. + u32 leaky_ap_avg_num_frames_leaked; // average number of frame leaked by AP after frame with PM bit set was ACK'ed by AP + u32 leaky_ap_guard_time; // guard time currently in force (when implementing IEEE power management based on + // frame control PM bit), How long driver waits before shutting down the radio and + // after receiving an ACK for a data frame with PM bit set) + u32 mgmt_rx; // access point mgmt frames received count from connected AP (including Beacon) + u32 mgmt_action_rx; // action frames received count + u32 mgmt_action_tx; // action frames transmit count + wifi_rssi rssi_mgmt; // access Point Beacon and Management frames RSSI (averaged) + wifi_rssi rssi_data; // access Point Data Frames RSSI (averaged) from connected AP + wifi_rssi rssi_ack; // access Point ACK RSSI (averaged) from connected AP + wifi_wmm_ac_stat ac[WIFI_AC_MAX]; // per ac data packet statistics + u32 num_peers; // number of peers + wifi_peer_info peer_info[]; // per peer statistics +} wifi_iface_stat; + +/* Various states for the link */ +typedef enum { + // Chip does not support reporting the state of the link. + WIFI_LINK_STATE_UNKNOWN = 0, + // Link has not been in use since last report. It is placed in power save. All + // management, control and data frames for the MLO connection are carried over + // other links. In this state the link will not listen to beacons even in DTIM + // period and does not perform any GTK/IGTK/BIGTK updates but remains + // associated. + WIFI_LINK_STATE_NOT_IN_USE = 1, + // Link is in use. In presence of traffic, it is set to be power active. When + // the traffic stops, the link will go into power save mode and will listen + // for beacons every DTIM period. + WIFI_LINK_STATE_IN_USE = 2, +} wifi_link_state; + +/* Per link statistics */ +typedef struct { + u8 link_id; // Identifier for the link. + wifi_link_state state; // State for the link. + wifi_radio radio; // Radio on which link stats are sampled. + u32 frequency; // Frequency on which link is operating. + u32 beacon_rx; // Beacon received count from connected AP on the link. + u64 average_tsf_offset; // Average beacon offset encountered (beacon_TSF - + // TBTT). The average_tsf_offset field is used so as + // to calculate the typical beacon contention time on + // the channel as well may be used to debug beacon + // synchronization and related power consumption + // issue. + u32 leaky_ap_detected; // Indicate that this AP on the link typically leaks + // packets beyond the driver guard time. + u32 leaky_ap_avg_num_frames_leaked; // Average number of frame leaked by AP + // in the link after frame with PM bit + // set was ACK'ed by AP. + u32 leaky_ap_guard_time; // Guard time currently in force (when implementing + // IEEE power management based on frame control PM + // bit), How long driver waits before shutting down + // the radio and after receiving an ACK for a data + // frame with PM bit set). + u32 mgmt_rx; // Management frames received count from connected AP on the + // link (including Beacon). + u32 mgmt_action_rx; // Action frames received count on the link. + u32 mgmt_action_tx; // Action frames transmit count on the link. + wifi_rssi rssi_mgmt; // Access Point Beacon and Management frames RSSI + // (averaged) on the link. + wifi_rssi rssi_data; // Access Point Data Frames RSSI (averaged) from + // connected AP on the link. + wifi_rssi rssi_ack; // Access Point ACK RSSI (averaged) from connected AP on + // the links. + wifi_wmm_ac_stat ac[WIFI_AC_MAX]; // Per AC data packet statistics for the + // link. + u8 time_slicing_duty_cycle_percent; // If this link is being served using + // time slicing on a radio with one or + // more links, then the duty cycle + // assigned to this link in %. + u32 num_peers; // Number of peers. + wifi_peer_info peer_info[]; // Peer statistics for the link. +} wifi_link_stat; + +/* Multi link stats for interface */ +typedef struct { + wifi_interface_handle iface; // Wifi interface. + wifi_interface_link_layer_info info; // Current state of the interface. + int num_links; // Number of links. + wifi_link_stat links[]; // Stats per link. +} wifi_iface_ml_stat; +/* configuration params */ +typedef struct { + u32 mpdu_size_threshold; // threshold to classify the pkts as short or long + // packet size < mpdu_size_threshold => short + u32 aggressive_statistics_gathering; // set for field debug mode. Driver should collect all statistics regardless of performance impact. +} wifi_link_layer_params; + +/* API to trigger the link layer statistics collection. + Unless his API is invoked - link layer statistics will not be collected. + Radio statistics (once started) do not stop or get reset unless wifi_clear_link_stats is invoked + Interface statistics (once started) reset and start afresh after each connection */ +wifi_error wifi_set_link_stats(wifi_interface_handle iface, wifi_link_layer_params params); + +/* Callbacks for reporting link layer stats. Only one of the callbacks needs to + * be called. */ +typedef struct { + /* Legacy: Single iface/link stats. */ + void (*on_link_stats_results)(wifi_request_id id, + wifi_iface_stat *iface_stat, int num_radios, + wifi_radio_stat *radio_stat); + /* Multi link stats. */ + void (*on_multi_link_stats_results)(wifi_request_id id, + wifi_iface_ml_stat *iface_ml_stat, + int num_radios, + wifi_radio_stat *radio_stat); +} wifi_stats_result_handler; + +/* api to collect the link layer statistics for a given iface and all the radio stats */ +wifi_error wifi_get_link_stats(wifi_request_id id, + wifi_interface_handle iface, wifi_stats_result_handler handler); + +/* wifi statistics bitmap */ +#define WIFI_STATS_RADIO 0x00000001 // all radio statistics +#define WIFI_STATS_RADIO_CCA 0x00000002 // cca_busy_time (within radio statistics) +#define WIFI_STATS_RADIO_CHANNELS 0x00000004 // all channel statistics (within radio statistics) +#define WIFI_STATS_RADIO_SCAN 0x00000008 // all scan statistics (within radio statistics) +#define WIFI_STATS_IFACE 0x00000010 // all interface statistics +#define WIFI_STATS_IFACE_TXRATE 0x00000020 // all tx rate statistics (within interface statistics) +#define WIFI_STATS_IFACE_AC 0x00000040 // all ac statistics (within interface statistics) +#define WIFI_STATS_IFACE_CONTENTION 0x00000080 // all contention (min, max, avg) statistics (within ac statisctics) + +/* clear api to reset statistics, stats_clear_rsp_mask identifies what stats have been cleared + stop_req = 1 will imply whether to stop the statistics collection. + stop_rsp = 1 will imply that stop_req was honored and statistics collection was stopped. + */ +wifi_error wifi_clear_link_stats(wifi_interface_handle iface, + u32 stats_clear_req_mask, u32 *stats_clear_rsp_mask, u8 stop_req, u8 *stop_rsp); + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#endif /*__WIFI_HAL_STATS_ */ diff --git a/wifi/legacy_headers/include/hardware_legacy/roam.h b/wifi/legacy_headers/include/hardware_legacy/roam.h new file mode 100644 index 0000000000..dbfd54bed8 --- /dev/null +++ b/wifi/legacy_headers/include/hardware_legacy/roam.h @@ -0,0 +1,62 @@ +/* + * Copyright (C) 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. + */ + +#ifndef __WIFI_HAL_ROAM_H__ +#define __WIFI_HAL_ROAM_H__ + +#include "wifi_hal.h" + +#define MAX_BLACKLIST_BSSID 16 +#define MAX_WHITELIST_SSID 8 +#define MAX_SSID_LENGTH 32 + +typedef struct { + u32 max_blacklist_size; + u32 max_whitelist_size; +} wifi_roaming_capabilities; + +typedef enum { + ROAMING_DISABLE, + ROAMING_ENABLE, + ROAMING_AGGRESSIVE +} fw_roaming_state_t; + +typedef struct { + u32 length; + char ssid_str[MAX_SSID_LENGTH]; +} ssid_t; + +typedef struct { + u32 num_blacklist_bssid; // Number of bssids valid in blacklist_bssid[]. + mac_addr blacklist_bssid[MAX_BLACKLIST_BSSID]; // List of bssids which should not be considered + // for romaing by firmware/driver. + u32 num_whitelist_ssid; // Number of ssids valid in whitelist_ssid[]. + ssid_t whitelist_ssid[MAX_WHITELIST_SSID]; // List of ssids to which firmware/driver can + // consider to roam to. +} wifi_roaming_config; + +/* Get the chipset roaming capabilities. */ +wifi_error wifi_get_roaming_capabilities(wifi_interface_handle handle, + wifi_roaming_capabilities *caps); +/* Enable/disable firmware roaming */ +wifi_error wifi_enable_firmware_roaming(wifi_interface_handle handle, + fw_roaming_state_t state); + +/* Pass down the blacklist BSSID and whitelist SSID to firmware. */ +wifi_error wifi_configure_roaming(wifi_interface_handle handle, + wifi_roaming_config *roaming_config); + +#endif /* __WIFI_HAL_ROAM_H__ */ diff --git a/wifi/legacy_headers/include/hardware_legacy/rtt.h b/wifi/legacy_headers/include/hardware_legacy/rtt.h new file mode 100644 index 0000000000..63c3325dda --- /dev/null +++ b/wifi/legacy_headers/include/hardware_legacy/rtt.h @@ -0,0 +1,411 @@ + +#include "wifi_hal.h" +#include "gscan.h" + +#ifndef __WIFI_HAL_RTT_H__ +#define __WIFI_HAL_RTT_H__ + +/* Ranging status */ +typedef enum { + RTT_STATUS_SUCCESS = 0, + RTT_STATUS_FAILURE = 1, // general failure status + RTT_STATUS_FAIL_NO_RSP = 2, // target STA does not respond to request + RTT_STATUS_FAIL_REJECTED = 3, // request rejected. Applies to 2-sided RTT only + RTT_STATUS_FAIL_NOT_SCHEDULED_YET = 4, + RTT_STATUS_FAIL_TM_TIMEOUT = 5, // timing measurement times out + RTT_STATUS_FAIL_AP_ON_DIFF_CHANNEL = 6, // Target on different channel, cannot range + RTT_STATUS_FAIL_NO_CAPABILITY = 7, // ranging not supported + RTT_STATUS_ABORTED = 8, // request aborted for unknown reason + RTT_STATUS_FAIL_INVALID_TS = 9, // Invalid T1-T4 timestamp + RTT_STATUS_FAIL_PROTOCOL = 10, // 11mc protocol failed + RTT_STATUS_FAIL_SCHEDULE = 11, // request could not be scheduled + RTT_STATUS_FAIL_BUSY_TRY_LATER = 12, // responder cannot collaborate at time of request + RTT_STATUS_INVALID_REQ = 13, // bad request args + RTT_STATUS_NO_WIFI = 14, // WiFi not enabled + RTT_STATUS_FAIL_FTM_PARAM_OVERRIDE = 15, // Responder overrides param info, cannot range with new params + RTT_STATUS_NAN_RANGING_PROTOCOL_FAILURE =16, //Negotiation failure + RTT_STATUS_NAN_RANGING_CONCURRENCY_NOT_SUPPORTED=17, //concurrency not supported (NDP+RTT) +} wifi_rtt_status; + +/* RTT peer type */ +typedef enum { + RTT_PEER_AP = 0x1, + RTT_PEER_STA = 0x2, + RTT_PEER_P2P_GO = 0x3, + RTT_PEER_P2P_CLIENT = 0x4, + RTT_PEER_NAN = 0x5 +} rtt_peer_type; + +/* RTT Measurement Bandwidth */ +typedef enum { + WIFI_RTT_BW_UNSPECIFIED = 0x00, + WIFI_RTT_BW_5 = 0x01, + WIFI_RTT_BW_10 = 0x02, + WIFI_RTT_BW_20 = 0x04, + WIFI_RTT_BW_40 = 0x08, + WIFI_RTT_BW_80 = 0x10, + WIFI_RTT_BW_160 = 0x20, + WIFI_RTT_BW_320 = 0x40 +} wifi_rtt_bw; + +/* RTT Measurement Preamble */ +typedef enum { + WIFI_RTT_PREAMBLE_INVALID = 0x0, + WIFI_RTT_PREAMBLE_LEGACY = 0x1, + WIFI_RTT_PREAMBLE_HT = 0x2, + WIFI_RTT_PREAMBLE_VHT = 0x4, + WIFI_RTT_PREAMBLE_HE = 0x8, + WIFI_RTT_PREAMBLE_EHT = 0x10, +} wifi_rtt_preamble ; + +/* RTT Type */ +typedef enum { + RTT_TYPE_1_SIDED = 0x1, + /* Deprecated. Use RTT_TYPE_2_SIDED_11MC instead. */ + RTT_TYPE_2_SIDED = 0x2, + RTT_TYPE_2_SIDED_11MC = RTT_TYPE_2_SIDED, + RTT_TYPE_2_SIDED_11AZ_NTB = 0x3, + +} wifi_rtt_type; + +/* RTT configuration */ +typedef struct { + mac_addr addr; // peer device mac address + wifi_rtt_type type; // 1-sided or 2-sided RTT (11mc and 11az) + rtt_peer_type peer; // optional - peer device hint (STA, P2P, AP) + wifi_channel_info channel; // Required for STA-AP mode, optional for P2P, NBD etc. + unsigned burst_period; // 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) + // Note: Applicable for 11mc only. + unsigned num_burst; // 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) + // Note: Applicable for 11mc only. + unsigned num_frames_per_burst; // 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. + // Note: Applicable for 11mc only. + unsigned num_retries_per_rtt_frame; // number of retries for a failed RTT frame. Applies + // to 1-sided RTT only. Minimum value = 0, Maximum value = 3 + + //following fields are only valid for 2-side RTT + unsigned num_retries_per_ftmr; // Maximum number of retries that the initiator can + // retry an FTMR frame. + // Minimum value = 0, Maximum value = 3 + byte LCI_request; // 1: request LCI, 0: do not request LCI + byte LCR_request; // 1: request LCR, 0: do not request LCR + unsigned burst_duration; // Applies to 1-sided and 2-sided 11mc 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. + wifi_rtt_preamble preamble; // RTT preamble to be used in the RTT frames + wifi_rtt_bw bw; // RTT BW to be used in the RTT frames +} wifi_rtt_config; + +/* RTT configuration v3 (11az support)*/ +typedef struct { + wifi_rtt_config rtt_config; + byte ntb_min_measurement_time_millis; // 11az Non-Trigger-based (non-TB) minimum measurement + // time in milliseconds + byte ntb_max_measurement_time_millis; // 11az Non-Trigger-based (non-TB) maximum measurement + // time in milliseconds + byte tx_ltf_repetition_count; // Multiple transmissions of HE-LTF symbols in an HE + // Ranging NDP. A value of 1 indicates no repetition. +} wifi_rtt_config_v3; + +/* RTT results */ +typedef struct { + mac_addr addr; // device mac address + unsigned burst_num; // burst number in a multi-burst request. Note: Applicable to + // 1-sided RTT and 2-sided IEEE 802.11mc only. + unsigned measurement_number; // Total RTT measurement frames attempted + unsigned success_number; // Total successful RTT measurement frames + byte number_per_burst_peer; // 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. + wifi_rtt_status status; // ranging status + byte retry_after_duration; // 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. + wifi_rtt_type type; // RTT type + wifi_rssi rssi; // average rssi in 0.5 dB steps e.g. 143 implies -71.5 dB + wifi_rssi rssi_spread; // rssi spread in 0.5 dB steps e.g. 5 implies 2.5 dB spread (optional) + wifi_rate tx_rate; // 1-sided RTT: TX rate of RTT frame. + // 2-sided RTT: TX rate of initiator's Ack in response to FTM frame. + wifi_rate rx_rate; // 1-sided RTT: TX rate of Ack from other side. + // 2-sided RTT: TX rate of FTM frame coming from responder. + wifi_timespan rtt; // round trip time in picoseconds + wifi_timespan rtt_sd; // rtt standard deviation in picoseconds + wifi_timespan rtt_spread; // difference between max and min rtt times recorded in picoseconds + // Note: Only applicable for IEEE 802.11mc + int distance_mm; // distance in mm (optional) + int distance_sd_mm; // standard deviation in mm (optional) + int distance_spread_mm; // difference between max and min distance recorded in mm (optional) + wifi_timestamp ts; // time of the measurement (in microseconds since boot) + int burst_duration; // in ms, actual time taken by the FW to finish one burst + // measurement. Applies to 1-sided and 2-sided RTT. + int negotiated_burst_num; // Number of bursts allowed by the responder. Applies + // to 2-sided 11mc RTT only. + wifi_information_element *LCI; // for 11mc and 11az only + wifi_information_element *LCR; // for 11mc and 11az only +} wifi_rtt_result; + +/* RTT results version 2 */ +typedef struct { + wifi_rtt_result rtt_result; // Legacy wifi rtt result structure + wifi_channel frequency; // primary channel frequency (MHz) used for ranging measurements + // If frequency is unknown, this will be set to |UNSPECIFIED(-1)| + wifi_rtt_bw packet_bw; // RTT packet bandwidth is an average BW of the BWs of RTT frames. + // Cap the average close to a specific valid RttBw. +} wifi_rtt_result_v2; + +/* RTT results v3 (11az support)*/ +typedef struct { + wifi_rtt_result_v2 rtt_result; + int tx_ltf_repetition_count; // 11az Transmit LTF repetitions used to get this result. + int ntb_min_measurement_time_millis; // Minimum non-trigger based (non-TB) dynamic measurement + // time in milliseconds assigned by the 11az responder. + int ntb_max_measurement_time_millis; // Maximum non-trigger based (non-TB) dynamic measurement + // time in milliseconds assigned by the 11az responder. +} wifi_rtt_result_v3; + + +/* RTT result callbacks */ +typedef struct { + /* + * This callback is deprecated on Android 14 and onwards. Newer implementations should support + * on_rtt_results_v2 callback. + */ + void (*on_rtt_results) (wifi_request_id id, + unsigned num_results, + wifi_rtt_result *rtt_result[]); + + /* + * Called when vendor implementation supports sending RTT results version 2. + * + * Note: This callback is deprecated on Android 15 onwards. Newer implementation should support + * on_rtt_results_v3. + */ + void (*on_rtt_results_v2) (wifi_request_id id, + unsigned num_results, + wifi_rtt_result_v2 *rtt_result_v2[]); +} wifi_rtt_event_handler; + +/* API to request RTT measurement */ +wifi_error wifi_rtt_range_request(wifi_request_id id, wifi_interface_handle iface, + unsigned num_rtt_config, wifi_rtt_config rtt_config[], wifi_rtt_event_handler handler); + +/* RTT result v3 callback (11az support) */ +typedef struct { + /* + * Called when vendor implementation supports sending RTT results version 3 (Added support for + * 11az ranging) + */ + void (*on_rtt_results_v3) (wifi_request_id id, + unsigned num_results, + wifi_rtt_result_v3 *rtt_result_v3[]); +} wifi_rtt_event_handler_v3; + + +/* v3 API to request RTT measurement(11az support). */ +wifi_error wifi_rtt_range_request_v3(wifi_request_id id, + wifi_interface_handle iface, + unsigned num_rtt_config, + wifi_rtt_config_v3 rtt_config_v3[], + wifi_rtt_event_handler_v3 handler); + +/* API to cancel RTT measurements */ +wifi_error wifi_rtt_range_cancel(wifi_request_id id, wifi_interface_handle iface, + unsigned num_devices, mac_addr addr[]); + +/* NBD ranging channel map */ +typedef struct { + wifi_channel availablity[32]; // specifies the channel map for each of the 16 TU windows + // frequency of 0 => unspecified; which means firmware is + // free to do whatever it wants in this window. +} wifi_channel_map; + +/* API to start publishing the channel map on responder device in a NBD cluster. + Responder device will take this request and schedule broadcasting the channel map + in a NBD ranging attribute in a SDF. DE will automatically remove the ranging + attribute from the OTA queue after number of DW specified by num_dw + where Each DW is 512 TUs apart */ +wifi_error wifi_rtt_channel_map_set(wifi_request_id id, + wifi_interface_handle iface, wifi_channel_map *params, unsigned num_dw); + +/* API to clear the channel map on the responder device in a NBD cluster. + Responder device will cancel future ranging channel request, starting from “next” + DW interval and will also stop broadcasting NBD ranging attribute in SDF */ +wifi_error wifi_rtt_channel_map_clear(wifi_request_id id, wifi_interface_handle iface); + +// Preamble definition for bit mask used in wifi_rtt_capabilities +#define PREAMBLE_LEGACY 0x1 +#define PREAMBLE_HT 0x2 +#define PREAMBLE_VHT 0x4 +#define PREAMBLE_HE 0x8 +#define PREAMBLE_EHT 0x10 + +// BW definition for bit mask used in wifi_rtt_capabilities +#define BW_5_SUPPORT 0x1 +#define BW_10_SUPPORT 0x2 +#define BW_20_SUPPORT 0x4 +#define BW_40_SUPPORT 0x8 +#define BW_80_SUPPORT 0x10 +#define BW_160_SUPPORT 0x20 +#define BW_320_SUPPORT 0x40 + +/* RTT Capabilities */ +typedef struct { + byte rtt_one_sided_supported; // if 1-sided rtt data collection is supported + byte rtt_ftm_supported; // if ftm rtt data collection is supported + byte lci_support; // if initiator supports LCI request. Applies to 2-sided RTT + // (applies to both 11mc and 11az). + byte lcr_support; // if initiator supports LCR request. Applies to 2-sided RTT + // (applies to both 11mc and 11az). + byte preamble_support; // bit mask indicates what preamble is supported by 11mc + // initiator + byte bw_support; // bit mask indicates what BW is supported by 11mc initiator + byte responder_supported; // if 11mc responder mode is supported + byte mc_version; // draft 11mc spec version supported by chip. For instance, + // version 4.0 should be 40 and version 4.3 should be 43 etc. +} wifi_rtt_capabilities; + + +/* RTT capabilities of the device */ +wifi_error wifi_get_rtt_capabilities(wifi_interface_handle iface, + wifi_rtt_capabilities *capabilities); + +/* RTT Capabilities v3 (11az support) */ +typedef struct { + wifi_rtt_capabilities rtt_capab; + byte az_preamble_support; // bit mask indicates what preamble is supported by the 11az + // initiator + byte az_bw_support; // bit mask indicates what BW is supported by 11az initiator + byte ntb_initiator_supported; // if 11az non-TB initiator is supported + byte ntb_responder_supported; // if 11az non-TB responder is supported + byte max_tx_ltf_repetition_count;// maximum HE LTF repetitions the 11az initiator is capable of + // transmitting in the preamble of I2R NDP +} wifi_rtt_capabilities_v3; + +/* RTT capabilities v3 of the device (11az support) */ +wifi_error wifi_get_rtt_capabilities_v3(wifi_interface_handle iface, + wifi_rtt_capabilities_v3 *capabilities); + +/* debugging definitions */ +enum { + RTT_DEBUG_DISABLE, + RTT_DEBUG_LOG, + RTT_DEBUG_PROTO, + RTT_DEBUG_BURST, + RTT_DEBUG_ACCURACY, + RTT_DEBUG_LOGDETAIL +}; //rtt debug type + +enum { + RTT_DEBUG_FORMAT_TXT, + RTT_DEBUG_FORMAT_BINARY +}; //rtt debug format + +typedef struct rtt_debug { + unsigned version; + unsigned len; // total length of after len field + unsigned type; // rtt debug type + unsigned format; //rtt debug format + char dbuf[0]; // debug content +} rtt_debug_t; + +/* set configuration for debug */ +wifi_error wifi_rtt_debug_cfg(wifi_interface_handle h, unsigned rtt_dbg_type, char *cfgbuf, unsigned cfg_buf_size); +/* get the debug information */ +wifi_error wifi_rtt_debug_get(wifi_interface_handle h, rtt_debug_t **debugbuf); +/* free the debug buffer */ +wifi_error wifi_rtt_debug_free(wifi_interface_handle h, rtt_debug_t *debugbuf); + +/* API for setting LCI/LCR information to be provided to a requestor */ +typedef enum { + WIFI_MOTION_NOT_EXPECTED = 0, // Not expected to change location + WIFI_MOTION_EXPECTED = 1, // Expected to change location + WIFI_MOTION_UNKNOWN = 2, // Movement pattern unknown +} wifi_motion_pattern; + +typedef struct { + long latitude; // latitude in degrees * 2^25 , 2's complement + long longitude; // latitude in degrees * 2^25 , 2's complement + int altitude; // Altitude in units of 1/256 m + byte latitude_unc; // As defined in Section 2.3.2 of IETF RFC 6225 + byte longitude_unc; // As defined in Section 2.3.2 of IETF RFC 6225 + byte altitude_unc; // As defined in Section 2.4.5 from IETF RFC 6225: + + //Following element for configuring the Z subelement + wifi_motion_pattern motion_pattern; + int floor; // floor in units of 1/16th of floor. 0x80000000 if unknown. + int height_above_floor; // in units of 1/64 m + int height_unc; // in units of 1/64 m. 0 if unknown +} wifi_lci_information; + +typedef struct { + char country_code[2]; // country code + int length; // length of the info field + char civic_info[256]; // Civic info to be copied in FTM frame +} wifi_lcr_information; + +// API to configure the LCI. Used in RTT Responder mode only +wifi_error wifi_set_lci(wifi_request_id id, wifi_interface_handle iface, + wifi_lci_information *lci); + +// API to configure the LCR. Used in RTT Responder mode only. +wifi_error wifi_set_lcr(wifi_request_id id, wifi_interface_handle iface, + wifi_lcr_information *lcr); + +/** + * RTT Responder information + */ +typedef struct { + wifi_channel_info channel; + wifi_rtt_preamble preamble; +} wifi_rtt_responder; + +/** + * Get RTT responder information e.g. WiFi channel to enable responder on. + */ +wifi_error wifi_rtt_get_responder_info(wifi_interface_handle iface, + wifi_rtt_responder *responder_info); + +/** + * Enable RTT responder mode. + * channel_hint - hint of the channel information where RTT responder should be enabled on. + * max_duration_seconds - timeout of responder mode. + * channel_used - channel used for RTT responder, NULL if responder is not enabled. + */ +wifi_error wifi_enable_responder(wifi_request_id id, wifi_interface_handle iface, + wifi_channel_info channel_hint, unsigned max_duration_seconds, + wifi_rtt_responder *responder_info); + +/** + * Disable RTT responder mode. + */ +wifi_error wifi_disable_responder(wifi_request_id id, wifi_interface_handle iface); + +#endif diff --git a/wifi/legacy_headers/include/hardware_legacy/tdls.h b/wifi/legacy_headers/include/hardware_legacy/tdls.h new file mode 100644 index 0000000000..9ac225a72a --- /dev/null +++ b/wifi/legacy_headers/include/hardware_legacy/tdls.h @@ -0,0 +1,85 @@ + +#include "wifi_hal.h" + +#ifndef _TDLS_H_ +#define _TDLS_H_ + +typedef enum { + WIFI_TDLS_DISABLED = 1, /* TDLS is not enabled, default status for all STAs */ + WIFI_TDLS_ENABLED, /* TDLS is enabled, but not yet tried */ + WIFI_TDLS_ESTABLISHED, /* Direct link is established */ + WIFI_TDLS_ESTABLISHED_OFF_CHANNEL, /* Direct link is established using MCC */ + WIFI_TDLS_DROPPED, /* Direct link was established, + * but is temporarily dropped now */ + WIFI_TDLS_FAILED /* TDLS permanent failed. Inform error to upper layer + * and go back to WIFI_TDLS_DISABLED */ +} wifi_tdls_state; + +typedef enum { + WIFI_TDLS_SUCCESS, /* Success */ + WIFI_TDLS_UNSPECIFIED = -1, /* Unspecified reason */ + WIFI_TDLS_NOT_SUPPORTED = -2, /* Remote side doesn't support TDLS */ + WIFI_TDLS_UNSUPPORTED_BAND = -3, /* Remote side doesn't support this band */ + WIFI_TDLS_NOT_BENEFICIAL = -4, /* Going to AP is better than going direct */ + WIFI_TDLS_DROPPED_BY_REMOTE = -5 /* Remote side doesn't want it anymore */ +} wifi_tdls_reason; + +typedef struct { + int channel; /* channel hint, in channel number (NOT frequency ) */ + int global_operating_class; /* operating class to use */ + int max_latency_ms; /* max latency that can be tolerated by apps */ + int min_bandwidth_kbps; /* bandwidth required by apps, in kilo bits per second */ +} wifi_tdls_params; + +typedef struct { + int channel; + int global_operating_class; + wifi_tdls_state state; + wifi_tdls_reason reason; +} wifi_tdls_status; + +typedef struct { + int max_concurrent_tdls_session_num; /* Maximum TDLS session number can be supported by the + * Firmware and hardware*/ + int is_global_tdls_supported; /* 1 -- support, 0 -- not support */ + int is_per_mac_tdls_supported; /* 1 -- support, 0 -- not support */ + int is_off_channel_tdls_supported; /* 1 -- support, 0 -- not support */ +} wifi_tdls_capabilities; + +typedef struct { + /* on_tdls_state_changed - reports state of TDLS link to framework + * Report this event when the state of TDLS link changes */ + void (*on_tdls_state_changed)(mac_addr addr, wifi_tdls_status status); +} wifi_tdls_handler; + + +/* wifi_enable_tdls - enables TDLS-auto mode for a specific route + * + * params specifies hints, which provide more information about + * why TDLS is being sought. The firmware should do its best to + * honor the hints before downgrading regular AP link + * If upper layer has no specific values, this should be NULL + * + * handler is used to inform the upper layer about the status change and the corresponding reason + */ +wifi_error wifi_enable_tdls(wifi_interface_handle iface, mac_addr addr, + wifi_tdls_params *params, wifi_tdls_handler handler); + +/* wifi_disable_tdls - disables TDLS-auto mode for a specific route + * + * This terminates any existing TDLS with addr device, and frees the + * device resources to make TDLS connections on new routes. + * + * DON'T fire any more events on 'handler' specified in earlier call to + * wifi_enable_tdls after this action. + */ +wifi_error wifi_disable_tdls(wifi_interface_handle iface, mac_addr addr); + +/* wifi_get_tdls_status - allows getting the status of TDLS for a specific route */ +wifi_error wifi_get_tdls_status(wifi_interface_handle iface, mac_addr addr, + wifi_tdls_status *status); + +/* return the current HW + Firmware combination's TDLS capabilities */ +wifi_error wifi_get_tdls_capabilities(wifi_interface_handle iface, + wifi_tdls_capabilities *capabilities); +#endif diff --git a/wifi/legacy_headers/include/hardware_legacy/wifi_cached_scan_results.h b/wifi/legacy_headers/include/hardware_legacy/wifi_cached_scan_results.h new file mode 100644 index 0000000000..a2a23fe269 --- /dev/null +++ b/wifi/legacy_headers/include/hardware_legacy/wifi_cached_scan_results.h @@ -0,0 +1,92 @@ +/* + * Copyright (C) 2022 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. + */ + +#ifndef __WIFI_CACHED_SCAN_RESULTS_H__ +#define __WIFI_CACHED_SCAN_RESULTS_H__ + +#include "wifi_hal.h" + +#define WIFI_CACHED_SCAN_RESULT_FLAGS_NONE (0) +/* Element ID 61 (HT Operation) is present (see HT 7.3.2) */ +#define WIFI_CACHED_SCAN_RESULT_FLAGS_HT_OPS_PRESENT (1 << 0) +/* Element ID 192 (VHT Operation) is present (see VHT 8.4.2) */ +#define WIFI_CACHED_SCAN_RESULT_FLAGS_VHT_OPS_PRESENT (1 << 1) +/* Element ID 255 + Extension 36 (HE Operation) is present + * (see 802.11ax 9.4.2.1) + */ +#define WIFI_CACHED_SCAN_RESULT_FLAGS_HE_OPS_PRESENT (1 << 2) +/* Element ID 255 + Extension 106 (HE Operation) is present + * (see 802.11be D1.5 9.4.2.1) + */ +#define WIFI_CACHED_SCAN_RESULT_FLAGS_EHT_OPS_PRESENT (1 << 3) +/* Element ID 127 (Extended Capabilities) is present, and bit 70 + * (Fine Timing Measurement Responder) is set to 1 + * (see IEEE Std 802.11-2016 9.4.2.27) + */ +#define WIFI_CACHED_SCAN_RESULT_FLAGS_IS_FTM_RESPONDER (1 << 4) + +/** + * Provides information about a single access point (AP) detected in a scan. + */ +typedef struct { + /* Number of milliseconds prior to ts in the enclosing + * wifi_cached_scan_result_report struct when + * the probe response or beacon frame that + * was used to populate this structure was received. + */ + u32 age_ms; + /* The Capability Information field */ + u16 capability; + /* null terminated */ + u8 ssid[33]; + u8 ssid_len; + u8 bssid[6]; + /* A set of flags from WIFI_CACHED_SCAN_RESULT_FLAGS_* */ + u8 flags; + s8 rssi; + wifi_channel_spec chanspec; +}wifi_cached_scan_result; + +/* + * Data structure sent with events of type WifiCachedScanResult. + */ +typedef struct { + /* time since boot (in microsecond) when the result was retrieved */ + wifi_timestamp ts; + /* If 0, indicates that all frequencies in current regulation were + * scanned. Otherwise, indicates the number of frequencies scanned, as + * specified in scanned_freq_list. + */ + u16 scanned_freq_num; + /* Pointer to an array containing scanned_freq_num values comprising the + * set of frequencies that were scanned. Frequencies are specified as + * channel center frequencies in MHz. May be NULL if scannedFreqListLen is + * 0. + */ + const u32 *scanned_freq_list; + /* The total number of cached results returned. */ + u8 result_cnt; + /* Pointer to an array containing result_cnt entries. May be NULL if + * result_cnt is 0. + */ + const wifi_cached_scan_result *results; +} wifi_cached_scan_report; + +/* callback for reporting cached scan report */ +typedef struct { + void (*on_cached_scan_results) (wifi_cached_scan_report *cache_report); +} wifi_cached_scan_result_handler; +#endif diff --git a/wifi/legacy_headers/include/hardware_legacy/wifi_config.h b/wifi/legacy_headers/include/hardware_legacy/wifi_config.h new file mode 100644 index 0000000000..9ddf8b8b5c --- /dev/null +++ b/wifi/legacy_headers/include/hardware_legacy/wifi_config.h @@ -0,0 +1,45 @@ +#include "wifi_hal.h" + +#ifndef __WIFI_HAL_CONFIG_H +#define __WIFI_HAL_CONFIG_H + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + +#define CONFIG_MAJOR_VERSION 1 +#define CONFIG_MINOR_VERSION 0 +#define CONFIG_MICRO_VERSION 0 + +// whether the wifi chipset wakes at every dtim beacon or a multiple of the dtim period +// if extended_dtim is set to 3, the STA shall wake up every 3 DTIM beacons +wifi_error wifi_extended_dtim_config_set(wifi_request_id id, + wifi_interface_handle iface, int extended_dtim); + +//set the country code to driver +wifi_error wifi_set_country_code(wifi_interface_handle iface, const char* country_code); + +//set the wifi_iface stats averaging factor used to calculate +// statistics like average the TSF offset or average number of frame leaked +// For instance, upon beacon reception: +// current_avg = ((beacon_TSF - TBTT) * factor + previous_avg * (0x10000 - factor) ) / 0x10000 +// For instance, when evaluating leaky APs: +// current_avg = ((num frame received within guard time) * factor + previous_avg * (0x10000 - factor)) / 0x10000 + +wifi_error wifi_set_beacon_wifi_iface_stats_averaging_factor(wifi_request_id id, wifi_interface_handle iface, + u16 factor); + +// configure guard time, i.e. when implementing IEEE power management based on +// frame control PM bit, how long driver waits before shutting down the radio and +// after receiving an ACK for a data frame with PM bit set +wifi_error wifi_set_guard_time(wifi_request_id id, wifi_interface_handle iface, + u32 guard_time); + +#ifdef __cplusplus +} + +#endif /* __cplusplus */ + +#endif /*__WIFI_HAL_STATS_ */ + diff --git a/wifi/legacy_headers/include/hardware_legacy/wifi_hal.h b/wifi/legacy_headers/include/hardware_legacy/wifi_hal.h new file mode 100644 index 0000000000..9c82e80b39 --- /dev/null +++ b/wifi/legacy_headers/include/hardware_legacy/wifi_hal.h @@ -0,0 +1,1389 @@ +/* + * Copyright (C) 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. + */ + +#ifndef __WIFI_HAL_H__ +#define __WIFI_HAL_H__ + +#ifdef __cplusplus +extern "C" +{ +#endif +#include + +#define IFNAMSIZ 16 +#define UNSPECIFIED -1 // wifi HAL common definition for unspecified value + +/* typedefs */ +typedef unsigned char byte; +typedef unsigned char u8; +typedef signed char s8; +typedef uint16_t u16; +typedef uint32_t u32; +typedef int32_t s32; +typedef uint64_t u64; +typedef int64_t s64; +typedef int wifi_request_id; +typedef int wifi_channel; // indicates channel frequency in MHz +typedef int wifi_rssi; +typedef int wifi_radio; +typedef byte mac_addr[6]; +typedef byte oui[3]; +typedef int64_t wifi_timestamp; // In microseconds (us) +typedef int64_t wifi_timespan; // In picoseconds (ps) +typedef uint64_t feature_set; + +/* forward declarations */ +struct wifi_info; +struct wifi_interface_info; +typedef struct wifi_info *wifi_handle; +typedef struct wifi_interface_info *wifi_interface_handle; + +/* WiFi Common definitions */ +/* channel operating width */ +typedef enum { + WIFI_CHAN_WIDTH_20 = 0, + WIFI_CHAN_WIDTH_40 = 1, + WIFI_CHAN_WIDTH_80 = 2, + WIFI_CHAN_WIDTH_160 = 3, + WIFI_CHAN_WIDTH_80P80 = 4, + WIFI_CHAN_WIDTH_5 = 5, + WIFI_CHAN_WIDTH_10 = 6, + WIFI_CHAN_WIDTH_320 = 7, + WIFI_CHAN_WIDTH_INVALID = -1 +} wifi_channel_width; + +/* Multi-Link Operation modes */ +typedef enum { + WIFI_MLO_MODE_DEFAULT = 0, + WIFI_MLO_MODE_LOW_LATENCY = 1, + WIFI_MLO_MODE_HIGH_THROUGHPUT = 2, + WIFI_MLO_MODE_LOW_POWER = 3, +} wifi_mlo_mode; + +/* Pre selected Power scenarios to be applied from BDF file */ +typedef enum { + WIFI_POWER_SCENARIO_INVALID = -2, + WIFI_POWER_SCENARIO_DEFAULT = -1, + WIFI_POWER_SCENARIO_VOICE_CALL = 0, + WIFI_POWER_SCENARIO_ON_HEAD_CELL_OFF = 1, + WIFI_POWER_SCENARIO_ON_HEAD_CELL_ON = 2, + WIFI_POWER_SCENARIO_ON_BODY_CELL_OFF = 3, + WIFI_POWER_SCENARIO_ON_BODY_CELL_ON = 4, + WIFI_POWER_SCENARIO_ON_BODY_BT = 5, + WIFI_POWER_SCENARIO_ON_HEAD_HOTSPOT = 6, + WIFI_POWER_SCENARIO_ON_HEAD_HOTSPOT_MMW = 7, + WIFI_POWER_SCENARIO_ON_BODY_CELL_ON_BT = 8, + WIFI_POWER_SCENARIO_ON_BODY_HOTSPOT = 9, + WIFI_POWER_SCENARIO_ON_BODY_HOTSPOT_BT = 10, + WIFI_POWER_SCENARIO_ON_BODY_HOTSPOT_MMW = 11, + WIFI_POWER_SCENARIO_ON_BODY_HOTSPOT_BT_MMW = 12, + WIFI_POWER_SCENARIO_ON_HEAD_CELL_OFF_UNFOLDED = 13, + WIFI_POWER_SCENARIO_ON_HEAD_CELL_ON_UNFOLDED = 14, + WIFI_POWER_SCENARIO_ON_HEAD_HOTSPOT_UNFOLDED = 15, + WIFI_POWER_SCENARIO_ON_HEAD_HOTSPOT_MMW_UNFOLDED = 16, + WIFI_POWER_SCENARIO_ON_BODY_CELL_OFF_UNFOLDED = 17, + WIFI_POWER_SCENARIO_ON_BODY_BT_UNFOLDED = 18, + WIFI_POWER_SCENARIO_ON_BODY_CELL_ON_UNFOLDED = 19, + WIFI_POWER_SCENARIO_ON_BODY_CELL_ON_BT_UNFOLDED = 20, + WIFI_POWER_SCENARIO_ON_BODY_HOTSPOT_UNFOLDED = 21, + WIFI_POWER_SCENARIO_ON_BODY_HOTSPOT_BT_UNFOLDED = 22, + WIFI_POWER_SCENARIO_ON_BODY_HOTSPOT_MMW_UNFOLDED = 23, + WIFI_POWER_SCENARIO_ON_BODY_HOTSPOT_BT_MMW_UNFOLDED = 24, + WIFI_POWER_SCENARIO_ON_BODY_REAR_CAMERA = 25, + WIFI_POWER_SCENARIO_ON_BODY_CELL_OFF_UNFOLDED_CAP = 26, + WIFI_POWER_SCENARIO_ON_BODY_BT_UNFOLDED_CAP = 27, + WIFI_POWER_SCENARIO_ON_BODY_CELL_ON_UNFOLDED_CAP = 28, + WIFI_POWER_SCENARIO_ON_BODY_CELL_ON_BT_UNFOLDED_CAP = 29, +} wifi_power_scenario; + +typedef enum { + WIFI_LATENCY_MODE_NORMAL = 0, + WIFI_LATENCY_MODE_LOW = 1, +} wifi_latency_mode; + +/* Wifi Thermal mitigation modes */ +typedef enum { + WIFI_MITIGATION_NONE = 0, + WIFI_MITIGATION_LIGHT = 1, + WIFI_MITIGATION_MODERATE = 2, + WIFI_MITIGATION_SEVERE = 3, + WIFI_MITIGATION_CRITICAL = 4, + WIFI_MITIGATION_EMERGENCY = 5, +} wifi_thermal_mode; + +/* + * Wifi voice over IP mode + * may add new modes later, for example, voice + video over IP mode. + */ +typedef enum { + WIFI_VOIP_MODE_OFF = 0, + WIFI_VOIP_MODE_VOICE = 1, +} wifi_voip_mode; + +/* List of interface types supported */ +typedef enum { + WIFI_INTERFACE_TYPE_STA = 0, + WIFI_INTERFACE_TYPE_AP = 1, + WIFI_INTERFACE_TYPE_P2P = 2, + WIFI_INTERFACE_TYPE_NAN = 3, + WIFI_INTERFACE_TYPE_AP_BRIDGED = 4, +} wifi_interface_type; + +/* + * enum wlan_mac_band - Band information corresponding to the WLAN MAC. + */ +typedef enum { +/* WLAN MAC Operates in 2.4 GHz Band */ + WLAN_MAC_2_4_BAND = 1 << 0, +/* WLAN MAC Operates in 5 GHz Band */ + WLAN_MAC_5_0_BAND = 1 << 1, +/* WLAN MAC Operates in 6 GHz Band */ + WLAN_MAC_6_0_BAND = 1 << 2, +/* WLAN MAC Operates in 60 GHz Band */ + WLAN_MAC_60_0_BAND = 1 << 3, +} wlan_mac_band; + +/* List of chre nan rtt state */ +typedef enum { + CHRE_PREEMPTED = 0, + CHRE_UNAVAILABLE = 1, + CHRE_AVAILABLE = 2, +} chre_nan_rtt_state; + +typedef struct { + wifi_channel_width width; + int center_frequency0; + int center_frequency1; + int primary_frequency; +} wifi_channel_spec; + +/* + * wifi_usable_channel specifies a channel frequency, bandwidth, and bitmask + * of modes allowed on the channel. + */ +typedef struct { + /* Channel frequency in MHz */ + wifi_channel freq; + /* Channel operating width (20, 40, 80, 160, 320 etc.) */ + wifi_channel_width width; + /* BIT MASK of BIT(WIFI_INTERFACE_*) represented by |wifi_interface_mode| + * Bitmask does not represent concurrency. + * Examples: + * - If a channel is usable only for STA, then only the WIFI_INTERFACE_STA + * bit would be set for that channel. + * - If 5GHz SAP is not allowed, then none of the 5GHz channels will have + * WIFI_INTERFACE_SOFTAP bit set. + * Note: TDLS bit is set only if there is a STA connection. TDLS bit is set + * on non-STA channels only if TDLS off channel is supported. + */ + u32 iface_mode_mask; +} wifi_usable_channel; + +/* + * wifi_usable_channel_filter + */ +typedef enum { + /* Filter Wifi channels that should be avoided due to cellular coex + * restrictions. Some Wifi channels can have extreme interference + * from/to cellular due to short frequency separation with neighboring + * cellular channels or when there is harmonic and intermodulation + * interference. Channels which only have some performance degradation + * (e.g. power back off is sufficient to deal with coexistence issue) + * can be included and should not be filtered out. + */ + WIFI_USABLE_CHANNEL_FILTER_CELLULAR_COEXISTENCE = 1 << 0, + /* Filter channels due to concurrency state. + * Examples: + * - 5GHz SAP operation may be supported in standalone mode, but if + * there is STA connection on 5GHz DFS channel, none of the 5GHz + * channels are usable for SAP if device does not support DFS SAP mode. + * - P2P GO may not be supported on indoor channels in EU during + * standalone mode but if there is a STA connection on indoor channel, + * P2P GO may be supported by some vendors on the same STA channel. + */ + WIFI_USABLE_CHANNEL_FILTER_CONCURRENCY = 1 << 1, + /* This Filter queries Wifi channels and bands that are supported for + * NAN3.1 Instant communication mode. This filter should only be applied to NAN interface. + * If 5G is supported default discovery channel 149/44 is considered, + * If 5G is not supported then channel 6 has to be considered. + * Based on regulatory domain if channel 149 and 44 are restricted, channel 6 should + * be considered for instant communication channel + */ + WIFI_USABLE_CHANNEL_FILTER_NAN_INSTANT_MODE = 1 << 2, +} wifi_usable_channel_filter; + +typedef enum { + WIFI_SUCCESS = 0, + WIFI_ERROR_NONE = 0, + WIFI_ERROR_UNKNOWN = -1, + WIFI_ERROR_UNINITIALIZED = -2, + WIFI_ERROR_NOT_SUPPORTED = -3, + WIFI_ERROR_NOT_AVAILABLE = -4, // Not available right now, but try later + WIFI_ERROR_INVALID_ARGS = -5, + WIFI_ERROR_INVALID_REQUEST_ID = -6, + WIFI_ERROR_TIMED_OUT = -7, + WIFI_ERROR_TOO_MANY_REQUESTS = -8, // Too many instances of this request + WIFI_ERROR_OUT_OF_MEMORY = -9, + WIFI_ERROR_BUSY = -10, +} wifi_error; + +typedef enum { + WIFI_ACCESS_CATEGORY_BEST_EFFORT = 0, + WIFI_ACCESS_CATEGORY_BACKGROUND = 1, + WIFI_ACCESS_CATEGORY_VIDEO = 2, + WIFI_ACCESS_CATEGORY_VOICE = 3 +} wifi_access_category; + +/* Channel category mask */ +typedef enum { + WIFI_INDOOR_CHANNEL = 1 << 0, + WIFI_DFS_CHANNEL = 1 << 1, +} wifi_channel_category; + +/* Antenna configuration */ +typedef enum { + WIFI_ANTENNA_UNSPECIFIED = 0, + WIFI_ANTENNA_1X1 = 1, + WIFI_ANTENNA_2X2 = 2, + WIFI_ANTENNA_3X3 = 3, + WIFI_ANTENNA_4X4 = 4, +} wifi_antenna_configuration; + +/* Wifi Radio configuration */ +typedef struct { + /* Operating band */ + wlan_mac_band band; + /* Antenna configuration */ + wifi_antenna_configuration antenna_cfg; +} wifi_radio_configuration; + +/* WiFi Radio Combination */ +typedef struct { + u32 num_radio_configurations; + wifi_radio_configuration radio_configurations[]; +} wifi_radio_combination; + +/* WiFi Radio combinations matrix */ +/* For Example in case of a chip which has two radios, where one radio is + * capable of 2.4GHz 2X2 only and another radio which is capable of either + * 5GHz or 6GHz 2X2, number of possible radio combinations in this case + * are 5 and possible combinations are + * {{{2G 2X2}}, //Standalone 2G + * {{5G 2X2}}, //Standalone 5G + * {{6G 2X2}}, //Standalone 6G + * {{2G 2X2}, {5G 2X2}}, //2G+5G DBS + * {{2G 2X2}, {6G 2X2}}} //2G+6G DBS + * Note: Since this chip doesn’t support 5G+6G simultaneous operation + * as there is only one radio which can support both, So it can only + * do MCC 5G+6G. This table should not get populated with possible MCC + * configurations. This is only for simultaneous radio configurations + * (such as Standalone, multi band simultaneous or single band simultaneous). + */ +typedef struct { + u32 num_radio_combinations; + /* Each row represents possible radio combinations */ + wifi_radio_combination radio_combinations[]; +} wifi_radio_combination_matrix; + +typedef struct { + /** + * Maximum number of links supported by the chip for MLO association. + */ + u32 max_mlo_association_link_count; + /** + * Maximum number of Simultaneous Transmit and Receive (STR) links used + * in Multi-Link Operation. The maximum number of STR links used can be + * different from the maximum number of radios supported by the chip. + * + * This is a static configuration of the chip. + */ + u32 max_mlo_str_link_count; + /** + * Maximum number of concurrent TDLS sessions supported by the chip. + * + */ + u32 max_concurrent_tdls_session_count; +} wifi_chip_capabilities; + +#define MAX_IFACE_COMBINATIONS 16 +#define MAX_IFACE_LIMITS 8 + +/* Wifi interface limit + * Example: + * 1. To allow STA+STA: + * wifi_iface_limit limit1 = { + * .max_limit = 2, + * .iface_mask = BIT(WIFI_INTERFACE_TYPE_STA) + * }; + * 2. To allow Single P2P/NAN: + * wifi_iface_limit limit2 = { + * .max_limit = 1, + * .iface_mask = BIT(WIFI_INTERFACE_TYPE_P2P) + * | BIT(WIFI_INTERFACE_TYPE_NAN) + * }; + */ +typedef struct { + /* Max number of interfaces of same type */ + u32 max_limit; + /* BIT mask of interfaces from wifi_interface_type */ + u32 iface_mask; +} wifi_iface_limit; + +/* Wifi Interface combination + * Example: + * 1. To allow STA+SAP: + * wifi_iface_limit limits1[] = { + * {1, BIT(WIFI_INTERFACE_TYPE_STA)}, + * }; + * wifi_iface_limit limits2[] = { + * {1, BIT(WIFI_INTERFACE_TYPE_AP)}, + * }; + * wifi_iface_combination comb1 = { + * .max_ifaces = 2, + * .num_iface_limits = 2, + * .iface_limits = {limits1, limits2,}, + * }; + * + * 2. To allow STA+P2P/NAN: + * wifi_iface_limit limits3[] = { + * {1, BIT(WIFI_INTERFACE_TYPE_STA)}, + * {1, BIT(WIFI_INTERFACE_TYPE_P2P) + | BIT(WIFI_INTERFACE_TYPE_NAN)}, + * }; + * wifi_iface_combination comb2 = { + * .max_ifaces = 2, + * .num_iface_limits = 1, + * .iface_limits = {limits3,}, + * }; + * + * 3. To allow STA+STA/AP: + * wifi_iface_limit limits4[] = { + * {2, BIT(WIFI_INTERFACE_TYPE_STA)}, + * }; + * wifi_iface_limit limits5[] = { + * {1, BIT(WIFI_INTERFACE_TYPE_STA)}, + * {1, BIT(WIFI_INTERFACE_TYPE_AP)}, + * }; + * wifi_iface_combination comb3 = { + * .max_ifaces = 2, + * .num_iface_limits = 2, + * .iface_limits = {limits4, limits5,}, + * }; + * + * 4. To allow AP_BRIDGED (AP+AP in bridge mode): + * wifi_iface_limit limits6[] = { + * {1, BIT(WIFI_INTERFACE_TYPE_AP_BRIDGED)}, + * }; + * wifi_iface_combination comb4 = { + * .max_ifaces = 1, + * .num_iface_limits = 1, + * .iface_limits = {limits6,}, + * }; + */ +typedef struct { + /* Maximum number of concurrent interfaces allowed in this combination */ + u32 max_ifaces; + /* Total number of interface limits in a combination */ + u32 num_iface_limits; + /* Interface limits */ + wifi_iface_limit iface_limits[MAX_IFACE_LIMITS]; +} wifi_iface_combination; + +/* Wifi Interface concurrency combination matrix + * Example: + * 1. To allow 2 port concurrency with limts defined in above comments: + * wifi_iface_concurrency_matrix iface_concurrency_matrix = { + * .num_iface_combinations = 4, + * .iface_combinations = {comb1, comb2, comb3, comb4, } + * }; + */ +typedef struct { + /* Total count of possible iface combinations */ + u32 num_iface_combinations; + /* Interface combinations */ + wifi_iface_combination iface_combinations[MAX_IFACE_COMBINATIONS]; +} wifi_iface_concurrency_matrix; + +/* Initialize/Cleanup */ + +wifi_error wifi_initialize(wifi_handle *handle); + +/** + * wifi_wait_for_driver + * Function should block until the driver is ready to proceed. + * Any errors from this function is considered fatal & will fail the HAL startup sequence. + * + * on success returns WIFI_SUCCESS + * on failure returns WIFI_ERROR_TIMED_OUT + */ +wifi_error wifi_wait_for_driver_ready(void); + +typedef void (*wifi_cleaned_up_handler) (wifi_handle handle); +void wifi_cleanup(wifi_handle handle, wifi_cleaned_up_handler handler); +void wifi_event_loop(wifi_handle handle); + +/* Error handling */ +void wifi_get_error_info(wifi_error err, const char **msg); // return a pointer to a static string + +/* Feature enums */ +#define WIFI_FEATURE_INFRA (uint64_t)0x1 // Basic infrastructure mode +#define WIFI_FEATURE_INFRA_5G (uint64_t)0x2 // Support for 5 GHz Band +#define WIFI_FEATURE_HOTSPOT (uint64_t)0x4 // Support for GAS/ANQP +#define WIFI_FEATURE_P2P (uint64_t)0x8 // Wifi-Direct +#define WIFI_FEATURE_SOFT_AP (uint64_t)0x10 // Soft AP +#define WIFI_FEATURE_GSCAN (uint64_t)0x20 // Google-Scan APIs +#define WIFI_FEATURE_NAN (uint64_t)0x40 // Neighbor Awareness Networking +#define WIFI_FEATURE_D2D_RTT (uint64_t)0x80 // Device-to-device RTT +#define WIFI_FEATURE_D2AP_RTT (uint64_t)0x100 // Device-to-AP RTT +#define WIFI_FEATURE_BATCH_SCAN (uint64_t)0x200 // Batched Scan (legacy) +#define WIFI_FEATURE_PNO (uint64_t)0x400 // Preferred network offload +#define WIFI_FEATURE_ADDITIONAL_STA (uint64_t)0x800 // Support for two STAs +#define WIFI_FEATURE_TDLS (uint64_t)0x1000 // Tunnel directed link setup +#define WIFI_FEATURE_TDLS_OFFCHANNEL (uint64_t)0x2000 // Support for TDLS off channel +#define WIFI_FEATURE_EPR (uint64_t)0x4000 // Enhanced power reporting +#define WIFI_FEATURE_AP_STA (uint64_t)0x8000 // Support for AP STA Concurrency +#define WIFI_FEATURE_LINK_LAYER_STATS (uint64_t)0x10000 // Link layer stats collection +#define WIFI_FEATURE_LOGGER (uint64_t)0x20000 // WiFi Logger +#define WIFI_FEATURE_HAL_EPNO (uint64_t)0x40000 // WiFi PNO enhanced +#define WIFI_FEATURE_RSSI_MONITOR (uint64_t)0x80000 // RSSI Monitor +#define WIFI_FEATURE_MKEEP_ALIVE (uint64_t)0x100000 // WiFi mkeep_alive +#define WIFI_FEATURE_CONFIG_NDO (uint64_t)0x200000 // ND offload configure +#define WIFI_FEATURE_TX_TRANSMIT_POWER (uint64_t)0x400000 // Capture Tx transmit power levels +#define WIFI_FEATURE_CONTROL_ROAMING (uint64_t)0x800000 // Enable/Disable firmware roaming +#define WIFI_FEATURE_IE_WHITELIST (uint64_t)0x1000000 // Support Probe IE white listing +#define WIFI_FEATURE_SCAN_RAND (uint64_t)0x2000000 // Support MAC & Probe Sequence Number randomization +#define WIFI_FEATURE_SET_TX_POWER_LIMIT (uint64_t)0x4000000 // Support Tx Power Limit setting +#define WIFI_FEATURE_USE_BODY_HEAD_SAR (uint64_t)0x8000000 // Support Using Body/Head Proximity for SAR +#define WIFI_FEATURE_DYNAMIC_SET_MAC (uint64_t)0x10000000 // Support changing MAC address without iface reset(down and up) +#define WIFI_FEATURE_SET_LATENCY_MODE (uint64_t)0x40000000 // Support Latency mode setting +#define WIFI_FEATURE_P2P_RAND_MAC (uint64_t)0x80000000 // Support P2P MAC randomization +#define WIFI_FEATURE_INFRA_60G (uint64_t)0x100000000 // Support for 60GHz Band +#define WIFI_FEATURE_AFC_CHANNEL (uint64_t)0x200000000 // Support for setting 6GHz AFC channel allowance +#define WIFI_FEATURE_T2LM_NEGO (uint64_t)0x400000000 // Support for TID-To-Link mapping negotiation +#define WIFI_FEATURE_ROAMING_MODE_CONTROL (uint64_t)0x800000000 // Support for configuring roaming mode +#define WIFI_FEATURE_SET_VOIP_MODE (uint64_t)0x1000000000 // Support Voip mode setting +#define WIFI_FEATURE_CACHED_SCAN_RESULTS (uint64_t)0x2000000000 // Support cached scan result report +// Add more features here + +#define IS_MASK_SET(mask, flags) (((flags) & (mask)) == (mask)) + +#define IS_SUPPORTED_FEATURE(feature, featureSet) IS_MASK_SET(feature, featureSet) + +/* Feature set */ +wifi_error wifi_get_supported_feature_set(wifi_interface_handle handle, feature_set *set); + +/* + * Each row represents a valid feature combination; + * all other combinations are invalid! + */ +wifi_error wifi_get_concurrency_matrix(wifi_interface_handle handle, int set_size_max, + feature_set set[], int *set_size); + +/* multiple interface support */ + +wifi_error wifi_get_ifaces(wifi_handle handle, int *num_ifaces, wifi_interface_handle **ifaces); +wifi_error wifi_get_iface_name(wifi_interface_handle iface, char *name, size_t size); +wifi_interface_handle wifi_get_iface_handle(wifi_handle handle, char *name); + +/* STA + STA support - Supported if WIFI_FEATURE_ADDITIONAL_STA is set */ + +/** + * Invoked to indicate that the provided iface is the primary STA iface when there are more + * than 1 STA iface concurrently active. + * + * Note: If the wifi firmware/chip cannot support multiple instances of any offload + * (like roaming, APF, rssi threshold, etc), the firmware should ensure that these + * offloads are at least enabled for the primary interface. If the new primary interface is + * already connected to a network, the firmware must switch all the offloads on + * this new interface without disconnecting. + */ +wifi_error wifi_multi_sta_set_primary_connection(wifi_handle handle, wifi_interface_handle iface); + +/** + * When there are 2 or more simultaneous STA connections, this use case hint indicates what + * use-case is being enabled by the framework. This use case hint can be used by the firmware + * to modify various firmware configurations like: + * - Allowed BSSIDs the firmware can choose for the initial connection/roaming attempts. + * - Duty cycle to choose for the 2 STA connections if the radio is in MCC mode. + * - Whether roaming, APF and other offloads needs to be enabled or not. + * + * Note: + * - This will be invoked before an active wifi connection is established on the second interface. + * - This use-case hint is implicitly void when the second STA interface is brought down. + */ +typedef enum { + /** + * Usage: + * - This will be sent down for make before break use-case. + * - Platform is trying to speculatively connect to a second network and evaluate it without + * disrupting the primary connection. + * + * Requirements for Firmware: + * - Do not reduce the number of tx/rx chains of primary connection. + * - If using MCC, should set the MCC duty cycle of the primary connection to be higher than + * the secondary connection (maybe 70/30 split). + * - Should pick the best BSSID for the secondary STA (disregard the chip mode) independent of + * the primary STA: + * - Don’t optimize for DBS vs MCC/SCC + * - Should not impact the primary connection’s bssid selection: + * - Don’t downgrade chains of the existing primary connection. + * - Don’t optimize for DBS vs MCC/SCC. + */ + WIFI_DUAL_STA_TRANSIENT_PREFER_PRIMARY = 0, + /** + * Usage: + * - This will be sent down for any app requested peer to peer connections. + * - In this case, both the connections needs to be allocated equal resources. + * - For the peer to peer use case, BSSID for the secondary connection will be chosen by the + * framework. + * + * Requirements for Firmware: + * - Can choose MCC or DBS mode depending on the MCC efficiency and HW capability. + * - If using MCC, set the MCC duty cycle of the primary connection to be equal to the secondary + * connection. + * - Prefer BSSID candidates which will help provide the best "overall" performance for both the + * connections. + */ + WIFI_DUAL_STA_NON_TRANSIENT_UNBIASED = 1 +} wifi_multi_sta_use_case; + +wifi_error wifi_multi_sta_set_use_case(wifi_handle handle, wifi_multi_sta_use_case use_case); + +/* Configuration events */ + +typedef struct { + void (*on_country_code_changed)(char code[2]); // We can get this from supplicant too + + // More event handlers +} wifi_event_handler; + +typedef struct { + char iface_name[IFNAMSIZ + 1]; + wifi_channel channel; +} wifi_iface_info; + +typedef struct { + u32 wlan_mac_id; +/* BIT MASK of BIT(WLAN_MAC*) as represented by wlan_mac_band */ + u32 mac_band; +/* Represents the connected Wi-Fi interfaces associated with each MAC */ + int num_iface; + wifi_iface_info *iface_info; +} wifi_mac_info; + +typedef struct { + void (*on_radio_mode_change)(wifi_request_id id, unsigned num_mac, + wifi_mac_info *mac_info); +} wifi_radio_mode_change_handler; + +typedef struct { + void (*on_rssi_threshold_breached)(wifi_request_id id, u8 *cur_bssid, s8 cur_rssi); +} wifi_rssi_event_handler; + +typedef struct { + void (*on_subsystem_restart)(const char* error); +} wifi_subsystem_restart_handler; + +typedef struct { + void (*on_chre_nan_rtt_change)(chre_nan_rtt_state state); +} wifi_chre_handler; + +wifi_error wifi_set_iface_event_handler(wifi_request_id id, wifi_interface_handle iface, wifi_event_handler eh); +wifi_error wifi_reset_iface_event_handler(wifi_request_id id, wifi_interface_handle iface); + +wifi_error wifi_set_nodfs_flag(wifi_interface_handle handle, u32 nodfs); +wifi_error wifi_select_tx_power_scenario(wifi_interface_handle handle, wifi_power_scenario scenario); +wifi_error wifi_reset_tx_power_scenario(wifi_interface_handle handle); +wifi_error wifi_set_latency_mode(wifi_interface_handle handle, wifi_latency_mode mode); +wifi_error wifi_map_dscp_access_category(wifi_handle handle, + uint32_t start, uint32_t end, + uint32_t access_category); +wifi_error wifi_reset_dscp_mapping(wifi_handle handle); + +wifi_error wifi_set_subsystem_restart_handler(wifi_handle handle, + wifi_subsystem_restart_handler handler); + +/** + * Wifi HAL Thermal Mitigation API + * + * wifi_handle : wifi global handle (note: this is not a interface specific + * command). Mitigation is expected to be applied across all active interfaces + * The implementation and the mitigation action mapping to each mode is chip + * specific. Mitigation will be active until Wifi is turned off or + * WIFI_MITIGATION_NONE mode is sent + * + * mode: Thermal mitigation mode + * WIFI_MITIGATION_NONE : Clear all Wifi thermal mitigation actions + * WIFI_MITIGATION_LIGHT : Light Throttling where UX is not impacted + * WIFI_MITIGATION_MODERATE : Moderate throttling where UX not largely impacted + * WIFI_MITIGATION_SEVERE : Severe throttling where UX is largely impacted + * WIFI_MITIGATION_CRITICAL : Platform has done everything to reduce power + * WIFI_MITIGATION_EMERGENCY: Key components in platform are shutting down + * + * completion_window + * Deadline (in milliseconds) to complete this request, value 0 implies apply + * immediately. Deadline is basically a relaxed limit and allows vendors to + * apply the mitigation within the window (if it cannot apply immediately) + * + * Return + * WIFI_ERROR_NOT_SUPPORTED : Chip does not support thermal mitigation + * WIFI_ERROR_BUSY : Mitigation is supported, but retry later + * WIFI_ERROR_NONE : Mitigation request has been accepted + */ +wifi_error wifi_set_thermal_mitigation_mode(wifi_handle handle, + wifi_thermal_mode mode, + u32 completion_window); + + +typedef struct rx_data_cnt_details_t { + int rx_unicast_cnt; /*Total rx unicast packet which woke up host */ + int rx_multicast_cnt; /*Total rx multicast packet which woke up host */ + int rx_broadcast_cnt; /*Total rx broadcast packet which woke up host */ +} RX_DATA_WAKE_CNT_DETAILS; + +typedef struct rx_wake_pkt_type_classification_t { + int icmp_pkt; /*wake icmp packet count */ + int icmp6_pkt; /*wake icmp6 packet count */ + int icmp6_ra; /*wake icmp6 RA packet count */ + int icmp6_na; /*wake icmp6 NA packet count */ + int icmp6_ns; /*wake icmp6 NS packet count */ + //ToDo: Any more interesting classification to add? +} RX_WAKE_PKT_TYPE_CLASSFICATION; + +typedef struct rx_multicast_cnt_t{ + int ipv4_rx_multicast_addr_cnt; /*Rx wake packet was ipv4 multicast */ + int ipv6_rx_multicast_addr_cnt; /*Rx wake packet was ipv6 multicast */ + int other_rx_multicast_addr_cnt;/*Rx wake packet was non-ipv4 and non-ipv6*/ +} RX_MULTICAST_WAKE_DATA_CNT; + +/* + * Structure holding all the driver/firmware wake count reasons. + * + * Buffers for the array fields (cmd_event_wake_cnt/driver_fw_local_wake_cnt) + * are allocated and freed by the framework. The size of each allocated + * array is indicated by the corresponding |_cnt| field. HAL needs to fill in + * the corresponding |_used| field to indicate the number of elements used in + * the array. + */ +typedef struct wlan_driver_wake_reason_cnt_t { + int total_cmd_event_wake; /* Total count of cmd event wakes */ + int *cmd_event_wake_cnt; /* Individual wake count array, each index a reason */ + int cmd_event_wake_cnt_sz; /* Max number of cmd event wake reasons */ + int cmd_event_wake_cnt_used; /* Number of cmd event wake reasons specific to the driver */ + + int total_driver_fw_local_wake; /* Total count of drive/fw wakes, for local reasons */ + int *driver_fw_local_wake_cnt; /* Individual wake count array, each index a reason */ + int driver_fw_local_wake_cnt_sz; /* Max number of local driver/fw wake reasons */ + int driver_fw_local_wake_cnt_used; /* Number of local driver/fw wake reasons specific to the driver */ + + int total_rx_data_wake; /* total data rx packets, that woke up host */ + RX_DATA_WAKE_CNT_DETAILS rx_wake_details; + RX_WAKE_PKT_TYPE_CLASSFICATION rx_wake_pkt_classification_info; + RX_MULTICAST_WAKE_DATA_CNT rx_multicast_wake_pkt_info; +} WLAN_DRIVER_WAKE_REASON_CNT; + +/* Wi-Fi coex channel avoidance support */ + +#define WIFI_COEX_NO_POWER_CAP (int32_t)0x7FFFFFF + +typedef enum { + WIFI_AWARE = 1 << 0, + SOFTAP = 1 << 1, + WIFI_DIRECT = 1 << 2 +} wifi_coex_restriction; + +/** + * Representation of a Wi-Fi channel to be avoided for Wi-Fi coex channel avoidance. + * + * band is represented as an WLAN_MAC* enum value defined in wlan_mac_band. + * If power_cap_dbm is WIFI_COEX_NO_POWER_CAP, then no power cap should be applied if the specified + * channel is used. + */ +typedef struct { + wlan_mac_band band; + u32 channel; + s32 power_cap_dbm; +} wifi_coex_unsafe_channel; + + +/* include various feature headers */ + +#include "gscan.h" +#include "link_layer_stats.h" +#include "wifi_cached_scan_results.h" +#include "rtt.h" +#include "tdls.h" +#include "wifi_logger.h" +#include "wifi_config.h" +#include "wifi_nan.h" +#include "wifi_offload.h" +#include "roam.h" +#include "wifi_twt.h" + +//wifi HAL function pointer table +typedef struct { + wifi_error (* wifi_initialize) (wifi_handle *); + wifi_error (* wifi_wait_for_driver_ready) (void); + void (* wifi_cleanup) (wifi_handle, wifi_cleaned_up_handler); + void (*wifi_event_loop)(wifi_handle); + void (* wifi_get_error_info) (wifi_error , const char **); + wifi_error (* wifi_get_supported_feature_set) (wifi_interface_handle, feature_set *); + wifi_error (* wifi_get_concurrency_matrix) (wifi_interface_handle, int, feature_set *, int *); + wifi_error (* wifi_set_scanning_mac_oui) (wifi_interface_handle, unsigned char *); + wifi_error (* wifi_get_supported_channels)(wifi_handle, int *, wifi_channel *); + wifi_error (* wifi_is_epr_supported)(wifi_handle); + wifi_error (* wifi_get_ifaces) (wifi_handle , int *, wifi_interface_handle **); + wifi_error (* wifi_get_iface_name) (wifi_interface_handle, char *name, size_t); + wifi_error (* wifi_set_iface_event_handler) (wifi_request_id,wifi_interface_handle , + wifi_event_handler); + wifi_error (* wifi_reset_iface_event_handler) (wifi_request_id, wifi_interface_handle); + wifi_error (* wifi_start_gscan) (wifi_request_id, wifi_interface_handle, wifi_scan_cmd_params, + wifi_scan_result_handler); + wifi_error (* wifi_stop_gscan)(wifi_request_id, wifi_interface_handle); + wifi_error (* wifi_get_cached_gscan_results)(wifi_interface_handle, byte, int, + wifi_cached_scan_results *, int *); + wifi_error (* wifi_set_bssid_hotlist)(wifi_request_id, wifi_interface_handle, + wifi_bssid_hotlist_params, wifi_hotlist_ap_found_handler); + wifi_error (* wifi_reset_bssid_hotlist)(wifi_request_id, wifi_interface_handle); + wifi_error (* wifi_set_significant_change_handler)(wifi_request_id, wifi_interface_handle, + wifi_significant_change_params, wifi_significant_change_handler); + wifi_error (* wifi_reset_significant_change_handler)(wifi_request_id, wifi_interface_handle); + wifi_error (* wifi_get_gscan_capabilities)(wifi_interface_handle, wifi_gscan_capabilities *); + wifi_error (* wifi_set_link_stats) (wifi_interface_handle, wifi_link_layer_params); + wifi_error (* wifi_get_link_stats) (wifi_request_id,wifi_interface_handle, + wifi_stats_result_handler); + wifi_error (* wifi_clear_link_stats)(wifi_interface_handle,u32, u32 *, u8, u8 *); + wifi_error (* wifi_get_valid_channels)(wifi_interface_handle,int, int, wifi_channel *, int *); + wifi_error (* wifi_rtt_range_request)(wifi_request_id, wifi_interface_handle, unsigned, + wifi_rtt_config[], wifi_rtt_event_handler); + wifi_error (* wifi_rtt_range_request_v3)(wifi_request_id, wifi_interface_handle, unsigned, + wifi_rtt_config_v3[], wifi_rtt_event_handler_v3); + wifi_error (* wifi_rtt_range_cancel)(wifi_request_id, wifi_interface_handle, unsigned, + mac_addr[]); + wifi_error (* wifi_get_rtt_capabilities)(wifi_interface_handle, wifi_rtt_capabilities *); + wifi_error (* wifi_get_rtt_capabilities_v3)(wifi_interface_handle, wifi_rtt_capabilities_v3 *); + wifi_error (* wifi_rtt_get_responder_info)(wifi_interface_handle iface, + wifi_rtt_responder *responder_info); + wifi_error (* wifi_enable_responder)(wifi_request_id id, wifi_interface_handle iface, + wifi_channel_info channel_hint, unsigned max_duration_seconds, + wifi_rtt_responder *responder_info); + wifi_error (* wifi_disable_responder)(wifi_request_id id, wifi_interface_handle iface); + wifi_error (* wifi_set_nodfs_flag)(wifi_interface_handle, u32); + wifi_error (* wifi_start_logging)(wifi_interface_handle, u32, u32, u32, u32, char *); + wifi_error (* wifi_set_epno_list)(wifi_request_id, wifi_interface_handle, + const wifi_epno_params *, wifi_epno_handler); + wifi_error (* wifi_reset_epno_list)(wifi_request_id, wifi_interface_handle); + wifi_error (* wifi_set_country_code)(wifi_interface_handle, const char *); + wifi_error (* wifi_get_firmware_memory_dump)( wifi_interface_handle iface, + wifi_firmware_memory_dump_handler handler); + wifi_error (* wifi_set_log_handler)(wifi_request_id id, wifi_interface_handle iface, + wifi_ring_buffer_data_handler handler); + wifi_error (* wifi_reset_log_handler)(wifi_request_id id, wifi_interface_handle iface); + wifi_error (* wifi_set_alert_handler)(wifi_request_id id, wifi_interface_handle iface, + wifi_alert_handler handler); + wifi_error (* wifi_reset_alert_handler)(wifi_request_id id, wifi_interface_handle iface); + wifi_error (* wifi_get_firmware_version)(wifi_interface_handle iface, char *buffer, + int buffer_size); + wifi_error (* wifi_get_ring_buffers_status)(wifi_interface_handle iface, + u32 *num_rings, wifi_ring_buffer_status *status); + wifi_error (* wifi_get_logger_supported_feature_set)(wifi_interface_handle iface, + unsigned int *support); + wifi_error (* wifi_get_ring_data)(wifi_interface_handle iface, char *ring_name); + wifi_error (* wifi_enable_tdls)(wifi_interface_handle, mac_addr, wifi_tdls_params *, + wifi_tdls_handler); + wifi_error (* wifi_disable_tdls)(wifi_interface_handle, mac_addr); + wifi_error (*wifi_get_tdls_status) (wifi_interface_handle, mac_addr, wifi_tdls_status *); + wifi_error (*wifi_get_tdls_capabilities)(wifi_interface_handle iface, + wifi_tdls_capabilities *capabilities); + wifi_error (* wifi_get_driver_version)(wifi_interface_handle iface, char *buffer, + int buffer_size); + wifi_error (* wifi_set_passpoint_list)(wifi_request_id id, wifi_interface_handle iface, + int num, wifi_passpoint_network *networks, wifi_passpoint_event_handler handler); + wifi_error (* wifi_reset_passpoint_list)(wifi_request_id id, wifi_interface_handle iface); + wifi_error (*wifi_set_lci) (wifi_request_id id, wifi_interface_handle iface, + wifi_lci_information *lci); + wifi_error (*wifi_set_lcr) (wifi_request_id id, wifi_interface_handle iface, + wifi_lcr_information *lcr); + wifi_error (*wifi_start_sending_offloaded_packet)(wifi_request_id id, + wifi_interface_handle iface, u16 ether_type, u8 *ip_packet, + u16 ip_packet_len, u8 *src_mac_addr, u8 *dst_mac_addr, + u32 period_msec); + wifi_error (*wifi_stop_sending_offloaded_packet)(wifi_request_id id, + wifi_interface_handle iface); + wifi_error (*wifi_start_rssi_monitoring)(wifi_request_id id, wifi_interface_handle + iface, s8 max_rssi, s8 min_rssi, wifi_rssi_event_handler eh); + wifi_error (*wifi_stop_rssi_monitoring)(wifi_request_id id, wifi_interface_handle iface); + wifi_error (*wifi_get_wake_reason_stats)(wifi_interface_handle iface, + WLAN_DRIVER_WAKE_REASON_CNT *wifi_wake_reason_cnt); + wifi_error (*wifi_configure_nd_offload)(wifi_interface_handle iface, u8 enable); + wifi_error (*wifi_get_driver_memory_dump)(wifi_interface_handle iface, + wifi_driver_memory_dump_callbacks callbacks); + wifi_error (*wifi_start_pkt_fate_monitoring)(wifi_interface_handle iface); + wifi_error (*wifi_get_tx_pkt_fates)(wifi_interface_handle handle, + wifi_tx_report *tx_report_bufs, + size_t n_requested_fates, + size_t *n_provided_fates); + wifi_error (*wifi_get_rx_pkt_fates)(wifi_interface_handle handle, + wifi_rx_report *rx_report_bufs, + size_t n_requested_fates, + size_t *n_provided_fates); + + /* NAN functions */ + wifi_error (*wifi_nan_enable_request)(transaction_id id, + wifi_interface_handle iface, + NanEnableRequest* msg); + wifi_error (*wifi_nan_disable_request)(transaction_id id, + wifi_interface_handle iface); + wifi_error (*wifi_nan_publish_request)(transaction_id id, + wifi_interface_handle iface, + NanPublishRequest* msg); + wifi_error (*wifi_nan_publish_cancel_request)(transaction_id id, + wifi_interface_handle iface, + NanPublishCancelRequest* msg); + wifi_error (*wifi_nan_subscribe_request)(transaction_id id, + wifi_interface_handle iface, + NanSubscribeRequest* msg); + wifi_error (*wifi_nan_subscribe_cancel_request)(transaction_id id, + wifi_interface_handle iface, + NanSubscribeCancelRequest* msg); + wifi_error (*wifi_nan_transmit_followup_request)(transaction_id id, + wifi_interface_handle iface, + NanTransmitFollowupRequest* msg); + wifi_error (*wifi_nan_stats_request)(transaction_id id, + wifi_interface_handle iface, + NanStatsRequest* msg); + wifi_error (*wifi_nan_config_request)(transaction_id id, + wifi_interface_handle iface, + NanConfigRequest* msg); + wifi_error (*wifi_nan_tca_request)(transaction_id id, + wifi_interface_handle iface, + NanTCARequest* msg); + wifi_error (*wifi_nan_beacon_sdf_payload_request)(transaction_id id, + wifi_interface_handle iface, + NanBeaconSdfPayloadRequest* msg); + wifi_error (*wifi_nan_register_handler)(wifi_interface_handle iface, + NanCallbackHandler handlers); + wifi_error (*wifi_nan_get_version)(wifi_handle handle, + NanVersion* version); + wifi_error (*wifi_nan_get_capabilities)(transaction_id id, + wifi_interface_handle iface); + wifi_error (*wifi_nan_data_interface_create)(transaction_id id, + wifi_interface_handle iface, + char *iface_name); + wifi_error (*wifi_nan_data_interface_delete)(transaction_id id, + wifi_interface_handle iface, + char *iface_name); + wifi_error (*wifi_nan_data_request_initiator)( + transaction_id id, wifi_interface_handle iface, + NanDataPathInitiatorRequest *msg); + wifi_error (*wifi_nan_data_indication_response)( + transaction_id id, wifi_interface_handle iface, + NanDataPathIndicationResponse *msg); + wifi_error (*wifi_nan_data_end)(transaction_id id, + wifi_interface_handle iface, + NanDataPathEndRequest *msg); + wifi_error (*wifi_select_tx_power_scenario)(wifi_interface_handle iface, + wifi_power_scenario scenario); + wifi_error (*wifi_reset_tx_power_scenario)(wifi_interface_handle iface); + + /** + * Returns the chipset's hardware filtering capabilities: + * @param version pointer to version of the packet filter interpreter + *                supported, filled in upon return. 0 indicates no support. + * @param max_len pointer to maximum size of the filter bytecode, filled in + *                upon return. + */ + wifi_error (*wifi_get_packet_filter_capabilities)(wifi_interface_handle handle, + u32 *version, u32 *max_len); + /** +     * Programs the packet filter. + * @param program pointer to the program byte-code. + * @param len length of the program byte-code. +     */ + wifi_error (*wifi_set_packet_filter)(wifi_interface_handle handle, + const u8 *program, u32 len); + wifi_error (*wifi_read_packet_filter)(wifi_interface_handle handle, + u32 src_offset, u8 *host_dst, + u32 length); + wifi_error (*wifi_get_roaming_capabilities)(wifi_interface_handle handle, + wifi_roaming_capabilities *caps); + wifi_error (*wifi_enable_firmware_roaming)(wifi_interface_handle handle, + fw_roaming_state_t state); + wifi_error (*wifi_configure_roaming)(wifi_interface_handle handle, + wifi_roaming_config *roaming_config); + wifi_error (*wifi_set_radio_mode_change_handler)(wifi_request_id id, wifi_interface_handle + iface, wifi_radio_mode_change_handler eh); + wifi_error (*wifi_set_latency_mode)(wifi_interface_handle iface, + wifi_latency_mode mode); + wifi_error (*wifi_set_thermal_mitigation_mode)(wifi_handle handle, + wifi_thermal_mode mode, + u32 completion_window); + wifi_error (*wifi_map_dscp_access_category)(wifi_handle handle, + u32 start, u32 end, + u32 access_category); + wifi_error (*wifi_reset_dscp_mapping)(wifi_handle handle); + + wifi_error (*wifi_virtual_interface_create)(wifi_handle handle, const char* ifname, + wifi_interface_type iface_type); + wifi_error (*wifi_virtual_interface_delete)(wifi_handle handle, const char* ifname); + + wifi_error (*wifi_set_subsystem_restart_handler)(wifi_handle handle, + wifi_subsystem_restart_handler handler); + + /** + * Allow vendor HAL to choose interface name when creating + * an interface. This can be implemented by chips with their + * own interface naming policy. + * If not implemented, the default naming will be used. + */ + wifi_error (*wifi_get_supported_iface_name)(wifi_handle handle, u32 iface_type, + char *name, size_t len); + + /** + * Perform early initialization steps that are needed when WIFI + * is disabled. + * If the function returns failure, it means the vendor HAL is unusable + * (for example, if chip hardware is not installed) and no further + * functions should be called. + */ + wifi_error (*wifi_early_initialize)(void); + + /** + * Get supported feature set which are chip-global, that is + * not dependent on any created interface. + */ + wifi_error (*wifi_get_chip_feature_set)(wifi_handle handle, feature_set *set); + + /** + * Invoked to indicate that the provided iface is the primary STA iface when there are more + * than 1 STA iface concurrently active. + */ + wifi_error (*wifi_multi_sta_set_primary_connection)(wifi_handle handle, + wifi_interface_handle iface); + + + /** + * When there are 2 simultaneous STA connections, this use case hint + * indicates what STA + STA use-case is being enabled by the framework. + */ + wifi_error (*wifi_multi_sta_set_use_case)(wifi_handle handle, + wifi_multi_sta_use_case use_case); + + /** + * Invoked to indicate that the following list of wifi_coex_unsafe_channel should be avoided + * with the specified restrictions. + * @param unsafeChannels list of current |wifi_coex_unsafe_channel| to avoid. + * @param restrictions bitmask of |wifi_coex_restriction| indicating wifi interfaces to + * restrict from the current unsafe channels. + */ + wifi_error (*wifi_set_coex_unsafe_channels)(wifi_handle handle, u32 num_channels, + wifi_coex_unsafe_channel *unsafeChannels, + u32 restrictions); + + /** + * Invoked to set voip optimization mode for the provided STA iface + */ + wifi_error (*wifi_set_voip_mode)(wifi_interface_handle iface, wifi_voip_mode mode); + + /** + * Get Target Wake Time (TWT) local device capabilities for the station interface. + * + * @param iface Wifi interface handle + * @param capabilities TWT capabilities + * @return Synchronous wifi_error + */ + wifi_error (*wifi_twt_get_capabilities)(wifi_interface_handle iface, + wifi_twt_capabilities* capabilities); + /** + * Setup a TWT session. + * + * Supported only if wifi_twt_capabilities.is_twt_requester_supported is set. Results in + * asynchronous callback wifi_twt_events.on_twt_session_create on success or + * wifi_twt_events.on_twt_failure with error code. + * + * @param id Identifier for the command. The value 0 is reserved. + * @param iface Wifi interface handle + * @param request TWT request parameters + * @param events TWT events + * @return Synchronous wifi_error + */ + wifi_error (*wifi_twt_session_setup)(wifi_request_id id, wifi_interface_handle iface, + wifi_twt_request request, wifi_twt_events events); + /** + * Update a TWT session. + * + * Supported only if wifi_twt_session.is_updatable is set. Reesults in asynchronous callback + * wifi_twt_events.on_twt_session_update on success or wifi_twt_events.on_twt_failure with + * error code. + * + * @param id Identifier for the command. The value 0 is reserved. + * @param iface Wifi interface handle + * @param session_id TWT session identifier + * @param request TWT request parameters + * @return Synchronous wifi_error + */ + wifi_error (*wifi_twt_session_update)(wifi_request_id id, wifi_interface_handle iface, + int session_id, wifi_twt_request request); + /** + * Suspend a TWT session. + * Supported only if wifi_twt_session.is_suspendable is set. Results in asynchronous callback + * wifi_twt_events.on_twt_session_suspend on success or wifi_twt_events.on_twt_failure with + * error code. + * + * @param id Identifier for the command. The value 0 is reserved. + * @param iface Wifi interface handle + * @param session_id TWT session identifier + * @return Synchronous wifi_error + */ + wifi_error (*wifi_twt_session_suspend)(wifi_request_id id, wifi_interface_handle iface, + int session_id); + /** + * Resume a suspended TWT session. + * + * Supported only if wifi_twt_session.is_suspendable is set. Results in asynchronous callback + * wifi_twt_events.on_twt_session_resume on success or wifi_twt_events.on_twt_failure with + * error code. + * + * @param id Identifier for the command. The value 0 is reserved. + * @param iface Wifi interface handle + * @param session_id TWT session identifier + * @return Synchronous wifi_error + */ + wifi_error (*wifi_twt_session_resume)(wifi_request_id id, wifi_interface_handle iface, + int session_id); + /** + * Teardown a TWT session. + * + * Results in asynchronous callback wifi_twt_events.on_twt_session_teardown on success or + * wifi_twt_events.on_twt_failure with error code. + * + * @param id Identifier for the command. The value 0 is reserved. + * @param iface Wifi interface handle + * @param session_id TWT session identifier + * @return Synchronous wifi_error + */ + wifi_error (*wifi_twt_session_teardown)(wifi_request_id id, wifi_interface_handle iface, + int session_id); + + /** + * Get stats for a TWT session. + * + * Results in asynchronous callback wifi_twt_events.on_twt_session_stats on success or + * wifi_twt_events.on_twt_failure with error code. + * + * @param id Identifier for the command. The value 0 is reserved. + * @param iface Wifi interface handle + * @param session_id TWT session identifier + * @return Synchronous wifi_error + */ + wifi_error (*wifi_twt_session_get_stats)(wifi_request_id id, wifi_interface_handle iface, + int session_id); + + /**@brief twt_register_handler + * Request to register TWT callback before sending any TWT request + * @param wifi_interface_handle: + * @param TwtCallbackHandler: callback function pointers + * @return Synchronous wifi_error + * + * Note: This function is deprecated + */ + wifi_error (*wifi_twt_register_handler)(wifi_interface_handle iface, + TwtCallbackHandler handler); + + /**@brief twt_get_capability + * Request TWT capability + * @param wifi_interface_handle: + * @return Synchronous wifi_error and TwtCapabilitySet + * + * Note: This function is deprecated by wifi_twt_get_capabilities + */ + wifi_error (*wifi_twt_get_capability)(wifi_interface_handle iface, + TwtCapabilitySet* twt_cap_set); + + /**@brief twt_setup_request + * Request to send TWT setup frame + * @param wifi_interface_handle: + * @param TwtSetupRequest: detailed parameters of setup request + * @return Synchronous wifi_error + * @return Asynchronous EventTwtSetupResponse CB return TwtSetupResponse + * + * Note: This function is deprecated by wifi_twt_session_setup + */ + wifi_error (*wifi_twt_setup_request)(wifi_interface_handle iface, + TwtSetupRequest* msg); + + /**@brief twt_teardown_request + * Request to send TWT teardown frame + * @param wifi_interface_handle: + * @param TwtTeardownRequest: detailed parameters of teardown request + * @return Synchronous wifi_error + * @return Asynchronous EventTwtTeardownCompletion CB return TwtTeardownCompletion + * TwtTeardownCompletion may also be received due to other events + * like CSA, BTCX, TWT scheduler, MultiConnection, peer-initiated teardown, etc. + * + * Note: This function is deprecated by wifi_twt_session_teardown + */ + wifi_error (*wifi_twt_teardown_request)(wifi_interface_handle iface, + TwtTeardownRequest* msg); + + /**@brief twt_info_frame_request + * Request to send TWT info frame + * @param wifi_interface_handle: + * @param TwtInfoFrameRequest: detailed parameters in info frame + * @return Synchronous wifi_error + * @return Asynchronous EventTwtInfoFrameReceived CB return TwtInfoFrameReceived + * Driver may also receive Peer-initiated TwtInfoFrame + * + * Note: This function is deprecated by wifi_twt_session_suspend and + * wifi_twt_session_resume + */ + wifi_error (*wifi_twt_info_frame_request)(wifi_interface_handle iface, + TwtInfoFrameRequest* msg); + + /**@brief twt_get_stats + * Request to get TWT stats + * @param wifi_interface_handle: + * @param config_id: configuration ID of TWT request + * @return Synchronous wifi_error and TwtStats + * + * Note: This function is deprecated by wifi_twt_get_session_stats + */ + wifi_error (*wifi_twt_get_stats)(wifi_interface_handle iface, u8 config_id, + TwtStats* stats); + + /**@brief twt_clear_stats + * Request to clear TWT stats + * @param wifi_interface_handle: + * @param config_id: configuration ID of TWT request + * @return Synchronous wifi_error + * + * Note: This function is deprecated by wifi_twt_session_clear_stats + */ + wifi_error (*wifi_twt_clear_stats)(wifi_interface_handle iface, u8 config_id); + + /** + * Invoked to set DTIM configuration when the host is in the suspend mode + * @param wifi_interface_handle: + * @param multiplier: when STA in the power saving mode, the wake up interval will be set to + * 1) multiplier * DTIM period if multiplier > 0. + * 2) the device default value if multiplier <=0 + * Some implementations may apply an additional cap to wake up interval in the case of 1). + */ + wifi_error (*wifi_set_dtim_config)(wifi_interface_handle handle, u32 multiplier); + + /**@brief wifi_get_usable_channels + * Request list of usable channels for the requested bands and modes. Usable + * implies channel is allowed as per regulatory for the current country code + * and not restricted due to other hard limitations (e.g. DFS, Coex) In + * certain modes (e.g. STA+SAP) there could be other hard restrictions + * since MCC operation many not be supported by SAP. This API also allows + * driver to return list of usable channels for each mode uniquely to + * distinguish cases where only a limited set of modes are allowed on + * a given channel e.g. srd channels may be supported for P2P but not + * for SAP or P2P-Client may be allowed on an indoor channel but P2P-GO + * may not be allowed. This API is not interface specific and will be + * used to query capabilities of driver in terms of what modes (STA, SAP, + * P2P_CLI, P2P_GO, NAN, TDLS) can be supported on each of the channels. + * @param handle global wifi_handle + * @param band_mask BIT MASK of WLAN_MAC* as represented by |wlan_mac_band| + * @param iface_mode_mask BIT MASK of BIT(WIFI_INTERFACE_*) represented by + * |wifi_interface_mode|. Bitmask respresents all the modes that the + * caller is interested in (e.g. STA, SAP, WFD-CLI, WFD-GO, TDLS, NAN). + * Note: Bitmask does not represent concurrency matrix. If the caller + * is interested in CLI, GO modes, the iface_mode_mask would be set + * to WIFI_INTERFACE_P2P_CLIENT|WIFI_INTERFACE_P2P_GO. + * @param filter_mask BIT MASK of WIFI_USABLE_CHANNEL_FILTER_* represented by + * |wifi_usable_channel_filter|. Indicates if the channel list should + * be filtered based on additional criteria. If filter_mask is not + * specified, driver should return list of usable channels purely + * based on regulatory constraints. + * @param max_size maximum number of |wifi_usable_channel| + * @param size actual number of |wifi_usable_channel| entries returned by driver + * @param channels list of usable channels represented by |wifi_usable_channel| + */ + wifi_error (*wifi_get_usable_channels)(wifi_handle handle, u32 band_mask, u32 iface_mode_mask, + u32 filter_mask, u32 max_size, u32* size, + wifi_usable_channel* channels); + + /** + * Trigger wifi subsystem restart to reload firmware + */ + wifi_error (*wifi_trigger_subsystem_restart)(wifi_handle handle); + + /** + * Invoked to set that the device is operating in an indoor environment. + * @param handle global wifi_handle + * @param isIndoor: true if the device is operating in an indoor + * environment, false otherwise. + * @return Synchronous wifi_error + */ + wifi_error (*wifi_set_indoor_state)(wifi_handle handle, bool isIndoor); + + /**@brief wifi_get_supported_radio_combinations_matrix + * Request all the possible radio combinations this device can offer. + * @param handle global wifi_handle + * @param max_size maximum size allocated for filling the wifi_radio_combination_matrix + * @param wifi_radio_combination_matrix to return all the possible radio + * combinations. + * @param size actual size of wifi_radio_combination_matrix returned from + * lower layer + * + */ + wifi_error (*wifi_get_supported_radio_combinations_matrix)( + wifi_handle handle, u32 max_size, u32 *size, + wifi_radio_combination_matrix *radio_combination_matrix); + + /**@brief wifi_nan_rtt_chre_enable_request + * Request to enable CHRE NAN RTT + * @param transaction_id: NAN transaction id + * @param wifi_interface_handle + * @param NanEnableRequest request message + * @return Synchronous wifi_error + */ + wifi_error (*wifi_nan_rtt_chre_enable_request)(transaction_id id, + wifi_interface_handle iface, + NanEnableRequest* msg); + + /**@brief wifi_nan_rtt_chre_disable_request + * Request to disable CHRE NAN RTT + * @param transaction_id: NAN transaction id + * @param wifi_interface_handle + * @return Synchronous wifi_error + */ + wifi_error (*wifi_nan_rtt_chre_disable_request)(transaction_id id, wifi_interface_handle iface); + + /**@brief wifi_chre_register_handler + * register a handler to get the state of CHR + * @param wifi_interface_handle + * @param wifi_chre_handler: callback function pointer + * @return Synchronous wifi_error + */ + wifi_error (*wifi_chre_register_handler)(wifi_interface_handle iface, + wifi_chre_handler handler); + + /**@brief wifi_enable_tx_power_limits + * Enable WiFi Tx power limis + * @param wifi_interface_handle + * @param isEnable : If enable TX limit or not + * @return Synchronous wifi_error + */ + wifi_error (*wifi_enable_tx_power_limits) (wifi_interface_handle iface, + bool isEnable); + + /**@brief wifi_get_cached_scan_results + * Retrieve scan results cached in wifi firmware + * @param wifi_interface_handle + * @param wifi_cached_scan_result_handler : callback function pointer + * @return Synchronous wifi_error + */ + wifi_error (*wifi_get_cached_scan_results)(wifi_interface_handle iface, + wifi_cached_scan_result_handler handler); + /**@brief wifi_get_chip_capabilities + * Retrieve capabilities supported by this chip + * @param wifi_handle + * @return Synchronous wifi_error and chip capabilites + */ + wifi_error (*wifi_get_chip_capabilities)(wifi_handle handle, + wifi_chip_capabilities *chip_capabilities); + + /**@brief wifi_get_supported_iface_concurrency_matrix + * Request all the possible interface concurrency combinations this + * Wifi Chip can offer. + * @param handle global wifi_handle + * @param wifi_iface_concurrency_matrix to return all the possible + * interface concurrency combinations. + * @return Synchronous wifi_error + */ + wifi_error (*wifi_get_supported_iface_concurrency_matrix)( + wifi_handle handle, wifi_iface_concurrency_matrix *matrix); + + /**@brief wifi_enable_sta_channel_for_peer_network + * enable or disable the feature of allowing current STA-connected + * channel for WFA GO, SAP and Wi-Fi Aware when the regulatory allows. + * @param handle global wifi_handle + * @param channelCategoryEnableFlag bitmask of |wifi_channel_category|. + * @return Synchronous wifi_error + */ + wifi_error (*wifi_enable_sta_channel_for_peer_network)( + wifi_handle handle, u32 channelCategoryEnableFlag); + + /**@brief wifi_nan_suspend_request + * Request that the specified NAN session be suspended. + * @param transaction_id: NAN transaction id + * @param wifi_interface_handle + * @param NanSuspendRequest request message + * @return Synchronous wifi_error + */ + wifi_error (*wifi_nan_suspend_request)(transaction_id id, wifi_interface_handle iface, + NanSuspendRequest *msg); + + /**@brief wifi_nan_resume_request + * Request that the specified NAN session be resumed. + * @param transaction_id: NAN transaction id + * @param wifi_interface_handle + * @param NanResumeRequest request message + * @return Synchronous wifi_error + */ + wifi_error (*wifi_nan_resume_request)(transaction_id id, wifi_interface_handle iface, + NanResumeRequest *msg); + + wifi_error (*wifi_nan_pairing_request)( + transaction_id id, wifi_interface_handle iface, + NanPairingRequest *msg); + wifi_error (*wifi_nan_pairing_indication_response)( + transaction_id id, wifi_interface_handle iface, + NanPairingIndicationResponse *msg); + wifi_error (*wifi_nan_bootstrapping_request)( + transaction_id id, wifi_interface_handle iface, + NanBootstrappingRequest *msg); + wifi_error (*wifi_nan_bootstrapping_indication_response)( + transaction_id id, wifi_interface_handle iface, + NanBootstrappingIndicationResponse *msg); + + /**@brief wifi_set_scan_mode + * Notify driver/firmware current is scan only mode to allow lower + * level to optimize power consumption. + * @param enable true if current is scan only mode + * @return Synchronous wifi_error + */ + wifi_error (*wifi_set_scan_mode)(const char * ifname, bool enable); + + wifi_error (*wifi_nan_pairing_end)(transaction_id id, + wifi_interface_handle iface, + NanPairingEndRequest *msg); + + /**@brief wifi_set_mlo_mode + * Set Multi-Link Operation mode. + * @param handle global wifi_handle + * @param mode: MLO mode + * @return Synchronous wifi_error + */ + wifi_error (*wifi_set_mlo_mode)(wifi_handle handle, wifi_mlo_mode mode); + + /* + * when adding new functions make sure to add stubs in + * wifi_legacy_hal_stubs.cpp::initHalFuncTableWithStubs + */ +} wifi_hal_fn; + +wifi_error init_wifi_vendor_hal_func_table(wifi_hal_fn *fn); +typedef wifi_error (*init_wifi_vendor_hal_func_table_t)(wifi_hal_fn *fn); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/wifi/legacy_headers/include/hardware_legacy/wifi_logger.h b/wifi/legacy_headers/include/hardware_legacy/wifi_logger.h new file mode 100644 index 0000000000..06928598c0 --- /dev/null +++ b/wifi/legacy_headers/include/hardware_legacy/wifi_logger.h @@ -0,0 +1,646 @@ +#include "wifi_hal.h" + +#ifndef __WIFI_HAL_LOGGER_H +#define __WIFI_HAL_LOGGER_H + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + +#define LOGGER_MAJOR_VERSION 1 +#define LOGGER_MINOR_VERSION 0 +#define LOGGER_MICRO_VERSION 0 + + + +/** + * WiFi logger life cycle is as follow: + * + * - At initialization time, framework will call wifi_get_ring_buffers_status + * so as to obtain the names and list of supported buffers. + * - When WiFi operation start framework will call wifi_start_logging + * so as to trigger log collection. + * - Developper UI will provide an option to the user, so as it can set the verbose level + * of individual buffer as reported by wifi_get_ring_buffers_status. + * - During wifi operations, driver will periodically report per ring data to framework + * by invoking the on_ring_buffer_data call back. + * - when capturing a bug report, framework will indicate to driver that all the data + * has to be uploaded, urgently, by calling wifi_get_ring_data. + * + * The data uploaded by driver will be stored by framework in separate files, with one stream + * of file per ring. + * Framework will store the files in pcapng format, allowing for easy merging and parsing + * with network analyzer tools. + */ + + +typedef int wifi_ring_buffer_id; + +#define PER_PACKET_ENTRY_FLAGS_DIRECTION_TX 1 // 0: TX, 1: RX +#define PER_PACKET_ENTRY_FLAGS_TX_SUCCESS 2 // whether packet was transmitted or + // received/decrypted successfully +#define PER_PACKET_ENTRY_FLAGS_80211_HEADER 4 // has full 802.11 header, else has 802.3 header +#define PER_PACKET_ENTRY_FLAGS_PROTECTED 8 // whether packet was encrypted + +typedef struct { + u8 flags; + u8 tid; // transmit or received tid + u16 MCS; // modulation and bandwidth + u8 rssi; // TX: RSSI of ACK for that packet + // RX: RSSI of packet + u8 num_retries; // number of attempted retries + u16 last_transmit_rate; // last transmit rate in .5 mbps + u16 link_layer_transmit_sequence; // transmit/reeive sequence for that MPDU packet + u64 firmware_entry_timestamp; // TX: firmware timestamp (us) when packet is queued within + // firmware buffer for SDIO/HSIC or into PCIe buffer + // RX: firmware receive timestamp + u64 start_contention_timestamp; // firmware timestamp (us) when packet start contending for the + // medium for the first time, at head of its AC queue, + // or as part of an MPDU or A-MPDU. This timestamp is + // not updated for each retry, only the first transmit attempt. + u64 transmit_success_timestamp; // fimrware timestamp (us) when packet is successfully + // transmitted or aborted because it has exhausted + // its maximum number of retries. + u8 data[0]; // packet data. The length of packet data is determined by the entry_size field of + // the wifi_ring_buffer_entry structure. It is expected that first bytes of the + // packet, or packet headers only (up to TCP or RTP/UDP headers) + // will be copied into the ring +} __attribute__((packed)) wifi_ring_per_packet_status_entry; + + +/* Below events refer to the wifi_connectivity_event ring and shall be supported */ +#define WIFI_EVENT_ASSOCIATION_REQUESTED 0 // driver receives association command from kernel +#define WIFI_EVENT_AUTH_COMPLETE 1 +#define WIFI_EVENT_ASSOC_COMPLETE 2 +#define WIFI_EVENT_FW_AUTH_STARTED 3 // fw event indicating auth frames are sent +#define WIFI_EVENT_FW_ASSOC_STARTED 4 // fw event indicating assoc frames are sent +#define WIFI_EVENT_FW_RE_ASSOC_STARTED 5 // fw event indicating reassoc frames are sent +#define WIFI_EVENT_DRIVER_SCAN_REQUESTED 6 +#define WIFI_EVENT_DRIVER_SCAN_RESULT_FOUND 7 +#define WIFI_EVENT_DRIVER_SCAN_COMPLETE 8 +#define WIFI_EVENT_G_SCAN_STARTED 9 +#define WIFI_EVENT_G_SCAN_COMPLETE 10 +#define WIFI_EVENT_DISASSOCIATION_REQUESTED 11 +#define WIFI_EVENT_RE_ASSOCIATION_REQUESTED 12 +#define WIFI_EVENT_ROAM_REQUESTED 13 +#define WIFI_EVENT_BEACON_RECEIVED 14 // received beacon from AP (event enabled + // only in verbose mode) +#define WIFI_EVENT_ROAM_SCAN_STARTED 15 // firmware has triggered a roam scan (not g-scan) +#define WIFI_EVENT_ROAM_SCAN_COMPLETE 16 // firmware has completed a roam scan (not g-scan) +#define WIFI_EVENT_ROAM_SEARCH_STARTED 17 // firmware has started searching for roam + // candidates (with reason =xx) +#define WIFI_EVENT_ROAM_SEARCH_STOPPED 18 // firmware has stopped searching for roam + // candidates (with reason =xx) +#define WIFI_EVENT_CHANNEL_SWITCH_ANOUNCEMENT 20 // received channel switch anouncement from AP +#define WIFI_EVENT_FW_EAPOL_FRAME_TRANSMIT_START 21 // fw start transmit eapol frame, with + // EAPOL index 1-4 +#define WIFI_EVENT_FW_EAPOL_FRAME_TRANSMIT_STOP 22 // fw gives up eapol frame, with rate, + // success/failure and number retries +#define WIFI_EVENT_DRIVER_EAPOL_FRAME_TRANSMIT_REQUESTED 23 // kernel queue EAPOL for transmission + // in driver with EAPOL index 1-4 +#define WIFI_EVENT_FW_EAPOL_FRAME_RECEIVED 24 // with rate, regardless of the fact that + // EAPOL frame is accepted or rejected by fw +#define WIFI_EVENT_DRIVER_EAPOL_FRAME_RECEIVED 26 // with rate, and eapol index, driver has + // received EAPOL frame and will queue it up + // to wpa_supplicant +#define WIFI_EVENT_BLOCK_ACK_NEGOTIATION_COMPLETE 27 // with success/failure, parameters +#define WIFI_EVENT_BT_COEX_BT_SCO_START 28 +#define WIFI_EVENT_BT_COEX_BT_SCO_STOP 29 +#define WIFI_EVENT_BT_COEX_BT_SCAN_START 30 // for paging/scan etc., when BT starts transmiting + // twice per BT slot +#define WIFI_EVENT_BT_COEX_BT_SCAN_STOP 31 +#define WIFI_EVENT_BT_COEX_BT_HID_START 32 +#define WIFI_EVENT_BT_COEX_BT_HID_STOP 33 +#define WIFI_EVENT_ROAM_AUTH_STARTED 34 // fw sends auth frame in roaming to next candidate +#define WIFI_EVENT_ROAM_AUTH_COMPLETE 35 // fw receive auth confirm from ap +#define WIFI_EVENT_ROAM_ASSOC_STARTED 36 // firmware sends assoc/reassoc frame in + // roaming to next candidate +#define WIFI_EVENT_ROAM_ASSOC_COMPLETE 37 // firmware receive assoc/reassoc confirm from ap +#define WIFI_EVENT_G_SCAN_STOP 38 // firmware sends stop G_SCAN +#define WIFI_EVENT_G_SCAN_CYCLE_STARTED 39 // firmware indicates G_SCAN scan cycle started +#define WIFI_EVENT_G_SCAN_CYCLE_COMPLETED 40 // firmware indicates G_SCAN scan cycle completed +#define WIFI_EVENT_G_SCAN_BUCKET_STARTED 41 // firmware indicates G_SCAN scan start + // for a particular bucket +#define WIFI_EVENT_G_SCAN_BUCKET_COMPLETED 42 // firmware indicates G_SCAN scan completed for + // for a particular bucket +#define WIFI_EVENT_G_SCAN_RESULTS_AVAILABLE 43 // Event received from firmware about G_SCAN scan + // results being available +#define WIFI_EVENT_G_SCAN_CAPABILITIES 44 // Event received from firmware with G_SCAN + // capabilities +#define WIFI_EVENT_ROAM_CANDIDATE_FOUND 45 // Event received from firmware when eligible + // candidate is found +#define WIFI_EVENT_ROAM_SCAN_CONFIG 46 // Event received from firmware when roam scan + // configuration gets enabled or disabled +#define WIFI_EVENT_AUTH_TIMEOUT 47 // firmware/driver timed out authentication +#define WIFI_EVENT_ASSOC_TIMEOUT 48 // firmware/driver timed out association +#define WIFI_EVENT_MEM_ALLOC_FAILURE 49 // firmware/driver encountered allocation failure +#define WIFI_EVENT_DRIVER_PNO_ADD 50 // driver added a PNO network in firmware +#define WIFI_EVENT_DRIVER_PNO_REMOVE 51 // driver removed a PNO network in firmware +#define WIFI_EVENT_DRIVER_PNO_NETWORK_FOUND 52 // driver received PNO networks + // found indication from firmware +#define WIFI_EVENT_DRIVER_PNO_SCAN_REQUESTED 53 // driver triggered a scan for PNO networks +#define WIFI_EVENT_DRIVER_PNO_SCAN_RESULT_FOUND 54 // driver received scan results + // of PNO networks +#define WIFI_EVENT_DRIVER_PNO_SCAN_COMPLETE 55 // driver updated scan results from + // PNO networks to cfg80211 + +/** + * Parameters of wifi logger events are TLVs + * Event parameters tags are defined as: + */ +#define WIFI_TAG_VENDOR_SPECIFIC 0 // take a byte stream as parameter +#define WIFI_TAG_BSSID 1 // takes a 6 bytes MAC address as parameter +#define WIFI_TAG_ADDR 2 // takes a 6 bytes MAC address as parameter +#define WIFI_TAG_SSID 3 // takes a 32 bytes SSID address as parameter +#define WIFI_TAG_STATUS 4 // takes an integer as parameter +#define WIFI_TAG_CHANNEL_SPEC 5 // takes one or more wifi_channel_spec as parameter +#define WIFI_TAG_WAKE_LOCK_EVENT 6 // takes a wake_lock_event struct as parameter +#define WIFI_TAG_ADDR1 7 // takes a 6 bytes MAC address as parameter +#define WIFI_TAG_ADDR2 8 // takes a 6 bytes MAC address as parameter +#define WIFI_TAG_ADDR3 9 // takes a 6 bytes MAC address as parameter +#define WIFI_TAG_ADDR4 10 // takes a 6 bytes MAC address as parameter +#define WIFI_TAG_TSF 11 // take a 64 bits TSF value as parameter +#define WIFI_TAG_IE 12 // take one or more specific 802.11 IEs parameter, + // IEs are in turn indicated in TLV format as per + // 802.11 spec +#define WIFI_TAG_INTERFACE 13 // take interface name as parameter +#define WIFI_TAG_REASON_CODE 14 // take a reason code as per 802.11 as parameter +#define WIFI_TAG_RATE_MBPS 15 // take a wifi rate in 0.5 mbps +#define WIFI_TAG_REQUEST_ID 16 // take an integer as parameter +#define WIFI_TAG_BUCKET_ID 17 // take an integer as parameter +#define WIFI_TAG_GSCAN_PARAMS 18 // takes a wifi_scan_cmd_params struct as parameter +#define WIFI_TAG_GSCAN_CAPABILITIES 19 // takes a wifi_gscan_capabilities struct as parameter +#define WIFI_TAG_SCAN_ID 20 // take an integer as parameter +#define WIFI_TAG_RSSI 21 // take an integer as parameter +#define WIFI_TAG_CHANNEL 22 // take an integer as parameter +#define WIFI_TAG_LINK_ID 23 // take an integer as parameter +#define WIFI_TAG_LINK_ROLE 24 // take an integer as parameter +#define WIFI_TAG_LINK_STATE 25 // take an integer as parameter +#define WIFI_TAG_LINK_TYPE 26 // take an integer as parameter +#define WIFI_TAG_TSCO 27 // take an integer as parameter +#define WIFI_TAG_RSCO 28 // take an integer as parameter +#define WIFI_TAG_EAPOL_MESSAGE_TYPE 29 // take an integer as parameter + // M1-1, M2-2, M3-3, M4-4 + +typedef struct { + u16 tag; + u16 length; // length of value + u8 value[0]; +} __attribute__((packed)) tlv_log; + +typedef struct { + u16 event; + tlv_log tlvs[0]; // separate parameter structure per event to be provided and optional data + // the event_data is expected to include an official android part, with some + // parameter as transmit rate, num retries, num scan result found etc... + // as well, event_data can include a vendor proprietary part which is + // understood by the developer only. +} __attribute__((packed)) wifi_ring_buffer_driver_connectivity_event; + + +/** + * Ring buffer name for power events ring. note that power event are extremely frequents + * and thus should be stored in their own ring/file so as not to clobber connectivity events. + */ +typedef struct { + int status; // 0 taken, 1 released + int reason; // reason why this wake lock is taken + char name[0]; // null terminated +} __attribute__((packed)) wake_lock_event; + +typedef struct { + u16 event; + tlv_log tlvs[0]; +} __attribute__((packed)) wifi_power_event; + + +/** + * This structure represent a logger entry within a ring buffer. + * Wifi driver are responsible to manage the ring buffer and write the debug + * information into those rings. + * + * In general, the debug entries can be used to store meaningful 802.11 information (SME, MLME, + * connection and packet statistics) as well as vendor proprietary data that is specific to a + * specific driver or chipset. + * Binary entries can be used so as to store packet data or vendor specific information and + * will be treated as blobs of data by android. + * + * A user land process will be started by framework so as to periodically retrieve the + * data logged by drivers into their ring buffer, store the data into log files and include + * the logs into android bugreports. + */ +enum { + RING_BUFFER_ENTRY_FLAGS_HAS_BINARY = (1 << (0)), // set for binary entries + RING_BUFFER_ENTRY_FLAGS_HAS_TIMESTAMP = (1 << (1)) // set if 64 bits timestamp is present +}; + +enum { + ENTRY_TYPE_CONNECT_EVENT = 1, + ENTRY_TYPE_PKT, + ENTRY_TYPE_WAKE_LOCK, + ENTRY_TYPE_POWER_EVENT, + ENTRY_TYPE_DATA +}; + +typedef struct { + u16 entry_size; // the size of payload excluding the header. + u8 flags; + u8 type; // entry type + u64 timestamp; // present if has_timestamp bit is set. +} __attribute__((packed)) wifi_ring_buffer_entry; + +#define WIFI_RING_BUFFER_FLAG_HAS_BINARY_ENTRIES 0x00000001 // set if binary entries are present +#define WIFI_RING_BUFFER_FLAG_HAS_ASCII_ENTRIES 0x00000002 // set if ascii entries are present + + +/* ring buffer params */ +/** + * written_bytes and read_bytes implement a producer consumer API + * hence written_bytes >= read_bytes + * a modulo arithmetic of the buffer size has to be applied to those counters: + * actual offset into ring buffer = written_bytes % ring_buffer_byte_size + * + */ +typedef struct { + u8 name[32]; + u32 flags; + wifi_ring_buffer_id ring_id; // unique integer representing the ring + u32 ring_buffer_byte_size; // total memory size allocated for the buffer + u32 verbose_level; // verbose level for ring buffer + u32 written_bytes; // number of bytes that was written to the buffer by driver, + // monotonously increasing integer + u32 read_bytes; // number of bytes that was read from the buffer by user land, + // monotonously increasing integer + u32 written_records; // number of records that was written to the buffer by driver, + // monotonously increasing integer +} wifi_ring_buffer_status; + + +/** + * Callback for reporting ring data + * + * The ring buffer data collection is event based: + * - Driver calls on_ring_buffer_data when new records are available, the wifi_ring_buffer_status + * passed up to framework in the call back indicates to framework if more data is available in + * the ring buffer. It is not expected that driver will necessarily always empty the ring + * immediately as data is available, instead driver will report data every X seconds or if + * N bytes are available. + * - In the case where a bug report has to be captured, framework will require driver to upload + * all data immediately. This is indicated to driver when framework calls wifi_get_ringdata. + * When framework calls wifi_get_ring_data, driver will start sending all available data in the + * indicated ring by repeatedly invoking the on_ring_buffer_data callback. + * + * The callback is called by log handler whenever ring data comes in driver. + */ +typedef struct { + void (*on_ring_buffer_data) (char *ring_name, char *buffer, int buffer_size, + wifi_ring_buffer_status *status); +} wifi_ring_buffer_data_handler; + +/** + * API to set the log handler for getting ring data + * - Only a single instance of log handler can be instantiated for each ring buffer. + */ +wifi_error wifi_set_log_handler(wifi_request_id id, wifi_interface_handle iface, + wifi_ring_buffer_data_handler handler); + +/* API to reset the log handler */ +wifi_error wifi_reset_log_handler(wifi_request_id id, wifi_interface_handle iface); + + +/** + * Callback for reporting FW dump + * + * The buffer data collection is event based such as FW health check or FW dump. + * The callback is called by alert handler. + */ +typedef struct { + void (*on_alert) (wifi_request_id id, char *buffer, int buffer_size, int err_code); +} wifi_alert_handler; + +/* + * API to set the alert handler for the alert case in Wi-Fi Chip + * - Only a single instance of alert handler can be instantiated. + */ +wifi_error wifi_set_alert_handler(wifi_request_id id, wifi_interface_handle iface, + wifi_alert_handler handler); + +/* API to reset the alert handler */ +wifi_error wifi_reset_alert_handler(wifi_request_id id, wifi_interface_handle iface); + +/* API for framework to indicate driver has to upload and drain all data of a given ring */ +wifi_error wifi_get_ring_data(wifi_interface_handle iface, char *ring_name); + + +/** + * API to trigger the debug collection. + * Unless his API is invoked - logging is not triggered. + * - Verbose_level 0 corresponds to no collection, + * and it makes log handler stop by no more events from driver. + * - Verbose_level 1 correspond to normal log level, with minimal user impact. + * This is the default value. + * - Verbose_level 2 are 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_level 3+ are used when trying to actively debug a problem. + * + * ring_name represent the name of the ring for which data collection shall start. + * + * flags: TBD parameter used to enable/disable specific events on a ring + * max_interval: maximum interval in seconds for driver to invoke on_ring_buffer_data, + * ignore if zero + * min_data_size: minimum data size in buffer for driver to invoke on_ring_buffer_data, + * ignore if zero + */ +wifi_error wifi_start_logging(wifi_interface_handle iface, u32 verbose_level, u32 flags, + u32 max_interval_sec, u32 min_data_size, char *ring_name); + +/** + * API to get the status of all ring buffers supported by driver. + * - Caller is responsible to allocate / free ring buffer status. + * - Maximum no of ring buffer would be 10. + */ +wifi_error wifi_get_ring_buffers_status(wifi_interface_handle iface, u32 *num_rings, + wifi_ring_buffer_status *status); + +/** + * Synchronous memory dump by user request. + * - Caller is responsible to store memory dump data into a local, + * e.g., /data/misc/wifi/memdump.bin + */ +typedef struct { + void (*on_firmware_memory_dump) (char *buffer, int buffer_size); +} wifi_firmware_memory_dump_handler; + +/** + * API to collect a firmware memory dump for a given iface by async memdump event. + * - Triggered by Alerthandler, esp. when FW problem or FW health check happens + * - Caller is responsible to store fw dump data into a local, + * e.g., /data/misc/wifi/alertdump-1.bin + */ +wifi_error wifi_get_firmware_memory_dump(wifi_interface_handle iface, + wifi_firmware_memory_dump_handler handler); + +/** + * API to collect a firmware version string. + * - Caller is responsible to allocate / free a buffer to retrieve firmware verion info. + * - Max string will be at most 256 bytes. + */ +wifi_error wifi_get_firmware_version(wifi_interface_handle iface, char *buffer, int buffer_size); + +/** + * API to collect a driver version string. + * - Caller is responsible to allocate / free a buffer to retrieve driver verion info. + * - Max string will be at most 256 bytes. + */ +wifi_error wifi_get_driver_version(wifi_interface_handle iface, char *buffer, int buffer_size); + + +/* Feature set */ +enum { + WIFI_LOGGER_MEMORY_DUMP_SUPPORTED = (1 << (0)), // Memory dump of FW + WIFI_LOGGER_PER_PACKET_TX_RX_STATUS_SUPPORTED = (1 << (1)), // PKT status + WIFI_LOGGER_CONNECT_EVENT_SUPPORTED = (1 << (2)), // Connectivity event + WIFI_LOGGER_POWER_EVENT_SUPPORTED = (1 << (3)), // POWER of Driver + WIFI_LOGGER_WAKE_LOCK_SUPPORTED = (1 << (4)), // WAKE LOCK of Driver + WIFI_LOGGER_VERBOSE_SUPPORTED = (1 << (5)), // verbose log of FW + WIFI_LOGGER_WATCHDOG_TIMER_SUPPORTED = (1 << (6)), // monitor the health of FW + WIFI_LOGGER_DRIVER_DUMP_SUPPORTED = (1 << (7)), // dumps driver state + WIFI_LOGGER_PACKET_FATE_SUPPORTED = (1 << (8)), // tracks connection packets' fate +}; + +/** + * API to retrieve the current supportive features. + * - An integer variable is enough to have bit mapping info by caller. + */ +wifi_error wifi_get_logger_supported_feature_set(wifi_interface_handle iface, + unsigned int *support); + +typedef struct { + /* Buffer is to be allocated and freed by HAL implementation. */ + void (*on_driver_memory_dump) (char *buffer, int buffer_size); +} wifi_driver_memory_dump_callbacks; + +/** + API to collect driver state. + + Framework will call this API soon before or after (but not + concurrently with) wifi_get_firmware_memory_dump(). Capturing + firmware and driver dumps is intended to help identify + inconsistent state between these components. + + - In response to this call, HAL implementation should make one or + more calls to callbacks.on_driver_memory_dump(). Framework will + copy data out of the received |buffer|s, and concatenate the + contents thereof. + - HAL implemention will indicate completion of the driver memory + dump by returning from this call. +*/ +wifi_error wifi_get_driver_memory_dump( + wifi_interface_handle iface, + wifi_driver_memory_dump_callbacks callbacks); + + +/* packet fate logs */ + +#define MD5_PREFIX_LEN 4 +#define MAX_FATE_LOG_LEN 32 +#define MAX_FRAME_LEN_ETHERNET 1518 +#define MAX_FRAME_LEN_80211_MGMT 2352 // 802.11-2012 Fig. 8-34 + +typedef enum { + // Sent over air and ACKed. + TX_PKT_FATE_ACKED, + + // Sent over air but not ACKed. (Normal for broadcast/multicast.) + TX_PKT_FATE_SENT, + + // Queued within firmware, but not yet sent over air. + TX_PKT_FATE_FW_QUEUED, + + // Dropped by firmware as invalid. E.g. bad source address, bad checksum, + // or invalid for current state. + TX_PKT_FATE_FW_DROP_INVALID, + + // Dropped by firmware due to lack of buffer space. + TX_PKT_FATE_FW_DROP_NOBUFS, + + // Dropped by firmware for any other reason. Includes frames that + // were sent by driver to firmware, but unaccounted for by + // firmware. + TX_PKT_FATE_FW_DROP_OTHER, + + // Queued within driver, not yet sent to firmware. + TX_PKT_FATE_DRV_QUEUED, + + // Dropped by driver as invalid. E.g. bad source address, or + // invalid for current state. + TX_PKT_FATE_DRV_DROP_INVALID, + + // Dropped by driver due to lack of buffer space. + TX_PKT_FATE_DRV_DROP_NOBUFS, + + // Dropped by driver for any other reason. + TX_PKT_FATE_DRV_DROP_OTHER, +} wifi_tx_packet_fate; + +typedef enum { + // Valid and delivered to network stack (e.g., netif_rx()). + RX_PKT_FATE_SUCCESS, + + // Queued within firmware, but not yet sent to driver. + RX_PKT_FATE_FW_QUEUED, + + // Dropped by firmware due to host-programmable filters. + RX_PKT_FATE_FW_DROP_FILTER, + + // Dropped by firmware as invalid. E.g. bad checksum, decrypt failed, + // or invalid for current state. + RX_PKT_FATE_FW_DROP_INVALID, + + // Dropped by firmware due to lack of buffer space. + RX_PKT_FATE_FW_DROP_NOBUFS, + + // Dropped by firmware for any other reason. + RX_PKT_FATE_FW_DROP_OTHER, + + // Queued within driver, not yet delivered to network stack. + RX_PKT_FATE_DRV_QUEUED, + + // Dropped by driver due to filter rules. + RX_PKT_FATE_DRV_DROP_FILTER, + + // Dropped by driver as invalid. E.g. not permitted in current state. + RX_PKT_FATE_DRV_DROP_INVALID, + + // Dropped by driver due to lack of buffer space. + RX_PKT_FATE_DRV_DROP_NOBUFS, + + // Dropped by driver for any other reason. + RX_PKT_FATE_DRV_DROP_OTHER, +} wifi_rx_packet_fate; + +typedef enum { + FRAME_TYPE_UNKNOWN, + FRAME_TYPE_ETHERNET_II, + FRAME_TYPE_80211_MGMT, +} frame_type; + +typedef struct { + // 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. + frame_type payload_type; + + // The number of bytes included in |frame_content|. If the frame + // contents are missing (e.g. RX frame dropped in firmware), + // |frame_len| should be set to 0. + size_t frame_len; + + // Host clock when this frame was received by the driver (either + // outbound from the host network stack, or inbound from the + // firmware). + // - The timestamp should 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 should be set to 0. + u32 driver_timestamp_usec; + + // Firmware clock when this frame was received by the firmware + // (either outbound from the host, or inbound from a remote + // station). + // - The timestamp should 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 should be set to 0. + // - Consumers of |frame_info| should _not_ assume any + // synchronization between driver and firmware clocks. + u32 firmware_timestamp_usec; + + // Actual frame content. + // - 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, |frame_len| should be set + // to 0. + union { + char ethernet_ii_bytes[MAX_FRAME_LEN_ETHERNET]; + char ieee_80211_mgmt_bytes[MAX_FRAME_LEN_80211_MGMT]; + } frame_content; +} frame_info; + +typedef struct { + // Prefix of MD5 hash of |frame_inf.frame_content|. If frame + // content is not provided, prefix of MD5 hash over the same data + // that would be in frame_content, if frame content were provided. + char md5_prefix[MD5_PREFIX_LEN]; + wifi_tx_packet_fate fate; + frame_info frame_inf; +} wifi_tx_report; + +typedef struct { + // Prefix of MD5 hash of |frame_inf.frame_content|. If frame + // content is not provided, prefix of MD5 hash over the same data + // that would be in frame_content, if frame content were provided. + char md5_prefix[MD5_PREFIX_LEN]; + wifi_rx_packet_fate fate; + frame_info frame_inf; +} wifi_rx_report; + +/** + API to start packet fate monitoring. + - Once stared, monitoring should remain active until HAL is unloaded. + - When HAL is unloaded, all packet fate buffers should be cleared. +*/ +wifi_error wifi_start_pkt_fate_monitoring(wifi_interface_handle handle); + +/** + API to retrieve fates of outbound packets. + - HAL implementation should fill |tx_report_bufs| with fates of + _first_ min(n_requested_fates, actual packets) frames + transmitted for the most recent association. The fate reports + should follow the same order as their respective packets. + - HAL implementation may choose (but is not required) to include + reports for management frames. + - Packets reported by firmware, but not recognized by driver, + should be included. However, the ordering of the corresponding + reports is at the discretion of HAL implementation. + - Framework may call this API multiple times for the same association. + - Framework will ensure |n_requested_fates <= MAX_FATE_LOG_LEN|. + - Framework will allocate and free the referenced storage. +*/ +wifi_error wifi_get_tx_pkt_fates(wifi_interface_handle handle, + wifi_tx_report *tx_report_bufs, + size_t n_requested_fates, + size_t *n_provided_fates); + +/** + API to retrieve fates of inbound packets. + - HAL implementation should fill |rx_report_bufs| with fates of + _first_ min(n_requested_fates, actual packets) frames + received for the most recent association. The fate reports + should follow the same order as their respective packets. + - HAL implementation may choose (but is not required) to include + reports for management frames. + - Packets reported by firmware, but not recognized by driver, + should be included. However, the ordering of the corresponding + reports is at the discretion of HAL implementation. + - Framework may call this API multiple times for the same association. + - Framework will ensure |n_requested_fates <= MAX_FATE_LOG_LEN|. + - Framework will allocate and free the referenced storage. +*/ +wifi_error wifi_get_rx_pkt_fates(wifi_interface_handle handle, + wifi_rx_report *rx_report_bufs, + size_t n_requested_fates, + size_t *n_provided_fates); + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#endif /*__WIFI_HAL_STATS_ */ diff --git a/wifi/legacy_headers/include/hardware_legacy/wifi_nan.h b/wifi/legacy_headers/include/hardware_legacy/wifi_nan.h new file mode 100644 index 0000000000..55034d131e --- /dev/null +++ b/wifi/legacy_headers/include/hardware_legacy/wifi_nan.h @@ -0,0 +1,3500 @@ +/* + * Copyright (C) 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. + */ + +#ifndef __NAN_H__ +#define __NAN_H__ + +#include +#include +#include "wifi_hal.h" + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + +/***************************************************************************** + * Neighbour Aware Network Service Structures and Functions + *****************************************************************************/ + +/* + Definitions + All multi-byte fields within all NAN protocol stack messages are assumed to be in Little Endian order. +*/ + +typedef int NanVersion; +typedef u16 transaction_id; +typedef u32 NanDataPathId; + +#define NAN_MAC_ADDR_LEN 6 +#define NAN_MAJOR_VERSION 4 +#define NAN_MINOR_VERSION 0 +#define NAN_MICRO_VERSION 0 +#define NAN_MAX_SOCIAL_CHANNELS 3 + +/* NAN Maximum Lengths */ +#define NAN_MAX_SERVICE_NAME_LEN 255 +#define NAN_MAX_MATCH_FILTER_LEN 255 +#define NAN_MAX_SERVICE_SPECIFIC_INFO_LEN 1024 +#define NAN_MAX_VSA_DATA_LEN 1024 +#define NAN_MAX_MESH_DATA_LEN 32 +#define NAN_MAX_INFRA_DATA_LEN 32 +#define NAN_MAX_CLUSTER_ATTRIBUTE_LEN 255 +#define NAN_MAX_SUBSCRIBE_MAX_ADDRESS 42 +#define NAN_MAX_FAM_CHANNELS 32 +#define NAN_MAX_POSTDISCOVERY_LEN 5 +#define NAN_MAX_FRAME_DATA_LEN 504 +#define NAN_DP_MAX_APP_INFO_LEN 512 +#define NAN_ERROR_STR_LEN 255 +#define NAN_PMK_INFO_LEN 32 +#define NAN_MAX_SCID_BUF_LEN 1024 +#define NAN_MAX_SDEA_SERVICE_SPECIFIC_INFO_LEN 2048 +#define NAN_SECURITY_MIN_PASSPHRASE_LEN 8 +#define NAN_SECURITY_MAX_PASSPHRASE_LEN 63 +#define NAN_MAX_CHANNEL_INFO_SUPPORTED 4 +#define NAN_IDENTITY_KEY_LEN 16 +#define NAN_IDENTITY_TAG_LEN 8 +#define NAN_IDENTITY_NONCE_LEN 8 +#define NAN_MAX_MATCH_IDENTITY_LEN 1024 +/* + Definition of various NanResponseType +*/ +typedef enum { + NAN_RESPONSE_ENABLED = 0, + NAN_RESPONSE_DISABLED = 1, + NAN_RESPONSE_PUBLISH = 2, + NAN_RESPONSE_PUBLISH_CANCEL = 3, + NAN_RESPONSE_TRANSMIT_FOLLOWUP = 4, + NAN_RESPONSE_SUBSCRIBE = 5, + NAN_RESPONSE_SUBSCRIBE_CANCEL = 6, + NAN_RESPONSE_STATS = 7, + NAN_RESPONSE_CONFIG = 8, + NAN_RESPONSE_TCA = 9, + NAN_RESPONSE_ERROR = 10, + NAN_RESPONSE_BEACON_SDF_PAYLOAD = 11, + NAN_GET_CAPABILITIES = 12, + NAN_DP_INTERFACE_CREATE = 13, + NAN_DP_INTERFACE_DELETE = 14, + NAN_DP_INITIATOR_RESPONSE = 15, + NAN_DP_RESPONDER_RESPONSE = 16, + NAN_DP_END = 17, + NAN_PAIRING_INITIATOR_RESPONSE = 18, + NAN_PAIRING_RESPONDER_RESPONSE = 19, + NAN_BOOTSTRAPPING_INITIATOR_RESPONSE = 20, + NAN_BOOTSTRAPPING_RESPONDER_RESPONSE = 21, + NAN_PAIRING_END = 22, + NAN_SUSPEND_REQUEST_RESPONSE = 23, + NAN_RESUME_REQUEST_RESPONSE = 24 +} NanResponseType; + +/* NAN Publish Types */ +typedef enum { + NAN_PUBLISH_TYPE_UNSOLICITED = 0, + NAN_PUBLISH_TYPE_SOLICITED, + NAN_PUBLISH_TYPE_UNSOLICITED_SOLICITED +} NanPublishType; + +/* NAN Transmit Priorities */ +typedef enum { + NAN_TX_PRIORITY_NORMAL = 0, + NAN_TX_PRIORITY_HIGH +} NanTxPriority; + +/* NAN Statistics Request ID Codes */ +typedef enum { + NAN_STATS_ID_DE_PUBLISH = 0, + NAN_STATS_ID_DE_SUBSCRIBE, + NAN_STATS_ID_DE_MAC, + NAN_STATS_ID_DE_TIMING_SYNC, + NAN_STATS_ID_DE_DW, + NAN_STATS_ID_DE +} NanStatsType; + +/* NAN Protocol Event ID Codes */ +typedef enum { + NAN_EVENT_ID_DISC_MAC_ADDR = 0, + NAN_EVENT_ID_STARTED_CLUSTER, + NAN_EVENT_ID_JOINED_CLUSTER +} NanDiscEngEventType; + +/* NAN Data Path type */ +typedef enum { + NAN_DATA_PATH_UNICAST_MSG = 0, + NAN_DATA_PATH_MULTICAST_MSG +} NdpType; + +/* NAN Ranging Configuration */ +typedef enum { + NAN_RANGING_DISABLE = 0, + NAN_RANGING_ENABLE +} NanRangingState; + +/* TCA Type */ +typedef enum { + NAN_TCA_ID_CLUSTER_SIZE = 0 +} NanTcaType; + +/* pairing request type*/ +typedef enum { + NAN_PAIRING_SETUP = 0, + NAN_PAIRING_VERIFICATION = 1 +} NanPairingRequestType; + +/* Nan AKM type */ +typedef enum { + SAE = 0, + PASN = 1 +} NanAkm; + +/* NAN Channel Info */ +typedef struct { + u32 channel; + u32 bandwidth; + u32 nss; +} NanChannelInfo; + +/* + Various NAN Protocol Response code +*/ +typedef enum { + /* NAN Protocol Response Codes */ + NAN_STATUS_SUCCESS = 0, + /* NAN Discovery Engine/Host driver failures */ + NAN_STATUS_INTERNAL_FAILURE = 1, + /* NAN OTA failures */ + NAN_STATUS_PROTOCOL_FAILURE = 2, + /* if the publish/subscribe id is invalid */ + NAN_STATUS_INVALID_PUBLISH_SUBSCRIBE_ID = 3, + /* If we run out of resources allocated */ + NAN_STATUS_NO_RESOURCE_AVAILABLE = 4, + /* if invalid params are passed */ + NAN_STATUS_INVALID_PARAM = 5, + /* if the requestor instance id is invalid */ + NAN_STATUS_INVALID_REQUESTOR_INSTANCE_ID = 6, + /* if the ndp id is invalid */ + NAN_STATUS_INVALID_NDP_ID = 7, + /* if NAN is enabled when wifi is turned off */ + NAN_STATUS_NAN_NOT_ALLOWED = 8, + /* if over the air ack is not received */ + NAN_STATUS_NO_OTA_ACK = 9, + /* If NAN is already enabled and we are try to re-enable the same */ + NAN_STATUS_ALREADY_ENABLED = 10, + /* If followup message internal queue is full */ + NAN_STATUS_FOLLOWUP_QUEUE_FULL = 11, + /* Unsupported concurrency session enabled, NAN disabled notified */ + NAN_STATUS_UNSUPPORTED_CONCURRENCY_NAN_DISABLED = 12, + /* if the pairing id is invalid */ + NAN_STATUS_INVALID_PAIRING_ID = 13, + /* if the bootstrapping id is invalid */ + NAN_STATUS_INVALID_BOOTSTRAPPING_ID = 14, + /* If same request is received again */ + NAN_STATUS_REDUNDANT_REQUEST = 15, + /* If current request is not supported */ + NAN_STATUS_NOT_SUPPORTED = 16, + /* If no Wifi Aware connection is active */ + NAN_STATUS_NO_CONNECTION = 17, +} NanStatusType; + +/* NAN Transmit Types */ +typedef enum { + NAN_TX_TYPE_BROADCAST = 0, + NAN_TX_TYPE_UNICAST +} NanTxType; + +/* NAN Subscribe Type */ +typedef enum { + NAN_SUBSCRIBE_TYPE_PASSIVE = 0, + NAN_SUBSCRIBE_TYPE_ACTIVE +} NanSubscribeType; + +/* NAN Service Response Filter Attribute Bit */ +typedef enum { + NAN_SRF_ATTR_BLOOM_FILTER = 0, + NAN_SRF_ATTR_PARTIAL_MAC_ADDR +} NanSRFType; + +/* NAN Service Response Filter Include Bit */ +typedef enum { + NAN_SRF_INCLUDE_DO_NOT_RESPOND = 0, + NAN_SRF_INCLUDE_RESPOND +} NanSRFIncludeType; + +/* NAN Match indication type */ +typedef enum { + NAN_MATCH_ALG_MATCH_ONCE = 0, + NAN_MATCH_ALG_MATCH_CONTINUOUS, + NAN_MATCH_ALG_MATCH_NEVER +} NanMatchAlg; + +/* NAN Transmit Window Type */ +typedef enum { + NAN_TRANSMIT_IN_DW = 0, + NAN_TRANSMIT_IN_FAW +} NanTransmitWindowType; + +/* NAN SRF State in Subscribe */ +typedef enum { + NAN_DO_NOT_USE_SRF = 0, + NAN_USE_SRF +} NanSRFState; + +/* NAN Include SSI in MatchInd */ +typedef enum { + NAN_SSI_NOT_REQUIRED_IN_MATCH_IND = 0, + NAN_SSI_REQUIRED_IN_MATCH_IND +} NanSsiInMatchInd; + +/* NAN DP security Configuration */ +typedef enum { + NAN_DP_CONFIG_NO_SECURITY = 0, + NAN_DP_CONFIG_SECURITY +} NanDataPathSecurityCfgStatus; + +typedef enum { + NAN_QOS_NOT_REQUIRED = 0, + NAN_QOS_REQUIRED +} NanQosCfgStatus; + + +/* Data request Responder's response */ +typedef enum { + NAN_DP_REQUEST_ACCEPT = 0, + NAN_DP_REQUEST_REJECT +} NanDataPathResponseCode; + +/* Pairing request Responder's response */ +typedef enum { + NAN_PAIRING_REQUEST_ACCEPT = 0, + NAN_PAIRING_REQUEST_REJECT +} NanPairingResponseCode; + +/* Pairing bootstrapping Responder's response */ +typedef enum { + NAN_BOOTSTRAPPING_REQUEST_ACCEPT = 0, + NAN_BOOTSTRAPPING_REQUEST_REJECT = 1, + NAN_BOOTSTRAPPING_REQUEST_COMEBACK = 2 +} NanBootstrappingResponseCode; + +/* NAN DP channel config options */ +typedef enum { + NAN_DP_CHANNEL_NOT_REQUESTED = 0, + NAN_DP_REQUEST_CHANNEL_SETUP, + NAN_DP_FORCE_CHANNEL_SETUP +} NanDataPathChannelCfg; + +/* Enable/Disable NAN Ranging Auto response */ +typedef enum { + NAN_RANGING_AUTO_RESPONSE_ENABLE = 1, + NAN_RANGING_AUTO_RESPONSE_DISABLE +} NanRangingAutoResponse; + +/* Enable/Disable NAN service range report */ +typedef enum { + NAN_DISABLE_RANGE_REPORT = 1, + NAN_ENABLE_RANGE_REPORT +} NanRangeReport; + +/* NAN Range Response */ +typedef enum { + NAN_RANGE_REQUEST_ACCEPT = 1, + NAN_RANGE_REQUEST_REJECT, + NAN_RANGE_REQUEST_CANCEL +} NanRangeResponse; + +/* NAN Security Key Input Type*/ +typedef enum { + NAN_SECURITY_KEY_INPUT_PMK = 1, + NAN_SECURITY_KEY_INPUT_PASSPHRASE +} NanSecurityKeyInputType; + +typedef struct { + /* pmk length */ + u32 pmk_len; + /* + PMK: Info is optional in Discovery phase. + PMK info can be passed during + the NDP session. + */ + u8 pmk[NAN_PMK_INFO_LEN]; +} NanSecurityPmk; + +typedef struct { + /* passphrase length */ + u32 passphrase_len; + /* + passphrase info is optional in Discovery phase. + passphrase info can be passed during + the NDP session. + */ + u8 passphrase[NAN_SECURITY_MAX_PASSPHRASE_LEN]; +} NanSecurityPassPhrase; + +typedef struct { + NanSecurityKeyInputType key_type; + union { + NanSecurityPmk pmk_info; + NanSecurityPassPhrase passphrase_info; + } body; +} NanSecurityKeyInfo; + +/* NAN Security Cipher Suites Mask */ +#define NAN_CIPHER_SUITE_SHARED_KEY_NONE 0x00 +#define NAN_CIPHER_SUITE_SHARED_KEY_128_MASK 0x01 +#define NAN_CIPHER_SUITE_SHARED_KEY_256_MASK 0x02 +#define NAN_CIPHER_SUITE_PUBLIC_KEY_2WDH_128_MASK 0x04 +#define NAN_CIPHER_SUITE_PUBLIC_KEY_2WDH_256_MASK 0x08 +#define NAN_CIPHER_SUITE_PUBLIC_KEY_PASN_128_MASK 0x40 +#define NAN_CIPHER_SUITE_PUBLIC_KEY_PASN_256_MASK 0x80 + +/* NAN ranging indication condition MASKS */ +#define NAN_RANGING_INDICATE_CONTINUOUS_MASK 0x01 +#define NAN_RANGING_INDICATE_INGRESS_MET_MASK 0x02 +#define NAN_RANGING_INDICATE_EGRESS_MET_MASK 0x04 + +/* NAN schedule update reason MASKS */ +#define NAN_SCHEDULE_UPDATE_NSS_MASK 0x01 +#define NAN_SCHEDULE_UPDATE_CHANNEL_MASK 0x02 + +/* NAN pairing bootstrapping method */ +#define NAN_PAIRING_BOOTSTRAPPING_OPPORTUNISTIC_MASK 0x01 +#define NAN_PAIRING_BOOTSTRAPPING_PIN_CODE_DISPLAY_MASK 0x02 +#define NAN_PAIRING_BOOTSTRAPPING_PASSPHRASE_DISPLAY_MASK 0x04 +#define NAN_PAIRING_BOOTSTRAPPING_QR_DISPLAY_MASK 0x08 +#define NAN_PAIRING_BOOTSTRAPPING_NFC_TAG_MASK 0x10 +#define NAN_PAIRING_BOOTSTRAPPING_PIN_CODE_KEYPAD_MASK 0x20 +#define NAN_PAIRING_BOOTSTRAPPING_PASSPHRASE_KEYPAD_MASK 0x40 +#define NAN_PAIRING_BOOTSTRAPPING_QR_SCAN_MASK 0x80 +#define NAN_PAIRING_BOOTSTRAPPING_NFC_READER_MASK 0x100 +#define NAN_PAIRING_BOOTSTRAPPING_SERVICE_MANAGED_MASK 0x4000 +#define NAN_PAIRING_BOOTSTRAPPING_HANDSHAKE_SHIP_MASK 0x8000 + +/* + Structure to set the Service Descriptor Extension + Attribute (SDEA) passed as part of NanPublishRequest/ + NanSubscribeRequest/NanMatchInd. +*/ +typedef struct { + /* + Optional configuration of Data Path Enable request. + configure flag determines whether configuration needs + to be passed or not. + */ + u8 config_nan_data_path; + NdpType ndp_type; + /* + NAN secuirty required flag to indicate + if the security is enabled or disabled + */ + NanDataPathSecurityCfgStatus security_cfg; + /* + NAN ranging required flag to indicate + if ranging is enabled on disabled + */ + NanRangingState ranging_state; + /* + Enable/Disable Ranging report, + when configured NanRangeReportInd received + */ + NanRangeReport range_report; + /* + NAN QOS required flag to indicate + if QOS is required or not. + */ + NanQosCfgStatus qos_cfg; + /* + Config to set FSD with Gas bit + in the SDEA Control Field. + */ + u8 config_fsd_gas; + u8 enable_fsd_gas; + + /* + Config to set FSD Required bit + in the SDEA Control Field. + */ + u8 config_fsd_req; + u8 enable_fsd_req; + + /* + Config to set gtk protection bit + in the SDEA Control Field. + */ + u8 gtk_protection; +} NanSdeaCtrlParams; + +/* + Nan Ranging Peer Info in MatchInd +*/ +typedef struct { + /* + Distance to the NAN device with the MAC address indicated + with ranged mac address. + */ + u32 range_measurement_mm; + /* Ranging event matching the configuration of continuous/ingress/egress. */ + u32 ranging_event_type; +} NanRangeInfo; + +/* Nan/NDP Capabilites info */ +typedef struct { + u32 max_concurrent_nan_clusters; + u32 max_publishes; + u32 max_subscribes; + u32 max_service_name_len; + u32 max_match_filter_len; + u32 max_total_match_filter_len; + u32 max_service_specific_info_len; + u32 max_vsa_data_len; + u32 max_mesh_data_len; + u32 max_ndi_interfaces; + u32 max_ndp_sessions; + u32 max_app_info_len; + u32 max_queued_transmit_followup_msgs; + u32 ndp_supported_bands; + u32 cipher_suites_supported; + u32 max_scid_len; + bool is_ndp_security_supported; + u32 max_sdea_service_specific_info_len; + u32 max_subscribe_address; + u32 ndpe_attr_supported; + bool is_instant_mode_supported; + bool is_6g_supported; + bool is_he_supported; + bool is_pairing_supported; + bool is_set_cluster_id_supported; + bool is_suspension_supported; +} NanCapabilities; + +/* + Nan accept policy: Per service basis policy + Based on this policy(ALL/NONE), responder side + will send ACCEPT/REJECT +*/ +typedef enum { + NAN_SERVICE_ACCEPT_POLICY_NONE = 0, + /* Default value */ + NAN_SERVICE_ACCEPT_POLICY_ALL +} NanServiceAcceptPolicy; + +/* + Host can send Vendor specific attributes which the Discovery Engine can + enclose in Beacons and/or Service Discovery frames transmitted. + Below structure is used to populate that. +*/ +typedef struct { + /* + 0 = transmit only in the next discovery window + 1 = transmit in next 16 discovery window + */ + u8 payload_transmit_flag; + /* + Below flags will determine in which all frames + the vendor specific attributes should be included + */ + u8 tx_in_discovery_beacon; + u8 tx_in_sync_beacon; + u8 tx_in_service_discovery; + /* Organizationally Unique Identifier */ + u32 vendor_oui; + /* + vendor specific attribute to be transmitted + vsa_len : Length of the vsa data. + */ + u32 vsa_len; + u8 vsa[NAN_MAX_VSA_DATA_LEN]; +} NanTransmitVendorSpecificAttribute; + + +/* + Discovery Engine will forward any Vendor Specific Attributes + which it received as part of this structure. +*/ +/* Mask to determine on which frames attribute was received */ +#define RX_DISCOVERY_BEACON_MASK 0x01 +#define RX_SYNC_BEACON_MASK 0x02 +#define RX_SERVICE_DISCOVERY_MASK 0x04 +typedef struct { + /* + Frames on which this vendor specific attribute + was received. Mask defined above + */ + u8 vsa_received_on; + /* Organizationally Unique Identifier */ + u32 vendor_oui; + /* vendor specific attribute */ + u32 attr_len; + u8 vsa[NAN_MAX_VSA_DATA_LEN]; +} NanReceiveVendorSpecificAttribute; + +/* + NAN Beacon SDF Payload Received structure + Discovery engine sends the details of received Beacon or + Service Discovery Frames as part of this structure. +*/ +typedef struct { + /* Frame data */ + u32 frame_len; + u8 frame_data[NAN_MAX_FRAME_DATA_LEN]; +} NanBeaconSdfPayloadReceive; + +/* + Host can set the Periodic scan parameters for each of the + 3(6, 44, 149) Social channels. Only these channels are allowed + any other channels are rejected +*/ +typedef enum { + NAN_CHANNEL_24G_BAND = 0, + NAN_CHANNEL_5G_BAND_LOW, + NAN_CHANNEL_5G_BAND_HIGH +} NanChannelIndex; + +/* + Structure to set the Social Channel Scan parameters + passed as part of NanEnableRequest/NanConfigRequest +*/ +typedef struct { + /* + Dwell time of each social channel in milliseconds + NanChannelIndex corresponds to the respective channel + If time set to 0 then the FW default time will be used. + */ + u8 dwell_time[NAN_MAX_SOCIAL_CHANNELS]; // default value 200 msec + + /* + Scan period of each social channel in seconds + NanChannelIndex corresponds to the respective channel + If time set to 0 then the FW default time will be used. + */ + u16 scan_period[NAN_MAX_SOCIAL_CHANNELS]; // default value 20 sec +} NanSocialChannelScanParams; + +/* + Host can send Post Connectivity Capability attributes + to be included in Service Discovery frames transmitted + as part of this structure. +*/ +typedef struct { + /* + 0 = transmit only in the next discovery window + 1 = transmit in next 16 discovery window + */ + u8 payload_transmit_flag; + /* 1 - Wifi Direct supported 0 - Not supported */ + u8 is_wfd_supported; + /* 1 - Wifi Direct Services supported 0 - Not supported */ + u8 is_wfds_supported; + /* 1 - TDLS supported 0 - Not supported */ + u8 is_tdls_supported; + /* 1 - IBSS supported 0 - Not supported */ + u8 is_ibss_supported; + /* 1 - Mesh supported 0 - Not supported */ + u8 is_mesh_supported; + /* + 1 - NAN Device currently connect to WLAN Infra AP + 0 - otherwise + */ + u8 wlan_infra_field; +} NanTransmitPostConnectivityCapability; + +/* + Discovery engine providing the post connectivity capability + received. +*/ +typedef struct { + /* 1 - Wifi Direct supported 0 - Not supported */ + u8 is_wfd_supported; + /* 1 - Wifi Direct Services supported 0 - Not supported */ + u8 is_wfds_supported; + /* 1 - TDLS supported 0 - Not supported */ + u8 is_tdls_supported; + /* 1 - IBSS supported 0 - Not supported */ + u8 is_ibss_supported; + /* 1 - Mesh supported 0 - Not supported */ + u8 is_mesh_supported; + /* + 1 - NAN Device currently connect to WLAN Infra AP + 0 - otherwise + */ + u8 wlan_infra_field; +} NanReceivePostConnectivityCapability; + +/* + Indicates the availability interval duration associated with the + Availability Intervals Bitmap field +*/ +typedef enum { + NAN_DURATION_16MS = 0, + NAN_DURATION_32MS = 1, + NAN_DURATION_64MS = 2 +} NanAvailDuration; + +/* Further availability per channel information */ +typedef struct { + /* Defined above */ + NanAvailDuration entry_control; + /* + 1 byte field indicating the frequency band the NAN Device + will be available as defined in IEEE Std. 802.11-2012 + Annex E Table E-4 Global Operating Classes + */ + u8 class_val; + /* + 1 byte field indicating the channel the NAN Device + will be available. + */ + u8 channel; + /* + Map Id - 4 bit field which identifies the Further + availability map attribute. + */ + u8 mapid; + /* + divides the time between the beginnings of consecutive Discovery + Windows of a given NAN cluster into consecutive time intervals + of equal durations. The time interval duration is specified by + the Availability Interval Duration subfield of the Entry Control + field. + + A Nan device that sets the i-th bit of the Availability + Intervals Bitmap to 1 shall be present during the corresponding + i-th time interval in the operation channel indicated by the + Operating Class and Channel Number fields in the same Availability Entry. + + A Nan device that sets the i-th bit of the Availability Intervals Bitmap to + 0 may be present during the corresponding i-th time interval in the operation + channel indicated by the Operating Class and Channel Number fields in the same + Availability Entry. + + The size of the Bitmap is dependent upon the Availability Interval Duration + chosen in the Entry Control Field. The size can be either 1, 2 or 4 bytes long + + - Duration field is equal to 0, only AIB[0] is valid + - Duration field is equal to 1, only AIB [0] and AIB [1] is valid + - Duration field is equal to 2, AIB [0], AIB [1], AIB [2] and AIB [3] are valid + */ + u32 avail_interval_bitmap; +} NanFurtherAvailabilityChannel; + +/* + Further availability map which can be sent and received from + Discovery engine +*/ +typedef struct { + /* + Number of channels indicates the number of channel + entries which is part of fam + */ + u8 numchans; + NanFurtherAvailabilityChannel famchan[NAN_MAX_FAM_CHANNELS]; +} NanFurtherAvailabilityMap; + +/* + Host can send Post-Nan Discovery attributes which the Discovery Engine can + enclose in Service Discovery frames +*/ +/* Possible connection types in Post NAN Discovery attributes */ +typedef enum { + NAN_CONN_WLAN_INFRA = 0, + NAN_CONN_P2P_OPER = 1, + NAN_CONN_WLAN_IBSS = 2, + NAN_CONN_WLAN_MESH = 3, + NAN_CONN_FURTHER_SERVICE_AVAILABILITY = 4, + NAN_CONN_WLAN_RANGING = 5 +} NanConnectionType; + +/* Possible device roles in Post NAN Discovery attributes */ +typedef enum { + NAN_WLAN_INFRA_AP = 0, + NAN_WLAN_INFRA_STA = 1, + NAN_P2P_OPER_GO = 2, + NAN_P2P_OPER_DEV = 3, + NAN_P2P_OPER_CLI = 4 +} NanDeviceRole; + +/* Configuration params of NAN Ranging */ +typedef struct { + /* + Interval in milli sec between two ranging measurements. + If the Awake DW intervals in NanEnable/Config are larger + than the ranging intervals priority is given to Awake DW + Intervals. Only on a match the ranging is initiated for the + peer + */ + u32 ranging_interval_msec; + /* + Flags indicating the type of ranging event to be notified + NAN_RANGING_INDICATE_ MASKS are used to set these. + BIT0 - Continuous Ranging event notification. + BIT1 - Ingress distance is <=. + BIT2 - Egress distance is >=. + */ + u32 config_ranging_indications; + /* Ingress distance in millimeters (optional) */ + u32 distance_ingress_mm; + /* Egress distance in millmilliimeters (optional) */ + u32 distance_egress_mm; +} NanRangingCfg; + +/* NAN Ranging request's response */ +typedef struct { + /* Publish Id of an earlier Publisher */ + u16 publish_id; + /* + A 32 bit Requestor instance Id which is sent to the Application. + This Id will be used in subsequent RangeResponse on Subscribe side. + */ + u32 requestor_instance_id; + /* Peer MAC addr of Range Requestor */ + u8 peer_addr[NAN_MAC_ADDR_LEN]; + /* Response indicating ACCEPT/REJECT/CANCEL of Range Request */ + NanRangeResponse ranging_response; +} NanRangeResponseCfg; + +/* Structure of Post NAN Discovery attribute */ +typedef struct { + /* Connection type of the host */ + NanConnectionType type; + /* + Device role of the host based on + the connection type + */ + NanDeviceRole role; + /* + Flag to send the information as a single shot or repeated + for next 16 discovery windows + 0 - Single_shot + 1 - next 16 discovery windows + */ + u8 transmit_freq; + /* Duration of the availability bitmask */ + NanAvailDuration duration; + /* Availability interval bitmap based on duration */ + u32 avail_interval_bitmap; + /* + Mac address depending on the conn type and device role + -------------------------------------------------- + | Conn Type | Device Role | Mac address Usage | + -------------------------------------------------- + | WLAN_INFRA | AP/STA | BSSID of the AP | + -------------------------------------------------- + | P2P_OPER | GO | GO's address | + -------------------------------------------------- + | P2P_OPER | P2P_DEVICE | Address of who | + | | | would become GO | + -------------------------------------------------- + | WLAN_IBSS | NA | BSSID | + -------------------------------------------------- + | WLAN_MESH | NA | BSSID | + -------------------------------------------------- + */ + u8 addr[NAN_MAC_ADDR_LEN]; + /* + Mandatory mesh id value if connection type is WLAN_MESH + Mesh id contains 0-32 octet identifier and should be + as per IEEE Std.802.11-2012 spec. + */ + u16 mesh_id_len; + u8 mesh_id[NAN_MAX_MESH_DATA_LEN]; + /* + Optional infrastructure SSID if conn_type is set to + NAN_CONN_WLAN_INFRA + */ + u16 infrastructure_ssid_len; + u8 infrastructure_ssid_val[NAN_MAX_INFRA_DATA_LEN]; +} NanTransmitPostDiscovery; + +/* + Discovery engine providing the structure of Post NAN + Discovery +*/ +typedef struct { + /* Connection type of the host */ + NanConnectionType type; + /* + Device role of the host based on + the connection type + */ + NanDeviceRole role; + /* Duration of the availability bitmask */ + NanAvailDuration duration; + /* Availability interval bitmap based on duration */ + u32 avail_interval_bitmap; + /* + Map Id - 4 bit field which identifies the Further + availability map attribute. + */ + u8 mapid; + /* + Mac address depending on the conn type and device role + -------------------------------------------------- + | Conn Type | Device Role | Mac address Usage | + -------------------------------------------------- + | WLAN_INFRA | AP/STA | BSSID of the AP | + -------------------------------------------------- + | P2P_OPER | GO | GO's address | + -------------------------------------------------- + | P2P_OPER | P2P_DEVICE | Address of who | + | | | would become GO | + -------------------------------------------------- + | WLAN_IBSS | NA | BSSID | + -------------------------------------------------- + | WLAN_MESH | NA | BSSID | + -------------------------------------------------- + */ + u8 addr[NAN_MAC_ADDR_LEN]; + /* + Mandatory mesh id value if connection type is WLAN_MESH + Mesh id contains 0-32 octet identifier and should be + as per IEEE Std.802.11-2012 spec. + */ + u16 mesh_id_len; + u8 mesh_id[NAN_MAX_MESH_DATA_LEN]; + /* + Optional infrastructure SSID if conn_type is set to + NAN_CONN_WLAN_INFRA + */ + u16 infrastructure_ssid_len; + u8 infrastructure_ssid_val[NAN_MAX_INFRA_DATA_LEN]; +} NanReceivePostDiscovery; + +/* + NAN device level configuration of SDF and Sync beacons in both + 2.4/5GHz bands +*/ +typedef struct { + /* Configure 2.4GHz DW Band */ + u8 config_2dot4g_dw_band; + /* + Indicates the interval for Sync beacons and SDF's in 2.4GHz band. + Valid values of DW Interval are: 1, 2, 3, 4 and 5, 0 is reserved. + The SDF includes in OTA when enabled. The publish/subscribe period + values don't override the device level configurations. + */ + u32 dw_2dot4g_interval_val; // default value 1 + /* Configure 5GHz DW Band */ + u8 config_5g_dw_band; + /* + Indicates the interval for Sync beacons and SDF's in 5GHz band + Valid values of DW Interval are: 1, 2, 3, 4 and 5, 0 no wake up for + any interval. The SDF includes in OTA when enabled. The publish/subscribe + period values don't override the device level configurations. + */ + u32 dw_5g_interval_val; // default value 1 when 5G is enabled +} NanConfigDW; + +/* + Enable Request Message Structure + The NanEnableReq message instructs the Discovery Engine to enter an operational state +*/ +typedef struct { + /* Mandatory parameters below */ + u8 master_pref; // default value 0x02 + /* + A cluster_low value matching cluster_high indicates a request to join + a cluster with that value. If the requested cluster is not found the + device will start its own cluster. + */ + u16 cluster_low; // default value 0 + u16 cluster_high; // default value 0xFFFF + + /* + Optional configuration of Enable request. + Each of the optional parameters have configure flag which + determine whether configuration is to be passed or not. + */ + u8 config_support_5g; + u8 support_5g_val; // default value 0; turned off by default + /* + BIT 0 is used to specify to include Service IDs in Sync/Discovery beacons + 0 - Do not include SIDs in any beacons + 1 - Include SIDs in all beacons. + Rest 7 bits are count field which allows control over the number of SIDs + included in the Beacon. 0 means to include as many SIDs that fit into + the maximum allow Beacon frame size + */ + u8 config_sid_beacon; + u8 sid_beacon_val; // default value 0x01 + /* + The rssi values below should be specified without sign. + For eg: -70dBm should be specified as 70. + */ + u8 config_2dot4g_rssi_close; + u8 rssi_close_2dot4g_val; // default value -60 dBm + + u8 config_2dot4g_rssi_middle; + u8 rssi_middle_2dot4g_val; // default value -70 dBm + + u8 config_2dot4g_rssi_proximity; + u8 rssi_proximity_2dot4g_val;// default value -60dBm + + u8 config_hop_count_limit; + u8 hop_count_limit_val; // default value 0x02 + + /* + Defines 2.4G channel access support + 0 - No Support + 1 - Supported + */ + u8 config_2dot4g_support; + u8 support_2dot4g_val; // default value 0x01 + /* + Defines 2.4G channels will be used for sync/discovery beacons + 0 - 2.4G channels not used for beacons + 1 - 2.4G channels used for beacons + */ + u8 config_2dot4g_beacons; + u8 beacon_2dot4g_val; // default value 1 + /* + Defines 2.4G channels will be used for Service Discovery frames + 0 - 2.4G channels not used for Service Discovery frames + 1 - 2.4G channels used for Service Discovery frames + */ + u8 config_2dot4g_sdf; + u8 sdf_2dot4g_val; // default value 1 + /* + Defines 5G channels will be used for sync/discovery beacons + 0 - 5G channels not used for beacons + 1 - 5G channels used for beacons + */ + u8 config_5g_beacons; + u8 beacon_5g_val; // default value 1 when 5G is enabled + /* + Defines 5G channels will be used for Service Discovery frames + 0 - 5G channels not used for Service Discovery frames + 1 - 5G channels used for Service Discovery frames + */ + u8 config_5g_sdf; + u8 sdf_5g_val; // default value is 0 when 5G is enabled + /* + 1 byte value which defines the RSSI in + dBm for a close by Peer in 5 Ghz channels. + The rssi values should be specified without sign. + For eg: -70dBm should be specified as 70. + */ + u8 config_5g_rssi_close; + u8 rssi_close_5g_val; // default value -60dBm when 5G is enabled + /* + 1 byte value which defines the RSSI value in + dBm for a close by Peer in 5 Ghz channels. + The rssi values should be specified without sign. + For eg: -70dBm should be specified as 70. + */ + u8 config_5g_rssi_middle; + u8 rssi_middle_5g_val; // default value -75dBm when 5G is enabled + /* + 1 byte value which defines the RSSI filter + threshold. Any Service Descriptors received above this + value that are configured for RSSI filtering will be dropped. + The rssi values should be specified without sign. + For eg: -70dBm should be specified as 70. + */ + u8 config_5g_rssi_close_proximity; + u8 rssi_close_proximity_5g_val; // default value -60dBm when 5G is enabled + /* + 1 byte quantity which defines the window size over + which the “average RSSI” will be calculated over. + */ + u8 config_rssi_window_size; + u8 rssi_window_size_val; // default value 0x08 + /* + The 24 bit Organizationally Unique ID + the 8 bit Network Id. + */ + u8 config_oui; + u32 oui_val; // default value {0x51, 0x6F, 0x9A, 0x01, 0x00, 0x00} + /* + NAN Interface Address, If not configured the Discovery Engine + will generate a 6 byte Random MAC. + */ + u8 config_intf_addr; + u8 intf_addr_val[NAN_MAC_ADDR_LEN]; + /* + If set to 1, the Discovery Engine will enclose the Cluster + Attribute only sent in Beacons in a Vendor Specific Attribute + and transmit in a Service Descriptor Frame. + */ + u8 config_cluster_attribute_val; + /* + The periodicity in seconds between full scan’s to find any new + clusters available in the area. A Full scan should not be done + more than every 10 seconds and should not be done less than every + 30 seconds. + */ + u8 config_scan_params; + NanSocialChannelScanParams scan_params_val; + /* + 1 byte quantity which forces the Random Factor to a particular + value for all transmitted Sync/Discovery beacons + */ + u8 config_random_factor_force; + u8 random_factor_force_val; // default value off and set to 0x00 + /* + 1 byte quantity which forces the HC for all transmitted Sync and + Discovery Beacon NO matter the real HC being received over the + air. + */ + u8 config_hop_count_force; + u8 hop_count_force_val; // default value 0x00 + + /* channel frequency in MHz to enable Nan on */ + u8 config_24g_channel; + wifi_channel channel_24g_val; // default value channel 0x6 + + u8 config_5g_channel; + wifi_channel channel_5g_val; // default value channel 44 or 149 regulatory + // domain + /* Configure 2.4/5GHz DW */ + NanConfigDW config_dw; + + /* + By default discovery MAC address randomization is enabled + and default interval value is 30 minutes i.e. 1800 seconds. + The value 0 is used to disable MAC addr randomization. + */ + u8 config_disc_mac_addr_randomization; + u32 disc_mac_addr_rand_interval_sec; // default value 1800 sec + + /* + Set/Enable corresponding bits to disable Discovery indications: + BIT0 - Disable Discovery MAC Address Event. + BIT1 - Disable Started Cluster Event. + BIT2 - Disable Joined Cluster Event. + */ + u8 discovery_indication_cfg; // default value 0x0 + /* + BIT 0 is used to specify to include Service IDs in Sync/Discovery beacons + 0 - Do not include SIDs in any beacons + 1 - Include SIDs in all beacons. + Rest 7 bits are count field which allows control over the number of SIDs + included in the Beacon. 0 means to include as many SIDs that fit into + the maximum allow Beacon frame size + */ + u8 config_subscribe_sid_beacon; + u32 subscribe_sid_beacon_val; // default value 0x0 + /* + Discovery Beacon Interval config. + Default value is 128 msec in 2G DW and 176 msec in 2G/5G DW. + When 0 value is passed it is reset to default value of 128 or 176 msec. + */ + u8 config_discovery_beacon_int; + u32 discovery_beacon_interval; + /* + Enable Number of Spatial Streams. + This is NAN Power Optimization feature for NAN discovery. + */ + u8 config_nss; + // default value is implementation specific and passing 0 sets it to default + u32 nss; + /* + Enable device level NAN Ranging feature. + 0 - Disable + 1 - Enable + */ + u8 config_enable_ranging; + u32 enable_ranging; + /* + Enable/Disable DW Early termination. + 0 - Disable + 1 - Enable + */ + u8 config_dw_early_termination; + u32 enable_dw_termination; + /* + Indicate whether to use NDPE attribute to bring-up TCP/IP connection. + If config_ndpe_attr is not configured, the default behavior is + not using NDPE attr, and the capability is not advertised. + 0 - Not use + 1 - Use + */ + u8 config_ndpe_attr; + u32 use_ndpe_attr; + /* + Enable NAN v3.1 instant communication mode. + 0 - Disable + 1 - Enable + */ + u8 config_enable_instant_mode; + u32 enable_instant_mode; + /* + Config NAN v3.1 instant communication channel frequency selected over NFC/OOB method. + If dual band is supported default channel is 149 or 44 as per regulatory domain, + else channel 6 (send frequency in MHz). + Sometimes depending on country code retrictions, even 149/44 may be restricted + in those cases instant channel will be operational only in 2.4GHz. + Use wifi_get_usable_channels() API to get supported bands/channels before + Instant mode NFC handshake is triggered + */ + u8 config_instant_mode_channel; + wifi_channel instant_mode_channel; + + /* + Enable/Disable unsync service discovery. + 0 - Disable + 1 - Enable + */ + u8 config_unsync_srvdsc; + u8 enable_unsync_srvdsc; + + /* + Configure regulatory information. + */ + u8 config_reg_info; + u8 reg_info_val; +} NanEnableRequest; + +/* + NAN pairing config. +*/ +typedef struct { + + /* + Enable Nan pairing setup + */ + u32 enable_pairing_setup; + + /* + Enable cache NIK/NPK after Nan pairing setup + */ + u32 enable_pairing_cache; + + /* + Enable Nan pairing verification with cached NIK/NPK + */ + u32 enable_pairing_verification; + + /* + The set of supported bootstrapping methods. + */ + u16 supported_bootstrapping_methods; +} NanPairingConfig; + +/* + Publish Msg Structure + Message is used to request the DE to publish the Service Name + using the parameters passed into the Discovery Window +*/ +typedef struct { + u16 publish_id;/* id 0 means new publish, any other id is existing publish */ + u16 ttl; /* how many seconds to run for. 0 means forever until canceled */ + /* + period: Awake DW Interval for publish(service) + 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, value 0 will + default to 1. + */ + u16 period; + NanPublishType publish_type;/* 0= unsolicited, solicited = 1, 2= both */ + NanTxType tx_type; /* 0 = broadcast, 1= unicast if solicited publish */ + u8 publish_count; /* number of OTA Publish, 0 means forever until canceled */ + u16 service_name_len; /* length of service name */ + u8 service_name[NAN_MAX_SERVICE_NAME_LEN];/* UTF-8 encoded string identifying the service */ + /* + Field which specifies how the matching indication to host is controlled. + 0 - Match and Indicate Once + 1 - Match and Indicate continuous + 2 - Match and Indicate never. This means don't indicate the match to the host. + 3 - Reserved + */ + NanMatchAlg publish_match_indicator; + + /* + Sequence of values + NAN Device that has invoked a Subscribe method corresponding to this Publish method + */ + u16 service_specific_info_len; + u8 service_specific_info[NAN_MAX_SERVICE_SPECIFIC_INFO_LEN]; + + /* + Ordered sequence of pairs which specify further response conditions + beyond the service name used to filter subscribe messages to respond to. + This is only needed when the PT is set to NAN_SOLICITED or NAN_SOLICITED_UNSOLICITED. + */ + u16 rx_match_filter_len; + u8 rx_match_filter[NAN_MAX_MATCH_FILTER_LEN]; + + /* + Ordered sequence of pairs to be included in the Discovery Frame. + If present it is always sent in a Discovery Frame + */ + u16 tx_match_filter_len; + u8 tx_match_filter[NAN_MAX_MATCH_FILTER_LEN]; + + /* + flag which specifies that the Publish should use the configured RSSI + threshold and the received RSSI in order to filter requests + 0 – ignore the configured RSSI threshold when running a Service + Descriptor attribute or Service ID List Attribute through the DE matching logic. + 1 – use the configured RSSI threshold when running a Service + Descriptor attribute or Service ID List Attribute through the DE matching logic. + + */ + u8 rssi_threshold_flag; + + /* + 8-bit bitmap which allows the Host to associate this publish + with a particular Post-NAN Connectivity attribute + which has been sent down in a NanConfigureRequest/NanEnableRequest + message. If the DE fails to find a configured Post-NAN + connectivity attributes referenced by the bitmap, + the DE will return an error code to the Host. + If the Publish is configured to use a Post-NAN Connectivity + attribute and the Host does not refresh the Post-NAN Connectivity + attribute the Publish will be canceled and the Host will be sent + a PublishTerminatedIndication message. + */ + u8 connmap; + /* + Set/Enable corresponding bits to disable any indications that follow a publish. + BIT0 - Disable publish termination indication. + BIT1 - Disable match expired indication. + BIT2 - Disable followUp indication received (OTA). + BIT3 - Disable publishReplied indication. + */ + u8 recv_indication_cfg; + /* + Nan accept policy for the specific service(publish) + */ + NanServiceAcceptPolicy service_responder_policy; + /* NAN Cipher Suite Type */ + u32 cipher_type; + /* + Nan Security Key Info is optional in Discovery phase. + PMK or passphrase info can be passed during + the NDP session. + */ + NanSecurityKeyInfo key_info; + + /* Security Context Identifiers length */ + u32 scid_len; + /* + Security Context Identifier attribute contains PMKID + shall be included in NDP setup and response messages. + Security Context Identifier, Identifies the Security + Context. For NAN Shared Key Cipher Suite, this field + contains the 16 octet PMKID identifying the PMK used + for setting up the Secure Data Path. + */ + u8 scid[NAN_MAX_SCID_BUF_LEN]; + + /* NAN configure service discovery extended attributes */ + NanSdeaCtrlParams sdea_params; + + /* NAN Ranging configuration */ + NanRangingCfg ranging_cfg; + + /* Enable/disable NAN serivce Ranging auto response mode */ + NanRangingAutoResponse ranging_auto_response; + + /* + When the ranging_auto_response_cfg is not set, NanRangeRequestInd is + received. Nan Range Response to Peer MAC Addr is notified to indicate + ACCEPT/REJECT/CANCEL to the requestor. + */ + NanRangeResponseCfg range_response_cfg; + + /* + Sequence of values indicating the service specific info in SDEA + */ + u16 sdea_service_specific_info_len; + u8 sdea_service_specific_info[NAN_MAX_SDEA_SERVICE_SPECIFIC_INFO_LEN]; + + /* + The Identity key for pairing, used to generate NIRA + */ + u8 nan_identity_key[NAN_IDENTITY_KEY_LEN]; + + /* + The config for Nan pairing + */ + NanPairingConfig nan_pairing_config; + + /* + Specifies whether suspension can be possible in this publish session. + The request would fail if enable_suspendability is true but + is_suspension_supported is false in NanCapabilities. + */ + bool enable_suspendability; + + /* s3 capabilities */ + u16 s3_capabilities; + + /* cipher capabilities */ + u8 cipher_capabilities; +} NanPublishRequest; + +/* + Publish Cancel Msg Structure + The PublishServiceCancelReq Message is used to request the DE to stop publishing + the Service Name identified by the Publish Id in the message. +*/ +typedef struct { + u16 publish_id; +} NanPublishCancelRequest; + +/* + NAN Subscribe Structure + The SubscribeServiceReq message is sent to the Discovery Engine + whenever the Upper layers would like to listen for a Service Name +*/ +typedef struct { + u16 subscribe_id; /* id 0 means new subscribe, non zero is existing subscribe */ + u16 ttl; /* how many seconds to run for. 0 means forever until canceled */ + /* + period: Awake DW Interval for subscribe(service) + 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, value 0 will + default to 1. + */ + u16 period; + + /* Flag which specifies how the Subscribe request shall be processed. */ + NanSubscribeType subscribe_type; /* 0 - PASSIVE , 1- ACTIVE */ + + /* Flag which specifies on Active Subscribes how the Service Response Filter attribute is populated.*/ + NanSRFType serviceResponseFilter; /* 0 - Bloom Filter, 1 - MAC Addr */ + + /* Flag which specifies how the Service Response Filter Include bit is populated.*/ + NanSRFIncludeType serviceResponseInclude; /* 0=Do not respond if in the Address Set, 1= Respond */ + + /* Flag which specifies if the Service Response Filter should be used when creating Subscribes.*/ + NanSRFState useServiceResponseFilter; /* 0=Do not send the Service Response Filter,1= send */ + + /* + Flag which specifies if the Service Specific Info is needed in + the Publish message before creating the MatchIndication + */ + NanSsiInMatchInd ssiRequiredForMatchIndication; /* 0=Not needed, 1= Required */ + + /* + Field which specifies how the matching indication to host is controlled. + 0 - Match and Indicate Once + 1 - Match and Indicate continuous + 2 - Match and Indicate never. This means don't indicate the match to the host. + 3 - Reserved + */ + NanMatchAlg subscribe_match_indicator; + + /* + The number of Subscribe Matches which should occur + before the Subscribe request is automatically terminated. + */ + u8 subscribe_count; /* If this value is 0 this field is not used by the DE.*/ + + u16 service_name_len;/* length of service name */ + u8 service_name[NAN_MAX_SERVICE_NAME_LEN]; /* UTF-8 encoded string identifying the service */ + + /* Sequence of values which further specify the published service beyond the service name*/ + u16 service_specific_info_len; + u8 service_specific_info[NAN_MAX_SERVICE_SPECIFIC_INFO_LEN]; + + /* + Ordered sequence of pairs used to filter out received publish discovery messages. + This can be sent both for a Passive or an Active Subscribe + */ + u16 rx_match_filter_len; + u8 rx_match_filter[NAN_MAX_MATCH_FILTER_LEN]; + + /* + Ordered sequence of pairs included in the + Discovery Frame when an Active Subscribe is used. + */ + u16 tx_match_filter_len; + u8 tx_match_filter[NAN_MAX_MATCH_FILTER_LEN]; + + /* + Flag which specifies that the Subscribe should use the configured RSSI + threshold and the received RSSI in order to filter requests + 0 – ignore the configured RSSI threshold when running a Service + Descriptor attribute or Service ID List Attribute through the DE matching logic. + 1 – use the configured RSSI threshold when running a Service + Descriptor attribute or Service ID List Attribute through the DE matching logic. + + */ + u8 rssi_threshold_flag; + + /* + 8-bit bitmap which allows the Host to associate this Active + Subscribe with a particular Post-NAN Connectivity attribute + which has been sent down in a NanConfigureRequest/NanEnableRequest + message. If the DE fails to find a configured Post-NAN + connectivity attributes referenced by the bitmap, + the DE will return an error code to the Host. + If the Subscribe is configured to use a Post-NAN Connectivity + attribute and the Host does not refresh the Post-NAN Connectivity + attribute the Subscribe will be canceled and the Host will be sent + a SubscribeTerminatedIndication message. + */ + u8 connmap; + /* + NAN Interface Address, conforming to the format as described in + 8.2.4.3.2 of IEEE Std. 802.11-2012. + */ + u8 num_intf_addr_present; + u8 intf_addr[NAN_MAX_SUBSCRIBE_MAX_ADDRESS][NAN_MAC_ADDR_LEN]; + /* + Set/Enable corresponding bits to disable indications that follow a subscribe. + BIT0 - Disable subscribe termination indication. + BIT1 - Disable match expired indication. + BIT2 - Disable followUp indication received (OTA). + */ + u8 recv_indication_cfg; + + /* NAN Cipher Suite Type */ + u32 cipher_type; + /* + Nan Security Key Info is optional in Discovery phase. + PMK or passphrase info can be passed during + the NDP session. + */ + NanSecurityKeyInfo key_info; + + /* Security Context Identifiers length */ + u32 scid_len; + /* + Security Context Identifier attribute contains PMKID + shall be included in NDP setup and response messages. + Security Context Identifier, Identifies the Security + Context. For NAN Shared Key Cipher Suite, this field + contains the 16 octet PMKID identifying the PMK used + for setting up the Secure Data Path. + */ + u8 scid[NAN_MAX_SCID_BUF_LEN]; + + /* NAN configure service discovery extended attributes */ + NanSdeaCtrlParams sdea_params; + + /* NAN Ranging configuration */ + NanRangingCfg ranging_cfg; + + /* Enable/disable NAN serivce Ranging auto response mode */ + NanRangingAutoResponse ranging_auto_response; + + /* + When the ranging_auto_response_cfg is not set, NanRangeRequestInd is + received. Nan Range Response to Peer MAC Addr is notified to indicate + ACCEPT/REJECT/CANCEL to the requestor. + */ + NanRangeResponseCfg range_response_cfg; + + /* + Sequence of values indicating the service specific info in SDEA + */ + u16 sdea_service_specific_info_len; + u8 sdea_service_specific_info[NAN_MAX_SDEA_SERVICE_SPECIFIC_INFO_LEN]; + /* + The Identity key for pairing, used to generate NIRA + */ + u8 nan_identity_key[NAN_IDENTITY_KEY_LEN]; + + /* + The config for Nan pairing + */ + NanPairingConfig nan_pairing_config; + + /* + Specifies whether suspension can be possible in this subscribe session. + The request would fail if enable_suspendability is true but + is_suspension_supported is false in NanCapabilities. + */ + bool enable_suspendability; + + /* cipher capabilities */ + u8 cipher_capabilities; +} NanSubscribeRequest; + +/* + NAN Subscribe Cancel Structure + The SubscribeCancelReq Message is used to request the DE to stop looking for the Service Name. +*/ +typedef struct { + u16 subscribe_id; +} NanSubscribeCancelRequest; + +/* + Transmit follow up Structure + The TransmitFollowupReq message is sent to the DE to allow the sending of the Service_Specific_Info + to a particular MAC address. +*/ +typedef struct { + /* Publish or Subscribe Id of an earlier Publish/Subscribe */ + u16 publish_subscribe_id; + + /* + This Id is the Requestor Instance that is passed as + part of earlier MatchInd/FollowupInd message. + */ + u32 requestor_instance_id; + u8 addr[NAN_MAC_ADDR_LEN]; /* Unicast address */ + NanTxPriority priority; /* priority of the request 2=high */ + NanTransmitWindowType dw_or_faw; /* 0= send in a DW, 1=send in FAW */ + + /* + Sequence of values which further specify the published service beyond + the service name. + */ + u16 service_specific_info_len; + u8 service_specific_info[NAN_MAX_SERVICE_SPECIFIC_INFO_LEN]; + /* + Set/Enable corresponding bits to disable responses after followUp. + BIT0 - Disable followUp response from FW. + */ + u8 recv_indication_cfg; + + /* + Sequence of values indicating the service specific info in SDEA + */ + u16 sdea_service_specific_info_len; + u8 sdea_service_specific_info[NAN_MAX_SDEA_SERVICE_SPECIFIC_INFO_LEN]; + + /* + Add shared key descriptor attribute to the Followup request when the + flag is set + */ + u8 shared_key_desc_flag; +} NanTransmitFollowupRequest; + +/* + Stats Request structure + The Discovery Engine can be queried at runtime by the Host processor for statistics + concerning various parts of the Discovery Engine. +*/ +typedef struct { + NanStatsType stats_type; /* NAN Statistics Request Type */ + u8 clear; /* 0= Do not clear the stats and return the current contents , 1= Clear the associated stats */ +} NanStatsRequest; + +/* + Suspend Request Structure + The SuspendRequest message is used to request that the specified session is suspended. + The session can be resumed using the NanResumeRequest message. +*/ +typedef struct { + u16 publish_subscribe_id; +} NanSuspendRequest; + +/* + Resume Request Structure + The ResumeRequest message is used to request that the specified session is resumed. +*/ +typedef struct { + u16 publish_subscribe_id; +} NanResumeRequest; + +/* + Config Structure + The NanConfigurationReq message is sent by the Host to the + Discovery Engine in order to configure the Discovery Engine during runtime. +*/ +typedef struct { + u8 config_sid_beacon; + u8 sid_beacon; + u8 config_rssi_proximity; + u8 rssi_proximity; // default value -60dBm + u8 config_master_pref; + u8 master_pref; // default value 0x02 + /* + 1 byte value which defines the RSSI filter threshold. + Any Service Descriptors received above this value + that are configured for RSSI filtering will be dropped. + The rssi values should be specified without sign. + For eg: -70dBm should be specified as 70. + */ + u8 config_5g_rssi_close_proximity; + u8 rssi_close_proximity_5g_val; // default value -60dBm + /* + Optional configuration of Configure request. + Each of the optional parameters have configure flag which + determine whether configuration is to be passed or not. + */ + /* + 1 byte quantity which defines the window size over + which the “average RSSI” will be calculated over. + */ + u8 config_rssi_window_size; + u8 rssi_window_size_val; // default value 0x08 + /* + If set to 1, the Discovery Engine will enclose the Cluster + Attribute only sent in Beacons in a Vendor Specific Attribute + and transmit in a Service Descriptor Frame. + */ + u8 config_cluster_attribute_val; + /* + The periodicity in seconds between full scan’s to find any new + clusters available in the area. A Full scan should not be done + more than every 10 seconds and should not be done less than every + 30 seconds. + */ + u8 config_scan_params; + NanSocialChannelScanParams scan_params_val; + /* + 1 byte quantity which forces the Random Factor to a particular + value for all transmitted Sync/Discovery beacons + */ + u8 config_random_factor_force; + u8 random_factor_force_val; // default value 0x00 + /* + 1 byte quantity which forces the HC for all transmitted Sync and + Discovery Beacon NO matter the real HC being received over the + air. + */ + u8 config_hop_count_force; + u8 hop_count_force_val; // default value of 0 + /* NAN Post Connectivity Capability */ + u8 config_conn_capability; + NanTransmitPostConnectivityCapability conn_capability_val; + /* NAN Post Discover Capability */ + u8 num_config_discovery_attr; + NanTransmitPostDiscovery discovery_attr_val[NAN_MAX_POSTDISCOVERY_LEN]; + /* NAN Further availability Map */ + u8 config_fam; + NanFurtherAvailabilityMap fam_val; + /* Configure 2.4/5GHz DW */ + NanConfigDW config_dw; + /* + By default discovery MAC address randomization is enabled + and default interval value is 30 minutes i.e. 1800 seconds. + The value 0 is used to disable MAC addr randomization. + */ + u8 config_disc_mac_addr_randomization; + u32 disc_mac_addr_rand_interval_sec; // default value of 30 minutes + + /* + Set/Enable corresponding bits to disable Discovery indications: + BIT0 - Disable Discovery MAC Address Event. + BIT1 - Disable Started Cluster Event. + BIT2 - Disable Joined Cluster Event. + */ + u8 discovery_indication_cfg; // default value of 0 + /* + BIT 0 is used to specify to include Service IDs in Sync/Discovery beacons + 0 - Do not include SIDs in any beacons + 1 - Include SIDs in all beacons. + Rest 7 bits are count field which allows control over the number of SIDs + included in the Beacon. 0 means to include as many SIDs that fit into + the maximum allow Beacon frame size + */ + u8 config_subscribe_sid_beacon; + u32 subscribe_sid_beacon_val; // default value 0x0 + /* + Discovery Beacon Interval config. + Default value is 128 msec in 2G DW and 176 msec in 2G/5G DW. + When 0 value is passed it is reset to default value of 128 or 176 msec. + */ + u8 config_discovery_beacon_int; + u32 discovery_beacon_interval; + /* + Enable Number of Spatial Streams. + This is NAN Power Optimization feature for NAN discovery. + */ + u8 config_nss; + // default value is implementation specific and passing 0 sets it to default + u32 nss; + /* + Enable device level NAN Ranging feature. + 0 - Disable + 1 - Enable + */ + u8 config_enable_ranging; + u32 enable_ranging; + /* + Enable/Disable DW Early termination. + 0 - Disable + 1 - Enable + */ + u8 config_dw_early_termination; + u32 enable_dw_termination; + /* + Indicate whether to use NDPE attribute to bring-up TCP/IP connection + If config_ndpe_attr is not configured, the default behavior is + not using NDPE attr, and the capability is not advertised. + 0 - Not use + 1 - Use + */ + u8 config_ndpe_attr; + u32 use_ndpe_attr; + /* + Enable NAN v3.1 instant communication mode. + 0 - Disable + 1 - Enable + */ + u8 config_enable_instant_mode; + u32 enable_instant_mode; + /* + Config NAN v3.1 instant communication channel selected over NFC/OOB method. + If dual band is supported default channel is 149 or 44 as per regulatory domain, + else channel 6 (send frequency in MHz). + Sometimes depending on country code retrictions, even 149/44 may be restricted + in those cases instant channel will be operational only in 2.4GHz. + Use wifi_get_usable_channels() API to get supported bands/channels before + Instant mode NFC handshake is triggered + */ + u8 config_instant_mode_channel; + wifi_channel instant_mode_channel; + /* + Config cluster ID with the cluster ID selected over NFC/OOB method. + */ + u8 config_cluster_id; + u16 cluster_id_val; // default value 0x0 +} NanConfigRequest; + +/* + TCA Structure + The Discovery Engine can be configured to send up Events whenever a configured + Threshold Crossing Alert (TCA) Type crosses an integral threshold in a particular direction. +*/ +typedef struct { + NanTcaType tca_type; /* Nan Protocol Threshold Crossing Alert (TCA) Codes */ + + /* flag which control whether or not an event is generated for the Rising direction */ + u8 rising_direction_evt_flag; /* 0 - no event, 1 - event */ + + /* flag which control whether or not an event is generated for the Falling direction */ + u8 falling_direction_evt_flag;/* 0 - no event, 1 - event */ + + /* flag which requests a previous TCA request to be cleared from the DE */ + u8 clear;/*0= Do not clear the TCA, 1=Clear the TCA */ + + /* 32 bit value which represents the threshold to be used.*/ + u32 threshold; +} NanTCARequest; + +/* + Beacon Sdf Payload Structure + The Discovery Engine can be configured to publish vendor specific attributes as part of + beacon or service discovery frame transmitted as part of this request.. +*/ +typedef struct { + /* + NanVendorAttribute will have the Vendor Specific Attribute which the + vendor wants to publish as part of Discovery or Sync or Service discovery frame + */ + NanTransmitVendorSpecificAttribute vsa; +} NanBeaconSdfPayloadRequest; + +/* Publish statistics. */ +typedef struct +{ + u32 validPublishServiceReqMsgs; + u32 validPublishServiceRspMsgs; + u32 validPublishServiceCancelReqMsgs; + u32 validPublishServiceCancelRspMsgs; + u32 validPublishRepliedIndMsgs; + u32 validPublishTerminatedIndMsgs; + u32 validActiveSubscribes; + u32 validMatches; + u32 validFollowups; + u32 invalidPublishServiceReqMsgs; + u32 invalidPublishServiceCancelReqMsgs; + u32 invalidActiveSubscribes; + u32 invalidMatches; + u32 invalidFollowups; + u32 publishCount; + u32 publishNewMatchCount; + u32 pubsubGlobalNewMatchCount; +} NanPublishStats; + +/* Subscribe statistics. */ +typedef struct +{ + u32 validSubscribeServiceReqMsgs; + u32 validSubscribeServiceRspMsgs; + u32 validSubscribeServiceCancelReqMsgs; + u32 validSubscribeServiceCancelRspMsgs; + u32 validSubscribeTerminatedIndMsgs; + u32 validSubscribeMatchIndMsgs; + u32 validSubscribeUnmatchIndMsgs; + u32 validSolicitedPublishes; + u32 validMatches; + u32 validFollowups; + u32 invalidSubscribeServiceReqMsgs; + u32 invalidSubscribeServiceCancelReqMsgs; + u32 invalidSubscribeFollowupReqMsgs; + u32 invalidSolicitedPublishes; + u32 invalidMatches; + u32 invalidFollowups; + u32 subscribeCount; + u32 bloomFilterIndex; + u32 subscribeNewMatchCount; + u32 pubsubGlobalNewMatchCount; +} NanSubscribeStats; + +/* NAN DW Statistics*/ +typedef struct +{ + /* RX stats */ + u32 validFrames; + u32 validActionFrames; + u32 validBeaconFrames; + u32 ignoredActionFrames; + u32 ignoredBeaconFrames; + u32 invalidFrames; + u32 invalidActionFrames; + u32 invalidBeaconFrames; + u32 invalidMacHeaders; + u32 invalidPafHeaders; + u32 nonNanBeaconFrames; + + u32 earlyActionFrames; + u32 inDwActionFrames; + u32 lateActionFrames; + + /* TX stats */ + u32 framesQueued; + u32 totalTRSpUpdates; + u32 completeByTRSp; + u32 completeByTp75DW; + u32 completeByTendDW; + u32 lateActionFramesTx; +} NanDWStats; + +/* NAN MAC Statistics. */ +typedef struct +{ + /* RX stats */ + u32 validFrames; + u32 validActionFrames; + u32 validBeaconFrames; + u32 ignoredActionFrames; + u32 ignoredBeaconFrames; + u32 invalidFrames; + u32 invalidActionFrames; + u32 invalidBeaconFrames; + u32 invalidMacHeaders; + u32 invalidPafHeaders; + u32 nonNanBeaconFrames; + + u32 earlyActionFrames; + u32 inDwActionFrames; + u32 lateActionFrames; + + /* TX stats */ + u32 framesQueued; + u32 totalTRSpUpdates; + u32 completeByTRSp; + u32 completeByTp75DW; + u32 completeByTendDW; + u32 lateActionFramesTx; + + u32 twIncreases; + u32 twDecreases; + u32 twChanges; + u32 twHighwater; + u32 bloomFilterIndex; +} NanMacStats; + +/* NAN Sync Statistics*/ +typedef struct +{ + u64 currTsf; + u64 myRank; + u64 currAmRank; + u64 lastAmRank; + u32 currAmBTT; + u32 lastAmBTT; + u8 currAmHopCount; + u8 currRole; + u16 currClusterId; + + u64 timeSpentInCurrRole; + u64 totalTimeSpentAsMaster; + u64 totalTimeSpentAsNonMasterSync; + u64 totalTimeSpentAsNonMasterNonSync; + u32 transitionsToAnchorMaster; + u32 transitionsToMaster; + u32 transitionsToNonMasterSync; + u32 transitionsToNonMasterNonSync; + u32 amrUpdateCount; + u32 amrUpdateRankChangedCount; + u32 amrUpdateBTTChangedCount; + u32 amrUpdateHcChangedCount; + u32 amrUpdateNewDeviceCount; + u32 amrExpireCount; + u32 mergeCount; + u32 beaconsAboveHcLimit; + u32 beaconsBelowRssiThresh; + u32 beaconsIgnoredNoSpace; + u32 beaconsForOurCluster; + u32 beaconsForOtherCluster; + u32 beaconCancelRequests; + u32 beaconCancelFailures; + u32 beaconUpdateRequests; + u32 beaconUpdateFailures; + u32 syncBeaconTxAttempts; + u32 syncBeaconTxFailures; + u32 discBeaconTxAttempts; + u32 discBeaconTxFailures; + u32 amHopCountExpireCount; + u32 ndpChannelFreq; + u32 ndpChannelFreq2; + u32 schedUpdateChannelFreq; +} NanSyncStats; + +/* NAN Misc DE Statistics */ +typedef struct +{ + u32 validErrorRspMsgs; + u32 validTransmitFollowupReqMsgs; + u32 validTransmitFollowupRspMsgs; + u32 validFollowupIndMsgs; + u32 validConfigurationReqMsgs; + u32 validConfigurationRspMsgs; + u32 validStatsReqMsgs; + u32 validStatsRspMsgs; + u32 validEnableReqMsgs; + u32 validEnableRspMsgs; + u32 validDisableReqMsgs; + u32 validDisableRspMsgs; + u32 validDisableIndMsgs; + u32 validEventIndMsgs; + u32 validTcaReqMsgs; + u32 validTcaRspMsgs; + u32 validTcaIndMsgs; + u32 invalidTransmitFollowupReqMsgs; + u32 invalidConfigurationReqMsgs; + u32 invalidStatsReqMsgs; + u32 invalidEnableReqMsgs; + u32 invalidDisableReqMsgs; + u32 invalidTcaReqMsgs; +} NanDeStats; + +/* Publish Response Message structure */ +typedef struct { + u16 publish_id; +} NanPublishResponse; + +/* Subscribe Response Message structure */ +typedef struct { + u16 subscribe_id; +} NanSubscribeResponse; + +/* + Stats Response Message structure + The Discovery Engine response to a request by the Host for statistics. +*/ +typedef struct { + NanStatsType stats_type; + union { + NanPublishStats publish_stats; + NanSubscribeStats subscribe_stats; + NanMacStats mac_stats; + NanSyncStats sync_stats; + NanDeStats de_stats; + NanDWStats dw_stats; + } data; +} NanStatsResponse; + +/* Response returned for Initiators Data request */ +typedef struct { + /* + Unique token Id generated on the initiator + side used for a NDP session between two NAN devices + */ + NanDataPathId ndp_instance_id; +} NanDataPathRequestResponse; + +/* Response returned for Initiators pairing request */ +typedef struct { + /* + Unique token Id generated on the initiator + side used for a pairing session between two NAN devices + */ + u32 paring_instance_id; +} NanPairingRequestResponse; + +/* Response returned for Initiators bootstrapping request */ +typedef struct { + /* + Unique token Id generated on the initiator + side used for a bootstrapping session between two NAN devices + */ + u32 bootstrapping_instance_id; +} NanBootstrappingRequestResponse; + +/* + NAN Response messages +*/ +typedef struct { + NanStatusType status; /* contains the result code */ + char nan_error[NAN_ERROR_STR_LEN]; /* Describe the NAN error type */ + NanResponseType response_type; /* NanResponseType Definitions */ + union { + NanPublishResponse publish_response; + NanSubscribeResponse subscribe_response; + NanStatsResponse stats_response; + NanDataPathRequestResponse data_request_response; + NanCapabilities nan_capabilities; + NanPairingRequestResponse pairing_request_response; + NanBootstrappingRequestResponse bootstrapping_request_response; + } body; +} NanResponseMsg; + +/* + Publish Replied Indication + The PublishRepliedInd Message is sent by the DE when an Active Subscribe is + received over the air and it matches a Solicited PublishServiceReq which had + been created with the replied_event_flag set. +*/ +typedef struct { + /* + A 32 bit Requestor Instance Id which is sent to the Application. + This Id will be sent in any subsequent UnmatchInd/FollowupInd + messages + */ + u32 requestor_instance_id; + u8 addr[NAN_MAC_ADDR_LEN]; + /* + If RSSI filtering was configured in NanPublishRequest then this + field will contain the received RSSI value. 0 if not + */ + u8 rssi_value; +} NanPublishRepliedInd; + +/* + Publish Terminated + The PublishTerminatedInd message is sent by the DE whenever a Publish + terminates from a user-specified timeout or a unrecoverable error in the DE. +*/ +typedef struct { + /* Id returned during the initial Publish */ + u16 publish_id; + /* + For all user configured termination NAN_STATUS_SUCCESS + and no other reasons expected from firmware. + */ + NanStatusType reason; + char nan_reason[NAN_ERROR_STR_LEN]; /* Describe the NAN reason type */ +} NanPublishTerminatedInd; + +/* The NIRA used to identify the pairing devices*/ +typedef struct { + u8 nonce[NAN_IDENTITY_NONCE_LEN]; + u8 tag[NAN_IDENTITY_TAG_LEN]; +} NanIdentityResolutionAttribute; + +/* + Match Indication + The MatchInd message is sent once per responding MAC address whenever + the Discovery Engine detects a match for a previous SubscribeServiceReq + or PublishServiceReq. +*/ +typedef struct { + /* Publish or Subscribe Id of an earlier Publish/Subscribe */ + u16 publish_subscribe_id; + /* + A 32 bit Requestor Instance Id which is sent to the Application. + This Id will be sent in any subsequent UnmatchInd/FollowupInd + messages + */ + u32 requestor_instance_id; + u8 addr[NAN_MAC_ADDR_LEN]; + + /* + Sequence of octets which were received in a Discovery Frame matching the + Subscribe Request. + */ + u16 service_specific_info_len; + u8 service_specific_info[NAN_MAX_SERVICE_SPECIFIC_INFO_LEN]; + + /* + Ordered sequence of pairs received in the Discovery Frame + matching the Subscribe Request. + */ + u16 sdf_match_filter_len; + u8 sdf_match_filter[NAN_MAX_MATCH_FILTER_LEN]; + + /* + flag to indicate if the Match occurred in a Beacon Frame or in a + Service Discovery Frame. + 0 - Match occured in a Service Discovery Frame + 1 - Match occured in a Beacon Frame + */ + u8 match_occured_flag; + + /* + flag to indicate FW is out of resource and that it can no longer + track this Service Name. The Host still need to send the received + Match_Handle but duplicate MatchInd messages may be received on + this Handle until the resource frees up. + 0 - FW is caching this match + 1 - FW is unable to cache this match + */ + u8 out_of_resource_flag; + + /* + If RSSI filtering was configured in NanSubscribeRequest then this + field will contain the received RSSI value. 0 if not. + All rssi values should be specified without sign. + For eg: -70dBm should be specified as 70. + */ + u8 rssi_value; + + /* + optional attributes. Each optional attribute is associated with a flag + which specifies whether the attribute is valid or not + */ + /* NAN Post Connectivity Capability received */ + u8 is_conn_capability_valid; + NanReceivePostConnectivityCapability conn_capability; + + /* NAN Post Discover Capability */ + u8 num_rx_discovery_attr; + NanReceivePostDiscovery discovery_attr[NAN_MAX_POSTDISCOVERY_LEN]; + + /* NAN Further availability Map */ + u8 num_chans; + NanFurtherAvailabilityChannel famchan[NAN_MAX_FAM_CHANNELS]; + + /* NAN Cluster Attribute */ + u8 cluster_attribute_len; + u8 cluster_attribute[NAN_MAX_CLUSTER_ATTRIBUTE_LEN]; + + /* NAN Cipher Suite */ + u32 peer_cipher_type; + + /* Security Context Identifiers length */ + u32 scid_len; + /* + Security Context Identifier attribute contains PMKID + shall be included in NDP setup and response messages. + Security Context Identifier, Identifies the Security + Context. For NAN Shared Key Cipher Suite, this field + contains the 16 octet PMKID identifying the PMK used + for setting up the Secure Data Path. + */ + u8 scid[NAN_MAX_SCID_BUF_LEN]; + + /* Peer service discovery extended attributes */ + NanSdeaCtrlParams peer_sdea_params; + + /* + Ranging indication and NanMatchAlg are not tied. + Ex: NanMatchAlg can indicate Match_ONCE, but ranging + indications can be continuous. All ranging indications + depend on SDEA control parameters of ranging required for + continuous, and ingress/egress values in the ranging config. + Ranging indication data is notified if: + 1) Ranging required is enabled in SDEA. + range info notified continuous. + 2) if range_limit ingress/egress MASKS are enabled + notify once for ingress >= ingress_distance + and egress <= egress_distance, same for ingress_egress_both + 3) if the Awake DW intervals are higher than the ranging intervals, + priority is given to the device DW intervalsi. + */ + /* + Range Info includes: + 1) distance to the NAN device with the MAC address indicated + with ranged mac address. + 2) Ranging event matching the configuration of continuous/ingress/egress. + */ + NanRangeInfo range_info; + + /* + Sequence of values indicating the service specific info in SDEA + */ + u16 sdea_service_specific_info_len; + u8 sdea_service_specific_info[NAN_MAX_SDEA_SERVICE_SPECIFIC_INFO_LEN]; + + /* + The config for Nan pairing set by the peer + */ + NanPairingConfig peer_pairing_config; + + /* + The NIRA from peer for Nan pairing verification + */ + NanIdentityResolutionAttribute nira; +} NanMatchInd; + +/* + MatchExpired Indication + The MatchExpiredInd message is sent whenever the Discovery Engine detects that + a previously Matched Service has been gone for too long. If the previous + MatchInd message for this Publish/Subscribe Id had the out_of_resource_flag + set then this message will not be received +*/ +typedef struct { + /* Publish or Subscribe Id of an earlier Publish/Subscribe */ + u16 publish_subscribe_id; + /* + 32 bit value sent by the DE in a previous + MatchInd/FollowupInd to the application. + */ + u32 requestor_instance_id; +} NanMatchExpiredInd; + +/* + Subscribe Terminated + The SubscribeTerminatedInd message is sent by the DE whenever a + Subscribe terminates from a user-specified timeout or a unrecoverable error in the DE. +*/ +typedef struct { + /* Id returned during initial Subscribe */ + u16 subscribe_id; + /* + For all user configured termination NAN_STATUS_SUCCESS + and no other reasons expected from firmware. + */ + NanStatusType reason; + char nan_reason[NAN_ERROR_STR_LEN]; /* Describe the NAN reason type */ +} NanSubscribeTerminatedInd; + +/* + Followup Indication Message + The FollowupInd message is sent by the DE to the Host whenever it receives a + Followup message from another peer. +*/ +typedef struct { + /* Publish or Subscribe Id of an earlier Publish/Subscribe */ + u16 publish_subscribe_id; + /* + A 32 bit Requestor instance Id which is sent to the Application. + This Id will be used in subsequent UnmatchInd/FollowupInd messages. + */ + u32 requestor_instance_id; + u8 addr[NAN_MAC_ADDR_LEN]; + + /* Flag which the DE uses to decide if received in a DW or a FAW*/ + u8 dw_or_faw; /* 0=Received in a DW, 1 = Received in a FAW*/ + + /* + Sequence of values which further specify the published service beyond + the service name + */ + u16 service_specific_info_len; + u8 service_specific_info[NAN_MAX_SERVICE_SPECIFIC_INFO_LEN]; + + /* + Sequence of values indicating the service specific info in SDEA + */ + u16 sdea_service_specific_info_len; + u8 sdea_service_specific_info[NAN_MAX_SDEA_SERVICE_SPECIFIC_INFO_LEN]; +} NanFollowupInd; + +/* + Event data notifying the Mac address of the Discovery engine. + which is reported as one of the Discovery engine event +*/ +typedef struct { + u8 addr[NAN_MAC_ADDR_LEN]; +} NanMacAddressEvent; + +/* + Event data notifying the Cluster address of the cluster + which is reported as one of the Discovery engine event +*/ +typedef struct { + u8 addr[NAN_MAC_ADDR_LEN]; +} NanClusterEvent; + +/* + Discovery Engine Event Indication + The Discovery Engine can inform the Host when significant events occur + The data following the EventId is dependent upon the EventId type. + In other words, each new event defined will carry a different + structure of information back to the host. +*/ +typedef struct { + NanDiscEngEventType event_type; /* NAN Protocol Event Codes */ + union { + /* + MacAddressEvent which will have 6 byte mac address + of the Discovery engine. + */ + NanMacAddressEvent mac_addr; + /* + Cluster Event Data which will be obtained when the + device starts a new cluster or joins a cluster. + The event data will have 6 byte octet string of the + cluster started or joined. + */ + NanClusterEvent cluster; + } data; +} NanDiscEngEventInd; + +/* Cluster size TCA event*/ +typedef struct { + /* size of the cluster*/ + u32 cluster_size; +} NanTcaClusterEvent; + +/* + NAN TCA Indication + The Discovery Engine can inform the Host when significant events occur. + The data following the TcaId is dependent upon the TcaId type. + In other words, each new event defined will carry a different structure + of information back to the host. +*/ +typedef struct { + NanTcaType tca_type; + /* flag which defines if the configured Threshold has risen above the threshold */ + u8 rising_direction_evt_flag; /* 0 - no event, 1 - event */ + + /* flag which defines if the configured Threshold has fallen below the threshold */ + u8 falling_direction_evt_flag;/* 0 - no event, 1 - event */ + union { + /* + This event in obtained when the cluser size threshold + is crossed. Event will have the cluster size + */ + NanTcaClusterEvent cluster; + } data; +} NanTCAInd; + +/* + NAN Disabled Indication + The NanDisableInd message indicates to the upper layers that the Discovery + Engine has flushed all state and has been shutdown. When this message is received + the DE is guaranteed to have left the NAN cluster it was part of and will have terminated + any in progress Publishes or Subscribes. +*/ +typedef struct { + /* + Following reasons expected: + NAN_STATUS_SUCCESS + NAN_STATUS_UNSUPPORTED_CONCURRENCY_NAN_DISABLED + */ + NanStatusType reason; + char nan_reason[NAN_ERROR_STR_LEN]; /* Describe the NAN reason type */ +} NanDisabledInd; + +/* + NAN Beacon or SDF Payload Indication + The NanBeaconSdfPayloadInd message indicates to the upper layers that information + elements were received either in a Beacon or SDF which needs to be delivered + outside of a Publish/Subscribe Handle. +*/ +typedef struct { + /* The MAC address of the peer which sent the attributes.*/ + u8 addr[NAN_MAC_ADDR_LEN]; + /* + Optional attributes. Each optional attribute is associated with a flag + which specifies whether the attribute is valid or not + */ + /* NAN Receive Vendor Specific Attribute*/ + u8 is_vsa_received; + NanReceiveVendorSpecificAttribute vsa; + + /* NAN Beacon or SDF Payload Received*/ + u8 is_beacon_sdf_payload_received; + NanBeaconSdfPayloadReceive data; +} NanBeaconSdfPayloadInd; + +/* + Event Indication notifying the + transmit followup in progress +*/ +typedef struct { + transaction_id id; + /* + Following reason codes returned: + NAN_STATUS_SUCCESS + NAN_STATUS_NO_OTA_ACK + NAN_STATUS_PROTOCOL_FAILURE + */ + NanStatusType reason; + char nan_reason[NAN_ERROR_STR_LEN]; /* Describe the NAN reason type */ +} NanTransmitFollowupInd; + +/* + Data request Initiator/Responder + app/service related info +*/ +typedef struct { + u16 ndp_app_info_len; + u8 ndp_app_info[NAN_DP_MAX_APP_INFO_LEN]; +} NanDataPathAppInfo; + +/* QoS configuration */ +typedef enum { + NAN_DP_CONFIG_NO_QOS = 0, + NAN_DP_CONFIG_QOS +} NanDataPathQosCfg; + +/* Configuration params of Data request Initiator/Responder */ +typedef struct { + /* Status Indicating Security/No Security */ + NanDataPathSecurityCfgStatus security_cfg; + NanDataPathQosCfg qos_cfg; +} NanDataPathCfg; + +/* Nan Data Path Initiator requesting a data session */ +typedef struct { + /* + Unique Instance Id identifying the Responder's service. + This is same as publish_id notified on the subscribe side + in a publish/subscribe scenario + */ + u32 requestor_instance_id; /* Value 0 for no publish/subscribe */ + + /* Config flag for channel request */ + NanDataPathChannelCfg channel_request_type; + /* Channel frequency in MHz to start data-path */ + wifi_channel channel; + /* + Discovery MAC addr of the publisher/peer + */ + u8 peer_disc_mac_addr[NAN_MAC_ADDR_LEN]; + /* + Interface name on which this NDP session is to be started. + This will be the same interface name provided during interface + create. + */ + char ndp_iface[IFNAMSIZ+1]; + /* Initiator/Responder Security/QoS configuration */ + NanDataPathCfg ndp_cfg; + /* App/Service information of the Initiator */ + NanDataPathAppInfo app_info; + /* NAN Cipher Suite Type */ + u32 cipher_type; + /* + Nan Security Key Info is optional in Discovery phase. + PMK or passphrase info can be passed during + the NDP session. + */ + NanSecurityKeyInfo key_info; + /* length of service name */ + u32 service_name_len; + /* + UTF-8 encoded string identifying the service name. + The service name field is only used if a Nan discovery + is not associated with the NDP (out-of-band discovery). + */ + u8 service_name[NAN_MAX_SERVICE_NAME_LEN]; + + /* Security Context Identifiers length */ + u32 scid_len; + /* + Security Context Identifier attribute contains PMKID + shall be included in NDP setup and response messages. + Security Context Identifier, Identifies the Security + Context. For NAN Shared Key Cipher Suite, this field + contains the 16 octet PMKID identifying the PMK used + for setting up the Secure Data Path. + */ + u8 scid[NAN_MAX_SCID_BUF_LEN]; + + /* Publish or Subscribe Id of an earlier Publish/Subscribe */ + u16 publish_subscribe_id; + + /* configure CSIA (Cipher Suite Information attribute) capability to specify GTK, IGTK, BIGTK + are supported or not + */ + u8 csia_capabilities; + + /* configure GTK(Group Transient Key) protection required or not */ + u8 gtk_protection; + +} NanDataPathInitiatorRequest; + +/* + Data struct to initiate a data response on the responder side + for an indication received with a data request +*/ +typedef struct { + /* + Unique token Id generated on the initiator/responder + side used for a NDP session between two NAN devices + */ + NanDataPathId ndp_instance_id; + /* + Interface name on which this NDP session is to be started. + This will be the same interface name provided during interface + create. + */ + char ndp_iface[IFNAMSIZ+1]; + /* Initiator/Responder Security/QoS configuration */ + NanDataPathCfg ndp_cfg; + /* App/Service information of the responder */ + NanDataPathAppInfo app_info; + /* Response Code indicating ACCEPT/REJECT/DEFER */ + NanDataPathResponseCode rsp_code; + /* NAN Cipher Suite Type */ + u32 cipher_type; + /* + Nan Security Key Info is optional in Discovery phase. + PMK or passphrase info can be passed during + the NDP session. + */ + NanSecurityKeyInfo key_info; + /* length of service name */ + u32 service_name_len; + /* + UTF-8 encoded string identifying the service name. + The service name field is only used if a Nan discovery + is not associated with the NDP (out-of-band discovery). + */ + u8 service_name[NAN_MAX_SERVICE_NAME_LEN]; + + /* Security Context Identifiers length */ + u32 scid_len; + /* + Security Context Identifier attribute contains PMKID + shall be included in NDP setup and response messages. + Security Context Identifier, Identifies the Security + Context. For NAN Shared Key Cipher Suite, this field + contains the 16 octet PMKID identifying the PMK used + for setting up the Secure Data Path. + */ + u8 scid[NAN_MAX_SCID_BUF_LEN]; + + /* Publish or Subscribe Id of an earlier Publish/Subscribe */ + u16 publish_subscribe_id; + + /* + Discovery MAC addr of the publisher/peer + */ + u8 peer_disc_mac_addr[NAN_MAC_ADDR_LEN]; + + /* configure CSIA (Cipher Suite Information attribute) capability to specify GTK, IGTK, BIGTK + are supported or not + */ + u8 csia_capabilities; + + /* configure GTK(Group Transient Key) protection required or not */ + u8 gtk_protection; +} NanDataPathIndicationResponse; + +/* Sub slot parameters */ +typedef struct { + u8 entry_control; + u16 time_bitmap_control; + u32 time_bitmap; +} NanS3Params; + +/* NDP termination info */ +typedef struct { + u8 num_ndp_instances; + /* + Unique token Id generated on the initiator/responder side + used for a NDP session between two NAN devices + */ + NanDataPathId ndp_instance_id[]; +} NanDataPathEndRequest; + +/* + Event indication received on the + responder side when a Nan Data request or + NDP session is initiated on the Initiator side +*/ +typedef struct { + /* + Unique Instance Id corresponding to a service/session. + This is similar to the publish_id generated on the + publisher side + */ + u16 service_instance_id; + /* Discovery MAC addr of the peer/initiator */ + u8 peer_disc_mac_addr[NAN_MAC_ADDR_LEN]; + /* + Unique token Id generated on the initiator/responder side + used for a NDP session between two NAN devices + */ + NanDataPathId ndp_instance_id; + /* Initiator/Responder Security/QoS configuration */ + NanDataPathCfg ndp_cfg; + /* App/Service information of the initiator */ + NanDataPathAppInfo app_info; + + /* Security Context Identifiers length */ + u32 scid_len; + /* + Security Context Identifier attribute contains PMKID + shall be included in NDP setup and response messages. + Security Context Identifier, Identifies the Security + Context. For NAN Shared Key Cipher Suite, this field + contains the 16 octet PMKID identifying the PMK used + for setting up the Secure Data Path. + */ + u8 scid[NAN_MAX_SCID_BUF_LEN]; + + /* configure CSIA (Cipher Suite Information attribute) capability to specify GTK, IGTK, BIGTK + are supported or not + */ + u8 csia_capabilities; + + /* configure GTK(Group Transient Key) protection required or not */ + u8 gtk_protection; +} NanDataPathRequestInd; + +/* + Event indication of data confirm is received on both + initiator and responder side confirming a NDP session +*/ +typedef struct { + /* + Unique token Id generated on the initiator/responder side + used for a NDP session between two NAN devices + */ + NanDataPathId ndp_instance_id; + /* + NDI mac address of the peer + (required to derive target ipv6 address) + */ + u8 peer_ndi_mac_addr[NAN_MAC_ADDR_LEN]; + /* App/Service information of Initiator/Responder */ + NanDataPathAppInfo app_info; + /* Response code indicating ACCEPT/REJECT/DEFER */ + NanDataPathResponseCode rsp_code; + /* + Reason code indicating the cause for REJECT. + NAN_STATUS_SUCCESS and NAN_STATUS_PROTOCOL_FAILURE are + expected reason codes. + */ + NanStatusType reason_code; + /* Number of channels for which info is indicated */ + u32 num_channels; + /* + Data indicating the Channel list and BW of the channel. + */ + NanChannelInfo channel_info[NAN_MAX_CHANNEL_INFO_SUPPORTED]; +} NanDataPathConfirmInd; + +/* + Event indication of schedule update is received on both + initiator and responder when a schedule change occurs +*/ +typedef struct { + /* + NMI mac address + */ + u8 peer_mac_addr[NAN_MAC_ADDR_LEN]; + /* + Reason code indicating the cause of schedule update. + BIT_0 NSS Update + BIT_1 Channel list update + */ + u32 schedule_update_reason_code; + /* Number of channels for which info is indicated */ + u32 num_channels; + /* + Data indicating the Channel list and BW of the channel. + */ + NanChannelInfo channel_info[NAN_MAX_CHANNEL_INFO_SUPPORTED]; + /* Number of NDP instance Ids */ + u8 num_ndp_instances; + /* + Unique token Id generated on the initiator/responder side + used for a NDP session between two NAN devices + */ + NanDataPathId ndp_instance_id[]; +} NanDataPathScheduleUpdateInd; + +/* + Event indication received on the + initiator/responder side terminating + a NDP session +*/ +typedef struct { + u8 num_ndp_instances; + /* + Unique token Id generated on the initiator/responder side + used for a NDP session between two NAN devices + */ + NanDataPathId ndp_instance_id[]; +} NanDataPathEndInd; + +/* + Event indicating Range Request received on the + Published side. +*/ +typedef struct { + u16 publish_id;/* id is existing publish */ + /* Range Requestor's MAC address */ + u8 range_req_intf_addr[NAN_MAC_ADDR_LEN]; +} NanRangeRequestInd; + +/* + Event indicating Range report on the + Published side. +*/ +typedef struct { + u16 publish_id;/* id is existing publish */ + /* Range Requestor's MAC address */ + u8 range_req_intf_addr[NAN_MAC_ADDR_LEN]; + /* + Distance to the NAN device with the MAC address indicated + with ranged mac address. + */ + u32 range_measurement_mm; +} NanRangeReportInd; + +/* + NAN pairing initator request +*/ +typedef struct { + /* + This Id is the Requestor Instance that is passed as + part of earlier MatchInd/FollowupInd message. + */ + u32 requestor_instance_id; + + /* + Discovery MAC addr of the publisher/peer + */ + u8 peer_disc_mac_addr[NAN_MAC_ADDR_LEN]; + + /* + Indicate the pairing session is of setup or verification + */ + NanPairingRequestType nan_pairing_request_type; + + /* + whether the pairing is opportunistic or password + */ + u8 is_opportunistic; + + /* + Security key info used for the pairing setup or verification + */ + NanSecurityKeyInfo key_info; + /* + AKM used for the pairing verification + */ + NanAkm akm; + + /* + Whether should cache the negotiated NIK/NPK for future verification + */ + u8 enable_pairing_cache; + + /* + The Identity key for pairing, can be used for pairing verification + */ + u8 nan_identity_key[NAN_IDENTITY_KEY_LEN]; + + /* + NAN Cipher Suite Type + */ + u32 cipher_type; + +} NanPairingRequest; + +/* + Data struct to initiate a pairing response on the responder side for an indication received with a + pairing request +*/ +typedef struct { + + /* + Unique token Id generated on the initiator/responder side + used for a pairing session between two NAN devices + */ + u32 pairing_instance_id; + + /* + Indicate the pairing session is setup or verification + */ + NanPairingRequestType nan_pairing_request_type; + + /* Response Code indicating ACCEPT/REJECT */ + NanPairingResponseCode rsp_code; + + /* + whether the pairing is opportunistic or password + */ + u8 is_opportunistic; + + /* + Security key info used for the pairing setup or verification + */ + NanSecurityKeyInfo key_info; + + /* + AKM used for the pairing verification + */ + NanAkm akm; + + /* + Whether should cache the negotiated NIK/NPK for future verification + */ + u8 enable_pairing_cache; + + /* + The Identity key for pairing, can be used for pairing verification + */ + u8 nan_identity_key[NAN_IDENTITY_KEY_LEN]; + + /* + NAN Cipher Suite Type + */ + u32 cipher_type; +} NanPairingIndicationResponse; + +typedef struct { + /* + Unique token Id generated on the initiator/responder side + used for a pairing session between two NAN devices + */ + u32 pairing_instance_id; +} NanPairingEndRequest; + +/* + Event indication received on the responder side when a Nan pairing session is initiated on the + Initiator side +*/ +typedef struct { + /* Publish instance id generated on Publisher side corresponding to a session */ + u16 publish_subscribe_id; + /* + This Id is the Requestor Instance that is passed as + part of earlier MatchInd/FollowupInd message. + */ + u32 requestor_instance_id; + /* + Unique Instance Id corresponding to a service/session. + This is similar to the publish_id generated on the + publisher side + */ + u32 pairing_instance_id; + /* Discovery MAC addr of the peer/initiator */ + u8 peer_disc_mac_addr[NAN_MAC_ADDR_LEN]; + /* Indicate the pairing session is setup or verification */ + NanPairingRequestType nan_pairing_request_type; + /* Whether should cache the negotiated NIK/NPK for future verification */ + u8 enable_pairing_cache; + /* The NIRA from peer for Nan pairing verification */ + NanIdentityResolutionAttribute nira; +} NanPairingRequestInd; + +/* + The security info negotiate after the pairing setup for caching +*/ +typedef struct { + /* The inentity key of peer device*/ + u8 peer_nan_identity_key[NAN_IDENTITY_KEY_LEN]; + /* The inentity key of local device*/ + u8 local_nan_identity_key[NAN_IDENTITY_KEY_LEN]; + /* The PMK excahnge between two devices*/ + NanSecurityPmk npk; + /* The AKM used during the key exchange*/ + NanAkm akm; + /* NAN Cipher Suite Type */ + u32 cipher_type; +} NpkSecurityAssociation; + +/* + Event indication of pairing confirm is received on both + initiator and responder side confirming a pairing session +*/ +typedef struct { + /* + Unique token Id generated on the initiator/responder side + used for a pairing session between two NAN devices + */ + u32 pairing_instance_id; + /* Response code indicating ACCEPT/REJECT */ + NanPairingResponseCode rsp_code; + /* + Reason code indicating the cause for REJECT. + NAN_STATUS_SUCCESS and NAN_STATUS_PROTOCOL_FAILURE are + expected reason codes. + */ + NanStatusType reason_code; + /* + Indicate the pairing session is setup or verification + */ + NanPairingRequestType nan_pairing_request_type; + /* Whether should cache the negotiated NIK/NPK for future verification */ + u8 enable_pairing_cache; + /* + The security association info negotiated in the pairing setup, used for future verification + */ + NpkSecurityAssociation npk_security_association; +} NanPairingConfirmInd; + +/* + NAN pairing bootstrapping initiator request +*/ +typedef struct { + /* Publish or Subscribe Id of local Publish/Subscribe */ + u16 publish_subscribe_id; + + /* + This Id is the Requestor Instance that is passed as + part of earlier MatchInd/FollowupInd message. + */ + u32 requestor_instance_id; + + /* + Discovery MAC addr of the publisher/peer + */ + u8 peer_disc_mac_addr[NAN_MAC_ADDR_LEN]; + + /* Proposed bootstrapping method */ + u16 request_bootstrapping_method; + + /* + Sequence of values which further specify the published service beyond + the service name. + */ + u16 service_specific_info_len; + u8 service_specific_info[NAN_MAX_SERVICE_SPECIFIC_INFO_LEN]; + + /* + Sequence of values indicating the service specific info in SDEA + Used for service managed bootstrapping method + */ + u16 sdea_service_specific_info_len; + u8 sdea_service_specific_info[NAN_MAX_SDEA_SERVICE_SPECIFIC_INFO_LEN]; + + /* Indicates that this is comeback Bootstrapping request */ + u8 comeback; + + /* The length of cookie. */ + u32 cookie_length; + + /* Cookie for the follow up request */ + u8 cookie[]; + +} NanBootstrappingRequest; +/* + NAN pairing bootstrapping response from responder to a initate request +*/ +typedef struct { + /* Publish or Subscribe Id of local Publish/Subscribe */ + u16 publish_subscribe_id; + + /* + This Id is the Peer Instance that is passed as + part of earlier MatchInd/FollowupInd message. + */ + u32 service_instance_id; + + /* Discovery MAC addr of the peer/initiator */ + u8 peer_disc_mac_addr[NAN_MAC_ADDR_LEN]; + + /* + Sequence of values which further specify the published service beyond + the service name. + */ + u16 service_specific_info_len; + u8 service_specific_info[NAN_MAX_SERVICE_SPECIFIC_INFO_LEN]; + + /* + Sequence of values indicating the service specific info in SDEA + Used for service managed bootstrapping method + */ + u16 sdea_service_specific_info_len; + u8 sdea_service_specific_info[NAN_MAX_SDEA_SERVICE_SPECIFIC_INFO_LEN]; + + /* Response Code indicating ACCEPT/REJECT */ + NanBootstrappingResponseCode rsp_code; + + /* The delay of bootstrapping in seconds */ + u32 come_back_delay; + + /* The length of cookie. */ + u32 cookie_length; + + /* Cookie for the follow up response */ + u8 cookie[]; + +} NanBootstrappingIndicationResponse; + +/* + Event indication received on the responder side when a Nan bootsrapping session is initiated on + the Initiator side +*/ +typedef struct { + /* Publish or Subscribe Id of an earlier Publish/Subscribe */ + u16 publish_subscribe_id; + /* + Unique Instance Id corresponding to a service/session. + This is similar to the publish_id generated on the + publisher side + */ + u32 bootstrapping_instance_id; + /* + This Id is the Requestor Instance that is passed as + part of earlier MatchInd/FollowupInd message. + */ + u32 requestor_instance_id; + /* Discovery MAC addr of the peer/initiator */ + u8 peer_disc_mac_addr[NAN_MAC_ADDR_LEN]; + /* Proposed bootstrapping method from peer*/ + u16 request_bootstrapping_method; + +} NanBootstrappingRequestInd; + +/* + Event indication of bootstapping confirm is received on both + initiator side confirming a bootstrapping method +*/ +typedef struct { + /* + Unique token Id generated on the initiator/responder side + used for a bootstrapping session between two NAN devices + */ + u32 bootstrapping_instance_id; + /* Response Code indicating ACCEPT/REJECT */ + NanBootstrappingResponseCode rsp_code; + /* + Reason code indicating the cause for REJECT. + NAN_STATUS_SUCCESS and NAN_STATUS_PROTOCOL_FAILURE are + expected reason codes. + */ + NanStatusType reason_code; + /* The delay of bootstrapping in seconds */ + u32 come_back_delay; + + /* The length of cookie. */ + u32 cookie_length; + + /* Cookie received from the comeback response */ + u8 cookie[]; + +} NanBootstrappingConfirmInd; + +/* + Event indication the device enter or exist the suspension mode +*/ +typedef struct { + /* Indication the device is suspended or not */ + bool is_suspended; +} NanSuspensionModeChangeInd; + +/* Response and Event Callbacks */ +typedef struct { + /* NotifyResponse invoked to notify the status of the Request */ + void (*NotifyResponse)(transaction_id id, NanResponseMsg* rsp_data); + /* Callbacks for various Events */ + void (*EventPublishReplied)(NanPublishRepliedInd *event); + void (*EventPublishTerminated)(NanPublishTerminatedInd* event); + void (*EventMatch) (NanMatchInd* event); + void (*EventMatchExpired) (NanMatchExpiredInd* event); + void (*EventSubscribeTerminated) (NanSubscribeTerminatedInd* event); + void (*EventFollowup) (NanFollowupInd* event); + void (*EventDiscEngEvent) (NanDiscEngEventInd* event); + void (*EventDisabled) (NanDisabledInd* event); + void (*EventTca) (NanTCAInd* event); + void (*EventBeaconSdfPayload) (NanBeaconSdfPayloadInd* event); + void (*EventDataRequest)(NanDataPathRequestInd* event); + void (*EventDataConfirm)(NanDataPathConfirmInd* event); + void (*EventDataEnd)(NanDataPathEndInd* event); + void (*EventTransmitFollowup) (NanTransmitFollowupInd* event); + void (*EventRangeRequest) (NanRangeRequestInd* event); + void (*EventRangeReport) (NanRangeReportInd* event); + void (*EventScheduleUpdate) (NanDataPathScheduleUpdateInd* event); + void (*EventPairingRequest) (NanPairingRequestInd* event); + void (*EventPairingConfirm) (NanPairingConfirmInd* event); + void (*EventBootstrappingRequest) (NanBootstrappingRequestInd* event); + void (*EventBootstrappingConfirm) (NanBootstrappingConfirmInd* event); + void (*EventSuspensionModeChange) (NanSuspensionModeChangeInd* event); +} NanCallbackHandler; + +/**@brief nan_enable_request + * Enable NAN functionality + * + * @param transaction_id: + * @param wifi_interface_handle: + * @param NanEnableRequest: + * @return Synchronous wifi_error + * @return Asynchronous NotifyResponse CB return + * NAN_STATUS_SUCCESS + * NAN_STATUS_ALREADY_ENABLED + * NAN_STATUS_INVALID_PARAM + * NAN_STATUS_INTERNAL_FAILURE + * NAN_STATUS_PROTOCOL_FAILURE + * NAN_STATUS_NAN_NOT_ALLOWED + */ +wifi_error nan_enable_request(transaction_id id, + wifi_interface_handle iface, + NanEnableRequest* msg); + +/**@brief nan_disbale_request + * Disable NAN functionality. + * + * @param transaction_id: + * @param wifi_interface_handle: + * @param NanDisableRequest: + * @return Synchronous wifi_error + * @return Asynchronous NotifyResponse CB return + * NAN_STATUS_SUCCESS + * NAN_STATUS_PROTOCOL_FAILURE + * + */ +wifi_error nan_disable_request(transaction_id id, + wifi_interface_handle iface); + +/**@brief nan_publish_request + * Publish request to advertize a service + * + * @param transaction_id: + * @param wifi_interface_handle: + * @param NanPublishRequest: + * @return Synchronous wifi_error + * @return Asynchronous NotifyResponse CB return + * NAN_STATUS_SUCCESS + * NAN_STATUS_INVALID_PARAM + * NAN_STATUS_PROTOCOL_FAILURE + * NAN_STATUS_NO_RESOURCE_AVAILABLE + * NAN_STATUS_INVALID_PUBLISH_SUBSCRIBE_ID + */ +wifi_error nan_publish_request(transaction_id id, + wifi_interface_handle iface, + NanPublishRequest* msg); + +/**@brief nan_publish_cancel_request + * Cancel previous publish request + * + * @param transaction_id: + * @param wifi_interface_handle: + * @param NanPublishCancelRequest: + * @return Synchronous wifi_error + * @return Asynchronous NotifyResponse CB return + * NAN_STATUS_SUCCESS + * NAN_STATUS_INVALID_PUBLISH_SUBSCRIBE_ID + * NAN_STATUS_INTERNAL_FAILURE + */ +wifi_error nan_publish_cancel_request(transaction_id id, + wifi_interface_handle iface, + NanPublishCancelRequest* msg); + +/**@brief nan_subscribe_request + * Subscribe request to search for a service + * + * @param transaction_id: + * @param wifi_interface_handle: + * @param NanSubscribeRequest: + * @return Synchronous wifi_error + * @return Asynchronous NotifyResponse CB return + * NAN_STATUS_SUCCESS + * NAN_STATUS_INVALID_PARAM + * NAN_STATUS_PROTOCOL_FAILURE + * NAN_STATUS_INTERNAL_FAILURE + * NAN_STATUS_NO_SPACE_AVAILABLE + * NAN_STATUS_INVALID_PUBLISH_SUBSCRIBE_ID + */ +wifi_error nan_subscribe_request(transaction_id id, + wifi_interface_handle iface, + NanSubscribeRequest* msg); + +/**@brief nan_subscribe_cancel_request + * Cancel previous subscribe requests. + * + * @param transaction_id: + * @param wifi_interface_handle: + * @param NanSubscribeRequest: + * @return Synchronous wifi_error + * @return Asynchronous NotifyResponse CB return + * NAN_STATUS_SUCCESS + * NAN_STATUS_INVALID_PUBLISH_SUBSCRIBE_ID + * NAN_STATUS_INTERNAL_FAILURE + */ +wifi_error nan_subscribe_cancel_request(transaction_id id, + wifi_interface_handle iface, + NanSubscribeCancelRequest* msg); + +/**@brief nan_transmit_followup_request + * NAN transmit follow up request + * + * @param transaction_id: + * @param wifi_interface_handle: + * @param NanTransmitFollowupRequest: + * @return Synchronous wifi_error + * @return Asynchronous NotifyResponse CB return + * NAN_STATUS_SUCCESS + * NAN_STATUS_INVALID_PARAM + * NAN_STATUS_INTERNAL_FAILURE + * NAN_STATUS_INVALID_PUBLISH_SUBSCRIBE_ID + * NAN_STATUS_INVALID_REQUESTOR_INSTANCE_ID + * NAN_STATUS_FOLLOWUP_QUEUE_FULL + * @return Asynchronous TransmitFollowupInd CB return + * NAN_STATUS_SUCCESS + * NAN_STATUS_PROTOCOL_FAILURE + * NAN_STATUS_NO_OTA_ACK + */ +wifi_error nan_transmit_followup_request(transaction_id id, + wifi_interface_handle iface, + NanTransmitFollowupRequest* msg); + +/**@brief nan_stats_request + * Request NAN statistics from Discovery Engine. + * + * @param transaction_id: + * @param wifi_interface_handle: + * @param NanStatsRequest: + * @return Synchronous wifi_error + * @return Asynchronous NotifyResponse CB return + * NAN_STATUS_SUCCESS + * NAN_STATUS_INTERNAL_FAILURE + * NAN_STATUS_INVALID_PARAM + */ +wifi_error nan_stats_request(transaction_id id, + wifi_interface_handle iface, + NanStatsRequest* msg); + +/**@brief nan_config_request + * NAN configuration request. + * + * @param transaction_id: + * @param wifi_interface_handle: + * @param NanConfigRequest: + * @return Synchronous wifi_error + * @return Asynchronous NotifyResponse CB return + * NAN_STATUS_SUCCESS + * NAN_STATUS_INVALID_PARAM + * NAN_STATUS_PROTOCOL_FAILURE + * NAN_STATUS_INTERNAL_FAILURE + */ +wifi_error nan_config_request(transaction_id id, + wifi_interface_handle iface, + NanConfigRequest* msg); + +/**@brief nan_tca_request + * Configure the various Threshold crossing alerts + * + * @param transaction_id: + * @param wifi_interface_handle: + * @param NanStatsRequest: + * @return Synchronous wifi_error + * @return Asynchronous NotifyResponse CB return + * NAN_STATUS_SUCCESS + * NAN_STATUS_INVALID_PARAM + * NAN_STATUS_INTERNAL_FAILURE + */ +wifi_error nan_tca_request(transaction_id id, + wifi_interface_handle iface, + NanTCARequest* msg); + +/**@brief nan_beacon_sdf_payload_request + * Set NAN Beacon or sdf payload to discovery engine. + * This instructs the Discovery Engine to begin publishing the + * received payload in any Beacon or Service Discovery Frame transmitted + * + * @param transaction_id: + * @param wifi_interface_handle: + * @param NanStatsRequest: + * @return Synchronous wifi_error + * @return Asynchronous NotifyResponse CB return + * NAN_STATUS_SUCCESS + * NAN_STATUS_INVALID_PARAM + * NAN_STATUS_INTERNAL_FAILURE + */ +wifi_error nan_beacon_sdf_payload_request(transaction_id id, + wifi_interface_handle iface, + NanBeaconSdfPayloadRequest* msg); + +/* Register NAN callbacks. */ +wifi_error nan_register_handler(wifi_interface_handle iface, + NanCallbackHandler handlers); + +/* Get NAN HAL version. */ +wifi_error nan_get_version(wifi_handle handle, + NanVersion* version); + +/**@brief nan_get_capabilities + * Get NAN Capabilities + * + * @param transaction_id: + * @param wifi_interface_handle: + * @return Synchronous wifi_error + * @return Asynchronous NotifyResponse CB return + * NAN_STATUS_SUCCESS + */ +/* Get NAN capabilities. */ +wifi_error nan_get_capabilities(transaction_id id, + wifi_interface_handle iface); + +/* ========== Nan Data Path APIs ================ */ +/**@brief nan_data_interface_create + * Create NAN Data Interface. + * + * @param transaction_id: + * @param wifi_interface_handle: + * @param iface_name: + * @return Synchronous wifi_error + * @return Asynchronous NotifyResponse CB return + * NAN_STATUS_SUCCESS + * NAN_STATUS_INVALID_PARAM + * NAN_STATUS_INTERNAL_FAILURE + */ +wifi_error nan_data_interface_create(transaction_id id, + wifi_interface_handle iface, + char* iface_name); + +/**@brief nan_data_interface_delete + * Delete NAN Data Interface. + * + * @param transaction_id: + * @param wifi_interface_handle: + * @param iface_name: + * @return Synchronous wifi_error + * @return Asynchronous NotifyResponse CB return + * NAN_STATUS_SUCCESS + * NAN_STATUS_INVALID_PARAM + * NAN_STATUS_INTERNAL_FAILURE + */ +wifi_error nan_data_interface_delete(transaction_id id, + wifi_interface_handle iface, + char* iface_name); + +/**@brief nan_data_request_initiator + * Initiate a NAN Data Path session. + * + * @param transaction_id: + * @param wifi_interface_handle: + * @param NanDataPathInitiatorRequest: + * @return Synchronous wifi_error + * @return Asynchronous NotifyResponse CB return + * NAN_STATUS_SUCCESS + * NAN_STATUS_INVALID_PARAM + * NAN_STATUS_INTERNAL_FAILURE + * NAN_STATUS_PROTOCOL_FAILURE + * NAN_STATUS_INVALID_REQUESTOR_INSTANCE_ID + */ +wifi_error nan_data_request_initiator(transaction_id id, + wifi_interface_handle iface, + NanDataPathInitiatorRequest* msg); + +/**@brief nan_data_indication_response + * Response to a data indication received + * corresponding to a NDP session. An indication + * is received with a data request and the responder + * will send a data response + * + * @param transaction_id: + * @param wifi_interface_handle: + * @param NanDataPathIndicationResponse: + * @return Synchronous wifi_error + * @return Asynchronous NotifyResponse CB return + * NAN_STATUS_SUCCESS + * NAN_STATUS_INVALID_PARAM + * NAN_STATUS_INTERNAL_FAILURE + * NAN_STATUS_PROTOCOL_FAILURE + * NAN_STATUS_INVALID_NDP_ID + */ +wifi_error nan_data_indication_response(transaction_id id, + wifi_interface_handle iface, + NanDataPathIndicationResponse* msg); + +/**@brief nan_data_end + * NDL termination request: from either Initiator/Responder + * + * @param transaction_id: + * @param wifi_interface_handle: + * @param NanDataPathEndRequest: + * @return Synchronous wifi_error + * @return Asynchronous NotifyResponse CB return + * NAN_STATUS_SUCCESS + * NAN_STATUS_INVALID_PARAM + * NAN_STATUS_INTERNAL_FAILURE + * NAN_STATUS_PROTOCOL_FAILURE + * NAN_STATUS_INVALID_NDP_ID + */ +wifi_error nan_data_end(transaction_id id, + wifi_interface_handle iface, + NanDataPathEndRequest* msg); +/**@brief nan_pairing_request + * Initiate a NAN Pairingsession. + * + * @param transaction_id: + * @param wifi_interface_handle: + * @param NanPairingRequest: + * @return Synchronous wifi_error + * @return Asynchronous NotifyResponse CB return + * NAN_STATUS_SUCCESS + * NAN_STATUS_INVALID_PARAM + * NAN_STATUS_INTERNAL_FAILURE + * NAN_STATUS_PROTOCOL_FAILURE + * NAN_STATUS_INVALID_REQUESTOR_INSTANCE_ID + */ +wifi_error nan_pairing_request(transaction_id id, wifi_interface_handle iface, + NanPairingRequest* msg); + +/**@brief nan_pairing_indication_response + * Response to a pairing indication received + * corresponding to a pairing session. An indication + * is received with a pairing request and the responder + * will send a pairing response + * + * @param transaction_id: + * @param wifi_interface_handle: + * @param NanPairingIndicationResponse: + * @return Synchronous wifi_error + * @return Asynchronous NotifyResponse CB return + * NAN_STATUS_SUCCESS + * NAN_STATUS_INVALID_PARAM + * NAN_STATUS_INTERNAL_FAILURE + * NAN_STATUS_PROTOCOL_FAILURE + * NAN_STATUS_INVALID_PAIRING_ID + */ +wifi_error nan_pairing_indication_response(transaction_id id, wifi_interface_handle iface, + NanPairingIndicationResponse* msg); + +/**@brief nan_pairing_end + * Cancel and remove the existing Pairing setups + * + * @param transaction_id: + * @param wifi_interface_handle: + * @param NanPairingEndRequest: + * @return Synchronous wifi_error + * @return Asynchronous NotifyResponse CB return + * NAN_STATUS_SUCCESS + * NAN_STATUS_INVALID_PARAM + * NAN_STATUS_INTERNAL_FAILURE + * NAN_STATUS_PROTOCOL_FAILURE + * NAN_STATUS_INVALID_PAIRING_ID + */ +wifi_error nan_pairing_end(transaction_id id, wifi_interface_handle iface, + NanPairingEndRequest* msg); + +/**@brief nan_bootstrapping_request + * Initiate a NAN Bootstrapping session. + * + * @param transaction_id: + * @param wifi_interface_handle: + * @param NanBootstrappingRequest: + * @return Synchronous wifi_error + * @return Asynchronous NotifyResponse CB return + * NAN_STATUS_SUCCESS + * NAN_STATUS_INVALID_PARAM + * NAN_STATUS_INTERNAL_FAILURE + * NAN_STATUS_PROTOCOL_FAILURE + * NAN_STATUS_INVALID_REQUESTOR_INSTANCE_ID + */ +wifi_error nan_bootstrapping_request(transaction_id id, wifi_interface_handle iface, + NanBootstrappingRequest* msg); + +/**@brief nan_bootstrapping_indication_response + * Response to a pairing indication received + * corresponding to a pairing session. An indication + * is received with a pairing request and the responder + * will send a pairing response + * + * @param transaction_id: + * @param wifi_interface_handle: + * @param NanBootstrappingIndicationResponse: + * @return Synchronous wifi_error + * @return Asynchronous NotifyResponse CB return + * NAN_STATUS_SUCCESS + * NAN_STATUS_INVALID_PARAM + * NAN_STATUS_INTERNAL_FAILURE + * NAN_STATUS_PROTOCOL_FAILURE + * NAN_STATUS_INVALID_BOOTSTRAPPING_ID + */ +wifi_error nan_bootstrapping_indication_response(transaction_id id, wifi_interface_handle iface, + NanBootstrappingIndicationResponse* msg); + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#endif /* __NAN_H__ */ diff --git a/wifi/legacy_headers/include/hardware_legacy/wifi_offload.h b/wifi/legacy_headers/include/hardware_legacy/wifi_offload.h new file mode 100644 index 0000000000..835614ee69 --- /dev/null +++ b/wifi/legacy_headers/include/hardware_legacy/wifi_offload.h @@ -0,0 +1,32 @@ +#include "wifi_hal.h" + +#ifndef __WIFI_HAL_OFFLOAD_H +#define __WIFI_HAL_OFFLOAD_H + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + +#define ETHER_ADDR_LEN 6 // Ethernet frame address length +#define N_AVAIL_ID 3 // available mkeep_alive IDs from 1 to 3 +#define MKEEP_ALIVE_IP_PKT_MAX 256 // max size of IP packet for keep alive + +/** + * Send specified keep alive packet periodically. + */ +wifi_error wifi_start_sending_offloaded_packet(wifi_request_id id, wifi_interface_handle iface, + u16 ether_type, u8 *ip_packet, u16 ip_packet_len, u8 *src_mac_addr, u8 *dst_mac_addr, + u32 period_msec); + +/** + * Stop sending keep alive packet. + */ +wifi_error wifi_stop_sending_offloaded_packet(wifi_request_id id, wifi_interface_handle iface); + + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#endif /*__WIFI_HAL_OFFLOAD_H */ diff --git a/wifi/legacy_headers/include/hardware_legacy/wifi_twt.h b/wifi/legacy_headers/include/hardware_legacy/wifi_twt.h new file mode 100644 index 0000000000..1a787ef05e --- /dev/null +++ b/wifi/legacy_headers/include/hardware_legacy/wifi_twt.h @@ -0,0 +1,310 @@ +/* + * Copyright (C) 2020 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. + */ + +#ifndef __WIFI_HAL_TWT_H__ +#define __WIFI_HAL_TWT_H__ + +#include "wifi_hal.h" + +/** + * New HAL interface to Target Wake Time (TWT). + */ + +/* TWT capabilities supported */ +typedef struct { + u8 is_twt_requester_supported; // 0 for not supporting twt requester + u8 is_twt_responder_supported; // 0 for not supporting twt responder + u8 is_broadcast_twt_supported; // 0 for not supporting broadcast twt + u8 is_flexible_twt_supported; // 0 for not supporting flexible twt schedules + u32 min_wake_duration_micros; // minimum twt wake duration capable in microseconds + u32 max_wake_duration_micros; // maximum twt wake duration capable in microseconds + u32 min_wake_interval_micros; // minimum twt wake interval capable in microseconds + u32 max_wake_interval_micros; // maximum twt wake interval capable in microseconds +} wifi_twt_capabilities; + +/* TWT request parameters to setup or update a TWT session */ +typedef struct { + s8 mlo_link_id; // MLO Link id in case TWT is requesting for MLO connection. + // Otherwise UNSPECIFIED. + u32 min_wake_duration_micros; // minimum twt wake duration in microseconds + u32 max_wake_duration_micros; // maximum twt wake duration in microseconds + u32 min_wake_interval_micros; // minimum twt wake interval in microseconds + u32 max_wake_interval_micros; // maximum twt wake interval in microseconds +} wifi_twt_request; + +/* TWT negotiation types */ +typedef enum { + WIFI_TWT_NEGO_TYPE_INDIVIDUAL, + WIFI_TWT_NEGO_TYPE_BROADCAST, +} wifi_twt_negotiation_type; + +/* TWT session */ +typedef struct { + u32 session_id; // a unique identifier for the session + s8 mlo_link_id; // link id in case of MLO connection. Otherwise UNSPECIFIED. + u32 wake_duration_micros; // TWT service period in microseconds + u32 wake_interval_micros; // TWT wake interval for this session in microseconds + wifi_twt_negotiation_type negotiation_type; // TWT negotiation type + u8 is_trigger_enabled; // 0 if this TWT session is not trigger enabled + u8 is_announced; // 0 if this TWT session is not announced + u8 is_implicit; // 0 if this TWT session is not implicit + u8 is_protected; // 0 if this TWT session is not protected + u8 is_updatable; // 0 if this TWT session is not updatable + u8 is_suspendable; // 0 if this TWT session can not be suspended and resumed + u8 is_responder_pm_mode_enabled; // 0 if TWT responder does not intend to go to doze mode + // outside of TWT service periods +} wifi_twt_session; + +/* TWT session stats */ +typedef struct { + u32 avg_pkt_num_tx; // Average number of Tx packets in each wake duration. + u32 avg_pkt_num_rx; // Average number of Rx packets in each wake duration. + u32 avg_tx_pkt_size; // Average bytes per Rx packet in each wake duration. + u32 avg_rx_pkt_size; // Average bytes per Rx packet in each wake duration. + u32 avg_eosp_dur_us; // Average duration of early terminated SP + u32 eosp_count; // Count of early terminations +} wifi_twt_session_stats; + +/* TWT error codes */ +typedef enum { + WIFI_TWT_ERROR_CODE_FAILURE_UNKNOWN, // unknown failure + WIFI_TWT_ERROR_CODE_ALREADY_RESUMED, // TWT session is already resumed + WIFI_TWT_ERROR_CODE_ALREADY_SUSPENDED, // TWT session is already suspended + WIFI_TWT_ERROR_CODE_INVALID_PARAMS, // invalid parameters + WIFI_TWT_ERROR_CODE_MAX_SESSION_REACHED,// maximum number of sessions reached + WIFI_TWT_ERROR_CODE_NOT_AVAILABLE, // requested operation is not available + WIFI_TWT_ERROR_CODE_NOT_SUPPORTED, // requested operation is not supported + WIFI_TWT_ERROR_CODE_PEER_NOT_SUPPORTED, // requested operation is not supported by the + // peer + WIFI_TWT_ERROR_CODE_PEER_REJECTED, // requested operation is rejected by the peer + WIFI_TWT_ERROR_CODE_TIMEOUT, // requested operation is timed out +} wifi_twt_error_code; + +/* TWT teardown reason codes */ +typedef enum { + WIFI_TWT_TEARDOWN_REASON_CODE_UNKNOWN, // unknown reason + WIFI_TWT_TEARDOWN_REASON_CODE_LOCALLY_REQUESTED, // teardown requested by the framework + WIFI_TWT_TEARDOWN_REASON_CODE_INTERNALLY_INITIATED, // teardown initiated internally by the + // firmware or driver. + WIFI_TWT_TEARDOWN_REASON_CODE_PEER_INITIATED, // teardown initiated by the peer +} wifi_twt_teardown_reason_code; + +/** + * TWT events + * + * Each of the events has a wifi_request_id to match the command responsible for the event. If the + * id is 0, the event is an unsolicited. + */ +typedef struct { + /** + * Called to indicate a TWT failure. + * + * @param id Id used to identify the command. The value 0 indicates no associated command. + * @param error_code TWT error code. + */ + void (*on_twt_failure)(wifi_request_id id, wifi_twt_error_code error_code); + + /** + * Called when a Target Wake Time session is created. See wifi_twt_session_setup. + * + * @param id Id used to identify the command. + * @param session TWT session created. + */ + void (*on_twt_session_create)(wifi_request_id id, wifi_twt_session session); + + /** + * Called when a Target Wake Time session is updated. See wifi_twt_session_update. + * + * @param id Id used to identify the command. The value 0 indicates no associated command. + * @param twtSession TWT session. + */ + void (*on_twt_session_update)(wifi_request_id id, wifi_twt_session session); + + /** + * Called when the Target Wake Time session is torn down. See wifi_twt_session_teardown. + * + * @param id Id used to identify the command. The value 0 indicates no associated command. + * @param session_id TWT session id. + * @param reason Teardown reason code. + */ + void (*on_twt_session_teardown)(wifi_request_id id, int session_id, + wifi_twt_teardown_reason_code reason); + + /** + * Called when TWT session stats available. See wifi_twt_session_get_stats. + * + * @param id Id used to identify the command. + * @param session_id TWT session id. + * @param stats TWT session stats. + */ + void (*on_twt_session_stats)(wifi_request_id id, int session_id, wifi_twt_session_stats stats); + + /** + * Called when the Target Wake Time session is suspended. See wifi_twt_session_suspend. + * + * @param id Id used to identify the command. + * @param session_id TWT session id. + */ + void (*on_twt_session_suspend)(wifi_request_id id, int session_id); + + /** + * Called when the Target Wake Time session is resumed. See wifi_twt_session_resume. + * + * @param id Id used to identify the command. + * @param session_id TWT session id. + */ + void (*on_twt_session_resume)(wifi_request_id id, int session_id); +} wifi_twt_events; + +/** + * Important note: Following legacy HAL TWT interface is deprecated. It will be removed in future. + * Please use the new interface listed above. + */ +typedef struct { + u8 requester_supported; // 0 for not supporting requester + u8 responder_supported; // 0 for not supporting responder + u8 broadcast_twt_supported; // 0 for not supporting broadcast TWT + u8 flexibile_twt_supported; // 0 for not supporting flexible TWT +} TwtCapability; + +typedef struct { + TwtCapability device_capability; + TwtCapability peer_capability; +} TwtCapabilitySet; + +// For all optional fields below, if no value specify -1 +typedef struct { + u8 config_id; // An unique ID for an individual TWT request + u8 negotiation_type; // 0 for individual TWT, 1 for broadcast TWT + u8 trigger_type; // 0 for non-triggered TWT, 1 for triggered TWT + s32 wake_dur_us; // Proposed wake duration in us + s32 wake_int_us; // Average wake interval in us + s32 wake_int_min_us; // Min wake interval in us. Optional. + s32 wake_int_max_us; // Max wake interval in us. Optional. + s32 wake_dur_min_us; // Min wake duration in us. Optional. + s32 wake_dur_max_us; // Max wake duration in us. Optional. + s32 avg_pkt_size; // Average bytes of each packet to send in each wake + // duration. Optional. + s32 avg_pkt_num; // Average number of packets to send in each wake + // duration. Optional. + s32 wake_time_off_us; // First wake duration time offset in us. Optional. +} TwtSetupRequest; + +typedef enum { + TWT_SETUP_SUCCESS = 0, // TWT setup is accepted. + TWT_SETUP_REJECT = 1, // TWT setup is rejected by AP. + TWT_SETUP_TIMEOUT = 2, // TWT setup response from AP times out. + TWT_SETUP_IE = 3, // AP sent TWT Setup IE parsing failure. + TWT_SETUP_PARAMS = 4, // AP sent TWT Setup IE Parameters invalid. + TWT_SETUP_ERROR = 255, // Generic error +} TwtSetupReasonCode; + +typedef struct { + u8 config_id; // An unique ID for an individual TWT request + u8 status; // 0 for success, non-zero for failure + TwtSetupReasonCode reason_code; + u8 negotiation_type; // 0 for individual TWT, 1 for broadcast TWT + u8 trigger_type; // 0 for non-triggered TWT, 1 for triggered TWT + s32 wake_dur_us; // Proposed wake duration in us + s32 wake_int_us; // Average wake interval in us + s32 wake_time_off_us; // First wake duration time offset in us. +} TwtSetupResponse; + +typedef struct { + u8 config_id; // An unique ID for an individual TWT request + u8 all_twt; // 0 for individual setp request, 1 for all TWT + u8 negotiation_type; // 0 for individual TWT, 1 for broadcast TWT +} TwtTeardownRequest; + +typedef enum { + TWT_TD_RC_HOST = 0, // Teardown triggered by Host + TWT_TD_RC_PEER = 1, // Peer initiated teardown + TWT_TD_RC_MCHAN = 2, // Teardown due to MCHAN Active + TWT_TD_RC_MCNX = 3, // Teardown due to MultiConnection + TWT_TD_RC_CSA = 4, // Teardown due to CSA + TWT_TD_RC_BTCX = 5, // Teardown due to BT Coex + TWT_TD_RC_SETUP_FAIL = 6, // Setup fails midway. Teardown all connections + TWT_TD_RC_SCHED = 7, // Teardown by TWT Scheduler + TWT_TD_RC_ERROR = 255, // Generic error cases +} TwtTeardownReason; + +typedef struct { + u8 config_id; // An unique ID for an individual TWT request + u8 all_twt; // 0 for individual setp request, 1 for all TWT + u8 status; // 0 for success, non-zero for failure + TwtTeardownReason reason; +} TwtTeardownCompletion; + +typedef struct { + u8 config_id; // An unique ID for an individual TWT request + u8 all_twt; // 0 for individual setup request, 1 for all TWT + s32 resume_time_us; // If -1, TWT is suspended for indefinite time. + // Otherwise, TWT is suspended for resume_time_us +} TwtInfoFrameRequest; + +typedef enum { + TWT_INFO_RC_HOST = 0, // Host initiated TWT Info frame */ + TWT_INFO_RC_PEER = 1, // Peer initiated TWT Info frame + TWT_INFO_RC_ERROR = 2, // Generic error conditions */ +} TwtInfoFrameReason; + +// TWT Info frame triggered externally. +// Device should not send TwtInfoFrameReceived to Host for internally +// triggered TWT Info frame during SCAN, MCHAN operations. +typedef struct { + u8 config_id; // An unique ID for an individual TWT request + u8 all_twt; // 0 for individual setup request, 1 for all TWT + u8 status; // 0 for success, non-zero for failure + TwtInfoFrameReason reason; + u8 twt_resumed; // 1 - TWT resumed, 0 - TWT suspended +} TwtInfoFrameReceived; + +typedef struct { + u8 config_id; + u32 avg_pkt_num_tx; // Average number of Tx packets in each wake duration. + u32 avg_pkt_num_rx; // Average number of Rx packets in each wake duration. + u32 avg_tx_pkt_size; // Average bytes per Rx packet in each wake duration. + u32 avg_rx_pkt_size; // Average bytes per Rx packet in each wake duration. + u32 avg_eosp_dur_us; // Average duration of early terminated SP + u32 eosp_count; // Count of early terminations + u32 num_sp; // Count of service period (SP), also known as wake duration. +} TwtStats; + +// Asynchronous notification from the device. +// For example, TWT was torn down by the device and later when the device is +// ready, it can send this async notification. +// This can be expandable in future. +typedef enum { + TWT_NOTIF_ALLOW_TWT = 1, // Device ready to process TWT Setup request +} TwtNotification; + +typedef struct { + TwtNotification notification; +} TwtDeviceNotify; + +// Callbacks for various TWT responses and events +typedef struct { + // Callback for TWT setup response + void (*EventTwtSetupResponse)(TwtSetupResponse *event); + // Callback for TWT teardown completion + void (*EventTwtTeardownCompletion)(TwtTeardownCompletion* event); + // Callback for TWT info frame received event + void (*EventTwtInfoFrameReceived)(TwtInfoFrameReceived* event); + // Callback for TWT notification from the device + void (*EventTwtDeviceNotify)(TwtDeviceNotify* event); +} TwtCallbackHandler; + +#endif /* __WIFI_HAL_TWT_H__ */