/* * 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 pairs which specify further response conditions beyond the service name used to filter subscribe messages to respond to. This is only needed when the PT is set to NAN_SOLICITED or NAN_SOLICITED_UNSOLICITED. */ u16 rx_match_filter_len; u8 rx_match_filter[NAN_MAX_MATCH_FILTER_LEN]; /* Ordered sequence of pairs to be included in the Discovery Frame. If present it is always sent in a Discovery Frame */ u16 tx_match_filter_len; u8 tx_match_filter[NAN_MAX_MATCH_FILTER_LEN]; }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 pairs used to filter out received publish discovery messages. This can be sent both for a Passive or an Active Subscribe */ u16 rx_match_filter_len; u8 rx_match_filter[NAN_MAX_MATCH_FILTER_LEN]; /* Ordered sequence of pairs included in the Discovery Frame when an Active Subscribe is used.*/ u16 tx_match_filter_len; u8 tx_match_filter[NAN_MAX_MATCH_FILTER_LEN]; }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 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__ */