diff --git a/wifi/1.0/default/wifi_legacy_hal.cpp b/wifi/1.0/default/wifi_legacy_hal.cpp
index 135e2c5..46482aa 100644
--- a/wifi/1.0/default/wifi_legacy_hal.cpp
+++ b/wifi/1.0/default/wifi_legacy_hal.cpp
@@ -112,6 +112,18 @@
   }
 }
 
+// Callback to be invoked for rtt results results.
+std::function<void(
+    wifi_request_id, unsigned num_results, wifi_rtt_result* rtt_results[])>
+    on_rtt_results_internal_callback;
+void onRttResults(wifi_request_id id,
+                  unsigned num_results,
+                  wifi_rtt_result* rtt_results[]) {
+  if (on_rtt_results_internal_callback) {
+    on_rtt_results_internal_callback(id, num_results, rtt_results);
+  }
+}
+
 // End of the free-standing "C" style callbacks.
 
 WifiLegacyHal::WifiLegacyHal()
@@ -549,6 +561,108 @@
                                                ring_name_internal.data());
 }
 
+wifi_error WifiLegacyHal::startRttRangeRequest(
+    wifi_request_id id,
+    const std::vector<wifi_rtt_config>& rtt_configs,
+    const on_rtt_results_callback& on_results_user_callback) {
+  if (on_rtt_results_internal_callback) {
+    return WIFI_ERROR_NOT_AVAILABLE;
+  }
+
+  on_rtt_results_internal_callback = [on_results_user_callback](
+      wifi_request_id id,
+      unsigned num_results,
+      wifi_rtt_result* rtt_results[]) {
+    if (num_results > 0 && !rtt_results) {
+      LOG(ERROR) << "Unexpected nullptr in RTT results";
+      return;
+    }
+    std::vector<const wifi_rtt_result*> rtt_results_vec;
+    std::copy_if(
+        rtt_results,
+        rtt_results + num_results,
+        back_inserter(rtt_results_vec),
+        [](wifi_rtt_result* rtt_result) { return rtt_result != nullptr; });
+    on_results_user_callback(id, rtt_results_vec);
+  };
+
+  std::vector<wifi_rtt_config> rtt_configs_internal(rtt_configs);
+  return global_func_table_.wifi_rtt_range_request(id,
+                                                   wlan_interface_handle_,
+                                                   rtt_configs.size(),
+                                                   rtt_configs_internal.data(),
+                                                   {onRttResults});
+}
+
+wifi_error WifiLegacyHal::cancelRttRangeRequest(
+    wifi_request_id id, const std::vector<std::array<uint8_t, 6>>& mac_addrs) {
+  if (!on_rtt_results_internal_callback) {
+    return WIFI_ERROR_NOT_AVAILABLE;
+  }
+  static_assert(sizeof(mac_addr) == sizeof(std::array<uint8_t, 6>),
+                "MAC address size mismatch");
+  // TODO: How do we handle partial cancels (i.e only a subset of enabled mac
+  // addressed are cancelled).
+  std::vector<std::array<uint8_t, 6>> mac_addrs_internal(mac_addrs);
+  wifi_error status = global_func_table_.wifi_rtt_range_cancel(
+      id,
+      wlan_interface_handle_,
+      mac_addrs.size(),
+      reinterpret_cast<mac_addr*>(mac_addrs_internal.data()));
+  // If the request Id is wrong, don't stop the ongoing range request. Any
+  // other error should be treated as the end of rtt ranging.
+  if (status != WIFI_ERROR_INVALID_REQUEST_ID) {
+    on_rtt_results_internal_callback = nullptr;
+  }
+  return status;
+}
+
+std::pair<wifi_error, wifi_rtt_capabilities>
+WifiLegacyHal::getRttCapabilities() {
+  wifi_rtt_capabilities rtt_caps;
+  wifi_error status = global_func_table_.wifi_get_rtt_capabilities(
+      wlan_interface_handle_, &rtt_caps);
+  return {status, rtt_caps};
+}
+
+std::pair<wifi_error, wifi_rtt_responder> WifiLegacyHal::getRttResponderInfo() {
+  wifi_rtt_responder rtt_responder;
+  wifi_error status = global_func_table_.wifi_rtt_get_responder_info(
+      wlan_interface_handle_, &rtt_responder);
+  return {status, rtt_responder};
+}
+
+wifi_error WifiLegacyHal::enableRttResponder(
+    wifi_request_id id,
+    const wifi_channel_info& channel_hint,
+    uint32_t max_duration_secs,
+    const wifi_rtt_responder& info) {
+  wifi_rtt_responder info_internal(info);
+  return global_func_table_.wifi_enable_responder(id,
+                                                  wlan_interface_handle_,
+                                                  channel_hint,
+                                                  max_duration_secs,
+                                                  &info_internal);
+}
+
+wifi_error WifiLegacyHal::disableRttResponder(wifi_request_id id) {
+  return global_func_table_.wifi_disable_responder(id, wlan_interface_handle_);
+}
+
+wifi_error WifiLegacyHal::setRttLci(wifi_request_id id,
+                                    const wifi_lci_information& info) {
+  wifi_lci_information info_internal(info);
+  return global_func_table_.wifi_set_lci(
+      id, wlan_interface_handle_, &info_internal);
+}
+
+wifi_error WifiLegacyHal::setRttLcr(wifi_request_id id,
+                                    const wifi_lcr_information& info) {
+  wifi_lcr_information info_internal(info);
+  return global_func_table_.wifi_set_lcr(
+      id, wlan_interface_handle_, &info_internal);
+}
+
 wifi_error WifiLegacyHal::retrieveWlanInterfaceHandle() {
   const std::string& ifname_to_find = getStaIfaceName();
   wifi_interface_handle* iface_handles = nullptr;
@@ -627,6 +741,7 @@
   on_gscan_full_result_internal_callback = nullptr;
   on_link_layer_stats_result_internal_callback = nullptr;
   on_ring_buffer_data_internal_callback = nullptr;
+  on_rtt_results_internal_callback = nullptr;
 }
 
 }  // namespace legacy_hal
