diff --git a/wifi/1.0/default/Android.mk b/wifi/1.0/default/Android.mk
index 62d2e0b..931a314 100644
--- a/wifi/1.0/default/Android.mk
+++ b/wifi/1.0/default/Android.mk
@@ -18,6 +18,7 @@
 LOCAL_MODULE_RELATIVE_PATH := hw
 LOCAL_CPPFLAGS := -Wall -Wno-unused-parameter -Werror -Wextra
 LOCAL_SRC_FILES := \
+    hidl_struct_util.cpp \
     service.cpp \
     wifi.cpp \
     wifi_ap_iface.cpp \
diff --git a/wifi/1.0/default/hidl_struct_util.cpp b/wifi/1.0/default/hidl_struct_util.cpp
new file mode 100644
index 0000000..b4dcc0a
--- /dev/null
+++ b/wifi/1.0/default/hidl_struct_util.cpp
@@ -0,0 +1,259 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <android-base/logging.h>
+#include <utils/SystemClock.h>
+
+#include "hidl_struct_util.h"
+
+namespace android {
+namespace hardware {
+namespace wifi {
+namespace V1_0 {
+namespace implementation {
+namespace hidl_struct_util {
+
+uint8_t ConvertHidlReportEventFlagToLegacy(
+    StaBackgroundScanBucketEventReportSchemeMask hidl_flag) {
+  using HidlFlag = StaBackgroundScanBucketEventReportSchemeMask;
+  switch (hidl_flag) {
+    case HidlFlag::EACH_SCAN:
+      return REPORT_EVENTS_EACH_SCAN;
+    case HidlFlag::FULL_RESULTS:
+      return REPORT_EVENTS_FULL_RESULTS;
+    case HidlFlag::NO_BATCH:
+      return REPORT_EVENTS_NO_BATCH;
+  };
+}
+
+bool convertHidlScanParamsToLegacy(
+    const StaBackgroundScanParameters& hidl_scan_params,
+    legacy_hal::wifi_scan_cmd_params* legacy_scan_params) {
+  if (!legacy_scan_params) {
+    return false;
+  }
+  legacy_scan_params->base_period = hidl_scan_params.basePeriodInMs;
+  legacy_scan_params->max_ap_per_scan = hidl_scan_params.maxApPerScan;
+  legacy_scan_params->report_threshold_percent =
+      hidl_scan_params.reportThresholdPercent;
+  legacy_scan_params->report_threshold_num_scans =
+      hidl_scan_params.reportThresholdNumScans;
+  // TODO(b/33194311): Expose these max limits in the HIDL interface.
+  if (hidl_scan_params.buckets.size() > MAX_BUCKETS) {
+    return false;
+  }
+  legacy_scan_params->num_buckets = hidl_scan_params.buckets.size();
+  for (uint32_t bucket_idx = 0; bucket_idx < hidl_scan_params.buckets.size();
+       bucket_idx++) {
+    const StaBackgroundScanBucketParameters& hidl_bucket_spec =
+        hidl_scan_params.buckets[bucket_idx];
+    legacy_hal::wifi_scan_bucket_spec& legacy_bucket_spec =
+        legacy_scan_params->buckets[bucket_idx];
+    legacy_bucket_spec.bucket = bucket_idx;
+    legacy_bucket_spec.band =
+        static_cast<legacy_hal::wifi_band>(hidl_bucket_spec.band);
+    legacy_bucket_spec.period = hidl_bucket_spec.periodInMs;
+    legacy_bucket_spec.max_period = hidl_bucket_spec.exponentialMaxPeriodInMs;
+    legacy_bucket_spec.base = hidl_bucket_spec.exponentialBase;
+    legacy_bucket_spec.step_count = hidl_bucket_spec.exponentialStepCount;
+    legacy_bucket_spec.report_events = 0;
+    using HidlFlag = StaBackgroundScanBucketEventReportSchemeMask;
+    for (const auto flag :
+         {HidlFlag::EACH_SCAN, HidlFlag::FULL_RESULTS, HidlFlag::NO_BATCH}) {
+      if (hidl_bucket_spec.eventReportScheme &
+          static_cast<std::underlying_type<HidlFlag>::type>(flag)) {
+        legacy_bucket_spec.report_events |=
+            ConvertHidlReportEventFlagToLegacy(flag);
+      }
+    }
+    // TODO(b/33194311): Expose these max limits in the HIDL interface.
+    if (hidl_bucket_spec.frequencies.size() > MAX_CHANNELS) {
+      return false;
+    }
+    legacy_bucket_spec.num_channels = hidl_bucket_spec.frequencies.size();
+    for (uint32_t freq_idx = 0; freq_idx < hidl_bucket_spec.frequencies.size();
+         freq_idx++) {
+      legacy_bucket_spec.channels[freq_idx].channel =
+          hidl_bucket_spec.frequencies[freq_idx];
+    }
+  }
+  return true;
+}
+
+bool convertLegacyIeBlobToHidl(const uint8_t* ie_blob,
+                               uint32_t ie_blob_len,
+                               std::vector<WifiInformationElement>* hidl_ies) {
+  if (!ie_blob || !hidl_ies) {
+    return false;
+  }
+  const uint8_t* ies_begin = ie_blob;
+  const uint8_t* ies_end = ie_blob + ie_blob_len;
+  const uint8_t* next_ie = ies_begin;
+  using wifi_ie = legacy_hal::wifi_information_element;
+  constexpr size_t kIeHeaderLen = sizeof(wifi_ie);
+  // Each IE should atleast have the header (i.e |id| & |len| fields).
+  while (next_ie + kIeHeaderLen <= ies_end) {
+    const wifi_ie& legacy_ie = (*reinterpret_cast<const wifi_ie*>(next_ie));
+    uint32_t curr_ie_len = kIeHeaderLen + legacy_ie.len;
+    if (next_ie + curr_ie_len > ies_end) {
+      return false;
+    }
+    WifiInformationElement hidl_ie;
+    hidl_ie.id = legacy_ie.id;
+    hidl_ie.data =
+        std::vector<uint8_t>(legacy_ie.data, legacy_ie.data + legacy_ie.len);
+    hidl_ies->push_back(std::move(hidl_ie));
+    next_ie += curr_ie_len;
+  }
+  // Ensure that the blob has been fully consumed.
+  return (next_ie == ies_end);
+}
+
+bool convertLegacyScanResultToHidl(
+    const legacy_hal::wifi_scan_result& legacy_scan_result,
+    bool has_ie_data,
+    StaScanResult* hidl_scan_result) {
+  if (!hidl_scan_result) {
+    return false;
+  }
+  hidl_scan_result->timeStampInUs = legacy_scan_result.ts;
+  hidl_scan_result->ssid = std::vector<uint8_t>(
+      legacy_scan_result.ssid,
+      legacy_scan_result.ssid + sizeof(legacy_scan_result.ssid));
+  memcpy(hidl_scan_result->bssid.data(),
+         legacy_scan_result.bssid,
+         hidl_scan_result->bssid.size());
+  hidl_scan_result->frequency = legacy_scan_result.channel;
+  hidl_scan_result->rssi = legacy_scan_result.rssi;
+  hidl_scan_result->beaconPeriodInMs = legacy_scan_result.beacon_period;
+  hidl_scan_result->capability = legacy_scan_result.capability;
+  if (has_ie_data) {
+    std::vector<WifiInformationElement> ies;
+    if (!convertLegacyIeBlobToHidl(
+            reinterpret_cast<const uint8_t*>(legacy_scan_result.ie_data),
+            legacy_scan_result.ie_length,
+            &ies)) {
+      return false;
+    }
+    hidl_scan_result->informationElements = std::move(ies);
+  }
+  return true;
+}
+
+bool convertLegacyCachedScanResultsToHidl(
+    const legacy_hal::wifi_cached_scan_results& legacy_cached_scan_result,
+    StaScanData* hidl_scan_data) {
+  if (!hidl_scan_data) {
+    return false;
+  }
+  hidl_scan_data->flags = legacy_cached_scan_result.flags;
+  hidl_scan_data->bucketsScanned = legacy_cached_scan_result.buckets_scanned;
+
+  CHECK(legacy_cached_scan_result.num_results >= 0 &&
+        legacy_cached_scan_result.num_results <= MAX_AP_CACHE_PER_SCAN);
+  std::vector<StaScanResult> hidl_scan_results;
+  for (int32_t result_idx = 0;
+       result_idx < legacy_cached_scan_result.num_results;
+       result_idx++) {
+    StaScanResult hidl_scan_result;
+    if (!convertLegacyScanResultToHidl(
+            legacy_cached_scan_result.results[result_idx],
+            false,
+            &hidl_scan_result)) {
+      return false;
+    }
+    hidl_scan_results.push_back(hidl_scan_result);
+  }
+  hidl_scan_data->results = std::move(hidl_scan_results);
+  return true;
+}
+
+bool convertLegacyVectorOfCachedScanResultsToHidl(
+    const std::vector<legacy_hal::wifi_cached_scan_results>&
+        legacy_cached_scan_results,
+    std::vector<StaScanData>* hidl_scan_datas) {
+  if (!hidl_scan_datas) {
+    return false;
+  }
+  for (const auto& legacy_cached_scan_result : legacy_cached_scan_results) {
+    StaScanData hidl_scan_data;
+    if (!convertLegacyCachedScanResultsToHidl(legacy_cached_scan_result,
+                                              &hidl_scan_data)) {
+      return false;
+    }
+    hidl_scan_datas->push_back(hidl_scan_data);
+  }
+  return true;
+}
+
+bool convertLegacyLinkLayerStatsToHidl(
+    const legacy_hal::LinkLayerStats& legacy_stats,
+    StaLinkLayerStats* hidl_stats) {
+  if (!hidl_stats) {
+    return false;
+  }
+  // iface legacy_stats conversion.
+  hidl_stats->iface.beaconRx = legacy_stats.iface.beacon_rx;
+  hidl_stats->iface.avgRssiMgmt = legacy_stats.iface.rssi_mgmt;
+  hidl_stats->iface.wmeBePktStats.rxMpdu =
+      legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].rx_mpdu;
+  hidl_stats->iface.wmeBePktStats.txMpdu =
+      legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].tx_mpdu;
+  hidl_stats->iface.wmeBePktStats.lostMpdu =
+      legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].mpdu_lost;
+  hidl_stats->iface.wmeBePktStats.retries =
+      legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].retries;
+  hidl_stats->iface.wmeBkPktStats.rxMpdu =
+      legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].rx_mpdu;
+  hidl_stats->iface.wmeBkPktStats.txMpdu =
+      legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].tx_mpdu;
+  hidl_stats->iface.wmeBkPktStats.lostMpdu =
+      legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].mpdu_lost;
+  hidl_stats->iface.wmeBkPktStats.retries =
+      legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].retries;
+  hidl_stats->iface.wmeViPktStats.rxMpdu =
+      legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].rx_mpdu;
+  hidl_stats->iface.wmeViPktStats.txMpdu =
+      legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].tx_mpdu;
+  hidl_stats->iface.wmeViPktStats.lostMpdu =
+      legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].mpdu_lost;
+  hidl_stats->iface.wmeViPktStats.retries =
+      legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].retries;
+  hidl_stats->iface.wmeVoPktStats.rxMpdu =
+      legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].rx_mpdu;
+  hidl_stats->iface.wmeVoPktStats.txMpdu =
+      legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].tx_mpdu;
+  hidl_stats->iface.wmeVoPktStats.lostMpdu =
+      legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].mpdu_lost;
+  hidl_stats->iface.wmeVoPktStats.retries =
+      legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].retries;
+  // radio legacy_stats conversion.
+  hidl_stats->radio.onTimeInMs = legacy_stats.radio.on_time;
+  hidl_stats->radio.txTimeInMs = legacy_stats.radio.tx_time;
+  hidl_stats->radio.rxTimeInMs = legacy_stats.radio.rx_time;
+  hidl_stats->radio.onTimeInMsForScan = legacy_stats.radio.on_time_scan;
+  hidl_stats->radio.txTimeInMsPerLevel = legacy_stats.radio_tx_time_per_levels;
+  // Timestamp in the HAL wrapper here since it's not provided in the legacy
+  // HAL API.
+  hidl_stats->timeStampInMs = uptimeMillis();
+  return true;
+}
+}  // namespace hidl_struct_util
+}  // namespace implementation
+}  // namespace V1_0
+}  // namespace wifi
+}  // namespace hardware
+}  // namespace android
diff --git a/wifi/1.0/default/hidl_struct_util.h b/wifi/1.0/default/hidl_struct_util.h
new file mode 100644
index 0000000..6c91e03
--- /dev/null
+++ b/wifi/1.0/default/hidl_struct_util.h
@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef HIDL_STRUCT_UTIL_H_
+#define HIDL_STRUCT_UTIL_H_
+
+#include <vector>
+
+#include <android/hardware/wifi/1.0/IWifi.h>
+
+#include "wifi_legacy_hal.h"
+
+/**
+ * This file contains a bunch of functions to convert structs from the legacy
+ * HAL to HIDL and vice versa.
+ * TODO(b/32093047): Add unit tests for these conversion methods in the VTS test
+ * suite.
+ */
+namespace android {
+namespace hardware {
+namespace wifi {
+namespace V1_0 {
+namespace implementation {
+namespace hidl_struct_util {
+
+// Convert hidl gscan params to legacy gscan params.
+bool convertHidlScanParamsToLegacy(
+    const StaBackgroundScanParameters& hidl_scan_params,
+    legacy_hal::wifi_scan_cmd_params* legacy_scan_params);
+// Convert the blob of packed IE elements to vector of
+// |WifiInformationElement| structures.
+bool convertLegacyIeBlobToHidl(const uint8_t* ie_blob,
+                               uint32_t ie_blob_len,
+                               std::vector<WifiInformationElement>* hidl_ies);
+// |has_ie_data| indicates whether or not the wifi_scan_result includes 802.11
+// Information Elements (IEs)
+bool convertLegacyScanResultToHidl(
+    const legacy_hal::wifi_scan_result& legacy_scan_result,
+    bool has_ie_data,
+    StaScanResult* hidl_scan_result);
+// |cached_results| is assumed to not include IEs.
+bool convertLegacyVectorOfCachedScanResultsToHidl(
+    const std::vector<legacy_hal::wifi_cached_scan_results>&
+        legacy_cached_scan_results,
+    std::vector<StaScanData>* hidl_scan_datas);
+bool convertLegacyLinkLayerStatsToHidl(
+    const legacy_hal::LinkLayerStats& legacy_stats,
+    StaLinkLayerStats* hidl_stats);
+}  // namespace hidl_struct_util
+}  // namespace implementation
+}  // namespace V1_0
+}  // namespace wifi
+}  // namespace hardware
+}  // namespace android
+
+#endif  // HIDL_STRUCT_UTIL_H_
diff --git a/wifi/1.0/default/wifi.cpp b/wifi/1.0/default/wifi.cpp
index 3475c46..19f7e53 100644
--- a/wifi/1.0/default/wifi.cpp
+++ b/wifi/1.0/default/wifi.cpp
@@ -98,8 +98,8 @@
   }
 
   LOG(INFO) << "Starting HAL";
