1 /*
2 * Copyright (C) 2014 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 *
16 * Changes from Qualcomm Innovation Center are provided under the following license:
17 *
18 * Copyright (c) 2022 Qualcomm Innovation Center, Inc. All rights reserved.
19 *
20 * Redistribution and use in source and binary forms, with or without
21 * modification, are permitted (subject to the limitations in the
22 * disclaimer below) provided that the following conditions are met:
23 *
24 * * Redistributions of source code must retain the above copyright
25 * notice, this list of conditions and the following disclaimer.
26 *
27 * * Redistributions in binary form must reproduce the above
28 * copyright notice, this list of conditions and the following
29 * disclaimer in the documentation and/or other materials provided
30 * with the distribution.
31 *
32 * * Neither the name of Qualcomm Innovation Center, Inc. nor the names of its
33 * contributors may be used to endorse or promote products derived
34 * from this software without specific prior written permission.
35 *
36 * NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE
37 * GRANTED BY THIS LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT
38 * HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED
39 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
40 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
41 * IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
42 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
43 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
44 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
45 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
46 * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
47 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
48 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
49 */
50
51 #include "sync.h"
52 #include <utils/Log.h>
53 #include <hardware_legacy/wifi_hal.h>
54 #include "nan_i.h"
55 #include "nancommand.h"
56
57
isNanResponse()58 int NanCommand::isNanResponse()
59 {
60 if (mNanVendorEvent == NULL) {
61 ALOGE("NULL check failed");
62 return WIFI_ERROR_INVALID_ARGS;
63 }
64
65 NanMsgHeader *pHeader = (NanMsgHeader *)mNanVendorEvent;
66
67 switch (pHeader->msgId) {
68 case NAN_MSG_ID_ERROR_RSP:
69 case NAN_MSG_ID_CONFIGURATION_RSP:
70 case NAN_MSG_ID_PUBLISH_SERVICE_CANCEL_RSP:
71 case NAN_MSG_ID_PUBLISH_SERVICE_RSP:
72 case NAN_MSG_ID_SUBSCRIBE_SERVICE_RSP:
73 case NAN_MSG_ID_SUBSCRIBE_SERVICE_CANCEL_RSP:
74 case NAN_MSG_ID_TRANSMIT_FOLLOWUP_RSP:
75 case NAN_MSG_ID_STATS_RSP:
76 case NAN_MSG_ID_ENABLE_RSP:
77 case NAN_MSG_ID_DISABLE_RSP:
78 case NAN_MSG_ID_TCA_RSP:
79 case NAN_MSG_ID_BEACON_SDF_RSP:
80 case NAN_MSG_ID_CAPABILITIES_RSP:
81 case NAN_MSG_ID_TESTMODE_RSP:
82 return 1;
83 default:
84 return 0;
85 }
86 }
87
88 struct verboseTlv {
89 NanTlvType tlvType;
90 char strTlv[NAN_ERROR_STR_LEN];
91 };
92
93 struct verboseTlv tlvToStr[] = {
94 {NAN_TLV_TYPE_SDF_MATCH_FILTER, " SDF match filter"},
95 {NAN_TLV_TYPE_TX_MATCH_FILTER, " Tx match filter"},
96 {NAN_TLV_TYPE_RX_MATCH_FILTER, " Rx match filter"},
97 {NAN_TLV_TYPE_SERVICE_SPECIFIC_INFO,
98 " Service specific info"},
99 {NAN_TLV_TYPE_EXT_SERVICE_SPECIFIC_INFO,
100 " Extended Service specific info"},
101 {NAN_TLV_TYPE_VENDOR_SPECIFIC_ATTRIBUTE_TRANSMIT,
102 " Vendor specific attribute transmit"},
103 {NAN_TLV_TYPE_VENDOR_SPECIFIC_ATTRIBUTE_RECEIVE,
104 " Vendor specific attribute receive"},
105 {NAN_TLV_TYPE_POST_NAN_CONNECTIVITY_CAPABILITIES_RECEIVE,
106 " Post Nan connectivity capability receive"},
107 {NAN_TLV_TYPE_POST_NAN_DISCOVERY_ATTRIBUTE_RECEIVE,
108 " Post Nan discovery attribute receive"},
109 {NAN_TLV_TYPE_BEACON_SDF_PAYLOAD_RECEIVE,
110 " Beacon SDF payload receive"},
111
112 /* Configuration types */
113 {NAN_TLV_TYPE_CONFIG_FIRST, " Config first"},
114 {NAN_TLV_TYPE_24G_SUPPORT, " 2.4G support"},
115 {NAN_TLV_TYPE_24G_BEACON, " 2.4G beacon"},
116 {NAN_TLV_TYPE_24G_SDF, " 2.4G SDF"},
117 {NAN_TLV_TYPE_24G_RSSI_CLOSE, " 2.4G RSSI close"},
118 {NAN_TLV_TYPE_24G_RSSI_MIDDLE, " 2.4G RSSI middle"},
119 {NAN_TLV_TYPE_24G_RSSI_CLOSE_PROXIMITY,
120 " 2.4G RSSI close proximity"},
121 {NAN_TLV_TYPE_5G_SUPPORT, " 5G support"},
122 {NAN_TLV_TYPE_5G_BEACON, " 5G beacon"},
123 {NAN_TLV_TYPE_5G_SDF, " 5G SDF"},
124 {NAN_TLV_TYPE_5G_RSSI_CLOSE, " 5G RSSI close"},
125 {NAN_TLV_TYPE_5G_RSSI_MIDDLE, " 5G RSSI middle"},
126 {NAN_TLV_TYPE_5G_RSSI_CLOSE_PROXIMITY,
127 " 5G RSSI close proximity"},
128 {NAN_TLV_TYPE_SID_BEACON, " SID beacon"},
129 {NAN_TLV_TYPE_HOP_COUNT_LIMIT, " Hop count limit"},
130 {NAN_TLV_TYPE_MASTER_PREFERENCE, " Master preference"},
131 {NAN_TLV_TYPE_CLUSTER_ID_LOW, " Cluster ID low"},
132 {NAN_TLV_TYPE_CLUSTER_ID_HIGH, " Cluster ID high"},
133 {NAN_TLV_TYPE_RSSI_AVERAGING_WINDOW_SIZE,
134 " RSSI averaging window size"},
135 {NAN_TLV_TYPE_CLUSTER_OUI_NETWORK_ID,
136 " Cluster OUI network ID"},
137 {NAN_TLV_TYPE_SOURCE_MAC_ADDRESS,
138 " Source MAC address"},
139 {NAN_TLV_TYPE_CLUSTER_ATTRIBUTE_IN_SDF,
140 " Cluster attribute in SDF"},
141 {NAN_TLV_TYPE_SOCIAL_CHANNEL_SCAN_PARAMS,
142 " Social channel scan params"},
143 {NAN_TLV_TYPE_DEBUGGING_FLAGS, " Debugging flags"},
144 {NAN_TLV_TYPE_POST_NAN_CONNECTIVITY_CAPABILITIES_TRANSMIT,
145 " Post nan connectivity capabilities transmit"},
146 {NAN_TLV_TYPE_POST_NAN_DISCOVERY_ATTRIBUTE_TRANSMIT,
147 " Post nan discovery attribute transmit"},
148 {NAN_TLV_TYPE_FURTHER_AVAILABILITY_MAP,
149 " Further availability map"},
150 {NAN_TLV_TYPE_HOP_COUNT_FORCE, " Hop count force"},
151 {NAN_TLV_TYPE_RANDOM_FACTOR_FORCE,
152 " Random factor force"},
153 {NAN_TLV_TYPE_RANDOM_UPDATE_TIME,
154 " Random update time"},
155 {NAN_TLV_TYPE_EARLY_WAKEUP, " Early wakeup"},
156 {NAN_TLV_TYPE_PERIODIC_SCAN_INTERVAL,
157 " Periodic scan interval"},
158 {NAN_TLV_TYPE_DW_INTERVAL, " DW interval"},
159 {NAN_TLV_TYPE_DB_INTERVAL, " DB interval"},
160 {NAN_TLV_TYPE_FURTHER_AVAILABILITY,
161 " Further availability"},
162 {NAN_TLV_TYPE_24G_CHANNEL, " 2.4G channel"},
163 {NAN_TLV_TYPE_5G_CHANNEL, " 5G channel"},
164 {NAN_TLV_TYPE_CONFIG_LAST, " Config last"},
165
166 /* Attributes types */
167 {NAN_TLV_TYPE_ATTRS_FIRST, " Attributes first"},
168 {NAN_TLV_TYPE_AVAILABILITY_INTERVALS_MAP,
169 " Availability intervals map"},
170 {NAN_TLV_TYPE_WLAN_MESH_ID, " WLAN mesh ID"},
171 {NAN_TLV_TYPE_MAC_ADDRESS, " MAC address"},
172 {NAN_TLV_TYPE_RECEIVED_RSSI_VALUE,
173 " Received RSSI value"},
174 {NAN_TLV_TYPE_CLUSTER_ATTRIBUTE,
175 " Cluster attribute"},
176 {NAN_TLV_TYPE_WLAN_INFRA_SSID, " WLAN infra SSID"},
177 {NAN_TLV_TYPE_ATTRS_LAST, " Attributes last"},
178
179 /* Events Type */
180 {NAN_TLV_TYPE_EVENTS_FIRST, " Events first"},
181 {NAN_TLV_TYPE_EVENT_SELF_STATION_MAC_ADDRESS,
182 " Event Self station MAC address"},
183 {NAN_TLV_TYPE_EVENT_STARTED_CLUSTER,
184 " Event started cluster"},
185 {NAN_TLV_TYPE_EVENT_JOINED_CLUSTER,
186 " Event joined cluster"},
187 {NAN_TLV_TYPE_EVENT_CLUSTER_SCAN_RESULTS,
188 " Event cluster scan results"},
189 {NAN_TLV_TYPE_FAW_MEM_AVAIL,
190 " FAW memory availability"},
191 {NAN_TLV_TYPE_EVENTS_LAST, " Events last"},
192
193 /* TCA types */
194 {NAN_TLV_TYPE_TCA_FIRST, " TCA-Threshold Crossing Alert first"},
195 {NAN_TLV_TYPE_CLUSTER_SIZE_REQ,
196 " Cluster size request"},
197 {NAN_TLV_TYPE_CLUSTER_SIZE_RSP,
198 " Cluster size response"},
199 {NAN_TLV_TYPE_TCA_LAST, " TCA last"},
200
201 /* Statistics types */
202 {NAN_TLV_TYPE_STATS_FIRST, " Stats first"},
203 {NAN_TLV_TYPE_DE_PUBLISH_STATS,
204 " Discovery engine publish stats"},
205 {NAN_TLV_TYPE_DE_SUBSCRIBE_STATS,
206 " Discovery engine subscribe stats"},
207 {NAN_TLV_TYPE_DE_MAC_STATS,
208 " Discovery engine MAC stats"},
209 {NAN_TLV_TYPE_DE_TIMING_SYNC_STATS,
210 " Discovery engine timing sync stats"},
211 {NAN_TLV_TYPE_DE_DW_STATS,
212 " Discovery engine DW stats"},
213 {NAN_TLV_TYPE_DE_STATS, " Discovery engine stats"},
214 {NAN_TLV_TYPE_STATS_LAST, " Stats last"},
215
216 {NAN_TLV_TYPE_LAST, " Last"}
217 };
218
219 struct errorCode {
220 NanStatusType frameworkError;
221 NanInternalStatusType firmwareError;
222 char nan_error[NAN_ERROR_STR_LEN];
223 };
224
225 struct errorCode errorCodeTranslation[] = {
226 {NAN_STATUS_SUCCESS, NAN_I_STATUS_SUCCESS,
227 "NAN status success"},
228
229 {NAN_STATUS_INTERNAL_FAILURE, NAN_I_STATUS_DE_FAILURE,
230 "NAN Discovery engine failure"},
231
232 {NAN_STATUS_INVALID_PUBLISH_SUBSCRIBE_ID, NAN_I_STATUS_INVALID_HANDLE,
233 "Invalid Publish/Subscribe ID"},
234
235 {NAN_STATUS_NO_RESOURCE_AVAILABLE, NAN_I_STATUS_NO_SPACE_AVAILABLE,
236 "No space available"},
237
238 {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_PUBLISH_TYPE,
239 "Invalid Publish type, can be 0 or 1"},
240 {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_TX_TYPE,
241 "Invalid Tx type"},
242 {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_MSG_VERSION,
243 "Invalid internal message version"},
244 {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_MSG_LEN,
245 "Invalid message length"},
246 {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_MSG_ID,
247 "Invalid message ID"},
248 {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_MATCH_ALGORITHM,
249 "Invalid matching algorithm, can be 0(match once), 1(match continuous) or 2(match never)"},
250 {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_TLV_LEN,
251 "Invalid TLV length"},
252 {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_TLV_TYPE,
253 "Invalid TLV type"},
254 {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_MISSING_TLV_TYPE,
255 "Missing TLV type"},
256 {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_TOTAL_TLVS_LEN,
257 "Invalid total TLV length"},
258 {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_TLV_VALUE,
259 "Invalid TLV value"},
260 {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_TX_PRIORITY,
261 "Invalid Tx priority"},
262 {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_CONNECTION_MAP,
263 "Invalid connection map"},
264 {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_THRESHOLD_CROSSING_ALERT_ID,
265 "Invalid TCA-Threshold Crossing Alert ID"},
266 {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_STATS_ID,
267 "Invalid STATS ID"},
268
269 {NAN_STATUS_PROTOCOL_FAILURE, NAN_I_STATUS_TX_FAIL,
270 "Tx Fail"},
271
272 {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_RSSI_CLOSE_VALUE,
273 "Invalid RSSI close value range is 20dbm to 60dbm"},
274 {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_RSSI_MIDDLE_VALUE,
275 "Invalid RSSI middle value range is 20dbm to 75dbm"},
276 {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_HOP_COUNT_LIMIT,
277 "Invalid hop count limit, max hop count limit is 5"},
278 {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_HIGH_CLUSTER_ID_VALUE,
279 "Invalid cluster ID value. Please set the cluster id high greater than the cluster id low"},
280 {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_BACKGROUND_SCAN_PERIOD,
281 "Invalid background scan period. The range is 10 to 30 milliseconds"},
282 {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_SCAN_CHANNEL,
283 "Invalid scan channel. Only valid channels are the NAN social channels"},
284 {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_POST_NAN_CONNECTIVITY_CAPABILITIES_BITMAP,
285 "Invalid post nan connectivity bitmap"},
286 {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_FURTHER_AVAILABILITY_MAP_NUMCHAN_VALUE,
287 "Invalid further availability map number of channel value"},
288 {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_FURTHER_AVAILABILITY_MAP_DURATION_VALUE,
289 "Invalid further availability map duration value"},
290 {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_FURTHER_AVAILABILITY_MAP_CLASS_VALUE,
291 "Invalid further availability map class value"},
292 {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_FURTHER_AVAILABILITY_MAP_CHANNEL_VALUE,
293 "Invalid further availability map channel value"},
294 {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_FURTHER_AVAILABILITY_MAP_AVAILABILITY_INTERVAL_BITMAP_VALUE,
295 "Invalid further availability map availability interval bitmap value"},
296 {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_FURTHER_AVAILABILITY_MAP_MAP_ID,
297 "Invalid further availability map map ID"},
298 {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_POST_NAN_DISCOVERY_CONN_TYPE_VALUE,
299 "Invalid post nan discovery connection type value"},
300 {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_POST_NAN_DISCOVERY_DEVICE_ROLE_VALUE,
301 "Invalid post nan discovery device role value"},
302 {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_POST_NAN_DISCOVERY_DURATION_VALUE,
303 "Invalid post nan discovery duration value"},
304 {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_POST_NAN_DISCOVERY_BITMAP_VALUE,
305 "Invalid post nan discovery bitmap value"},
306 {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_MISSING_FUTHER_AVAILABILITY_MAP,
307 "Missing further availability map"},
308 {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_BAND_CONFIG_FLAGS,
309 "Invalid band configuration flags"},
310 {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_RANDOM_FACTOR_UPDATE_TIME_VALUE,
311 "Invalid random factor update time value"},
312 {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_ONGOING_SCAN_PERIOD,
313 "Invalid ongoing scan period"},
314 {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_DW_INTERVAL_VALUE,
315 "Invalid DW interval value"},
316 {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_DB_INTERVAL_VALUE,
317 "Invalid DB interval value"},
318
319 {NAN_STATUS_SUCCESS, NAN_I_PUBLISH_SUBSCRIBE_TERMINATED_REASON_TIMEOUT,
320 "Terminated Reason: Timeout"},
321 {NAN_STATUS_SUCCESS, NAN_I_PUBLISH_SUBSCRIBE_TERMINATED_REASON_USER_REQUEST,
322 "Terminated Reason: User Request"},
323 {NAN_STATUS_SUCCESS, NAN_I_PUBLISH_SUBSCRIBE_TERMINATED_REASON_COUNT_REACHED,
324 "Terminated Reason: Count Reached"},
325
326 {NAN_STATUS_INVALID_REQUESTOR_INSTANCE_ID, NAN_I_STATUS_INVALID_REQUESTER_INSTANCE_ID,
327 "Invalid match handle"},
328 {NAN_STATUS_NAN_NOT_ALLOWED, NAN_I_STATUS_NAN_NOT_ALLOWED,
329 "Nan not allowed"},
330 {NAN_STATUS_NO_OTA_ACK, NAN_I_STATUS_NO_OTA_ACK,
331 "No OTA ack"},
332 {NAN_STATUS_ALREADY_ENABLED, NAN_I_STATUS_NAN_ALREADY_ENABLED,
333 "NAN is Already enabled"},
334 {NAN_STATUS_FOLLOWUP_QUEUE_FULL, NAN_I_STATUS_FOLLOWUP_QUEUE_FULL,
335 "Follow-up queue full"},
336
337 {NAN_STATUS_UNSUPPORTED_CONCURRENCY_NAN_DISABLED, NDP_I_UNSUPPORTED_CONCURRENCY,
338 "Unsupported Concurrency"},
339
340 {NAN_STATUS_INTERNAL_FAILURE, NDP_I_NAN_DATA_IFACE_CREATE_FAILED,
341 "NAN data interface create failed"},
342 {NAN_STATUS_INTERNAL_FAILURE, NDP_I_NAN_DATA_IFACE_DELETE_FAILED,
343 "NAN data interface delete failed"},
344 {NAN_STATUS_INTERNAL_FAILURE, NDP_I_DATA_INITIATOR_REQUEST_FAILED,
345 "NAN data initiator request failed"},
346 {NAN_STATUS_INTERNAL_FAILURE, NDP_I_DATA_RESPONDER_REQUEST_FAILED,
347 "NAN data responder request failed"},
348
349 {NAN_STATUS_INVALID_NDP_ID, NDP_I_INVALID_NDP_INSTANCE_ID,
350 "Invalid NDP instance ID"},
351
352 {NAN_STATUS_INVALID_PARAM, NDP_I_INVALID_RESPONSE_CODE,
353 "Invalid response code"},
354 {NAN_STATUS_INVALID_PARAM, NDP_I_INVALID_APP_INFO_LEN,
355 "Invalid app info length"},
356
357 {NAN_STATUS_PROTOCOL_FAILURE, NDP_I_MGMT_FRAME_REQUEST_FAILED,
358 "Management frame request failed"},
359 {NAN_STATUS_PROTOCOL_FAILURE, NDP_I_MGMT_FRAME_RESPONSE_FAILED,
360 "Management frame response failed"},
361 {NAN_STATUS_PROTOCOL_FAILURE, NDP_I_MGMT_FRAME_CONFIRM_FAILED,
362 "Management frame confirm failed"},
363
364 {NAN_STATUS_INTERNAL_FAILURE, NDP_I_END_FAILED,
365 "NDP end failed"},
366
367 {NAN_STATUS_PROTOCOL_FAILURE, NDP_I_MGMT_FRAME_END_REQUEST_FAILED,
368 "Management frame end request failed"},
369
370 {NAN_STATUS_INTERNAL_FAILURE, NDP_I_VENDOR_SPECIFIC_ERROR,
371 "Vendor specific error"}
372 };
373
NanErrorTranslation(NanInternalStatusType firmwareErrorRecvd,u32 valueRcvd,void * pResponse,bool is_ndp_rsp)374 void NanCommand::NanErrorTranslation(NanInternalStatusType firmwareErrorRecvd,
375 u32 valueRcvd,
376 void* pResponse,
377 bool is_ndp_rsp)
378 {
379 int i = 0, j = 0;
380 u16 msg_id; /* Based on the message_id in the header determine the Indication type */
381 NanResponseMsg *pRsp;
382 NanPublishTerminatedInd* pRspInd;
383 NanDisabledInd* pRspdInd;
384 char tlvInfo[NAN_ERROR_STR_LEN];
385 tlvInfo[0] = '\0';
386
387 if ((is_ndp_rsp == true) || isNanResponse()) {
388 pRsp = (NanResponseMsg*)pResponse;
389 for (i = 0; i < (int)(sizeof(errorCodeTranslation)/ sizeof(errorCode)); i++) {
390 if (errorCodeTranslation[i].firmwareError == firmwareErrorRecvd) {
391 pRsp->status = errorCodeTranslation[i].frameworkError;
392 strlcpy(pRsp->nan_error, errorCodeTranslation[i].nan_error, NAN_ERROR_STR_LEN);
393 if (NAN_I_STATUS_INVALID_TLV_TYPE == firmwareErrorRecvd) {
394 for (j = 0; j < (int)(sizeof(tlvToStr)/sizeof(verboseTlv)); j++) {
395 if (tlvToStr[j].tlvType == valueRcvd) {
396 strlcpy(tlvInfo, tlvToStr[i].strTlv, NAN_ERROR_STR_LEN);
397 break;
398 }
399 }
400 }
401 strlcat(pRsp->nan_error, tlvInfo, sizeof(pRsp->nan_error));
402 break;
403 }
404 }
405 if (i == (int)(sizeof(errorCodeTranslation)/sizeof(errorCode))) {
406 pRsp->status = NAN_STATUS_INTERNAL_FAILURE;
407 strlcpy(pRsp->nan_error, "NAN Discovery engine failure", NAN_ERROR_STR_LEN);
408 }
409 ALOGD("%s: Status: %d Error Info[value %d]: %s", __FUNCTION__, pRsp->status, valueRcvd, pRsp->nan_error);
410 } else {
411 msg_id = getIndicationType();
412
413 switch(msg_id) {
414 case NAN_INDICATION_PUBLISH_TERMINATED:
415 case NAN_INDICATION_SUBSCRIBE_TERMINATED:
416 case NAN_INDICATION_SELF_TRANSMIT_FOLLOWUP:
417 pRspInd = (NanPublishTerminatedInd*)pResponse;
418 for (i = 0; i < (int)(sizeof(errorCodeTranslation)/ sizeof(errorCode)); i++) {
419 if (errorCodeTranslation[i].firmwareError == firmwareErrorRecvd) {
420 pRspInd->reason = errorCodeTranslation[i].frameworkError;
421 strlcpy(pRspInd->nan_reason, errorCodeTranslation[i].nan_error, NAN_ERROR_STR_LEN);
422 break;
423 }
424 }
425 if (i == (int)(sizeof(errorCodeTranslation)/sizeof(errorCode))) {
426 pRspInd->reason = NAN_STATUS_INTERNAL_FAILURE;
427 strlcpy(pRspInd->nan_reason, "NAN Discovery engine failure", NAN_ERROR_STR_LEN);
428 }
429 ALOGD("%s: Status: %d Error Info[value %d]: %s", __FUNCTION__, pRspInd->reason, valueRcvd, pRspInd->nan_reason);
430 break;
431 case NAN_INDICATION_DISABLED:
432 pRspdInd = (NanDisabledInd*)pResponse;
433 for (i = 0; i < (int)(sizeof(errorCodeTranslation)/ sizeof(errorCode)); i++) {
434 if (errorCodeTranslation[i].firmwareError == firmwareErrorRecvd) {
435 pRspdInd->reason = errorCodeTranslation[i].frameworkError;
436 strlcpy(pRspdInd->nan_reason, errorCodeTranslation[i].nan_error, NAN_ERROR_STR_LEN);
437 break;
438 }
439 }
440 if (i == (int)(sizeof(errorCodeTranslation)/sizeof(errorCode))) {
441 pRspdInd->reason = NAN_STATUS_INTERNAL_FAILURE;
442 strlcpy(pRspdInd->nan_reason, "NAN Discovery engine failure", NAN_ERROR_STR_LEN);
443 }
444 ALOGD("%s: Status: %d Error Info[value %d]: %s", __FUNCTION__, pRspdInd->reason, valueRcvd, pRspdInd->nan_reason);
445 break;
446 }
447 }
448 }
449
getNanResponse(transaction_id * id,NanResponseMsg * pRsp)450 int NanCommand::getNanResponse(transaction_id *id, NanResponseMsg *pRsp)
451 {
452 if (mNanVendorEvent == NULL || pRsp == NULL) {
453 ALOGE("NULL check failed");
454 return WIFI_ERROR_INVALID_ARGS;
455 }
456
457 NanMsgHeader *pHeader = (NanMsgHeader *)mNanVendorEvent;
458
459 switch (pHeader->msgId) {
460 case NAN_MSG_ID_ERROR_RSP:
461 {
462 pNanErrorRspMsg pFwRsp = \
463 (pNanErrorRspMsg)mNanVendorEvent;
464 *id = (transaction_id)pFwRsp->fwHeader.transactionId;
465 NanErrorTranslation((NanInternalStatusType)pFwRsp->status, pFwRsp->value, pRsp, false);
466 pRsp->response_type = NAN_RESPONSE_ERROR;
467 break;
468 }
469 case NAN_MSG_ID_CONFIGURATION_RSP:
470 {
471 pNanConfigurationRspMsg pFwRsp = \
472 (pNanConfigurationRspMsg)mNanVendorEvent;
473 *id = (transaction_id)pFwRsp->fwHeader.transactionId;
474 NanErrorTranslation((NanInternalStatusType)pFwRsp->status, pFwRsp->value, pRsp, false);
475 pRsp->response_type = NAN_RESPONSE_CONFIG;
476 }
477 break;
478 case NAN_MSG_ID_PUBLISH_SERVICE_CANCEL_RSP:
479 {
480 pNanPublishServiceCancelRspMsg pFwRsp = \
481 (pNanPublishServiceCancelRspMsg)mNanVendorEvent;
482 *id = (transaction_id)pFwRsp->fwHeader.transactionId;
483 NanErrorTranslation((NanInternalStatusType)pFwRsp->status, pFwRsp->value, pRsp, false);
484 pRsp->response_type = NAN_RESPONSE_PUBLISH_CANCEL;
485 pRsp->body.publish_response.publish_id = \
486 pFwRsp->fwHeader.handle;
487 break;
488 }
489 case NAN_MSG_ID_PUBLISH_SERVICE_RSP:
490 {
491 pNanPublishServiceRspMsg pFwRsp = \
492 (pNanPublishServiceRspMsg)mNanVendorEvent;
493 *id = (transaction_id)pFwRsp->fwHeader.transactionId;
494 NanErrorTranslation((NanInternalStatusType)pFwRsp->status, pFwRsp->value, pRsp, false);
495 pRsp->response_type = NAN_RESPONSE_PUBLISH;
496 pRsp->body.publish_response.publish_id = \
497 pFwRsp->fwHeader.handle;
498 break;
499 }
500 case NAN_MSG_ID_SUBSCRIBE_SERVICE_RSP:
501 {
502 pNanSubscribeServiceRspMsg pFwRsp = \
503 (pNanSubscribeServiceRspMsg)mNanVendorEvent;
504 *id = (transaction_id)pFwRsp->fwHeader.transactionId;
505 NanErrorTranslation((NanInternalStatusType)pFwRsp->status, pFwRsp->value, pRsp, false);
506 pRsp->response_type = NAN_RESPONSE_SUBSCRIBE;
507 pRsp->body.subscribe_response.subscribe_id = \
508 pFwRsp->fwHeader.handle;
509 }
510 break;
511 case NAN_MSG_ID_SUBSCRIBE_SERVICE_CANCEL_RSP:
512 {
513 pNanSubscribeServiceCancelRspMsg pFwRsp = \
514 (pNanSubscribeServiceCancelRspMsg)mNanVendorEvent;
515 *id = (transaction_id)pFwRsp->fwHeader.transactionId;
516 NanErrorTranslation((NanInternalStatusType)pFwRsp->status, pFwRsp->value, pRsp, false);
517 pRsp->response_type = NAN_RESPONSE_SUBSCRIBE_CANCEL;
518 pRsp->body.subscribe_response.subscribe_id = \
519 pFwRsp->fwHeader.handle;
520 break;
521 }
522 case NAN_MSG_ID_TRANSMIT_FOLLOWUP_RSP:
523 {
524 pNanTransmitFollowupRspMsg pFwRsp = \
525 (pNanTransmitFollowupRspMsg)mNanVendorEvent;
526 *id = (transaction_id)pFwRsp->fwHeader.transactionId;
527 NanErrorTranslation((NanInternalStatusType)pFwRsp->status, pFwRsp->value, pRsp, false);
528 pRsp->response_type = NAN_RESPONSE_TRANSMIT_FOLLOWUP;
529 break;
530 }
531 case NAN_MSG_ID_STATS_RSP:
532 {
533 pNanStatsRspMsg pFwRsp = \
534 (pNanStatsRspMsg)mNanVendorEvent;
535 *id = (transaction_id)pFwRsp->fwHeader.transactionId;
536 NanErrorTranslation((NanInternalStatusType)pFwRsp->statsRspParams.status,
537 pFwRsp->statsRspParams.value, pRsp, false);
538 pRsp->response_type = NAN_RESPONSE_STATS;
539 pRsp->body.stats_response.stats_type = \
540 (NanStatsType)pFwRsp->statsRspParams.statsType;
541 ALOGV("%s: stats_type:%d",__func__,
542 pRsp->body.stats_response.stats_type);
543 u8 *pInputTlv = pFwRsp->ptlv;
544 NanTlv outputTlv;
545 memset(&outputTlv, 0, sizeof(outputTlv));
546 u16 readLen = 0;
547 int remainingLen = (mNanDataLen - \
548 (sizeof(NanMsgHeader) + sizeof(NanStatsRspParams)));
549 if (remainingLen > 0) {
550 readLen = NANTLV_ReadTlv(pInputTlv, &outputTlv, remainingLen);
551 ALOGV("%s: Remaining Len:%d readLen:%d type:%d length:%d",
552 __func__, remainingLen, readLen, outputTlv.type,
553 outputTlv.length);
554 if (outputTlv.length <= \
555 sizeof(pRsp->body.stats_response.data)) {
556 handleNanStatsResponse(pRsp->body.stats_response.stats_type,
557 (char *)outputTlv.value,
558 &pRsp->body.stats_response,
559 outputTlv.length);
560 }
561 } else
562 ALOGV("%s: No TLV's present",__func__);
563 break;
564 }
565 case NAN_MSG_ID_ENABLE_RSP:
566 {
567 pNanEnableRspMsg pFwRsp = \
568 (pNanEnableRspMsg)mNanVendorEvent;
569 *id = (transaction_id)pFwRsp->fwHeader.transactionId;
570 NanErrorTranslation((NanInternalStatusType)pFwRsp->status, pFwRsp->value, pRsp, false);
571 pRsp->response_type = NAN_RESPONSE_ENABLED;
572 break;
573 }
574 case NAN_MSG_ID_DISABLE_RSP:
575 {
576 pNanDisableRspMsg pFwRsp = \
577 (pNanDisableRspMsg)mNanVendorEvent;
578 *id = (transaction_id)pFwRsp->fwHeader.transactionId;
579 NanErrorTranslation((NanInternalStatusType)pFwRsp->status, 0, pRsp, false);
580 pRsp->response_type = NAN_RESPONSE_DISABLED;
581 break;
582 }
583 case NAN_MSG_ID_TCA_RSP:
584 {
585 pNanTcaRspMsg pFwRsp = \
586 (pNanTcaRspMsg)mNanVendorEvent;
587 *id = (transaction_id)pFwRsp->fwHeader.transactionId;
588 NanErrorTranslation((NanInternalStatusType)pFwRsp->status, pFwRsp->value, pRsp, false);
589 pRsp->response_type = NAN_RESPONSE_TCA;
590 break;
591 }
592 case NAN_MSG_ID_BEACON_SDF_RSP:
593 {
594 pNanBeaconSdfPayloadRspMsg pFwRsp = \
595 (pNanBeaconSdfPayloadRspMsg)mNanVendorEvent;
596 *id = (transaction_id)pFwRsp->fwHeader.transactionId;
597 NanErrorTranslation((NanInternalStatusType)pFwRsp->status, 0, pRsp, false);
598 pRsp->response_type = NAN_RESPONSE_BEACON_SDF_PAYLOAD;
599 break;
600 }
601 case NAN_MSG_ID_CAPABILITIES_RSP:
602 {
603 pNanCapabilitiesRspMsg pFwRsp = \
604 (pNanCapabilitiesRspMsg)mNanVendorEvent;
605 *id = (transaction_id)pFwRsp->fwHeader.transactionId;
606 NanErrorTranslation((NanInternalStatusType)pFwRsp->status, pFwRsp->value, pRsp, false);
607 pRsp->response_type = NAN_GET_CAPABILITIES;
608 pRsp->body.nan_capabilities.max_concurrent_nan_clusters = \
609 pFwRsp->max_concurrent_nan_clusters;
610 pRsp->body.nan_capabilities.max_publishes = \
611 pFwRsp->max_publishes;
612 pRsp->body.nan_capabilities.max_subscribes = \
613 pFwRsp->max_subscribes;
614 pRsp->body.nan_capabilities.max_service_name_len = \
615 pFwRsp->max_service_name_len;
616 pRsp->body.nan_capabilities.max_match_filter_len = \
617 pFwRsp->max_match_filter_len;
618 pRsp->body.nan_capabilities.max_total_match_filter_len = \
619 pFwRsp->max_total_match_filter_len;
620 pRsp->body.nan_capabilities.max_service_specific_info_len = \
621 pFwRsp->max_service_specific_info_len;
622 pRsp->body.nan_capabilities.max_vsa_data_len = \
623 pFwRsp->max_vsa_data_len;
624 pRsp->body.nan_capabilities.max_mesh_data_len = \
625 pFwRsp->max_mesh_data_len;
626 pRsp->body.nan_capabilities.max_ndi_interfaces = \
627 pFwRsp->max_ndi_interfaces;
628 pRsp->body.nan_capabilities.max_ndp_sessions = \
629 pFwRsp->max_ndp_sessions;
630 pRsp->body.nan_capabilities.max_app_info_len = \
631 pFwRsp->max_app_info_len;
632 pRsp->body.nan_capabilities.max_queued_transmit_followup_msgs = \
633 pFwRsp->max_queued_transmit_followup_msgs;
634 pRsp->body.nan_capabilities.ndp_supported_bands = \
635 pFwRsp->ndp_supported_bands;
636 pRsp->body.nan_capabilities.cipher_suites_supported = \
637 pFwRsp->cipher_suites_supported;
638 pRsp->body.nan_capabilities.max_scid_len = \
639 pFwRsp->max_scid_len;
640 pRsp->body.nan_capabilities.is_ndp_security_supported = \
641 pFwRsp->is_ndp_security_supported;
642 pRsp->body.nan_capabilities.max_sdea_service_specific_info_len = \
643 pFwRsp->max_sdea_service_specific_info_len;
644 pRsp->body.nan_capabilities.max_subscribe_address = \
645 pFwRsp->max_subscribe_address;
646 if (pFwRsp->max_publishes > NAN_DEF_PUB_SUB) {
647 mNanCommandInstance->mNanMaxPublishes = pFwRsp->max_publishes;
648 mNanCommandInstance->reallocSvcParams(NAN_ROLE_PUBLISHER);
649 }
650 if (pFwRsp->max_subscribes > NAN_DEF_PUB_SUB) {
651 mNanCommandInstance->mNanMaxSubscribes = pFwRsp->max_subscribes;
652 mNanCommandInstance->reallocSvcParams(NAN_ROLE_SUBSCRIBER);
653 }
654
655 break;
656 }
657 default:
658 return -1;
659 }
660 return 0;
661 }
662
handleNanResponse()663 int NanCommand::handleNanResponse()
664 {
665 //parse the data and call
666 //the response callback handler with the populated
667 //NanResponseMsg
668 NanResponseMsg rsp_data;
669 int ret;
670 transaction_id id;
671
672 ALOGV("handleNanResponse called %p", this);
673 memset(&rsp_data, 0, sizeof(rsp_data));
674 //get the rsp_data
675 ret = getNanResponse(&id, &rsp_data);
676
677 ALOGI("handleNanResponse ret:%d status:%u value:%s response_type:%u",
678 ret, rsp_data.status, rsp_data.nan_error, rsp_data.response_type);
679 if (ret == 0 && (rsp_data.response_type == NAN_RESPONSE_STATS) &&
680 (mStaParam != NULL) &&
681 (rsp_data.body.stats_response.stats_type == NAN_STATS_ID_DE_TIMING_SYNC)) {
682 /*
683 Fill the staParam with appropriate values and return from here.
684 No need to call NotifyResponse as the request is for getting the
685 STA response
686 */
687 NanSyncStats *pSyncStats = &rsp_data.body.stats_response.data.sync_stats;
688 mStaParam->master_rank = pSyncStats->myRank;
689 mStaParam->master_pref = (pSyncStats->myRank & 0xFF00000000000000) >> 56;
690 mStaParam->random_factor = (pSyncStats->myRank & 0x00FF000000000000) >> 48;
691 mStaParam->hop_count = pSyncStats->currAmHopCount;
692 mStaParam->beacon_transmit_time = pSyncStats->currAmBTT;
693 mStaParam->ndp_channel_freq = pSyncStats->ndpChannelFreq;
694
695 ALOGI("%s:0x%02x master_pref 0x%02x random_factor 0x%02x hop_count %u Channel",
696 __func__, mStaParam->master_pref, mStaParam->random_factor,
697 mStaParam->hop_count, mStaParam->ndp_channel_freq);
698
699 return ret;
700 }
701 //Call the NotifyResponse Handler
702 if (ret == 0 && mHandler.NotifyResponse) {
703 (*mHandler.NotifyResponse)(id, &rsp_data);
704 }
705 return ret;
706 }
707
handleNanStatsResponse(NanStatsType stats_type,char * rspBuf,NanStatsResponse * pRsp,u32 message_len)708 void NanCommand::handleNanStatsResponse(NanStatsType stats_type,
709 char *rspBuf,
710 NanStatsResponse *pRsp,
711 u32 message_len)
712 {
713 if (stats_type == NAN_STATS_ID_DE_PUBLISH) {
714 NanPublishStats publish_stats;
715 if (message_len != sizeof(NanPublishStats)) {
716 ALOGE("%s: stats_type = %d invalid stats length = %u expected length = %zu\n",
717 __func__, stats_type, message_len, sizeof(NanPublishStats));
718 return;
719 }
720 FwNanPublishStats *pPubStats = (FwNanPublishStats *)rspBuf;
721
722 publish_stats.validPublishServiceReqMsgs =
723 pPubStats->validPublishServiceReqMsgs;
724 publish_stats.validPublishServiceRspMsgs =
725 pPubStats->validPublishServiceRspMsgs;
726 publish_stats.validPublishServiceCancelReqMsgs =
727 pPubStats->validPublishServiceCancelReqMsgs;
728 publish_stats.validPublishServiceCancelRspMsgs =
729 pPubStats->validPublishServiceCancelRspMsgs;
730 publish_stats.validPublishRepliedIndMsgs =
731 pPubStats->validPublishRepliedIndMsgs;
732 publish_stats.validPublishTerminatedIndMsgs =
733 pPubStats->validPublishTerminatedIndMsgs;
734 publish_stats.validActiveSubscribes = pPubStats->validActiveSubscribes;
735 publish_stats.validMatches = pPubStats->validMatches;
736 publish_stats.validFollowups = pPubStats->validFollowups;
737 publish_stats.invalidPublishServiceReqMsgs =
738 pPubStats->invalidPublishServiceReqMsgs;
739 publish_stats.invalidPublishServiceCancelReqMsgs =
740 pPubStats->invalidPublishServiceCancelReqMsgs;
741 publish_stats.invalidActiveSubscribes =
742 pPubStats->invalidActiveSubscribes;
743 publish_stats.invalidMatches = pPubStats->invalidMatches;
744 publish_stats.invalidFollowups = pPubStats->invalidFollowups;
745 publish_stats.publishCount = pPubStats->publishCount;
746 publish_stats.publishNewMatchCount = pPubStats->publishNewMatchCount;
747 publish_stats.pubsubGlobalNewMatchCount =
748 pPubStats->pubsubGlobalNewMatchCount;
749 memcpy(&pRsp->data.publish_stats, &publish_stats, sizeof(NanPublishStats));
750 } else if (stats_type == NAN_STATS_ID_DE_SUBSCRIBE) {
751 NanSubscribeStats sub_stats;
752 if (message_len != sizeof(NanSubscribeStats)) {
753 ALOGE("%s: stats_type = %d invalid stats length = %u expected length = %zu\n",
754 __func__, stats_type, message_len, sizeof(NanSubscribeStats));
755 return;
756 }
757 FwNanSubscribeStats *pSubStats = (FwNanSubscribeStats *)rspBuf;
758
759 sub_stats.validSubscribeServiceReqMsgs =
760 pSubStats->validSubscribeServiceReqMsgs;
761 sub_stats.validSubscribeServiceRspMsgs =
762 pSubStats->validSubscribeServiceRspMsgs;
763 sub_stats.validSubscribeServiceCancelReqMsgs =
764 pSubStats->validSubscribeServiceCancelReqMsgs;
765 sub_stats.validSubscribeServiceCancelRspMsgs =
766 pSubStats->validSubscribeServiceCancelRspMsgs;
767 sub_stats.validSubscribeTerminatedIndMsgs =
768 pSubStats->validSubscribeTerminatedIndMsgs;
769 sub_stats.validSubscribeMatchIndMsgs =
770 pSubStats->validSubscribeMatchIndMsgs;
771 sub_stats.validSubscribeUnmatchIndMsgs =
772 pSubStats->validSubscribeUnmatchIndMsgs;
773 sub_stats.validSolicitedPublishes =
774 pSubStats->validSolicitedPublishes;
775 sub_stats.validMatches = pSubStats->validMatches;
776 sub_stats.validFollowups = pSubStats->validFollowups;
777 sub_stats.invalidSubscribeServiceReqMsgs =
778 pSubStats->invalidSubscribeServiceReqMsgs;
779 sub_stats.invalidSubscribeServiceCancelReqMsgs =
780 pSubStats->invalidSubscribeServiceCancelReqMsgs;
781 sub_stats.invalidSubscribeFollowupReqMsgs =
782 pSubStats->invalidSubscribeFollowupReqMsgs;
783 sub_stats.invalidSolicitedPublishes =
784 pSubStats->invalidSolicitedPublishes;
785 sub_stats.invalidMatches = pSubStats->invalidMatches;
786 sub_stats.invalidFollowups = pSubStats->invalidFollowups;
787 sub_stats.subscribeCount = pSubStats->subscribeCount;
788 sub_stats.bloomFilterIndex = pSubStats->bloomFilterIndex;
789 sub_stats.subscribeNewMatchCount = pSubStats->subscribeNewMatchCount;
790 sub_stats.pubsubGlobalNewMatchCount =
791 pSubStats->pubsubGlobalNewMatchCount;
792 memcpy(&pRsp->data.subscribe_stats, &sub_stats, sizeof(NanSubscribeStats));
793 } else if (stats_type == NAN_STATS_ID_DE_DW) {
794 NanDWStats dw_stats;
795 if (message_len != sizeof(NanDWStats)) {
796 ALOGE("%s: stats_type = %d invalid stats length = %u expected length = %zu\n",
797 __func__, stats_type, message_len, sizeof(NanDWStats));
798 return;
799 }
800 FwNanMacStats *pMacStats = (FwNanMacStats *)rspBuf;
801
802 dw_stats.validFrames = pMacStats->validFrames;
803 dw_stats.validActionFrames = pMacStats->validActionFrames;
804 dw_stats.validBeaconFrames = pMacStats->validBeaconFrames;
805 dw_stats.ignoredActionFrames = pMacStats->ignoredActionFrames;
806 dw_stats.ignoredBeaconFrames = pMacStats->ignoredBeaconFrames;
807 dw_stats.invalidFrames = pMacStats->invalidFrames;
808 dw_stats.invalidActionFrames = pMacStats->invalidActionFrames;
809 dw_stats.invalidBeaconFrames = pMacStats->invalidBeaconFrames;
810 dw_stats.invalidMacHeaders = pMacStats->invalidMacHeaders;
811 dw_stats.invalidPafHeaders = pMacStats->invalidPafHeaders;
812 dw_stats.nonNanBeaconFrames = pMacStats->nonNanBeaconFrames;
813 dw_stats.earlyActionFrames = pMacStats->earlyActionFrames;
814 dw_stats.inDwActionFrames = pMacStats->inDwActionFrames;
815 dw_stats.lateActionFrames = pMacStats->lateActionFrames;
816 dw_stats.framesQueued = pMacStats->framesQueued;
817 dw_stats.totalTRSpUpdates = pMacStats->totalTRSpUpdates;
818 dw_stats.completeByTRSp = pMacStats->completeByTRSp;
819 dw_stats.completeByTp75DW = pMacStats->completeByTp75DW;
820 dw_stats.completeByTendDW = pMacStats->completeByTendDW;
821 dw_stats.lateActionFramesTx = pMacStats->lateActionFramesTx;
822 memcpy(&pRsp->data.dw_stats, &dw_stats, sizeof(NanDWStats));
823 } else if (stats_type == NAN_STATS_ID_DE_MAC) {
824 NanMacStats mac_stats;
825 if (message_len != sizeof(NanMacStats)) {
826 ALOGE("%s: stats_type = %d invalid stats length = %u expected length = %zu\n",
827 __func__, stats_type, message_len, sizeof(NanMacStats));
828 return;
829 }
830 FwNanMacStats *pMacStats = (FwNanMacStats *)rspBuf;
831
832 mac_stats.validFrames = pMacStats->validFrames;
833 mac_stats.validActionFrames = pMacStats->validActionFrames;
834 mac_stats.validBeaconFrames = pMacStats->validBeaconFrames;
835 mac_stats.ignoredActionFrames = pMacStats->ignoredActionFrames;
836 mac_stats.ignoredBeaconFrames = pMacStats->ignoredBeaconFrames;
837 mac_stats.invalidFrames = pMacStats->invalidFrames;
838 mac_stats.invalidActionFrames = pMacStats->invalidActionFrames;
839 mac_stats.invalidBeaconFrames = pMacStats->invalidBeaconFrames;
840 mac_stats.invalidMacHeaders = pMacStats->invalidMacHeaders;
841 mac_stats.invalidPafHeaders = pMacStats->invalidPafHeaders;
842 mac_stats.nonNanBeaconFrames = pMacStats->nonNanBeaconFrames;
843 mac_stats.earlyActionFrames = pMacStats->earlyActionFrames;
844 mac_stats.inDwActionFrames = pMacStats->inDwActionFrames;
845 mac_stats.lateActionFrames = pMacStats->lateActionFrames;
846 mac_stats.framesQueued = pMacStats->framesQueued;
847 mac_stats.totalTRSpUpdates = pMacStats->totalTRSpUpdates;
848 mac_stats.completeByTRSp = pMacStats->completeByTRSp;
849 mac_stats.completeByTp75DW = pMacStats->completeByTp75DW;
850 mac_stats.completeByTendDW = pMacStats->completeByTendDW;
851 mac_stats.lateActionFramesTx = pMacStats->lateActionFramesTx;
852 mac_stats.twIncreases = pMacStats->twIncreases;
853 mac_stats.twDecreases = pMacStats->twDecreases;
854 mac_stats.twChanges = pMacStats->twChanges;
855 mac_stats.twHighwater = pMacStats->twHighwater;
856 mac_stats.bloomFilterIndex = pMacStats->bloomFilterIndex;
857 memcpy(&pRsp->data.mac_stats, &mac_stats, sizeof(NanMacStats));
858 } else if (stats_type == NAN_STATS_ID_DE_TIMING_SYNC) {
859 NanSyncStats sync_stats;
860 if (message_len != sizeof(NanSyncStats)) {
861 ALOGE("%s: stats_type = %d invalid stats length = %u expected length = %zu\n",
862 __func__, stats_type, message_len, sizeof(NanSyncStats));
863 return;
864 }
865 FwNanSyncStats *pSyncStats = (FwNanSyncStats *)rspBuf;
866
867 sync_stats.currTsf = pSyncStats->currTsf;
868 sync_stats.myRank = pSyncStats->myRank;
869 sync_stats.currAmRank = pSyncStats->currAmRank;
870 sync_stats.lastAmRank = pSyncStats->lastAmRank;
871 sync_stats.currAmBTT = pSyncStats->currAmBTT;
872 sync_stats.lastAmBTT = pSyncStats->lastAmBTT;
873 sync_stats.currAmHopCount = pSyncStats->currAmHopCount;
874 sync_stats.currRole = pSyncStats->currRole;
875 sync_stats.currClusterId = pSyncStats->currClusterId;
876
877 sync_stats.timeSpentInCurrRole = pSyncStats->timeSpentInCurrRole;
878 sync_stats.totalTimeSpentAsMaster = pSyncStats->totalTimeSpentAsMaster;
879 sync_stats.totalTimeSpentAsNonMasterSync =
880 pSyncStats->totalTimeSpentAsNonMasterSync;
881 sync_stats.totalTimeSpentAsNonMasterNonSync =
882 pSyncStats->totalTimeSpentAsNonMasterNonSync;
883 sync_stats.transitionsToAnchorMaster =
884 pSyncStats->transitionsToAnchorMaster;
885 sync_stats.transitionsToMaster =
886 pSyncStats->transitionsToMaster;
887 sync_stats.transitionsToNonMasterSync =
888 pSyncStats->transitionsToNonMasterSync;
889 sync_stats.transitionsToNonMasterNonSync =
890 pSyncStats->transitionsToNonMasterNonSync;
891 sync_stats.amrUpdateCount = pSyncStats->amrUpdateCount;
892 sync_stats.amrUpdateRankChangedCount =
893 pSyncStats->amrUpdateRankChangedCount;
894 sync_stats.amrUpdateBTTChangedCount =
895 pSyncStats->amrUpdateBTTChangedCount;
896 sync_stats.amrUpdateHcChangedCount =
897 pSyncStats->amrUpdateHcChangedCount;
898 sync_stats.amrUpdateNewDeviceCount =
899 pSyncStats->amrUpdateNewDeviceCount;
900 sync_stats.amrExpireCount = pSyncStats->amrExpireCount;
901 sync_stats.mergeCount = pSyncStats->mergeCount;
902 sync_stats.beaconsAboveHcLimit = pSyncStats->beaconsAboveHcLimit;
903 sync_stats.beaconsBelowRssiThresh = pSyncStats->beaconsBelowRssiThresh;
904 sync_stats.beaconsIgnoredNoSpace = pSyncStats->beaconsIgnoredNoSpace;
905 sync_stats.beaconsForOurCluster = pSyncStats->beaconsForOtherCluster;
906 sync_stats.beaconsForOtherCluster = pSyncStats->beaconsForOtherCluster;
907 sync_stats.beaconCancelRequests = pSyncStats->beaconCancelRequests;
908 sync_stats.beaconCancelFailures = pSyncStats->beaconCancelFailures;
909 sync_stats.beaconUpdateRequests = pSyncStats->beaconUpdateRequests;
910 sync_stats.beaconUpdateFailures = pSyncStats->beaconUpdateFailures;
911 sync_stats.syncBeaconTxAttempts = pSyncStats->syncBeaconTxAttempts;
912 sync_stats.syncBeaconTxFailures = pSyncStats->syncBeaconTxFailures;
913 sync_stats.discBeaconTxAttempts = pSyncStats->discBeaconTxAttempts;
914 sync_stats.discBeaconTxFailures = pSyncStats->discBeaconTxFailures;
915 sync_stats.amHopCountExpireCount = pSyncStats->amHopCountExpireCount;
916 sync_stats.ndpChannelFreq = pSyncStats->ndpChannelFreq;
917 sync_stats.ndpChannelFreq2 = pSyncStats->ndpChannelFreq2;
918 sync_stats.schedUpdateChannelFreq = pSyncStats->schedUpdateChannelFreq;
919 memcpy(&pRsp->data.sync_stats, &sync_stats, sizeof(NanSyncStats));
920 } else if (stats_type == NAN_STATS_ID_DE) {
921 NanDeStats de_stats;
922 if (message_len != sizeof(NanDeStats)) {
923 ALOGE("%s: stats_type = %d invalid stats length = %u expected length = %zu\n",
924 __func__, stats_type, message_len, sizeof(NanDeStats));
925 return;
926 }
927 FwNanDeStats *pDeStats = (FwNanDeStats *)rspBuf;
928
929 de_stats.validErrorRspMsgs = pDeStats->validErrorRspMsgs;
930 de_stats.validTransmitFollowupReqMsgs =
931 pDeStats->validTransmitFollowupReqMsgs;
932 de_stats.validTransmitFollowupRspMsgs =
933 pDeStats->validTransmitFollowupRspMsgs;
934 de_stats.validFollowupIndMsgs =
935 pDeStats->validFollowupIndMsgs;
936 de_stats.validConfigurationReqMsgs =
937 pDeStats->validConfigurationReqMsgs;
938 de_stats.validConfigurationRspMsgs =
939 pDeStats->validConfigurationRspMsgs;
940 de_stats.validStatsReqMsgs = pDeStats->validStatsReqMsgs;
941 de_stats.validStatsRspMsgs = pDeStats->validStatsRspMsgs;
942 de_stats.validEnableReqMsgs = pDeStats->validEnableReqMsgs;
943 de_stats.validEnableRspMsgs = pDeStats->validEnableRspMsgs;
944 de_stats.validDisableReqMsgs = pDeStats->validDisableReqMsgs;
945 de_stats.validDisableRspMsgs = pDeStats->validDisableRspMsgs;
946 de_stats.validDisableIndMsgs = pDeStats->validDisableIndMsgs;
947 de_stats.validEventIndMsgs = pDeStats->validEventIndMsgs;
948 de_stats.validTcaReqMsgs = pDeStats->validTcaReqMsgs;
949 de_stats.validTcaRspMsgs = pDeStats->validTcaRspMsgs;
950 de_stats.validTcaIndMsgs = pDeStats->validTcaIndMsgs;
951 de_stats.invalidTransmitFollowupReqMsgs =
952 pDeStats->invalidTransmitFollowupReqMsgs;
953 de_stats.invalidConfigurationReqMsgs =
954 pDeStats->invalidConfigurationReqMsgs;
955 de_stats.invalidStatsReqMsgs = pDeStats->invalidStatsReqMsgs;
956 de_stats.invalidEnableReqMsgs = pDeStats->invalidEnableReqMsgs;
957 de_stats.invalidDisableReqMsgs = pDeStats->invalidDisableReqMsgs;
958 de_stats.invalidTcaReqMsgs = pDeStats->invalidTcaReqMsgs;
959 memcpy(&pRsp->data.de_stats, &de_stats, sizeof(NanDeStats));
960 } else {
961 ALOGE("Unknown stats_type:%d\n", stats_type);
962 }
963 }
964
handleNdpResponse(NanResponseType ndpCmdType,struct nlattr ** tb_vendor)965 int NanCommand::handleNdpResponse(NanResponseType ndpCmdType,
966 struct nlattr **tb_vendor)
967 {
968 //parse the data and call
969 //the response callback handler with the populated
970 //NanResponseMsg
971 NanResponseMsg rsp_data;
972 transaction_id id;
973
974 memset(&rsp_data, 0, sizeof(rsp_data));
975
976 if ((!tb_vendor[QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID]) ||
977 (!tb_vendor[QCA_WLAN_VENDOR_ATTR_NDP_DRV_RESPONSE_STATUS_TYPE]) ||
978 (!tb_vendor[QCA_WLAN_VENDOR_ATTR_NDP_DRV_RETURN_VALUE]))
979 {
980 ALOGE("%s: QCA_WLAN_VENDOR_ATTR_NDP not found", __FUNCTION__);
981 return WIFI_ERROR_INVALID_ARGS;
982 }
983
984 id = nla_get_u16(tb_vendor[QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID]);
985 ALOGD("%s: Transaction id : val %d", __FUNCTION__, id);
986
987 NanErrorTranslation((NanInternalStatusType)nla_get_u32(tb_vendor[QCA_WLAN_VENDOR_ATTR_NDP_DRV_RESPONSE_STATUS_TYPE]),
988 nla_get_u32(tb_vendor[QCA_WLAN_VENDOR_ATTR_NDP_DRV_RETURN_VALUE]), &rsp_data, true);
989 rsp_data.response_type = ndpCmdType;
990
991 if (ndpCmdType == NAN_DP_INITIATOR_RESPONSE)
992 {
993 if (!tb_vendor[QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID])
994 {
995 ALOGE("%s: QCA_WLAN_VENDOR_ATTR_NDP not found", __FUNCTION__);
996 return WIFI_ERROR_INVALID_ARGS;
997 }
998 rsp_data.body.data_request_response.ndp_instance_id =
999 nla_get_u32(tb_vendor[QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID]);
1000 }
1001 //Call the NotifyResponse Handler
1002 if (mHandler.NotifyResponse) {
1003 (*mHandler.NotifyResponse)(id, &rsp_data);
1004 }
1005 return WIFI_SUCCESS;
1006 }
1007