blob: d5f517b396a9500e35340983f7ceda1bd76c489a [file] [log] [blame]
Roshan Piuse65edb12016-11-22 13:02:01 -08001/*
2 * Copyright (C) 2016 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
17#include <android-base/logging.h>
18#include <utils/SystemClock.h>
19
20#include "hidl_struct_util.h"
21
22namespace android {
23namespace hardware {
24namespace wifi {
25namespace V1_0 {
26namespace implementation {
27namespace hidl_struct_util {
28
Roshan Pius32d0ca92016-12-02 11:21:19 -080029uint8_t convertHidlScanReportEventFlagToLegacy(
Roshan Piuse65edb12016-11-22 13:02:01 -080030 StaBackgroundScanBucketEventReportSchemeMask hidl_flag) {
31 using HidlFlag = StaBackgroundScanBucketEventReportSchemeMask;
32 switch (hidl_flag) {
33 case HidlFlag::EACH_SCAN:
34 return REPORT_EVENTS_EACH_SCAN;
35 case HidlFlag::FULL_RESULTS:
36 return REPORT_EVENTS_FULL_RESULTS;
37 case HidlFlag::NO_BATCH:
38 return REPORT_EVENTS_NO_BATCH;
39 };
40}
41
Roshan Pius32d0ca92016-12-02 11:21:19 -080042StaScanDataFlagMask convertLegacyScanDataFlagToHidl(uint8_t legacy_flag) {
43 switch (legacy_flag) {
44 case legacy_hal::WIFI_SCAN_FLAG_INTERRUPTED:
45 return StaScanDataFlagMask::INTERRUPTED;
46 };
47 CHECK(false) << "Unknown legacy flag: " << legacy_flag;
48 // To silence the compiler warning about reaching the end of non-void
49 // function.
50 return StaScanDataFlagMask::INTERRUPTED;
51}
52
Roshan Piuse65edb12016-11-22 13:02:01 -080053bool convertHidlScanParamsToLegacy(
54 const StaBackgroundScanParameters& hidl_scan_params,
55 legacy_hal::wifi_scan_cmd_params* legacy_scan_params) {
56 if (!legacy_scan_params) {
57 return false;
58 }
59 legacy_scan_params->base_period = hidl_scan_params.basePeriodInMs;
60 legacy_scan_params->max_ap_per_scan = hidl_scan_params.maxApPerScan;
61 legacy_scan_params->report_threshold_percent =
62 hidl_scan_params.reportThresholdPercent;
63 legacy_scan_params->report_threshold_num_scans =
64 hidl_scan_params.reportThresholdNumScans;
65 // TODO(b/33194311): Expose these max limits in the HIDL interface.
66 if (hidl_scan_params.buckets.size() > MAX_BUCKETS) {
67 return false;
68 }
69 legacy_scan_params->num_buckets = hidl_scan_params.buckets.size();
70 for (uint32_t bucket_idx = 0; bucket_idx < hidl_scan_params.buckets.size();
71 bucket_idx++) {
72 const StaBackgroundScanBucketParameters& hidl_bucket_spec =
73 hidl_scan_params.buckets[bucket_idx];
74 legacy_hal::wifi_scan_bucket_spec& legacy_bucket_spec =
75 legacy_scan_params->buckets[bucket_idx];
76 legacy_bucket_spec.bucket = bucket_idx;
77 legacy_bucket_spec.band =
78 static_cast<legacy_hal::wifi_band>(hidl_bucket_spec.band);
79 legacy_bucket_spec.period = hidl_bucket_spec.periodInMs;
80 legacy_bucket_spec.max_period = hidl_bucket_spec.exponentialMaxPeriodInMs;
81 legacy_bucket_spec.base = hidl_bucket_spec.exponentialBase;
82 legacy_bucket_spec.step_count = hidl_bucket_spec.exponentialStepCount;
83 legacy_bucket_spec.report_events = 0;
84 using HidlFlag = StaBackgroundScanBucketEventReportSchemeMask;
85 for (const auto flag :
86 {HidlFlag::EACH_SCAN, HidlFlag::FULL_RESULTS, HidlFlag::NO_BATCH}) {
87 if (hidl_bucket_spec.eventReportScheme &
88 static_cast<std::underlying_type<HidlFlag>::type>(flag)) {
89 legacy_bucket_spec.report_events |=
Roshan Pius32d0ca92016-12-02 11:21:19 -080090 convertHidlScanReportEventFlagToLegacy(flag);
Roshan Piuse65edb12016-11-22 13:02:01 -080091 }
92 }
93 // TODO(b/33194311): Expose these max limits in the HIDL interface.
94 if (hidl_bucket_spec.frequencies.size() > MAX_CHANNELS) {
95 return false;
96 }
97 legacy_bucket_spec.num_channels = hidl_bucket_spec.frequencies.size();
98 for (uint32_t freq_idx = 0; freq_idx < hidl_bucket_spec.frequencies.size();
99 freq_idx++) {
100 legacy_bucket_spec.channels[freq_idx].channel =
101 hidl_bucket_spec.frequencies[freq_idx];
102 }
103 }
104 return true;
105}
106
107bool convertLegacyIeBlobToHidl(const uint8_t* ie_blob,
108 uint32_t ie_blob_len,
109 std::vector<WifiInformationElement>* hidl_ies) {
110 if (!ie_blob || !hidl_ies) {
111 return false;
112 }
113 const uint8_t* ies_begin = ie_blob;
114 const uint8_t* ies_end = ie_blob + ie_blob_len;
115 const uint8_t* next_ie = ies_begin;
116 using wifi_ie = legacy_hal::wifi_information_element;
117 constexpr size_t kIeHeaderLen = sizeof(wifi_ie);
118 // Each IE should atleast have the header (i.e |id| & |len| fields).
119 while (next_ie + kIeHeaderLen <= ies_end) {
120 const wifi_ie& legacy_ie = (*reinterpret_cast<const wifi_ie*>(next_ie));
121 uint32_t curr_ie_len = kIeHeaderLen + legacy_ie.len;
122 if (next_ie + curr_ie_len > ies_end) {
123 return false;
124 }
125 WifiInformationElement hidl_ie;
126 hidl_ie.id = legacy_ie.id;
127 hidl_ie.data =
128 std::vector<uint8_t>(legacy_ie.data, legacy_ie.data + legacy_ie.len);
129 hidl_ies->push_back(std::move(hidl_ie));
130 next_ie += curr_ie_len;
131 }
132 // Ensure that the blob has been fully consumed.
133 return (next_ie == ies_end);
134}
135
136bool convertLegacyScanResultToHidl(
137 const legacy_hal::wifi_scan_result& legacy_scan_result,
138 bool has_ie_data,
139 StaScanResult* hidl_scan_result) {
140 if (!hidl_scan_result) {
141 return false;
142 }
143 hidl_scan_result->timeStampInUs = legacy_scan_result.ts;
144 hidl_scan_result->ssid = std::vector<uint8_t>(
145 legacy_scan_result.ssid,
146 legacy_scan_result.ssid + sizeof(legacy_scan_result.ssid));
147 memcpy(hidl_scan_result->bssid.data(),
148 legacy_scan_result.bssid,
149 hidl_scan_result->bssid.size());
150 hidl_scan_result->frequency = legacy_scan_result.channel;
151 hidl_scan_result->rssi = legacy_scan_result.rssi;
152 hidl_scan_result->beaconPeriodInMs = legacy_scan_result.beacon_period;
153 hidl_scan_result->capability = legacy_scan_result.capability;
154 if (has_ie_data) {
155 std::vector<WifiInformationElement> ies;
156 if (!convertLegacyIeBlobToHidl(
157 reinterpret_cast<const uint8_t*>(legacy_scan_result.ie_data),
158 legacy_scan_result.ie_length,
159 &ies)) {
160 return false;
161 }
162 hidl_scan_result->informationElements = std::move(ies);
163 }
164 return true;
165}
166
167bool convertLegacyCachedScanResultsToHidl(
168 const legacy_hal::wifi_cached_scan_results& legacy_cached_scan_result,
169 StaScanData* hidl_scan_data) {
170 if (!hidl_scan_data) {
171 return false;
172 }
Roshan Pius32d0ca92016-12-02 11:21:19 -0800173 for (const auto flag : {legacy_hal::WIFI_SCAN_FLAG_INTERRUPTED}) {
174 if (legacy_cached_scan_result.flags & flag) {
175 hidl_scan_data->flags |=
176 static_cast<std::underlying_type<StaScanDataFlagMask>::type>(
177 convertLegacyScanDataFlagToHidl(flag));
178 }
179 }
Roshan Piuse65edb12016-11-22 13:02:01 -0800180 hidl_scan_data->bucketsScanned = legacy_cached_scan_result.buckets_scanned;
181
182 CHECK(legacy_cached_scan_result.num_results >= 0 &&
183 legacy_cached_scan_result.num_results <= MAX_AP_CACHE_PER_SCAN);
184 std::vector<StaScanResult> hidl_scan_results;
185 for (int32_t result_idx = 0;
186 result_idx < legacy_cached_scan_result.num_results;
187 result_idx++) {
188 StaScanResult hidl_scan_result;
189 if (!convertLegacyScanResultToHidl(
190 legacy_cached_scan_result.results[result_idx],
191 false,
192 &hidl_scan_result)) {
193 return false;
194 }
195 hidl_scan_results.push_back(hidl_scan_result);
196 }
197 hidl_scan_data->results = std::move(hidl_scan_results);
198 return true;
199}
200
201bool convertLegacyVectorOfCachedScanResultsToHidl(
202 const std::vector<legacy_hal::wifi_cached_scan_results>&
203 legacy_cached_scan_results,
204 std::vector<StaScanData>* hidl_scan_datas) {
205 if (!hidl_scan_datas) {
206 return false;
207 }
208 for (const auto& legacy_cached_scan_result : legacy_cached_scan_results) {
209 StaScanData hidl_scan_data;
210 if (!convertLegacyCachedScanResultsToHidl(legacy_cached_scan_result,
211 &hidl_scan_data)) {
212 return false;
213 }
214 hidl_scan_datas->push_back(hidl_scan_data);
215 }
216 return true;
217}
218
Roshan Pius32d0ca92016-12-02 11:21:19 -0800219WifiDebugTxPacketFate convertLegacyDebugTxPacketFateToHidl(
220 legacy_hal::wifi_tx_packet_fate fate) {
221 switch (fate) {
222 case legacy_hal::TX_PKT_FATE_ACKED:
223 return WifiDebugTxPacketFate::ACKED;
224 case legacy_hal::TX_PKT_FATE_SENT:
225 return WifiDebugTxPacketFate::SENT;
226 case legacy_hal::TX_PKT_FATE_FW_QUEUED:
227 return WifiDebugTxPacketFate::FW_QUEUED;
228 case legacy_hal::TX_PKT_FATE_FW_DROP_INVALID:
229 return WifiDebugTxPacketFate::FW_DROP_INVALID;
230 case legacy_hal::TX_PKT_FATE_FW_DROP_NOBUFS:
231 return WifiDebugTxPacketFate::FW_DROP_NOBUFS;
232 case legacy_hal::TX_PKT_FATE_FW_DROP_OTHER:
233 return WifiDebugTxPacketFate::FW_DROP_OTHER;
234 case legacy_hal::TX_PKT_FATE_DRV_QUEUED:
235 return WifiDebugTxPacketFate::DRV_QUEUED;
236 case legacy_hal::TX_PKT_FATE_DRV_DROP_INVALID:
237 return WifiDebugTxPacketFate::DRV_DROP_INVALID;
238 case legacy_hal::TX_PKT_FATE_DRV_DROP_NOBUFS:
239 return WifiDebugTxPacketFate::DRV_DROP_NOBUFS;
240 case legacy_hal::TX_PKT_FATE_DRV_DROP_OTHER:
241 return WifiDebugTxPacketFate::DRV_DROP_OTHER;
242 };
243}
244
245WifiDebugRxPacketFate convertLegacyDebugRxPacketFateToHidl(
246 legacy_hal::wifi_rx_packet_fate fate) {
247 switch (fate) {
248 case legacy_hal::RX_PKT_FATE_SUCCESS:
249 return WifiDebugRxPacketFate::SUCCESS;
250 case legacy_hal::RX_PKT_FATE_FW_QUEUED:
251 return WifiDebugRxPacketFate::FW_QUEUED;
252 case legacy_hal::RX_PKT_FATE_FW_DROP_FILTER:
253 return WifiDebugRxPacketFate::FW_DROP_FILTER;
254 case legacy_hal::RX_PKT_FATE_FW_DROP_INVALID:
255 return WifiDebugRxPacketFate::FW_DROP_INVALID;
256 case legacy_hal::RX_PKT_FATE_FW_DROP_NOBUFS:
257 return WifiDebugRxPacketFate::FW_DROP_NOBUFS;
258 case legacy_hal::RX_PKT_FATE_FW_DROP_OTHER:
259 return WifiDebugRxPacketFate::FW_DROP_OTHER;
260 case legacy_hal::RX_PKT_FATE_DRV_QUEUED:
261 return WifiDebugRxPacketFate::DRV_QUEUED;
262 case legacy_hal::RX_PKT_FATE_DRV_DROP_FILTER:
263 return WifiDebugRxPacketFate::DRV_DROP_FILTER;
264 case legacy_hal::RX_PKT_FATE_DRV_DROP_INVALID:
265 return WifiDebugRxPacketFate::DRV_DROP_INVALID;
266 case legacy_hal::RX_PKT_FATE_DRV_DROP_NOBUFS:
267 return WifiDebugRxPacketFate::DRV_DROP_NOBUFS;
268 case legacy_hal::RX_PKT_FATE_DRV_DROP_OTHER:
269 return WifiDebugRxPacketFate::DRV_DROP_OTHER;
270 };
271}
272
273WifiDebugPacketFateFrameType convertLegacyDebugPacketFateFrameTypeToHidl(
274 legacy_hal::frame_type type) {
275 switch (type) {
276 case legacy_hal::FRAME_TYPE_UNKNOWN:
277 return WifiDebugPacketFateFrameType::UNKNOWN;
278 case legacy_hal::FRAME_TYPE_ETHERNET_II:
279 return WifiDebugPacketFateFrameType::ETHERNET_II;
280 case legacy_hal::FRAME_TYPE_80211_MGMT:
281 return WifiDebugPacketFateFrameType::MGMT_80211;
282 };
283}
284
285bool convertLegacyDebugPacketFateFrameToHidl(
286 const legacy_hal::frame_info& legacy_frame,
287 WifiDebugPacketFateFrameInfo* hidl_frame) {
288 if (!hidl_frame) {
289 return false;
290 }
291 hidl_frame->frameType =
292 convertLegacyDebugPacketFateFrameTypeToHidl(legacy_frame.payload_type);
293 hidl_frame->frameLen = legacy_frame.frame_len;
294 hidl_frame->driverTimestampUsec = legacy_frame.driver_timestamp_usec;
295 hidl_frame->firmwareTimestampUsec = legacy_frame.firmware_timestamp_usec;
296 const uint8_t* frame_begin = reinterpret_cast<const uint8_t*>(
297 legacy_frame.frame_content.ethernet_ii_bytes);
298 hidl_frame->frameContent =
299 std::vector<uint8_t>(frame_begin, frame_begin + legacy_frame.frame_len);
300 return true;
301}
302
303bool convertLegacyDebugTxPacketFateToHidl(
304 const legacy_hal::wifi_tx_report& legacy_fate,
305 WifiDebugTxPacketFateReport* hidl_fate) {
306 if (!hidl_fate) {
307 return false;
308 }
309 hidl_fate->fate = convertLegacyDebugTxPacketFateToHidl(legacy_fate.fate);
310 return convertLegacyDebugPacketFateFrameToHidl(legacy_fate.frame_inf,
311 &hidl_fate->frameInfo);
312}
313
314bool convertLegacyDebugRxPacketFateToHidl(
315 const legacy_hal::wifi_rx_report& legacy_fate,
316 WifiDebugRxPacketFateReport* hidl_fate) {
317 if (!hidl_fate) {
318 return false;
319 }
320 hidl_fate->fate = convertLegacyDebugRxPacketFateToHidl(legacy_fate.fate);
321 return convertLegacyDebugPacketFateFrameToHidl(legacy_fate.frame_inf,
322 &hidl_fate->frameInfo);
323}
324
Roshan Piuse65edb12016-11-22 13:02:01 -0800325bool convertLegacyLinkLayerStatsToHidl(
326 const legacy_hal::LinkLayerStats& legacy_stats,
327 StaLinkLayerStats* hidl_stats) {
328 if (!hidl_stats) {
329 return false;
330 }
331 // iface legacy_stats conversion.
332 hidl_stats->iface.beaconRx = legacy_stats.iface.beacon_rx;
333 hidl_stats->iface.avgRssiMgmt = legacy_stats.iface.rssi_mgmt;
334 hidl_stats->iface.wmeBePktStats.rxMpdu =
335 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].rx_mpdu;
336 hidl_stats->iface.wmeBePktStats.txMpdu =
337 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].tx_mpdu;
338 hidl_stats->iface.wmeBePktStats.lostMpdu =
339 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].mpdu_lost;
340 hidl_stats->iface.wmeBePktStats.retries =
341 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].retries;
342 hidl_stats->iface.wmeBkPktStats.rxMpdu =
343 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].rx_mpdu;
344 hidl_stats->iface.wmeBkPktStats.txMpdu =
345 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].tx_mpdu;
346 hidl_stats->iface.wmeBkPktStats.lostMpdu =
347 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].mpdu_lost;
348 hidl_stats->iface.wmeBkPktStats.retries =
349 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].retries;
350 hidl_stats->iface.wmeViPktStats.rxMpdu =
351 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].rx_mpdu;
352 hidl_stats->iface.wmeViPktStats.txMpdu =
353 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].tx_mpdu;
354 hidl_stats->iface.wmeViPktStats.lostMpdu =
355 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].mpdu_lost;
356 hidl_stats->iface.wmeViPktStats.retries =
357 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].retries;
358 hidl_stats->iface.wmeVoPktStats.rxMpdu =
359 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].rx_mpdu;
360 hidl_stats->iface.wmeVoPktStats.txMpdu =
361 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].tx_mpdu;
362 hidl_stats->iface.wmeVoPktStats.lostMpdu =
363 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].mpdu_lost;
364 hidl_stats->iface.wmeVoPktStats.retries =
365 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].retries;
366 // radio legacy_stats conversion.
367 hidl_stats->radio.onTimeInMs = legacy_stats.radio.on_time;
368 hidl_stats->radio.txTimeInMs = legacy_stats.radio.tx_time;
369 hidl_stats->radio.rxTimeInMs = legacy_stats.radio.rx_time;
370 hidl_stats->radio.onTimeInMsForScan = legacy_stats.radio.on_time_scan;
371 hidl_stats->radio.txTimeInMsPerLevel = legacy_stats.radio_tx_time_per_levels;
372 // Timestamp in the HAL wrapper here since it's not provided in the legacy
373 // HAL API.
374 hidl_stats->timeStampInMs = uptimeMillis();
375 return true;
376}
Roshan Piusf5f51fd2016-12-01 13:54:24 -0800377
378legacy_hal::NanPublishType convertHidlNanPublishTypeToLegacy(
379 NanPublishType type) {
380 switch (type) {
381 case NanPublishType::UNSOLICITED:
382 return legacy_hal::NAN_PUBLISH_TYPE_UNSOLICITED;
383 case NanPublishType::SOLICITED:
384 return legacy_hal::NAN_PUBLISH_TYPE_SOLICITED;
385 case NanPublishType::UNSOLICITED_SOLICITED:
386 return legacy_hal::NAN_PUBLISH_TYPE_UNSOLICITED_SOLICITED;
387 };
388}
389
390legacy_hal::NanTxType convertHidlNanTxTypeToLegacy(NanTxType type) {
391 switch (type) {
392 case NanTxType::BROADCAST:
393 return legacy_hal::NAN_TX_TYPE_BROADCAST;
394 case NanTxType::UNICAST:
395 return legacy_hal::NAN_TX_TYPE_UNICAST;
396 };
397}
398
399legacy_hal::NanMatchAlg convertHidlNanMatchAlgToLegacy(NanMatchAlg type) {
400 switch (type) {
401 case NanMatchAlg::MATCH_ONCE:
402 return legacy_hal::NAN_MATCH_ALG_MATCH_ONCE;
403 case NanMatchAlg::MATCH_CONTINUOUS:
404 return legacy_hal::NAN_MATCH_ALG_MATCH_CONTINUOUS;
405 case NanMatchAlg::MATCH_NEVER:
406 return legacy_hal::NAN_MATCH_ALG_MATCH_NEVER;
407 };
408}
409
410legacy_hal::NanSubscribeType convertHidlNanSubscribeTypeToLegacy(
411 NanSubscribeType type) {
412 switch (type) {
413 case NanSubscribeType::ACTIVE:
414 return legacy_hal::NAN_SUBSCRIBE_TYPE_ACTIVE;
415 case NanSubscribeType::PASSIVE:
416 return legacy_hal::NAN_SUBSCRIBE_TYPE_PASSIVE;
417 };
418}
419
420legacy_hal::NanSRFType convertHidlNanSrfTypeToLegacy(NanSrfType type) {
421 switch (type) {
422 case NanSrfType::BLOOM_FILTER:
423 return legacy_hal::NAN_SRF_ATTR_BLOOM_FILTER;
424 case NanSrfType::PARTIAL_MAC_ADDR:
425 return legacy_hal::NAN_SRF_ATTR_PARTIAL_MAC_ADDR;
426 };
427}
428
429legacy_hal::NanSRFIncludeType convertHidlNanSrfIncludeTypeToLegacy(
430 NanSrfIncludeType type) {
431 switch (type) {
432 case NanSrfIncludeType::DO_NOT_RESPOND:
433 return legacy_hal::NAN_SRF_INCLUDE_DO_NOT_RESPOND;
434 case NanSrfIncludeType::RESPOND:
435 return legacy_hal::NAN_SRF_INCLUDE_RESPOND;
436 };
437}
438
439NanStatusType convertLegacyNanStatusTypeToHidl(
440 legacy_hal::NanStatusType /* type */) {
441 // TODO: The |NanStatusType| has changed in legacy HAL and no longer in sync
442 // with the HIDL interface.
443 return NanStatusType::SUCCESS;
444}
445
446NanResponseType convertLegacyNanResponseTypeToHidl(
447 legacy_hal::NanResponseType type) {
448 switch (type) {
449 case legacy_hal::NAN_RESPONSE_ENABLED:
450 return NanResponseType::ENABLED;
451 case legacy_hal::NAN_RESPONSE_DISABLED:
452 return NanResponseType::DISABLED;
453 case legacy_hal::NAN_RESPONSE_PUBLISH:
454 return NanResponseType::PUBLISH;
455 case legacy_hal::NAN_RESPONSE_PUBLISH_CANCEL:
456 return NanResponseType::PUBLISH_CANCEL;
457 case legacy_hal::NAN_RESPONSE_TRANSMIT_FOLLOWUP:
458 return NanResponseType::TRANSMIT_FOLLOWUP;
459 case legacy_hal::NAN_RESPONSE_SUBSCRIBE:
460 return NanResponseType::SUBSCRIBE;
461 case legacy_hal::NAN_RESPONSE_SUBSCRIBE_CANCEL:
462 return NanResponseType::SUBSCRIBE_CANCEL;
463 case legacy_hal::NAN_RESPONSE_STATS:
464 // Not present in HIDL. Is going to be deprecated in legacy HAL as well.
465 CHECK(0);
466 case legacy_hal::NAN_RESPONSE_CONFIG:
467 return NanResponseType::CONFIG;
468 case legacy_hal::NAN_RESPONSE_TCA:
469 // Not present in HIDL. Is going to be deprecated in legacy HAL as well.
470 CHECK(0);
471 case legacy_hal::NAN_RESPONSE_ERROR:
472 return NanResponseType::ERROR;
473 case legacy_hal::NAN_RESPONSE_BEACON_SDF_PAYLOAD:
474 return NanResponseType::BEACON_SDF_PAYLOAD;
475 case legacy_hal::NAN_GET_CAPABILITIES:
476 return NanResponseType::GET_CAPABILITIES;
477 case legacy_hal::NAN_DP_INTERFACE_CREATE:
478 return NanResponseType::DP_INTERFACE_CREATE;
479 case legacy_hal::NAN_DP_INTERFACE_DELETE:
480 return NanResponseType::DP_INTERFACE_DELETE;
481 case legacy_hal::NAN_DP_INITIATOR_RESPONSE:
482 return NanResponseType::DP_INITIATOR_RESPONSE;
483 case legacy_hal::NAN_DP_RESPONDER_RESPONSE:
484 return NanResponseType::DP_RESPONDER_RESPONSE;
485 case legacy_hal::NAN_DP_END:
486 return NanResponseType::DP_END;
487 };
488}
489
490bool convertHidlNanEnableRequestToLegacy(
491 const NanEnableRequest& hidl_request,
492 legacy_hal::NanEnableRequest* legacy_request) {
493 if (!legacy_request) {
494 return false;
495 }
496 legacy_request->master_pref = hidl_request.masterPref;
497 legacy_request->cluster_low = hidl_request.clusterLow;
498 legacy_request->cluster_high = hidl_request.clusterHigh;
499 legacy_request->config_support_5g = hidl_request.validSupport5gVal;
500 legacy_request->support_5g_val = hidl_request.support5gVal;
501 legacy_request->config_sid_beacon = hidl_request.validSidBeaconVal;
502 legacy_request->sid_beacon_val = hidl_request.sidBeaconVal;
503 legacy_request->config_2dot4g_rssi_close =
504 hidl_request.valid2dot4gRssiCloseVal;
505 legacy_request->rssi_close_2dot4g_val = hidl_request.rssiClose2dot4gVal;
506 legacy_request->config_2dot4g_rssi_middle =
507 hidl_request.valid2dot4gRssiMiddleVal;
508 legacy_request->rssi_middle_2dot4g_val = hidl_request.rssiMiddle2dot4gVal;
509 legacy_request->config_2dot4g_rssi_proximity =
510 hidl_request.valid2dot4gRssiProximityVal;
511 legacy_request->rssi_proximity_2dot4g_val =
512 hidl_request.rssiProximity2dot4gVal;
513 legacy_request->config_hop_count_limit = hidl_request.validHopCountLimitVal;
514 legacy_request->hop_count_limit_val = hidl_request.hopCountLimitVal;
515 legacy_request->config_2dot4g_support = hidl_request.valid2dot4gSupportVal;
516 legacy_request->support_2dot4g_val = hidl_request.support2dot4gVal;
517 legacy_request->config_2dot4g_beacons = hidl_request.valid2dot4gBeaconsVal;
518 legacy_request->beacon_2dot4g_val = hidl_request.beacon2dot4gVal;
519 legacy_request->config_2dot4g_sdf = hidl_request.valid2dot4gSdfVal;
520 legacy_request->sdf_2dot4g_val = hidl_request.sdf2dot4gVal;
521 legacy_request->config_5g_beacons = hidl_request.valid5gBeaconsVal;
522 legacy_request->beacon_5g_val = hidl_request.beacon5gVal;
523 legacy_request->config_5g_sdf = hidl_request.valid5gSdfVal;
524 legacy_request->sdf_5g_val = hidl_request.sdf5gVal;
525 legacy_request->config_5g_rssi_close = hidl_request.valid5gRssiCloseVal;
526 legacy_request->rssi_close_5g_val = hidl_request.rssiClose5gVal;
527 legacy_request->config_5g_rssi_middle = hidl_request.valid5gRssiMiddleVal;
528 legacy_request->rssi_middle_5g_val = hidl_request.rssiMiddle5gVal;
529 legacy_request->config_5g_rssi_close_proximity =
530 hidl_request.valid5gRssiCloseProximityVal;
531 legacy_request->rssi_close_proximity_5g_val =
532 hidl_request.rssiCloseProximity5gVal;
533 legacy_request->config_rssi_window_size = hidl_request.validRssiWindowSizeVal;
534 legacy_request->rssi_window_size_val = hidl_request.rssiWindowSizeVal;
535 legacy_request->config_oui = hidl_request.validOuiVal;
536 legacy_request->oui_val = hidl_request.ouiVal;
537 legacy_request->config_intf_addr = hidl_request.validIntfAddrVal;
538 CHECK(hidl_request.intfAddrVal.size() ==
539 sizeof(legacy_request->intf_addr_val));
540 memcpy(legacy_request->intf_addr_val,
541 hidl_request.intfAddrVal.data(),
542 hidl_request.intfAddrVal.size());
543 legacy_request->config_cluster_attribute_val =
544 hidl_request.configClusterAttributeVal;
545 legacy_request->config_scan_params = hidl_request.validScanParamsVal;
546 if (hidl_request.scanParamsVal.dwellTime.size() >
547 sizeof(legacy_request->scan_params_val.dwell_time)) {
548 return false;
549 }
550 memcpy(legacy_request->scan_params_val.dwell_time,
551 hidl_request.scanParamsVal.dwellTime.data(),
552 hidl_request.scanParamsVal.dwellTime.size());
553 if (hidl_request.scanParamsVal.scanPeriod.size() >
554 sizeof(legacy_request->scan_params_val.scan_period)) {
555 return false;
556 }
557 memcpy(legacy_request->scan_params_val.scan_period,
558 hidl_request.scanParamsVal.scanPeriod.data(),
559 hidl_request.scanParamsVal.scanPeriod.size());
560 legacy_request->config_random_factor_force =
561 hidl_request.validRandomFactorForceVal;
562 legacy_request->random_factor_force_val = hidl_request.randomFactorForceVal;
563 legacy_request->config_hop_count_force = hidl_request.validHopCountLimitVal;
564 legacy_request->hop_count_force_val = hidl_request.hopCountLimitVal;
565 legacy_request->config_24g_channel = hidl_request.valid24gChannelVal;
566 legacy_request->channel_24g_val = hidl_request.channel24gVal;
567 legacy_request->config_5g_channel = hidl_request.valid5gChannelVal;
568 legacy_request->channel_5g_val = hidl_request.channel5gVal;
569 return true;
570}
571
572bool convertHidlNanPublishRequestToLegacy(
573 const NanPublishRequest& hidl_request,
574 legacy_hal::NanPublishRequest* legacy_request) {
575 if (!legacy_request) {
576 return false;
577 }
578 legacy_request->publish_id = hidl_request.publishId;
579 legacy_request->ttl = hidl_request.ttl;
580 legacy_request->period = hidl_request.period;
581 legacy_request->publish_type =
582 convertHidlNanPublishTypeToLegacy(hidl_request.publishType);
583 legacy_request->tx_type = convertHidlNanTxTypeToLegacy(hidl_request.txType);
584 legacy_request->publish_count = hidl_request.publishCount;
585 if (hidl_request.serviceName.size() > sizeof(legacy_request->service_name)) {
586 return false;
587 }
588 legacy_request->service_name_len = hidl_request.serviceName.size();
589 memcpy(legacy_request->service_name,
590 hidl_request.serviceName.c_str(),
591 hidl_request.serviceName.size());
592 legacy_request->publish_match_indicator =
593 convertHidlNanMatchAlgToLegacy(hidl_request.publishMatchIndicator);
594 if (hidl_request.serviceSpecificInfo.size() >
595 sizeof(legacy_request->service_specific_info)) {
596 return false;
597 }
598 legacy_request->service_specific_info_len =
599 hidl_request.serviceSpecificInfo.size();
600 memcpy(legacy_request->service_specific_info,
601 hidl_request.serviceSpecificInfo.data(),
602 hidl_request.serviceSpecificInfo.size());
603 if (hidl_request.rxMatchFilter.size() >
604 sizeof(legacy_request->rx_match_filter)) {
605 return false;
606 }
607 legacy_request->rx_match_filter_len = hidl_request.rxMatchFilter.size();
608 memcpy(legacy_request->rx_match_filter,
609 hidl_request.rxMatchFilter.data(),
610 hidl_request.rxMatchFilter.size());
611 if (hidl_request.txMatchFilter.size() >
612 sizeof(legacy_request->tx_match_filter)) {
613 return false;
614 }
615 legacy_request->tx_match_filter_len = hidl_request.txMatchFilter.size();
616 memcpy(legacy_request->tx_match_filter,
617 hidl_request.txMatchFilter.data(),
618 hidl_request.txMatchFilter.size());
619 legacy_request->rssi_threshold_flag = hidl_request.useRssiThreshold;
620 legacy_request->connmap = hidl_request.connmap;
621 legacy_request->recv_indication_cfg = hidl_request.recvIndicationCfg;
622 return true;
623}
624
625bool convertHidlNanPublishCancelRequestToLegacy(
626 const NanPublishCancelRequest& hidl_request,
627 legacy_hal::NanPublishCancelRequest* legacy_request) {
628 legacy_request->publish_id = hidl_request.publishId;
629 return true;
630}
631
632bool convertHidlNanSubscribeRequestToLegacy(
633 const NanSubscribeRequest& hidl_request,
634 legacy_hal::NanSubscribeRequest* legacy_request) {
635 if (!legacy_request) {
636 return false;
637 }
638 legacy_request->subscribe_id = hidl_request.subscribeId;
639 legacy_request->ttl = hidl_request.ttl;
640 legacy_request->period = hidl_request.period;
641 legacy_request->subscribe_type =
642 convertHidlNanSubscribeTypeToLegacy(hidl_request.subscribeType);
643 legacy_request->serviceResponseFilter =
644 convertHidlNanSrfTypeToLegacy(hidl_request.serviceResponseFilter);
645 legacy_request->serviceResponseInclude =
646 convertHidlNanSrfIncludeTypeToLegacy(hidl_request.serviceResponseInclude);
647 legacy_request->useServiceResponseFilter =
648 hidl_request.shouldUseServiceResponseFilter
649 ? legacy_hal::NAN_USE_SRF
650 : legacy_hal::NAN_DO_NOT_USE_SRF;
651 legacy_request->ssiRequiredForMatchIndication =
652 hidl_request.isSsiRequiredForMatchIndication
653 ? legacy_hal::NAN_SSI_REQUIRED_IN_MATCH_IND
654 : legacy_hal::NAN_SSI_NOT_REQUIRED_IN_MATCH_IND;
655 legacy_request->subscribe_match_indicator =
656 convertHidlNanMatchAlgToLegacy(hidl_request.subscribeMatchIndicator);
657 legacy_request->subscribe_count = hidl_request.subscribeCount;
658 if (hidl_request.serviceName.size() > sizeof(legacy_request->service_name)) {
659 return false;
660 }
661 legacy_request->service_name_len = hidl_request.serviceName.size();
662 memcpy(legacy_request->service_name,
663 hidl_request.serviceName.c_str(),
664 hidl_request.serviceName.size());
665 if (hidl_request.serviceSpecificInfo.size() >
666 sizeof(legacy_request->service_specific_info)) {
667 return false;
668 }
669 legacy_request->service_specific_info_len =
670 hidl_request.serviceSpecificInfo.size();
671 memcpy(legacy_request->service_specific_info,
672 hidl_request.serviceSpecificInfo.data(),
673 hidl_request.serviceSpecificInfo.size());
674 if (hidl_request.rxMatchFilter.size() >
675 sizeof(legacy_request->rx_match_filter)) {
676 return false;
677 }
678 legacy_request->rx_match_filter_len = hidl_request.rxMatchFilter.size();
679 memcpy(legacy_request->rx_match_filter,
680 hidl_request.rxMatchFilter.data(),
681 hidl_request.rxMatchFilter.size());
682 if (hidl_request.txMatchFilter.size() >
683 sizeof(legacy_request->tx_match_filter)) {
684 return false;
685 }
686 legacy_request->tx_match_filter_len = hidl_request.txMatchFilter.size();
687 memcpy(legacy_request->tx_match_filter,
688 hidl_request.txMatchFilter.data(),
689 hidl_request.txMatchFilter.size());
690 legacy_request->rssi_threshold_flag = hidl_request.useRssiThreshold;
691 legacy_request->connmap = hidl_request.connmap;
692 if (hidl_request.intfAddr.size() > NAN_MAX_SUBSCRIBE_MAX_ADDRESS) {
693 return false;
694 }
695 legacy_request->num_intf_addr_present = hidl_request.intfAddr.size();
696 for (uint32_t i = 0; i < hidl_request.intfAddr.size(); i++) {
697 CHECK(hidl_request.intfAddr[i].size() ==
698 sizeof(legacy_request->intf_addr[i]));
699 memcpy(legacy_request->intf_addr[i],
700 hidl_request.intfAddr[i].data(),
701 hidl_request.intfAddr[i].size());
702 }
703 legacy_request->recv_indication_cfg = hidl_request.recvIndicationCfg;
704 return true;
705}
706
707bool convertHidlNanSubscribeCancelRequestToLegacy(
708 const NanSubscribeCancelRequest& /* hidl_request */,
709 legacy_hal::NanSubscribeCancelRequest* /* legacy_request */) {
710 return false;
711}
712
713bool convertHidlNanTransmitFollowupRequestToLegacy(
714 const NanTransmitFollowupRequest& /* hidl_request */,
715 legacy_hal::NanTransmitFollowupRequest* /* legacy_request */) {
716 return false;
717}
718
719bool convertHidlNanConfigRequestToLegacy(
720 const NanConfigRequest& /* hidl_request */,
721 legacy_hal::NanConfigRequest* /* legacy_request */) {
722 return false;
723}
724
725bool convertHidlNanBeaconSdfPayloadRequestToLegacy(
726 const NanBeaconSdfPayloadRequest& /* hidl_request */,
727 legacy_hal::NanBeaconSdfPayloadRequest* /* legacy_request */) {
728 return false;
729}
730
731bool convertHidlNanDataPathInitiatorRequestToLegacy(
732 const NanDataPathInitiatorRequest& /* hidl_request */,
733 legacy_hal::NanDataPathInitiatorRequest* /* legacy_request */) {
734 return false;
735}
736
737bool convertHidlNanDataPathIndicationResponseToLegacy(
738 const NanDataPathIndicationResponse& /* hidl_response */,
739 legacy_hal::NanDataPathIndicationResponse* /* legacy_response */) {
740 return false;
741}
742
743bool convertHidlNanDataPathEndRequestToLegacy(
744 const NanDataPathEndRequest& /* hidl_request */,
745 legacy_hal::NanDataPathEndRequest* /* legacy_request */) {
746 return false;
747}
748
749bool convertLegacyNanResponseHeaderToHidl(
750 const legacy_hal::NanResponseMsg& legacy_response,
751 NanResponseMsgHeader* hidl_response) {
752 if (!hidl_response) {
753 return false;
754 }
755 hidl_response->status =
756 convertLegacyNanStatusTypeToHidl(legacy_response.status);
757 hidl_response->value = legacy_response.value;
758 hidl_response->responseType =
759 convertLegacyNanResponseTypeToHidl(legacy_response.response_type);
760 return true;
761}
762
763bool convertLegacyNanPublishResponseToHidl(
764 const legacy_hal::NanPublishResponse& /* legacy_response */,
765 NanPublishResponse* /* hidl_response */) {
766 return false;
767}
768
769bool convertLegacyNanSubscribeResponseToHidl(
770 const legacy_hal::NanSubscribeResponse& /* legacy_response */,
771 NanSubscribeResponse* /* hidl_response */) {
772 return false;
773}
774
775bool convertLegacyNanDataPathResponseToHidl(
776 const legacy_hal::NanDataPathRequestResponse& /* legacy_response */,
777 NanDataPathResponse* /* hidl_response */) {
778 return false;
779}
780
781bool convertLegacyNanCapabilitiesResponseToHidl(
782 const legacy_hal::NanCapabilities& /* legacy_response */,
783 NanCapabilitiesResponse* /* hidl_response */) {
784 return false;
785}
786
787bool convertLegacyNanPublishTerminatedIndToHidl(
788 const legacy_hal::NanPublishTerminatedInd& /* legacy_ind */,
789 NanPublishTerminatedInd* /* hidl_ind */) {
790 return false;
791}
792
793bool convertLegacyNanMatchIndToHidl(
794 const legacy_hal::NanMatchInd& /* legacy_ind */,
795 NanMatchInd* /* hidl_ind */) {
796 return false;
797}
798
799bool convertLegacyNanMatchExpiredIndToHidl(
800 const legacy_hal::NanMatchExpiredInd& /* legacy_ind */,
801 NanMatchExpiredInd* /* hidl_ind */) {
802 return false;
803}
804
805bool convertLegacyNanSubscribeTerminatedIndToHidl(
806 const legacy_hal::NanSubscribeTerminatedInd& /* legacy_ind */,
807 NanSubscribeTerminatedInd* /* hidl_ind */) {
808 return false;
809}
810
811bool convertLegacyNanFollowupIndToHidl(
812 const legacy_hal::NanFollowupInd& /* legacy_ind */,
813 NanFollowupInd* /* hidl_ind */) {
814 return false;
815}
816
817bool convertLegacyNanDiscEngEventIndToHidl(
818 const legacy_hal::NanDiscEngEventInd& /* legacy_ind */,
819 NanDiscEngEventInd* /* hidl_ind */) {
820 return false;
821}
822
823bool convertLegacyNanDisabledIndToHidl(
824 const legacy_hal::NanDisabledInd& /* legacy_ind */,
825 NanDisabledInd* /* hidl_ind */) {
826 return false;
827}
828
829bool convertLegacyNanBeaconSdfPayloadIndToHidl(
830 const legacy_hal::NanBeaconSdfPayloadInd& /* legacy_ind */,
831 NanBeaconSdfPayloadInd* /* hidl_ind */) {
832 return false;
833}
834
835bool convertLegacyNanDataPathRequestIndToHidl(
836 const legacy_hal::NanDataPathRequestInd& /* legacy_ind */,
837 NanDataPathRequestInd* /* hidl_ind */) {
838 return false;
839}
840
841bool convertLegacyNanDataPathConfirmIndToHidl(
842 const legacy_hal::NanDataPathConfirmInd& /* legacy_ind */,
843 NanDataPathConfirmInd* /* hidl_ind */) {
844 return false;
845}
846
847bool convertLegacyNanDataPathEndIndToHidl(
848 const legacy_hal::NanDataPathEndInd& /* legacy_ind */,
849 NanDataPathEndInd* /* hidl_ind */) {
850 return false;
851}
852
853bool convertLegacyNanTransmitFollowupIndToHidl(
854 const legacy_hal::NanTransmitFollowupInd& /* legacy_ind */,
855 NanTransmitFollowupInd* /* hidl_ind */) {
856 return false;
857}
Roshan Piuse65edb12016-11-22 13:02:01 -0800858} // namespace hidl_struct_util
859} // namespace implementation
860} // namespace V1_0
861} // namespace wifi
862} // namespace hardware
863} // namespace android