-  wifi_error legacy_status = legacy_hal_->start();
-  if (legacy_status != WIFI_SUCCESS) {
+  legacy_hal::wifi_error legacy_status = legacy_hal_->start();
+  if (legacy_status != legacy_hal::WIFI_SUCCESS) {
     LOG(ERROR) << "Failed to start Wifi HAL: "
                << legacyErrorToString(legacy_status);
     return createWifiStatusFromLegacyError(legacy_status,
@@ -139,8 +139,9 @@
       };
     }
   };
-  wifi_error legacy_status = legacy_hal_->stop(on_complete_callback_);
-  if (legacy_status != WIFI_SUCCESS) {
+  legacy_hal::wifi_error legacy_status =
+      legacy_hal_->stop(on_complete_callback_);
+  if (legacy_status != legacy_hal::WIFI_SUCCESS) {
     LOG(ERROR) << "Failed to stop Wifi HAL: "
                << legacyErrorToString(legacy_status);
     WifiStatus wifi_status =
diff --git a/wifi/1.0/default/wifi_chip.cpp b/wifi/1.0/default/wifi_chip.cpp
index 4d1bce5..3ab6052 100644
--- a/wifi/1.0/default/wifi_chip.cpp
+++ b/wifi/1.0/default/wifi_chip.cpp
@@ -319,10 +319,10 @@
 std::pair<WifiStatus, IWifiChip::ChipDebugInfo>
 WifiChip::requestChipDebugInfoInternal() {
   IWifiChip::ChipDebugInfo result;
-  wifi_error legacy_status;
+  legacy_hal::wifi_error legacy_status;
   std::string driver_desc;
   std::tie(legacy_status, driver_desc) = legacy_hal_.lock()->getDriverVersion();
-  if (legacy_status != WIFI_SUCCESS) {
+  if (legacy_status != legacy_hal::WIFI_SUCCESS) {
     LOG(ERROR) << "Failed to get driver version: "
                << legacyErrorToString(legacy_status);
     WifiStatus status = createWifiStatusFromLegacyError(
@@ -334,7 +334,7 @@
   std::string firmware_desc;
   std::tie(legacy_status, firmware_desc) =
       legacy_hal_.lock()->getFirmwareVersion();
-  if (legacy_status != WIFI_SUCCESS) {
+  if (legacy_status != legacy_hal::WIFI_SUCCESS) {
     LOG(ERROR) << "Failed to get firmware version: "
                << legacyErrorToString(legacy_status);
     WifiStatus status = createWifiStatusFromLegacyError(
@@ -348,11 +348,11 @@
 
 std::pair<WifiStatus, std::vector<uint8_t>>
 WifiChip::requestDriverDebugDumpInternal() {
-  wifi_error legacy_status;
+  legacy_hal::wifi_error legacy_status;
   std::vector<uint8_t> driver_dump;
   std::tie(legacy_status, driver_dump) =
       legacy_hal_.lock()->requestDriverMemoryDump();
-  if (legacy_status != WIFI_SUCCESS) {
+  if (legacy_status != legacy_hal::WIFI_SUCCESS) {
     LOG(ERROR) << "Failed to get driver debug dump: "
                << legacyErrorToString(legacy_status);
     return {createWifiStatusFromLegacyError(legacy_status),
@@ -363,11 +363,11 @@
 
 std::pair<WifiStatus, std::vector<uint8_t>>
 WifiChip::requestFirmwareDebugDumpInternal() {
-  wifi_error legacy_status;
+  legacy_hal::wifi_error legacy_status;
   std::vector<uint8_t> firmware_dump;
   std::tie(legacy_status, firmware_dump) =
       legacy_hal_.lock()->requestFirmwareMemoryDump();
-  if (legacy_status != WIFI_SUCCESS) {
+  if (legacy_status != legacy_hal::WIFI_SUCCESS) {
     LOG(ERROR) << "Failed to get firmware debug dump: "
                << legacyErrorToString(legacy_status);
     return {createWifiStatusFromLegacyError(legacy_status), {}};
diff --git a/wifi/1.0/default/wifi_status_util.cpp b/wifi/1.0/default/wifi_status_util.cpp
index 34a1c1d..9a7ad0d 100644
--- a/wifi/1.0/default/wifi_status_util.cpp
+++ b/wifi/1.0/default/wifi_status_util.cpp
@@ -22,27 +22,27 @@
 namespace V1_0 {
 namespace implementation {
 
-std::string legacyErrorToString(wifi_error error) {
+std::string legacyErrorToString(legacy_hal::wifi_error error) {
   switch (error) {
-    case WIFI_SUCCESS:
+    case legacy_hal::WIFI_SUCCESS:
       return "SUCCESS";
-    case WIFI_ERROR_UNINITIALIZED:
+    case legacy_hal::WIFI_ERROR_UNINITIALIZED:
       return "UNINITIALIZED";
-    case WIFI_ERROR_NOT_AVAILABLE:
+    case legacy_hal::WIFI_ERROR_NOT_AVAILABLE:
       return "NOT_AVAILABLE";
-    case WIFI_ERROR_NOT_SUPPORTED:
+    case legacy_hal::WIFI_ERROR_NOT_SUPPORTED:
       return "NOT_SUPPORTED";
-    case WIFI_ERROR_INVALID_ARGS:
+    case legacy_hal::WIFI_ERROR_INVALID_ARGS:
       return "INVALID_ARGS";
-    case WIFI_ERROR_INVALID_REQUEST_ID:
+    case legacy_hal::WIFI_ERROR_INVALID_REQUEST_ID:
       return "INVALID_REQUEST_ID";
-    case WIFI_ERROR_TIMED_OUT:
+    case legacy_hal::WIFI_ERROR_TIMED_OUT:
       return "TIMED_OUT";
-    case WIFI_ERROR_TOO_MANY_REQUESTS:
+    case legacy_hal::WIFI_ERROR_TOO_MANY_REQUESTS:
       return "TOO_MANY_REQUESTS";
-    case WIFI_ERROR_OUT_OF_MEMORY:
+    case legacy_hal::WIFI_ERROR_OUT_OF_MEMORY:
       return "OUT_OF_MEMORY";
-    case WIFI_ERROR_UNKNOWN:
+    case legacy_hal::WIFI_ERROR_UNKNOWN:
     default:
       return "UNKNOWN";
   }
@@ -57,42 +57,42 @@
   return createWifiStatus(code, "");
 }
 
-WifiStatus createWifiStatusFromLegacyError(wifi_error error,
+WifiStatus createWifiStatusFromLegacyError(legacy_hal::wifi_error error,
                                            const std::string& desc) {
   switch (error) {
-    case WIFI_ERROR_UNINITIALIZED:
-    case WIFI_ERROR_NOT_AVAILABLE:
+    case legacy_hal::WIFI_ERROR_UNINITIALIZED:
+    case legacy_hal::WIFI_ERROR_NOT_AVAILABLE:
       return createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE, desc);
 
-    case WIFI_ERROR_NOT_SUPPORTED:
+    case legacy_hal::WIFI_ERROR_NOT_SUPPORTED:
       return createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED, desc);
 
-    case WIFI_ERROR_INVALID_ARGS:
-    case WIFI_ERROR_INVALID_REQUEST_ID:
+    case legacy_hal::WIFI_ERROR_INVALID_ARGS:
+    case legacy_hal::WIFI_ERROR_INVALID_REQUEST_ID:
       return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS, desc);
 
-    case WIFI_ERROR_TIMED_OUT:
+    case legacy_hal::WIFI_ERROR_TIMED_OUT:
       return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN,
                               desc + ", timed out");
 
-    case WIFI_ERROR_TOO_MANY_REQUESTS:
+    case legacy_hal::WIFI_ERROR_TOO_MANY_REQUESTS:
       return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN,
                               desc + ", too many requests");
 
-    case WIFI_ERROR_OUT_OF_MEMORY:
+    case legacy_hal::WIFI_ERROR_OUT_OF_MEMORY:
       return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN,
                               desc + ", out of memory");
 
-    case WIFI_ERROR_NONE:
+    case legacy_hal::WIFI_ERROR_NONE:
       return createWifiStatus(WifiStatusCode::SUCCESS, desc);
 
-    case WIFI_ERROR_UNKNOWN:
+    case legacy_hal::WIFI_ERROR_UNKNOWN:
     default:
       return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN, "unknown");
   }
 }
 
-WifiStatus createWifiStatusFromLegacyError(wifi_error error) {
+WifiStatus createWifiStatusFromLegacyError(legacy_hal::wifi_error error) {
   return createWifiStatusFromLegacyError(error, "");
 }
 
diff --git a/wifi/1.0/default/wifi_status_util.h b/wifi/1.0/default/wifi_status_util.h
index c988b05..7f557e0 100644
--- a/wifi/1.0/default/wifi_status_util.h
+++ b/wifi/1.0/default/wifi_status_util.h
@@ -18,7 +18,8 @@
 #define WIFI_STATUS_UTIL_H_
 
 #include <android/hardware/wifi/1.0/IWifi.h>
-#include <hardware_legacy/wifi_hal.h>
+
+#include "wifi_legacy_hal.h"
 
 namespace android {
 namespace hardware {
@@ -26,13 +27,13 @@
 namespace V1_0 {
 namespace implementation {
 
-std::string legacyErrorToString(wifi_error error);
+std::string legacyErrorToString(legacy_hal::wifi_error error);
 WifiStatus createWifiStatus(WifiStatusCode code,
                             const std::string& description);
 WifiStatus createWifiStatus(WifiStatusCode code);
-WifiStatus createWifiStatusFromLegacyError(wifi_error error,
+WifiStatus createWifiStatusFromLegacyError(legacy_hal::wifi_error error,
                                            const std::string& description);
-WifiStatus createWifiStatusFromLegacyError(wifi_error error);
+WifiStatus createWifiStatusFromLegacyError(legacy_hal::wifi_error error);
 
 }  // namespace implementation
 }  // namespace V1_0