| /* |
| * Copyright (C) 2014 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #ifndef __NAN_H__ |
| #define __NAN_H__ |
| |
| #include "wifi_hal.h" |
| |
| #ifdef __cplusplus |
| extern "C" |
| { |
| #endif /* __cplusplus */ |
| |
| /***************************************************************************** |
| * NAN Discovery Service Structures and Functions |
| *****************************************************************************/ |
| |
| /* |
| Definitions |
| All multi-byte fields within all NAN protocol stack messages are assumed to be in Little Endian order. |
| */ |
| |
| typedef int NanVersion; |
| |
| #define NAN_MAC_ADDR_LEN 6 |
| #define NAN_COUNTRY_STRING_LEN 3 |
| #define NAN_MAJOR_VERSION 1 |
| #define NAN_MINOR_VERSION 0 |
| #define NAN_MICRO_VERSION 0 |
| |
| /* NAN Maximum Lengths */ |
| #define NAN_MAX_SERVICE_NAME_LEN 255 |
| #define NAN_MAX_MATCH_FILTER_LEN 255 |
| #define NAN_MAX_SERVICE_SPECIFIC_INFO_LEN 1024 |
| |
| /* |
| Definition of various NanRequestType |
| */ |
| typedef enum { |
| NAN_REQUEST_ENABLE =0, |
| NAN_REQUEST_DISABLE =1, |
| NAN_REQUEST_PUBLISH =2, |
| NAN_REQUEST_PUBLISH_CANCEL =3, |
| NAN_REQUEST_TRANSMIT_FOLLOWUP =4, |
| NAN_REQUEST_SUBSCRIBE =5, |
| NAN_REQUEST_SUBSCRIBE_CANCEL =6, |
| NAN_REQUEST_STATS =7, |
| NAN_REQUEST_CONFIG =8, |
| NAN_REQUEST_TCA =9, |
| NAN_REQUEST_LAST =0xFFFF |
| } NanRequestType; |
| |
| /* |
| Definition of various NanResponseType |
| */ |
| typedef enum { |
| NAN_RESPONSE_ENABLED =0, |
| NAN_RESPONSE_DISABLED =1, |
| NAN_RESPONSE_PUBLISH =2, |
| NAN_RESPONSE_PUBLISH_CANCEL =3, |
| NAN_RESPONSE_TRANSMIT_FOLLOWUP =4, |
| NAN_RESPONSE_SUBSCRIBE =5, |
| NAN_RESPONSE_SUBSCRIBE_CANCEL =6, |
| NAN_RESPONSE_STATS =7, |
| NAN_RESPONSE_CONFIG =8, |
| NAN_RESPONSE_TCA =9, |
| NAN_RESPONSE_ERROR =10, |
| NAN_RESPONSE_UNKNOWN =0xFFFF |
| } NanResponseType; |
| |
| /* |
| Definition of various NanIndication(events) |
| */ |
| typedef enum { |
| NAN_INDICATION_PUBLISH_REPLIED =0, |
| NAN_INDICATION_PUBLISH_TERMINATED =1, |
| NAN_INDICATION_SUBSCRIBE_MATCH =2, |
| NAN_INDICATION_SUBSCRIBE_UNMATCH =3, |
| NAN_INDICATION_SUBSCRIBE_TERMINATED =4, |
| NAN_INDICATION_DE_EVENT =5, |
| NAN_INDICATION_FOLLOWUP =6, |
| NAN_INDICATION_DISABLED =7, |
| NAN_INDICATION_TCA =8, |
| NAN_INDICATION_UNKNOWN =0xFFFF |
| } NanIndicationType; |
| |
| |
| /* NAN Publish Types */ |
| typedef enum { |
| NAN_PUBLISH_TYPE_UNSOLICITED = 0, |
| NAN_PUBLISH_TYPE_SOLICITED, |
| NAN_PUBLISH_TYPE_UNSOLICITED_SOLICITED, |
| NAN_PUBLISH_TYPE_LAST, |
| } NanPublishType; |
| |
| /* NAN Transmit Priorities */ |
| typedef enum { |
| NAN_TX_PRIORITY_LOW = 0, |
| NAN_TX_PRIORITY_NORMAL, |
| NAN_TX_PRIORITY_HIGH, |
| NAN_TX_PRIORITY_LAST |
| } NanTxPriority; |
| |
| /* NAN Statistics Request ID Codes */ |
| typedef enum |
| { |
| NAN_STATS_ID_FIRST = 0, |
| NAN_STATS_ID_DE_PUBLISH = NAN_STATS_ID_FIRST, |
| NAN_STATS_ID_DE_SUBSCRIBE, |
| NAN_STATS_ID_DE_MAC, |
| NAN_STATS_ID_DE_TIMING_SYNC, |
| NAN_STATS_ID_DE_DW, |
| NAN_STATS_ID_DE, |
| NAN_STATS_ID_LAST |
| } NanStatsId; |
| |
| /* NAN Protocol Event ID Codes */ |
| typedef enum |
| { |
| NAN_EVENT_ID_FIRST = 0, |
| NAN_EVENT_ID_SELF_STA_MAC_ADDR = NAN_EVENT_ID_FIRST, |
| NAN_EVENT_ID_STARTED_CLUSTER, |
| NAN_EVENT_ID_JOINED_CLUSTER, |
| NAN_EVENT_ID_LAST |
| } NanEventId; |
| |
| /* TCA IDs */ |
| typedef enum |
| { |
| NAN_TCA_ID_FIRST = 0, |
| NAN_TCA_ID_CLUSTER_SIZE = NAN_TCA_ID_FIRST, |
| NAN_TCA_ID_LAST |
| } NanTcaId; |
| |
| /* |
| Various NAN Protocol Response code |
| */ |
| typedef enum |
| { |
| /* NAN Protocol Response Codes */ |
| NAN_STATUS_SUCCESS = 0, |
| NAN_STATUS_TIMEOUT, |
| NAN_STATUS_DE_FAILURE, |
| NAN_STATUS_INVALID_MSG_VERSION, |
| NAN_STATUS_INVALID_MSG_LEN, |
| NAN_STATUS_INVALID_MSG_ID, |
| NAN_STATUS_INVALID_HANDLE, |
| NAN_STATUS_NO_SPACE_AVAILABLE, |
| NAN_STATUS_INVALID_PUBLISH_TYPE, |
| NAN_STATUS_INVALID_TX_TYPE, |
| NAN_STATUS_INVALID_MATCH_ALGORITHM, |
| NAN_STATUS_DISABLE_IN_PROGRESS, |
| NAN_STATUS_INVALID_TLV_LEN, |
| NAN_STATUS_INVALID_TLV_TYPE, |
| NAN_STATUS_MISSING_TLV_TYPE, |
| NAN_STATUS_INVALID_TOTAL_TLVS_LEN, |
| NAN_STATUS_INVALID_MATCH_HANDLE, |
| NAN_STATUS_INVALID_TLV_VALUE, |
| NAN_STATUS_INVALID_TX_PRIORITY, |
| NAN_STATUS_INVALID_TCA_ID, |
| NAN_STATUS_INVALID_STATS_ID, |
| |
| /* NAN Configuration Response codes */ |
| NAN_STATUS_INVALID_RSSI_CLOSE_VALUE = 128, |
| NAN_STATUS_INVALID_RSSI_MEDIUM_VALUE, |
| NAN_STATUS_INVALID_HOP_COUNT_LIMIT, |
| NAN_STATUS_INVALID_CLUSTER_JOIN_COUNT, |
| NAN_STATUS_INVALID_MIN_WAKE_DW_DURATION_VALUE, |
| NAN_STATUS_INVALID_OFDM_DATA_RATE_VALUE, |
| NAN_STATUS_INVALID_RANDOM_FACTOR_UPDATE_TIME_VALUE, |
| NAN_STATUS_INVALID_MASTER_PREFERENCE_VALUE, |
| NAN_STATUS_INVALID_EARLY_DW_WAKE_INTERVAL_VALUE, |
| NAN_STATUS_INVALID_LOW_CLUSTER_ID_VALUE, |
| NAN_STATUS_INVALID_HIGH_CLUSTER_ID_VALUE, |
| NAN_STATUS_INVALID_INITIAL_SCAN_PERIOD, |
| NAN_STATUS_INVALID_ONGOING_SCAN_PERIOD, |
| NAN_STATUS_INVALID_RSSI_PROXIMITY_VALUE |
| } NanStatusType; |
| |
| /* |
| Various NAN Terminated Indication Code |
| */ |
| typedef enum |
| { |
| NAN_TERMINATED_REASON_INVALID = 0, |
| NAN_TERMINATED_REASON_TIMEOUT, |
| NAN_TERMINATED_REASON_USER_REQUEST, |
| NAN_TERMINATED_REASON_FAILURE, |
| NAN_TERMINATED_REASON_COUNT_REACHED, |
| NAN_TERMINATED_REASON_DE_SHUTDOWN, |
| NAN_TERMINATED_REASON_DISABLE_IN_PROGRESS |
| } NanTerminatedStatus; |
| |
| /* NAN Transmit Types */ |
| typedef enum |
| { |
| NAN_TX_TYPE_BROADCAST = 0, |
| NAN_TX_TYPE_UNICAST, |
| NAN_TX_TYPE_LAST |
| } NanTxType; |
| |
| /* NAN Subscribe Type Bit */ |
| #define NAN_SUBSCRIBE_TYPE_PASSIVE 0 |
| #define NAN_SUBSCRIBE_TYPE_ACTIVE 1 |
| |
| /* NAN Service Response Filter Attribute Bit */ |
| #define NAN_SRF_ATTR_BLOOM_FILTER 0 |
| #define NAN_SRF_ATTR_PARTIAL_MAC_ADDR 1 |
| |
| /* NAN Service Response Filter Include Bit */ |
| #define NAN_SRF_INCLUDE_DO_NOT_RESPOND 0 |
| #define NAN_SRF_INCLUDE_RESPOND 1 |
| |
| /* NAN Match Algorithms */ |
| typedef enum |
| { |
| NAN_MATCH_ALG_FIRST = 0, |
| NAN_MATCH_ALG_MATCH_ONCE = NAN_MATCH_ALG_FIRST, |
| NAN_MATCH_ALG_MATCH_CONTINUOUS, |
| NAN_MATCH_ALG_LAST |
| } NanMatchAlg; |
| |
| /* NAN Header */ |
| typedef struct { |
| /* |
| 16-bit quantity which is allocated by the FW. |
| Pass the Handle as 0xFFFF if the Host would like to set up a new |
| Publish/Subscribe and the FW will pass back a valid handle in response msg. |
| To update an already opened Publish/Subscribe Host can pass a Handle |
| which has already been allocated by the FW. |
| */ |
| u16 handle; |
| |
| /* |
| 16-bit quantity which is allocated in 2 contexts. For all Request |
| messages the TransactionId is allocated by the Service Layer and |
| passed down to the DE. In all Indication messages the TransactionId |
| field is allocated by the DE. There is no correlation between the |
| TransactionIds allocated by the Service Layer and those allocated by the DE |
| */ |
| u16 transaction_id; |
| } NanHeader; |
| |
| /* |
| Enable Request Message Structure |
| The NanEnableReq message instructs the Discovery Engine to enter an operational state |
| */ |
| typedef struct { |
| NanHeader header; |
| u8 support_5g; /* default = 0 */ |
| u16 cluster_low; /* default = 0 */ |
| u16 cluster_high; /* default = 0 */ |
| u8 sid_beacon; /* default = 0x80 */ |
| u8 sync_disc_5g; /* default = 1 i.e 5G Discovery frames only*/ |
| u8 rssi_close; /* default = 60 (-60 dBm) */ |
| u8 rssi_middle; /* default = 70 (-70 dBm) */ |
| u8 rssi_proximity; /* default = 70 (-70 dBm) */ |
| u8 hop_count_limit; /* default = 2 */ |
| u8 random_time; /* default = 120 (DWs) */ |
| u8 master_pref; /* default = 0 */ |
| u8 periodic_scan_interval; /* default = 20 seconds */ |
| /* TBD: Google specific IE */ |
| }NanEnableRequest; |
| |
| /* |
| Disable Request Message Structure |
| The NanDisableReq message instructs the Discovery Engine to exit an operational state. |
| */ |
| typedef struct { |
| NanHeader header; |
| }NanDisableRequest; |
| |
| /* |
| Publish Msg Structure |
| Message is used to request the DE to publish the Service Name |
| using the parameters passed into the Discovery Window |
| */ |
| typedef struct { |
| NanHeader header; |
| u16 ttl; /* how many seconds to run for. 0 means forever until canceled */ |
| u16 period; /* periodicity of OTA unsolicited publish. Specified in increments of 500 ms */ |
| u8 replied_event_flag; /* 1= RepliedEventInd needed, 0 = Not needed */ |
| NanPublishType publish_type;/* 0= unsolicited, solicited = 1, 2= both */ |
| NanTxType tx_type; /* 0 = broadcast, 1= unicast if solicited publish */ |
| u8 publish_count; /* number of OTA Publish, 0 means forever until canceled */ |
| u16 service_name_len; /* length of service name */ |
| u8 service_name[NAN_MAX_SERVICE_NAME_LEN];/* UTF-8 encoded string identifying the service */ |
| |
| /* Sequence of values which should be conveyed to the Discovery Engine of a |
| NAN Device that has invoked a Subscribe method corresponding to this Publish method |
| */ |
| u16 service_specific_info_len; |
| u8 service_specific_info[NAN_MAX_SERVICE_SPECIFIC_INFO_LEN]; |
| |
| /* Ordered sequence of <length, value> pairs which specify further response conditions |
| beyond the service name used to filter subscribe messages to respond to. |
| This is only needed when the PT is set to NAN_SOLICITED or NAN_SOLICITED_UNSOLICITED. |
| */ |
| u16 rx_match_filter_len; |
| u8 rx_match_filter[NAN_MAX_MATCH_FILTER_LEN]; |
| |
| /* Ordered sequence of <length, value> pairs to be included in the Discovery Frame. |
| If present it is always sent in a Discovery Frame |
| */ |
| u16 tx_match_filter_len; |
| u8 tx_match_filter[NAN_MAX_MATCH_FILTER_LEN]; |
| }NanPublishRequest; |
| |
| /* |
| Publish Cancel Msg Structure |
| The PublishServiceCancelReq Message is used to request the DE to stop publishing |
| the Service Name identified by the handle in the message. |
| */ |
| typedef struct { |
| NanHeader header; |
| }NanPublishCancelRequest; |
| |
| /* |
| NAN Subscribe Structure |
| The SubscribeServiceReq message is sent to the Discovery Engine |
| whenever the Upper layers would like to listen for a Service Name |
| */ |
| typedef struct { |
| NanHeader header; |
| u16 ttl; /* how many seconds to run for. 0 means forever until canceled */ |
| u16 period;/* periodicity of OTA Active Subscribe. Units in increments of 500 ms , 0 = attempt every DW*/ |
| |
| /* Flag which specifies how the Subscribe request shall be processed. */ |
| u8 subscribe_type; /* 0 - PASSIVE , 1- ACTIVE */ |
| |
| /* Flag which specifies on Active Subscribes how the Service Response Filter attribute is populated.*/ |
| u8 serviceResponseFilter; /* 0 - Bloom Filter, 1 - MAC Addr */ |
| |
| /* Flag which specifies how the Service Response Filter Include bit is populated.*/ |
| u8 serviceResponseInclude; /* 0=Do not respond if in the Address Set, 1= Respond */ |
| |
| /* Flag which specifies if the Service Response Filter should be used when creating Subscribes.*/ |
| u8 useServiceResponseFilter; /* 0=Do not send the Service Response Filter,1= send */ |
| |
| /* Flag which specifies if the Service Specific Info is needed in the Publish message before creating the MatchIndication*/ |
| u8 ssiRequiredForMatchIndication; /* 0=Not needed, 1= Required */ |
| |
| /* Field which allows the matching behavior to be controlled. */ |
| NanMatchAlg subscribe_match; /* 0 - Match Once, 1 - Match continuous */ |
| |
| /* The number of Subscribe Matches which should occur before the Subscribe request is automatically terminated.*/ |
| u8 subscribe_count; /* If this value is 0 this field is not used by the DE.*/ |
| |
| u16 service_name_len;/* length of service name */ |
| u8 service_name[NAN_MAX_SERVICE_NAME_LEN]; /* UTF-8 encoded string identifying the service */ |
| |
| /* Sequence of values which further specify the published service beyond the service name*/ |
| u16 service_specific_info_len; |
| u8 service_specific_info[NAN_MAX_SERVICE_SPECIFIC_INFO_LEN]; |
| |
| /* Ordered sequence of <length, value> pairs used to filter out received publish discovery messages. |
| This can be sent both for a Passive or an Active Subscribe |
| */ |
| u16 rx_match_filter_len; |
| u8 rx_match_filter[NAN_MAX_MATCH_FILTER_LEN]; |
| |
| /* Ordered sequence of <length, value> pairs included in the Discovery Frame when an Active Subscribe is used.*/ |
| u16 tx_match_filter_len; |
| u8 tx_match_filter[NAN_MAX_MATCH_FILTER_LEN]; |
| }NanSubscribeRequest; |
| |
| |
| /* |
| NAN Subscribe Cancel Structure |
| The SubscribeCancelReq Message is used to request the DE to stop looking for the Service Name. |
| */ |
| typedef struct { |
| NanHeader header; |
| }NanSubscribeCancelRequest; |
| |
| |
| /* |
| Transmit follow up Structure |
| The TransmitFollowupReq message is sent to the DE to allow the sending of the Service_Specific_Info |
| to a particular MAC address. |
| */ |
| typedef struct { |
| NanHeader header; |
| u8 addr[NAN_MAC_ADDR_LEN]; /* Can be a broadcast/multicast or unicast address */ |
| NanTxPriority priority; /* priority of the request 0 = low, 1=normal, 2=high */ |
| u8 dw_or_faw; /* 0= send in a DW, 1=send in FAW */ |
| |
| /* Sequence of values which further specify the published service beyond the service name |
| Treated as service specific info in case dw_or_faw is set to 0 |
| Treated as extended service specific info in case dw_or_faw is set to non-zero*/ |
| u16 service_specific_info_len; |
| u8 service_specific_info[NAN_MAX_SERVICE_SPECIFIC_INFO_LEN]; |
| }NanTransmitFollowupRequest; |
| |
| /* |
| Stats Request structure |
| The Discovery Engine can be queried at runtime by the Host processor for statistics |
| concerning various parts of the Discovery Engine. |
| */ |
| typedef struct { |
| NanHeader header; |
| NanStatsId stats_id; /* NAN Statistics Request ID Codes */ |
| u8 clear; /* 0= Do not clear the stats and return the current contents , 1= Clear the associated stats */ |
| }NanStatsRequest; |
| |
| /* |
| Config Structure |
| The NanConfigurationReq message is sent by the Host to the |
| Discovery Engine in order to configure the Discovery Engine during runtime. |
| */ |
| typedef struct { |
| NanHeader header; |
| u8 sid_beacon; /* default = 0x80 */ |
| u8 sync_disc_5g; /* default = 1 i.e 5G Discovery frames only*/ |
| u8 rssi_proximity; /* default = 70 (-70 dBm) */ |
| u8 random_time; /* default = 120 (DWs) */ |
| u8 master_pref; /* default = 0 */ |
| u8 periodic_scan_interval; /* default = 20 seconds */ |
| /* The number of Additional Discovery Window slots in |
| increments of 16 ms. Since each DW is 512 TUs apart |
| and the DW takes up 1 slot, the maximum number of additional |
| slots which can be specified is 31. This is a hint to the |
| scheduler and there is no guarantee that all 31 slots will |
| be available because of MCC and BT Coexistence channel usage |
| */ |
| u8 additional_disc_window_slots; /* default = 0.*/ |
| }NanConfigRequest; |
| |
| /* |
| TCA Structure |
| The Discovery Engine can be configured to send up Events whenever a configured |
| Threshold Crossing Alert (TCA) Id crosses an integral threshold in a particular direction. |
| */ |
| typedef struct { |
| NanHeader header; |
| NanTcaId tca_id; /* Nan Protocol Threshold Crossing Alert (TCA) Codes */ |
| |
| /* flag which control whether or not an event is generated for the Rising direction */ |
| u8 rising_direction_evt_flag; /* 0 - no event, 1 - event */ |
| |
| /* flag which control whether or not an event is generated for the Falling direction */ |
| u8 falling_direction_evt_flag;/* 0 - no event, 1 - event */ |
| |
| /* flag which requests a previous TCA request to be cleared from the DE */ |
| u8 clear;/*0= Do not clear the TCA, 1=Clear the TCA */ |
| |
| /* 32 bit value which represents the threshold to be used.*/ |
| u32 threshold; |
| }NanTCARequest; |
| |
| /* Publish statistics. */ |
| typedef struct |
| { |
| u32 validPublishServiceReqMsgs; |
| u32 validPublishServiceRspMsgs; |
| u32 validPublishServiceCancelReqMsgs; |
| u32 validPublishServiceCancelRspMsgs; |
| u32 validPublishRepliedIndMsgs; |
| u32 validPublishTerminatedIndMsgs; |
| u32 validActiveSubscribes; |
| u32 validMatches; |
| u32 validFollowups; |
| u32 invalidPublishServiceReqMsgs; |
| u32 invalidPublishServiceCancelReqMsgs; |
| u32 invalidActiveSubscribes; |
| u32 invalidMatches; |
| u32 invalidFollowups; |
| u32 publishCount; |
| } NanPublishStats; |
| |
| /* Subscribe statistics. */ |
| typedef struct |
| { |
| u32 validSubscribeServiceReqMsgs; |
| u32 validSubscribeServiceRspMsgs; |
| u32 validSubscribeServiceCancelReqMsgs; |
| u32 validSubscribeServiceCancelRspMsgs; |
| u32 validSubscribeTerminatedIndMsgs; |
| u32 validSubscribeMatchIndMsgs; |
| u32 validSubscribeUnmatchIndMsgs; |
| u32 validSolicitedPublishes; |
| u32 validMatches; |
| u32 validFollowups; |
| u32 invalidSubscribeServiceReqMsgs; |
| u32 invalidSubscribeServiceCancelReqMsgs; |
| u32 invalidSubscribeFollowupReqMsgs; |
| u32 invalidSolicitedPublishes; |
| u32 invalidMatches; |
| u32 invalidFollowups; |
| u32 subscribeCount; |
| u32 bloomFilterIndex; |
| } NanSubscribeStats; |
| |
| /* NAN MAC Statistics. Used for MAC and DW statistics. */ |
| typedef struct |
| { |
| /* RX stats */ |
| u32 validFrames; |
| u32 validActionFrames; |
| u32 validBeaconFrames; |
| u32 ignoredActionFrames; |
| u32 ignoredBeaconFrames; |
| u32 invalidFrames; |
| u32 invalidActionFrames; |
| u32 invalidBeaconFrames; |
| u32 invalidMacHeaders; |
| u32 invalidPafHeaders; |
| u32 nonNanBeaconFrames; |
| |
| u32 earlyActionFrames; |
| u32 inDwActionFrames; |
| u32 lateActionFrames; |
| |
| /* TX stats */ |
| u32 framesQueued; |
| u32 totalTRSpUpdates; |
| u32 completeByTRSp; |
| u32 completeByTp75DW; |
| u32 completeByTendDW; |
| u32 lateActionFramesTx; |
| |
| /* Misc stats - ignored for DW. */ |
| u32 twIncreases; |
| u32 twDecreases; |
| u32 twChanges; |
| u32 twHighwater; |
| u32 bloomFilterIndex; |
| } NanMacStats; |
| |
| /* NAN Sync Statistics*/ |
| typedef struct |
| { |
| u64 currTsf; |
| u64 myRank; |
| u64 currAmRank; |
| u64 lastAmRank; |
| u32 currAmBTT; |
| u32 lastAmBTT; |
| u8 currAmHopCount; |
| u8 currRole; |
| u16 currClusterId; |
| |
| u64 timeSpentInCurrRole; |
| u64 totalTimeSpentAsMaster; |
| u64 totalTimeSpentAsNonMasterSync; |
| u64 totalTimeSpentAsNonMasterNonSync; |
| u32 transitionsToAnchorMaster; |
| u32 transitionsToMaster; |
| u32 transitionsToNonMasterSync; |
| u32 transitionsToNonMasterNonSync; |
| u32 amrUpdateCount; |
| u32 amrUpdateRankChangedCount; |
| u32 amrUpdateBTTChangedCount; |
| u32 amrUpdateHcChangedCount; |
| u32 amrUpdateNewDeviceCount; |
| u32 amrExpireCount; |
| u32 mergeCount; |
| u32 beaconsAboveHcLimit; |
| u32 beaconsBelowRssiThresh; |
| u32 beaconsIgnoredNoSpace; |
| u32 beaconsForOurCluster; |
| u32 beaconsForOtherCluster; |
| u32 beaconCancelRequests; |
| u32 beaconCancelFailures; |
| u32 beaconUpdateRequests; |
| u32 beaconUpdateFailures; |
| u32 syncBeaconTxAttempts; |
| u32 discBeaconTxAttempts; |
| } NanSyncStats; |
| |
| /* NAN Misc DE Statistics */ |
| typedef struct |
| { |
| u32 validErrorRspMsgs; |
| u32 validTransmitFollowupReqMsgs; |
| u32 validTransmitFollowupRspMsgs; |
| u32 validFollowupIndMsgs; |
| u32 validConfigurationReqMsgs; |
| u32 validConfigurationRspMsgs; |
| u32 validStatsReqMsgs; |
| u32 validStatsRspMsgs; |
| u32 validEnableReqMsgs; |
| u32 validEnableRspMsgs; |
| u32 validDisableReqMsgs; |
| u32 validDisableRspMsgs; |
| u32 validDisableIndMsgs; |
| u32 validEventIndMsgs; |
| u32 validTcaReqMsgs; |
| u32 validTcaRspMsgs; |
| u32 validTcaIndMsgs; |
| u32 invalidTransmitFollowupReqMsgs; |
| u32 invalidConfigurationReqMsgs; |
| u32 invalidStatsReqMsgs; |
| u32 invalidEnableReqMsgs; |
| u32 invalidDisableReqMsgs; |
| u32 invalidTcaReqMsgs; |
| } NanDeStats; |
| |
| /* |
| Stats Response Message structure |
| The Discovery Engine response to a request by the Host for statistics. |
| */ |
| typedef struct { |
| NanStatsId stats_id; |
| union { |
| NanPublishStats publish_stats; |
| NanSubscribeStats subscribe_stats; |
| NanMacStats mac_stats; |
| NanSyncStats sync_stats; |
| NanDeStats de_stats; |
| }data; |
| }NanStatsResponse; |
| |
| /* |
| NAN Response messages |
| */ |
| typedef struct { |
| NanHeader header; |
| u16 status; /* contains the result code */ |
| u16 value; /* For error returns the value is returned which was in error */ |
| NanResponseType response_type; /* NanResponseType Definitions */ |
| union { |
| NanStatsResponse stats_response; |
| }body; |
| }NanResponseMsg; |
| |
| |
| /* |
| Publish Replied Indication |
| The PublishRepliedInd Message is sent by the DE when an Active Subscribe is |
| received over the air and it matches a Solicited PublishServiceReq which had |
| been created with the replied_event_flag set. |
| */ |
| typedef struct { |
| NanHeader header; |
| u8 addr[NAN_MAC_ADDR_LEN]; |
| }NanPublishRepliedInd; |
| |
| /* |
| Publish Terminated |
| The PublishTerminatedInd message is sent by the DE whenever a Publish |
| terminates from a user-specified timeout or a unrecoverable error in the DE. |
| */ |
| typedef struct { |
| NanHeader header; |
| NanTerminatedStatus reason; |
| }NanPublishTerminatedInd; |
| |
| /* |
| Subscribe Match Indication |
| The SubscribeMatchInd message is sent once per responding MAC address whenever |
| the Discovery Engine detects a match for a previous SubscribeServiceReq. |
| */ |
| typedef struct { |
| NanHeader header; |
| |
| /* a 16 bit Handle which is sent to the Application. This handle will be sent in any subsequent |
| UnmatchInd messages rather than resending the Match_Filter/Service_Specific_Info TLVs |
| The Match_Handle is a DE resource and it is of limited quantity. In the event that the DE |
| runs out of Match_Handles the DE will still send the SubscribeMatchInd message but will |
| set the Match_Handle to MATCH_HANDLE_MATCH_POOL_EXHAUSTED=0xFFFF |
| */ |
| u16 match_handle; |
| u8 addr[NAN_MAC_ADDR_LEN]; |
| |
| /* Sequence of octets which were received in a Discovery Frame matching this |
| Subscribe Request.*/ |
| u16 service_specific_info_len; |
| u8 service_specific_info[NAN_MAX_SERVICE_NAME_LEN]; |
| |
| /* Ordered sequence of <length, value> pairs received in the Discovery Frame |
| matching this Subscribe Request.*/ |
| u16 sdf_match_filter_len; |
| u8 sdf_match_filter[NAN_MAX_MATCH_FILTER_LEN]; |
| }NanSubscribeMatchInd; |
| |
| /* |
| Subscribe UnMatch |
| The SubscribeUnmatchInd message is sent whenever the Discovery Engine detects that |
| a previously Matched Subscribed Service Name has been gone for too long. |
| If the previous SubscribeMatchInd message contained a Match_Handle equal to |
| MATCH_HANDLE_MATCH_POOL_EXHAUSTED then this message will not be sent to the Host. |
| */ |
| typedef struct { |
| NanHeader header; |
| /* 16 bit value sent by the DE in a previous SubscribeMatchInd to the application. */ |
| u16 match_handle; |
| }NanSubscribeUnmatchInd; |
| |
| /* |
| Subscribe Terminated |
| The SubscribeTerminatedInd message is sent by the DE whenever a |
| Subscribe terminates from a user-specified timeout or a unrecoverable error in the DE. |
| */ |
| typedef struct { |
| NanHeader header; |
| NanTerminatedStatus reason; |
| }NanSubscribeTerminatedInd; |
| |
| /* |
| Followup Indication Message |
| The FollowupInd message is sent by the DE to the Host whenever it receives a |
| Followup message from another peer. |
| */ |
| typedef struct { |
| NanHeader header; |
| u8 addr[NAN_MAC_ADDR_LEN]; |
| |
| /* Flag which the DE uses to decide if received in a DW or a FAW*/ |
| u8 dw_or_faw; /* 0=Received in a DW, 1 = Received in a FAW*/ |
| |
| /* Sequence of values which further specify the published service beyond the service name |
| Service specific info in case dw_or_faw is set to 0 |
| Extended service specific info in case dw_or_faw is set to non-zero*/ |
| u16 service_specific_info_len; |
| u8 service_specific_info[NAN_MAX_SERVICE_SPECIFIC_INFO_LEN]; |
| }NanFollowupInd; |
| |
| /* Selfstaevent data*/ |
| typedef struct { |
| u8 addr[NAN_MAC_ADDR_LEN]; |
| }NanSelfStaEvent; |
| |
| /* joined or Started cluster data*/ |
| typedef struct { |
| u8 addr[NAN_MAC_ADDR_LEN]; |
| }NanClusterEventData; |
| |
| /* |
| Discovery Engine Event Indication |
| The Discovery Engine can inform the Host when significant events occur |
| The data following the EventId is dependent upon the EventId type. |
| In other words, each new event defined will carry a different |
| structure of information back to the host. |
| */ |
| typedef struct { |
| NanHeader header; |
| NanEventId event_id; /* NAN Protocol Event Codes */ |
| union { |
| /* SelfStaEvent which will have 6 byte mac address |
| of the Discovery engine.*/ |
| NanSelfStaEvent self_sta; |
| /* Cluster Event Data which will be obtained when the |
| device starts a new cluster or joins a cluster. |
| The event data will have 6 byte octet string of the |
| cluster started or joined.*/ |
| NanClusterEventData cluster; |
| }data; |
| }NanDiscEngEventInd; |
| |
| /* Cluster size TCA data*/ |
| typedef struct { |
| u16 cluster_size; |
| }NanTcaClusterData; |
| |
| /* |
| NAN TCA Indication |
| The Discovery Engine can inform the Host when significant events occur. |
| The data following the TcaId is dependent upon the TcaId type. |
| In other words, each new event defined will carry a different structure |
| of information back to the host. |
| */ |
| typedef struct { |
| NanHeader header; |
| NanTcaId tca_id; |
| union { |
| /* This event in obtained when the cluser size threshold |
| is crossed. Event will have the cluster size */ |
| NanTcaClusterData cluster; |
| }data; |
| }NanTCAInd; |
| |
| /* |
| NAN Disabled Indication |
| The NanDisableInd message indicates to the upper layers that the Discovery |
| Engine has flushed all state and has been shutdown. When this message is received |
| the DE is guaranteed to have left the NAN cluster it was part of and will have terminated |
| any in progress Publishes or Subscribes. |
| */ |
| typedef struct { |
| NanHeader header; |
| NanStatusType reason; |
| }NanDisabledInd; |
| |
| /* Response and Event Callbacks */ |
| typedef struct { |
| /* NotifyResponse invoked to notify the status of the Request */ |
| void (*NotifyResponse)(NanResponseMsg* rsp_data); |
| /* Various Events Callback */ |
| void (*EventPublishReplied)(NanPublishRepliedInd* event); |
| void (*EventPublishTerminated)(NanPublishTerminatedInd* event); |
| void (*EventSubscribeMatch) (NanSubscribeMatchInd* event); |
| void (*EventSubscribeUnMatch) (NanSubscribeUnmatchInd* event); |
| void (*EventSubscribeTerminated) (NanSubscribeTerminatedInd* event); |
| void (*EventFollowup) (NanFollowupInd* event); |
| void (*EventDiscEngEvent) (NanDiscEngEventInd* event); |
| void (*EventDisabled) (NanDisabledInd* event); |
| void (*EventTca) (NanTCAInd* event); |
| } NanCallbackHandler; |
| |
| |
| /* Function to send NAN request to the wifi driver.*/ |
| wifi_error nan_enable_request(wifi_request_id id, |
| wifi_handle handle, |
| NanEnableRequest* msg); |
| |
| /* Function to send NAN request to the wifi driver.*/ |
| wifi_error nan_disable_request(wifi_request_id id, |
| wifi_handle handle, |
| NanDisableRequest* msg); |
| |
| /* Function to send NAN request to the wifi driver.*/ |
| wifi_error nan_publish_request(wifi_request_id id, |
| wifi_handle handle, |
| NanPublishRequest* msg); |
| |
| /* Function to send NAN request to the wifi driver.*/ |
| wifi_error nan_publish_cancel_request(wifi_request_id id, |
| wifi_handle handle, |
| NanPublishCancelRequest* msg); |
| |
| /* Function to send NAN request to the wifi driver.*/ |
| wifi_error nan_subscribe_request(wifi_request_id id, |
| wifi_handle handle, |
| NanSubscribeRequest* msg); |
| |
| /* Function to send NAN request to the wifi driver.*/ |
| wifi_error nan_subscribe_cancel_request(wifi_request_id id, |
| wifi_handle handle, |
| NanSubscribeCancelRequest* msg); |
| |
| /* Function to send NAN request to the wifi driver.*/ |
| wifi_error nan_transmit_followup_request(wifi_request_id id, |
| wifi_handle handle, |
| NanTransmitFollowupRequest* msg); |
| |
| /* Function to send NAN statistics request to the wifi driver.*/ |
| wifi_error nan_stats_request(wifi_request_id id, |
| wifi_handle handle, |
| NanStatsRequest* msg); |
| |
| /* Function to send NAN configuration request to the wifi driver.*/ |
| wifi_error nan_config_request(wifi_request_id id, |
| wifi_handle handle, |
| NanConfigRequest* msg); |
| |
| /* Function to send NAN request to the wifi driver.*/ |
| wifi_error nan_tca_request(wifi_request_id id, |
| wifi_handle handle, |
| NanTCARequest* msg); |
| |
| /* Function to register NAN callback */ |
| wifi_error nan_register_handler(wifi_handle handle, |
| NanCallbackHandler handlers); |
| |
| /* Function to get version of the NAN HAL */ |
| wifi_error nan_get_version(wifi_handle handle, |
| NanVersion* version); |
| |
| #ifdef __cplusplus |
| } |
| #endif /* __cplusplus */ |
| |
| #endif /* __NAN_H__ */ |