diff --git a/wifi/1.0/default/wifi_legacy_hal.h b/wifi/1.0/default/wifi_legacy_hal.h
index 3dc98ad..0bb78b2 100644
--- a/wifi/1.0/default/wifi_legacy_hal.h
+++ b/wifi/1.0/default/wifi_legacy_hal.h
@@ -75,6 +75,13 @@
 using on_gscan_results_callback = std::function<void(
     wifi_request_id, const std::vector<wifi_cached_scan_results>&)>;
 
+// Callback for RTT range request results.
+// Rtt results contain IE info and are hence passed by reference, to
+// preserve the |LCI| and |LCR| pointers. Callee must not retain
+// the pointer.
+using on_rtt_results_callback = std::function<void(
+    wifi_request_id, const std::vector<const wifi_rtt_result*>&)>;
+
 // Callback for ring buffer data.
 using on_ring_buffer_data_callback =
     std::function<void(const std::string&,
@@ -147,6 +154,22 @@
                                     uint32_t max_interval_sec,
                                     uint32_t min_data_size);
   wifi_error getRingBufferData(const std::string& ring_name);
+  // RTT functions.
+  wifi_error startRttRangeRequest(
+      wifi_request_id id,
+      const std::vector<wifi_rtt_config>& rtt_configs,
+      const on_rtt_results_callback& on_results_callback);
+  wifi_error cancelRttRangeRequest(
+      wifi_request_id id, const std::vector<std::array<uint8_t, 6>>& mac_addrs);
+  std::pair<wifi_error, wifi_rtt_capabilities> getRttCapabilities();
+  std::pair<wifi_error, wifi_rtt_responder> getRttResponderInfo();
+  wifi_error enableRttResponder(wifi_request_id id,
+                                const wifi_channel_info& channel_hint,
+                                uint32_t max_duration_secs,
+                                const wifi_rtt_responder& info);
+  wifi_error disableRttResponder(wifi_request_id id);
+  wifi_error setRttLci(wifi_request_id id, const wifi_lci_information& info);
+  wifi_error setRttLcr(wifi_request_id id, const wifi_lcr_information& info);
 
  private:
   // Retrieve the interface handle to be used for the "wlan" interface.