tequilaOS/platform_hardware_interfaces
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Copy legacy HAL header files to the wifi

Browse source 
interface directory.

No-Typo-Check: Unable to update misspelled variables
BYPASS_INCLUSIVE_LANGUAGE_REASON=Moving legacy code

Bug: 271177978
Test: atest VtsHalWifiChipTargetTest \
            VtsHalWifiStaIfaceTargetTest \
	    VtsHalWifiApIfaceTargetTest \
	    VtsHalWifiNanIfaceTargetTest \
	    VtsHalWifiRttControllerTargetTest
Change-Id: I9329c2bc8c816299cabacb4c3702a20b0056929f
This commit is contained in:
Gabriel Biren 2024-04-02 18:06:26 +00:00
parent e237f5bfaa
commit 97e48aa122
13 changed files with 7384 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

40
wifi/legacy_headers/Android.bp Normal file
View file

@ -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",
],
}

430
wifi/legacy_headers/include/hardware_legacy/gscan.h Normal file
View file

@ -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

342
wifi/legacy_headers/include/hardware_legacy/link_layer_stats.h Normal file
View file

@ -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_ */

62
wifi/legacy_headers/include/hardware_legacy/roam.h Normal file
View file

@ -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__ */

411
wifi/legacy_headers/include/hardware_legacy/rtt.h Normal file
View file

@ -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

85
wifi/legacy_headers/include/hardware_legacy/tdls.h Normal file
View file

@ -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

92
wifi/legacy_headers/include/hardware_legacy/wifi_cached_scan_results.h Normal file
View file

@ -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

45
wifi/legacy_headers/include/hardware_legacy/wifi_config.h Normal file
View file

@ -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_ */

1389
wifi/legacy_headers/include/hardware_legacy/wifi_hal.h Normal file
View file

File diff suppressed because it is too large Load diff

646
wifi/legacy_headers/include/hardware_legacy/wifi_logger.h Normal file
View file

@ -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_ */

3500
wifi/legacy_headers/include/hardware_legacy/wifi_nan.h Normal file
View file

File diff suppressed because it is too large Load diff

32
wifi/legacy_headers/include/hardware_legacy/wifi_offload.h Normal file
View file

@ -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 */

310
wifi/legacy_headers/include/hardware_legacy/wifi_twt.h Normal file
View file

@ -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__ */