diff --git a/Android.mk b/Android.mk
index 6b93aa5..0bf822e 100644
--- a/Android.mk
+++ b/Android.mk
@@ -16,6 +16,14 @@
 
 LOCAL_PATH := $(call my-dir)
 
+# If the daemon is using USF, but USF isn't enabled, disable the daemon.
+# TODO (b/157659611): Remove when USF is available on partner with a prebuilt.
+ifeq ($(CHRE_DAEMON_USES_USF),true)
+  ifneq ($(USF_ENABLED),true)
+    CHRE_DAEMON_ENABLED := false
+  endif
+endif
+
 # Don't build the daemon for targets that don't contain a vendor image as
 # libsdsprpc and libadsprpc are provided by vendor code
 ifeq ($(BUILDING_VENDOR_IMAGE),true)
@@ -56,23 +64,41 @@
     host/common/log_message_parser_base.cc \
     host/common/socket_server.cc \
     host/common/st_hal_lpma_handler.cc \
-    host/msm/daemon/fastrpc_daemon.cc \
-    host/msm/daemon/main.cc \
-    host/msm/daemon/generated/chre_slpi_stub.c \
     platform/shared/host_protocol_common.cc
 
+MSM_DAEMON_SRC_FILES := \
+    host/msm/daemon/fastrpc_daemon.cc \
+    host/msm/daemon/main.cc \
+    host/msm/daemon/generated/chre_slpi_stub.c
+
+USF_DAEMON_SRC_FILES := \
+    host/usf_daemon/usf_daemon.cc \
+    host/usf_daemon/main.cc
+
+USF_DAEMON_CFLAGS := \
+    -DFLATBUFFERS_USF
+
 LOCAL_C_INCLUDES := \
-    external/fastrpc/inc \
     system/chre/external/flatbuffers/include \
     system/chre/host/common/include \
-    system/chre/host/msm/daemon \
     system/chre/platform/shared/include \
-    system/chre/platform/slpi/include \
     system/chre/util/include \
     system/core/base/include \
     system/core/libcutils/include \
     system/core/liblog/include \
-    system/core/libutils/include \
+    system/core/libutils/include
+
+MSM_DAEMON_INCLUDES := \
+    external/fastrpc/inc \
+    system/chre/platform/slpi/include \
+    system/chre/host/msm/daemon
+
+USF_DAEMON_INCLUDES := \
+    system/chre/host/usf_daemon \
+    vendor/google/sensors/usf/core/include \
+    vendor/google/sensors/usf/pal/android/include \
+    vendor/google/sensors/usf/pal/include \
+    vendor/google/sensors/usf/core/fbs
 
 LOCAL_SHARED_LIBRARIES := \
     libjsoncpp \
@@ -84,6 +110,23 @@
     android.hardware.soundtrigger@2.0 \
     libpower
 
+USF_DAEMON_SHARED_LIBRARIES := libusf
+
+ifeq ($(CHRE_DAEMON_USES_USF),true)
+LOCAL_C_INCLUDES += $(USF_DAEMON_INCLUDES)
+LOCAL_SRC_FILES += $(USF_DAEMON_SRC_FILES)
+LOCAL_CFLAGS += $(USF_DAEMON_CFLAGS)
+LOCAL_SHARED_LIBRARIES += $(USF_DAEMON_SHARED_LIBRARIES)
+else
+LOCAL_SRC_FILES += $(MSM_DAEMON_SRC_FILES)
+LOCAL_C_INCLUDES += $(MSM_DAEMON_INCLUDES)
+ifeq ($(CHRE_DAEMON_USE_SDSPRPC),true)
+LOCAL_SHARED_LIBRARIES += libsdsprpc
+else
+LOCAL_SHARED_LIBRARIES += libadsprpc
+endif
+endif
+
 # Enable tokenized logging
 ifeq ($(CHRE_USE_TOKENIZED_LOGGING),true)
 LOCAL_CFLAGS += -DCHRE_USE_TOKENIZED_LOGGING
@@ -102,10 +145,9 @@
 LOCAL_SRC_FILES += $(PIGWEED_TOKENIZER_DIR_RELPATH)/pw_varint/varint.cc
 endif
 
-ifeq ($(CHRE_DAEMON_USE_SDSPRPC),true)
-LOCAL_SHARED_LIBRARIES += libsdsprpc
-else
-LOCAL_SHARED_LIBRARIES += libadsprpc
+ifeq ($(CHRE_DAEMON_LPMA_ENABLED),true)
+LOCAL_SHARED_LIBRARIES += android.hardware.soundtrigger@2.0
+LOCAL_SHARED_LIBRARIES += libpower
 endif
 
 include $(BUILD_EXECUTABLE)
diff --git a/Makefile b/Makefile
index 6c178a7..631a4b3 100644
--- a/Makefile
+++ b/Makefile
@@ -97,6 +97,7 @@
 # implementation of CHRE. Example: this CHRE implementation is never built for
 # google_cm4_nanohub as Nanohub itself is a CHRE implementation.
 include $(CHRE_PREFIX)/build/variant/google_arm64_android.mk
+include $(CHRE_PREFIX)/build/variant/google_armv8a_aoc.mk
 include $(CHRE_PREFIX)/build/variant/google_hexagonv55_slpi-see.mk
 include $(CHRE_PREFIX)/build/variant/google_hexagonv60_slpi.mk
 include $(CHRE_PREFIX)/build/variant/google_hexagonv62_slpi.mk
diff --git a/apps/apps.mk b/apps/apps.mk
index a76dc71..6ab4d6d 100644
--- a/apps/apps.mk
+++ b/apps/apps.mk
@@ -7,7 +7,6 @@
 COMMON_CFLAGS += -Iapps/include
 
 # App makefiles ################################################################
-
 ifeq ($(CHRE_AUDIO_SUPPORT_ENABLED), true)
 include apps/audio_world/audio_world.mk
 endif
diff --git a/apps/sensor_world/sensor_world.cc b/apps/sensor_world/sensor_world.cc
index 32e69d6..33e4052 100644
--- a/apps/sensor_world/sensor_world.cc
+++ b/apps/sensor_world/sensor_world.cc
@@ -334,6 +334,7 @@
       const auto *ev = static_cast<const chreSensorThreeAxisData *>(eventData);
       const auto header = ev->header;
       const auto *data = ev->readings;
+      const auto accuracy = header.accuracy;
       sampleTime = header.baseTimestamp;
 
       float x = 0, y = 0, z = 0;
@@ -347,9 +348,9 @@
       y /= header.readingCount;
       z /= header.readingCount;
 
-      CLOGI("%s, %d samples: %f %f %f, t=%" PRIu64 " ms",
+      CLOGI("%s, %d samples: %f %f %f, accuracy: %u, t=%" PRIu64 " ms",
             getSensorName(header.sensorHandle), header.readingCount, x, y, z,
-            header.baseTimestamp / kOneMillisecondInNanoseconds);
+            accuracy, header.baseTimestamp / kOneMillisecondInNanoseconds);
 
       if (eventType == CHRE_EVENT_SENSOR_UNCALIBRATED_GYROSCOPE_DATA) {
         CLOGI("UncalGyro time: first %" PRIu64 " last %" PRIu64 " chre %" PRIu64
@@ -377,8 +378,9 @@
       }
       v /= header.readingCount;
 
-      CLOGI("%s, %d samples: %f, t=%" PRIu64 " ms",
+      CLOGI("%s, %d samples: %f, accuracy = %u, t=%" PRIu64 " ms",
             getSensorName(header.sensorHandle), header.readingCount, v,
+            header.accuracy,
             header.baseTimestamp / kOneMillisecondInNanoseconds);
       break;
     }
@@ -389,9 +391,9 @@
       const auto reading = ev->readings[0];
       sampleTime = header.baseTimestamp;
 
-      CLOGI("%s, %d samples: isNear %d, invalid %d",
+      CLOGI("%s, %d samples: isNear %d, invalid %d, accuracy: %u",
             getSensorName(header.sensorHandle), header.readingCount,
-            reading.isNear, reading.invalid);
+            reading.isNear, reading.invalid, header.accuracy);
 
       CLOGI("Prox time: sample %" PRIu64 " chre %" PRIu64 " delta %" PRId64
             "ms",
@@ -427,8 +429,8 @@
       const auto *ev = static_cast<const chreSensorOccurrenceData *>(eventData);
       const auto header = ev->header;
 
-      CLOGI("%s, %d samples", getSensorName(header.sensorHandle),
-            header.readingCount);
+      CLOGI("%s, %d samples, accuracy: %u", getSensorName(header.sensorHandle),
+            header.readingCount, header.accuracy);
       break;
     }
 
diff --git a/build/arch/armv8a.mk b/build/arch/armv8a.mk
new file mode 100644
index 0000000..3073cb9
--- /dev/null
+++ b/build/arch/armv8a.mk
@@ -0,0 +1,36 @@
+#
+# Build targets for an ARMv8 based processor
+#
+
+# The ARMV8A_XX binary path needs to be specified by a
+# higher level makefile
+TARGET_AR = $(ARMV8A_AR)
+TARGET_CC = $(ARMV8A_CC)
+TARGET_LD = $(ARMV8A_LD)
+
+TARGET_CFLAGS += $(DEFINES)
+TARGET_CFLAGS += $(CPPFLAGS)
+COMMON_CXX_CFLAGS += $(CXXFLAGS)
+COMMON_C_CFLAGS += $(CFLAGS)
+
+TARGET_SO_LDFLAGS += $(LDFLAGS)
+TARGET_SO_EARLY_LIBS += $(LDLIBS)
+
+# TODO: Fix ar_client so the following two can be removed.
+TARGET_CFLAGS += -Wno-strict-prototypes
+TARGET_CFLAGS += -Wno-missing-prototypes
+
+# TODO: Fix log_null so this can be removed.
+TARGET_CFLAGS += -Wno-unused-parameter
+
+# CHRE's stack size is 8KB so leave a little room to ensure the stack isn't
+# blown when calling nanoapps since nanoappStart will be invoked with some data
+# on the stack.
+TARGET_CFLAGS += -Wframe-larger-than=7000
+
+# Don't add these flags when building just the static archive as they generate
+# sections that will break static linking.
+ifeq ($(IS_ARCHIVE_ONLY_BUILD),)
+TARGET_CFLAGS += -fPIC
+TARGET_SO_LDFLAGS += -shared
+endif
diff --git a/build/build_template.mk b/build/build_template.mk
index cb2867a..0a956fd 100644
--- a/build/build_template.mk
+++ b/build/build_template.mk
@@ -110,7 +110,11 @@
 $(1)_header: $$($$(1)_HEADER)
 
 .PHONY: $(1)
+ifeq ($(IS_ARCHIVE_ONLY_BUILD),true)
+$(1): $(1)_ar
+else
 $(1): $(1)_ar $(1)_so $(1)_bin $(1)_header
+endif
 
 # If building the runtime, simply add the archive and shared object to the all
 # target. When building CHRE, it is expected that this runtime just be linked
@@ -135,7 +139,7 @@
 #   uint32_t magic;                // "NANO"
 #   uint64_t appId;                // App Id, contains vendor id
 #   uint32_t appVersion;           // Version of the app
-#   uint32_t flags;                // Signed, encrypted
+#   uint32_t flags;                // Signed, encrypted, TCM-capable
 #   uint64_t hwHubType;            // Which hub type is this compiled for
 #   uint8_t targetChreApiMajorVersion; // CHRE API version
 #   uint8_t targetChreApiMinorVersion;
@@ -151,13 +155,20 @@
 # the nanoapp, the version and the app ID. Marshalling this data from the
 # Makefile environment into something like python or even a small C program
 # is an unnecessary step.
+#
+# For the flags field of the struct, the following values are currently defined:
+# Signed                 = 0x00000001
+# Encrypted              = 0x00000002
+# TCM-capable            = 0x00000004
+#
+# The highest order byte is reserved for platform-specific usage.
 
 $$($$(1)_HEADER): $$(OUT)/$$$(1) $$($$$(1)_DIRS)
 	printf "00000000  %.8x " `$(BE_TO_LE_SCRIPT) 0x00000001` > $$@
 	printf "%.8x " `$(BE_TO_LE_SCRIPT) 0x4f4e414e` >> $$@
 	printf "%.16x\n" `$(BE_TO_LE_SCRIPT) $(NANOAPP_ID)` >> $$@
 	printf "00000010  %.8x " `$(BE_TO_LE_SCRIPT) $(NANOAPP_VERSION)` >> $$@
-	printf "%.8x " `$(BE_TO_LE_SCRIPT) 0x00000001` >> $$@
+	printf "%.8x " `$(BE_TO_LE_SCRIPT) $(TARGET_NANOAPP_FLAGS)` >> $$@
 	printf "%.16x\n" `$(BE_TO_LE_SCRIPT) $(13)` >> $$@
 	printf "00000020  %.2x " \
 	    `$(BE_TO_LE_SCRIPT) $(TARGET_CHRE_API_VERSION_MAJOR)` >> $$@
@@ -261,6 +272,9 @@
 
 TARGET_CFLAGS_LOCAL = $(TARGET_CFLAGS)
 TARGET_CFLAGS_LOCAL += -DCHRE_PLATFORM_ID=$(TARGET_PLATFORM_ID)
+
+# Default the nanoapp header flag values to signed if not overidden.
+TARGET_NANOAPP_FLAGS ?= 0x00000001
 $(eval $(call BUILD_TEMPLATE, $(TARGET_NAME), \
                               $(COMMON_CFLAGS) $(TARGET_CFLAGS_LOCAL), \
                               $(TARGET_CC), \
diff --git a/build/nanoapp/app.mk b/build/nanoapp/app.mk
index 25f7791..b153345 100644
--- a/build/nanoapp/app.mk
+++ b/build/nanoapp/app.mk
@@ -112,6 +112,7 @@
 GOOGLE_HEXAGONV66_SLPI-SEE_SRCS += $(DSO_SUPPORT_LIB_SRCS)
 GOOGLE_HEXAGONV66_SLPI-SEE-UIMG_SRCS += $(DSO_SUPPORT_LIB_SRCS)
 GOOGLE_ARM64_ANDROID_SRCS += $(DSO_SUPPORT_LIB_SRCS)
+GOOGLE_AOC_SRCS += $(DSO_SUPPORT_LIB_SRCS)
 GOOGLE_X86_LINUX_SRCS += $(DSO_SUPPORT_LIB_SRCS)
 QCOM_HEXAGONV60_NANOHUB_SRCS += $(APP_SUPPORT_PATH)/qcom_nanohub/app_support.cc
 QCOM_HEXAGONV60_NANOHUB-UIMG_SRCS += $(APP_SUPPORT_PATH)/qcom_nanohub/app_support_uimg.cc
@@ -127,6 +128,7 @@
 
 # Supported variants includes
 include $(CHRE_PREFIX)/build/variant/google_arm64_android.mk
+include $(CHRE_PREFIX)/build/variant/google_armv8a_aoc.mk
 include $(CHRE_PREFIX)/build/variant/google_cm4_nanohub.mk
 include $(CHRE_PREFIX)/build/variant/google_hexagonv55_slpi-see.mk
 include $(CHRE_PREFIX)/build/variant/google_hexagonv60_slpi.mk
diff --git a/build/nanoapp/google_aoc.mk b/build/nanoapp/google_aoc.mk
new file mode 100644
index 0000000..2828d2d
--- /dev/null
+++ b/build/nanoapp/google_aoc.mk
@@ -0,0 +1,31 @@
+#
+# Nanoapp Build Rules for Google CHRE on AoC
+#
+
+################################################################################
+#
+# Google Generic CHRE on AoC Nanoapp Build Template
+#
+# Invoke this to instantiate a set of Nanoapp post processing build targets.
+#
+# TARGET_NAME_nanoapp - The resulting nanoapp output.
+#
+# Argument List:
+#     $1 - TARGET_NAME         - The name of the target being built.
+#
+################################################################################
+
+ifndef GOOGLE_AOC_NANOAPP_BUILD_TEMPLATE
+define GOOGLE_AOC_NANOAPP_BUILD_TEMPLATE
+
+.PHONY: $(1)_nanoapp
+all: $(1)_nanoapp
+
+$(1)_nanoapp: $(1)
+
+endef
+endif
+
+# Template Invocation ##########################################################
+
+$(eval $(call GOOGLE_AOC_NANOAPP_BUILD_TEMPLATE, $(TARGET_NAME)))
diff --git a/build/variant/google_armv8a_aoc.mk b/build/variant/google_armv8a_aoc.mk
new file mode 100644
index 0000000..427aa88
--- /dev/null
+++ b/build/variant/google_armv8a_aoc.mk
@@ -0,0 +1,101 @@
+include $(CHRE_PREFIX)/build/clean_build_template_args.mk
+
+TARGET_NAME = google_armv8a_aoc
+ifneq ($(filter $(TARGET_NAME)% all, $(MAKECMDGOALS)),)
+
+# Environment Checks
+ifeq ($(AOC_TOP_DIR),)
+$(error "The AoC root source directory needs to be exported as the AOC_TOP_DIR \
+         environment variable")
+endif
+
+SUPPORTED_AOC_PLATFORMS_ON_CHRE := fpga_a32 whi_a0_a32
+ifeq ($(AOC_PLATFORM) ,)
+$(error "The platform we're building for needs to be exported as the \
+         AOC_PLATFORM environment variable. Supported platforms are \
+         [${SUPPORTED_AOC_PLATFORMS_ON_CHRE}]")
+endif
+
+ifeq ($(filter $(AOC_PLATFORM),$(SUPPORTED_AOC_PLATFORMS_ON_CHRE)),)
+$(error "Unsupported AoC Platform - $(AOC_PLATFORM) - Supported platforms are \
+        [${SUPPORTED_AOC_PLATFORMS_ON_CHRE}]")
+endif
+
+# The SRC_DIR variable is used in toolchain selection in AoC, add that as
+# a dependency before including the platform toolchain makefile
+ifeq ($(SRC_DIR),)
+SRC_DIR=$(AOC_TOP_DIR)/AOC
+endif
+
+include $(AOC_TOP_DIR)/AOC/build/$(AOC_PLATFORM)/toolchain.mk
+include $(AOC_TOP_DIR)/AOC/targets/aoc.$(AOC_PLATFORM)/local.mk
+
+# Sized based on the buffer allocated in the host daemon (4096 bytes), minus
+# FlatBuffer overhead (max 80 bytes), minus some extra space to make a nice
+# round number and allow for addition of new fields to the FlatBuffer
+TARGET_CFLAGS = -DCHRE_MESSAGE_TO_HOST_MAX_SIZE=4000
+TARGET_CFLAGS += $(AOC_CFLAGS)
+TARGET_CFLAGS += $(FREERTOS_CFLAGS)
+TARGET_CFLAGS += -I$(AOC_TOP_DIR)/AOC/libs/common/basic/include
+TARGET_CFLAGS += -I$(AOC_TOP_DIR)/external/libcxx/include
+
+# libc / libm headers must be included after libcxx headers in case libcxx
+# headers utilize #include_next
+TARGET_CFLAGS += -I$(AOC_TOP_DIR)/AOC/libs/bionic_interface/include
+TARGET_CFLAGS += -I$(AOC_TOP_DIR)/AOC/libs/common/libc/include
+
+# Used to expose libc headers to nanoapps that aren't supported on the given platform
+TARGET_CFLAGS += -I$(CHRE_PREFIX)/platform/shared/include/chre/platform/shared/libc
+
+# add platform specific flags
+ifeq ($(AOC_PLATFORM),fpga_a32)
+TARGET_CFLAGS += $(AOC_FPGA_A32_CFLAGS)
+# We need a function stack size of at least 400 bytes, which might not be
+# the case by default
+TARGET_CFLAGS += -Wframe-larger-than=420
+endif
+ifeq ($(AOC_PLATFORM),whi_a0_a32)
+TARGET_CFLAGS += $(AOC_WHI_A0_A32_CFLAGS)
+# We need a function stack size of at least 400 bytes, which might not be
+# the case by default
+TARGET_CFLAGS += -Wframe-larger-than=420
+endif
+
+TARGET_VARIANT_SRCS += $(AOC_SRCS)
+TARGET_VARIANT_SRCS += $(FREERTOS_SRCS)
+TARGET_VARIANT_SRCS += $(GOOGLE_AOC_SRCS)
+
+TARGET_PLATFORM_ID = 0x476F6F676C000008
+
+# Set platform-based build variables for arch armv8a
+ARMV8A_AR = $(CLANG_PATH)/llvm-ar
+ARMV8A_CC = $(CXX)
+ARMV8A_LD = $(LD)
+
+ifneq ($(IS_NANOAPP_BUILD),)
+ifeq ($(CHRE_NANOAPP_BUILD_ID),)
+# Set to "local" to indicate this was generated locally. Any production build
+# of the nanoapp will specify this ID.
+CHRE_NANOAPP_BUILD_ID=local
+endif
+
+# Provide the CHRE commit hash to make it easy to identify CHRE changes that
+# may be present in a nanoapp. This ID may change even if no nanoapp changes
+# have been made so it has to go in the unstable ID section.
+COMMIT_HASH_COMMAND = git describe --always --long --dirty
+CHRE_COMMIT_HASH = $(shell cd $(CHRE_PREFIX) && $(COMMIT_HASH_COMMAND))
+
+TARGET_CFLAGS += \
+    -DNANOAPP_UNSTABLE_ID=\"nanoapp_unstable_id=$(CHRE_NANOAPP_BUILD_ID)@chre-$(CHRE_COMMIT_HASH)\"
+
+include $(CHRE_PREFIX)/build/nanoapp/google_aoc.mk
+ifeq ($(CHRE_TCM_ENABLED),true)
+TARGET_CFLAGS += -DCHRE_TCM_ENABLED
+# Flags:  Signed | TCM
+TARGET_NANOAPP_FLAGS = 0x00000005
+endif
+endif
+
+include $(CHRE_PREFIX)/build/arch/armv8a.mk
+include $(CHRE_PREFIX)/build/build_template.mk
+endif
diff --git a/chpp/platform/aoc/chpp_init.cc b/chpp/platform/aoc/chpp_init.cc
new file mode 100644
index 0000000..d9d539a
--- /dev/null
+++ b/chpp/platform/aoc/chpp_init.cc
@@ -0,0 +1,159 @@
+/*
+ * Copyright (C) 2020 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 "chpp/platform/chpp_init.h"
+
+#include "chpp/app.h"
+#include "chpp/platform/chpp_uart_link_manager.h"
+#include "chpp/transport.h"
+#include "chre/util/fixed_size_vector.h"
+#include "chre/util/nested_data_ptr.h"
+#include "environment.h"
+#include "uart_map.h"
+
+#include "task.h"
+
+// Forward declaration
+constexpr uint8_t chpp::UartLinkManager::kWifiWakeOutGpioPinNumber;
+constexpr uint8_t chpp::UartLinkManager::kWifiWakeInGpiNumber;
+constexpr uint8_t chpp::UartLinkManager::kGnssWakeOutGpioPinNumber;
+constexpr uint8_t chpp::UartLinkManager::kGnssWakeInGpiNumber;
+constexpr uint8_t chpp::UartLinkManager::kWwanWakeOutGpioPinNumber;
+constexpr uint8_t chpp::UartLinkManager::kWwanWakeInGpiNumber;
+
+using chre::FixedSizeVector;
+using chre::NestedDataPtr;
+
+namespace chpp {
+namespace {
+
+constexpr configSTACK_DEPTH_TYPE kChppTaskStackDepthWords = 0x400;
+
+// Choose an appripriate priority to avoid initializing things too late.
+// TODO: Configure priority in relation to CHRE based on end to end testing.
+constexpr UBaseType_t kChppTaskPriority = tskIDLE_PRIORITY + 2;
+
+// Structures to hold CHPP task related variables
+constexpr size_t kChppLinkTotal = ChppLinkType::CHPP_LINK_TYPE_TOTAL;
+TaskHandle_t gChppTaskHandleList[kChppLinkTotal];
+ChppTransportState gChppTransportStateList[kChppLinkTotal];
+ChppAppState gChppAppStateList[kChppLinkTotal];
+FixedSizeVector<chpp::UartLinkManager, kChppLinkTotal> gManagerList;
+
+struct ChppClientServiceSet getClientServiceSet(ChppLinkType type) {
+  struct ChppClientServiceSet set = {};
+  switch (type) {
+    case ChppLinkType::CHPP_LINK_TYPE_WIFI:
+      set.wifiClient = 1;
+      break;
+    case ChppLinkType::CHPP_LINK_TYPE_GNSS:
+      set.gnssClient = 1;
+      break;
+    case ChppLinkType::CHPP_LINK_TYPE_WWAN:
+      set.wwanClient = 1;
+      break;
+    default:
+      LOGE("Invalid type %d to get client/service set", type);
+      CHRE_ASSERT(false);
+  }
+
+  return set;
+}
+
+// Initializes the CHPP instance and runs the work thread.
+void chppThreadEntry(void *context) {
+  NestedDataPtr<ChppLinkType> type;
+  type.dataPtr = context;
+
+  struct ChppTransportState *transportState =
+      &gChppTransportStateList[type.data];
+  struct ChppAppState *appState = &gChppAppStateList[type.data];
+
+  chppTransportInit(transportState, appState);
+  chppAppInitWithClientServiceSet(appState, transportState,
+                                  getClientServiceSet(type.data));
+
+  chppWorkThreadStart(transportState);
+
+  chppAppDeinit(appState);
+  chppTransportDeinit(transportState);
+
+  vTaskDelete(nullptr);
+  gChppTaskHandleList[type.data] = nullptr;
+}
+
+BaseType_t startChppWorkThread(ChppLinkType type, const char *taskName) {
+  struct ChppTransportState *transportState = &gChppTransportStateList[type];
+  transportState->linkParams.uartLinkManager = &gManagerList[type];
+
+  NestedDataPtr<ChppLinkType> linkType(type);
+  return xTaskCreate(chppThreadEntry, taskName, kChppTaskStackDepthWords,
+                     linkType.dataPtr /* args */, kChppTaskPriority,
+                     &gChppTaskHandleList[type]);
+}
+
+void stopChppWorkThread(ChppLinkType type) {
+  if (gChppTaskHandleList[type] != nullptr) {
+    chppWorkThreadStop(&gChppTransportStateList[type]);
+  }
+}
+
+}  // namespace
+
+void init() {
+  gManagerList.emplace_back(
+      &gChppTransportStateList[ChppLinkType::CHPP_LINK_TYPE_WIFI],
+      Environment::Instance()->UART(UART_MAP::UART_MAP_WIFI),
+      chpp::UartLinkManager::kWifiWakeOutGpioPinNumber,
+      chpp::UartLinkManager::kWifiWakeInGpiNumber);
+
+  gManagerList.emplace_back(
+      &gChppTransportStateList[ChppLinkType::CHPP_LINK_TYPE_GNSS],
+      Environment::Instance()->UART(UART_MAP::UART_MAP_GNSS),
+      chpp::UartLinkManager::kGnssWakeOutGpioPinNumber,
+      chpp::UartLinkManager::kGnssWakeInGpiNumber);
+
+  gManagerList.emplace_back(
+      &gChppTransportStateList[ChppLinkType::CHPP_LINK_TYPE_WWAN],
+      Environment::Instance()->UART(UART_MAP::UART_MAP_MODEM),
+      chpp::UartLinkManager::kWwanWakeOutGpioPinNumber,
+      chpp::UartLinkManager::kWwanWakeInGpiNumber);
+
+  BaseType_t rc =
+      startChppWorkThread(ChppLinkType::CHPP_LINK_TYPE_WIFI, "CHPP WIFI");
+  CHRE_ASSERT(rc == pdPASS);
+
+  rc = startChppWorkThread(ChppLinkType::CHPP_LINK_TYPE_GNSS, "CHPP GNSS");
+  CHRE_ASSERT(rc == pdPASS);
+
+  rc = startChppWorkThread(ChppLinkType::CHPP_LINK_TYPE_WWAN, "CHPP WWAN");
+  CHRE_ASSERT(rc == pdPASS);
+}
+
+void deinit() {
+  stopChppWorkThread(ChppLinkType::CHPP_LINK_TYPE_WIFI);
+  stopChppWorkThread(ChppLinkType::CHPP_LINK_TYPE_GNSS);
+  stopChppWorkThread(ChppLinkType::CHPP_LINK_TYPE_WWAN);
+}
+
+ChppAppState *getChppAppState(ChppLinkType linkType) {
+  CHRE_ASSERT(linkType < ChppLinkType::CHPP_LINK_TYPE_TOTAL);
+  return (linkType < ChppLinkType::CHPP_LINK_TYPE_TOTAL)
+             ? &gChppAppStateList[linkType]
+             : nullptr;
+}
+
+}  // namespace chpp
diff --git a/chpp/platform/aoc/chpp_uart_link_manager.cc b/chpp/platform/aoc/chpp_uart_link_manager.cc
new file mode 100644
index 0000000..76c7ebb
--- /dev/null
+++ b/chpp/platform/aoc/chpp_uart_link_manager.cc
@@ -0,0 +1,253 @@
+/*
+ * Copyright (C) 2020 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 "chpp/platform/chpp_uart_link_manager.h"
+
+#include "aoc.h"
+#include "chpp/macros.h"
+#include "chpp/platform/log.h"
+#include "chre/platform/fatal_error.h"
+#include "efw/include/interrupt_controller.h"
+#include "efw/include/processor.h"
+#include "efw/include/timer.h"
+#include "ipc-regions.h"
+
+// Define as 0 to disable wake handshaking
+// TODO: Enable once ready
+#define WAKE_HANDSHAKE_ENABLE 0
+
+namespace chpp {
+
+namespace {
+
+void onUartRxInterrupt(void *context) {
+  UartLinkManager *manager = static_cast<UartLinkManager *>(context);
+  manager->getUart()->DisableRxInterrupt();
+  manager->pullRxSamples();
+  chppWorkThreadSignalFromLink(&manager->getTransportContext()->linkParams,
+                               CHPP_TRANSPORT_SIGNAL_LINK_RX_PROCESS);
+  if (!manager->isRxBufferFull()) {
+    manager->getUart()->EnableRxInterrupt();
+  }
+}
+
+//! This is the interrupt to use when handling requests from the remote
+//! to start a transaction.
+void onTransactionRequestInterrupt(void *context, uint32_t /* interrupt */) {
+  UartLinkManager *manager = static_cast<UartLinkManager *>(context);
+  manager->getWakeInGpi()->SetTriggerFunction(GPIAoC::GPI_DISABLE);
+  manager->getWakeInGpi()->ClearInterrupt();
+  manager->setTransactionPending();
+  chppWorkThreadSignalFromLink(&manager->getTransportContext()->linkParams,
+                               CHPP_TRANSPORT_SIGNAL_LINK_WAKE_IN_IRQ);
+}
+
+#if WAKE_HANDSHAKE_ENABLE
+//! This is the interrupt to use when handling signal handshaking during
+//! an on-going transaction.
+void onTransactionHandshakeInterrupt(void *context, uint32_t /* interrupt */) {
+  UartLinkManager *manager = static_cast<UartLinkManager *>(context);
+  manager->getWakeInGpi()->SetTriggerFunction(GPIAoC::GPI_DISABLE);
+  manager->getWakeInGpi()->ClearInterrupt();
+
+  BaseType_t xHigherPriorityTaskWoken = 0;
+  xTaskNotifyFromISR(manager->getTaskHandle(),
+                     CHPP_TRANSPORT_SIGNAL_LINK_HANDSHAKE_IRQ, eSetBits,
+                     &xHigherPriorityTaskWoken);
+  portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
+}
+#endif  // WAKE_HANDSHAKE_ENABLE
+
+}  // anonymous namespace
+
+UartLinkManager::UartLinkManager(struct ChppTransportState *context, UART *uart,
+                                 uint8_t wakeOutPinNumber,
+                                 uint8_t wakeInGpiNumber)
+    : mTransportContext(context),
+      mUart(uart),
+      mWakeOutGpio(wakeOutPinNumber, IP_LOCK_GPIO),
+      mWakeInGpi(wakeInGpiNumber) {
+  mWakeOutGpio.SetDirection(GPIO::DIRECTION::OUTPUT);
+  mWakeOutGpio.Clear();
+  mTaskHandle = xTaskGetCurrentTaskHandle();
+}
+
+void UartLinkManager::init() {
+  mUart->RegisterRxCallback(onUartRxInterrupt, this);
+  mUart->EnableRxInterrupt();
+
+  mWakeInGpi.SetInterruptHandler(onTransactionRequestInterrupt, this);
+  mWakeInGpi.SetTriggerFunction(GPIAoC::GPI_RISING_EDGE);
+  InterruptController::Instance()->InterruptEnable(
+      IRQ_GPI0 + mWakeInGpi.GetGpiNumber(), Processor::Instance()->CoreID(),
+      true /* enable */);
+}
+
+void UartLinkManager::deinit() {
+  clearTxPacket();
+  mWakeOutGpio.Clear();
+
+  mUart->DisableRxInterrupt();
+
+  InterruptController::Instance()->InterruptEnable(
+      IRQ_GPI0 + mWakeInGpi.GetGpiNumber(), Processor::Instance()->CoreID(),
+      false /* enable */);
+  mWakeInGpi.SetTriggerFunction(GPIAoC::GPI_DISABLE);
+}
+
+bool UartLinkManager::prepareTxPacket(uint8_t *buf, size_t len) {
+  bool success = !hasTxPacket();
+  if (!success) {
+    CHPP_LOGE("Cannot prepare packet while one pending");
+  } else {
+    mCurrentBuffer = buf;
+    mCurrentBufferLen = len;
+    setTransactionPending();
+  }
+  return success;
+}
+
+bool UartLinkManager::waitForHandshakeIrq(uint64_t timeoutNs) {
+#if WAKE_HANDSHAKE_ENABLE
+  bool success = false;
+  Timer *timer = Timer::Instance();
+  const TickType_t timeoutTicks =
+      static_cast<TickType_t>(timer->NsToTicks(timeoutNs));
+
+  // Treat as if the IRQ occurred in the timeout case. We check if the timer
+  // was successfully cancelled to determine if we timed out or not.
+  auto timeoutCallback = [](void *context) -> bool {
+    onTransactionHandshakeInterrupt(context, 0);
+    return false;  // one-shot
+  };
+
+  void *timerHandle;
+  int rc = timer->EventAddAtOffset(timeoutTicks, timeoutCallback, this,
+                                   &timerHandle);
+  if (rc != 0) {
+    CHPP_LOGE("Failed to set handshake timeout timer");
+  } else {
+    uint32_t signal = 0;
+    while ((signal & CHPP_TRANSPORT_SIGNAL_LINK_HANDSHAKE_IRQ) == 0) {
+      xTaskNotifyWait(
+          0 /* ulBitsToClearOnEntry */,
+          CHPP_TRANSPORT_SIGNAL_LINK_HANDSHAKE_IRQ /* ulBitsToClearOnExit */,
+          &signal, portMAX_DELAY /* xTicksToWait */);
+    }
+
+    // If we cleared the notification while another one is in progress,
+    // re-notify the task so it doesn't get lost.
+    if ((signal & ~(CHPP_TRANSPORT_SIGNAL_LINK_HANDSHAKE_IRQ)) != 0) {
+      xTaskNotify(mTaskHandle, 0, eNoAction);
+    }
+
+    // EventRemove() will not return 0 if the timer already fired.
+    success = (timer->EventRemove(timerHandle) == 0);
+  }
+
+  return success;
+#else
+  return true;
+#endif  // WAKE_HANDSHAKE_ENABLE
+}
+
+bool UartLinkManager::startTransaction() {
+  bool success = true;
+  mWakeInGpi.SetTriggerFunction(GPIAoC::GPI_DISABLE);
+
+  // Check if a transaction is pending (either from an IRQ or from a pending
+  // TX packet) before starting one. This check is required to avoid attempting
+  // to start a transaction when it has already been handled (e.g. an IRQ has
+  // signalled the transport layer, but it already had a packet to send and
+  // handled them together).
+  if (mTransactionPending.load()) {
+    mWakeOutGpio.Set(true /* set */);
+
+#if WAKE_HANDSHAKE_ENABLE
+    mWakeInGpi.SetInterruptHandler(onTransactionHandshakeInterrupt, this);
+    mWakeInGpi.SetTriggerFunction(GPIAoC::GPI_LEVEL_ACTIVE_HIGH);
+#endif  // WAKE_HANDSHAKE_ENABLE
+
+    if (waitForHandshakeIrq(kStartTimeoutNs)) {
+      if (hasTxPacket()) {
+        int bytesTransmitted = mUart->Tx(mCurrentBuffer, mCurrentBufferLen);
+
+        // Deassert wake_out as soon as data is transmitted, per specifications.
+        mWakeOutGpio.Clear();
+
+        if (static_cast<size_t>(bytesTransmitted) != mCurrentBufferLen) {
+          CHPP_LOGE("Failed to transmit data");
+          success = false;
+        }
+
+      } else {
+        // TODO: Wait for pulse width requirement per specifications.
+        mWakeOutGpio.Clear();
+      }
+
+#if WAKE_HANDSHAKE_ENABLE
+      mWakeInGpi.SetTriggerFunction(GPIAoC::GPI_LEVEL_ACTIVE_LOW);
+      if (!waitForHandshakeIrq(kEndTimeoutNs)) {
+        CHPP_LOGE("Wake handshaking end timed out");
+        success = false;
+      }
+#endif  // WAKE_HANDSHAKE_ENABLE
+    } else {
+      CHPP_LOGE("Wake handshaking start timed out");
+      success = false;
+      mWakeOutGpio.Clear();
+    }
+
+    mTransactionPending = false;
+  }
+
+  // Re-enable the interrupt to handle transaction requests.
+  mWakeInGpi.SetTriggerFunction(GPIAoC::GPI_DISABLE);
+  mWakeInGpi.SetInterruptHandler(onTransactionRequestInterrupt, this);
+  // TODO: Handle potential cases where we miss a rising edge
+  mWakeInGpi.SetTriggerFunction(GPIAoC::GPI_RISING_EDGE);
+
+  // Remove the TX packet to allow subsequent transmission.
+  clearTxPacket();
+
+  return success;
+}
+
+void UartLinkManager::pullRxSamples() {
+  int ch;
+  while ((ch = mUart->GetChar()) != EOF && mRxBufIndex < kRxBufSize) {
+    mRxBuf[mRxBufIndex++] = static_cast<uint8_t>(ch);
+  }
+}
+
+void UartLinkManager::processRxSamples() {
+  mUart->DisableRxInterrupt();
+  pullRxSamples();
+
+  chppRxDataCb(mTransportContext, const_cast<uint8_t *>(mRxBuf), mRxBufIndex);
+  mRxBufIndex = 0;
+  mUart->EnableRxInterrupt();
+}
+
+bool UartLinkManager::hasTxPacket() const {
+  return mCurrentBuffer != nullptr && mUart != nullptr;
+}
+
+void UartLinkManager::clearTxPacket() {
+  mCurrentBuffer = nullptr;
+}
+
+}  // namespace chpp
diff --git a/chpp/platform/aoc/condition_variable.cc b/chpp/platform/aoc/condition_variable.cc
new file mode 100644
index 0000000..e4d9aca
--- /dev/null
+++ b/chpp/platform/aoc/condition_variable.cc
@@ -0,0 +1,88 @@
+/*
+ * Copyright (C) 2020 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 "chpp/platform/platform_condition_variable.h"
+
+#include "chpp/platform/log.h"
+#include "chre/platform/fatal_error.h"
+#include "efw/include/interrupt_controller.h"
+#include "efw/include/timer.h"
+
+namespace {
+
+bool wait(struct ChppConditionVariable *cv, struct ChppMutex *mutex) {
+  chppMutexUnlock(mutex);
+  BaseType_t rc = xSemaphoreTake(cv->semaphoreHandle, portMAX_DELAY);
+  chppMutexLock(mutex);
+
+  return (rc == pdTRUE);
+}
+
+bool timeoutCallback(void *context) {
+  auto *cv = static_cast<struct ChppConditionVariable *>(context);
+  chppPlatformConditionVariableSignal(cv);
+  return false;  // one-shot
+}
+
+}  // anonymous namespace
+
+void chppPlatformConditionVariableInit(struct ChppConditionVariable *cv) {
+  cv->semaphoreHandle = xSemaphoreCreateBinaryStatic(&cv->staticSemaphore);
+  if (cv->semaphoreHandle == NULL) {
+    FATAL_ERROR("Failed to create cv semaphore");
+  }
+}
+
+void chppPlatformConditionVariableDeinit(struct ChppConditionVariable *cv) {
+  if (cv->semaphoreHandle != NULL) {
+    vSemaphoreDelete(cv->semaphoreHandle);
+  }
+}
+
+bool chppPlatformConditionVariableWait(struct ChppConditionVariable *cv,
+                                       struct ChppMutex *mutex) {
+  return wait(cv, mutex);
+}
+
+bool chppPlatformConditionVariableTimedWait(struct ChppConditionVariable *cv,
+                                            struct ChppMutex *mutex,
+                                            uint64_t timeoutNs) {
+  bool success = false;
+  Timer *timer = Timer::Instance();
+  const TickType_t timeoutTicks =
+      static_cast<TickType_t>(timer->NsToTicks(timeoutNs));
+
+  void *timerHandle;
+  int rc =
+      timer->EventAddAtOffset(timeoutTicks, timeoutCallback, cv, &timerHandle);
+  if (rc != 0) {
+    CHPP_LOGE("Failed to set cv timeout timer");
+  } else {
+    success = wait(cv, mutex) && (timer->EventRemove(timerHandle) == 0);
+  }
+
+  return success;
+}
+
+void chppPlatformConditionVariableSignal(struct ChppConditionVariable *cv) {
+  if (InterruptController::Instance()->IsInterruptContext()) {
+    BaseType_t xHigherPriorityTaskWoken = 0;
+    xSemaphoreGiveFromISR(cv->semaphoreHandle, &xHigherPriorityTaskWoken);
+    portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
+  } else {
+    xSemaphoreGive(cv->semaphoreHandle);
+  }
+}
diff --git a/chpp/platform/aoc/include/chpp/platform/chpp_init.h b/chpp/platform/aoc/include/chpp/platform/chpp_init.h
new file mode 100644
index 0000000..35aef3a
--- /dev/null
+++ b/chpp/platform/aoc/include/chpp/platform/chpp_init.h
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2020 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 CHPP_PLATFORM_INIT_H_
+#define CHPP_PLATFORM_INIT_H_
+
+#include "chpp/app.h"
+
+namespace chpp {
+
+/**
+ * Initializes all CHPP instance and threads.
+ */
+void init();
+
+/**
+ * Deinitializes all CHPP instance and threads.
+ */
+void deinit();
+
+/**
+ * @return The ChppAppState associated with the provided link type.
+ */
+ChppAppState *getChppAppState(ChppLinkType linkType);
+
+}  // namespace chpp
+
+#endif  // CHPP_PLATFORM_INIT_H_
diff --git a/chpp/platform/aoc/include/chpp/platform/chpp_uart_link_manager.h b/chpp/platform/aoc/include/chpp/platform/chpp_uart_link_manager.h
new file mode 100644
index 0000000..e6d2b06
--- /dev/null
+++ b/chpp/platform/aoc/include/chpp/platform/chpp_uart_link_manager.h
@@ -0,0 +1,203 @@
+/*
+ * Copyright (C) 2020 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 CHPP_PLATFORM_UART_LINK_MANAGER_H_
+#define CHPP_PLATFORM_UART_LINK_MANAGER_H_
+
+#include "FreeRTOS.h"
+#include "chpp/condition_variable.h"
+#include "chpp/link.h"
+#include "chpp/mutex.h"
+#include "chpp/transport.h"
+#include "chre/platform/atomic.h"
+#include "chre/util/non_copyable.h"
+#include "chre/util/time.h"
+#include "gpi_aoc.h"
+#include "gpio_aoc.h"
+#include "uart.h"
+
+namespace chpp {
+
+/**
+ * A class to manage a CHPP link to a remote CHPP endpoint using UART as the
+ * physical layer. Each physical link must instantiate its own instance of
+ * the UartLinkManager.
+ *
+ * This class implements the wake handshaking protocol as follows. Each endpoint
+ * is expected to have a wake_in and wake_out GPIO and a bidirectional UART
+ * link.
+ *
+ * 1) A transaction begins by a request to transmit a packet from either
+ * end of the link. If the local endpoint has data to transmit, it must notify
+ * the remote endpoint by asserting its wake_out GPIO. Consequently, a request
+ * from the remote endpoint is driven by an IRQ from the wake_in GPIO.
+ *
+ * 2) If a packet is pending, it can be transmitted once the remote end has
+ * asserted its wake_out GPIO. Otherwise, the wake_out GPIO pulse should be
+ * asserted for at least the duration to satisfy the pulse width requirements of
+ * the specification.
+ *
+ * 3) The wake_out GPIO can be deasserted once the transmission is complete (if
+ * any). No transaction can begin until the current one has completed, and both
+ * GPIOs have been deasserted.
+ */
+class UartLinkManager : public chre::NonCopyable {
+ public:
+  /**
+   * @param context The context pointer of the CHPP transport.
+   * @param uart The pointer to the UART instance.
+   * @param wakeOutPinNumber The pin number of the wake_out GPIO.
+   * @param wakeInGpiNumber The GPI number of the wake_in GPIO.
+   */
+  UartLinkManager(struct ChppTransportState *context, UART *uart,
+                  uint8_t wakeOutPinNumber, uint8_t wakeInGpiNumber);
+
+  /**
+   * This method must be called before invoking the rest of the public methods
+   * in this class.
+   */
+  void init();
+
+  /**
+   * Resets the state and disables the UartLinkManager. init() must be called
+   * after invoking this method to use this class again.
+   */
+  void deinit();
+
+  /**
+   * @param buf The non-null pointer to the buffer.
+   * @param len The length of the above buffer.
+   *
+   * @return true if the packet was successfully prepared to be transmitted in
+   * the next transaction.
+   */
+  bool prepareTxPacket(uint8_t *buf, size_t len);
+
+  /**
+   * Starts a transaction to transmit any pending packets (if any, via a
+   * previous call to prepareTxPacket()), and handles the wake handshaking
+   * protocol.
+   *
+   * @return true if the transaction succeeded.
+   */
+  bool startTransaction();
+
+  /**
+   * Pulls RX data from the UART peripheral.
+   */
+  void pullRxSamples();
+
+  /**
+   * Same as pullRxSamples() but also sends the data to the CHPP transport.
+   */
+  void processRxSamples();
+
+  struct ChppTransportState *getTransportContext() const {
+    return mTransportContext;
+  }
+
+  UART *getUart() const {
+    return mUart;
+  }
+
+  GPIAoC *getWakeInGpi() {
+    return &mWakeInGpi;
+  }
+
+  void setTransactionPending() {
+    mTransactionPending = true;
+  }
+
+  TaskHandle_t getTaskHandle() const {
+    return mTaskHandle;
+  }
+
+  /**
+   * Waits for a wake handshaking IRQ to trigger, with a specified timeout.
+   *
+   * @param timeoutNs The timeout in nanoseconds.
+   *
+   * @return false if timed out
+   */
+  bool waitForHandshakeIrq(uint64_t timeoutNs);
+
+  bool isRxBufferFull() const {
+    return mRxBufIndex == kRxBufSize;
+  }
+
+  /**
+   * GPIO pin numbers to be used in the argument of UartLinkManager, which
+   * defines the physical pin used for the wake_out GPIO.
+   */
+  static constexpr uint8_t kWifiWakeOutGpioPinNumber = 43;
+  static constexpr uint8_t kGnssWakeOutGpioPinNumber = 86;
+  static constexpr uint8_t kWwanWakeOutGpioPinNumber = 84;
+
+  /**
+   * GPI numbers to be used in the argument of UartLinkManager, which defines
+   * the GPI used to generate the wake_in interrupts.
+   */
+  static constexpr uint8_t kWifiWakeInGpiNumber = 46;
+  static constexpr uint8_t kGnssWakeInGpiNumber = 44;
+  static constexpr uint8_t kWwanWakeInGpiNumber = 42;
+
+ private:
+  TaskHandle_t mTaskHandle = nullptr;
+
+  struct ChppTransportState *mTransportContext = nullptr;
+
+  UART *mUart = nullptr;
+
+  GPIOAoC mWakeOutGpio;
+
+  GPIAoC mWakeInGpi;
+
+  //! The pointer to the currently pending TX packet.
+  uint8_t *mCurrentBuffer = nullptr;
+  size_t mCurrentBufferLen = 0;
+
+  //! The temporary buffer to store RX data.
+  //! NOTE: Access to these variables must be done when the RX interrupt is
+  //! disabled.
+  static constexpr size_t kRxBufSize = CHPP_PLATFORM_LINK_RX_MTU_BYTES;
+  volatile uint8_t mRxBuf[kRxBufSize];
+  volatile size_t mRxBufIndex = 0;
+
+  //! The timeout for waiting on the remote to indicate transaction readiness
+  //! (t_start per specifications).
+  static constexpr uint64_t kStartTimeoutNs =
+      100 * chre::kOneMillisecondInNanoseconds;
+
+  //! The timeout for waiting on the remote to indicate transaction ended
+  //! (t_end per specifications).
+  static constexpr uint64_t kEndTimeoutNs = chre::kOneSecondInNanoseconds;
+
+  chre::AtomicBool mTransactionPending{false};
+
+  /**
+   * @return if a TX packet is pending transmission.
+   */
+  bool hasTxPacket() const;
+
+  /**
+   * Clears a pending TX packet.
+   */
+  void clearTxPacket();
+};
+
+}  // namespace chpp
+
+#endif  // CHPP_PLATFORM_UART_LINK_MANAGER_H_
diff --git a/chpp/platform/aoc/include/chpp/platform/log.h b/chpp/platform/aoc/include/chpp/platform/log.h
new file mode 100644
index 0000000..7228fd8
--- /dev/null
+++ b/chpp/platform/aoc/include/chpp/platform/log.h
@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2020 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 CHPP_LOG_H_
+#define CHPP_LOG_H_
+
+#include <chre.h>
+#include <inttypes.h>
+
+#include "FreeRTOS.h"
+#include "task.h"
+
+#ifndef PRIuSIZE
+#define PRIuSIZE "zu"
+#endif
+
+#define CHPP_AOC_LOG(level, fmt, ...)                                    \
+  chreLog(level, "%s: " fmt, pcTaskGetName(xTaskGetCurrentTaskHandle()), \
+          ##__VA_ARGS__)
+
+#define CHPP_LOGE(fmt, ...) CHPP_AOC_LOG(CHRE_LOG_ERROR, fmt, ##__VA_ARGS__)
+#define CHPP_LOGW(fmt, ...) CHPP_AOC_LOG(CHRE_LOG_WARN, fmt, ##__VA_ARGS__)
+#define CHPP_LOGI(fmt, ...) CHPP_AOC_LOG(CHRE_LOG_INFO, fmt, ##__VA_ARGS__)
+#define CHPP_LOGD(fmt, ...) CHPP_AOC_LOG(CHRE_LOG_DEBUG, fmt, ##__VA_ARGS__)
+
+#define CHPP_LOG_OOM(fmt, ...) \
+  CHPP_AOC_LOG(CHRE_LOG_ERROR, "(OOM) " fmt, ##__VA_ARGS__)
+
+#endif  // CHPP_LOG_H_
diff --git a/chpp/platform/aoc/include/chpp/platform/platform_condition_variable.h b/chpp/platform/aoc/include/chpp/platform/platform_condition_variable.h
new file mode 100644
index 0000000..79e4ccf
--- /dev/null
+++ b/chpp/platform/aoc/include/chpp/platform/platform_condition_variable.h
@@ -0,0 +1,88 @@
+/*
+ * Copyright (C) 2020 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 CHPP_PLATFORM_CONDITION_VARIABLE_H_
+#define CHPP_PLATFORM_CONDITION_VARIABLE_H_
+
+#include <stdbool.h>
+
+#include "FreeRTOS.h"
+#include "chpp/mutex.h"
+#include "semphr.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct ChppConditionVariable {
+  SemaphoreHandle_t semaphoreHandle;
+  StaticSemaphore_t staticSemaphore;
+};
+
+/**
+ * Platform implementation of chppConditionVariableInit().
+ */
+void chppPlatformConditionVariableInit(struct ChppConditionVariable *cv);
+
+/**
+ * Platform implementation of chppConditionVariableDeinit().
+ */
+void chppPlatformConditionVariableDeinit(struct ChppConditionVariable *cv);
+
+/**
+ * Platform implementation of chppConditionVariable[Timed]Wait().
+ */
+bool chppPlatformConditionVariableWait(struct ChppConditionVariable *cv,
+                                       struct ChppMutex *mutex);
+bool chppPlatformConditionVariableTimedWait(struct ChppConditionVariable *cv,
+                                            struct ChppMutex *mutex,
+                                            uint64_t timeoutNs);
+
+/**
+ * Platform implementation of chppConditionVariableSignal().
+ */
+void chppPlatformConditionVariableSignal(struct ChppConditionVariable *cv);
+
+static inline void chppConditionVariableInit(struct ChppConditionVariable *cv) {
+  chppPlatformConditionVariableInit(cv);
+}
+
+static inline void chppConditionVariableDeinit(
+    struct ChppConditionVariable *cv) {
+  chppPlatformConditionVariableDeinit(cv);
+}
+
+static inline bool chppConditionVariableWait(struct ChppConditionVariable *cv,
+                                             struct ChppMutex *mutex) {
+  return chppPlatformConditionVariableWait(cv, mutex);
+}
+
+static inline bool chppConditionVariableTimedWait(
+    struct ChppConditionVariable *cv, struct ChppMutex *mutex,
+    uint64_t timeoutNs) {
+  return chppPlatformConditionVariableTimedWait(cv, mutex, timeoutNs);
+}
+
+static inline void chppConditionVariableSignal(
+    struct ChppConditionVariable *cv) {
+  chppPlatformConditionVariableSignal(cv);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CHPP_PLATFORM_CONDITION_VARIABLE_H_
diff --git a/chpp/platform/aoc/include/chpp/platform/platform_link.h b/chpp/platform/aoc/include/chpp/platform/platform_link.h
new file mode 100644
index 0000000..e3b607e
--- /dev/null
+++ b/chpp/platform/aoc/include/chpp/platform/platform_link.h
@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 2020 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 CHPP_PLATFORM_LINK_H_
+#define CHPP_PLATFORM_LINK_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+//! A signal to use when there is RX data to process at the UART.
+#define CHPP_TRANSPORT_SIGNAL_LINK_RX_PROCESS UINT32_C(1 << 16)
+
+//! A signal to use when there is an interrupt from the wake_in GPIO.
+#define CHPP_TRANSPORT_SIGNAL_LINK_WAKE_IN_IRQ UINT32_C(1 << 17)
+
+//! A signal to use when waiting for the handshaking wake_in GPIO IRQs.
+//! This signal is reserved for use internally in the chpp::UartLinkManager.
+#define CHPP_TRANSPORT_SIGNAL_LINK_HANDSHAKE_IRQ UINT32_C(1 << 18)
+
+#define CHPP_PLATFORM_LINK_TX_MTU_BYTES 1280
+#define CHPP_PLATFORM_LINK_RX_MTU_BYTES 1280
+
+#define CHPP_PLATFORM_TRANSPORT_TIMEOUT_MS 1000
+
+enum ChppLinkType {
+  CHPP_LINK_TYPE_WIFI = 0,
+  CHPP_LINK_TYPE_GNSS,
+  CHPP_LINK_TYPE_WWAN,
+  CHPP_LINK_TYPE_TOTAL,
+};
+
+struct ChppPlatformLinkParameters {
+  //! Must be of type chpp::UartLinkManager
+  void *uartLinkManager;
+};
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CHPP_PLATFORM_LINK_H_
diff --git a/chpp/platform/aoc/include/chpp/platform/platform_mutex.h b/chpp/platform/aoc/include/chpp/platform/platform_mutex.h
new file mode 100644
index 0000000..c745478
--- /dev/null
+++ b/chpp/platform/aoc/include/chpp/platform/platform_mutex.h
@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) 2020 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 CHPP_PLATFORM_MUTEX_H_
+#define CHPP_PLATFORM_MUTEX_H_
+
+#include "chpp/platform/log.h"
+#include "FreeRTOS.h"
+#include "semphr.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Encapsulates a mutex handle and its associated semaphore structure.
+ * The static semaphore is used to avoid heap allocations.
+ */
+struct ChppMutex {
+  SemaphoreHandle_t semaphoreHandle;
+  StaticSemaphore_t staticSemaphore;
+};
+
+static inline void chppMutexInit(struct ChppMutex *mutex) {
+  mutex->semaphoreHandle = xSemaphoreCreateMutexStatic(&mutex->staticSemaphore);
+}
+
+static inline void chppMutexDeinit(struct ChppMutex *mutex) {
+  if (mutex->semaphoreHandle) {
+    vSemaphoreDelete(mutex->semaphoreHandle);
+  }
+}
+
+static inline void chppMutexLock(struct ChppMutex *mutex) {
+  TickType_t blockForever = portMAX_DELAY;
+  if (pdTRUE != xSemaphoreTake(mutex->semaphoreHandle, blockForever)) {
+    // TODO: Use CHPP_ASSERT
+    CHPP_LOGE("Failed to lock mutex");
+  }
+}
+
+static inline void chppMutexUnlock(struct ChppMutex *mutex) {
+  if (pdTRUE != xSemaphoreGive(mutex->semaphoreHandle)) {
+    CHPP_LOGE("Failed to properly unlock mutex!");
+  }
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CHPP_PLATFORM_MUTEX_H_
diff --git a/chpp/platform/aoc/include/chpp/platform/platform_notifier.h b/chpp/platform/aoc/include/chpp/platform/platform_notifier.h
new file mode 100644
index 0000000..47364c4
--- /dev/null
+++ b/chpp/platform/aoc/include/chpp/platform/platform_notifier.h
@@ -0,0 +1,73 @@
+/*
+ * Copyright (C) 2020 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 CHPP_PLATFORM_SYNC_H_
+#define CHPP_PLATFORM_SYNC_H_
+
+#include "FreeRTOS.h"
+#include "task.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct ChppNotifier {
+  //! The task that will be notified.
+  TaskHandle_t task;
+};
+
+/**
+ * Platform implementation of chppNotifierInit()
+ */
+void chppPlatformNotifierInit(struct ChppNotifier *notifier);
+
+/**
+ * Platform implementation of chppNotifierDeinit()
+ */
+void chppPlatformNotifierDeinit(struct ChppNotifier *notifier);
+
+/**
+ * Platform implementation of chppNotifierWait()
+ */
+uint32_t chppPlatformNotifierWait(struct ChppNotifier *notifier);
+
+/**
+ * Platform implementation of chppNotifierSignal()
+ */
+void chppPlatformNotifierSignal(struct ChppNotifier *notifier, uint32_t signal);
+
+static inline void chppNotifierInit(struct ChppNotifier *notifier) {
+  chppPlatformNotifierInit(notifier);
+}
+
+static inline void chppNotifierDeinit(struct ChppNotifier *notifier) {
+  chppPlatformNotifierDeinit(notifier);
+}
+
+static inline uint32_t chppNotifierWait(struct ChppNotifier *notifier) {
+  return chppPlatformNotifierWait(notifier);
+}
+
+static inline void chppNotifierSignal(struct ChppNotifier *notifier,
+                                      uint32_t signal) {
+  chppPlatformNotifierSignal(notifier, signal);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CHPP_PLATFORM_SYNC_H_
diff --git a/chpp/platform/aoc/include/chpp/platform/platform_time.h b/chpp/platform/aoc/include/chpp/platform/platform_time.h
new file mode 100644
index 0000000..a9c17a1
--- /dev/null
+++ b/chpp/platform/aoc/include/chpp/platform/platform_time.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2020 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 CHPP_PLATFORM_TIME_H_
+#define CHPP_PLATFORM_TIME_H_
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Platform implementation of chppGetCurrentTimeNs().
+ */
+uint64_t chppPlatformGetCurrentTimeNs();
+
+static inline uint64_t chppGetCurrentTimeNs(void) {
+  return chppPlatformGetCurrentTimeNs();
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // CHPP_PLATFORM_TIME_H_
diff --git a/chpp/platform/aoc/link.cc b/chpp/platform/aoc/link.cc
new file mode 100644
index 0000000..9158789
--- /dev/null
+++ b/chpp/platform/aoc/link.cc
@@ -0,0 +1,72 @@
+/*
+ * Copyright (C) 2020 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 "chpp/link.h"
+
+#include "chpp/macros.h"
+#include "chpp/platform/chpp_uart_link_manager.h"
+#include "chpp/transport.h"
+
+using chpp::UartLinkManager;
+
+void chppPlatformLinkInit(struct ChppPlatformLinkParameters *params) {
+  UartLinkManager *manager =
+      static_cast<UartLinkManager *>(params->uartLinkManager);
+  manager->init();
+}
+
+void chppPlatformLinkDeinit(struct ChppPlatformLinkParameters *params) {
+  UartLinkManager *manager =
+      static_cast<UartLinkManager *>(params->uartLinkManager);
+  manager->deinit();
+}
+
+enum ChppLinkErrorCode chppPlatformLinkSend(
+    struct ChppPlatformLinkParameters *params, uint8_t *buf, size_t len) {
+  bool success = false;
+
+  UartLinkManager *manager =
+      static_cast<UartLinkManager *>(params->uartLinkManager);
+  if (manager->prepareTxPacket(buf, len)) {
+    // TODO: Consider some other cases where asynchronous reporting
+    // is necessary, e.g. delayed transaction when waiting for a
+    // timeout.
+    success = manager->startTransaction();
+  }
+
+  return success ? CHPP_LINK_ERROR_NONE_SENT : CHPP_LINK_ERROR_UNSPECIFIED;
+}
+
+void chppPlatformLinkDoWork(struct ChppPlatformLinkParameters *params,
+                            uint32_t signal) {
+  UartLinkManager *manager =
+      static_cast<UartLinkManager *>(params->uartLinkManager);
+
+  if (signal & CHPP_TRANSPORT_SIGNAL_LINK_WAKE_IN_IRQ) {
+    // This indicates that the remote end wants to start a transaction.
+    manager->startTransaction();
+  }
+  if (signal & CHPP_TRANSPORT_SIGNAL_LINK_RX_PROCESS) {
+    manager->processRxSamples();
+  }
+}
+
+void chppPlatformLinkReset(struct ChppPlatformLinkParameters *params) {
+  UartLinkManager *manager =
+      static_cast<UartLinkManager *>(params->uartLinkManager);
+  manager->deinit();
+  manager->init();
+}
diff --git a/chpp/platform/aoc/memory.cc b/chpp/platform/aoc/memory.cc
new file mode 100644
index 0000000..eff5855
--- /dev/null
+++ b/chpp/platform/aoc/memory.cc
@@ -0,0 +1,47 @@
+/*
+ * Copyright (C) 2020 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 "chpp/memory.h"
+#include "chpp/macros.h"
+
+#include "chre/platform/memory.h"
+#include "string.h"
+
+void *chppMalloc(const size_t size) {
+  return chre::memoryAlloc(size);
+}
+
+void chppFree(void *ptr) {
+  chre::memoryFree(ptr);
+}
+
+void *chppRealloc(void *oldPtr, const size_t newSize, const size_t oldSize) {
+  if (newSize == 0) {
+    chppFree(oldPtr);
+    return nullptr;
+  }
+  if (newSize == oldSize) {
+    return oldPtr;
+  }
+
+  void *ptr = chppMalloc(newSize);
+  if (ptr != nullptr) {
+    memcpy(ptr, oldPtr, newSize > oldSize ? oldSize : newSize);
+    chppFree(oldPtr);
+  }
+
+  return ptr;
+}
diff --git a/chpp/platform/aoc/notifier.cc b/chpp/platform/aoc/notifier.cc
new file mode 100644
index 0000000..3a7eac4
--- /dev/null
+++ b/chpp/platform/aoc/notifier.cc
@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2020 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 <stdbool.h>
+
+#include "chpp/macros.h"
+#include "chpp/memory.h"
+#include "chpp/notifier.h"
+#include "efw/include/interrupt_controller.h"
+
+void chppPlatformNotifierInit(struct ChppNotifier *notifier) {
+  notifier->task = xTaskGetCurrentTaskHandle();
+  xTaskNotifyStateClear(notifier->task);
+}
+
+void chppPlatformNotifierDeinit(struct ChppNotifier *notifier) {}
+
+uint32_t chppPlatformNotifierWait(struct ChppNotifier *notifier) {
+  uint32_t signal;
+  xTaskNotifyWait(0 /* ulBitsToClearOnEntry */,
+                  UINT32_MAX /* ulBitsToClearOnExit */, &signal,
+                  portMAX_DELAY /* xTicksToWait */);
+  return signal;
+}
+
+void chppPlatformNotifierSignal(struct ChppNotifier *notifier,
+                                uint32_t signal) {
+  if (InterruptController::Instance()->IsInterruptContext()) {
+    BaseType_t xHigherPriorityTaskWoken = 0;
+    xTaskNotifyFromISR(notifier->task, signal, eSetBits,
+                       &xHigherPriorityTaskWoken);
+    portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
+  } else {
+    xTaskNotify(notifier->task, signal, eSetBits);
+  }
+}
diff --git a/chpp/platform/aoc/time.cc b/chpp/platform/aoc/time.cc
new file mode 100644
index 0000000..51ec0d9
--- /dev/null
+++ b/chpp/platform/aoc/time.cc
@@ -0,0 +1,23 @@
+/*
+ * Copyright (C) 2020 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 "chpp/platform/platform_time.h"
+
+#include "chre/platform/system_time.h"
+
+uint64_t chppPlatformGetCurrentTimeNs() {
+  return chre::SystemTime::getMonotonicTime().toRawNanoseconds();
+}
diff --git a/chre_daemon.rc b/chre_daemon.rc
index 120da10..544d3fe 100644
--- a/chre_daemon.rc
+++ b/chre_daemon.rc
@@ -17,7 +17,7 @@
 service vendor.chre /vendor/bin/chre
     class late_start
     user context_hub
-    group wakelock context_hub
+    group wakelock context_hub system
     capabilities BLOCK_SUSPEND
     socket chre seqpacket 0660 root context_hub
     shutdown critical
diff --git a/core/include/chre/core/event_loop_common.h b/core/include/chre/core/event_loop_common.h
index 03765f0..ea1cdbc 100644
--- a/core/include/chre/core/event_loop_common.h
+++ b/core/include/chre/core/event_loop_common.h
@@ -53,6 +53,7 @@
   SettingChangeEvent,
   GnssLocationReportEvent,
   GnssMeasurementReportEvent,
+  TimerSyncRequest,
 };
 
 //! The function signature of a system callback mirrors the CHRE event free
diff --git a/external/external.mk b/external/external.mk
index 4a04a13..c95b43e 100644
--- a/external/external.mk
+++ b/external/external.mk
@@ -29,7 +29,7 @@
 #
 # Kiss FFT
 #
-
+ifeq ($(CHRE_AUDIO_SUPPORT_ENABLED), true)
 # Common Compiler Flags ########################################################
 
 # Include paths.
@@ -42,3 +42,4 @@
 
 COMMON_SRCS += external/kiss_fft/kiss_fft.c
 COMMON_SRCS += external/kiss_fft/kiss_fftr.c
+endif
diff --git a/external/kiss_fft/_kiss_fft_guts.h b/external/kiss_fft/_kiss_fft_guts.h
index e83771f..6aa102d 100644
--- a/external/kiss_fft/_kiss_fft_guts.h
+++ b/external/kiss_fft/_kiss_fft_guts.h
@@ -55,9 +55,13 @@
 #define SAMP_MIN -SAMP_MAX
 
 #if defined(CHECK_OVERFLOW)
+#ifdef CHRE_KISS_FFT_CAN_USE_STDIO
 #  define CHECK_OVERFLOW_OP(a,op,b)  \
 	if ( (SAMPPROD)(a) op (SAMPPROD)(b) > SAMP_MAX || (SAMPPROD)(a) op (SAMPPROD)(b) < SAMP_MIN ) { \
 		fprintf(stderr,"WARNING:overflow @ " __FILE__ "(%d): (%d " #op" %d) = %ld\n",__LINE__,(a),(b),(SAMPPROD)(a) op (SAMPPROD)(b) );  }
+#else
+#define CHECK_OVERFLOW(a, op, b) {}
+#endif
 #endif
 
 
@@ -145,10 +149,13 @@
 	}while(0)
 
 
+#ifdef CHRE_KISS_FFT_CAN_USE_STDIO
 /* a debugging function */
 #define pcpx(c)\
     fprintf(stderr,"%g + %gi\n",(double)((c)->r),(double)((c)->i) )
-
+#else
+#define pcpx(c) {}
+#endif
 
 #ifdef KISS_FFT_USE_ALLOCA
 // define this to allow use of alloca instead of malloc for temporary buffers
diff --git a/external/kiss_fft/kiss_fft.c b/external/kiss_fft/kiss_fft.c
index 7f439c2..c1ea7e3 100644
--- a/external/kiss_fft/kiss_fft.c
+++ b/external/kiss_fft/kiss_fft.c
@@ -18,6 +18,14 @@
  fixed or floating point complex numbers.  It also delares the kf_ internal functions.
  */
 
+// CHRE modifications begin
+#if defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wcast-align"
+#pragma clang diagnostic ignored "-Wbad-function-cast"
+#endif
+// CHRE modifications end
+
 static void kf_bfly2(
         kiss_fft_cpx * Fout,
         const size_t fstride,
@@ -406,3 +414,9 @@
     }
     return n;
 }
+
+// CHRE modifications begin
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#endif
+// CHRE modifications end
diff --git a/external/kiss_fft/kiss_fftr.c b/external/kiss_fft/kiss_fftr.c
index f31f23e..0dad8a2 100644
--- a/external/kiss_fft/kiss_fftr.c
+++ b/external/kiss_fft/kiss_fftr.c
@@ -15,6 +15,14 @@
 #include "kiss_fftr.h"
 #include "_kiss_fft_guts.h"
 
+// CHRE modifications begin
+#if defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wcast-align"
+#pragma clang diagnostic ignored "-Wbad-function-cast"
+#endif
+// CHRE modifications end
+
 struct kiss_fftr_state{
     kiss_fft_cfg substate;
     kiss_fft_cpx * tmpbuf;
@@ -31,7 +39,9 @@
     size_t subsize, memneeded;
 
     if (nfft & 1) {
+#if CHRE_KISS_FFT_CAN_USE_STDIO
         fprintf(stderr,"Real FFT optimization must be even.\n");
+#endif
         return NULL;
     }
     nfft >>= 1;
@@ -71,8 +81,12 @@
     kiss_fft_cpx fpnk,fpk,f1k,f2k,tw,tdc;
 
     if ( st->substate->inverse) {
+#if CHRE_KISS_FFT_CAN_USE_STDIO
         fprintf(stderr,"kiss fft usage error: improper alloc\n");
         exit(1);
+#else
+        return;
+#endif
     }
 
     ncfft = st->substate->nfft;
@@ -126,8 +140,12 @@
     int k, ncfft;
 
     if (st->substate->inverse == 0) {
+#if CHRE_KISS_FFT_CAN_USE_STDIO
         fprintf (stderr, "kiss fft usage error: improper alloc\n");
         exit (1);
+#else
+        return;
+#endif
     }
 
     ncfft = st->substate->nfft;
@@ -157,3 +175,9 @@
     }
     kiss_fft (st->substate, st->tmpbuf, (kiss_fft_cpx *) timedata);
 }
+
+// CHRE modifications begin
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#endif
+// CHRE modifications end
diff --git a/host/common/audio_stress_test/audio_stress_test.cc b/host/common/audio_stress_test/audio_stress_test.cc
index f824786..0073718 100644
--- a/host/common/audio_stress_test/audio_stress_test.cc
+++ b/host/common/audio_stress_test/audio_stress_test.cc
@@ -15,6 +15,7 @@
  */
 
 #include "chre/util/nanoapp/app_id.h"
+#include "chre/util/system/napp_header_utils.h"
 #include "chre_host/host_protocol_host.h"
 #include "chre_host/log.h"
 #include "chre_host/socket_client.h"
@@ -92,12 +93,15 @@
     return;
   }
 
+  // All loaded nanoapps must be signed currently.
+  uint32_t appFlags = CHRE_NAPP_HEADER_SIGNED;
+
   // Perform loading with 1 fragment for simplicity
   FlatBufferBuilder builder(size + 128);
   FragmentedLoadTransaction transaction =
       FragmentedLoadTransaction(1 /* transactionId */, appId, appVersion,
-                                0x01000000 /* targetApiVersion */, buffer,
-                                buffer.size() /* fragmentSize */);
+                                appFlags, 0x01000000 /* targetApiVersion */,
+                                buffer, buffer.size() /* fragmentSize */);
   HostProtocolHost::encodeFragmentedLoadNanoappRequest(
       builder, transaction.getNextRequest());
 
diff --git a/host/common/fragmented_load_transaction.cc b/host/common/fragmented_load_transaction.cc
index cf1f637..c3c26d3 100644
--- a/host/common/fragmented_load_transaction.cc
+++ b/host/common/fragmented_load_transaction.cc
@@ -48,8 +48,8 @@
 
 FragmentedLoadTransaction::FragmentedLoadTransaction(
     uint32_t transactionId, uint64_t appId, uint32_t appVersion,
-    uint32_t targetApiVersion, const std::vector<uint8_t> &appBinary,
-    size_t fragmentSize) {
+    uint32_t appFlags, uint32_t targetApiVersion,
+    const std::vector<uint8_t> &appBinary, size_t fragmentSize) {
   mTransactionId = transactionId;
 
   // Start with fragmentId at 1 since 0 is used to indicate
@@ -59,8 +59,9 @@
   do {
     if (fragmentId == 1) {
       mFragmentRequests.emplace_back(
-          fragmentId++, transactionId, appId, appVersion, targetApiVersion,
-          appBinary.size(), getSubVector(appBinary, byteIndex, fragmentSize));
+          fragmentId++, transactionId, appId, appVersion, appFlags,
+          targetApiVersion, appBinary.size(),
+          getSubVector(appBinary, byteIndex, fragmentSize));
     } else {
       mFragmentRequests.emplace_back(
           fragmentId++, transactionId,
diff --git a/host/common/host_protocol_host.cc b/host/common/host_protocol_host.cc
index 21904f5..365a237 100644
--- a/host/common/host_protocol_host.cc
+++ b/host/common/host_protocol_host.cc
@@ -103,8 +103,8 @@
     const FragmentedLoadRequest &request) {
   encodeLoadNanoappRequestForBinary(
       builder, request.transactionId, request.appId, request.appVersion,
-      request.targetApiVersion, request.binary, request.fragmentId,
-      request.appTotalSizeBytes);
+      request.appFlags, request.targetApiVersion, request.binary,
+      request.fragmentId, request.appTotalSizeBytes);
 }
 
 void HostProtocolHost::encodeNanoappListRequest(FlatBufferBuilder &builder) {
@@ -170,13 +170,13 @@
 
 void HostProtocolHost::encodeLoadNanoappRequestForBinary(
     FlatBufferBuilder &builder, uint32_t transactionId, uint64_t appId,
-    uint32_t appVersion, uint32_t targetApiVersion,
+    uint32_t appVersion, uint32_t appFlags, uint32_t targetApiVersion,
     const std::vector<uint8_t> &nanoappBinary, uint32_t fragmentId,
     size_t appTotalSizeBytes) {
   auto appBinary = builder.CreateVector(nanoappBinary);
   auto request = fbs::CreateLoadNanoappRequest(
       builder, transactionId, appId, appVersion, targetApiVersion, appBinary,
-      fragmentId, appTotalSizeBytes);
+      fragmentId, appTotalSizeBytes, 0 /* app_binary_file_name */, appFlags);
   finalize(builder, fbs::ChreMessage::LoadNanoappRequest, request.Union());
 }
 
diff --git a/host/common/include/chre_host/daemon_base.h b/host/common/include/chre_host/daemon_base.h
index 7423849..469f9a8 100644
--- a/host/common/include/chre_host/daemon_base.h
+++ b/host/common/include/chre_host/daemon_base.h
@@ -66,7 +66,8 @@
    * @param message A buffer containing the message
    * @param messageLen size of the message buffer in bytes
    */
-  virtual void onMessageReceived(unsigned char *message, size_t messageLen) = 0;
+  virtual void onMessageReceived(const unsigned char *message,
+                                 size_t messageLen) = 0;
 
   /**
    * Function to query if a graceful shutdown of CHRE was requested
@@ -77,6 +78,16 @@
     return mChreShutdownRequested;
   }
 
+  /**
+   * Loads the supplied file into the provided buffer.
+   *
+   * @param filename The name of the file to load.
+   * @param buffer The buffer to load into.
+   * @return true if successful, false otherwise.
+   */
+  static bool readFileContents(const char *filename,
+                               std::vector<uint8_t> *buffer);
+
  protected:
   //! The host ID to use when preloading nanoapps. This is used before the
   //! server is started and is sufficiently high enough so as to not collide
@@ -112,8 +123,9 @@
    * @param name The filename of the nanoapp to load.
    * @param transactionId The transaction ID to use when loading the app.
    */
-  void loadPreloadedNanoapp(const std::string &directory,
-                            const std::string &name, uint32_t transactionId);
+  virtual void loadPreloadedNanoapp(const std::string &directory,
+                                    const std::string &name,
+                                    uint32_t transactionId);
 
   /**
    * Sends a preloaded nanoapp filename / metadata to CHRE.
@@ -165,20 +177,11 @@
                              bool logOnError);
 
   /**
-   * Loads the supplied file into the provided buffer.
-   *
-   * @param filename The name of the file to load.
-   * @param buffer The buffer to load into.
-   * @return true if successful, false otherwise.
-   */
-  bool readFileContents(const char *filename, std::vector<uint8_t> *buffer);
-
-  /**
    * Handles a message that is directed towards the daemon.
    *
    * @param message The message sent to the daemon.
    */
-  void handleDaemonMessage(const uint8_t *message);
+  virtual void handleDaemonMessage(const uint8_t *message);
 
  private:
   //! Set to true when we request a graceful shutdown of CHRE
diff --git a/host/common/include/chre_host/fragmented_load_transaction.h b/host/common/include/chre_host/fragmented_load_transaction.h
index 98a4e56..42ce478 100644
--- a/host/common/include/chre_host/fragmented_load_transaction.h
+++ b/host/common/include/chre_host/fragmented_load_transaction.h
@@ -34,22 +34,25 @@
   uint32_t transactionId;
   uint64_t appId;
   uint32_t appVersion;
+  uint32_t appFlags;
   uint32_t targetApiVersion;
   size_t appTotalSizeBytes;
   std::vector<uint8_t> binary;
 
   FragmentedLoadRequest(size_t fragmentId, uint32_t transactionId,
                         const std::vector<uint8_t> &binary)
-      : FragmentedLoadRequest(fragmentId, transactionId, 0, 0, 0, 0, binary) {}
+      : FragmentedLoadRequest(fragmentId, transactionId, 0, 0, 0, 0, 0,
+                              binary) {}
 
   FragmentedLoadRequest(size_t fragmentId, uint32_t transactionId,
-                        uint64_t appId, uint32_t appVersion,
+                        uint64_t appId, uint32_t appVersion, uint32_t appFlags,
                         uint32_t targetApiVersion, size_t appTotalSizeBytes,
                         const std::vector<uint8_t> &binary)
       : fragmentId(fragmentId),
         transactionId(transactionId),
         appId(appId),
         appVersion(appVersion),
+        appFlags(appFlags),
         targetApiVersion(targetApiVersion),
         appTotalSizeBytes(appTotalSizeBytes),
         binary(binary) {}
@@ -69,12 +72,14 @@
    * @param transactionId the unique ID of the unfragmented load transaction
    * @param appId the unique ID of the nanoapp
    * @param appVersion the version of the nanoapp
+   * @param appFlags the flags specified by the nanoapp to be loaded.
    * @param targetApiVersion the API version this nanoapp is targeted for
    * @param appBinary the nanoapp binary data
    * @param fragmentSize the size of each fragment in bytes
    */
   FragmentedLoadTransaction(uint32_t transactionId, uint64_t appId,
-                            uint32_t appVersion, uint32_t targetApiVersion,
+                            uint32_t appVersion, uint32_t appFlags,
+                            uint32_t targetApiVersion,
                             const std::vector<uint8_t> &appBinary,
                             size_t fragmentSize = kDefaultFragmentSize);
 
diff --git a/host/common/include/chre_host/generated/host_messages_generated.h b/host/common/include/chre_host/generated/host_messages_generated.h
index 4e280b6..7eb9317 100644
--- a/host/common/include/chre_host/generated/host_messages_generated.h
+++ b/host/common/include/chre_host/generated/host_messages_generated.h
@@ -1174,13 +1174,15 @@
   uint32_t fragment_id;
   uint32_t total_app_size;
   std::vector<int8_t> app_binary_file_name;
+  uint32_t app_flags;
   LoadNanoappRequestT()
       : transaction_id(0),
         app_id(0),
         app_version(0),
         target_api_version(0),
         fragment_id(0),
-        total_app_size(0) {
+        total_app_size(0),
+        app_flags(0) {
   }
 };
 
@@ -1233,7 +1235,8 @@
     VT_APP_BINARY = 12,
     VT_FRAGMENT_ID = 14,
     VT_TOTAL_APP_SIZE = 16,
-    VT_APP_BINARY_FILE_NAME = 18
+    VT_APP_BINARY_FILE_NAME = 18,
+    VT_APP_FLAGS = 20
   };
   uint32_t transaction_id() const {
     return GetField<uint32_t>(VT_TRANSACTION_ID, 0);
@@ -1289,6 +1292,14 @@
   flatbuffers::Vector<int8_t> *mutable_app_binary_file_name() {
     return GetPointer<flatbuffers::Vector<int8_t> *>(VT_APP_BINARY_FILE_NAME);
   }
+  /// The nanoapp flag values from the nanoapp header defined in
+  /// build/build_template.mk. Refer to that file for more details.
+  uint32_t app_flags() const {
+    return GetField<uint32_t>(VT_APP_FLAGS, 0);
+  }
+  bool mutate_app_flags(uint32_t _app_flags) {
+    return SetField<uint32_t>(VT_APP_FLAGS, _app_flags, 0);
+  }
   bool Verify(flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<uint32_t>(verifier, VT_TRANSACTION_ID) &&
@@ -1301,6 +1312,7 @@
            VerifyField<uint32_t>(verifier, VT_TOTAL_APP_SIZE) &&
            VerifyOffset(verifier, VT_APP_BINARY_FILE_NAME) &&
            verifier.VerifyVector(app_binary_file_name()) &&
+           VerifyField<uint32_t>(verifier, VT_APP_FLAGS) &&
            verifier.EndTable();
   }
   LoadNanoappRequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
@@ -1336,6 +1348,9 @@
   void add_app_binary_file_name(flatbuffers::Offset<flatbuffers::Vector<int8_t>> app_binary_file_name) {
     fbb_.AddOffset(LoadNanoappRequest::VT_APP_BINARY_FILE_NAME, app_binary_file_name);
   }
+  void add_app_flags(uint32_t app_flags) {
+    fbb_.AddElement<uint32_t>(LoadNanoappRequest::VT_APP_FLAGS, app_flags, 0);
+  }
   explicit LoadNanoappRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
@@ -1358,9 +1373,11 @@
     flatbuffers::Offset<flatbuffers::Vector<uint8_t>> app_binary = 0,
     uint32_t fragment_id = 0,
     uint32_t total_app_size = 0,
-    flatbuffers::Offset<flatbuffers::Vector<int8_t>> app_binary_file_name = 0) {
+    flatbuffers::Offset<flatbuffers::Vector<int8_t>> app_binary_file_name = 0,
+    uint32_t app_flags = 0) {
   LoadNanoappRequestBuilder builder_(_fbb);
   builder_.add_app_id(app_id);
+  builder_.add_app_flags(app_flags);
   builder_.add_app_binary_file_name(app_binary_file_name);
   builder_.add_total_app_size(total_app_size);
   builder_.add_fragment_id(fragment_id);
@@ -1380,7 +1397,8 @@
     const std::vector<uint8_t> *app_binary = nullptr,
     uint32_t fragment_id = 0,
     uint32_t total_app_size = 0,
-    const std::vector<int8_t> *app_binary_file_name = nullptr) {
+    const std::vector<int8_t> *app_binary_file_name = nullptr,
+    uint32_t app_flags = 0) {
   auto app_binary__ = app_binary ? _fbb.CreateVector<uint8_t>(*app_binary) : 0;
   auto app_binary_file_name__ = app_binary_file_name ? _fbb.CreateVector<int8_t>(*app_binary_file_name) : 0;
   return chre::fbs::CreateLoadNanoappRequest(
@@ -1392,7 +1410,8 @@
       app_binary__,
       fragment_id,
       total_app_size,
-      app_binary_file_name__);
+      app_binary_file_name__,
+      app_flags);
 }
 
 flatbuffers::Offset<LoadNanoappRequest> CreateLoadNanoappRequest(flatbuffers::FlatBufferBuilder &_fbb, const LoadNanoappRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
@@ -2640,6 +2659,7 @@
   { auto _e = fragment_id(); _o->fragment_id = _e; }
   { auto _e = total_app_size(); _o->total_app_size = _e; }
   { auto _e = app_binary_file_name(); if (_e) { _o->app_binary_file_name.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->app_binary_file_name[_i] = _e->Get(_i); } } }
+  { auto _e = app_flags(); _o->app_flags = _e; }
 }
 
 inline flatbuffers::Offset<LoadNanoappRequest> LoadNanoappRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LoadNanoappRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
@@ -2658,6 +2678,7 @@
   auto _fragment_id = _o->fragment_id;
   auto _total_app_size = _o->total_app_size;
   auto _app_binary_file_name = _o->app_binary_file_name.size() ? _fbb.CreateVector(_o->app_binary_file_name) : 0;
+  auto _app_flags = _o->app_flags;
   return chre::fbs::CreateLoadNanoappRequest(
       _fbb,
       _transaction_id,
@@ -2667,7 +2688,8 @@
       _app_binary,
       _fragment_id,
       _total_app_size,
-      _app_binary_file_name);
+      _app_binary_file_name,
+      _app_flags);
 }
 
 inline LoadNanoappResponseT *LoadNanoappResponse::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
diff --git a/host/common/include/chre_host/host_protocol_host.h b/host/common/include/chre_host/host_protocol_host.h
index ba04c14..107cb58 100644
--- a/host/common/include/chre_host/host_protocol_host.h
+++ b/host/common/include/chre_host/host_protocol_host.h
@@ -196,9 +196,9 @@
    */
   static void encodeLoadNanoappRequestForBinary(
       flatbuffers::FlatBufferBuilder &builder, uint32_t transactionId,
-      uint64_t appId, uint32_t appVersion, uint32_t targetApiVersion,
-      const std::vector<uint8_t> &nanoappBinary, uint32_t fragmentId,
-      size_t appTotalSizeBytes);
+      uint64_t appId, uint32_t appVersion, uint32_t appFlags,
+      uint32_t targetApiVersion, const std::vector<uint8_t> &nanoappBinary,
+      uint32_t fragmentId, size_t appTotalSizeBytes);
 
   /**
    * Encodes a message requesting to load a nanoapp specified by the included
diff --git a/host/common/include/chre_host/log_message_parser_base.h b/host/common/include/chre_host/log_message_parser_base.h
index e949ce3..932c196 100644
--- a/host/common/include/chre_host/log_message_parser_base.h
+++ b/host/common/include/chre_host/log_message_parser_base.h
@@ -46,8 +46,7 @@
     return true;
   };
 
-  virtual void log(const uint8_t * /* logBuffer */,
-                   size_t /* logBufferSize */) {}
+  virtual void log(const uint8_t *logBuffer, size_t logBufferSize);
 
   /**
    * With verbose logging enabled (via enableVerbose()), dump a
@@ -71,6 +70,21 @@
 
   void emitLogMessage(uint8_t level, uint64_t timestampNanos,
                       const char *logMessage);
+
+ private:
+  enum LogLevel : uint8_t {
+    ERROR = 1,
+    WARNING = 2,
+    INFO = 3,
+    DEBUG = 4,
+  };
+
+  //! See host_messages.fbs for the definition of this struct.
+  struct LogMessage {
+    enum LogLevel logLevel;
+    uint64_t timestampNanos;
+    char logMessage[];
+  } __attribute__((packed));
 };
 
 }  // namespace chre
diff --git a/host/common/include/chre_host/tokenized_log_message_parser.h b/host/common/include/chre_host/tokenized_log_message_parser.h
index d82140d..7677b38 100644
--- a/host/common/include/chre_host/tokenized_log_message_parser.h
+++ b/host/common/include/chre_host/tokenized_log_message_parser.h
@@ -18,6 +18,7 @@
 #define CHRE_TOKENIZED_LOG_MESSAGE_PARSER_H_
 
 #include <memory>
+#include "chre_host/daemon_base.h"
 #include "chre_host/log_message_parser_base.h"
 
 #include "pw_tokenizer/detokenize.h"
@@ -25,12 +26,14 @@
 using pw::tokenizer::DetokenizedString;
 using pw::tokenizer::Detokenizer;
 
+namespace android {
 namespace chre {
 
 class ChreTokenizedLogMessageParser : public ChreLogMessageParserBase {
  public:
   virtual bool init() override final {
     mDetokenizer = logDetokenizerInit();
+    return mDetokenizer != nullptr;
   }
 
   virtual void log(const uint8_t *logBuffer,
@@ -55,7 +58,7 @@
     constexpr const char kLogDatabaseFilePath[] =
         "/vendor/etc/chre/libchre_log_database.bin";
     std::vector<uint8_t> tokenData;
-    if (readFileContents(kLogDatabaseFilePath, &tokenData)) {
+    if (ChreDaemonBase::readFileContents(kLogDatabaseFilePath, &tokenData)) {
       pw::tokenizer::TokenDatabase database =
           pw::tokenizer::TokenDatabase::Create(tokenData);
       if (database.ok()) {
@@ -71,7 +74,7 @@
 
   // Log messages are routed through ashLog if tokenized logging
   // is disabled, so only parse tokenized log messages here.
-  void parseAndEmitTokenizedLogMessages(unsigned char *message,
+  void parseAndEmitTokenizedLogMessages(const uint8_t *message,
                                         unsigned int messageLen,
                                         const Detokenizer *detokenizer) {
     if (detokenizer != nullptr) {
@@ -80,24 +83,16 @@
       // logs (b/148873804)
       constexpr size_t kLogMessageHeaderSize =
           1 /*logLevel*/ + sizeof(uint64_t) /*timestamp*/;
-
-      const fbs::MessageContainer *container =
-          fbs::GetMessageContainer(message);
-      const auto *logMessage =
-          static_cast<const fbs::LogMessage *>(container->message());
-
-      const flatbuffers::Vector<int8_t> &logData = *logMessage->buffer();
-      const uint8_t *log = reinterpret_cast<const uint8_t *>(logData.data());
-      uint8_t level = *log;
-      ++log;
+      uint8_t level = *message;
+      ++message;
 
       uint64_t timestampNanos;
-      memcpy(&timestampNanos, log, sizeof(uint64_t));
+      memcpy(&timestampNanos, message, sizeof(uint64_t));
       timestampNanos = le64toh(timestampNanos);
-      log += sizeof(uint64_t);
+      message += sizeof(uint64_t);
 
       DetokenizedString detokenizedLog =
-          detokenizer->Detokenize(log, messageLen - kLogMessageHeaderSize);
+          detokenizer->Detokenize(message, messageLen - kLogMessageHeaderSize);
       std::string decodedLog = detokenizedLog.BestStringWithErrors();
       emitLogMessage(level, timestampNanos, decodedLog.c_str());
     } else {
@@ -107,5 +102,6 @@
 };
 
 }  // namespace chre
+}  // namespace android
 
 #endif  // CHRE_TOKENIZED_LOG_MESSAGE_PARSER_H_
\ No newline at end of file
diff --git a/host/common/log_message_parser_base.cc b/host/common/log_message_parser_base.cc
index 86d70d5..3de5002 100644
--- a/host/common/log_message_parser_base.cc
+++ b/host/common/log_message_parser_base.cc
@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+#include <endian.h>
 #include <cstdio>
 
 #include "chre_host/log_message_parser_base.h"
@@ -27,14 +28,6 @@
 #else
 constexpr bool kVerboseLoggingEnabled = false;
 #endif
-
-enum ChreLogLevel : uint8_t {
-  LOG_LEVEL_ERROR = 0,
-  LOG_LEVEL_WARN = 1,
-  LOG_LEVEL_INFO = 2,
-  LOG_LEVEL_DEBUG = 3
-};
-
 }  // anonymous namespace
 
 ChreLogMessageParserBase::ChreLogMessageParserBase()
@@ -85,19 +78,33 @@
 android_LogPriority ChreLogMessageParserBase::chreLogLevelToAndroidLogPriority(
     uint8_t level) {
   switch (level) {
-    case LOG_LEVEL_ERROR:
+    case LogLevel::ERROR:
       return ANDROID_LOG_ERROR;
-    case LOG_LEVEL_WARN:
+    case LogLevel::WARNING:
       return ANDROID_LOG_WARN;
-    case LOG_LEVEL_INFO:
+    case LogLevel::INFO:
       return ANDROID_LOG_INFO;
-    case LOG_LEVEL_DEBUG:
+    case LogLevel::DEBUG:
       return ANDROID_LOG_DEBUG;
     default:
       return ANDROID_LOG_SILENT;
   }
 }
 
+void ChreLogMessageParserBase::log(const uint8_t *logBuffer,
+                                   size_t logBufferSize) {
+  size_t bufferIndex = 0;
+  while (bufferIndex < logBufferSize) {
+    const LogMessage *message =
+        reinterpret_cast<const LogMessage *>(&logBuffer[bufferIndex]);
+    emitLogMessage(message->logLevel, le64toh(message->timestampNanos),
+                   message->logMessage);
+    bufferIndex += sizeof(LogMessage) +
+                   strnlen(message->logMessage, logBufferSize - bufferIndex) +
+                   1;
+  }
+}
+
 void ChreLogMessageParserBase::emitLogMessage(uint8_t level,
                                               uint64_t timestampNanos,
                                               const char *logMessage) {
diff --git a/host/common/test/chre_test_client.cc b/host/common/test/chre_test_client.cc
index d651cb8..8e74657 100644
--- a/host/common/test/chre_test_client.cc
+++ b/host/common/test/chre_test_client.cc
@@ -15,6 +15,7 @@
  */
 
 #include "chre/util/nanoapp/app_id.h"
+#include "chre/util/system/napp_header_utils.h"
 #include "chre_host/host_protocol_host.h"
 #include "chre_host/log.h"
 #include "chre_host/socket_client.h"
@@ -37,7 +38,7 @@
  *
  * Usage:
  *  chre_test_client load <nanoapp-id> <nanoapp-path> \
- *      [app-version] [api-version]
+ *      [app-version] [api-version] [tcm-capable]
  *  chre_test_client unload <nanoapp-id>
  */
 
@@ -168,7 +169,7 @@
 
 void sendLoadNanoappRequest(SocketClient &client, const char *filename,
                             uint64_t appId, uint32_t appVersion,
-                            uint32_t apiVersion) {
+                            uint32_t apiVersion, bool tcmApp) {
   std::ifstream file(filename, std::ios::binary | std::ios::ate);
   if (!file) {
     LOGE("Couldn't open file '%s': %s", filename, strerror(errno));
@@ -183,10 +184,16 @@
     return;
   }
 
+  // All loaded nanoapps must be signed currently.
+  uint32_t appFlags = CHRE_NAPP_HEADER_SIGNED;
+  if (tcmApp) {
+    appFlags |= CHRE_NAPP_HEADER_TCM_CAPABLE;
+  }
+
   // Perform loading with 1 fragment for simplicity
   FlatBufferBuilder builder(size + 128);
   FragmentedLoadTransaction transaction = FragmentedLoadTransaction(
-      1 /* transactionId */, appId, appVersion, apiVersion, buffer,
+      1 /* transactionId */, appId, appVersion, appFlags, apiVersion, buffer,
       buffer.size() /* fragmentSize */);
   HostProtocolHost::encodeFragmentedLoadNanoappRequest(
       builder, transaction.getNextRequest());
@@ -237,6 +244,7 @@
   const std::string path{argi < argc ? argv[argi++] : ""};
   const std::string appVerStr{argi < argc ? argv[argi++] : ""};
   const std::string apiVerStr{argi < argc ? argv[argi++] : ""};
+  const std::string tcmCapStr{argi < argc ? argv[argi++] : ""};
 
   SocketClient client;
   sp<SocketCallbacks> callbacks = new SocketCallbacks();
@@ -252,7 +260,8 @@
     sendMessageToNanoapp(client);
     sendLoadNanoappRequest(client, "/data/activity.so",
                            0x476f6f676c00100b /* appId */, 0 /* appVersion */,
-                           0x01000000 /* targetApiVersion */);
+                           0x01000000 /* targetApiVersion */,
+                           false /* tcmCapable */);
     sendUnloadNanoappRequest(client, 0x476f6f676c00100b /* appId */);
 
     LOGI("Sleeping, waiting on responses");
@@ -261,6 +270,7 @@
     uint64_t id = 0;
     uint32_t appVersion = kDefaultAppVersion;
     uint32_t apiVersion = kDefaultApiVersion;
+    bool tcmApp = false;
 
     if (idstr.empty() || path.empty()) {
       LOGE("Arguments not provided!");
@@ -274,7 +284,11 @@
     if (!apiVerStr.empty()) {
       std::istringstream(apiVerStr) >> std::setbase(0) >> apiVersion;
     }
-    sendLoadNanoappRequest(client, path.c_str(), id, appVersion, apiVersion);
+    if (!tcmCapStr.empty()) {
+      std::istringstream(tcmCapStr) >> tcmApp;
+    }
+    sendLoadNanoappRequest(client, path.c_str(), id, appVersion, apiVersion,
+                           tcmApp);
   } else if (cmd == "unload") {
     uint64_t id = 0;
 
diff --git a/host/common/test/power_test/chre_power_test_client.cc b/host/common/test/power_test/chre_power_test_client.cc
index 65a5aa5..fca1e93 100644
--- a/host/common/test/power_test/chre_power_test_client.cc
+++ b/host/common/test/power_test/chre_power_test_client.cc
@@ -32,6 +32,7 @@
 #include <vector>
 
 #include "chre/util/nanoapp/app_id.h"
+#include "chre/util/system/napp_header_utils.h"
 #include "chre/version.h"
 #include "chre_host/host_protocol_host.h"
 #include "chre_host/log.h"
@@ -279,7 +280,7 @@
 
 bool sendLoadNanoappRequest(SocketClient &client, const char *filename,
                             uint64_t appId, uint32_t appVersion,
-                            uint32_t apiVersion) {
+                            uint32_t apiVersion, bool tcmApp) {
   std::ifstream file(filename, std::ios::binary | std::ios::ate);
   if (!file) {
     LOGE("Couldn't open file '%s': %s", filename, strerror(errno));
@@ -295,10 +296,16 @@
     return false;
   }
 
+  // All loaded nanoapps must be signed currently.
+  uint32_t appFlags = CHRE_NAPP_HEADER_SIGNED;
+  if (tcmApp) {
+    appFlags |= CHRE_NAPP_HEADER_TCM_CAPABLE;
+  }
+
   // Perform loading with 1 fragment for simplicity
   FlatBufferBuilder builder(size + 128);
   FragmentedLoadTransaction transaction = FragmentedLoadTransaction(
-      1 /* transactionId */, appId, appVersion, apiVersion, buffer,
+      1 /* transactionId */, appId, appVersion, appFlags, apiVersion, buffer,
       buffer.size() /* fragmentSize */);
   HostProtocolHost::encodeFragmentedLoadNanoappRequest(
       builder, transaction.getNextRequest());
@@ -316,9 +323,9 @@
 
 bool loadNanoapp(SocketClient &client, sp<SocketCallbacks> callbacks,
                  const char *filename, uint64_t appId, uint32_t appVersion,
-                 uint32_t apiVersion) {
-  if (!sendLoadNanoappRequest(client, filename, appId, appVersion,
-                              apiVersion)) {
+                 uint32_t apiVersion, bool tcmApp) {
+  if (!sendLoadNanoappRequest(client, filename, appId, appVersion, apiVersion,
+                              tcmApp)) {
     return false;
   }
   auto status = kReadyCond.wait_for(kReadyCondLock, kTimeout);
@@ -382,11 +389,12 @@
   return true;
 }
 
+bool isTcmArgSpecified(std::vector<string> &args) {
+  return !args.empty() && args[0] == "tcm";
+}
+
 inline uint64_t getId(std::vector<string> &args) {
-  if (!args.empty() && args[0] == "tcm") {
-    return kPowerTestTcmAppId;
-  }
-  return kPowerTestAppId;
+  return isTcmArgSpecified(args) ? kPowerTestTcmAppId : kPowerTestAppId;
 }
 
 /**
@@ -759,7 +767,7 @@
     }
     case Command::kLoad: {
       success = loadNanoapp(client, callbacks, getPath(args), getId(args),
-                            kAppVersion, kApiVersion);
+                            kAppVersion, kApiVersion, isTcmArgSpecified(args));
       break;
     }
     default: {
diff --git a/host/hal_generic/common/generic_context_hub_base.h b/host/hal_generic/common/generic_context_hub_base.h
index 81514e5..6f0f47f 100644
--- a/host/hal_generic/common/generic_context_hub_base.h
+++ b/host/hal_generic/common/generic_context_hub_base.h
@@ -239,7 +239,7 @@
       uint32_t targetApiVersion = (appBinary.targetChreApiMajorVersion << 24) |
                                   (appBinary.targetChreApiMinorVersion << 16);
       mPendingLoadTransaction = FragmentedLoadTransaction(
-          transactionId, appBinary.appId, appBinary.appVersion,
+          transactionId, appBinary.appId, appBinary.appVersion, appBinary.flags,
           targetApiVersion, appBinary.customBinary, kLoadFragmentSizeBytes);
 
       result =
diff --git a/host/msm/daemon/fastrpc_daemon.cc b/host/msm/daemon/fastrpc_daemon.cc
index 5ba4ccc..7ffe5c0 100644
--- a/host/msm/daemon/fastrpc_daemon.cc
+++ b/host/msm/daemon/fastrpc_daemon.cc
@@ -147,7 +147,13 @@
   }
 
   if (messageType == fbs::ChreMessage::LogMessage) {
-    mLogger.log(messageBuffer, messageLen);
+    std::unique_ptr<fbs::MessageContainerT> container =
+        fbs::UnPackMessageContainer(messageBuffer);
+    const auto *logMessage = container->message.AsLogMessage();
+    const std::vector<int8_t> &logData = logMessage->buffer;
+
+    mLogger.log(reinterpret_cast<const uint8_t *>(logData.data()),
+                logData.size());
   } else if (messageType == fbs::ChreMessage::TimeSyncRequest) {
     sendTimeSync(true /* logOnError */);
   } else if (messageType == fbs::ChreMessage::LowPowerMicAccessRequest) {
diff --git a/host/usf_daemon/main.cc b/host/usf_daemon/main.cc
new file mode 100644
index 0000000..0911d1f
--- /dev/null
+++ b/host/usf_daemon/main.cc
@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2020 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 "usf_daemon.h"
+
+#include "chre_host/log.h"
+
+int main() {
+  LOGI("CHRE Starting!");
+
+  android::chre::UsfChreDaemon daemon;
+
+  if (!daemon.init()) {
+    LOGE("Failed to initialize the CHRE daemon..");
+  } else {
+    daemon.run();
+  }
+
+  return 0;
+}
diff --git a/host/usf_daemon/usf_daemon.cc b/host/usf_daemon/usf_daemon.cc
new file mode 100644
index 0000000..e5b21c6
--- /dev/null
+++ b/host/usf_daemon/usf_daemon.cc
@@ -0,0 +1,377 @@
+/*
+ * Copyright (C) 2020 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 "usf_daemon.h"
+
+#include <unistd.h>
+#include <chrono>
+#include <fstream>
+#include <thread>
+
+#include "usf/usf_android_time.h"
+#include "usf/usf_client.h"
+
+// Aliased for consistency with the way these symbols are referenced in
+// CHRE-side code
+namespace fbs = ::chre::fbs;
+
+namespace android {
+namespace chre {
+
+namespace {
+
+using ReffedTransportClientPtr = refcount::reffed_ptr<usf::UsfTransportClient>;
+
+constexpr uint8_t kConnectRetries = 5;
+constexpr int kRetryDelayMilliSeconds = 100;
+
+bool connectToUsfWithRetry(ReffedTransportClientPtr &client) {
+  // client has already been nullptr-checked
+  uint8_t retryCount = 0;
+  bool success = false;
+  usf::UsfErr err;
+
+  while (retryCount < kConnectRetries) {
+    if ((err = client->Connect()) == usf::kErrNone) {
+      success = true;
+      break;
+    }
+    ++retryCount;
+    std::this_thread::sleep_for(
+        std::chrono::milliseconds(kRetryDelayMilliSeconds));
+  }
+
+  if (success) {
+    LOGD("Connected to USF Transport server (retry count: %u)", retryCount + 1);
+  }
+
+  return success;
+}
+
+}  // namespace
+
+bool UsfChreDaemon::init() {
+  constexpr size_t kMaxTimeSyncRetries = 5;
+  constexpr useconds_t kTimeSyncRetryDelayUs = 50000;  // 50 ms
+  bool success = false;
+  usf::UsfErr err;
+
+  if ((err = usf::UsfClientMgr::Init()) != usf::kErrNone) {
+    LOGE("Failed to initialize usf client mgr: (err %d)",
+         static_cast<int>(err));
+  } else if ((err = usf::UsfTransportClient::Create(
+                  &mConnection.transportClient)) != usf::kErrNone) {
+    LOGE("Failed to create a USF transport client: (err %d)",
+         static_cast<int>(err));
+  } else if (mConnection.transportClient == nullptr) {
+    LOGE("Init Failed: Created a NULL transport client!");
+  } else if (!connectToUsfWithRetry(mConnection.transportClient)) {
+    LOGE("Failed to  connect to USF transport server on %u retries",
+         kConnectRetries);
+  } else if ((err = usf::UsfTransportMgr::SetMsgHandler(
+                  usf::UsfMsgType_CHRE, UsfChreDaemon::usfMessageHandler,
+                  this)) != usf::kErrNone) {
+    LOGE("Failed to set Usf Message Handler");
+  } else if (!sendTimeSyncWithRetry(kMaxTimeSyncRetries, kTimeSyncRetryDelayUs,
+                                    true /* logOnError */)) {
+    LOGE("Failed to send initial time sync message");
+  } else {
+    mLogger = getLogMessageParser();
+    loadPreloadedNanoapps();
+    success = true;
+    LOGD("CHRE daemon initialized successfully");
+  }
+
+  return success;
+}
+
+void UsfChreDaemon::deinit() {
+  setShutdownRequested(true);
+  usf::UsfClientMgr::Deinit();
+}
+
+void UsfChreDaemon::run() {
+  constexpr char kChreSocketName[] = "chre";
+  auto serverCb = [&](uint16_t clientId, void *data, size_t len) {
+    sendMessageToChre(clientId, data, len);
+  };
+
+  mSocketServer.run(kChreSocketName, true /* allowSocketCreation */, serverCb);
+}
+
+usf::UsfErr UsfChreDaemon::sendUsfMessage(const uint8_t *data, size_t dataLen) {
+  usf::UsfTxMsg msg;
+
+  msg.SetMsgType(usf::UsfMsgType_CHRE);
+  msg.SetData(data, dataLen);
+
+  return mConnection.transportClient->SendMsg(&msg);
+}
+
+bool UsfChreDaemon::sendMessageToChre(uint16_t clientId, void *data,
+                                      size_t length) {
+  bool success = false;
+  usf::UsfErr err;
+
+  if (!HostProtocolHost::mutateHostClientId(data, length, clientId)) {
+    LOGE("Couldn't set host client ID in message container!");
+  } else {
+    LOGV("Delivering message from host (size %zu)", length);
+    if ((err = sendUsfMessage(static_cast<const uint8_t *>(data), length)) !=
+        usf::kErrNone) {
+      LOGE("Failed to deliver message from host to CHRE: %d",
+           static_cast<int>(err));
+    } else {
+      success = true;
+    }
+  }
+
+  return success;
+}
+
+// TODO(karthikmb): Consider moving platform independent parts of this
+// function to the base class, revisit when implementing the daemon for
+// another platform.
+void UsfChreDaemon::onMessageReceived(const unsigned char *messageBuffer,
+                                      size_t messageLen) {
+  mLogger.dump(messageBuffer, messageLen);
+
+  uint16_t hostClientId;
+  fbs::ChreMessage messageType;
+  if (!HostProtocolHost::extractHostClientIdAndType(
+          messageBuffer, messageLen, &hostClientId, &messageType)) {
+    LOGW(
+        "Failed to extract host client ID from message - sending "
+        "broadcast");
+    hostClientId = ::chre::kHostClientIdUnspecified;
+  }
+
+  if (messageType == fbs::ChreMessage::LogMessage) {
+    std::unique_ptr<fbs::MessageContainerT> container =
+        fbs::UnPackMessageContainer(messageBuffer);
+    const auto *logMessage = container->message.AsLogMessage();
+    const std::vector<int8_t> &logData = logMessage->buffer;
+
+    mLogger.log(reinterpret_cast<const uint8_t *>(logData.data()),
+                logData.size());
+  } else if (messageType == fbs::ChreMessage::TimeSyncRequest) {
+    sendTimeSync(true /* logOnError */);
+  } else if (messageType == fbs::ChreMessage::LowPowerMicAccessRequest) {
+    LOGD("LpmaRequest unsupported");
+  } else if (messageType == fbs::ChreMessage::LowPowerMicAccessRelease) {
+    LOGD("LpmaRelease unsupported");
+  } else if (hostClientId == kHostClientIdDaemon) {
+    handleDaemonMessage(messageBuffer);
+  } else if (hostClientId == ::chre::kHostClientIdUnspecified) {
+    mSocketServer.sendToAllClients(messageBuffer,
+                                   static_cast<size_t>(messageLen));
+  } else {
+    mSocketServer.sendToClientById(
+        messageBuffer, static_cast<size_t>(messageLen), hostClientId);
+  }
+}
+
+void UsfChreDaemon::handleDaemonMessage(const uint8_t *message) {
+  std::unique_ptr<fbs::MessageContainerT> container =
+      fbs::UnPackMessageContainer(message);
+  if (container->message.type != fbs::ChreMessage::LoadNanoappResponse) {
+    LOGE("Invalid message from CHRE directed to daemon");
+  } else {
+    const auto *response = container->message.AsLoadNanoappResponse();
+    std::unique_lock<std::mutex> lock(mPreloadedNanoappsMutex);
+
+    if (!mPreloadedNanoappPending) {
+      LOGE("Received nanoapp load response with no pending load");
+    } else if (mPreloadedNanoappPendingTransactionId !=
+               response->transaction_id) {
+      LOGE("Received nanoapp load response with invalid transaction id");
+    } else {
+      mPreloadedNanoappPending = false;
+    }
+
+    mPreloadedNanoappsCond.notify_all();
+  }
+}
+
+void UsfChreDaemon::loadPreloadedNanoapp(const std::string &directory,
+                                         const std::string &name,
+                                         uint32_t transactionId) {
+  std::vector<uint8_t> headerBuffer;
+  std::vector<uint8_t> nanoappBuffer;
+
+  std::string headerFilename = directory + "/" + name + ".napp_header";
+  std::string nanoappFilename = directory + "/" + name + ".so";
+
+  if (readFileContents(headerFilename, headerBuffer) &&
+      readFileContents(nanoappFilename, nanoappBuffer) &&
+      !loadNanoapp(headerBuffer, nanoappBuffer, transactionId)) {
+    LOGE("Failed to load nanoapp: '%s'", name.c_str());
+  }
+}
+
+bool UsfChreDaemon::readFileContents(const std::string &filename,
+                                     std::vector<uint8_t> &buffer) {
+  bool success = false;
+  std::ifstream file(filename.c_str(), std::ios::binary | std::ios::ate);
+  if (!file) {
+    LOGE("Couldn't open file '%s': %d (%s)", filename.c_str(), errno,
+         strerror(errno));
+  } else {
+    ssize_t size = file.tellg();
+    file.seekg(0, std::ios::beg);
+
+    buffer.resize(size);
+    if (!file.read(reinterpret_cast<char *>(buffer.data()), size)) {
+      LOGE("Couldn't read from file '%s': %d (%s)", filename.c_str(), errno,
+           strerror(errno));
+    } else {
+      success = true;
+    }
+  }
+
+  return success;
+}
+
+bool UsfChreDaemon::loadNanoapp(const std::vector<uint8_t> &header,
+                                const std::vector<uint8_t> &nanoapp,
+                                uint32_t transactionId) {
+  // This struct comes from build/build_template.mk and must not be modified.
+  // Refer to that file for more details.
+  struct NanoAppBinaryHeader {
+    uint32_t headerVersion;
+    uint32_t magic;
+    uint64_t appId;
+    uint32_t appVersion;
+    uint32_t flags;
+    uint64_t hwHubType;
+    uint8_t targetChreApiMajorVersion;
+    uint8_t targetChreApiMinorVersion;
+    uint8_t reserved[6];
+  } __attribute__((packed));
+
+  bool success = false;
+  if (header.size() != sizeof(NanoAppBinaryHeader)) {
+    LOGE("Header size mismatch");
+  } else {
+    // The header blob contains the struct above.
+    const auto *appHeader =
+        reinterpret_cast<const NanoAppBinaryHeader *>(header.data());
+
+    // Build the target API version from major and minor.
+    uint32_t targetApiVersion = (appHeader->targetChreApiMajorVersion << 24) |
+                                (appHeader->targetChreApiMinorVersion << 16);
+
+    success = sendFragmentedNanoappLoad(
+        appHeader->appId, appHeader->appVersion, appHeader->flags,
+        targetApiVersion, nanoapp.data(), nanoapp.size(), transactionId);
+  }
+
+  return success;
+}
+
+bool UsfChreDaemon::sendFragmentAndWaitOnResponse(
+    uint32_t transactionId, flatbuffers::FlatBufferBuilder &builder) {
+  bool success = true;
+  std::unique_lock<std::mutex> lock(mPreloadedNanoappsMutex);
+
+  mPreloadedNanoappPendingTransactionId = transactionId;
+  mPreloadedNanoappPending = sendMessageToChre(
+      kHostClientIdDaemon, builder.GetBufferPointer(), builder.GetSize());
+  if (!mPreloadedNanoappPending) {
+    LOGE("Failed to send nanoapp fragment");
+    success = false;
+  } else {
+    // 60s timeout for fragments. Set high for busy first bootups where the
+    // PALs can block CHRE initialization while other subsystems come up.
+    std::chrono::seconds timeout(60);
+    bool signaled = mPreloadedNanoappsCond.wait_for(
+        lock, timeout, [this] { return !mPreloadedNanoappPending; });
+
+    if (!signaled) {
+      LOGE("Nanoapp fragment load timed out");
+      success = false;
+    }
+  }
+  return success;
+}
+
+bool UsfChreDaemon::sendFragmentedNanoappLoad(
+    uint64_t appId, uint32_t appVersion, uint32_t appFlags,
+    uint32_t appTargetApiVersion, const uint8_t *appBinary, size_t appSize,
+    uint32_t transactionId) {
+  // TODO: This is currently limited by the USF Message size, revisit
+  // and increase this when the USF message size increases.
+  constexpr size_t kFragmentSize = 512;
+  std::vector<uint8_t> binary(appSize);
+  std::copy(appBinary, appBinary + appSize, binary.begin());
+
+  FragmentedLoadTransaction transaction(transactionId, appId, appVersion,
+                                        appFlags, appTargetApiVersion, binary,
+                                        kFragmentSize);
+
+  bool success = true;
+
+  while (success && !transaction.isComplete()) {
+    // Pad the builder to avoid allocation churn.
+    const auto &fragment = transaction.getNextRequest();
+    flatbuffers::FlatBufferBuilder builder(fragment.binary.size() + 128);
+    HostProtocolHost::encodeFragmentedLoadNanoappRequest(builder, fragment);
+    success = sendFragmentAndWaitOnResponse(transactionId, builder);
+  }
+
+  return success;
+}
+
+int64_t UsfChreDaemon::getTimeOffset(bool *success) {
+  int64_t offset = 0;
+  uint64_t androidTimeNs;
+  uint64_t sensorCoreTimeNs;
+  usf::UsfErr err =
+      usf::UsfGetAndroidAndSensorCoreTime(&androidTimeNs, &sensorCoreTimeNs);
+  if (err != usf::kErrNone) {
+    LOGE("Get Android and sensor core time failed.");
+  } else {
+    offset = static_cast<int64_t>(androidTimeNs) -
+             static_cast<int64_t>(sensorCoreTimeNs);
+  }
+  *success = (err == usf::kErrNone);
+  return offset;
+}
+
+ChreLogMessageParserBase UsfChreDaemon::getLogMessageParser() {
+#ifdef CHRE_USE_TOKENIZED_LOGGING
+  return ChreTokenizedLogMessageParser();
+#else
+  return ChreLogMessageParserBase();
+#endif
+}
+
+usf::UsfErr UsfChreDaemon::usfMessageHandler(
+    usf::UsfTransport * /* transport */, const usf::UsfMsg *usfMsg, void *arg) {
+  usf::UsfErr err = usf::kErrInvalid;
+  auto *daemon = static_cast<UsfChreDaemon *>(arg);
+  if ((daemon != nullptr) && (usfMsg != nullptr)) {
+    const uint8_t *msgData = usfMsg->data()->data();
+    size_t msgLen = usfMsg->data()->size();
+    daemon->onMessageReceived(msgData, msgLen);
+  } else {
+    LOGE("Error Handling Usf Message");
+  }
+  return err;
+}
+
+}  // namespace chre
+}  // namespace android
diff --git a/host/usf_daemon/usf_daemon.h b/host/usf_daemon/usf_daemon.h
new file mode 100644
index 0000000..194d719
--- /dev/null
+++ b/host/usf_daemon/usf_daemon.h
@@ -0,0 +1,168 @@
+/*
+ * Copyright (C) 2020 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 CHRE_USF_DAEMON_H_
+#define CHRE_USF_DAEMON_H_
+
+#include "chre_host/daemon_base.h"
+#include "chre_host/socket_server.h"
+#ifdef CHRE_USE_TOKENIZED_LOGGING
+#include "chre_host/tokenized_log_message_parser.h"
+#else
+#include "chre_host/log_message_parser_base.h"
+#endif
+
+#include "usf/usf_transport_client.h"
+
+#include <utils/SystemClock.h>
+
+// Disable verbose logging
+// TODO: use property_get_bool to make verbose logging runtime configurable
+// #define LOG_NDEBUG 0
+
+namespace android {
+namespace chre {
+
+class UsfChreDaemon : public ChreDaemonBase {
+ public:
+  struct UsfServerConnection {
+    refcount::reffed_ptr<usf::UsfTransportClient> transportClient;
+    usf::UsfTransport *transport;
+    usf::UsfServerHandle serverHandle;
+  };
+
+  ~UsfChreDaemon() {
+    deinit();
+  }
+
+  /**
+   * Initializes the CHRE daemon, and creates a USF transport for
+   * communicating with CHRE
+   *
+   * @return true on successful init
+   */
+  bool init();
+
+  /**
+   * Starts a socket server receive loop for inbound messages
+   */
+  void run();
+
+  bool sendMessageToChre(uint16_t clientId, void *data, size_t length);
+
+  void onMessageReceived(const unsigned char *messageBuffer, size_t messageLen);
+
+  UsfServerConnection &getMutableServerConnection() {
+    return mConnection;
+  }
+
+ protected:
+  void loadPreloadedNanoapp(const std::string &directory,
+                            const std::string &name,
+                            uint32_t transactionId) override;
+
+  void handleDaemonMessage(const uint8_t *message) override;
+
+ private:
+  SocketServer mSocketServer;
+  ChreLogMessageParserBase mLogger;
+  UsfServerConnection mConnection;
+
+  //! The mutex used to guard state between the nanoapp messaging thread
+  //! and loading preloaded nanoapps.
+  std::mutex mPreloadedNanoappsMutex;
+
+  //! The condition variable used to wait for a nanoapp to finish loading.
+  std::condition_variable mPreloadedNanoappsCond;
+
+  //! Set to true when a preloaded nanoapp is pending load.
+  bool mPreloadedNanoappPending;
+
+  //! Set to the expected transaction ID for loading a nanoapp.
+  uint32_t mPreloadedNanoappPendingTransactionId;
+
+  /**
+   * Perform a graceful shutdown of the daemon
+   */
+  void deinit();
+
+  /**
+   * Platform specific getTimeOffset for the WHI Daemon
+   *
+   * @return clock drift offset in nanoseconds
+   */
+  int64_t getTimeOffset(bool *success);
+
+  /**
+   * Get the Log Message Parser configured for this platform
+   *
+   * @return An instance of a log message parser
+   */
+  ChreLogMessageParserBase getLogMessageParser();
+
+  /**
+   * Loads the supplied file into the provided buffer.
+   *
+   * @param filename The name of the file to load.
+   * @param buffer The buffer to load into.
+   * @return true if successful, false otherwise.
+   */
+  bool readFileContents(const std::string &filename,
+                        std::vector<uint8_t> &buffer);
+
+  /**
+   * Sends a preloaded nanoapp to CHRE.
+   *
+   * @param header The nanoapp header binary blob.
+   * @param nanoapp The nanoapp binary blob.
+   * @param transactionId The transaction ID to use when loading the app.
+   * @return true if succssful, false otherwise.
+   */
+  bool loadNanoapp(const std::vector<uint8_t> &header,
+                   const std::vector<uint8_t> &nanoapp, uint32_t transactionId);
+
+  /**
+   * Loads a nanoapp using fragments.
+   *
+   * @param appId The ID of the nanoapp to load.
+   * @param appVersion The version of the nanoapp to load.
+   * @param appFlags The flags specified by the nanoapp to be loaded.
+   * @param appTargetApiVersion The version of the CHRE API that the app
+   * targets.
+   * @param appBinary The application binary code.
+   * @param appSize The size of the appBinary.
+   * @param transactionId The transaction ID to use when loading.
+   * @return true if successful, false otherwise.
+   */
+  bool sendFragmentedNanoappLoad(uint64_t appId, uint32_t appVersion,
+                                 uint32_t appFlags,
+                                 uint32_t appTargetApiVersion,
+                                 const uint8_t *appBinary, size_t appSize,
+                                 uint32_t transactionId);
+
+  static usf::UsfErr usfMessageHandler(usf::UsfTransport *transport,
+                                       const usf::UsfMsg *usfMsg, void *arg);
+
+  usf::UsfErr sendUsfMessage(const uint8_t *data, size_t dataLen);
+
+  bool sendFragmentAndWaitOnResponse(uint32_t transactionId,
+                                     flatbuffers::FlatBufferBuilder &builder);
+};
+
+}  // namespace chre
+}  // namespace android
+
+#endif  // CHRE_USF_DAEMON_H_
diff --git a/platform/aoc/audio_controller.cc b/platform/aoc/audio_controller.cc
new file mode 100644
index 0000000..2986ad3
--- /dev/null
+++ b/platform/aoc/audio_controller.cc
@@ -0,0 +1,173 @@
+/*
+ * Copyright (C) 2020 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 "chre/platform/aoc/audio_controller.h"
+#include "chre/core/event_loop_manager.h"
+#include "chre/platform/assert.h"
+
+#include "aoc/ff1/audio/include/controller_audio_input.h"  // For command IDs
+#include "aoc/include/processor_aoc.h"
+#include "efw/include/environment_ipc.h"
+#include "efw/include/ring_buffer_ipc.h"
+
+namespace chre {
+
+namespace {
+
+// Helper function to get the IPC Array parameter for the conroller
+// constructor. The function exists because of a current limitation in
+// the EFW Controller class constructor which requires an IPC array
+// variable to be passed in.
+inline IPCommunication **GetIpcArray() {
+  static IPCommunication *arr =
+      EnvironmentIpc::Instance()->IpcByID(IPC_CHANNEL_CMD_CHRE_AUDIO_NOTIF_ID);
+  return &arr;
+}
+
+}  // namespace
+
+AudioController::AudioController()
+    : Controller(
+          "CHRE_CTR" /* name */, EFWObject::Root(),
+          tskIDLE_PRIORITY + 5 /* priority */, 1024 /* stack size in words */,
+          GetIpcArray() /* ipc array */, 1 /*ipc descriptor array size */,
+          5 /* max outstanding ipc notifications */,
+          10 /* max total notifications */, 1 /* num IPC ring buffers */, 10),
+      mControllerIpcAoc("CHRE_CTR_IPC" /* name */, EFWObject::Root(),
+                        tskIDLE_PRIORITY + 5 /* priority */,
+                        ProcessorAoC::FF1 /* remote core */,
+                        EnvironmentIpc::Instance()->IpcByID(
+                            IPC_CHANNEL_CMD_CHRE_AUDIO_INPUT_ID),
+                        1 /* notifDepth */, 1 /* NumIpcRingBuffers */),
+      mPipeIpcReceiverAoc(
+          "CHRE_PIPE" /* name */,
+          EnvironmentIpc::Instance()->IpcByID(IPC_CHANNEL_DTA_CHRE_AUDIO_ID),
+          ProcessorAoC::A32 /* Primary core */, EFWObject::Root()) {
+  LOGV("MainController created");
+
+  TaskSpawn();
+}
+
+void AudioController::SetUp() {
+  Controller::SetUp();
+  mControllerIpcAoc.Start();
+}
+
+void AudioController::SetUpRemoteCore() {
+  if (!mDspCoreInitDone) {
+    int rc = -1;
+    struct CMD_HDR cmd;
+    // See controller_audio_input.h in EFW for command ID definitions.
+    uint16_t cmdId = ControllerAudioInput::CMD_AUDIO_INPUT_CHRE_SETUP_ID;
+    if ((rc = mControllerIpcAoc.CmdRelay(&cmd, cmdId, sizeof(CMD_HDR),
+                                         portMAX_DELAY)) != 0) {
+      LOGE("Failed to send setup cmd to DSP rc: %d", rc);
+    }
+  }
+}
+
+void AudioController::TearDown() {
+  Controller::TearDown();
+
+  mFilter.Stop();
+  mFilter.RingUnbind(AudioFilter::kRingIndex);
+}
+
+bool AudioController::CmdProcessor(struct CMD_HDR *cmd) {
+  switch (cmd->id) {
+    case ControllerAudioInput::CMD_AUDIO_INPUT_CHRE_F1_CTR_READY_ID:
+      cmd->reply = OnDspReady();
+      break;
+
+    default:
+      LOGD("Unknown cmd for CHRE controller");
+      cmd->reply = -1;
+      break;
+  }
+
+  return true;
+}
+
+int AudioController::OnDspReady() {
+  int rc = -1;
+
+  mDspCoreInitDone = true;
+
+  if ((rc = mFilter.InputBind(AudioFilter::kPipeIndex, &mPipeIpcReceiverAoc)) !=
+      0) {
+    LOGE("Failed to bind pipe to filter input");
+  } else if ((rc = mFilter.RingBind(
+                  AudioFilter::kRingIndex,
+                  ring_buffer_ipc_[AudioFilter::kRingIndex])) != 0) {
+    LOGE("Failed to bind ipc ring buffer to filter");
+  } else if ((rc = mFilter.Start()) != 0) {
+    LOGE("Failed to start audio filter");
+  } else {
+    EventLoopManagerSingleton::get()
+        ->getAudioRequestManager()
+        .handleAudioAvailability(0 /*handle*/, true /*available*/);
+  }
+
+  return rc;
+}
+
+const chreAudioSource *AudioController::GetSource(uint32_t /*handle*/) const {
+  return &kAudioSource;
+}
+
+void AudioController::SetEnabled(uint32_t /*handle*/, bool enabled) {
+  mSourceStatus.enabled = enabled;
+}
+
+bool AudioController::UpdateStream(uint32_t /*handle*/, bool start) {
+  bool success = false;
+  // TODO: handle and other params
+  if (mDspCoreInitDone && mSourceStatus.enabled) {
+    if (mRequestStarted != start) {
+      mRequestStarted = start;
+      CMD_HDR cmd;
+      cmd.reply = -1;  // negative value to test
+      // see controller_audio_input.h in EFW for command ID definitions.
+      uint16_t cmdId =
+          start ? ControllerAudioInput::CMD_AUDIO_INPUT_MIC_CHRE_START_ID
+                : ControllerAudioInput::CMD_AUDIO_INPUT_MIC_CHRE_STOP_ID;
+
+      int rc = mControllerIpcAoc.CmdRelay(&cmd, cmdId, sizeof(CMD_HDR),
+                                          portMAX_DELAY);
+      LOGV("request audio send: %d", rc);
+      success = (rc == 0);
+    } else {
+      // streaming already in the correct state for this handle
+      success = true;
+    }
+  }
+
+  return success;
+}
+
+bool AudioController::RequestAudio(uint32_t handle) {
+  return UpdateStream(handle, true /*start*/);
+}
+
+bool AudioController::ReleaseAudio(uint32_t handle) {
+  return UpdateStream(handle, false /*start*/);
+}
+
+void AudioController::OnBufferReleased() {
+  mFilter.Signal(AudioFilter::kBufferReleasedSignalIndex);
+}
+
+}  // namespace chre
diff --git a/platform/aoc/audio_filter.cc b/platform/aoc/audio_filter.cc
new file mode 100644
index 0000000..0c2f540
--- /dev/null
+++ b/platform/aoc/audio_filter.cc
@@ -0,0 +1,127 @@
+/*
+ * Copyright (C) 2020 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 "chre/platform/aoc/audio_filter.h"
+#include "chre/core/event_loop_manager.h"
+#include "chre/platform/assert.h"
+#include "chre/platform/log.h"
+#include "chre/platform/system_time.h"
+#include "chre/util/time.h"
+#include "efw/include/ring_buffer_ipc.h"
+
+namespace chre {
+
+AudioFilter::AudioFilter()
+    : Filter("CHRE_FLT" /* name */, EFWObject::Root() /* parent */,
+             tskIDLE_PRIORITY + 5 /* priority */, 512 /* stack size words */,
+             1 /* command depth */, 1 /* Num Filter inputs */,
+             1 /* Num Filter Outputs */, 1 /* Num Ring Buffers */) {
+  LOGV("Filter Created");
+
+  TaskSpawn();
+}
+
+int AudioFilter::StartCallback() {
+  mRingBufferHandle = ring_[kRingIndex]->ReaderRegister();
+  CHRE_ASSERT(mRingBufferHandle != nullptr);
+  return 0;
+}
+
+bool AudioFilter::StopCallback() {
+  ring_[kRingIndex]->ReaderUnregister(mRingBufferHandle);
+  mRingBufferHandle = nullptr;
+  return true;
+}
+
+bool AudioFilter::SignalProcessor(int index) {
+  switch (index) {
+    case kBufferReleasedSignalIndex:
+      OnBufferReleased();
+      break;
+    default:
+      break;
+  }
+  return true;
+}
+
+void AudioFilter::InputProcessor(int /*pin*/, void *message, size_t size) {
+  CHRE_ASSERT(message != nullptr);
+
+  if (!mBufferInUse) {
+    // TODO resync and synchronization, check metadata format etc.
+    auto *metadata = static_cast<struct AudioInputMetadata *>(message);
+
+    if (metadata->need_resync) {
+      LOGW("Resync request received, logic not implemented yet");
+    }
+
+    constexpr size_t kBytesPerAocSample = sizeof(uint32_t);
+    constexpr size_t kNumSamplesAoc = 160;
+    constexpr size_t kRingSize = kNumSamplesAoc * kBytesPerAocSample *
+                                 1;  // 1 channel of u32 samples per 10 ms
+    uint32_t buffer[kNumSamplesAoc];
+    uint32_t nBytes =
+        ring_[kRingIndex]->Read(mRingBufferHandle, &buffer, kRingSize);
+    CHRE_ASSERT_LOG(nBytes != 0, "Got data pipe notif, but no data in ring");
+    size_t nSamples = nBytes / kBytesPerAocSample;
+
+    if (mSampleCount == 0) {
+      // TODO: Get a better estimate of the timestamp of the first sample in
+      // the frame. Since the pipe notification arrives every 10ms, we could
+      // subtract 10ms from now(), and maybe even keep track of the embedded
+      // timestamp of the first sample of the current frame, and the last
+      // sample of the previous frame.
+      mDataEvent.timestamp = SystemTime::getMonotonicTime().toRawNanoseconds();
+    }
+
+    // TODO: For the initial implementation/testing, we assume that the
+    // frame might not fit to a T in our current buffer, but that is the
+    // expectation. With the current logic, we could end up dropping a frame,
+    // revisit this to make sure we capture the exact number of samples,
+    // while continuing to buffer samples either via a ping-pong scheme, or
+    // a small extra scratch space.
+    if ((nSamples + mSampleCount) > kSamplesPer2Sec) {
+      mDataEvent.sampleCount = mSampleCount;
+      mDataEvent.samplesS16 = mSampleBuffer;
+      mSampleCount = 0;
+      mBufferInUse = true;
+
+      EventLoopManagerSingleton::get()
+          ->getAudioRequestManager()
+          .handleAudioDataEvent(&mDataEvent);
+
+    } else {
+      for (size_t i = 0; i < nSamples; ++i, ++mSampleCount) {
+        // The zeroth byte of the received sample is a timestamp, which we
+        // strip out.
+        // TODO: Verify that there's no scaling on the remaining data, in
+        // which case casting without descaling won't be the right thing to
+        // do.
+        mSampleBuffer[mSampleCount] =
+            static_cast<int16_t>((buffer[i] >> 8) & 0xff);
+      }
+    }
+  } else {
+    LOGW(
+        "Received an audio notification before the previous event was "
+        "released!");
+  }
+}
+
+void AudioFilter::OnBufferReleased() {
+  mBufferInUse = false;
+}
+
+}  // namespace chre
diff --git a/platform/aoc/chre_api_re.cc b/platform/aoc/chre_api_re.cc
new file mode 100644
index 0000000..00fa668
--- /dev/null
+++ b/platform/aoc/chre_api_re.cc
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2020 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 <cinttypes>
+
+#include "chre/platform/log.h"
+#include "chre/util/macros.h"
+#include "chre_api/chre/re.h"
+
+void chreLog(enum chreLogLevel level, const char *formatStr, ...) {
+  va_list args;
+  va_start(args, formatStr);
+
+  // TODO(karthikmb): Remove this once log buffering is implemented.
+  char logBuf[500];
+  va_list vsnargs;
+  va_copy(vsnargs, args);
+  vsnprintf(logBuf, sizeof(logBuf), formatStr, args);
+  va_end(vsnargs);
+  printf("CHRE: %s\n", logBuf);
+
+  chre::vaLog(level, formatStr, args);
+  va_end(args);
+}
diff --git a/platform/aoc/dram_vote_client.cc b/platform/aoc/dram_vote_client.cc
new file mode 100644
index 0000000..0977560
--- /dev/null
+++ b/platform/aoc/dram_vote_client.cc
@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2020 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 "chre/platform/shared/dram_vote_client.h"
+
+#include "chre/platform/assert.h"
+
+#include "sysmem.h"
+
+namespace chre {
+
+void DramVoteClient::issueDramVote(bool enabled) {
+  if (mLastDramVote != enabled) {
+    int rc;
+    if (enabled) {
+      rc = SysMem::Instance()->MemoryRequest(SysMem::MIF, true);
+    } else {
+      rc = SysMem::Instance()->MemoryRelease(SysMem::MIF);
+    }
+
+    CHRE_ASSERT_LOG(rc == 0,
+                    "Unable to change DRAM access to %d with error code %d",
+                    enabled, rc);
+  }
+}
+
+}  // namespace chre
diff --git a/platform/aoc/fatal_error.cc b/platform/aoc/fatal_error.cc
new file mode 100644
index 0000000..ae3903d
--- /dev/null
+++ b/platform/aoc/fatal_error.cc
@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2020 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 "chre/target_platform/fatal_error.h"
+
+#include "chre/platform/shared/platform_log.h"
+
+namespace chre {
+
+void preFatalError() {
+  // TODO: stubbed out, Implement this.
+}
+
+}  // namespace chre
diff --git a/platform/aoc/host_link.cc b/platform/aoc/host_link.cc
new file mode 100644
index 0000000..2c0d638
--- /dev/null
+++ b/platform/aoc/host_link.cc
@@ -0,0 +1,541 @@
+/*
+ * Copyright (C) 2020 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 "chre/platform/host_link.h"
+
+#include "chre/core/event_loop_manager.h"
+#include "chre/core/host_comms_manager.h"
+#include "chre/core/settings.h"
+#include "chre/platform/aoc/system_time.h"
+#include "chre/platform/shared/host_protocol_chre.h"
+#include "chre/platform/shared/nanoapp_load_manager.h"
+#include "chre/util/fixed_size_blocking_queue.h"
+#include "chre/util/flatbuffers/helpers.h"
+#include "chre_api/chre/version.h"
+
+namespace chre {
+
+Nanoseconds HostLinkBase::mLastTimeSyncRequestNanos(0);
+
+namespace {
+
+//! Used to pass the client ID through the user data pointer in deferCallback
+union HostClientIdCallbackData {
+  uint16_t hostClientId;
+  void *ptr;
+};
+static_assert(sizeof(uint16_t) <= sizeof(void *),
+              "Pointer must at least fit a u16 for passing the host client ID");
+
+struct LoadNanoappCallbackData {
+  uint64_t appId;
+  uint32_t transactionId;
+  uint16_t hostClientId;
+  UniquePtr<Nanoapp> nanoapp;
+  uint32_t fragmentId;
+};
+
+struct UnloadNanoappCallbackData {
+  uint64_t appId;
+  uint32_t transactionId;
+  uint16_t hostClientId;
+  bool allowSystemNanoappUnload;
+};
+
+inline HostCommsManager &getHostCommsManager() {
+  return EventLoopManagerSingleton::get()->getHostCommsManager();
+}
+
+void setTimeSyncRequestTimer(Nanoseconds delay) {
+  static TimerHandle sHandle;
+  static bool sHandleInitialized;
+
+  if (sHandleInitialized) {
+    EventLoopManagerSingleton::get()->cancelDelayedCallback(sHandle);
+  }
+
+  auto callback = [](uint16_t /* eventType */, void * /* data */) {
+    HostLinkBase::sendTimeSyncRequest();
+  };
+  sHandle = EventLoopManagerSingleton::get()->setDelayedCallback(
+      SystemCallbackType::TimerSyncRequest, nullptr /* data */, callback,
+      delay);
+  sHandleInitialized = true;
+}
+
+bool getSettingFromFbs(fbs::Setting setting, Setting *chreSetting) {
+  bool success = true;
+  switch (setting) {
+    case fbs::Setting::LOCATION:
+      *chreSetting = Setting::LOCATION;
+      break;
+    default:
+      LOGE("Unknown setting %" PRIu8, setting);
+      success = false;
+  }
+
+  return success;
+}
+
+bool getSettingStateFromFbs(fbs::SettingState state,
+                            SettingState *chreSettingState) {
+  bool success = true;
+  switch (state) {
+    case fbs::SettingState::DISABLED:
+      *chreSettingState = SettingState::DISABLED;
+      break;
+    case fbs::SettingState::ENABLED:
+      *chreSettingState = SettingState::ENABLED;
+      break;
+    default:
+      LOGE("Unknown state %" PRIu8, state);
+      success = false;
+  }
+
+  return success;
+}
+
+void sendDebugDumpData(uint16_t hostClientId, const char *debugStr,
+                       size_t debugStrSize) {
+  constexpr size_t kFixedSizePortion = 52;
+  ChreFlatBufferBuilder builder(kFixedSizePortion + debugStrSize);
+  HostProtocolChre::encodeDebugDumpData(builder, hostClientId, debugStr,
+                                        debugStrSize);
+
+  getHostCommsManager().send(builder.GetBufferPointer(), builder.GetSize());
+}
+
+void sendDebugDumpResponse(uint16_t hostClientId, bool success,
+                           uint32_t dataCount) {
+  constexpr size_t kFixedSizePortion = 52;
+  ChreFlatBufferBuilder builder(kFixedSizePortion);
+  HostProtocolChre::encodeDebugDumpResponse(builder, hostClientId, success,
+                                            dataCount);
+  getHostCommsManager().send(builder.GetBufferPointer(), builder.GetSize());
+}
+
+void constructNanoappListCallback(uint16_t /*eventType*/, void *deferCbData) {
+  HostClientIdCallbackData clientIdCbData;
+  clientIdCbData.ptr = deferCbData;
+
+  struct NanoappListData {
+    ChreFlatBufferBuilder *builder;
+    DynamicVector<NanoappListEntryOffset> nanoappEntries;
+  };
+  NanoappListData cbData;
+
+  EventLoop &eventLoop = EventLoopManagerSingleton::get()->getEventLoop();
+  size_t expectedNanoappCount = eventLoop.getNanoappCount();
+  if (!cbData.nanoappEntries.reserve(expectedNanoappCount)) {
+    LOG_OOM();
+  } else {
+    constexpr size_t kFixedOverhead = 48;
+    constexpr size_t kPerNanoappSize = 32;
+    size_t initialBufferSize =
+        (kFixedOverhead + expectedNanoappCount * kPerNanoappSize);
+
+    ChreFlatBufferBuilder builder(initialBufferSize);
+    cbData.builder = &builder;
+
+    auto nanoappAdderCallback = [](const Nanoapp *nanoapp, void *data) {
+      auto *listData = static_cast<NanoappListData *>(data);
+      HostProtocolChre::addNanoappListEntry(
+          *(listData->builder), listData->nanoappEntries, nanoapp->getAppId(),
+          nanoapp->getAppVersion(), true /*enabled*/,
+          nanoapp->isSystemNanoapp());
+    };
+    eventLoop.forEachNanoapp(nanoappAdderCallback, &cbData);
+    HostProtocolChre::finishNanoappListResponse(builder, cbData.nanoappEntries,
+                                                clientIdCbData.hostClientId);
+    getHostCommsManager().send(builder.GetBufferPointer(), builder.GetSize());
+  }
+}
+
+void sendFragmentResponse(uint16_t hostClientId, uint32_t transactionId,
+                          uint32_t fragmentId, bool success) {
+  constexpr size_t kInitialBufferSize = 52;
+  ChreFlatBufferBuilder builder(kInitialBufferSize);
+  HostProtocolChre::encodeLoadNanoappResponse(
+      builder, hostClientId, transactionId, success, fragmentId);
+
+  if (!getHostCommsManager().send(builder.GetBufferPointer(),
+                                  builder.GetSize())) {
+    LOGE(
+        "Failed to send fragment response for HostClientID: %x FragmentID: %x"
+        "transactionID: 0x%x",
+        hostClientId, fragmentId, transactionId);
+  }
+}
+
+void finishLoadingNanoappCallback(uint16_t /*eventType*/, void *data) {
+  UniquePtr<LoadNanoappCallbackData> cbData(
+      static_cast<LoadNanoappCallbackData *>(data));
+  constexpr size_t kInitialBufferSize = 48;
+  ChreFlatBufferBuilder builder(kInitialBufferSize);
+
+  CHRE_ASSERT(cbData != nullptr);
+  LOGD("Finished loading nanoapp cb on fragment ID: %u", cbData->fragmentId);
+
+  EventLoop &eventLoop = EventLoopManagerSingleton::get()->getEventLoop();
+  bool success =
+      cbData->nanoapp->isLoaded() && eventLoop.startNanoapp(cbData->nanoapp);
+
+  sendFragmentResponse(cbData->hostClientId, cbData->transactionId,
+                       cbData->fragmentId, success);
+}
+
+void handleUnloadNanoappCallback(uint16_t /*eventType*/, void *data) {
+  auto *cbData = static_cast<UnloadNanoappCallbackData *>(data);
+  bool success = false;
+  uint32_t instanceId;
+  EventLoop &eventLoop = EventLoopManagerSingleton::get()->getEventLoop();
+  if (!eventLoop.findNanoappInstanceIdByAppId(cbData->appId, &instanceId)) {
+    LOGE("Couldn't unload app ID 0x%016" PRIx64 ": not found", cbData->appId);
+  } else {
+    success =
+        eventLoop.unloadNanoapp(instanceId, cbData->allowSystemNanoappUnload);
+  }
+
+  constexpr size_t kInitialBufferSize = 52;
+  ChreFlatBufferBuilder builder(kInitialBufferSize);
+  HostProtocolChre::encodeUnloadNanoappResponse(builder, cbData->hostClientId,
+                                                cbData->transactionId, success);
+
+  if (!getHostCommsManager().send(builder.GetBufferPointer(),
+                                  builder.GetSize())) {
+    LOGE("Failed to send unload response to host: %x transactionID: 0x%x",
+         cbData->hostClientId, cbData->transactionId);
+  }
+
+  memoryFree(data);
+}
+
+}  // anonymous namespace
+
+void sendDebugDumpResultToHost(uint16_t hostClientId, const char *debugStr,
+                               size_t debugStrSize, bool complete,
+                               uint32_t dataCount) {
+  if (debugStrSize > 0) {
+    sendDebugDumpData(hostClientId, debugStr, debugStrSize);
+  }
+
+  if (complete) {
+    sendDebugDumpResponse(hostClientId, true /*success*/, dataCount);
+  }
+}
+
+void HostLink::flushMessagesSentByNanoapp(uint64_t /* appId */) {
+  // TODO: Implement this once USF supports this (b/149318001)
+}
+
+bool HostLink::sendMessage(const MessageToHost *message) {
+  constexpr size_t kFixedReserveSize = 80;
+  ChreFlatBufferBuilder builder(message->message.size() + kFixedReserveSize);
+  HostProtocolChre::encodeNanoappMessage(
+      builder, message->appId, message->toHostData.messageType,
+      message->toHostData.hostEndpoint, message->message.data(),
+      message->message.size());
+
+  bool success =
+      getHostCommsManager().send(builder.GetBufferPointer(), builder.GetSize());
+
+  getHostCommsManager().onMessageToHostComplete(message);
+
+  return success;
+}
+
+HostLinkBase::HostLinkBase() {
+  usf::UsfErr err = usf::UsfTransportMgr::SetMsgHandler(
+      usf::UsfMsgType::UsfMsgType_CHRE, handleUsfMessage, nullptr);
+  if (err == usf::kErrNone) {
+    err = usf::UsfWorkMgr::CreateWorker(&mWorker);
+  }
+
+  if (err != usf::kErrNone) {
+    FATAL_ERROR("Failed to initialize CHRE transport");
+  }
+}
+
+HostLinkBase::~HostLinkBase() {
+  mWorker->Stop();
+  mWorker.reset();
+}
+
+void HostLinkBase::init(usf::UsfTransport *transport) {
+  if (mTransportHandle == nullptr) {
+    if (transport == nullptr) {
+      FATAL_ERROR("Null transport at init, cannot send out messages!");
+    }
+    mTransportHandle = transport;
+  }
+}
+
+bool HostLinkBase::send(uint8_t *data, size_t dataLen) {
+  usf::UsfErr err = usf::kErrFailed;
+
+  if (mTransportHandle != nullptr) {
+    usf::UsfTxMsg msg;
+    msg.SetMsgType(usf::UsfMsgType_CHRE);
+    msg.SetData(data, dataLen);
+    err = mTransportHandle->SendMsg(&msg);
+  }
+
+  return (usf::kErrNone == err);
+}
+
+usf::UsfErr HostLinkBase::handleUsfMessage(usf::UsfTransport *transport,
+                                           const usf::UsfMsg *msg,
+                                           void * /* arg */) {
+  usf::UsfErr rc = usf::kErrFailed;
+  getHostCommsManager().init(transport);
+
+  if (msg == nullptr) {
+    rc = usf::kErrInvalid;
+  } else {
+    usf::UsfMsgType msgType = msg->msg_type();
+
+    if (msgType == usf::UsfMsgType_CHRE) {
+      auto *dataVector = msg->data();
+      if (dataVector != nullptr) {
+        size_t dataLen = dataVector->size();
+        struct MessageData {
+          uint64_t dataLen;
+          void *data;
+        };
+
+        // handleUsfMessage isn't single-threaded. Make a copy and process
+        // on a worker thread to ensure CHRE only processes incoming messages
+        // on a single thread. CHRE's thread isn't used since several messages
+        // can be processed without posting to it.
+        //
+        // TODO(b/163592230): Improve USF messaging interface to remove extra
+        // data copies and keep work single-threaded.
+        MessageData data;
+        data.dataLen = dataLen;
+        data.data = memoryAlloc(dataLen);
+        if (data.data == nullptr) {
+          LOG_OOM();
+          rc = usf::kErrAllocation;
+        } else {
+          memcpy(data.data, dataVector->data(), dataLen);
+
+          auto callback = [](void *data) {
+            MessageData *dataInfo = static_cast<MessageData *>(data);
+            HostProtocolChre::decodeMessageFromHost(dataInfo->data,
+                                                    dataInfo->dataLen);
+            memoryFree(dataInfo->data);
+            // USF owns the passed in data pointer and will free it after the
+            // callback returns.
+          };
+          rc = getHostCommsManager().getWorker()->Enqueue(callback, &data,
+                                                          sizeof(data));
+        }
+      }
+    } else {
+      rc = usf::kErrInvalid;
+    }
+  }
+
+  // Opportunistically send a time sync message (1 hour period threshold)
+  constexpr Seconds kOpportunisticTimeSyncPeriod = Seconds(60 * 60 * 1);
+  if (SystemTime::getMonotonicTime() >
+      mLastTimeSyncRequestNanos + kOpportunisticTimeSyncPeriod) {
+    sendTimeSyncRequest();
+  }
+
+  return rc;
+}
+
+void HostLinkBase::sendLogMessage(const uint8_t *logMessage,
+                                  size_t logMessageSize) {
+  constexpr size_t kInitialSize = 128;
+  ChreFlatBufferBuilder builder(logMessageSize + kInitialSize);
+  HostProtocolChre::encodeLogMessages(builder, logMessage, logMessageSize);
+
+  getHostCommsManager().send(builder.GetBufferPointer(), builder.GetSize());
+}
+
+void HostLinkBase::sendTimeSyncRequest() {
+  constexpr size_t kInitialSize = 52;
+  ChreFlatBufferBuilder builder(kInitialSize);
+  HostProtocolChre::encodeTimeSyncRequest(builder);
+
+  getHostCommsManager().send(builder.GetBufferPointer(), builder.GetSize());
+
+  mLastTimeSyncRequestNanos = SystemTime::getMonotonicTime();
+}
+
+void HostMessageHandlers::handleDebugDumpRequest(uint16_t hostClientId) {
+  chre::EventLoopManagerSingleton::get()
+      ->getDebugDumpManager()
+      .onDebugDumpRequested(hostClientId);
+}
+
+void HostMessageHandlers::handleHubInfoRequest(uint16_t hostClientId) {
+  constexpr size_t kInitialBufferSize = 192;
+
+  constexpr char kHubName[] = "CHRE on AoC";
+  constexpr char kVendor[] = "Google";
+  constexpr char kToolchain[] =
+      "Clang " STRINGIFY(__clang_major__) "." STRINGIFY(
+          __clang_minor__) "." STRINGIFY(__clang_patchlevel__) ")";
+  constexpr uint32_t kLegacyPlatformVersion = 0;
+  constexpr uint32_t kLegacyToolchainVersion =
+      ((__clang_major__ & 0xFF) << 24) | ((__clang_minor__ & 0xFF) << 16) |
+      (__clang_patchlevel__ & 0xFFFF);
+  constexpr float kPeakMips = 800;
+  // TODO: The following need to be updated when we've measured the
+  // indicated power levels on the AoC
+  constexpr float kStoppedPower = 0;
+  constexpr float kSleepPower = 0;
+  constexpr float kPeakPower = 0;
+
+  ChreFlatBufferBuilder builder(kInitialBufferSize);
+  HostProtocolChre::encodeHubInfoResponse(
+      builder, kHubName, kVendor, kToolchain, kLegacyPlatformVersion,
+      kLegacyToolchainVersion, kPeakMips, kStoppedPower, kSleepPower,
+      kPeakPower, CHRE_MESSAGE_TO_HOST_MAX_SIZE, chreGetPlatformId(),
+      chreGetVersion(), hostClientId);
+
+  if (!getHostCommsManager().send(builder.GetBufferPointer(),
+                                  builder.GetSize())) {
+    LOGE("Failed to send Hub Info Response message");
+  }
+}
+
+void HostMessageHandlers::handleLoadNanoappRequest(
+    uint16_t hostClientId, uint32_t transactionId, uint64_t appId,
+    uint32_t appVersion, uint32_t appFlags, uint32_t targetApiVersion,
+    const void *buffer, size_t bufferLen, const char *appFileName,
+    uint32_t fragmentId, size_t appBinaryLen) {
+  bool success = true;
+  static NanoappLoadManager sLoadManager;
+
+  if (fragmentId == 0 || fragmentId == 1) {
+    size_t totalAppBinaryLen = (fragmentId == 0) ? bufferLen : appBinaryLen;
+    LOGD("Load nanoapp request for app ID 0x%016" PRIx64 " ver 0x%" PRIx32
+         " flags 0x%" PRIx32 " target API 0x%08" PRIx32
+         " size %zu (txnId %" PRIu32 " client %" PRIu16 ")",
+         appId, appVersion, appFlags, targetApiVersion, totalAppBinaryLen,
+         transactionId, hostClientId);
+
+    if (sLoadManager.hasPendingLoadTransaction()) {
+      FragmentedLoadInfo info = sLoadManager.getTransactionInfo();
+      sendFragmentResponse(info.hostClientId, info.transactionId,
+                           0 /* fragmentId */, false /* success */);
+      sLoadManager.markFailure();
+    }
+
+    success =
+        sLoadManager.prepareForLoad(hostClientId, transactionId, appId,
+                                    appVersion, appFlags, totalAppBinaryLen);
+  }
+
+  if (success) {
+    success = sLoadManager.copyNanoappFragment(
+        hostClientId, transactionId, (fragmentId == 0) ? 1 : fragmentId, buffer,
+        bufferLen);
+  } else {
+    LOGE("Failed to prepare for load");
+  }
+
+  if (sLoadManager.isLoadComplete()) {
+    LOGD("Load manager load complete...");
+    auto cbData = MakeUnique<LoadNanoappCallbackData>();
+    if (cbData.isNull()) {
+      LOG_OOM();
+    } else {
+      cbData->transactionId = transactionId;
+      cbData->hostClientId = hostClientId;
+      cbData->appId = appId;
+      cbData->fragmentId = fragmentId;
+      cbData->nanoapp = sLoadManager.releaseNanoapp();
+
+      // Note that if this fails, we'll generate the error response in
+      // the normal deferred callback
+      EventLoopManagerSingleton::get()->deferCallback(
+          SystemCallbackType::FinishLoadingNanoapp, cbData.release(),
+          finishLoadingNanoappCallback);
+    }
+  } else {
+    // send a response for this fragment
+    sendFragmentResponse(hostClientId, transactionId, fragmentId, success);
+  }
+}
+
+void HostMessageHandlers::handleNanoappListRequest(uint16_t hostClientId) {
+  LOGD("Nanoapp list request from client ID %" PRIu16, hostClientId);
+  HostClientIdCallbackData cbData = {};
+  cbData.hostClientId = hostClientId;
+  EventLoopManagerSingleton::get()->deferCallback(
+      SystemCallbackType::NanoappListResponse, cbData.ptr,
+      constructNanoappListCallback);
+}
+
+void HostMessageHandlers::handleNanoappMessage(uint64_t appId,
+                                               uint32_t messageType,
+                                               uint16_t hostEndpoint,
+                                               const void *messageData,
+                                               size_t messageDataLen) {
+  LOGD("Parsed nanoapp message from host: app ID 0x%016" PRIx64
+       " endpoint 0x%" PRIx16 " msgType %" PRIu32 " payload size %zu",
+       appId, hostEndpoint, messageType, messageDataLen);
+
+  getHostCommsManager().sendMessageToNanoappFromHost(
+      appId, messageType, hostEndpoint, messageData, messageDataLen);
+}
+
+void HostMessageHandlers::handleSettingChangeMessage(fbs::Setting setting,
+                                                     fbs::SettingState state) {
+  Setting chreSetting;
+  SettingState chreSettingState;
+  if (getSettingFromFbs(setting, &chreSetting) &&
+      getSettingStateFromFbs(state, &chreSettingState)) {
+    postSettingChange(chreSetting, chreSettingState);
+  }
+}
+
+void HostMessageHandlers::handleTimeSyncMessage(int64_t offset) {
+  setEstimatedHostTimeOffset(offset);
+
+  // Schedule a time sync request since offset may drift
+  constexpr Seconds kClockDriftTimeSyncPeriod =
+      Seconds(60 * 60 * 6);  // 6 hours
+  setTimeSyncRequestTimer(kClockDriftTimeSyncPeriod);
+}
+
+void HostMessageHandlers::handleUnloadNanoappRequest(
+    uint16_t hostClientId, uint32_t transactionId, uint64_t appId,
+    bool allowSystemNanoappUnload) {
+  LOGD("Unload nanoapp request (txnID %" PRIu32 ") for appId 0x%016" PRIx64
+       " system %d",
+       transactionId, appId, allowSystemNanoappUnload);
+  auto *cbData = memoryAlloc<UnloadNanoappCallbackData>();
+  if (cbData == nullptr) {
+    LOG_OOM();
+  } else {
+    cbData->appId = appId;
+    cbData->transactionId = transactionId;
+    cbData->hostClientId = hostClientId;
+    cbData->allowSystemNanoappUnload = allowSystemNanoappUnload;
+
+    EventLoopManagerSingleton::get()->deferCallback(
+        SystemCallbackType::HandleUnloadNanoapp, cbData,
+        handleUnloadNanoappCallback);
+  }
+}
+
+}  // namespace chre
diff --git a/platform/aoc/include/chre/platform/aoc/audio_controller.h b/platform/aoc/include/chre/platform/aoc/audio_controller.h
new file mode 100644
index 0000000..76d19e3
--- /dev/null
+++ b/platform/aoc/include/chre/platform/aoc/audio_controller.h
@@ -0,0 +1,185 @@
+/*
+ * Copyright (C) 2020 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 CHRE_PLATFORM_AOC_AUDIO_CONTROLLER_H_
+#define CHRE_PLATFORM_AOC_AUDIO_CONTROLLER_H_
+
+#include "chre/platform/log.h"
+#include "chre/platform/system_time.h"
+#include "chre/target_platform/init.h"
+#include "chre/util/time.h"
+#include "chre_api/chre/audio.h"
+
+#include "aoc/common/include/controller_ipc_aoc.h"
+#include "aoc/common/include/pipe_ipc_receiver_aoc.h"
+
+#include "efw/include/controller.h"
+
+#include "chre/platform/aoc/audio_filter.h"
+
+namespace chre {
+
+/**
+ * This class implements an audio controller, which sets up a filter object
+ * for buffering audio (see audio_filter.h), and manages both local and
+ * remote core commands to route audio data from the microphone to CHRE.
+ * To ensure proper timing of operation, commands are processed in a request-
+ * response pattern. The controller handles messages inbound from the remote
+ * core directly, via a PipeIPCReceiver object that it instantiates and binds
+ * to, while delegating outbound messages to a ControllerIPC object
+ * that it also instantiates. The controller handles all CHRE platform audio
+ * calls, relaying and collecting relevant information and data from the
+ * audio filter.
+ *
+ * Limitations:
+ *  - Only a single microphone channel is currently supported
+ */
+class AudioController : public Controller {
+ public:
+  static constexpr size_t kMaxAocMicrophones = 1;
+
+  AudioController();
+
+  /**
+   * Calls the base class SetUp method, initializes audio source data,
+   * and initializes cross core communication.
+   */
+  void SetUp() override;
+
+  /**
+   * Sends a command to the remote core indicating that the A32 Audio
+   * Controller is fully up and ready to process data. This prompts
+   * the DSP to setup its own CHRE Audio Controller.
+   */
+  void SetUpRemoteCore();
+
+  /**
+   * Calls the base class TearDown method, and unbinds the shared ring
+   * buffer from the audio filter, and shuts the filter down.
+   */
+  void TearDown() override;
+
+  /**
+   * Handles commands inbound to the filter. This method is only
+   * invoked if the IPC channel for this controller and its cross
+   * core peer has been configured and setup correctly, else all
+   * messages are dropped by default by the worker thread.
+   *
+   * @return We always return true from this function to not trigger
+   * assertions in the underlying CmdThread, regardless of whether
+   * we received a valid command or not. On receiving a command not
+   * recognized by the controller, we simply set the command reply to
+   * an error value (-1).
+   */
+  bool CmdProcessor(struct CMD_HDR *cmd) override;
+
+  /**
+   * Get audio source information
+   *
+   * @return Pointer to chreAudioSource
+   */
+  const chreAudioSource *GetSource(uint32_t handle) const;
+
+  /**
+   * Enables audio requests on a handle
+   *
+   * @param handle Handle to be enabled
+   *
+   * @param enabled Handle is enabled if true, disabled otherwise
+   */
+  void SetEnabled(uint32_t handle, bool enabled);
+
+  /**
+   * Request audio data from given handle/source.
+   *
+   * @param handle Handle to an audio source to request data from.
+   *
+   * @return true on success
+   */
+  bool RequestAudio(uint32_t handle);
+
+  /**
+   * Cancel/Release audio data events from given handle.
+   *
+   * @param handle Handle to audio source to cancel data from
+   *
+   * @return true on success
+   */
+  bool ReleaseAudio(uint32_t handle);
+
+  /**
+   * Called by the CHRE release audio data event callback, this function
+   * lets the filter know that the current audio buffer was processed
+   * by all clients.
+   */
+  void OnBufferReleased();
+
+ private:
+  static constexpr uint64_t kSupportedDurationNs =
+      Seconds(AudioFilter::kSupportedDurationSeconds).toRawNanoseconds();
+  static constexpr const char *kMicrophoneName = "MIC_0";
+
+  bool mDspCoreInitDone = false;
+  bool mRequestStarted = false;
+
+  const chreAudioSource kAudioSource = {
+      .name = kMicrophoneName,
+      .sampleRate = AudioFilter::kSupportedSampleRate,
+      .minBufferDuration = kSupportedDurationNs,
+      .maxBufferDuration = kSupportedDurationNs,
+      .format = CHRE_AUDIO_DATA_FORMAT_16_BIT_SIGNED_PCM};
+
+  chreAudioSourceStatus mSourceStatus = {.enabled = false, .suspended = false};
+
+  AudioFilter mFilter;
+
+  // The peer Controller IPC to the CHRE controller on the DSP,
+  // this class handles outbound messages from the audio controller.
+  ControllerIpcAoC mControllerIpcAoc;
+
+  // The peer Pipe Receiver to the CHRE pipe instance on the DSP,
+  // this class receives IPC pipe notifications sent by the said
+  // remote pipe.
+  PipeIpcReceiverAoC mPipeIpcReceiverAoc;
+
+  /**
+   * Invoked by the command processor when it gets a 'Ready'
+   * message from the DSP. Binds the Pipe object to the audio filter's
+   * input, and binds the ipc ring buffer to the audio filter.
+   *
+   * @return 0 on success, -1 otherwise.
+   */
+  int OnDspReady();
+
+  /**
+   * Checks the current streaming state of a handle/channel, sends
+   * a command to the remote core to start/stop streaming if they
+   * don't match, and updates the current state on the handle.
+   * Note that there's an ~50ms latency for a new 'start' on a handle.
+   *
+   * @param start Start streaming if enabled, stop otherwise.
+   *
+   * @return true on success.
+   *
+   * TODO: Handle the 'handle' parameter when multiple channels are supported,
+   * and update the state tracking logic accordingly.
+   */
+  bool UpdateStream(uint32_t handle, bool start);
+};
+
+}  // namespace chre
+
+#endif  // CHRE_PLATFORM_AOC_AUDIO_CONTROLLER_H_
diff --git a/platform/aoc/include/chre/platform/aoc/audio_filter.h b/platform/aoc/include/chre/platform/aoc/audio_filter.h
new file mode 100644
index 0000000..de96c7b
--- /dev/null
+++ b/platform/aoc/include/chre/platform/aoc/audio_filter.h
@@ -0,0 +1,167 @@
+/*
+ * Copyright (C) 2020 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 CHRE_PLATFORM_AOC_AUDIO_FILTER_H_
+#define CHRE_PLATFORM_AOC_AUDIO_FILTER_H_
+
+#include "chre_api/chre/audio.h"
+#include "efw/include/filter.h"
+#include "filters/audio/common/include/audio_metadata.h"
+
+namespace chre {
+
+/**
+ * This class implements an audio filter, whose primary purpose is to
+ * read audio samples from a shared ring buffer, process it, and route
+ * it to registered audio clients. 'Filter', in this context, means a
+ * data processing unit (audio data itself is raw, with no actual filtering
+ * done on it). The audio filter is fully controlled by an instance of an
+ * audio controller object (see audio_controller.h). The interaction occurs
+ * as follows:
+ *  - The controller instantiates a filter, and upon notification from the
+ *    remote core that a ring buffer is available, binds it to the filter.
+ *  - The controller also binds an IPC Pipe to the filter's input. The pipe's
+ *    primary (and only) purpose is to notify the filter that there's fresh
+ *    data in the ring buffer.
+ *  - The filter then reads the ring buffer, does some processing (strip
+ *    timestamps, format data, etc.), and sends said data out to clients via
+ *    the CHRE AudioRequestManager.
+ *  The filter instantiates a worker thread, which is woken up by any one of
+ *  the following two mechanisms (outside of the automatic watchdog pet wakeup):
+ *  - 'Signal': A signal is an internal (to the core) command, sent by the main
+ *  audio controller, to notify the filter of local (to the core) conditions.
+ *  For example, CHRE called a free data event, which the controller receives,
+ *  and notifies the filter. Signals are processed by overloading the
+ *  SignalProcessor method of the filter base class.
+ *  - 'Input': An input is a cross core notification that the filter registers
+ *  to, via the pipe that's bound to it. On a pipe notification, the thread
+ *  wakes up to read/process data, which is done by overloading the
+ *  InputProcessor method of the filter base class.
+ *
+ *  TODO:
+ *  1 - Audio samples are currently collected and processed in SRAM, need to
+ *      copy out to DRAM before passing to nanoapps, to free up the 2-sec
+ *      buffer to resume collecting samples.
+ *  2 - Only a single channel (of the 4 available) is currently supported
+ *      (blocked by 1)..
+ *  3 - The Input processor drops audio samples while the current buffer
+ *      is being serviced by clients (blocked by 1)
+ */
+
+class AudioFilter : public Filter {
+ public:
+  // Defines the index of a signal sent by the controller
+  // on receiving CHRE's freeAudioDataEvent.
+  static constexpr size_t kBufferReleasedSignalIndex = 0;
+
+  // Defines the index at which the audio controller's IPC pipe binds to
+  // the filter input. Note that this is dictated by the 'Num Inputs'
+  // parameter to the filter constructor.
+  static constexpr size_t kPipeIndex = 0;
+
+  // Defines the index at which the audio controller's IPC ring buffer
+  // binds to the filter's ring buffer array. Note that this is dictated
+  // by the 'Num Ring Buffers' parameter to the filter constructor.
+  static constexpr size_t kRingIndex = 0;
+
+  static constexpr uint32_t kSupportedSampleRate = 16000;
+  static constexpr uint32_t kSupportedDurationSeconds = 2;
+
+  AudioFilter();
+
+  /**
+   * Callback that's called at the start of  the 'Start' method,
+   * and before the worker thread has been instantiated.
+   *
+   * @return 0 on success, -1 otherwise.
+   */
+  int StartCallback() override final;
+
+  /**
+   * Callback that gets called at the end of the 'Stop' method,
+   * and after the worker thread has been shutdown.
+   *
+   * @return true on success
+   */
+  bool StopCallback() override final;
+
+  /**
+   * Method that handles commands that are internal to the core,
+   * typically sent by the audio controller. The argument to the
+   * function is predicated by the 'Command Depth' argument to the
+   * constructor. If the filter is expected to process a new signal,
+   * then the constructor argument needs to be incremented as well,
+   * as any index exceeding this is automatically dropped.
+   *
+   * @param index Signal ID (less than command depth) sent by the
+   * controller
+   *
+   * @return true on valid command and processing success
+   */
+  bool SignalProcessor(int index) override final;
+
+  /**
+   * Method that handles cross core pipe notifications, if one was bound
+   * to the filter's input. The 'pin' argument to the function is predicated
+   * by the 'Num Filter Inputs' argument to the constructor. If the filter is
+   * expected to process a new input (via a new pipe being bound to its
+   * input), then the constructor argument needs to be incremented as well,
+   * as any index exceeding this is automatically dropped. The pipe index
+   * depends on the order that InputBind was called. No lookup is provided,
+   * and the application is expected to keep track of this (maybe via an
+   * external enum).
+   *
+   * @param pin Index of the input pipe that was bound to the filter.
+   *
+   * @param message Input pipe notification to be processed. This can be
+   * a nullptr - which just means that the pipe wanted to notify a certain
+   * condition, but had no metadata to provide.
+   *
+   * @param size Input message size. Can be zero, if the pipe had no
+   * metadata to send.
+   */
+  void InputProcessor(int pin, void *message, size_t size) override final;
+
+  /**
+   * Callback that's invoked on CHRE's release audio data event.
+   *
+   * TODO: This needs to be refactored when we store audio samples in DRAM.
+   */
+  void OnBufferReleased();
+
+ private:
+  static constexpr size_t kSamplesPer2Sec =
+      kSupportedSampleRate * kSupportedDurationSeconds;
+
+  int16_t mSampleBuffer[kSamplesPer2Sec];
+  void *mRingBufferHandle = nullptr;
+  size_t mSampleCount = 0;
+  bool mBufferInUse = false;
+
+  struct chreAudioDataEvent mDataEvent = {
+      .version = CHRE_AUDIO_DATA_EVENT_VERSION,
+      .reserved = {0, 0, 0},
+      .handle = 0,
+      .timestamp = 0,
+      .sampleRate = kSupportedSampleRate,
+      .sampleCount = 0,
+      .format = CHRE_AUDIO_DATA_FORMAT_16_BIT_SIGNED_PCM,
+      .samplesS16 = nullptr};
+};
+
+}  // namespace chre
+
+#endif  // CHRE_PLATFORM_AOC_AUDIO_FILTER_H_
diff --git a/platform/aoc/include/chre/platform/aoc/memory.h b/platform/aoc/include/chre/platform/aoc/memory.h
new file mode 100644
index 0000000..38b6928
--- /dev/null
+++ b/platform/aoc/include/chre/platform/aoc/memory.h
@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2020 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 CHRE_PLATFORM_AOC_MEMORY_H_
+#define CHRE_PLATFORM_AOC_MEMORY_H_
+
+#include <cstddef>
+
+#include "chre/platform/shared/memory.h"
+
+namespace chre {
+
+/**
+ * Memory allocation specifically using the DRAM heap. The semantics are the
+ * same as malloc.
+ */
+void *memoryAllocDram(size_t size);
+
+/**
+ * Memory free from memory allocated using the DRAM heap. The semantics are the
+ * same as free.
+ */
+void memoryFreeDram(void *pointer);
+
+}  // namespace chre
+
+#endif  // CHRE_PLATFORM_AOC_MEMORY_H_
diff --git a/platform/aoc/include/chre/platform/aoc/system_time.h b/platform/aoc/include/chre/platform/aoc/system_time.h
new file mode 100644
index 0000000..26c4fca
--- /dev/null
+++ b/platform/aoc/include/chre/platform/aoc/system_time.h
@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2019 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 CHRE_PLATFORM_AOC_SYSTEM_TIME_H_
+#define CHRE_PLATFORM_AOC_SYSTEM_TIME_H_
+
+#include <cstdint>
+
+namespace chre {
+
+/**
+ * Sets the estimated offset between the host and AoC clock.
+ *
+ * @param offset The current estimated offset in nanoseconds.
+ */
+void setEstimatedHostTimeOffset(int64_t offset);
+
+}  // namespace chre
+
+#endif  // CHRE_PLATFORM_AOC_SYSTEM_TIME_H_
diff --git a/platform/aoc/include/chre/target_platform/assert.h b/platform/aoc/include/chre/target_platform/assert.h
new file mode 100644
index 0000000..aec4e33
--- /dev/null
+++ b/platform/aoc/include/chre/target_platform/assert.h
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2020 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 CHRE_PLATFORM_AOC_ASSERT_H_
+#define CHRE_PLATFORM_AOC_ASSERT_H_
+
+#include "chre/platform/fatal_error.h"
+
+#define CHRE_ASSERT(condition)                                            \
+  do {                                                                    \
+    if (!(condition)) {                                                   \
+      FATAL_ERROR("Assertion failure at %s:%d", CHRE_FILENAME, __LINE__); \
+    }                                                                     \
+  } while (0)
+
+#endif  // CHRE_PLATFORM_AOC_ASSERT_H_
diff --git a/platform/aoc/include/chre/target_platform/fatal_error.h b/platform/aoc/include/chre/target_platform/fatal_error.h
new file mode 100644
index 0000000..8a5c5c8
--- /dev/null
+++ b/platform/aoc/include/chre/target_platform/fatal_error.h
@@ -0,0 +1,32 @@
+/**
+ * Copyright 2019 Google LLC. All Rights Reserved
+ *
+ * @file fatal_error.h
+ *
+ * @brief Fatal Error Handling
+ */
+
+#ifndef CHRE_PLATFORM_AOC_FATAL_ERROR_H_
+#define CHRE_PLATFORM_AOC_FATAL_ERROR_H_
+
+#include <cstdlib>
+
+#define FATAL_ERROR_QUIT() \
+  do {                     \
+    chre::preFatalError(); \
+    abort();               \
+  } while (0)
+
+namespace chre {
+
+/**
+ * Do preparation for an impending fatal error including flushing logs.
+ *
+ * It must not be possible for FATAL_ERROR() to be called by this function or
+ * any of its callees.
+ */
+void preFatalError();
+
+}  // namespace chre
+
+#endif  // CHRE_PLATFORM_AOC_FATAL_ERROR_H_
diff --git a/platform/aoc/include/chre/target_platform/host_link_base.h b/platform/aoc/include/chre/target_platform/host_link_base.h
new file mode 100644
index 0000000..638866e
--- /dev/null
+++ b/platform/aoc/include/chre/target_platform/host_link_base.h
@@ -0,0 +1,116 @@
+/*
+ * Copyright (C) 2020 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 CHRE_PLATFORM_AOC_HOST_LINK_BASE_H_
+#define CHRE_PLATFORM_AOC_HOST_LINK_BASE_H_
+
+#include "chre/util/time.h"
+
+#include "usf/error.h"
+#include "usf/usf_transport.h"
+#include "usf/usf_work.h"
+
+namespace chre {
+
+/**
+ * Helper function to send debug dump result to host.
+ */
+void sendDebugDumpResultToHost(uint16_t hostClientId, const char *debugStr,
+                               size_t debugStrSize, bool complete,
+                               uint32_t dataCount);
+
+/**
+ * This class implements a basic wrapper for sending/receiving messages over USF
+ * transports. It sets up a callback into the USF transport layer for receiving
+ * messages on instantiation. The first message that we receive from the USF
+ * transport layer includes a pointer to a 'transport' abstraction, that can be
+ * used to send messages out of CHRE.
+ *
+ * TODO: Revisit this implementation after the USF feature requests in
+ * b/149318001 and b/149317051 are fulfilled
+ */
+class HostLinkBase {
+ public:
+  HostLinkBase();
+  ~HostLinkBase();
+
+  /**
+   * Initializes the host link with the transport provided when the CHRE daemon
+   * sends its first message to AoC. If called multiple times, only the first
+   * transport is used.
+   *
+   * TODO (b/149317051) Remove this once USF exposes an API to acquire a
+   * transport for communicating with the AP.
+   */
+  void init(usf::UsfTransport *transport);
+
+  /**
+   * Sends a message to the CHRE daemon.
+   *
+   * @param data data to be sent to the daemon
+   * @param dataLen length of the data being sent
+   * @return true if the data was successfully queued for sending
+   */
+  bool send(uint8_t *data, size_t dataLen);
+
+  refcount::reffed_ptr<usf::UsfWorker> &getWorker() {
+    return mWorker;
+  }
+
+  /**
+   * The USF external message handler function for CHRE, that
+   * is invoked on CHRE inbound messages from the AP
+   *
+   * @param transport A pointer to a transport that is used to send messages
+   * out of CHRE to the AP
+   * @param msg flatbuffer encoded message of type UsfMsgType_CHRE
+   * @param arg yields the message length when cast to size_t
+   * @return usf::kErrNone if success, an error code indicating the failure
+   * otherwise
+   */
+  static usf::UsfErr handleUsfMessage(usf::UsfTransport *transport,
+                                      const usf::UsfMsg *msg, void *arg);
+
+  /**
+   * Sends a request to the host for a time sync message.
+   */
+  static void sendTimeSyncRequest();
+
+  /**
+   * Enqueues a log message to be sent to the host.
+   *
+   * @param logMessage Pointer to a buffer that has the log message. Note that
+   * the message might be encoded
+   *
+   * @param logMessageSize length of the log message buffer
+   */
+  void sendLogMessage(const uint8_t *logMessage, size_t logMessageSize);
+
+ private:
+  //! The last time a time sync request message has been sent.
+  static Nanoseconds mLastTimeSyncRequestNanos;
+
+  //! Transport handle provided when the CHRE daemon sends its first message
+  //! to AoC.
+  usf::UsfTransport *mTransportHandle = nullptr;
+
+  //! Worker thread used to ensure single-threaded communication with CHRE.
+  refcount::reffed_ptr<usf::UsfWorker> mWorker;
+};
+
+}  // namespace chre
+
+#endif  // CHRE_PLATFORM_AOC_HOST_LINK_BASE_H_
diff --git a/platform/aoc/include/chre/target_platform/log.h b/platform/aoc/include/chre/target_platform/log.h
new file mode 100644
index 0000000..f2fb3d5
--- /dev/null
+++ b/platform/aoc/include/chre/target_platform/log.h
@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2020 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 CHRE_PLATFORM_AOC_LOG_H_
+#define CHRE_PLATFORM_AOC_LOG_H_
+
+#include <chre.h>
+#include <stdio.h>
+#include "efw_log.h"
+
+#ifndef __FILENAME__
+#ifdef __BASE_FILE__
+#define __FILENAME__ __BASE_FILE__
+#else
+#define __FILENAME__ __FILE__
+#endif  // __BASE_FILE__
+#endif  // __FILE_NAME__
+
+#ifndef CHRE_DL_VERBOSE
+#define CHRE_DL_VERBOSE false
+#endif  // CHRE_DL_VERBOSE
+
+// TODO(b/149317051): The printf in the below macro is needed until CHRE can log
+// to the AP before the daemon has connected to AoC.
+#define CHRE_AOC_LOG(level, fmt, ...)                               \
+  do {                                                              \
+    CHRE_LOG_PREAMBLE                                               \
+    chre::log(level, fmt, ##__VA_ARGS__);                           \
+    DBG_MSG_RAW(255, "CHRE:%s:%d\t" fmt "", __FILENAME__, __LINE__, \
+                ##__VA_ARGS__);                                     \
+    CHRE_LOG_EPILOGUE                                               \
+  } while (0)
+
+#define LOGE(fmt, ...) CHRE_AOC_LOG(CHRE_LOG_ERROR, fmt, ##__VA_ARGS__)
+#define LOGW(fmt, ...) CHRE_AOC_LOG(CHRE_LOG_WARN, fmt, ##__VA_ARGS__)
+#define LOGI(fmt, ...) CHRE_AOC_LOG(CHRE_LOG_INFO, fmt, ##__VA_ARGS__)
+#define LOGD(fmt, ...) CHRE_AOC_LOG(CHRE_LOG_DEBUG, fmt, ##__VA_ARGS__)
+
+#if CHRE_DL_VERBOSE
+#define LOGV(fmt, ...) LOGD(fmt, ##__VA_ARGS__)
+#else
+#define LOGV(fmt, ...)
+#endif  // CHRE_DL_VERBOSE
+
+namespace chre {
+
+void log(enum chreLogLevel level, const char *formatStr, ...);
+void vaLog(enum chreLogLevel level, const char *format, va_list args);
+
+}  // namespace chre
+
+#endif  // CHRE_PLATFORM_AOC_LOG_H_
diff --git a/platform/aoc/include/chre/target_platform/platform_audio_base.h b/platform/aoc/include/chre/target_platform/platform_audio_base.h
new file mode 100644
index 0000000..d42d2c8
--- /dev/null
+++ b/platform/aoc/include/chre/target_platform/platform_audio_base.h
@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2020 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 CHRE_PLATFORM_AOC_PLATFORM_AUDIO_BASE_H_
+#define CHRE_PLATFORM_AOC_PLATFORM_AUDIO_BASE_H_
+
+#include <cstring>
+
+#include "chre/platform/aoc/audio_controller.h"
+#include "chre/platform/platform_audio.h"
+
+namespace chre {
+
+/**
+ * The base PlatformAudio class for AoC to inject platform
+ * specific functionality from. Instantiates an Audio Controller object,
+ * which handles communications, data buffering, and audio data event
+ * dispatch for CHRE.
+ */
+class PlatformAudioBase {
+ protected:
+  AudioController mAudioController;
+};
+
+}  // namespace chre
+
+#endif  // CHRE_PLATFORM_AOC_PLATFORM_AUDIO_BASE_H_
diff --git a/platform/aoc/include/chre/target_platform/platform_log_base.h b/platform/aoc/include/chre/target_platform/platform_log_base.h
new file mode 100644
index 0000000..1d5657a
--- /dev/null
+++ b/platform/aoc/include/chre/target_platform/platform_log_base.h
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2020 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 CHRE_PLATFORM_AOC_PLATFORM_LOG_BASE_H_
+#define CHRE_PLATFORM_AOC_PLATFORM_LOG_BASE_H_
+
+namespace chre {
+
+class PlatformLogBase {
+  // TODO: Stubbed out, implement this
+  // Can we EFWObject::PrintSet(printf) here instead of in the application?
+};
+
+}  // namespace chre
+
+#endif  // CHRE_PLATFORM_AOC_PLATFORM_LOG_BASE_H_
diff --git a/platform/aoc/include/chre/target_platform/power_control_manager_base.h b/platform/aoc/include/chre/target_platform/power_control_manager_base.h
new file mode 100644
index 0000000..fdd9d46
--- /dev/null
+++ b/platform/aoc/include/chre/target_platform/power_control_manager_base.h
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2020 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 CHRE_PLATFORM_AOC_POWER_CONTROL_MANAGER_BASE_H
+#define CHRE_PLATFORM_AOC_POWER_CONTROL_MANAGER_BASE_H
+
+#include "chre/platform/atomic.h"
+
+namespace chre {
+
+class PowerControlManagerBase {
+ public:
+  PowerControlManagerBase();
+
+  /**
+   * Updates internal wake/suspend flag and pushes awake/sleep notification
+   * to nanoapps that are listening for it.
+   *
+   * @param awake true if host is awake, otherwise suspended.
+   */
+  void onHostWakeSuspendEvent(bool awake);
+
+ protected:
+  //! Set to true if the host is awake, false if suspended.
+  AtomicBool mHostIsAwake;
+};
+
+}  // namespace chre
+
+#endif  // CHRE_PLATFORM_AOC_POWER_CONTROL_MANAGER_BASE_H
diff --git a/platform/aoc/include/chre/target_platform/system_timer_base.h b/platform/aoc/include/chre/target_platform/system_timer_base.h
new file mode 100644
index 0000000..87edeb8
--- /dev/null
+++ b/platform/aoc/include/chre/target_platform/system_timer_base.h
@@ -0,0 +1,58 @@
+/*
+ * Copyright (C) 2020 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 CHRE_PLATFORM_AOC_SYSTEM_TIMER_BASE_H_
+#define CHRE_PLATFORM_AOC_SYSTEM_TIMER_BASE_H_
+
+#include <cstdint>
+
+#include "chre/platform/assert.h"
+#include "chre/util/time_impl.h"
+
+#include "efw/include/timer.h"
+
+#include "FreeRTOS.h"
+#include "task.h"
+
+namespace chre {
+
+/**
+ * The AOC platform base class for the SystemTimer. The AOC implementation uses
+ * a EFW timer.
+ */
+class SystemTimerBase {
+ protected:
+  //! The timer handle that is generated by Timer::EventAdd.
+  void *mTimerHandle;
+
+  //! Tracks whether the timer has been initialized correctly.
+  bool mInitialized = false;
+
+  //! A static method that is invoked by the underlying EFW timer.
+  static bool systemTimerNotifyCallback(void *context);
+
+  //! A FreeRTOS Thread to dispatch timer callbacks
+  static TaskHandle_t mTimerCbDispatchThreadHandle;
+
+  //! This function implements the timer callback dispatch thread.
+  // It blocks until it's woken up by the underlying system timer's ISR,
+  // then executes the CHRE timer callback from the dispatch thread context.
+  static void timerCallbackDispatch(void *context);
+};
+
+}  // namespace chre
+
+#endif  // CHRE_PLATFORM_AOC_SYSTEM_TIMER_BASE_H_
diff --git a/platform/aoc/log.cc b/platform/aoc/log.cc
new file mode 100644
index 0000000..689cef1
--- /dev/null
+++ b/platform/aoc/log.cc
@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2020 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 "chre/target_platform/log.h"
+
+#include "chre/core/event_loop_manager.h"
+#include "chre/platform/system_time.h"
+
+#include <endian.h>
+
+namespace chre {
+namespace {
+constexpr size_t kChreLogBufferSize = CHRE_MESSAGE_TO_HOST_MAX_SIZE;
+char logBuffer[kChreLogBufferSize];
+}  // namespace
+
+void log(enum chreLogLevel level, const char *formatStr, ...) {
+  va_list args;
+  va_start(args, formatStr);
+  vaLog(level, formatStr, args);
+  va_end(args);
+}
+
+// TODO: b/146164384 - We will need to batch logs rather than send them
+// one at a time to avoid waking the AP.
+void vaLog(enum chreLogLevel level, const char *format, va_list args) {
+  auto &hostCommsMgr =
+      chre::EventLoopManagerSingleton::get()->getHostCommsManager();
+
+  // See host_messages.fbs for the log message format.
+  size_t logBufIndex = 0;
+  logBuffer[logBufIndex] = level + 1;
+  logBufIndex++;
+
+  uint64_t currentTimeNs = SystemTime::getMonotonicTime().toRawNanoseconds();
+  memcpy(&logBuffer[logBufIndex], &currentTimeNs, sizeof(uint64_t));
+  logBufIndex += sizeof(uint64_t);
+
+  int msgLen = vsnprintf(&logBuffer[logBufIndex],
+                         kChreLogBufferSize - logBufIndex, format, args);
+  if (msgLen >= 0) {
+    // msgLen doesn't include the terminating null char.
+    logBufIndex += msgLen + 1;
+
+    hostCommsMgr.sendLogMessage(reinterpret_cast<uint8_t *>(logBuffer),
+                                logBufIndex);
+  }
+}
+
+}  // namespace chre
diff --git a/platform/aoc/memory.cc b/platform/aoc/memory.cc
new file mode 100644
index 0000000..43f3834
--- /dev/null
+++ b/platform/aoc/memory.cc
@@ -0,0 +1,236 @@
+/*
+ * Copyright (C) 2020 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 "chre/platform/aoc/memory.h"
+#include "chre/platform/memory.h"
+#include "chre/platform/mutex.h"
+#include "chre/platform/shared/dram_vote_client.h"
+#include "chre/platform/shared/pal_system_api.h"
+
+#include "basic.h"
+#include "heap.h"
+
+#include <cstdlib>
+
+// TODO(b/152442881): Remove printf statements and replace with CHRE_ASSERT
+// when things are considered more stable.
+
+//! Beginning of the CHRE SRAM heap.
+extern uintptr_t __heap_chre_beg__;
+//! End of the CHRE SRAM heap.
+extern uintptr_t __heap_chre_end__;
+//! Beginning of the CHRE DRAM heap.
+extern uintptr_t __heap_chre_dram_beg__;
+//! End of the CHRE DRAM heap.
+extern uintptr_t __heap_chre_dram_end__;
+
+namespace chre {
+namespace {
+
+//! Handle to the SRAM heap.
+void *gSramHeap = nullptr;
+//! Mutex used to synchronize access to the SRAM heap.
+Mutex gSramMutex;
+//! Handle to the DRAM heap.
+void *gDramHeap = nullptr;
+//! Mutex used to synchronize access to the DRAM heap.
+Mutex gDramMutex;
+
+enum ChreHeap { DRAM, SRAM };
+
+//! Helper functions passed to EFW so it can lock when heap allocations / frees
+//! are performed.
+inline void LockMutex(void *mutex) {
+  static_cast<Mutex *>(mutex)->lock();
+}
+inline void UnlockMutex(void *mutex) {
+  static_cast<Mutex *>(mutex)->unlock();
+}
+
+void *GetSramHeap() {
+  if (gSramHeap == nullptr) {
+    auto heap_base = &__heap_chre_beg__;
+    auto heap_size = PTR_OFFSET_GET(&__heap_chre_end__, heap_base);
+
+    gSramHeap = HeapInit(heap_base, heap_size);
+    CHRE_ASSERT(gSramHeap != nullptr);
+    if (gSramHeap == nullptr) {
+      printf("CHRE: Failed to initialize SRAM heap\n");
+      return nullptr;
+    } else {
+      HeapLocking(gSramHeap, &gSramMutex, LockMutex, UnlockMutex);
+    }
+  }
+  return gSramHeap;
+}
+
+void *GetDramHeap() {
+  if (gDramHeap == nullptr) {
+    auto heap_base = &__heap_chre_dram_beg__;
+    auto heap_size = PTR_OFFSET_GET(&__heap_chre_dram_end__, heap_base);
+
+    gDramHeap = HeapInit(heap_base, heap_size);
+    CHRE_ASSERT(gDramHeap != nullptr);
+    if (gDramHeap == nullptr) {
+      printf("CHRE: Failed to initialize DRAM heap\n");
+      return nullptr;
+    } else {
+      HeapLocking(gDramHeap, &gDramMutex, LockMutex, UnlockMutex);
+    }
+  }
+  return gDramHeap;
+}
+
+void *GetHeap(ChreHeap heap) {
+  if (heap == ChreHeap::SRAM) {
+    return GetSramHeap();
+  } else if (heap == ChreHeap::DRAM) {
+    return GetDramHeap();
+  } else {
+    printf("CHRE: GetHeap given invalid heap\n");
+  }
+  return nullptr;
+}
+
+bool IsInHeap(ChreHeap heap, const void *pointer) {
+  void *handle = GetHeap(heap);
+  bool found = false;
+  if (handle != nullptr) {
+    const struct HEAP_STATS *stats = HeapStats(handle);
+    const uintptr_t heapBase = reinterpret_cast<uintptr_t>(stats->base);
+    const uintptr_t castPointer = reinterpret_cast<uintptr_t>(pointer);
+    found = castPointer >= heapBase && castPointer < (heapBase + stats->len);
+  }
+
+  return found;
+}
+
+}  // namespace
+
+void *memoryAlloc(size_t size) {
+  void *ptr = nullptr;
+  void *handle = GetSramHeap();
+  if (handle != nullptr) {
+    ptr = HeapMalloc(handle, size);
+    // Fall back to DRAM memory when SRAM memory is exhausted. Must exclude size
+    // 0 as clients may not explicitly free memory of size 0, which may
+    // mistakenly leave DRAM accessible
+    if (ptr == nullptr && size != 0) {
+      // Increment DRAM vote count to prevent system from powering down DRAM
+      // while DRAM memory is in use.
+      DramVoteClientSingleton::get()->incrementDramVoteCount();
+      ptr = memoryAllocDram(size);
+
+      // DRAM allocation failed too.
+      if (ptr == nullptr) {
+        DramVoteClientSingleton::get()->decrementDramVoteCount();
+      }
+    }
+  }
+
+  return ptr;
+}
+
+void *memoryAllocAligned(size_t alignment, size_t size) {
+  void *ptr = nullptr;
+  void *handle = GetSramHeap();
+
+  if (handle != nullptr) {
+    ptr = HeapAlignedAlloc(handle, alignment, size);
+    // This method is currently only used for nanoapp loading so don't fall back
+    // to DRAM or there can be power implications.
+    if (ptr == nullptr) {
+      printf("CHRE: Failed to allocate memory in SRAM heap\n");
+    }
+  }
+
+  return ptr;
+}
+
+void *memoryAllocDramAligned(size_t alignment, size_t size) {
+  CHRE_ASSERT_LOG(DramVoteClientSingleton::get()->isDramVoteActive(),
+                  "DRAM allocation when not accessible");
+
+  void *ptr = nullptr;
+  void *handle = GetDramHeap();
+
+  if (handle != nullptr) {
+    ptr = HeapAlignedAlloc(handle, alignment, size);
+    if (ptr == nullptr) {
+      printf("CHRE: Failed to allocate memory in DRAM heap\n");
+    }
+  }
+
+  return ptr;
+}
+
+void *memoryAllocDram(size_t size) {
+  CHRE_ASSERT_LOG(DramVoteClientSingleton::get()->isDramVoteActive(),
+                  "DRAM allocation when not accessible");
+
+  void *ptr = nullptr;
+  void *handle = GetDramHeap();
+  if (handle != nullptr) {
+    ptr = HeapMalloc(handle, size);
+    if (ptr == nullptr) {
+      printf("CHRE: Failed to allocate memory in DRAM heap\n");
+    }
+  }
+
+  return ptr;
+}
+
+void memoryFree(void *pointer) {
+  if (pointer != nullptr) {
+    if (IsInHeap(ChreHeap::SRAM, pointer)) {
+      HeapFree(GetHeap(ChreHeap::SRAM), pointer);
+    } else {
+      memoryFreeDram(pointer);
+      DramVoteClientSingleton::get()->decrementDramVoteCount();
+    }
+  }
+}
+
+void memoryFreeDram(void *pointer) {
+  CHRE_ASSERT_LOG(DramVoteClientSingleton::get()->isDramVoteActive(),
+                  "DRAM freed when not accessible");
+
+  if (!IsInHeap(ChreHeap::DRAM, pointer)) {
+    printf(
+        "CHRE: Tried to free memory not in DRAM heap or DRAM heap not \
+            initialized\n");
+  } else {
+    HeapFree(GetDramHeap(), pointer);
+  }
+}
+
+void forceDramAccess() {
+  DramVoteClientSingleton::get()->voteDramAccess(true /* enabled */);
+}
+
+void removeDramAccessVote() {
+  DramVoteClientSingleton::get()->voteDramAccess(false /* enabled */);
+}
+
+void *palSystemApiMemoryAlloc(size_t size) {
+  return memoryAlloc(size);
+}
+
+void palSystemApiMemoryFree(void *pointer) {
+  memoryFree(pointer);
+}
+
+}  // namespace chre
diff --git a/platform/aoc/platform_audio.cc b/platform/aoc/platform_audio.cc
new file mode 100644
index 0000000..0019697
--- /dev/null
+++ b/platform/aoc/platform_audio.cc
@@ -0,0 +1,75 @@
+/*
+ * Copyright (C) 2020 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 "chre/platform/platform_audio.h"
+#include <cinttypes>
+#include "chre/core/event_loop_manager.h"
+#include "chre/platform/assert.h"
+#include "chre/platform/log.h"
+#include "chre/platform/system_time.h"
+
+namespace chre {
+
+PlatformAudio::PlatformAudio() {}
+
+PlatformAudio::~PlatformAudio() {}
+
+void PlatformAudio::init() {
+  mAudioController.Start();
+  mAudioController.SetUpRemoteCore();
+}
+
+size_t PlatformAudio::getSourceCount() {
+  return AudioController::kMaxAocMicrophones;
+}
+
+bool PlatformAudio::getAudioSource(uint32_t handle,
+                                   struct chreAudioSource *source) const {
+  bool success = false;
+  if ((handle < AudioController::kMaxAocMicrophones) && (source != nullptr)) {
+    memcpy(source, mAudioController.GetSource(handle), sizeof(chreAudioSource));
+    success = true;
+  }
+
+  return success;
+}
+
+void PlatformAudio::setHandleEnabled(uint32_t handle, bool enabled) {
+  mAudioController.SetEnabled(handle, enabled);
+}
+
+void PlatformAudio::cancelAudioDataEventRequest(uint32_t handle) {
+  mAudioController.ReleaseAudio(handle);
+}
+
+bool PlatformAudio::requestAudioDataEvent(uint32_t handle, uint32_t numSamples,
+                                          Nanoseconds eventDelay) {
+  // TODO: Event delay
+  bool success = mAudioController.RequestAudio(handle);
+  LOGV("Request audio data for hdl %u, numSamples %u @ %" PRIu64
+       ", success: %d",
+       handle, numSamples, SystemTime::getMonotonicTime().toRawNanoseconds(),
+       success);
+
+  return success;
+}
+
+void PlatformAudio::releaseAudioDataEvent(
+    struct chreAudioDataEvent * /*event*/) {
+  mAudioController.OnBufferReleased();
+}
+
+}  // namespace chre
diff --git a/platform/aoc/platform_cache_management.cc b/platform/aoc/platform_cache_management.cc
new file mode 100644
index 0000000..b375d16
--- /dev/null
+++ b/platform/aoc/platform_cache_management.cc
@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2020 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 "chre/target_platform/platform_cache_management.h"
+#include "core/arm/generic/include/cache_management.h"
+#include "core/arm/generic/include/memory_barrier.h"
+
+namespace chre {
+
+namespace {
+
+void invalidateInstructionCache() {
+  INSTRUCTION_CACHE_INVALIDATE();
+  MB();
+}
+
+void cleanAndInvalidateDataCache() {
+  CACHE_SET_WAY_FLUSH_AND_INVALIDATE_ALL();
+  MB();
+}
+
+}  // anonymous namespace
+
+void wipeSystemCaches() {
+  cleanAndInvalidateDataCache();
+  invalidateInstructionCache();
+}
+
+}  // namespace chre
diff --git a/platform/aoc/platform_pal.cc b/platform/aoc/platform_pal.cc
new file mode 100644
index 0000000..515a3e5
--- /dev/null
+++ b/platform/aoc/platform_pal.cc
@@ -0,0 +1,23 @@
+/*
+ * Copyright (C) 2020 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 "chre/platform/shared/platform_pal.h"
+
+namespace chre {
+
+void PlatformPal::prePalApiCall() const {}
+
+}  // namespace chre
diff --git a/platform/aoc/power_control_manager.cc b/platform/aoc/power_control_manager.cc
new file mode 100644
index 0000000..8e57651
--- /dev/null
+++ b/platform/aoc/power_control_manager.cc
@@ -0,0 +1,52 @@
+/*
+ * Copyright (C) 2020 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 "chre/platform/power_control_manager.h"
+
+#include "chre/core/event_loop_manager.h"
+#include "chre/platform/shared/memory.h"
+
+namespace chre {
+
+PowerControlManagerBase::PowerControlManagerBase() : mHostIsAwake(true) {}
+
+void PowerControlManagerBase::onHostWakeSuspendEvent(bool awake) {
+  if (mHostIsAwake != awake) {
+    mHostIsAwake = awake;
+
+    if (!awake) {
+      EventLoopManagerSingleton::get()
+          ->getHostCommsManager()
+          .resetBlameForNanoappHostWakeup();
+    }
+
+    EventLoopManagerSingleton::get()->getEventLoop().postEventOrDie(
+        awake ? CHRE_EVENT_HOST_AWAKE : CHRE_EVENT_HOST_ASLEEP,
+        nullptr /* eventData */, nullptr /* freeCallback */);
+  }
+}
+
+void PowerControlManager::postEventLoopProcess(size_t numPendingEvents) {
+  if (numPendingEvents == 0) {
+    removeDramAccessVote();
+  }
+}
+
+bool PowerControlManager::hostIsAwake() {
+  return mHostIsAwake;
+}
+
+}  // namespace chre
diff --git a/platform/aoc/system_time.cc b/platform/aoc/system_time.cc
new file mode 100644
index 0000000..ded9a63
--- /dev/null
+++ b/platform/aoc/system_time.cc
@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2020 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 "chre/platform/system_time.h"
+#include "chre/platform/assert.h"
+#include "chre/platform/log.h"
+
+#include "efw/include/timer.h"
+
+namespace chre {
+
+namespace {
+
+int64_t gEstimatedHostTimeOffset = 0;
+
+}
+
+Nanoseconds SystemTime::getMonotonicTime() {
+  return Nanoseconds(Timer::Instance()->TimestampNanoseconds());
+}
+
+int64_t SystemTime::getEstimatedHostTimeOffset() {
+  return gEstimatedHostTimeOffset;
+}
+
+void setEstimatedHostTimeOffset(int64_t offset) {
+  gEstimatedHostTimeOffset = offset;
+}
+
+}  // namespace chre
diff --git a/platform/aoc/system_timer.cc b/platform/aoc/system_timer.cc
new file mode 100644
index 0000000..f636a86
--- /dev/null
+++ b/platform/aoc/system_timer.cc
@@ -0,0 +1,131 @@
+/*
+ * Copyright (C) 2020 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 "chre/platform/system_timer.h"
+#include "chre/platform/assert.h"
+#include "chre/platform/log.h"
+#include "chre/util/time.h"
+
+#include "efw/include/timer.h"
+
+namespace {
+
+// The timer dispatch thread is notifed from a
+// timer interrupt context, and there are context checks in the FreeRTOS code
+// (i.e. the xxGive and xxGiveFromISR are not interchangeable). Since there
+// are no interrupts in a simulated platform, we end up with two different
+// notification mechanisms that accomplish the same purpose.
+void wakeupDispatchThread(TaskHandle_t &handle) {
+  BaseType_t xHigherPriorityTaskWoken = pdFALSE;
+  vTaskNotifyGiveFromISR(handle, &xHigherPriorityTaskWoken);
+  portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
+}
+
+}  // namespace
+
+namespace chre {
+
+TaskHandle_t SystemTimerBase::mTimerCbDispatchThreadHandle = NULL;
+
+bool SystemTimerBase::systemTimerNotifyCallback(void *context) {
+  SystemTimer *pTimer = static_cast<SystemTimer *>(context);
+  if (pTimer != nullptr) {
+    wakeupDispatchThread(mTimerCbDispatchThreadHandle);
+  }
+
+  // The EFW timer callback is setup in such a way that returning 'true'
+  // here reschedules the timer, while returning 'false' does not.
+  // Since we're interested in a one-shot timer, we return 'false' here.
+  return false;
+}
+
+void SystemTimerBase::timerCallbackDispatch(void *context) {
+  SystemTimer *pTimer = static_cast<SystemTimer *>(context);
+  if (pTimer == nullptr) {
+    FATAL_ERROR("Null System Timer");
+  }
+
+  while (true) {
+    ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
+    if ((pTimer != nullptr) && (pTimer->mCallback != nullptr)) {
+      pTimer->mCallback(pTimer->mData);
+    }
+  }
+}
+
+SystemTimer::SystemTimer() {}
+
+SystemTimer::~SystemTimer() {
+  // cancel an existing timer if any
+  cancel();
+  // Delete the timer dispatch thread if it was created
+  if (mTimerCbDispatchThreadHandle != NULL) {
+    vTaskDelete(mTimerCbDispatchThreadHandle);
+  }
+}
+
+bool SystemTimer::init() {
+  BaseType_t rc =
+      xTaskCreate(timerCallbackDispatch, "TimerCbDispatch", 1024, this,
+                  tskIDLE_PRIORITY + 2, &mTimerCbDispatchThreadHandle);
+  if (pdTRUE == rc) {
+    mInitialized = true;
+  } else {
+    LOGE("Failed to create Timer Dispatch Thread");
+  }
+
+  return mInitialized;
+}
+
+bool SystemTimer::set(SystemTimerCallback *callback, void *data,
+                      Nanoseconds delay) {
+  bool success = false;
+
+  if (mInitialized) {
+    // TODO: b/146374655 - investigate/handle possible race condition here
+    mCallback = callback;
+    mData = data;
+
+    Timer *timer = Timer::Instance();
+    int rc =
+        timer->EventAddAtOffset(timer->NsToTicks(delay.toRawNanoseconds()),
+                                systemTimerNotifyCallback, this, &mTimerHandle);
+
+    if (rc != 0) {
+      LOGE("Failed to set timer");
+    } else {
+      success = true;
+    }
+  }
+
+  return success;
+}
+
+bool SystemTimer::cancel() {
+  int rc = -1;
+  if (mTimerHandle != nullptr) {
+    rc = Timer::Instance()->EventRemove(mTimerHandle);
+  }
+
+  return (rc == 0) ? true : false;
+}
+
+bool SystemTimer::isActive() {
+  // TODO: stubbed out, Implement this.
+  return false;
+}
+
+}  // namespace chre
diff --git a/platform/freertos/context.cc b/platform/freertos/context.cc
new file mode 100644
index 0000000..8ee7448
--- /dev/null
+++ b/platform/freertos/context.cc
@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2019 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 "chre/platform/context.h"
+#include "chre/target_platform/init.h"
+
+#include "FreeRTOS.h"
+#include "task.h"
+
+namespace chre {
+
+bool inEventLoopThread() {
+  TaskHandle_t evtLoopTaskHandle = xTaskGetHandle(freertos::getChreTaskName());
+  TaskHandle_t currentTaskHandle = xTaskGetCurrentTaskHandle();
+
+  return (evtLoopTaskHandle == currentTaskHandle);
+}
+
+}  // namespace chre
diff --git a/platform/freertos/include/chre/target_platform/atomic_base.h b/platform/freertos/include/chre/target_platform/atomic_base.h
new file mode 100644
index 0000000..582d0ae
--- /dev/null
+++ b/platform/freertos/include/chre/target_platform/atomic_base.h
@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2019 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 CHRE_PLATFORM_FREERTOS_ATOMIC_BASE_H_
+#define CHRE_PLATFORM_FREERTOS_ATOMIC_BASE_H_
+
+#include <atomic>
+
+namespace chre {
+
+template <typename AtomicType>
+class AtomicBase {
+ protected:
+  std::atomic<AtomicType> mAtomic;
+};
+
+typedef AtomicBase<bool> AtomicBoolBase;
+typedef AtomicBase<uint32_t> AtomicUint32Base;
+
+}  // namespace chre
+
+#endif  // CHRE_PLATFORM_FREERTOS_ATOMIC_BASE_H_
diff --git a/platform/freertos/include/chre/target_platform/atomic_base_impl.h b/platform/freertos/include/chre/target_platform/atomic_base_impl.h
new file mode 100644
index 0000000..d44a197
--- /dev/null
+++ b/platform/freertos/include/chre/target_platform/atomic_base_impl.h
@@ -0,0 +1,84 @@
+/*
+ * Copyright (C) 2019 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 CHRE_PLATFORM_FREERTOS_ATOMIC_BASE_IMPL_H_
+#define CHRE_PLATFORM_FREERTOS_ATOMIC_BASE_IMPL_H_
+
+#include "chre/platform/atomic.h"
+
+namespace chre {
+
+inline AtomicBool::AtomicBool(bool startingValue) {
+  std::atomic_init(&mAtomic, startingValue);
+}
+
+inline bool AtomicBool::operator=(bool desired) {
+  mAtomic = desired;
+  return desired;
+}
+
+inline bool AtomicBool::load() const {
+  return mAtomic.load();
+}
+
+inline void AtomicBool::store(bool desired) {
+  mAtomic.store(desired);
+}
+
+inline bool AtomicBool::exchange(bool desired) {
+  return mAtomic.exchange(desired);
+}
+
+inline AtomicUint32::AtomicUint32(uint32_t startingValue) {
+  std::atomic_init(&mAtomic, startingValue);
+}
+
+inline uint32_t AtomicUint32::operator=(uint32_t desired) {
+  mAtomic = desired;
+  return desired;
+}
+
+inline uint32_t AtomicUint32::load() const {
+  return mAtomic.load();
+}
+
+inline void AtomicUint32::store(uint32_t desired) {
+  mAtomic.store(desired);
+}
+
+inline uint32_t AtomicUint32::exchange(uint32_t desired) {
+  return mAtomic.exchange(desired);
+}
+
+inline uint32_t AtomicUint32::fetch_add(uint32_t arg) {
+  return mAtomic.fetch_add(arg);
+}
+
+inline uint32_t AtomicUint32::fetch_increment() {
+  return mAtomic.fetch_add(1);
+}
+
+inline uint32_t AtomicUint32::fetch_sub(uint32_t arg) {
+  return mAtomic.fetch_sub(arg);
+}
+
+inline uint32_t AtomicUint32::fetch_decrement() {
+  return mAtomic.fetch_sub(1);
+}
+
+}  // namespace chre
+
+#endif  // CHRE_PLATFORM_FREERTOS_ATOMIC_BASE_IMPL_H_
diff --git a/platform/freertos/include/chre/target_platform/condition_variable_base.h b/platform/freertos/include/chre/target_platform/condition_variable_base.h
new file mode 100644
index 0000000..9ad3c49
--- /dev/null
+++ b/platform/freertos/include/chre/target_platform/condition_variable_base.h
@@ -0,0 +1,94 @@
+/*
+ * Copyright (C) 2019 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 CHRE_PLATFORM_FREERTOS_CONDITION_VARIABLE_BASE_H_
+#define CHRE_PLATFORM_FREERTOS_CONDITION_VARIABLE_BASE_H_
+
+#include "chre/platform/mutex.h"
+#include "chre/platform/system_timer.h"
+#include "chre/target_platform/fatal_error.h"
+
+#include "FreeRTOS.h"
+#include "semphr.h"
+
+namespace chre {
+
+/**
+ * @brief FreeRTOS implementation of the condition variable
+ *        using FreeRTOS primitives
+ *
+ * The following base class implements the CHRE ConditionVariable
+ * interface for FreeRTOS. Some points to be noted:
+ * - We have the benefit of not needing to support notify_all(),
+ *   as we only provide the notify_one() abstraction to common code.
+ * - We don't have the requirement where more than 1 thread can wait
+ *   on a given condition variable in parallel  (which kind of goes against the
+ *   CV name, but really we were looking for something that let us implement
+ *   @ref FixedSizeBlockingQueue while keeping familiarity to the C++11 thread
+ *   support library
+ * - Currently, there's exactly one user of the condition variable in the common
+ *   code, and that's the FixedSizeBlockingQueue used by the EventLoop. Hence,
+ *   we can codify assumptions that are well supported by the current code into
+ *   the API. One example of this would be ensuring the caller can handle
+ *   spurious wakeups (which is fine for CHRE) as the worst side effect of this
+ *   is an extra iteration of the while-empty-queue loop.
+ */
+class ConditionVariableBase {
+ protected:
+  // Since, per CHRE specification, only one thread is ever
+  // going to be blocked on this condition variable, all we
+  // need is a Binary Semaphore. Note that:
+  // - while std::condition_variable allows for multiple threads
+  //   to wait on the same condition variable object
+  //   concurrently, the CHRE platform implementation is only required
+  //   to allow for a single waiting thread.
+  // - The calling code has to allow for spurious wakeups
+
+  SemaphoreHandle_t mCvSemaphoreHandle;
+
+  /**
+   * Waits on a semaphore for a specified amount of timer ticks,
+   * locking the mutex before returning. If the timer ticks argument is
+   * 0, blocks indefinitely.
+   *
+   * @return true if the semaphore was successfully taken
+   */
+  bool waitWithTimeout(Mutex &mutex, const TickType_t &timeoutTicks) {
+    mutex.unlock();
+    BaseType_t rc = xSemaphoreTake(mCvSemaphoreHandle, timeoutTicks);
+    mutex.lock();
+
+    return (rc == pdTRUE);
+  }
+
+  /**
+   * Initialize a Static FreeRTOS semaphore. This function is called
+   * from the derived class constructor
+   */
+  void initStaticSemaphore() {
+    mCvSemaphoreHandle = xSemaphoreCreateBinaryStatic(&mCvStaticSemaphore);
+    if (mCvSemaphoreHandle == NULL) {
+      FATAL_ERROR("failed to create cv semaphore");
+    }
+  }
+
+ private:
+  StaticSemaphore_t mCvStaticSemaphore;
+};
+
+}  // namespace chre
+
+#endif  // CHRE_PLATFORM_FREERTOS_CONDITION_VARIABLE_BASE_H_
diff --git a/platform/freertos/include/chre/target_platform/condition_variable_impl.h b/platform/freertos/include/chre/target_platform/condition_variable_impl.h
new file mode 100644
index 0000000..32351ca
--- /dev/null
+++ b/platform/freertos/include/chre/target_platform/condition_variable_impl.h
@@ -0,0 +1,51 @@
+/*
+ * Copyright (C) 2019 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 CHRE_PLATFORM_FREERTOS_CONDITION_VARIABLE_IMPL_H_
+#define CHRE_PLATFORM_FREERTOS_CONDITION_VARIABLE_IMPL_H_
+
+#include "chre/platform/condition_variable.h"
+
+namespace chre {
+
+inline ConditionVariable::ConditionVariable() {
+  initStaticSemaphore();
+}
+
+inline ConditionVariable::~ConditionVariable() {
+  if (mCvSemaphoreHandle != NULL) {
+    vSemaphoreDelete(mCvSemaphoreHandle);
+  }
+}
+
+inline void ConditionVariable::notify_one() {
+  xSemaphoreGive(mCvSemaphoreHandle);
+}
+
+inline void ConditionVariable::wait(Mutex &mutex) {
+  const TickType_t timeout = portMAX_DELAY;  // block indefinitely
+  waitWithTimeout(mutex, timeout);
+}
+
+inline bool ConditionVariable::wait_for(Mutex &mutex, Nanoseconds timeout) {
+  const TickType_t timeoutTicks = static_cast<TickType_t>(
+      Timer::Instance()->NsToTicks(timeout.toRawNanoseconds()));
+  return waitWithTimeout(mutex, timeoutTicks);
+}
+
+}  // namespace chre
+
+#endif  // CHRE_PLATFORM_FREERTOS_CONDITION_VARIABLE_IMPL_H_
diff --git a/platform/freertos/include/chre/target_platform/init.h b/platform/freertos/include/chre/target_platform/init.h
new file mode 100644
index 0000000..5eb90c9
--- /dev/null
+++ b/platform/freertos/include/chre/target_platform/init.h
@@ -0,0 +1,48 @@
+/*
+ * Copyright (C) 2020 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 CHRE_PLATFORM_FREERTOS_INIT_H_
+#define CHRE_PLATFORM_FREERTOS_INIT_H_
+
+#include "FreeRTOS.h"
+
+namespace chre {
+namespace freertos {
+
+/**
+ * This init function spawns a (non-privileged) FreeRTOS task that
+ * initializes the CHRE core, loads any static nanoapps, and starts
+ * the CHRE event loop.
+ * The task attribute constants are located in the corresponding init.cc
+ * source file, in case they need to be altered. The defaults chosen are:
+ * - Task Stack Depth: 8K Words
+ * - Task Priority: 1 (idle_task + 1)
+ *
+ * @return pdPASS on success, a FreeRTOS error code otherwise.
+ */
+BaseType_t init();
+
+/**
+ * Delete the task spawned in the init function
+ */
+void deinit();
+
+const char *getChreTaskName();
+
+}  // namespace freertos
+}  // namespace chre
+
+#endif  // CHRE_PLATFORM_FREERTOS_INIT_H_
diff --git a/platform/freertos/include/chre/target_platform/mutex_base.h b/platform/freertos/include/chre/target_platform/mutex_base.h
new file mode 100644
index 0000000..d26170a
--- /dev/null
+++ b/platform/freertos/include/chre/target_platform/mutex_base.h
@@ -0,0 +1,52 @@
+/*
+ * Copyright (C) 2019 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 CHRE_PLATFORM_FREERTOS_MUTEX_BASE_H_
+#define CHRE_PLATFORM_FREERTOS_MUTEX_BASE_H_
+
+#include "chre/platform/assert.h"
+#include "chre/platform/log.h"
+
+#include "FreeRTOS.h"
+#include "semphr.h"
+
+namespace chre {
+
+/**
+ * The FreeRTOS implementation of MutexBase
+ */
+class MutexBase {
+ protected:
+  SemaphoreHandle_t mSemaphoreHandle;
+
+  /**
+   * Initialize the mutex handle using a static semaphore
+   * to avoid heap allocations
+   */
+  void initStaticMutex() {
+    mSemaphoreHandle = xSemaphoreCreateMutexStatic(&mStaticSemaphore);
+    if (mSemaphoreHandle == NULL) {
+      FATAL_ERROR("Failed to initialize mutex");
+    }
+  }
+
+ private:
+  StaticSemaphore_t mStaticSemaphore;
+};
+
+}  // namespace chre
+
+#endif  // CHRE_PLATFORM_FREERTOS_MUTEX_BASE_H_
diff --git a/platform/freertos/include/chre/target_platform/mutex_base_impl.h b/platform/freertos/include/chre/target_platform/mutex_base_impl.h
new file mode 100644
index 0000000..23e957d
--- /dev/null
+++ b/platform/freertos/include/chre/target_platform/mutex_base_impl.h
@@ -0,0 +1,56 @@
+/*
+ * Copyright (C) 2019 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 CHRE_PLATFORM_FREERTOS_MUTEX_BASE_IMPL_H_
+#define CHRE_PLATFORM_FREERTOS_MUTEX_BASE_IMPL_H_
+
+#include "chre/platform/mutex.h"
+
+namespace chre {
+
+inline Mutex::Mutex() {
+  initStaticMutex();
+}
+
+inline Mutex::~Mutex() {
+  if (mSemaphoreHandle) {
+    vSemaphoreDelete(mSemaphoreHandle);
+  }
+}
+
+inline void Mutex::lock() {
+  TickType_t blockForever = portMAX_DELAY;
+  if (pdTRUE != xSemaphoreTake(mSemaphoreHandle, blockForever)) {
+    LOGE("Failed to lock mutex");
+  }
+}
+
+inline bool Mutex::try_lock() {
+  TickType_t doNotBlock = static_cast<TickType_t>(0);
+  BaseType_t rv = xSemaphoreTake(mSemaphoreHandle, doNotBlock);
+
+  return (rv == pdTRUE) ? true : false;
+}
+
+inline void Mutex::unlock() {
+  if (pdTRUE != xSemaphoreGive(mSemaphoreHandle)) {
+    LOGE("Failed to properly unlock mutex!");
+  }
+}
+
+}  // namespace chre
+
+#endif  // CHRE_PLATFORM_FREERTOS_MUTEX_BASE_IMPL_H_
diff --git a/platform/freertos/include/chre/target_platform/platform_debug_dump_manager_base.h b/platform/freertos/include/chre/target_platform/platform_debug_dump_manager_base.h
new file mode 100644
index 0000000..5c2399c
--- /dev/null
+++ b/platform/freertos/include/chre/target_platform/platform_debug_dump_manager_base.h
@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 2020 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 CHRE_PLATFORM_FREERTOS_PLATFORM_DEBUG_DUMP_MANAGER_BASE_H_
+#define CHRE_PLATFORM_FREERTOS_PLATFORM_DEBUG_DUMP_MANAGER_BASE_H_
+
+#include <cstdbool>
+#include <cstddef>
+#include <cstdint>
+
+namespace chre {
+
+/**
+ * FreeRTOS-specific debug dump functionality.
+ */
+class PlatformDebugDumpManagerBase {
+ public:
+  /**
+   * To be called when receiving a debug dump request from host.
+   *
+   * @param hostClientId The host client ID that requested the debug dump.
+   */
+  void onDebugDumpRequested(uint16_t hostClientId);
+
+  /**
+   * @see PlatformDebugDumpManager::sendDebugDump
+   */
+  void sendDebugDumpResult(const char *debugStr, size_t debugStrSize,
+                           bool complete);
+
+ protected:
+  //! Host client ID that triggered the debug dump process.
+  uint16_t mHostClientId = 0;
+
+  //! Number of times sendDebugDumpToHost called with debugStrSize > 0.
+  uint32_t mDataCount = 0;
+
+  //! Whenther the last debug dump session has been marked complete.
+  bool mComplete = true;
+
+  static constexpr size_t kDebugDumpStrMaxSize = CHRE_MESSAGE_TO_HOST_MAX_SIZE;
+};
+
+}  // namespace chre
+
+#endif  // CHRE_PLATFORM_SLPI_PLATFORM_DEBUG_DUMP_MANAGER_BASE_H_
diff --git a/platform/freertos/include/chre/target_platform/platform_nanoapp_base.h b/platform/freertos/include/chre/target_platform/platform_nanoapp_base.h
new file mode 100644
index 0000000..bac8c46
--- /dev/null
+++ b/platform/freertos/include/chre/target_platform/platform_nanoapp_base.h
@@ -0,0 +1,159 @@
+/*
+ * Copyright (C) 2019 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 CHRE_PLATFORM_FREERTOS_PLATFORM_NANOAPP_BASE_H_
+#define CHRE_PLATFORM_FREERTOS_PLATFORM_NANOAPP_BASE_H_
+
+#include "chre/platform/shared/nanoapp_support_lib_dso.h"
+
+namespace chre {
+
+/**
+ * FREERTOS-specific nanoapp functionality.
+ */
+class PlatformNanoappBase {
+ public:
+  /**
+   * Associate this Nanoapp instance with a nanoapp that is statically built
+   * into the CHRE binary with the given app info structure.
+   */
+  void loadStatic(const struct chreNslNanoappInfo *appInfo);
+
+  /**
+   * @return true if the app's binary data is resident in memory or if the app's
+   *         filename is saved, i.e. all binary fragments are loaded through
+   *         copyNanoappFragment, loadFromFile/loadStatic() was successful
+   */
+  bool isLoaded() const;
+
+  /**
+   * @return true if this app is loaded into DRAM.
+   */
+  bool isDramApp() const;
+
+  /**
+   * Sets app info that will be used later when the app is loaded into the
+   * system.
+   *
+   * @param appId The unique app identifier associated with this binary
+   * @param appVersion An application-defined version number
+   * @param appFilename The filename of the app that should be loaded from disk
+   *
+   * @return true if the info was successfully stored
+   */
+  bool setAppInfo(uint64_t appId, uint32_t appVersion, const char *appFilename);
+
+  /**
+   * Reserves buffer space for a nanoapp's binary. This method should be called
+   * before copyNanoappFragment is called.
+   *
+   * @param appId The unique app identifier associated with this binary
+   * @param appVersion An application-defined version number
+   * @param appFlags The flags provided by the app being loaded
+   * @param appBinaryLen Size of appBinary, in bytes
+   *
+   * @return true if the allocation was successful, false otherwise
+   */
+  bool reserveBuffer(uint64_t appId, uint32_t appVersion, uint32_t appFlags,
+                     size_t appBinaryLen);
+
+  /**
+   * Copies the (possibly fragmented) application binary data into the allocated
+   * buffer, and updates the pointer to the next address to write into. The
+   * application may be invalid - full checking and initialization happens just
+   * before invoking start() nanoapp entry point.
+   *
+   * @param buffer The pointer to the buffer
+   * @param bufferSize The size of the buffer in bytes
+   *
+   * @return true if the reserved buffer did not overflow, false otherwise
+   */
+  bool copyNanoappFragment(const void *buffer, size_t bufferSize);
+
+ protected:
+  //! The app ID we received in the metadata alongside the nanoapp binary. This
+  //! is also included in (and checked against) mAppInfo.
+  uint64_t mExpectedAppId;
+
+  //! The application-defined version number we received in the metadata
+  //! alongside the nanoapp binary. This is also included in (and checked
+  //! against) mAppInfo.
+  uint32_t mExpectedAppVersion = 0;
+
+  bool mExpectedTcmCapable;
+
+  //! Buffer containing the complete DSO binary - only populated if
+  //! copyNanoappFragment() was used to load this nanoapp
+  void *mAppBinary = nullptr;
+  size_t mAppBinaryLen = 0;
+
+  //! Null-terminated ASCII string containing the file name that contains the
+  //! app binary to be loaded. This is used over mAppBinary to load the nanoapp
+  //! if set.
+  char *mAppFilename = nullptr;
+
+  //! The dynamic shared object (DSO) handle returned by dlopenbuf()
+  void *mDsoHandle = nullptr;
+
+  //! Pointer to the app info structure within this nanoapp
+  const struct chreNslNanoappInfo *mAppInfo = nullptr;
+
+  //! Pointer containing the unstable ID section for this nanoapp
+  const char *mAppUnstableId = nullptr;
+
+  //! Set to true if this app is built into the CHRE binary, and was loaded via
+  //! loadStatic(). In this case, the member variables above are not valid or
+  //! applicable.
+  bool mIsStatic = false;
+
+  //! The number of bytes of the binary that has been loaded so far.
+  size_t mBytesLoaded = 0;
+
+  /**
+   * Loads the nanoapp symbols from the currently loaded binary and verifies
+   * they match the expected information the nanoapp should have.
+   *
+   * @return true if the app info structure passed validation.
+   */
+  bool verifyNanoappInfo();
+
+  /**
+   * Calls through to openNanoappFromBuffer or openNanoappFromFile, depending on
+   * how this nanoapp was loaded.
+   */
+  bool openNanoapp();
+
+  /**
+   * Releases the DSO handle if it was active, by calling dlclose(). This will
+   * result in execution of any unload handlers in the nanoapp.
+   */
+  void closeNanoapp();
+
+  /**
+   * Retrieves the nanoapp's version string. This is intended to be a human
+   * readable version string to aid in debugging. This must always return a
+   * valid string so if none is available it is recommended to return
+   * "<undefined>" or similar.
+   *
+   * @param length The length of the returned version string
+   * @return A char array containing the version string for this nanoapp.
+   */
+  const char *getAppVersionString(size_t *length) const;
+};
+
+}  // namespace chre
+
+#endif  // CHRE_PLATFORM_FREERTOS_PLATFORM_NANOAPP_BASE_H_
diff --git a/platform/freertos/include/chre/target_platform/static_nanoapp_init.h b/platform/freertos/include/chre/target_platform/static_nanoapp_init.h
new file mode 100644
index 0000000..75d3531
--- /dev/null
+++ b/platform/freertos/include/chre/target_platform/static_nanoapp_init.h
@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2019 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 CHRE_PLATFORM_FREERTOS_STATIC_NANOAPP_INIT_H_
+#define CHRE_PLATFORM_FREERTOS_STATIC_NANOAPP_INIT_H_
+
+#include "chre/core/nanoapp.h"
+#include "chre/platform/fatal_error.h"
+#include "chre/util/unique_ptr.h"
+
+#define CHRE_STATIC_NANOAPP_INIT(appName, appId_, appVersion_)               \
+  namespace chre {                                                           \
+                                                                             \
+  UniquePtr<Nanoapp> initializeStaticNanoapp##appName() {                    \
+    UniquePtr<Nanoapp> nanoapp = MakeUnique<Nanoapp>();                      \
+    static struct chreNslNanoappInfo appInfo;                                \
+    appInfo.magic = CHRE_NSL_NANOAPP_INFO_MAGIC;                             \
+    appInfo.structMinorVersion = CHRE_NSL_NANOAPP_INFO_STRUCT_MINOR_VERSION; \
+    appInfo.targetApiVersion = CHRE_API_VERSION;                             \
+    appInfo.vendor = "Google"; /* TODO: make this configurable */            \
+    appInfo.name = #appName;                                                 \
+    appInfo.isSystemNanoapp = true;                                          \
+    appInfo.isTcmNanoapp = false;                                            \
+    appInfo.appId = appId_;                                                  \
+    appInfo.appVersion = appVersion_;                                        \
+    appInfo.entryPoints.start = nanoappStart;                                \
+    appInfo.entryPoints.handleEvent = nanoappHandleEvent;                    \
+    appInfo.entryPoints.end = nanoappEnd;                                    \
+    appInfo.appVersionString = "<undefined>";                                \
+    if (nanoapp.isNull()) {                                                  \
+      FATAL_ERROR("Failed to allocate nanoapp " #appName);                   \
+    } else {                                                                 \
+      nanoapp->loadStatic(&appInfo);                                         \
+    }                                                                        \
+                                                                             \
+    return nanoapp;                                                          \
+  }                                                                          \
+  } /* namespace chre */
+
+#endif  // CHRE_PLATFORM_FREERTOS_NANOAPP_INIT_H_
diff --git a/platform/freertos/init.cc b/platform/freertos/init.cc
new file mode 100644
index 0000000..c1cd445
--- /dev/null
+++ b/platform/freertos/init.cc
@@ -0,0 +1,89 @@
+/*
+ * Copyright (C) 2020 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 "chre/core/init.h"
+
+#include "chpp/platform/chpp_init.h"
+#include "chre/core/event_loop_manager.h"
+#include "chre/core/static_nanoapps.h"
+#include "chre/platform/shared/dram_vote_client.h"
+#include "chre/target_platform/init.h"
+
+#include "task.h"
+
+namespace chre {
+namespace freertos {
+namespace {
+
+constexpr configSTACK_DEPTH_TYPE kChreTaskStackDepthWords = 0x800;
+
+constexpr UBaseType_t kChreTaskPriority = tskIDLE_PRIORITY + 1;
+
+TaskHandle_t gChreTaskHandle;
+
+// This function is intended to be the task action function for FreeRTOS.
+// It Initializes CHRE, runs the event loop, and only exits if it receives
+// a message to shutdown. Note that depending on the hardware platform this
+// runs on, CHRE might create additional threads, which are cleaned up when
+// CHRE exits.
+void chreThreadEntry(void *context) {
+  DramVoteClientSingleton::init();
+
+  chre::init();
+  chre::EventLoopManagerSingleton::get()->lateInit();
+  chre::loadStaticNanoapps();
+
+  chre::EventLoopManagerSingleton::get()->getEventLoop().run();
+
+  // we only get here if the CHRE EventLoop exited
+  chre::deinit();
+
+  DramVoteClientSingleton::deinit();
+
+  vTaskDelete(nullptr);
+  gChreTaskHandle = nullptr;
+}
+
+}  // namespace
+
+BaseType_t init() {
+  BaseType_t rc = xTaskCreate(chreThreadEntry, freertos::getChreTaskName(),
+                              kChreTaskStackDepthWords, nullptr /* args */,
+                              kChreTaskPriority, &gChreTaskHandle);
+  CHRE_ASSERT(rc == pdPASS);
+
+  chpp::init();
+
+  return rc;
+}
+
+void deinit() {
+  // On a deinit call, we just stop the CHRE event loop. This causes the 'run'
+  // method in the task function exit, and move on to handle task cleanup
+  if (gChreTaskHandle != nullptr) {
+    chre::EventLoopManagerSingleton::get()->getEventLoop().stop();
+  }
+
+  chpp::deinit();
+}
+
+const char *getChreTaskName() {
+  static constexpr char kChreTaskName[] = "CHRE";
+  return kChreTaskName;
+}
+
+}  // namespace freertos
+}  // namespace chre
diff --git a/platform/freertos/memory.cc b/platform/freertos/memory.cc
new file mode 100644
index 0000000..ada6702
--- /dev/null
+++ b/platform/freertos/memory.cc
@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2019 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 "chre/platform/memory.h"
+#include "chre/platform/shared/pal_system_api.h"
+
+#include <cstdlib>
+
+namespace chre {
+
+void *memoryAlloc(size_t size) {
+  return malloc(size);
+}
+
+void *palSystemApiMemoryAlloc(size_t size) {
+  return malloc(size);
+}
+
+void memoryFree(void *pointer) {
+  free(pointer);
+}
+
+void palSystemApiMemoryFree(void *pointer) {
+  free(pointer);
+}
+
+}  // namespace chre
diff --git a/platform/freertos/memory_manager.cc b/platform/freertos/memory_manager.cc
new file mode 100644
index 0000000..b6ea251
--- /dev/null
+++ b/platform/freertos/memory_manager.cc
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2019 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 "chre/platform/memory_manager.h"
+#include "chre/platform/shared/memory.h"
+#include "chre/util/memory.h"
+
+namespace chre {
+
+void *MemoryManager::doAlloc(Nanoapp *app, uint32_t bytes) {
+  if (app->isDramApp()) {
+    return chre::memoryAllocDram(bytes);
+  } else {
+    return chre::memoryAlloc(bytes);
+  }
+}
+
+void MemoryManager::doFree(Nanoapp *app, void *ptr) {
+  if (app->isDramApp()) {
+    chre::memoryFreeDram(ptr);
+  } else {
+    chre::memoryFree(ptr);
+  }
+}
+
+}  // namespace chre
diff --git a/platform/freertos/platform_debug_dump_manager.cc b/platform/freertos/platform_debug_dump_manager.cc
new file mode 100644
index 0000000..056817e
--- /dev/null
+++ b/platform/freertos/platform_debug_dump_manager.cc
@@ -0,0 +1,58 @@
+/*
+ * Copyright (C) 2020 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 "chre/platform/platform_debug_dump_manager.h"
+
+#include "chre/core/event_loop_manager.h"
+#include "chre/platform/log.h"
+#include "chre/target_platform/host_link_base.h"
+#include "chre/target_platform/platform_debug_dump_manager_base.h"
+
+#include <cstring>
+
+namespace chre {
+
+void PlatformDebugDumpManager::sendDebugDump(const char *debugStr,
+                                             bool complete) {
+  // DDM is guaranteed to call complete=true at the end of a debug dump session.
+  // However, sendDebugDumpResult may not get called with complete=true.
+  // Therefore, mDataCount has to be reset here instead of in
+  // sendDebugDumpResult(), to properly start the next debug dump session.
+  if (mComplete) {
+    mDataCount = 0;
+  }
+  mComplete = complete;
+
+  sendDebugDumpResult(debugStr, strlen(debugStr), complete);
+}
+
+void PlatformDebugDumpManagerBase::onDebugDumpRequested(uint16_t hostClientId) {
+  mHostClientId = hostClientId;
+
+  EventLoopManagerSingleton::get()->getDebugDumpManager().trigger();
+}
+
+void PlatformDebugDumpManagerBase::sendDebugDumpResult(const char *debugStr,
+                                                       size_t debugStrSize,
+                                                       bool complete) {
+  if (debugStrSize > 0) {
+    mDataCount++;
+  }
+  sendDebugDumpResultToHost(mHostClientId, debugStr, debugStrSize, complete,
+                            mDataCount);
+}
+
+}  // namespace chre
diff --git a/platform/freertos/platform_nanoapp.cc b/platform/freertos/platform_nanoapp.cc
new file mode 100644
index 0000000..80fbf17
--- /dev/null
+++ b/platform/freertos/platform_nanoapp.cc
@@ -0,0 +1,282 @@
+/*
+ * Copyright (C) 2019 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 "chre/platform/platform_nanoapp.h"
+
+#include <dlfcn.h>
+#include <cinttypes>
+
+#include "chre/platform/assert.h"
+#include "chre/platform/log.h"
+#include "chre/platform/shared/memory.h"
+#include "chre/platform/shared/nanoapp_dso_util.h"
+#include "chre/platform/shared/nanoapp_loader.h"
+#include "chre/util/macros.h"
+#include "chre/util/system/napp_header_utils.h"
+#include "chre_api/chre/version.h"
+
+namespace chre {
+namespace {
+
+const char kDefaultAppVersionString[] = "<undefined>";
+size_t kDefaultAppVersionStringSize = ARRAY_SIZE(kDefaultAppVersionString);
+
+}  // namespace
+
+PlatformNanoapp::~PlatformNanoapp() {
+  closeNanoapp();
+
+  if (mAppBinary != nullptr) {
+    forceDramAccess();
+    memoryFreeDram(mAppBinary);
+  }
+}
+
+bool PlatformNanoapp::start() {
+  forceDramAccess();
+
+  bool success = false;
+  if (!openNanoapp()) {
+    LOGE("Failed to open nanoapp");
+  } else if (mAppInfo == nullptr) {
+    LOGE("Null app info!");
+  } else {
+    success = mAppInfo->entryPoints.start();
+  }
+  return success;
+}
+
+void PlatformNanoapp::handleEvent(uint32_t senderInstanceId, uint16_t eventType,
+                                  const void *eventData) {
+  forceDramAccess();
+  mAppInfo->entryPoints.handleEvent(senderInstanceId, eventType, eventData);
+}
+
+void PlatformNanoapp::end() {
+  forceDramAccess();
+  mAppInfo->entryPoints.end();
+  closeNanoapp();
+}
+
+uint64_t PlatformNanoapp::getAppId() const {
+  // TODO (karthikmb/stange): Ideally, we should store the metadata as SRAM
+  // variables, to avoid bumping into DRAM for basic queries.
+  forceDramAccess();
+  return (mAppInfo != nullptr) ? mAppInfo->appId : mExpectedAppId;
+}
+
+uint32_t PlatformNanoapp::getAppVersion() const {
+  forceDramAccess();
+  return (mAppInfo != nullptr) ? mAppInfo->appVersion : mExpectedAppVersion;
+}
+
+const char *PlatformNanoapp::getAppName() const {
+  forceDramAccess();
+  return (mAppInfo != nullptr) ? mAppInfo->name : "Unknown";
+}
+
+uint32_t PlatformNanoapp::getTargetApiVersion() const {
+  forceDramAccess();
+  return (mAppInfo != nullptr) ? mAppInfo->targetApiVersion : 0;
+}
+
+bool PlatformNanoapp::isSystemNanoapp() const {
+  forceDramAccess();
+  return (mAppInfo != nullptr && mAppInfo->isSystemNanoapp);
+}
+
+void PlatformNanoapp::logStateToBuffer(DebugDumpWrapper &debugDump) const {
+  if (mAppInfo != nullptr) {
+    size_t versionLen = 0;
+    const char *version = getAppVersionString(&versionLen);
+    debugDump.print("%s (%s) @ build: %.*s", mAppInfo->name, mAppInfo->vendor,
+                    versionLen, version);
+  }
+}
+
+const char *PlatformNanoappBase::getAppVersionString(size_t *length) const {
+  const char *versionString = kDefaultAppVersionString;
+  *length = kDefaultAppVersionStringSize;
+
+  size_t endOffset = 0;
+  if (mAppUnstableId != nullptr) {
+    size_t appVersionStringLength = strlen(mAppUnstableId);
+
+    //! The unstable ID is expected to be in the format of
+    //! <descriptor>=<build ID>@<more descriptors>. Use this expected layout
+    //! knowledge to parse the string and only return the build ID portion that
+    //! should be printed.
+    size_t startOffset = SIZE_MAX;
+    for (size_t i = 0; i < appVersionStringLength; i++) {
+      size_t offset = i + 1;
+      if (startOffset == SIZE_MAX && mAppUnstableId[i] == '=' &&
+          offset < appVersionStringLength) {
+        startOffset = offset;
+      }
+
+      if (mAppUnstableId[i] == '@') {
+        endOffset = i;
+        break;
+      }
+    }
+
+    if (startOffset < endOffset) {
+      versionString = &mAppUnstableId[startOffset];
+      *length = endOffset - startOffset;
+    }
+  }
+
+  return versionString;
+}
+
+bool PlatformNanoappBase::isLoaded() const {
+  return (mIsStatic ||
+          (mAppBinary != nullptr && mBytesLoaded == mAppBinaryLen) ||
+          mDsoHandle != nullptr || mAppFilename != nullptr);
+}
+
+bool PlatformNanoappBase::isDramApp() const {
+  // TODO: Determine if an app is in DRAM or not once nanoapps in SRAM
+  // are supported.
+  return true;
+}
+
+void PlatformNanoappBase::loadStatic(const struct chreNslNanoappInfo *appInfo) {
+  CHRE_ASSERT(!isLoaded());
+  mIsStatic = true;
+  mAppInfo = appInfo;
+}
+
+bool PlatformNanoappBase::reserveBuffer(uint64_t appId, uint32_t appVersion,
+                                        uint32_t appFlags,
+                                        size_t appBinaryLen) {
+  CHRE_ASSERT(!isLoaded());
+
+  forceDramAccess();
+
+  bool success = false;
+  mAppBinary = memoryAllocDram(appBinaryLen);
+
+  bool isSigned = IS_BIT_SET(appFlags, CHRE_NAPP_HEADER_SIGNED);
+  if (!isSigned) {
+    LOGE("Unable to load unsigned nanoapps");
+  } else if (mAppBinary == nullptr) {
+    LOG_OOM();
+  } else {
+    bool tcmCapable = IS_BIT_SET(appFlags, CHRE_NAPP_HEADER_TCM_CAPABLE);
+    mExpectedAppId = appId;
+    mExpectedAppVersion = appVersion;
+    mExpectedTcmCapable = tcmCapable;
+    mAppBinaryLen = appBinaryLen;
+    success = true;
+  }
+
+  return success;
+}
+
+bool PlatformNanoappBase::copyNanoappFragment(const void *buffer,
+                                              size_t bufferLen) {
+  CHRE_ASSERT(!isLoaded());
+
+  forceDramAccess();
+
+  bool success = true;
+
+  if ((mBytesLoaded + bufferLen) > mAppBinaryLen) {
+    LOGE("Overflow: cannot load %zu bytes to %zu/%zu nanoapp binary buffer",
+         bufferLen, mBytesLoaded, mAppBinaryLen);
+    success = false;
+  } else {
+    uint8_t *binaryBuffer = static_cast<uint8_t *>(mAppBinary) + mBytesLoaded;
+    memcpy(binaryBuffer, buffer, bufferLen);
+    mBytesLoaded += bufferLen;
+  }
+
+  return success;
+}
+
+bool PlatformNanoappBase::verifyNanoappInfo() {
+  bool success = false;
+
+  if (mDsoHandle == nullptr) {
+    LOGE("No nanoapp info to verify");
+  } else {
+    mAppInfo = static_cast<const struct chreNslNanoappInfo *>(
+        dlsym(mDsoHandle, CHRE_NSL_DSO_NANOAPP_INFO_SYMBOL_NAME));
+    mAppUnstableId = static_cast<const char *>(
+        dlsym(mDsoHandle, CHRE_NSL_DSO_NANOAPP_UNSTABLE_ID_SYMBOL_NAME));
+    if (mAppInfo == nullptr) {
+      LOGE("Failed to find app info symbol");
+    } else if (mAppUnstableId == nullptr) {
+      LOGE("Failed to find unstable ID symbol");
+    } else {
+      success = validateAppInfo(mExpectedAppId, mExpectedAppVersion, mAppInfo);
+      if (success && mAppInfo->isTcmNanoapp != mExpectedTcmCapable) {
+        success = false;
+        LOGE("Expected TCM nanoapp %d found %d", mExpectedTcmCapable,
+             mAppInfo->isTcmNanoapp);
+      }
+
+      if (!success) {
+        mAppInfo = nullptr;
+      } else {
+        LOGI("Successfully loaded nanoapp: %s (0x%016" PRIx64
+             ") version 0x%" PRIx32 " uimg %d system %d",
+             mAppInfo->name, mAppInfo->appId, mAppInfo->appVersion,
+             mAppInfo->isTcmNanoapp, mAppInfo->isSystemNanoapp);
+      }
+    }
+  }
+  return success;
+}
+
+bool PlatformNanoappBase::openNanoapp() {
+  bool success = false;
+  if (mIsStatic) {
+    success = true;
+  } else if (mAppBinary != nullptr) {
+    if (mDsoHandle == nullptr) {
+      mDsoHandle = dlopenbuf(mAppBinary, mExpectedTcmCapable);
+      success = verifyNanoappInfo();
+    } else {
+      LOGE("Trying to reopen an existing buffer");
+    }
+  }
+
+  if (!success) {
+    closeNanoapp();
+  }
+
+  if (mAppBinary != nullptr) {
+    memoryFreeDram(mAppBinary);
+    mAppBinary = nullptr;
+  }
+
+  return success;
+}
+
+void PlatformNanoappBase::closeNanoapp() {
+  if (mDsoHandle != nullptr) {
+    forceDramAccess();
+    mAppInfo = nullptr;
+    if (dlclose(mDsoHandle) != 0) {
+      LOGE("dlclose failed");
+    }
+    mDsoHandle = nullptr;
+  }
+}
+
+}  // namespace chre
diff --git a/platform/platform.mk b/platform/platform.mk
index 0666080..2c095a2 100644
--- a/platform/platform.mk
+++ b/platform/platform.mk
@@ -26,6 +26,9 @@
 SLPI_CFLAGS += -I$(SLPI_PREFIX)/platform/inc/a1std
 SLPI_CFLAGS += -I$(SLPI_PREFIX)/platform/inc/stddef
 SLPI_CFLAGS += -I$(SLPI_PREFIX)/platform/rtld/inc
+SLPI_CFLAGS += -I$(SLPI_PREFIX)/ssc/goog/api
+SLPI_CFLAGS += -I$(SLPI_PREFIX)/ssc/inc
+SLPI_CFLAGS += -I$(SLPI_PREFIX)/ssc/inc/internal
 
 SLPI_CFLAGS += -Iplatform/shared/include
 SLPI_CFLAGS += -Iplatform/slpi/include
@@ -33,6 +36,10 @@
 # We use FlatBuffers in the SLPI platform layer
 SLPI_CFLAGS += $(FLATBUFFERS_CFLAGS)
 
+# Needed to define __SIZEOF_ATTR_THREAD in sns_osa_thread.h, included in
+# sns_memmgr.h.
+SLPI_CFLAGS += -DSSC_TARGET_HEXAGON
+
 ifneq ($(CHRE_ENABLE_ACCEL_CAL), false)
 SLPI_CFLAGS += -DCHRE_ENABLE_ACCEL_CAL
 endif
@@ -49,19 +56,12 @@
 SLPI_SEE_CFLAGS += -I$(SLPI_PREFIX)/qmimsgs/common/api
 SLPI_SEE_CFLAGS += -I$(SLPI_PREFIX)/ssc_api/pb
 SLPI_SEE_CFLAGS += -I$(SLPI_PREFIX)/ssc/framework/cm/inc
-SLPI_SEE_CFLAGS += -I$(SLPI_PREFIX)/ssc/goog/api
-SLPI_SEE_CFLAGS += -I$(SLPI_PREFIX)/ssc/inc
-SLPI_SEE_CFLAGS += -I$(SLPI_PREFIX)/ssc/inc/internal
 SLPI_SEE_CFLAGS += -I$(SLPI_PREFIX)/ssc/inc/utils/nanopb
 
 SLPI_SEE_CFLAGS += -Iplatform/slpi/see/include
 
 SLPI_SEE_CFLAGS += -DCHRE_SLPI_SEE
 
-# Needed to define __SIZEOF_ATTR_THREAD in sns_osa_thread.h, included in
-# sns_memmgr.h.
-SLPI_SEE_CFLAGS += -DSSC_TARGET_HEXAGON
-
 # Defined in slpi_proc/ssc/build/ssc.scons
 SLPI_SEE_CFLAGS += -DPB_FIELD_16BIT
 
@@ -153,6 +153,139 @@
 SLPI_SEE_SRCS += platform/slpi/see/island_vote_client.cc
 endif
 
+# FreeRTOS-specific Source Files ###############################################
+
+FREERTOS_SRCS += platform/freertos/context.cc
+FREERTOS_SRCS += platform/freertos/init.cc
+FREERTOS_SRCS += platform/freertos/memory_manager.cc
+FREERTOS_SRCS += platform/freertos/platform_debug_dump_manager.cc
+FREERTOS_SRCS += platform/freertos/platform_nanoapp.cc
+
+# Optional FreeRTOS-specific Source Files ######################################
+
+# memory.cc is only needed if the given platform doesn't have its own memory
+# allocation setup.
+FREERTOS_OPTIONAL_SRCS += platform/freertos/memory.cc
+
+# FreeRTOS-specific Compiler Flags #############################################
+FREERTOS_CFLAGS += -I$(AOC_TOP_DIR)/external/FreeRTOS/FreeRTOS/Source/include
+FREERTOS_CFLAGS += -Iplatform/freertos/include
+FREERTOS_CFLAGS += -Iplatform/shared/include
+
+# AoC-specific Source Files ####################################################
+
+AOC_SRCS += chpp/transport.c
+AOC_SRCS += chpp/app.c
+AOC_SRCS += chpp/services.c
+AOC_SRCS += chpp/services/discovery.c
+AOC_SRCS += chpp/services/loopback.c
+AOC_SRCS += chpp/services/nonhandle.c
+AOC_SRCS += chpp/clients.c
+AOC_SRCS += chpp/clients/discovery.c
+AOC_SRCS += chpp/clients/loopback.c
+AOC_SRCS += chpp/platform/pal_api.c
+AOC_SRCS += chpp/platform/aoc/condition_variable.cc
+AOC_SRCS += chpp/platform/aoc/link.cc
+AOC_SRCS += chpp/platform/aoc/chpp_init.cc
+AOC_SRCS += chpp/platform/aoc/chpp_uart_link_manager.cc
+AOC_SRCS += chpp/platform/aoc/memory.cc
+AOC_SRCS += chpp/platform/aoc/notifier.cc
+AOC_SRCS += chpp/platform/aoc/time.cc
+AOC_SRCS += platform/aoc/audio_controller.cc
+AOC_SRCS += platform/aoc/audio_filter.cc
+AOC_SRCS += platform/aoc/chre_api_re.cc
+AOC_SRCS += platform/aoc/dram_vote_client.cc
+AOC_SRCS += platform/aoc/fatal_error.cc
+AOC_SRCS += platform/aoc/host_link.cc
+AOC_SRCS += platform/aoc/log.cc
+AOC_SRCS += platform/aoc/memory.cc
+AOC_SRCS += platform/aoc/power_control_manager.cc
+AOC_SRCS += platform/aoc/platform_audio.cc
+AOC_SRCS += platform/aoc/platform_cache_management.cc
+AOC_SRCS += platform/aoc/platform_pal.cc
+AOC_SRCS += platform/aoc/system_time.cc
+AOC_SRCS += platform/aoc/system_timer.cc
+AOC_SRCS += platform/shared/chre_api_audio.cc
+AOC_SRCS += platform/shared/chre_api_core.cc
+AOC_SRCS += platform/shared/chre_api_gnss.cc
+AOC_SRCS += platform/shared/chre_api_re.cc
+AOC_SRCS += platform/shared/chre_api_sensor.cc
+AOC_SRCS += platform/shared/chre_api_version.cc
+AOC_SRCS += platform/shared/chre_api_wifi.cc
+AOC_SRCS += platform/shared/chre_api_wwan.cc
+AOC_SRCS += platform/shared/dlfcn.cc
+AOC_SRCS += platform/shared/dram_vote_client.cc
+AOC_SRCS += platform/shared/host_protocol_chre.cc
+AOC_SRCS += platform/shared/host_protocol_common.cc
+AOC_SRCS += platform/shared/memory_manager.cc
+AOC_SRCS += platform/shared/nanoapp_loader.cc
+AOC_SRCS += platform/shared/nanoapp_load_manager.cc
+AOC_SRCS += platform/shared/pal_system_api.cc
+AOC_SRCS += platform/shared/pal_sensor_stub.cc
+AOC_SRCS += platform/shared/system_time.cc
+AOC_SRCS += platform/shared/nanoapp/nanoapp_dso_util.cc
+AOC_SRCS += platform/usf/platform_sensor.cc
+AOC_SRCS += platform/usf/platform_sensor_manager.cc
+AOC_SRCS += platform/usf/platform_sensor_type_helpers.cc
+AOC_SRCS += platform/usf/usf_helper.cc
+
+# Optional GNSS support.
+ifeq ($(CHRE_GNSS_SUPPORT_ENABLED), true)
+AOC_SRCS += platform/shared/platform_gnss.cc
+AOC_SRCS += chpp/clients/gnss.c
+AOC_CFLAGS += -DCHPP_CLIENT_ENABLED_CHRE_GNSS
+endif
+
+# Optional Wi-Fi support.
+ifeq ($(CHRE_WIFI_SUPPORT_ENABLED), true)
+AOC_SRCS += platform/shared/platform_wifi.cc
+AOC_SRCS += chpp/clients/wifi.c
+AOC_CFLAGS += -DCHPP_CLIENT_ENABLED_CHRE_WIFI
+endif
+
+# Optional WWAN support.
+ifeq ($(CHRE_WWAN_SUPPORT_ENABLED), true)
+AOC_SRCS += platform/shared/platform_wwan.cc
+AOC_SRCS += chpp/clients/wwan.c
+AOC_CFLAGS += -DCHPP_CLIENT_ENABLED_CHRE_WWAN
+endif
+
+# AoC-specific Compiler Flags ##################################################
+AOC_CFLAGS += -Iplatform/aoc/include
+AOC_CFLAGS += -Iplatform/usf/include
+AOC_CFLAGS += -I$(AOC_AUTOGEN_DIR)/regions
+AOC_CFLAGS += -I$(AOC_TOP_DIR)/AOC
+AOC_CFLAGS += -I$(AOC_TOP_DIR)/AOC/apps
+AOC_CFLAGS += -I$(AOC_TOP_DIR)/AOC/core/arm/generic/include
+AOC_CFLAGS += -I$(AOC_TOP_DIR)/AOC/drivers/gpio/aoc/include
+AOC_CFLAGS += -I$(AOC_TOP_DIR)/AOC/drivers/gpio/base/include
+AOC_CFLAGS += -I$(AOC_TOP_DIR)/AOC/drivers/gpi/aoc/include
+AOC_CFLAGS += -I$(AOC_TOP_DIR)/AOC/drivers/gpi/base/include
+AOC_CFLAGS += -I$(AOC_TOP_DIR)/AOC/drivers/processor
+AOC_CFLAGS += -I$(AOC_TOP_DIR)/AOC/drivers/processor/aoc/include
+AOC_CFLAGS += -I$(AOC_TOP_DIR)/AOC/drivers/sys_mem/base/include
+AOC_CFLAGS += -I$(AOC_TOP_DIR)/AOC/efw/include
+AOC_CFLAGS += -I$(AOC_TOP_DIR)/AOC/filters/audio/common/include
+AOC_CFLAGS += -I$(AOC_TOP_DIR)/AOC/libs/common/heap/common/include
+AOC_CFLAGS += -I$(AOC_TOP_DIR)/AOC/os/common/include
+AOC_CFLAGS += -I$(AOC_TOP_DIR)/AOC/platform/common/include
+AOC_CFLAGS += -I$(AOC_TOP_DIR)/AOC/product/$(AOC_PRODUCT_FAMILY)/include
+AOC_CFLAGS += -I$(AOC_TOP_DIR)/usf/core/include
+AOC_CFLAGS += -I$(AOC_TOP_DIR)/usf/core/fbs
+AOC_CFLAGS += -I$(AOC_TOP_DIR)/usf/pal/include
+AOC_CFLAGS += -I$(AOC_TOP_DIR)/usf/pal/efw/include
+
+AOC_CFLAGS += -Ichpp/include
+AOC_CFLAGS += -Ichpp/platform/aoc/include
+AOC_CFLAGS += -DCHPP_CLIENT_ENABLED_DISCOVERY
+
+# We use FlatBuffers in the AOC platform layer
+AOC_CFLAGS += $(FLATBUFFERS_CFLAGS)
+
+# Ensure USF uses its own flatbuffers header. This is needed while USF migrates
+# away from CHRE's header.
+AOC_CFLAGS += -DFLATBUFFERS_USF
+
 # Simulator-specific Compiler Flags ############################################
 
 SIM_CFLAGS += -Iplatform/shared/include
diff --git a/platform/shared/dlfcn.cc b/platform/shared/dlfcn.cc
new file mode 100644
index 0000000..630b73c
--- /dev/null
+++ b/platform/shared/dlfcn.cc
@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2020 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 <dlfcn.h>
+
+#include "chre/platform/assert.h"
+#include "chre/platform/shared/nanoapp_loader.h"
+#include "chre/util/unique_ptr.h"
+
+void *dlopenbuf(void *elfBinary, bool mapIntoTcm) {
+  return chre::NanoappLoader::create(elfBinary, mapIntoTcm);
+}
+
+void *dlsym(void *handle, const char *symbol) {
+  LOGV("Attempting to find %s", symbol);
+
+  void *resolvedSymbol = nullptr;
+  if (handle == RTLD_NEXT) {
+    resolvedSymbol = chre::NanoappLoader::findExportedSymbol(symbol);
+  } else if (handle != nullptr) {
+    auto *loader = reinterpret_cast<chre::NanoappLoader *>(handle);
+    resolvedSymbol = loader->findSymbolByName(symbol);
+  }
+
+  if (resolvedSymbol == nullptr) {
+    LOGE("dlsym unable to resolve %s", symbol);
+  } else {
+    LOGV("Found symbol at %p", resolvedSymbol);
+  }
+
+  return resolvedSymbol;
+}
+
+int dlclose(void *handle) {
+  int rv = -1;
+
+  if (handle != nullptr) {
+    chre::NanoappLoader::destroy(static_cast<chre::NanoappLoader *>(handle));
+    rv = 0;
+  }
+
+  return rv;
+}
+
+const char *dlerror() {
+  return "Shared library load failed";
+}
diff --git a/platform/shared/dram_vote_client.cc b/platform/shared/dram_vote_client.cc
new file mode 100644
index 0000000..9c713a9
--- /dev/null
+++ b/platform/shared/dram_vote_client.cc
@@ -0,0 +1,91 @@
+/*
+ * Copyright (C) 2020 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 "chre/platform/shared/dram_vote_client.h"
+
+#include <cinttypes>
+
+#include "chre/platform/assert.h"
+#include "chre/platform/fatal_error.h"
+#include "chre/platform/log.h"
+#include "chre/platform/system_time.h"
+
+namespace chre {
+
+void DramVoteClient::voteDramAccess(bool enabled) {
+  LockGuard<Mutex> lock(mMutex);
+  mLastDramRequest = enabled;
+
+  bool needDram = (enabled || mDramVoteCount > 0);
+  if (needDram != mLastDramVote) {
+    issueDramVote(needDram);
+    mLastDramVote = needDram;
+  }
+}
+
+void DramVoteClient::incrementDramVoteCount() {
+  LockGuard<Mutex> lock(mMutex);
+
+  if (mDramVoteCount++ == 0) {
+    mVoteCountStart = Milliseconds(SystemTime::getMonotonicTime());
+    LOGV("DRAM vote count begins");
+
+    if (!mLastDramVote) {
+      // Do not call voteDramAccess() directly as it will override
+      // mLastDramRequest.
+      issueDramVote(true /* enabled */);
+      mLastDramVote = true;
+    }
+  } else {
+    checkDramDuration();
+  }
+}
+
+void DramVoteClient::decrementDramVoteCount() {
+  LockGuard<Mutex> lock(mMutex);
+  CHRE_ASSERT_LOG(mDramVoteCount > 0,
+                  "Tried to decrement DRAM vote count when it's 0");
+
+  if (--mDramVoteCount == 0) {
+    LOGV("DRAM vote count ends: %" PRIu64 " ms", checkDramDuration());
+
+    // There's no DRAM activity now, remove CHRE's DRAM access vote.
+    if (!mLastDramRequest) {
+      issueDramVote(false /* enabled */);
+      mLastDramVote = false;
+    }
+  }
+}
+
+Milliseconds DramVoteClient::checkDramDuration() const {
+  Milliseconds duration(0);
+  if (mDramVoteCount > 0) {
+    duration = Milliseconds(SystemTime::getMonotonicTime()) - mVoteCountStart;
+  }
+
+  // DRAM memory fallback only intends to handle a surge of DRAM memory
+  // requests. If there's a prolonged period of memory fallback, this might
+  // indicate a memory leak or inadequate SRAM heap size.
+  if (duration > kMaxDramDuration) {
+    FATAL_ERROR("Forced into DRAM for %" PRIu64 " msec", duration);
+  }
+  return duration;
+}
+
+//! Explicitly instantiate the DramVoteClient singleton to reduce code size.
+template class Singleton<DramVoteClient>;
+
+}  // namespace chre
diff --git a/platform/shared/host_protocol_chre.cc b/platform/shared/host_protocol_chre.cc
index 7aa751e..9e04a1a 100644
--- a/platform/shared/host_protocol_chre.cc
+++ b/platform/shared/host_protocol_chre.cc
@@ -81,9 +81,10 @@
             getStringFromByteVector(request->app_binary_file_name());
         HostMessageHandlers::handleLoadNanoappRequest(
             hostClientId, request->transaction_id(), request->app_id(),
-            request->app_version(), request->target_api_version(),
-            appBinary->data(), appBinary->size(), appBinaryFilename,
-            request->fragment_id(), request->total_app_size());
+            request->app_version(), request->app_flags(),
+            request->target_api_version(), appBinary->data(), appBinary->size(),
+            appBinaryFilename, request->fragment_id(),
+            request->total_app_size());
         break;
       }
 
diff --git a/platform/shared/idl/host_messages.fbs b/platform/shared/idl/host_messages.fbs
index a34836c..c6f0451 100644
--- a/platform/shared/idl/host_messages.fbs
+++ b/platform/shared/idl/host_messages.fbs
@@ -139,6 +139,10 @@
   /// Null-terminated ASCII string containing the file name that contains the
   /// app binary to be loaded.
   app_binary_file_name:[byte];
+
+  /// The nanoapp flag values from the nanoapp header defined in
+  /// build/build_template.mk. Refer to that file for more details.
+  app_flags:uint;
 }
 
 table LoadNanoappResponse {
diff --git a/platform/shared/include/chre/platform/shared/dram_vote_client.h b/platform/shared/include/chre/platform/shared/dram_vote_client.h
new file mode 100644
index 0000000..00476a4
--- /dev/null
+++ b/platform/shared/include/chre/platform/shared/dram_vote_client.h
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2020 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 CHRE_PLATFORM_SHARED_VOTE_CLIENT_H_
+#define CHRE_PLATFORM_SHARED_VOTE_CLIENT_H_
+
+#include "chre/platform/mutex.h"
+#include "chre/util/lock_guard.h"
+#include "chre/util/singleton.h"
+#include "chre/util/time.h"
+
+namespace chre {
+
+/**
+ * Class used to manage voting for access to DRAM for platforms that require
+ * voting for DRAM memory to be accessible.
+ */
+class DramVoteClient : public NonCopyable {
+ public:
+  /**
+   * @return true if CHRE currently has a DRAM vote in place.
+   */
+  bool isDramVoteActive() {
+    LockGuard<Mutex> lock(mMutex);
+    return mLastDramVote;
+  }
+
+  /**
+   * Makes a DRAM access request. An actual vote to the memory manager may not
+   * be cast depending on the current mode and mDramVoteCount.
+   *
+   * @param enabled Whether to request DRAM access.
+   */
+  void voteDramAccess(bool enabled);
+
+  /**
+   * Increment the DRAM vote count when a client needs to perform some DRAM
+   * activity. A DRAM vote is issued when the count increments from 0.
+   */
+  void incrementDramVoteCount();
+
+  /**
+   * Decrement the DRAM vote count when a client finishes some activity that has
+   * to be performed in DRAM. A DRAM vote may be removed when the count
+   * decrements to 0, depending on if explicit DRAM votes have been issued from
+   * voteDramAccess.
+   */
+  void decrementDramVoteCount();
+
+ private:
+  //! The maximum allowed duration to be voted into DRAM by
+  //! incrementDramVoteCount before a FATAL_ERROR is triggered.
+  static constexpr Seconds kMaxDramDuration = Seconds(300);
+
+  //! Last DRAM request made through voteDramAccess().
+  bool mLastDramRequest = false;
+
+  //! Last DRAM vote cast to the system.
+  bool mLastDramVote = false;
+
+  //! The system time mDramVoteCount increments from 0.
+  Milliseconds mVoteCountStart = Milliseconds(0);
+
+  //! The count of DRAM activities.
+  uint32_t mDramVoteCount = 0;
+
+  //! Used to protect access to member variables from other threads.
+  Mutex mMutex;
+
+  /**
+   * Issue a vote to the underlying system. This must be implemented by each
+   * platform to communicate with the right system.
+   *
+   * @param enabled Whether DRAM should be accessible.
+   */
+  void issueDramVote(bool enabled);
+
+  /**
+   * Check how long the system has been voted into DRAM due to
+   * incrementDramVoteCount. If longer than kMaxDramDuration, trigger a crash.
+   *
+   * @return the duration in milliseconds since the system has been voted into
+   *         big image due to incrementDramVoteCount.
+   */
+  Milliseconds checkDramDuration() const;
+};
+
+//! Provides an alias to the DramVoteClient singleton
+typedef Singleton<DramVoteClient> DramVoteClientSingleton;
+
+extern template class Singleton<DramVoteClient>;
+
+}  // namespace chre
+
+#endif  // CHRE_PLATFORM_SHARED_VOTE_CLIENT_H_
diff --git a/platform/shared/include/chre/platform/shared/generated/host_messages_generated.h b/platform/shared/include/chre/platform/shared/generated/host_messages_generated.h
index 15a9284..8eeb753 100644
--- a/platform/shared/include/chre/platform/shared/generated/host_messages_generated.h
+++ b/platform/shared/include/chre/platform/shared/generated/host_messages_generated.h
@@ -839,7 +839,8 @@
     VT_APP_BINARY = 12,
     VT_FRAGMENT_ID = 14,
     VT_TOTAL_APP_SIZE = 16,
-    VT_APP_BINARY_FILE_NAME = 18
+    VT_APP_BINARY_FILE_NAME = 18,
+    VT_APP_FLAGS = 20
   };
   uint32_t transaction_id() const {
     return GetField<uint32_t>(VT_TRANSACTION_ID, 0);
@@ -871,6 +872,11 @@
   const flatbuffers::Vector<int8_t> *app_binary_file_name() const {
     return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_APP_BINARY_FILE_NAME);
   }
+  /// The nanoapp flag values from the nanoapp header defined in
+  /// build/build_template.mk. Refer to that file for more details.
+  uint32_t app_flags() const {
+    return GetField<uint32_t>(VT_APP_FLAGS, 0);
+  }
   bool Verify(flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<uint32_t>(verifier, VT_TRANSACTION_ID) &&
@@ -883,6 +889,7 @@
            VerifyField<uint32_t>(verifier, VT_TOTAL_APP_SIZE) &&
            VerifyOffset(verifier, VT_APP_BINARY_FILE_NAME) &&
            verifier.VerifyVector(app_binary_file_name()) &&
+           VerifyField<uint32_t>(verifier, VT_APP_FLAGS) &&
            verifier.EndTable();
   }
 };
@@ -915,6 +922,9 @@
   void add_app_binary_file_name(flatbuffers::Offset<flatbuffers::Vector<int8_t>> app_binary_file_name) {
     fbb_.AddOffset(LoadNanoappRequest::VT_APP_BINARY_FILE_NAME, app_binary_file_name);
   }
+  void add_app_flags(uint32_t app_flags) {
+    fbb_.AddElement<uint32_t>(LoadNanoappRequest::VT_APP_FLAGS, app_flags, 0);
+  }
   explicit LoadNanoappRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
@@ -937,9 +947,11 @@
     flatbuffers::Offset<flatbuffers::Vector<uint8_t>> app_binary = 0,
     uint32_t fragment_id = 0,
     uint32_t total_app_size = 0,
-    flatbuffers::Offset<flatbuffers::Vector<int8_t>> app_binary_file_name = 0) {
+    flatbuffers::Offset<flatbuffers::Vector<int8_t>> app_binary_file_name = 0,
+    uint32_t app_flags = 0) {
   LoadNanoappRequestBuilder builder_(_fbb);
   builder_.add_app_id(app_id);
+  builder_.add_app_flags(app_flags);
   builder_.add_app_binary_file_name(app_binary_file_name);
   builder_.add_total_app_size(total_app_size);
   builder_.add_fragment_id(fragment_id);
@@ -959,7 +971,8 @@
     const std::vector<uint8_t> *app_binary = nullptr,
     uint32_t fragment_id = 0,
     uint32_t total_app_size = 0,
-    const std::vector<int8_t> *app_binary_file_name = nullptr) {
+    const std::vector<int8_t> *app_binary_file_name = nullptr,
+    uint32_t app_flags = 0) {
   auto app_binary__ = app_binary ? _fbb.CreateVector<uint8_t>(*app_binary) : 0;
   auto app_binary_file_name__ = app_binary_file_name ? _fbb.CreateVector<int8_t>(*app_binary_file_name) : 0;
   return chre::fbs::CreateLoadNanoappRequest(
@@ -971,7 +984,8 @@
       app_binary__,
       fragment_id,
       total_app_size,
-      app_binary_file_name__);
+      app_binary_file_name__,
+      app_flags);
 }
 
 struct LoadNanoappResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
diff --git a/platform/shared/include/chre/platform/shared/host_protocol_chre.h b/platform/shared/include/chre/platform/shared/host_protocol_chre.h
index 8ee6f80..0b3deea 100644
--- a/platform/shared/include/chre/platform/shared/host_protocol_chre.h
+++ b/platform/shared/include/chre/platform/shared/host_protocol_chre.h
@@ -59,9 +59,9 @@
 
   static void handleLoadNanoappRequest(
       uint16_t hostClientId, uint32_t transactionId, uint64_t appId,
-      uint32_t appVersion, uint32_t targetApiVersion, const void *buffer,
-      size_t bufferLen, const char *appFileName, uint32_t fragmentId,
-      size_t appBinaryLen);
+      uint32_t appVersion, uint32_t appFlags, uint32_t targetApiVersion,
+      const void *buffer, size_t bufferLen, const char *appFileName,
+      uint32_t fragmentId, size_t appBinaryLen);
 
   static void handleUnloadNanoappRequest(uint16_t hostClientId,
                                          uint32_t transactionId, uint64_t appId,
diff --git a/platform/shared/include/chre/platform/shared/libc/dlfcn.h b/platform/shared/include/chre/platform/shared/libc/dlfcn.h
new file mode 100644
index 0000000..f7623b3
--- /dev/null
+++ b/platform/shared/include/chre/platform/shared/libc/dlfcn.h
@@ -0,0 +1,61 @@
+/*
+ * Copyright (C) 2020 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 CHRE_PLATFORM_SHARED_DLFCN_H_
+#define CHRE_PLATFORM_SHARED_DLFCN_H_
+
+//! This file is intended to be used when a platform doesn't provide a dlfcn.h
+//! implementation so that dynamic loading support can be provided to nanoapps.
+
+#include <cstdlib>
+
+//! Indicates that the dlsym call is attempting to lookup the provided symbol
+//! in another library (CHRE).
+#ifndef RTLD_NEXT
+#define RTLD_NEXT ((void *)-1L)
+#endif  // RTLD_NEXT
+
+/**
+ * This function parses, verifies, and loads a buffer containing an ELF
+ * file, and returns an opaque handle for symbol lookup via dlsym.
+ * Note that there is no requirement to pass in a 'buffer size' argument,
+ * since all the necessary information is gathered from the headers
+ * embedded in the elf file itself. The buffer is expected to contain the
+ * entire elf file in memory (cannot be a FILE pointer, for example).
+ *
+ * @param elfBinary is a buffer containing the elf file
+ * @param mapIntoTcm Indicates whether the elfBinary should be mapped into
+ *     tightly coupled memory.
+ */
+void *dlopenbuf(void *elfBinary, bool mapIntoTcm);
+
+/**
+ * Returns a (function) pointer to the symbol named by the input argument.
+ *
+ * @return pointer to the symbol if it was found, nullptr if not found or
+ * the handle was invalid
+ */
+void *dlsym(void *handle, const char *symbol);
+
+/**
+ * Invalidate the handle used for symbol lookup, and free up any
+ * allocated memory.
+ *
+ * @return 0 on success
+ */
+int dlclose(void *handle);
+
+#endif  // CHRE_PLATFORM_SHARED_DLFCN_H_
diff --git a/platform/shared/include/chre/platform/shared/loader_util.h b/platform/shared/include/chre/platform/shared/loader_util.h
new file mode 100644
index 0000000..8e33428
--- /dev/null
+++ b/platform/shared/include/chre/platform/shared/loader_util.h
@@ -0,0 +1,237 @@
+/*
+ * Copyright (C) 2020 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 CHRE_PLATFORM_SHARED_LOADER_UTIL_H_
+#define CHRE_PLATFORM_SHARED_LOADER_UTIL_H_
+
+// The below macros allow switching the ELF symbol type between 32/64-bit
+// depending on what the chipset supports.
+#ifndef ELFW
+#ifndef __WORDSIZE
+// Until we can get a hold of wordsize.h, we need to define it here.
+// Only 32-bit architectures currently supported.
+#ifndef __aarch64__
+#define __WORDSIZE 32
+#else
+#error "Only 32-bit architectures currently supported"
+#endif
+#endif
+// https://refspecs.linuxbase.org/elf/gabi4+/ch4.reloc.html
+#define ELF32_R_SYM(info) ((info) >> 8)
+#define ELF32_R_TYPE(info) ((unsigned char)(info))
+#define ELF32_R_INFO(sym, type) (((sym) << 8) + (unsigned char)(type))
+#define __ELF_NATIVE_CLASS __WORDSIZE
+#define ELFW(type) _ELFW(__ELF_NATIVE_CLASS, type)
+#define _ELFW(bits, type) __ELFW(bits, type)
+#define __ELFW(bits, type) ELF##bits##_##type
+#endif
+#define ELFW_R_TYPE(x) ELFW(R_TYPE)(x)
+#define ELFW_R_SYM(x) ELFW(R_SYM)(x)
+
+struct ExportedData {
+  void *data;
+  const char *dataName;
+};
+
+// The below is copied from bionic/libc/kernel/uapi/linux/elf.h
+// to avoid pulling those deps into the build.
+#if defined(__LP64__)
+#define ElfW(type) Elf64_##type
+#else
+#define ElfW(type) Elf32_##type
+#endif
+
+#define EM_ARM 40
+#define EI_MAG0 0
+#define EI_MAG1 1
+#define EI_MAG2 2
+#define EI_MAG3 3
+#define EI_CLASS 4
+#define EI_DATA 5
+#define EI_VERSION 6
+#define EI_OSABI 7
+#define EI_PAD 8
+#define ELFMAG0 0x7f
+#define ELFMAG1 'E'
+#define ELFMAG2 'L'
+#define ELFMAG3 'F'
+#define ELFMAG "\177ELF"
+#define SELFMAG 4
+#define ELFCLASSNONE 0
+#define ELFCLASS32 1
+#define ELFCLASS64 2
+#define ELFCLASSNUM 3
+#define ELFDATANONE 0
+#define ELFDATA2LSB 1
+#define ELFDATA2MSB 2
+#define EV_NONE 0
+#define EV_CURRENT 1
+#define EV_NUM 2
+#define ELFOSABI_NONE 0
+#define ELFOSABI_LINUX 3
+#define PT_NULL 0
+#define PT_LOAD 1
+#define PT_DYNAMIC 2
+#define PT_INTERP 3
+#define PT_NOTE 4
+#define PT_SHLIB 5
+#define PT_PHDR 6
+#define PT_TLS 7
+#define PT_LOOS 0x60000000
+#define PT_HIOS 0x6fffffff
+#define PT_LOPROC 0x70000000
+#define PT_HIPROC 0x7fffffff
+#define PT_GNU_EH_FRAME 0x6474e550
+#define PT_GNU_STACK (PT_LOOS + 0x474e551)
+#define PN_XNUM 0xffff
+#define ET_NONE 0
+#define ET_REL 1
+#define ET_EXEC 2
+#define ET_DYN 3
+#define ET_CORE 4
+#define ET_LOPROC 0xff00
+#define ET_HIPROC 0xffff
+#define DT_NULL 0
+#define DT_NEEDED 1
+#define DT_PLTRELSZ 2
+#define DT_PLTGOT 3
+#define DT_HASH 4
+#define DT_STRTAB 5
+#define DT_SYMTAB 6
+#define DT_RELA 7
+#define DT_RELASZ 8
+#define DT_RELAENT 9
+#define DT_STRSZ 10
+#define DT_SYMENT 11
+#define DT_INIT 12
+#define DT_FINI 13
+#define DT_SONAME 14
+#define DT_RPATH 15
+#define DT_SYMBOLIC 16
+#define DT_REL 17
+#define DT_RELSZ 18
+#define DT_RELENT 19
+#define DT_PLTREL 20
+#define DT_DEBUG 21
+#define DT_TEXTREL 22
+#define DT_JMPREL 23
+#define DT_ENCODING 32
+
+typedef __signed__ char __s8;
+typedef unsigned char __u8;
+typedef __signed__ short __s16;
+typedef unsigned short __u16;
+typedef __signed__ int __s32;
+typedef unsigned int __u32;
+typedef __signed__ long __s64;
+typedef unsigned long __u64;
+
+typedef __u32 Elf32_Addr;
+typedef __u16 Elf32_Half;
+typedef __u32 Elf32_Off;
+typedef __s32 Elf32_Sword;
+typedef __u32 Elf32_Word;
+
+#define EI_NIDENT 16
+typedef struct elf32_hdr {
+  unsigned char e_ident[EI_NIDENT];
+  Elf32_Half e_type;
+  Elf32_Half e_machine;
+  Elf32_Word e_version;
+  Elf32_Addr e_entry;
+  Elf32_Off e_phoff;
+  Elf32_Off e_shoff;
+  Elf32_Word e_flags;
+  Elf32_Half e_ehsize;
+  Elf32_Half e_phentsize;
+  Elf32_Half e_phnum;
+  Elf32_Half e_shentsize;
+  Elf32_Half e_shnum;
+  Elf32_Half e_shstrndx;
+} Elf32_Ehdr;
+
+typedef struct dynamic {
+  Elf32_Sword d_tag;
+  union {
+    Elf32_Sword d_val;
+    Elf32_Addr d_ptr;
+  } d_un;
+} Elf32_Dyn;
+
+typedef struct elf32_phdr {
+  Elf32_Word p_type;
+  Elf32_Off p_offset;
+  Elf32_Addr p_vaddr;
+  Elf32_Addr p_paddr;
+  Elf32_Word p_filesz;
+  Elf32_Word p_memsz;
+  Elf32_Word p_flags;
+  Elf32_Word p_align;
+} Elf32_Phdr;
+
+typedef struct elf32_shdr {
+  Elf32_Word sh_name;
+  Elf32_Word sh_type;
+  Elf32_Word sh_flags;
+  Elf32_Addr sh_addr;
+  Elf32_Off sh_offset;
+  Elf32_Word sh_size;
+  Elf32_Word sh_link;
+  Elf32_Word sh_info;
+  Elf32_Word sh_addralign;
+  Elf32_Word sh_entsize;
+} Elf32_Shdr;
+
+typedef struct elf32_rela {
+  Elf32_Addr r_offset;
+  Elf32_Word r_info;
+  Elf32_Sword r_addend;
+} Elf32_Rela;
+
+typedef struct elf32_rel {
+  Elf32_Addr r_offset;
+  Elf32_Word r_info;
+} Elf32_Rel;
+
+typedef struct elf32_sym {
+  Elf32_Word st_name;
+  Elf32_Addr st_value;
+  Elf32_Word st_size;
+  unsigned char st_info;
+  unsigned char st_other;
+  Elf32_Half st_shndx;
+} Elf32_Sym;
+
+// The following defines are copied from bionic's elf_arm.h header
+// at bionic/libc/kernel/uapi/linux/elf.h
+// Only the relocation types currently supported are copied.
+#define R_ARM_NONE 0
+#define R_ARM_ABS32 2
+#define R_ARM_COPY 20
+#define R_ARM_GLOB_DAT 21
+#define R_ARM_JUMP_SLOT 22
+#define R_ARM_RELATIVE 23
+
+// The following (legal values for segment flags) are copied from
+// bionic's elf.h
+/* http://www.sco.com/developers/gabi/latest/ch5.pheader.html */
+#define PF_X 0x1
+#define PF_W 0x2
+#define PF_R 0x4
+#define PF_MASKOS 0x0ff00000
+#define PF_MASKPROC 0xf0000000
+
+#endif  // CHRE_PLATFORM_SHARED_LOADER_UTIL_H_
diff --git a/platform/shared/include/chre/platform/shared/memory.h b/platform/shared/include/chre/platform/shared/memory.h
new file mode 100644
index 0000000..46a7721
--- /dev/null
+++ b/platform/shared/include/chre/platform/shared/memory.h
@@ -0,0 +1,89 @@
+/*
+ * Copyright (C) 2020 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 CHRE_PLATFORM_SHARED_MEMORY_H_
+#define CHRE_PLATFORM_SHARED_MEMORY_H_
+
+#include <cstddef>
+#include <type_traits>
+
+namespace chre {
+
+/**
+ * Aligned memory allocation using the lowest power heap available. The
+ * semantics are the same as malloc.
+ */
+void *memoryAllocAligned(size_t alignment, size_t size);
+
+/**
+ * Aligned memory allocation specifically using the DRAM heap. The semantics are
+ * the same as malloc.
+ *
+ * If DRAM or another large memory capacity region is not available, this will
+ * allocate from the same memory region as memoryAlloc.
+ */
+void *memoryAllocDramAligned(size_t alignment, size_t size);
+
+/**
+ * Memory allocation specifically using the DRAM heap. The semantics are the
+ * same as malloc.
+ *
+ * If DRAM or another large memory capacity region is not available, this will
+ * allocate from the same memory region as memoryAlloc.
+ */
+void *memoryAllocDram(size_t size);
+
+/**
+ * Memory free from memory allocated using the DRAM heap. The semantics are the
+ * same as free.
+ *
+ * If DRAM or another large memory capacity region is not available, this will
+ * free from the same memory region as memoryFree.
+ */
+void memoryFreeDram(void *pointer);
+
+/**
+ * Ensures memory allocated through memoryAllocDram can be utilized. If memory
+ * allocated through memoryAllocDram is always available, this method can be a
+ * no-op.
+ *
+ * This must be support being invoked from multiple threads.
+ */
+void forceDramAccess();
+
+/**
+ * Removes CHRE's vote to keep DRAM accessible. This must only be called when
+ * CHRE is idle.
+ */
+void removeDramAccessVote();
+
+/**
+ * Allocates memory in DRAM for an object of size T and constructs the object in
+ * the newly allocated object by forwarding the provided parameters.
+ */
+template <typename T, typename... Args>
+inline T *memoryAllocDram(Args &&... args) {
+  auto *storage = static_cast<T *>(memoryAllocDram(sizeof(T)));
+  if (storage != nullptr) {
+    new (storage) T(std::forward<Args>(args)...);
+  }
+
+  return storage;
+}
+
+}  // namespace chre
+
+#endif  // CHRE_PLATFORM_SHARED_MEMORY_H_
diff --git a/platform/shared/include/chre/platform/shared/nanoapp_load_manager.h b/platform/shared/include/chre/platform/shared/nanoapp_load_manager.h
index f8b17a5..c8ae589 100644
--- a/platform/shared/include/chre/platform/shared/nanoapp_load_manager.h
+++ b/platform/shared/include/chre/platform/shared/nanoapp_load_manager.h
@@ -52,12 +52,13 @@
    * @param transactionId the ID of the transaction
    * @param appId the ID of the app to load
    * @param appVersion the version of the app to load
+   * @param appFlags the flags provided by the app being loaded
    * @param totalBinaryLen the total nanoapp binary length
    *
    * @return true if the preparation was successful, false otherwise
    */
   bool prepareForLoad(uint16_t hostClientId, uint32_t transactionId,
-                      uint64_t appId, uint32_t appVersion,
+                      uint64_t appId, uint32_t appVersion, uint32_t appFlags,
                       size_t totalBinaryLen);
 
   /**
diff --git a/platform/shared/include/chre/platform/shared/nanoapp_loader.h b/platform/shared/include/chre/platform/shared/nanoapp_loader.h
new file mode 100644
index 0000000..97ac7e5
--- /dev/null
+++ b/platform/shared/include/chre/platform/shared/nanoapp_loader.h
@@ -0,0 +1,349 @@
+/*
+ * Copyright (C) 2020 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 CHRE_PLATFORM_SHARED_NANOAPP_LOADER_H_
+#define CHRE_PLATFORM_SHARED_NANOAPP_LOADER_H_
+
+#include <cinttypes>
+#include <cstdlib>
+
+#include "chre/platform/shared/loader_util.h"
+
+#include "chre/util/dynamic_vector.h"
+#include "chre/util/nested_data_ptr.h"
+
+namespace chre {
+
+/**
+ * Provides dynamic loading support for nanoapps on FreeRTOS-based platforms.
+ * At a high level, this class is responsible for mapping the provided binary
+ * into CHRE's address space, relocating and resolving symbols, and initializing
+ * and freeing static data.
+ */
+class NanoappLoader {
+ public:
+  NanoappLoader() = delete;
+
+  explicit NanoappLoader(void *elfInput, bool mapIntoTcm) {
+    mBinary.dataPtr = elfInput;
+    mIsTcmBinary = mapIntoTcm;
+  }
+
+  /**
+   * Factory method to create a NanoappLoader Instance after loading
+   * the buffer containing the ELF binary.
+   *
+   * @param elfInput Buffer containing the elf file
+   * @param mapIntoTcm Indicates whether the elfBinary should be mapped into
+   *     tightly coupled memory.
+   * @return Class instance on successful load and verification,
+   *     nullptr otherwise.
+   */
+  static void *create(void *elfInput, bool mapIntoTcm);
+
+  /**
+   * Closes and destroys the NanoappLoader instance.
+   *
+   * @param loader A non-null pointer to the loader that must be destroyed.
+   */
+  static void destroy(NanoappLoader *loader);
+
+  /**
+   * Attempts to locate the exported symbol specified by the given function
+   * name.
+   *
+   * @param name A null-terminated char array that is the name of the function
+   *     to be found.
+   * @return The address of the function. nullptr if not found.
+   */
+  static void *findExportedSymbol(const char *name);
+
+  /**
+   * Method for pointer lookup by symbol name. Only function pointers
+   * are currently supported.
+   *
+   * @return function pointer on successful lookup, nullptr otherwise
+   */
+  void *findSymbolByName(const char *name);
+
+  /**
+   * Registers a function provided through atexit during static initialization
+   * that should be called prior to unloading a nanoapp.
+   *
+   * @param function Function that should be invoked prior to unloading a
+   *     nanoapp.
+   */
+  void registerAtexitFunction(void (*function)(void));
+
+ private:
+  /**
+   * Opens the ELF binary. This maps the binary into memory, resolves symbols,
+   * and invokes any static initializers.
+   *
+   * @return true if all required opening steps were completed.
+   */
+  bool open();
+
+  /**
+   * Closes the loader, freeing any state associated with the loaded ELF binary
+   * and unmapping it from memory. Prior to unmapping from memory, any static
+   * termination functions will be invoked.
+   */
+  void close();
+
+  using DynamicHeader = ElfW(Dyn);
+  using ElfAddr = ElfW(Addr);
+  using ElfHeader = ElfW(Ehdr);
+  using ElfRel = ElfW(Rel);  // Relocation table entry,
+                             // in section of type SHT_REL
+  using ElfRela = ElfW(Rela);
+  using ElfSym = ElfW(Sym);
+  using ElfWord = ElfW(Word);
+  using ProgramHeader = ElfW(Phdr);
+  using SectionHeader = ElfW(Shdr);
+
+  //! Name of various segments in the ELF that need to be looked up
+  static constexpr const char *kSymTableName = ".symtab";
+  static constexpr const char *kStrTableName = ".strtab";
+  static constexpr const char *kInitArrayName = ".init_array";
+  static constexpr const char *kFiniArrayName = ".fini_array";
+  // For now, assume all segments are 4K aligned.
+  // TODO(karthikmb/stange): See about reducing this.
+  static constexpr size_t kBinaryAlignment = 4096;
+
+  //! Pointer to the table of all the section names.
+  char *mSectionNamesPtr;
+  //! Pointer to the table of symbol names of defined symbols.
+  char *mStringTablePtr;
+  //! Pointer to the table of symbol information for defined symbols.
+  uint8_t *mSymbolTablePtr;
+  //! Pointer to the array of section header entries.
+  SectionHeader *mSectionHeadersPtr;
+  //! Number of SectionHeaders pointed to by mSectionHeadersPtr.
+  size_t mNumSectionHeaders;
+  //! Size of the data pointed to by mSymbolTablePtr.
+  size_t mSymbolTableSize;
+
+  // TODO(stange): Store this elsewhere since the location will be invalid after
+  // loading is complete.
+  //! The ELF that is being mapped into the system. This pointer will be invalid
+  //! after open returns.
+  NestedDataPtr<uintptr_t> mBinary;
+  //! The starting location of the memory that has been mapped into the system.
+  NestedDataPtr<uintptr_t> mMapping;
+  //! The difference between where the first load segment was mapped into
+  //! virtual memory and what the virtual load offset was of that segment.
+  ElfAddr mLoadBias;
+  //! Dynamic vector containing functions that should be invoked prior to
+  //! unloading this nanoapp. Note that functions are stored in the order they
+  //! were added and should be called in reverse.
+  DynamicVector<void (*)(void)> mAtexitFunctions;
+  //! Whether this loader instance is managing a TCM nanoapp binary.
+  bool mIsTcmBinary;
+
+  /**
+   * Invokes all functions registered via atexit during static initialization.
+   */
+  void callAtexitFunctions();
+
+  /**
+   * Invokes all initialization functions in .init_array segment.
+   *
+   * @return true if static initialization succeeded.
+   */
+  bool callInitArray();
+
+  /**
+   * Invokes all termination functions in the .fini_array segment.
+   */
+  void callTerminatorArray();
+
+  /**
+   * Allocates memory for all load segments that need to be mapped into virtual
+   * memory and copies the load segments into the newly allocated memory.
+   *
+   * @return true if the memory for mapping was allocated and the load segments
+   *     were formatted correctly.
+   */
+  bool createMappings();
+
+  /**
+   * Copies various sections and headers from the ELF while verifying that they
+   * match the ELF format specficiation.
+   *
+   * @return true if all data was copied and verified.
+   */
+  bool copyAndVerifyHeaders();
+
+  /**
+   * Resolves all relocated symbols located in the DT_REL table.
+   *
+   * @return true if all relocated symbols were resolved.
+   */
+  bool fixRelocations();
+
+  /**
+   * Resolves entries in the Global Offset Table (GOT) to facility the ELF's
+   * compiled using position independent code (PIC).
+   *
+   * @return true if all symbols were resolved.
+   */
+  bool resolveGot();
+
+  /**
+   * Verifies the ELF header has correct values based on the ELF spec.
+   *
+   * @return true if the header passed verification.
+   */
+  bool verifyElfHeader();
+
+  /**
+   * Verifies basic information about program headers.
+   *
+   * @return true if the headers passed verification.
+   */
+  bool verifyProgramHeaders();
+
+  /**
+   * Verifies basic information about section headers.
+   *
+   * @return true if the headers passed verification.
+   */
+  bool verifySectionHeaders();
+
+  /**
+   * Retrieves the symbol name of data located at the given position in the
+   * symbol table.
+   *
+   * @param posInSymbolTable The position in the symbol table where information
+   *     about the symbol can be found.
+   * @return The symbol's name or nullptr if not found.
+   */
+  const char *getDataName(size_t posInSymbolTable);
+
+  /**
+   * Retrieves the name of the section header located at the given offset in the
+   * section name table.
+   *
+   * @param headerOffset The offset in the section names table where the header
+   *     is located.
+   * @return The section's name or the empty string if the offset is 0.
+   */
+  const char *getSectionHeaderName(size_t headerOffset);
+
+  /**
+   * Rounds the given address down to the closest alignment boundary.
+   *
+   * @param virtualAddr The address to be rounded.
+   * @return An address that is a multiple of the platform's alignment and is
+   *     less than or equal to virtualAddr.
+   */
+  uintptr_t roundDownToAlign(uintptr_t virtualAddr);
+
+  /**
+   * Frees any data that was allocated as part of loading the ELF into memory.
+   */
+  void freeAllocatedData();
+
+  /**
+   * Ensures the BSS section is properly mapped into memory. If there is a
+   * difference between the size of the BSS section in the ELF binary and the
+   * size it needs to be in memory, the rest of the section is zeroed out.
+   *
+   * @param header The ProgramHeader of the BSS section that is being mapped in.
+   */
+  void mapBss(const ProgramHeader *header);
+
+  /**
+   * Resolves the address of an undefined symbol located at the given position
+   * in the symbol table. This symbol must be defined and exposed by the given
+   * platform in order for it to be resolved successfully.
+   *
+   * @param posInSymbolTable The position of the undefined symbol in the symbol
+   *     table.
+   * @return The address of the resolved symbol. nullptr if not found.
+   */
+  void *resolveData(size_t posInSymbolTable);
+
+  /**
+   * @return The address for the dynamic segment. nullptr if not found.
+   */
+  DynamicHeader *getDynamicHeader();
+
+  /**
+   * @return The address of the first read-only segment. nullptr if not found.
+   */
+  ProgramHeader *getFirstRoSegHeader();
+
+  /**
+   * Retrieves the section header with the given name.
+   *
+   * @param headerName The name of the section header to find.
+   * @return The address of the section. nullptr if not found.
+   */
+  SectionHeader *getSectionHeader(const char *headerName);
+
+  /**
+   * @return The ELF header for the binary being loaded. nullptr if it doesn't
+   *    exist or no binary is being loaded.
+   */
+  ElfHeader *getElfHeader();
+
+  /**
+   * @return The array of program headers for the binary being loaded. nullptr
+   *    if it doesn't exist or no binary is being loaded.
+   */
+  ProgramHeader *getProgramHeaderArray();
+
+  /**
+   * @return The size of the array of program headers for the binary being
+   *    loaded. 0 if it doesn't exist or no binary is being loaded.
+   */
+  size_t getProgramHeaderArraySize();
+
+  /**
+   * @return An array of characters containing the symbol names for dynamic
+   *    symbols inside the binary being loaded. nullptr if it doesn't exist or
+   *    no binary is being loaded.
+   */
+  char *getDynamicStringTable();
+
+  /**
+   * @return An array of dynamic symbol information for the binary being loaded.
+   *     nullptr if it doesn't exist or no binary is being loaded.
+   */
+  uint8_t *getDynamicSymbolTable();
+
+  /**
+   * @return The size of the array of dynamic symbol information for the binary
+   *     being loaded. 0 if it doesn't exist or no binary is being loaded.
+   */
+  size_t getDynamicSymbolTableSize();
+
+  /**
+   * Returns the first entry in the dynamic header that has a tag that matches
+   * the given field.
+   *
+   * @param dyn The dynamic header for the binary.
+   * @param field The field to be searched for.
+   * @return The value found at the entry. 0 if the entry isn't found.
+   */
+  static ElfWord getDynEntry(DynamicHeader *dyn, int field);
+};
+
+}  // namespace chre
+
+#endif  // CHRE_PLATFORM_SHARED_NANOAPP_LOADER_H_
diff --git a/platform/shared/include/chre/platform/shared/nanoapp_support_lib_dso.h b/platform/shared/include/chre/platform/shared/nanoapp_support_lib_dso.h
index 239206e..abce1bb 100644
--- a/platform/shared/include/chre/platform/shared/nanoapp_support_lib_dso.h
+++ b/platform/shared/include/chre/platform/shared/nanoapp_support_lib_dso.h
@@ -46,6 +46,10 @@
 //! The symbol name expected from the nanoapp's definition of its info struct
 #define CHRE_NSL_DSO_NANOAPP_INFO_SYMBOL_NAME "_chreNslDsoNanoappInfo"
 
+//! The symbol name expected from the nanoapp's definition of its unstable ID
+//! char array
+#define CHRE_NSL_DSO_NANOAPP_UNSTABLE_ID_SYMBOL_NAME "_chreNanoappUnstableId"
+
 //! Maximum length of vendor and name strings
 #define CHRE_NSL_DSO_NANOAPP_STRING_MAX_LEN (32)
 
diff --git a/platform/shared/include/chre/target_platform/platform_cache_management.h b/platform/shared/include/chre/target_platform/platform_cache_management.h
new file mode 100644
index 0000000..123de17
--- /dev/null
+++ b/platform/shared/include/chre/target_platform/platform_cache_management.h
@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2020 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 CHRE_PLATFORM_SHARED_CACHE_MANAGEMENT_H_
+#define CHRE_PLATFORM_SHARED_CACHE_MANAGEMENT_H_
+
+namespace chre {
+
+/**
+ * Invalidates and/or cleans the system instruction and data caches.
+ *
+ * When nanoapps in CHRE are loaded dynamically, the data and
+ * executable segments are parsed and relocated into memory. This operation
+ * can cause cached instructions and data to be invalid when we start executing
+ * the newly loaded nanoapp's instructions, and could possibly lead to an
+ * exception. To support custom dynamic loading implementations (for example,
+ * when it's not part of the underlying OS/system), the platform needs to
+ * implement (or provide an empty stub for) the following method to invalidate
+ * and/or clean the system data and instruction caches.
+ */
+void wipeSystemCaches();
+
+}  // namespace chre
+
+#endif  // CHRE_PLATFORM_SHARED_CACHE_MANAGEMENT_H_
diff --git a/platform/shared/nanoapp/nanoapp_support_lib_dso.cc b/platform/shared/nanoapp/nanoapp_support_lib_dso.cc
index 51cba03..48131ea 100644
--- a/platform/shared/nanoapp/nanoapp_support_lib_dso.cc
+++ b/platform/shared/nanoapp/nanoapp_support_lib_dso.cc
@@ -31,7 +31,7 @@
 
 namespace {
 
-#ifdef CHRE_SLPI_UIMG_ENABLED
+#if defined(CHRE_SLPI_UIMG_ENABLED) || defined(CHRE_TCM_ENABLED)
 constexpr int kIsTcmNanoapp = 1;
 #else
 constexpr int kIsTcmNanoapp = 0;
@@ -75,6 +75,15 @@
 
 }  // anonymous namespace
 
+//! Additional symbol used to determine the given unstable ID that was provided
+//! when building this nanoapp, if any. The symbol is placed in its own section
+//! so it be stripped to determine if the nanoapp changed compared to a previous
+//! version.
+#ifdef NANOAPP_UNSTABLE_ID
+DLL_EXPORT extern "C" const char _chreNanoappUnstableId[]
+    __attribute__((section(".unstable_id"))) = NANOAPP_UNSTABLE_ID;
+#endif  // NANOAPP_UNSTABLE_ID
+
 DLL_EXPORT extern "C" const struct chreNslNanoappInfo _chreNslDsoNanoappInfo = {
     /* magic */ CHRE_NSL_NANOAPP_INFO_MAGIC,
     /* structMinorVersion */ CHRE_NSL_NANOAPP_INFO_STRUCT_MINOR_VERSION,
diff --git a/platform/shared/nanoapp_load_manager.cc b/platform/shared/nanoapp_load_manager.cc
index 03e2b0a..d16b822 100644
--- a/platform/shared/nanoapp_load_manager.cc
+++ b/platform/shared/nanoapp_load_manager.cc
@@ -20,13 +20,14 @@
 
 bool NanoappLoadManager::prepareForLoad(uint16_t hostClientId,
                                         uint32_t transactionId, uint64_t appId,
-                                        uint32_t appVersion,
+                                        uint32_t appVersion, uint32_t appFlags,
                                         size_t totalBinaryLen) {
   if (hasPendingLoadTransaction()) {
     LOGW(
         "Pending load transaction already exists. Overriding previous"
         " transaction.");
   }
+
   mCurrentLoadInfo.hostClientId = hostClientId;
   mCurrentLoadInfo.transactionId = transactionId;
   mCurrentLoadInfo.nextFragmentId = 1;
@@ -36,7 +37,8 @@
   if (mNanoapp.isNull()) {
     LOG_OOM();
   } else {
-    success = mNanoapp->reserveBuffer(appId, appVersion, totalBinaryLen);
+    success =
+        mNanoapp->reserveBuffer(appId, appVersion, appFlags, totalBinaryLen);
   }
 
   if (!success) {
diff --git a/platform/shared/nanoapp_loader.cc b/platform/shared/nanoapp_loader.cc
new file mode 100644
index 0000000..011c963
--- /dev/null
+++ b/platform/shared/nanoapp_loader.cc
@@ -0,0 +1,859 @@
+/*
+ * Copyright (C) 2020 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 <dlfcn.h>
+#include <cctype>
+#include <cmath>
+#include <cstring>
+
+#include "chre/platform/shared/nanoapp_loader.h"
+
+#include "ash.h"
+#include "chre.h"
+#include "chre/platform/assert.h"
+#include "chre/platform/shared/debug_dump.h"
+#include "chre/platform/shared/memory.h"
+#include "chre/target_platform/platform_cache_management.h"
+#include "chre/util/dynamic_vector.h"
+#include "chre/util/macros.h"
+
+#ifndef CHRE_LOADER_ARCH
+#define CHRE_LOADER_ARCH EM_ARM
+#endif  // CHRE_LOADER_ARCH
+
+namespace chre {
+namespace {
+
+using ElfHeader = ElfW(Ehdr);
+using ProgramHeader = ElfW(Phdr);
+
+struct ExportedData {
+  void *data;
+  const char *dataName;
+};
+
+//! If non-null, a nanoapp is currently being loaded. This allows certain C
+//! functions to access the nanoapp if called during static init.
+NanoappLoader *gCurrentlyLoadingNanoapp = nullptr;
+//! Indicates whether a failure occurred during static initialization.
+bool gStaticInitFailure = false;
+
+// The new operator is used by singleton.h which causes the delete operator to
+// be undefined in nanoapp binaries even though it's unused. Define this in case
+// a nanoapp actually tries to use the operator.
+void deleteOverride(void *ptr) {
+  FATAL_ERROR("Nanoapp tried to free %p through delete operator", ptr);
+}
+
+// atexit is used to register functions that must be called when a binary is
+// removed from the system.
+int atexitOverride(void (*function)(void)) {
+  LOGV("atexit invoked with %p", function);
+  if (gCurrentlyLoadingNanoapp == nullptr) {
+    CHRE_ASSERT_LOG(false,
+                    "atexit is only supported during static initialization.");
+    return -1;
+  }
+
+  gCurrentlyLoadingNanoapp->registerAtexitFunction(function);
+  return 0;
+}
+
+// The following functions from the cmath header need to be overridden, since
+// they're overloaded functions, and we need to specify explicit types of the
+// template for the compiler.
+double frexpOverride(double value, int *exp) {
+  return frexp(value, exp);
+}
+
+double sinOverride(double rad) {
+  return sin(rad);
+}
+
+double asinOverride(double val) {
+  return asin(val);
+}
+
+double cosOverride(double rad) {
+  return cos(rad);
+}
+
+float sqrtOverride(float val) {
+  return sqrt(val);
+}
+
+// This function is required to be exposed to nanoapps to handle errors from
+// invoking virtual functions.
+void __cxa_pure_virtual(void) {
+  chreAbort(CHRE_ERROR /* abortCode */);
+}
+
+#define ADD_EXPORTED_SYMBOL(function_name, function_string) \
+  { reinterpret_cast<void *>(function_name), function_string }
+#define ADD_EXPORTED_C_SYMBOL(function_name) \
+  ADD_EXPORTED_SYMBOL(function_name, STRINGIFY(function_name))
+
+// TODO(karthikmb/stange): While this array was hand-coded for simple
+// "hello-world" prototyping, the list of exported symbols must be
+// generated to minimize runtime errors and build breaks.
+const ExportedData gExportedData[] = {
+    /* libmath overrrides and symbols */
+    ADD_EXPORTED_SYMBOL(asinOverride, "asin"),
+    ADD_EXPORTED_SYMBOL(cosOverride, "cos"),
+    ADD_EXPORTED_SYMBOL(frexpOverride, "frexp"),
+    ADD_EXPORTED_SYMBOL(sinOverride, "sin"),
+    ADD_EXPORTED_SYMBOL(sqrtOverride, "sqrt"),
+    ADD_EXPORTED_C_SYMBOL(atan2f),
+    ADD_EXPORTED_C_SYMBOL(expf),
+    ADD_EXPORTED_C_SYMBOL(fmodf),
+    ADD_EXPORTED_C_SYMBOL(sqrtf),
+    ADD_EXPORTED_C_SYMBOL(tanhf),
+    /* libc overrides and symbols */
+    ADD_EXPORTED_C_SYMBOL(__cxa_pure_virtual),
+    ADD_EXPORTED_SYMBOL(atexitOverride, "atexit"),
+    ADD_EXPORTED_SYMBOL(deleteOverride, "_ZdlPv"),
+    ADD_EXPORTED_SYMBOL(dlsym, "_Z5dlsymPvPKc"),
+    ADD_EXPORTED_C_SYMBOL(memcmp),
+    ADD_EXPORTED_C_SYMBOL(memcpy),
+    ADD_EXPORTED_C_SYMBOL(memmove),
+    ADD_EXPORTED_C_SYMBOL(memset),
+    ADD_EXPORTED_C_SYMBOL(strcmp),
+    ADD_EXPORTED_C_SYMBOL(strlen),
+    ADD_EXPORTED_C_SYMBOL(strncmp),
+    ADD_EXPORTED_C_SYMBOL(tolower),
+    /* ash symbols */
+    ADD_EXPORTED_C_SYMBOL(ashLoadCalibrationParams),
+    ADD_EXPORTED_C_SYMBOL(ashSaveCalibrationParams),
+    ADD_EXPORTED_C_SYMBOL(ashSetCalibration),
+    /* CHRE symbols */
+    ADD_EXPORTED_C_SYMBOL(chreAbort),
+    ADD_EXPORTED_C_SYMBOL(chreAudioConfigureSource),
+    ADD_EXPORTED_C_SYMBOL(chreAudioGetSource),
+    ADD_EXPORTED_C_SYMBOL(chreConfigureDebugDumpEvent),
+    ADD_EXPORTED_C_SYMBOL(chreConfigureHostSleepStateEvents),
+    ADD_EXPORTED_C_SYMBOL(chreConfigureNanoappInfoEvents),
+    ADD_EXPORTED_C_SYMBOL(chreGetApiVersion),
+    ADD_EXPORTED_C_SYMBOL(chreGetAppId),
+    ADD_EXPORTED_C_SYMBOL(chreGetInstanceId),
+    ADD_EXPORTED_C_SYMBOL(chreGetEstimatedHostTimeOffset),
+    ADD_EXPORTED_C_SYMBOL(chreGetNanoappInfoByAppId),
+    ADD_EXPORTED_C_SYMBOL(chreGetPlatformId),
+    ADD_EXPORTED_C_SYMBOL(chreGetSensorInfo),
+    ADD_EXPORTED_C_SYMBOL(chreGetSensorSamplingStatus),
+    ADD_EXPORTED_C_SYMBOL(chreGetTime),
+    ADD_EXPORTED_C_SYMBOL(chreGnssGetCapabilities),
+    ADD_EXPORTED_C_SYMBOL(chreGnssLocationSessionStartAsync),
+    ADD_EXPORTED_C_SYMBOL(chreGnssLocationSessionStopAsync),
+    ADD_EXPORTED_C_SYMBOL(chreGnssMeasurementSessionStartAsync),
+    ADD_EXPORTED_C_SYMBOL(chreGnssMeasurementSessionStopAsync),
+    ADD_EXPORTED_C_SYMBOL(chreHeapAlloc),
+    ADD_EXPORTED_C_SYMBOL(chreHeapFree),
+    ADD_EXPORTED_C_SYMBOL(chreIsHostAwake),
+    ADD_EXPORTED_C_SYMBOL(chreLog),
+    ADD_EXPORTED_C_SYMBOL(chreSendEvent),
+    ADD_EXPORTED_C_SYMBOL(chreSendMessageToHostEndpoint),
+    ADD_EXPORTED_C_SYMBOL(chreSensorConfigure),
+    ADD_EXPORTED_C_SYMBOL(chreSensorFindDefault),
+    ADD_EXPORTED_C_SYMBOL(chreTimerCancel),
+    ADD_EXPORTED_C_SYMBOL(chreTimerSet),
+    ADD_EXPORTED_C_SYMBOL(chreWifiConfigureScanMonitorAsync),
+    ADD_EXPORTED_C_SYMBOL(chreWifiGetCapabilities),
+    ADD_EXPORTED_C_SYMBOL(chreWifiRequestScanAsync),
+    ADD_EXPORTED_C_SYMBOL(chreWwanGetCapabilities),
+    ADD_EXPORTED_C_SYMBOL(chreWwanGetCellInfoAsync),
+    ADD_EXPORTED_C_SYMBOL(platform_chreDebugDumpVaLog),
+};
+
+}  // namespace
+
+void *NanoappLoader::create(void *elfInput, bool mapIntoTcm) {
+  void *instance = nullptr;
+  NanoappLoader *loader = memoryAllocDram<NanoappLoader>(elfInput, mapIntoTcm);
+  if (loader != nullptr) {
+    if (loader->open()) {
+      instance = loader;
+    } else {
+      memoryFreeDram(loader);
+    }
+  } else {
+    LOG_OOM();
+  }
+
+  return instance;
+}
+
+void NanoappLoader::destroy(NanoappLoader *loader) {
+  loader->close();
+  // TODO(b/151847750): Modify utilities to support free'ing from regions other
+  // than SRAM.
+  loader->~NanoappLoader();
+  memoryFreeDram(loader);
+}
+
+void *NanoappLoader::findExportedSymbol(const char *name) {
+  for (size_t i = 0; i < ARRAY_SIZE(gExportedData); i++) {
+    if (strncmp(name, gExportedData[i].dataName,
+                strlen(gExportedData[i].dataName)) == 0) {
+      return gExportedData[i].data;
+    }
+  }
+
+  LOGE("Unable to find %s", name);
+  return nullptr;
+}
+
+bool NanoappLoader::open() {
+  bool success = false;
+  if (mBinary.dataPtr != nullptr) {
+    if (!copyAndVerifyHeaders()) {
+      LOGE("Failed to verify headers");
+    } else if (!createMappings()) {
+      LOGE("Failed to create mappings");
+    } else if (!fixRelocations()) {
+      LOGE("Failed to fix relocations");
+    } else if (!resolveGot()) {
+      LOGE("Failed to resolve GOT");
+    } else if (!callInitArray()) {
+      LOGE("Failed to perform static init");
+    } else {
+      success = true;
+    }
+  }
+
+  if (!success) {
+    freeAllocatedData();
+  } else {
+    wipeSystemCaches();
+  }
+
+  return success;
+}
+
+void NanoappLoader::close() {
+  callAtexitFunctions();
+  callTerminatorArray();
+  freeAllocatedData();
+}
+
+void *NanoappLoader::findSymbolByName(const char *name) {
+  void *symbol = nullptr;
+  uint8_t *index = mSymbolTablePtr;
+  while (index < (mSymbolTablePtr + mSymbolTableSize)) {
+    ElfSym *currSym = reinterpret_cast<ElfSym *>(index);
+    const char *symbolName = &mStringTablePtr[currSym->st_name];
+
+    if (strncmp(symbolName, name, strlen(name)) == 0) {
+      symbol = reinterpret_cast<void *>(mMapping.data + currSym->st_value);
+      break;
+    }
+
+    index += sizeof(ElfSym);
+  }
+  return symbol;
+}
+
+void NanoappLoader::registerAtexitFunction(void (*function)(void)) {
+  if (!mAtexitFunctions.push_back(function)) {
+    LOG_OOM();
+    gStaticInitFailure = true;
+  }
+}
+
+void NanoappLoader::mapBss(const ProgramHeader *hdr) {
+  // if the memory size of this segment exceeds the file size zero fill the
+  // difference.
+  LOGV("Program Hdr mem sz: %zu file size: %zu", hdr->p_memsz, hdr->p_filesz);
+  if (hdr->p_memsz > hdr->p_filesz) {
+    ElfAddr endOfFile = hdr->p_vaddr + hdr->p_filesz + mLoadBias;
+    ElfAddr endOfMem = hdr->p_vaddr + hdr->p_memsz + mLoadBias;
+    if (endOfMem > endOfFile) {
+      auto deltaMem = endOfMem - endOfFile;
+      LOGV("Zeroing out %zu from page %p", deltaMem, endOfFile);
+      memset(reinterpret_cast<void *>(endOfFile), 0, deltaMem);
+    }
+  }
+}
+
+bool NanoappLoader::callInitArray() {
+  bool success = true;
+  // Sets global variable used by atexit in case it's invoked as part of
+  // initializing static data.
+  gCurrentlyLoadingNanoapp = this;
+
+  // TODO(b/151847750): ELF can have other sections like .init, .preinit, .fini
+  // etc. Be sure to look for those if they end up being something that should
+  // be supported for nanoapps.
+  for (size_t i = 0; i < mNumSectionHeaders; ++i) {
+    const char *name = getSectionHeaderName(mSectionHeadersPtr[i].sh_name);
+    if (strncmp(name, kInitArrayName, strlen(kInitArrayName)) == 0) {
+      LOGV("Invoking init function");
+      uintptr_t initArray = reinterpret_cast<uintptr_t>(
+          mLoadBias + mSectionHeadersPtr[i].sh_addr);
+      uintptr_t offset = 0;
+      while (offset < mSectionHeadersPtr[i].sh_size) {
+        ElfAddr *funcPtr = reinterpret_cast<ElfAddr *>(initArray + offset);
+        uintptr_t initFunction = reinterpret_cast<uintptr_t>(*funcPtr);
+        ((void (*)())initFunction)();
+        offset += sizeof(initFunction);
+        if (gStaticInitFailure) {
+          success = false;
+          break;
+        }
+      }
+      break;
+    }
+  }
+
+  //! Reset global state so it doesn't leak into the next load.
+  gCurrentlyLoadingNanoapp = nullptr;
+  gStaticInitFailure = false;
+  return success;
+}
+
+uintptr_t NanoappLoader::roundDownToAlign(uintptr_t virtualAddr) {
+  return virtualAddr & -kBinaryAlignment;
+}
+
+void NanoappLoader::freeAllocatedData() {
+  if (mIsTcmBinary) {
+    memoryFree(mMapping.dataPtr);
+  } else {
+    memoryFreeDram(mMapping.dataPtr);
+  }
+  memoryFreeDram(mSectionHeadersPtr);
+  memoryFreeDram(mSectionNamesPtr);
+  memoryFreeDram(mSymbolTablePtr);
+  memoryFreeDram(mStringTablePtr);
+}
+
+bool NanoappLoader::verifyElfHeader() {
+  bool success = false;
+  ElfHeader *elfHeader = getElfHeader();
+  if (elfHeader != nullptr && (elfHeader->e_ident[EI_MAG0] == ELFMAG0) &&
+      (elfHeader->e_ident[EI_MAG1] == ELFMAG1) &&
+      (elfHeader->e_ident[EI_MAG2] == ELFMAG2) &&
+      (elfHeader->e_ident[EI_MAG3] == ELFMAG3) &&
+      (elfHeader->e_ehsize == sizeof(ElfHeader)) &&
+      (elfHeader->e_phentsize == sizeof(ProgramHeader)) &&
+      (elfHeader->e_shentsize == sizeof(SectionHeader)) &&
+      (elfHeader->e_shstrndx < elfHeader->e_shnum) &&
+      (elfHeader->e_version == EV_CURRENT) &&
+      (elfHeader->e_machine == CHRE_LOADER_ARCH) &&
+      (elfHeader->e_type == ET_DYN)) {
+    success = true;
+  }
+  return success;
+}
+
+bool NanoappLoader::verifyProgramHeaders() {
+  // This is a minimal check for now -
+  // there should be at least one load segment.
+  bool success = false;
+  for (size_t i = 0; i < getProgramHeaderArraySize(); ++i) {
+    if (getProgramHeaderArray()[i].p_type == PT_LOAD) {
+      success = true;
+      break;
+    }
+  }
+  return success;
+}
+
+const char *NanoappLoader::getSectionHeaderName(size_t headerOffset) {
+  if (headerOffset == 0) {
+    return "";
+  }
+
+  return &mSectionNamesPtr[headerOffset];
+}
+
+NanoappLoader::SectionHeader *NanoappLoader::getSectionHeader(
+    const char *headerName) {
+  SectionHeader *rv = nullptr;
+  for (size_t i = 0; i < mNumSectionHeaders; ++i) {
+    const char *name = getSectionHeaderName(mSectionHeadersPtr[i].sh_name);
+    if (strncmp(name, headerName, strlen(headerName)) == 0) {
+      rv = &mSectionHeadersPtr[i];
+      break;
+    }
+  }
+  return rv;
+}
+
+ElfHeader *NanoappLoader::getElfHeader() {
+  return reinterpret_cast<ElfHeader *>(mBinary.data);
+}
+
+ProgramHeader *NanoappLoader::getProgramHeaderArray() {
+  ElfHeader *elfHeader = getElfHeader();
+  ProgramHeader *programHeader = nullptr;
+  if (elfHeader != nullptr) {
+    programHeader =
+        reinterpret_cast<ProgramHeader *>(mBinary.data + elfHeader->e_phoff);
+  }
+
+  return programHeader;
+}
+
+size_t NanoappLoader::getProgramHeaderArraySize() {
+  ElfHeader *elfHeader = getElfHeader();
+  size_t arraySize = 0;
+  if (elfHeader != nullptr) {
+    arraySize = elfHeader->e_phnum;
+  }
+
+  return arraySize;
+}
+
+char *NanoappLoader::getDynamicStringTable() {
+  char *table = nullptr;
+
+  SectionHeader *dynamicStringTablePtr = getSectionHeader(".dynstr");
+  CHRE_ASSERT(dynamicStringTablePtr != nullptr);
+  if (dynamicStringTablePtr != nullptr && mBinary.dataPtr != nullptr) {
+    table = reinterpret_cast<char *>(mBinary.data +
+                                     dynamicStringTablePtr->sh_offset);
+  }
+
+  return table;
+}
+
+uint8_t *NanoappLoader::getDynamicSymbolTable() {
+  uint8_t *table = nullptr;
+
+  SectionHeader *dynamicSymbolTablePtr = getSectionHeader(".dynsym");
+  CHRE_ASSERT(dynamicSymbolTablePtr != nullptr);
+  if (dynamicSymbolTablePtr != nullptr && mBinary.dataPtr != nullptr) {
+    table = reinterpret_cast<uint8_t *>(mBinary.data +
+                                        dynamicSymbolTablePtr->sh_offset);
+  }
+
+  return table;
+}
+
+size_t NanoappLoader::getDynamicSymbolTableSize() {
+  size_t tableSize = 0;
+
+  SectionHeader *dynamicSymbolTablePtr = getSectionHeader(".dynsym");
+  CHRE_ASSERT(dynamicSymbolTablePtr != nullptr);
+  if (dynamicSymbolTablePtr != nullptr) {
+    tableSize = dynamicSymbolTablePtr->sh_size;
+  }
+
+  return tableSize;
+}
+
+bool NanoappLoader::verifySectionHeaders() {
+  bool foundSymbolTableHeader = false;
+  bool foundStringTableHeader = false;
+
+  for (size_t i = 0; i < mNumSectionHeaders; ++i) {
+    const char *name = getSectionHeaderName(mSectionHeadersPtr[i].sh_name);
+
+    if (strncmp(name, kSymTableName, strlen(kSymTableName)) == 0) {
+      foundSymbolTableHeader = true;
+    } else if (strncmp(name, kStrTableName, strlen(kStrTableName)) == 0) {
+      foundStringTableHeader = true;
+    }
+  }
+
+  return foundSymbolTableHeader && foundStringTableHeader;
+}
+
+bool NanoappLoader::copyAndVerifyHeaders() {
+  size_t offset = 0;
+  bool success = false;
+  uint8_t *pDataBytes = static_cast<uint8_t *>(mBinary.dataPtr);
+
+  // Verify the ELF Header
+  ElfHeader *elfHeader = getElfHeader();
+  success = verifyElfHeader();
+
+  LOGV("Verified ELF header %d", success);
+
+  // Verify Program Headers
+  if (success) {
+    success = verifyProgramHeaders();
+  }
+
+  LOGV("Verified Program headers %d", success);
+
+  // Load Section Headers
+  if (success) {
+    offset = elfHeader->e_shoff;
+    size_t sectionHeaderSizeBytes = sizeof(SectionHeader) * elfHeader->e_shnum;
+    mSectionHeadersPtr =
+        static_cast<SectionHeader *>(memoryAllocDram(sectionHeaderSizeBytes));
+    if (mSectionHeadersPtr == nullptr) {
+      success = false;
+      LOG_OOM();
+    } else {
+      memcpy(mSectionHeadersPtr, (pDataBytes + offset), sectionHeaderSizeBytes);
+      mNumSectionHeaders = elfHeader->e_shnum;
+    }
+  }
+
+  LOGV("Loaded section headers %d", success);
+
+  // Load section header names
+  if (success) {
+    SectionHeader &stringSection = mSectionHeadersPtr[elfHeader->e_shstrndx];
+    size_t sectionSize = stringSection.sh_size;
+    mSectionNamesPtr = static_cast<char *>(memoryAllocDram(sectionSize));
+    if (mSectionNamesPtr == nullptr) {
+      LOG_OOM();
+      success = false;
+    } else {
+      memcpy(mSectionNamesPtr,
+             reinterpret_cast<void *>(mBinary.data + stringSection.sh_offset),
+             sectionSize);
+    }
+  }
+
+  LOGV("Loaded section header names %d", success);
+
+  success = verifySectionHeaders();
+  LOGV("Verified Section headers %d", success);
+
+  // Load symbol table
+  if (success) {
+    SectionHeader *symbolTableHeader = getSectionHeader(kSymTableName);
+    mSymbolTableSize = symbolTableHeader->sh_size;
+    if (mSymbolTableSize == 0) {
+      LOGE("No symbols to resolve");
+      success = false;
+    } else {
+      mSymbolTablePtr =
+          static_cast<uint8_t *>(memoryAllocDram(mSymbolTableSize));
+      if (mSymbolTablePtr == nullptr) {
+        LOG_OOM();
+        success = false;
+      } else {
+        memcpy(mSymbolTablePtr,
+               reinterpret_cast<void *>(mBinary.data +
+                                        symbolTableHeader->sh_offset),
+               mSymbolTableSize);
+      }
+    }
+  }
+
+  LOGV("Loaded symbol table %d", success);
+
+  // Load string table
+  if (success) {
+    SectionHeader *stringTableHeader = getSectionHeader(kStrTableName);
+    size_t stringTableSize = stringTableHeader->sh_size;
+    if (mSymbolTableSize == 0) {
+      LOGE("No string table corresponding to symbols");
+      success = false;
+    } else {
+      mStringTablePtr = static_cast<char *>(memoryAllocDram(stringTableSize));
+      if (mStringTablePtr == nullptr) {
+        LOG_OOM();
+        success = false;
+      } else {
+        memcpy(mStringTablePtr,
+               reinterpret_cast<void *>(mBinary.data +
+                                        stringTableHeader->sh_offset),
+               stringTableSize);
+      }
+    }
+  }
+
+  LOGV("Loaded string table %d", success);
+
+  return success;
+}
+
+bool NanoappLoader::createMappings() {
+  // ELF needs pt_load segments to be in contiguous ascending order of
+  // virtual addresses. So the first and last segs can be used to
+  // calculate the entire address span of the image.
+  ElfHeader *elfHeader = getElfHeader();
+  ProgramHeader *programHeaderArray = getProgramHeaderArray();
+  size_t numProgramHeaders = getProgramHeaderArraySize();
+  const ProgramHeader *first = &programHeaderArray[0];
+  const ProgramHeader *last = &programHeaderArray[numProgramHeaders - 1];
+
+  // Find first load segment
+  while (first->p_type != PT_LOAD && first <= last) {
+    ++first;
+  }
+
+  bool success = false;
+  if (first->p_type != PT_LOAD) {
+    LOGE("Unable to find any load segments in the binary");
+  } else {
+    // Verify that the first load segment has a program header
+    // first byte of a valid load segment can't be greater than the
+    // program header offset
+    bool valid =
+        (first->p_offset < elfHeader->e_phoff) &&
+        (first->p_filesz >
+         (elfHeader->e_phoff + (numProgramHeaders * sizeof(ProgramHeader))));
+    if (!valid) {
+      LOGE("Load segment program header validation failed");
+    } else {
+      // Get the last load segment
+      while (last > first && last->p_type != PT_LOAD) --last;
+
+      size_t memorySpan = last->p_vaddr + last->p_memsz - first->p_vaddr;
+      LOGV("Nanoapp image Memory Span: %u", memorySpan);
+
+      if (mIsTcmBinary) {
+        mMapping.dataPtr = memoryAllocAligned(kBinaryAlignment, memorySpan);
+      } else {
+        mMapping.dataPtr = memoryAllocDramAligned(kBinaryAlignment, memorySpan);
+      }
+
+      if (mMapping.dataPtr == nullptr) {
+        LOG_OOM();
+      } else {
+        LOGV("Starting location of mappings %p", mMapping.dataPtr);
+
+        // Calculate the load bias using the first load segment.
+        uintptr_t adjustedFirstLoadSegAddr = roundDownToAlign(first->p_vaddr);
+        mLoadBias = mMapping.data - adjustedFirstLoadSegAddr;
+        LOGV("Load bias is %" PRIu32, mLoadBias);
+
+        success = true;
+      }
+    }
+  }
+
+  if (success) {
+    // Map the remaining segments
+    for (const ProgramHeader *ph = first; ph <= last; ++ph) {
+      if (ph->p_type == PT_LOAD) {
+        ElfAddr segStart = ph->p_vaddr + mLoadBias;
+        void *startPage = reinterpret_cast<void *>(roundDownToAlign(segStart));
+        ElfAddr phOffsetPage = roundDownToAlign(ph->p_offset);
+        void *binaryStartPage =
+            reinterpret_cast<void *>(mBinary.data + phOffsetPage);
+        size_t segmentLen = ph->p_filesz;
+
+        LOGV("Mapping start page %p from %p with length %zu", startPage,
+             binaryStartPage, segmentLen);
+        memcpy(startPage, binaryStartPage, segmentLen);
+        mapBss(ph);
+      } else {
+        LOGE("Non-load segment found between load segments");
+        success = false;
+        break;
+      }
+    }
+  }
+
+  return success;
+}
+
+const char *NanoappLoader::getDataName(size_t posInSymbolTable) {
+  size_t sectionSize = getDynamicSymbolTableSize();
+  uint8_t *dynamicSymbolTable = getDynamicSymbolTable();
+  size_t numElements = sectionSize / sizeof(ElfSym);
+  CHRE_ASSERT(posInSymbolTable < numElements);
+  char *dataName = nullptr;
+  if (posInSymbolTable < numElements) {
+    ElfSym *sym = reinterpret_cast<ElfSym *>(
+        &dynamicSymbolTable[posInSymbolTable * sizeof(ElfSym)]);
+    dataName = &getDynamicStringTable()[sym->st_name];
+  }
+  return dataName;
+}
+
+void *NanoappLoader::resolveData(size_t posInSymbolTable) {
+  const char *dataName = getDataName(posInSymbolTable);
+
+  if (dataName != nullptr) {
+    LOGV("Resolving %s", dataName);
+    return findExportedSymbol(dataName);
+  }
+
+  return nullptr;
+}
+
+NanoappLoader::DynamicHeader *NanoappLoader::getDynamicHeader() {
+  DynamicHeader *dyn = nullptr;
+  ProgramHeader *programHeaders = getProgramHeaderArray();
+  for (size_t i = 0; i < getProgramHeaderArraySize(); ++i) {
+    if (programHeaders[i].p_type == PT_DYNAMIC) {
+      dyn = reinterpret_cast<DynamicHeader *>(programHeaders[i].p_vaddr +
+                                              mLoadBias);
+      break;
+    }
+  }
+  return dyn;
+}
+
+NanoappLoader::ProgramHeader *NanoappLoader::getFirstRoSegHeader() {
+  // return the first read only segment found
+  ProgramHeader *ro = nullptr;
+  ProgramHeader *programHeaders = getProgramHeaderArray();
+  for (size_t i = 0; i < getProgramHeaderArraySize(); ++i) {
+    if (!(programHeaders[i].p_flags & PF_W)) {
+      ro = &programHeaders[i];
+      break;
+    }
+  }
+  return ro;
+}
+
+NanoappLoader::ElfWord NanoappLoader::getDynEntry(DynamicHeader *dyn,
+                                                  int field) {
+  ElfWord rv = 0;
+
+  while (dyn->d_tag != DT_NULL) {
+    if (dyn->d_tag == field) {
+      rv = dyn->d_un.d_val;
+      break;
+    }
+    ++dyn;
+  }
+
+  return rv;
+}
+
+bool NanoappLoader::fixRelocations() {
+  ElfAddr *addr;
+  DynamicHeader *dyn = getDynamicHeader();
+  ProgramHeader *roSeg = getFirstRoSegHeader();
+
+  bool success = false;
+  if ((dyn == nullptr) || (roSeg == nullptr)) {
+    LOGE("Mandatory headers missing from shared object, aborting load");
+  } else if (getDynEntry(dyn, DT_RELA) != 0) {
+    LOGE("Elf binaries with a DT_RELA dynamic entry are unsupported");
+  } else {
+    ElfRel *reloc =
+        reinterpret_cast<ElfRel *>(getDynEntry(dyn, DT_REL) + mBinary.data);
+    size_t relocSize = getDynEntry(dyn, DT_RELSZ);
+    size_t nRelocs = relocSize / sizeof(ElfRel);
+    LOGV("Relocation %zu entries in DT_REL table", nRelocs);
+
+    size_t i;
+    for (i = 0; i < nRelocs; ++i) {
+      ElfRel *curr = &reloc[i];
+      int relocType = ELFW_R_TYPE(curr->r_info);
+      switch (relocType) {
+        case R_ARM_RELATIVE:
+          LOGV("Resolving ARM_RELATIVE at offset %" PRIx32, curr->r_offset);
+          addr = reinterpret_cast<ElfAddr *>(curr->r_offset + mMapping.data);
+          // TODO: When we move to DRAM allocations, we need to check if the
+          // above address is in a Read-Only section of memory, and give it
+          // temporary write permission if that is the case.
+          *addr += mMapping.data;
+          break;
+
+        case R_ARM_ABS32:
+        case R_ARM_GLOB_DAT: {
+          LOGV("Resolving type %d at offset %" PRIx32, relocType,
+               curr->r_offset);
+          addr = reinterpret_cast<ElfAddr *>(curr->r_offset + mMapping.data);
+          size_t posInSymbolTable = ELFW_R_SYM(curr->r_info);
+          void *resolved = resolveData(posInSymbolTable);
+          if (resolved == nullptr) {
+            LOGV("Failed to resolve global symbol(%d) at offset 0x%x", i,
+                 curr->r_offset);
+            return false;
+          }
+          // TODO: When we move to DRAM allocations, we need to check if the
+          // above address is in a Read-Only section of memory, and give it
+          // temporary write permission if that is the case.
+          *addr = reinterpret_cast<ElfAddr>(resolved);
+          break;
+        }
+
+        case R_ARM_COPY:
+          LOGE("R_ARM_COPY is an invalid relocation for shared libraries");
+          break;
+        default:
+          LOGE("Invalid relocation type %u", relocType);
+          break;
+      }
+    }
+
+    if (i != nRelocs) {
+      LOGE("Unable to resolve all symbols in the binary");
+    } else {
+      success = true;
+    }
+  }
+
+  return success;
+}
+
+bool NanoappLoader::resolveGot() {
+  ElfAddr *addr;
+  ElfRel *reloc = reinterpret_cast<ElfRel *>(
+      getDynEntry(getDynamicHeader(), DT_JMPREL) + mMapping.data);
+  size_t relocSize = getDynEntry(getDynamicHeader(), DT_PLTRELSZ);
+  size_t nRelocs = relocSize / sizeof(ElfRel);
+  LOGV("Resolving GOT with %zu relocations", nRelocs);
+
+  for (size_t i = 0; i < nRelocs; ++i) {
+    ElfRel *curr = &reloc[i];
+    int relocType = ELFW_R_TYPE(curr->r_info);
+
+    switch (relocType) {
+      case R_ARM_JUMP_SLOT: {
+        LOGV("Resolving ARM_JUMP_SLOT at offset %" PRIx32, curr->r_offset);
+        addr = reinterpret_cast<ElfAddr *>(curr->r_offset + mMapping.data);
+        size_t posInSymbolTable = ELFW_R_SYM(curr->r_info);
+        void *resolved = resolveData(posInSymbolTable);
+        if (resolved == nullptr) {
+          LOGV("Failed to resolve symbol(%d) at offset 0x%x", i,
+               curr->r_offset);
+          return false;
+        }
+        *addr = reinterpret_cast<ElfAddr>(resolved);
+        break;
+      }
+
+      default:
+        LOGE("Unsupported relocation type: %u for symbol %s", relocType,
+             getDataName(ELFW_R_SYM(curr->r_info)));
+        return false;
+    }
+  }
+  return true;
+}
+
+void NanoappLoader::callAtexitFunctions() {
+  while (!mAtexitFunctions.empty()) {
+    LOGV("Calling atexit at %p", mAtexitFunctions.back());
+    mAtexitFunctions.back()();
+    mAtexitFunctions.pop_back();
+  }
+}
+
+void NanoappLoader::callTerminatorArray() {
+  for (size_t i = 0; i < mNumSectionHeaders; ++i) {
+    const char *name = getSectionHeaderName(mSectionHeadersPtr[i].sh_name);
+    if (strncmp(name, kFiniArrayName, strlen(kFiniArrayName)) == 0) {
+      uintptr_t finiArray = reinterpret_cast<uintptr_t>(
+          mLoadBias + mSectionHeadersPtr[i].sh_addr);
+      uintptr_t offset = 0;
+      while (offset < mSectionHeadersPtr[i].sh_size) {
+        ElfAddr *funcPtr = reinterpret_cast<ElfAddr *>(finiArray + offset);
+        uintptr_t finiFunction = reinterpret_cast<uintptr_t>(*funcPtr);
+        ((void (*)())finiFunction)();
+        offset += sizeof(finiFunction);
+      }
+      break;
+    }
+  }
+}
+
+}  // namespace chre
diff --git a/platform/slpi/host_link.cc b/platform/slpi/host_link.cc
index 990f02d..ed2f6b8 100644
--- a/platform/slpi/host_link.cc
+++ b/platform/slpi/host_link.cc
@@ -514,6 +514,7 @@
  * @param transactionId the ID of the transaction
  * @param appId the ID of the app to load
  * @param appVersion the version of the app to load
+ * @param appFlags The flags provided by the app being loaded
  * @param targetApiVersion the API version this nanoapp is targeted for
  * @param buffer the nanoapp binary data. May be only part of the nanoapp's
  *     binary if it's being sent over multiple fragments
@@ -524,20 +525,23 @@
  * @return A valid pointer to a nanoapp that can be loaded into the system. A
  *     nullptr if the preparation process fails.
  */
-UniquePtr<Nanoapp> handleLoadNanoappData(
-    uint16_t hostClientId, uint32_t transactionId, uint64_t appId,
-    uint32_t appVersion, uint32_t targetApiVersion, const void *buffer,
-    size_t bufferLen, uint32_t fragmentId, size_t appBinaryLen) {
+UniquePtr<Nanoapp> handleLoadNanoappData(uint16_t hostClientId,
+                                         uint32_t transactionId, uint64_t appId,
+                                         uint32_t appVersion, uint32_t appFlags,
+                                         uint32_t targetApiVersion,
+                                         const void *buffer, size_t bufferLen,
+                                         uint32_t fragmentId,
+                                         size_t appBinaryLen) {
   static NanoappLoadManager sLoadManager;
 
   bool success = true;
   if (fragmentId == 0 || fragmentId == 1) {  // first fragment
     size_t totalAppBinaryLen = (fragmentId == 0) ? bufferLen : appBinaryLen;
     LOGD("Load nanoapp request for app ID 0x%016" PRIx64 " ver 0x%" PRIx32
-         " target API 0x%08" PRIx32 " size %zu (txnId %" PRIu32
-         " client %" PRIu16 ")",
-         appId, appVersion, targetApiVersion, totalAppBinaryLen, transactionId,
-         hostClientId);
+         " flags 0x%" PRIx32 " target API 0x%08" PRIx32
+         " size %zu (txnId %" PRIu32 " client %" PRIu16 ")",
+         appId, appVersion, appFlags, targetApiVersion, totalAppBinaryLen,
+         transactionId, hostClientId);
 
     if (sLoadManager.hasPendingLoadTransaction()) {
       FragmentedLoadInfo info = sLoadManager.getTransactionInfo();
@@ -546,8 +550,9 @@
       sLoadManager.markFailure();
     }
 
-    success = sLoadManager.prepareForLoad(hostClientId, transactionId, appId,
-                                          appVersion, totalAppBinaryLen);
+    success =
+        sLoadManager.prepareForLoad(hostClientId, transactionId, appId,
+                                    appVersion, appFlags, totalAppBinaryLen);
   }
   success &= sLoadManager.copyNanoappFragment(
       hostClientId, transactionId, (fragmentId == 0) ? 1 : fragmentId, buffer,
@@ -844,18 +849,18 @@
 
 void HostMessageHandlers::handleLoadNanoappRequest(
     uint16_t hostClientId, uint32_t transactionId, uint64_t appId,
-    uint32_t appVersion, uint32_t targetApiVersion, const void *buffer,
-    size_t bufferLen, const char *appFileName, uint32_t fragmentId,
-    size_t appBinaryLen) {
+    uint32_t appVersion, uint32_t appFlags, uint32_t targetApiVersion,
+    const void *buffer, size_t bufferLen, const char *appFileName,
+    uint32_t fragmentId, size_t appBinaryLen) {
   UniquePtr<Nanoapp> pendingNanoapp;
   if (appFileName != nullptr) {
     pendingNanoapp =
         handleLoadNanoappFile(hostClientId, transactionId, appId, appVersion,
                               targetApiVersion, appFileName);
   } else {
-    pendingNanoapp = handleLoadNanoappData(hostClientId, transactionId, appId,
-                                           appVersion, targetApiVersion, buffer,
-                                           bufferLen, fragmentId, appBinaryLen);
+    pendingNanoapp = handleLoadNanoappData(
+        hostClientId, transactionId, appId, appVersion, appFlags,
+        targetApiVersion, buffer, bufferLen, fragmentId, appBinaryLen);
   }
 
   if (!pendingNanoapp.isNull()) {
diff --git a/platform/slpi/include/chre/target_platform/platform_nanoapp_base.h b/platform/slpi/include/chre/target_platform/platform_nanoapp_base.h
index 72aeb61..0dab266 100644
--- a/platform/slpi/include/chre/target_platform/platform_nanoapp_base.h
+++ b/platform/slpi/include/chre/target_platform/platform_nanoapp_base.h
@@ -48,11 +48,13 @@
    *
    * @param appId The unique app identifier associated with this binary
    * @param appVersion An application-defined version number
+   * @param appFlags The flags provided by the app being loaded
    * @param appBinaryLen Size of appBinary, in bytes
    *
    * @return true if the allocation was successful, false otherwise
    */
-  bool reserveBuffer(uint64_t appId, uint32_t appVersion, size_t appBinarylen);
+  bool reserveBuffer(uint64_t appId, uint32_t appVersion, uint32_t appFlags,
+                     size_t appBinarylen);
 
   /**
    * Copies the (possibly fragmented) application binary data into the allocated
diff --git a/platform/slpi/platform_nanoapp.cc b/platform/slpi/platform_nanoapp.cc
index 10d68f1..3ac54df 100644
--- a/platform/slpi/platform_nanoapp.cc
+++ b/platform/slpi/platform_nanoapp.cc
@@ -207,6 +207,7 @@
 }
 
 bool PlatformNanoappBase::reserveBuffer(uint64_t appId, uint32_t appVersion,
+                                        uint32_t /* appFlags */,
                                         size_t appBinaryLen) {
   CHRE_ASSERT(!isLoaded());
   bool success = false;
diff --git a/platform/usf/include/chre/platform/usf/usf_helper.h b/platform/usf/include/chre/platform/usf/usf_helper.h
new file mode 100644
index 0000000..98fa6a2
--- /dev/null
+++ b/platform/usf/include/chre/platform/usf/usf_helper.h
@@ -0,0 +1,368 @@
+/*
+ * Copyright (C) 2020 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 CHRE_PLATFORM_USF_USF_HELPER_H_
+#define CHRE_PLATFORM_USF_USF_HELPER_H_
+
+#include "chre/core/sensor_type.h"
+#include "chre/platform/system_time.h"
+#include "chre/util/dynamic_vector.h"
+#include "chre/util/unique_ptr.h"
+
+/*
+ * Include USF FlatBuffers services header before including other USF
+ * FlatBuffers headers.
+ */
+#include "usf/usf_flatbuffers.h"
+
+#include "usf/error.h"
+#include "usf/fbs/usf_msg_sample_root_generated.h"
+#include "usf/reffed_ptr.h"
+#include "usf/usf_power.h"
+#include "usf/usf_sensor.h"
+#include "usf/usf_sensor_report.h"
+#include "usf/usf_sensor_req.h"
+#include "usf/usf_transport_client.h"
+
+namespace chre {
+
+struct SensorInfo {
+  //! Used to fill in the chreSensorDataHeader field. If the user of the helper
+  //! doesn't care about this field, then it can be set to 0.
+  uint32_t sensorHandle;
+
+  //! Sampling ID corresponding to the active subscription to this sensor, if
+  //! one exists. 0 otherwise.
+  uint32_t samplingId;
+};
+
+//! A callback interface for receiving UsfHelper data events and to allow the
+//! UsfHelper to ask for information.
+class UsfHelperCallbackInterface {
+ public:
+  //! Invoked from the USF worker thread to provide sensor data events. The
+  //! event data format is one of the chreSensorXXXData defined in the CHRE API,
+  //! implicitly specified by sensorType.
+  virtual void onSensorDataEvent(uint8_t sensorType,
+                                 UniquePtr<uint8_t> &&eventData) = 0;
+
+  /**
+   * Invoked by the USF Helper to obtain sensor info for a given sensor type.
+   *
+   * @param sensorType The sensor type for which info should be populated
+   * @param sensorInfo Non-null pointer that will be populated with sensor info
+   *     if this method is successful
+   * @return true if all sensor info was obtained.
+   */
+  virtual bool getSensorInfo(uint8_t sensorType, SensorInfo *sensorInfo) = 0;
+
+  //! Invoked from the USF worker thread to provide a sensor sampling status
+  //! update. All fields are guaranteed to be valid.
+  virtual void onSamplingStatusUpdate(
+      uint8_t sensorType, const usf::UsfSensorSamplingEvent *update) = 0;
+
+  //! Invoked from the USF worker thread to indicate that flushing the given
+  //! sensor has completed.
+  virtual void onFlushComplete(usf::UsfErr err, uint32_t requestId,
+                               void *cookie) = 0;
+
+  //! Invoked from the USF worker thread to provide a bias update.
+  virtual void onBiasUpdate(
+      uint8_t sensorType,
+      UniquePtr<struct chreSensorThreeAxisData> &&eventData) = 0;
+
+  //! Invoked from the USF worker thread to provide an host wake suspend update.
+  virtual void onHostWakeSuspendEvent(bool awake) = 0;
+};
+
+//! Class that allows clients of UsfHelper that only want to listen for sensor
+//! events to implement only functions that relate to those events.
+class SensorEventCallbackInterface : public UsfHelperCallbackInterface {
+ public:
+  void onSamplingStatusUpdate(
+      uint8_t /*sensorType*/,
+      const usf::UsfSensorSamplingEvent * /*update*/) override {}
+
+  void onFlushComplete(usf::UsfErr /*err*/, uint32_t /*requestId*/,
+                       void * /*cookie*/) override {}
+
+  void onBiasUpdate(
+      uint8_t /*sensorType*/,
+      UniquePtr<struct chreSensorThreeAxisData> && /*eventData*/) override {}
+
+  void onHostWakeSuspendEvent(bool /*awake*/) override {}
+};
+
+//! Default timeout to wait for the USF transport client to return a response
+//! to a request
+constexpr Nanoseconds kDefaultUsfWaitTimeout = Seconds(5);
+
+/**
+ * Helper class used to abstract away most details of communicating with USF.
+ */
+class UsfHelper {
+ public:
+  ~UsfHelper();
+
+  //! Maps USF error codes to CHRE error codes.
+  static uint8_t usfErrorToChreError(usf::UsfErr err);
+
+  /**
+   * Initializes connection to USF.
+   *
+   * @param callback USF helper callback.
+   * @param worker USF worker pointer. If null, a new worker is created.
+   */
+  void init(UsfHelperCallbackInterface *callback,
+            usf::UsfWorker *worker = nullptr);
+
+  /**
+   * Retrieves the list of sensors available from USF.
+   *
+   * @param sensorList Non-null pointer to a UsfVector that will be populated
+   *     with all the available sensors from USF.
+   * @return true if the list of sensors was retrieved successfully.
+   */
+  bool getSensorList(
+      usf::UsfVector<refcount::reffed_ptr<usf::UsfSensor>> *sensorList);
+
+  /**
+   * Starts sampling sensor data from the given sensor.
+   *
+   * @param request The various parameters needed to issue the request to the
+   *     sensor.
+   * @param samplingId Non-null pointer that will be filled in with a valid
+   *     sampling ID if the request is issued successfully.
+   * @return true if the sensor request was issued successfully.
+   */
+  bool startSampling(usf::UsfStartSamplingReq *request, uint32_t *samplingId);
+
+  /**
+   * Reconfigures an existing sensor request.
+   *
+   * @param request The various parameters needed to issue the request to the
+   *     sensor.
+   * @return true if the sensor request was reconfigured successfully.
+   */
+  bool reconfigureSampling(usf::UsfReconfigSamplingReq *request);
+
+  /**
+   * Stops an active sensor request.
+   *
+   * @param request The various parameters needed to issue the request to the
+   *     sensor.
+   * @return true if the sensor request was stopped successfully.
+   */
+  bool stopSampling(usf::UsfStopSamplingReq *request);
+
+  /**
+   * Registers the helper for sensor sampling status updates from USF for the
+   * given sensor.
+   *
+   * @param sensor The sensor to listen to sampling status updates from.
+   * @return true if registration was successful.
+   */
+  bool registerForStatusUpdates(refcount::reffed_ptr<usf::UsfSensor> &sensor);
+
+  /**
+   * Registers the helper for bias updates from USF for the given sensor.
+   * This method is not idempotent meaning a call to unregisterForBiasUpdates
+   * must be made for the same sensor prior to another call to this method.
+   *
+   * @param sensor A non-null reffed_ptr to the sensor to listen for bias
+   *     updates from.
+   * @return true if registration was successful.
+   */
+  bool registerForBiasUpdates(
+      const refcount::reffed_ptr<usf::UsfSensor> &sensor);
+
+  /**
+   * Registers the helper for AP power state update from USF.
+   *
+   * @return true if successful.
+   */
+  bool registerForApPowerStateUpdates();
+
+  /**
+   * Unregisters the helper from bias updates from USF for the given sensor.
+   * If not registered, this method is a no-op.
+   *
+   * @param sensor A non-null reffed_ptr to the sensor to stop listening to bias
+   *     updates from.
+   */
+  void unregisterForBiasUpdates(
+      const refcount::reffed_ptr<usf::UsfSensor> &sensor);
+
+  /**
+   * Obtains the latest three axis bias received from the given sensor, if
+   * available.
+   *
+   * @param sensor The USF sensor to obtain the latest bias values from.
+   * @param bias A non-null pointer that will be filled with the latest bias
+   *     values if available.
+   * @return true if a bias value was available for the given sensor.
+   */
+  bool getThreeAxisBias(const refcount::reffed_ptr<usf::UsfSensor> &sensor,
+                        struct chreSensorThreeAxisData *bias) const;
+
+  /**
+   * Flushes sensor data from the provided sensor asynchronously. Once all data
+   * has been flushed, {@link #onFlushCompleteEvent} will be invoked on the
+   * callback the helper was initialized with.
+   *
+   * @param usfSensorHandle The USF handle corresponding to the sensor to flush
+   * @param cookie A cookie that will be delivered when the flush has completed
+   * @param requestId The ID associated with this flush request, if it was
+   *     made successfully
+   * @return True if the flush request was successfully sent.
+   */
+  bool flushAsync(const usf::UsfServerHandle usfSensorHandle, void *cookie,
+                  uint32_t *requestId);
+
+  /**
+   * Used to process sensor reports delivered through a listener registered with
+   * USF.
+   *
+   * @param event Pointer containing a valid sensor report
+   */
+  void processSensorReport(const usf::UsfMsgEvent *event);
+
+  /**
+   * Used to process a sensor sampling status update delivered through a
+   * listener registered with USF.
+   *
+   * @param update Update containing the latest state from USF.
+   */
+  void processStatusUpdate(const usf::UsfSensorSamplingEvent *update);
+
+  /**
+   * Process the bias update delivered through a listener registered with USF.
+   *
+   * @param update Update containing latest bias information for a sensor.
+   */
+  void processBiasUpdate(const usf::UsfSensorTransformConfigEvent *update);
+
+  /**
+   * Process the AP power state update delivered through a  listener registered
+   * with USF.
+   *
+   * @param update Update containing the current AP power state.
+   */
+  void processApPowerStateUpdate(const usf::UsfApPowerStateEvent *update);
+
+ private:
+  /**
+   * Sends a synchronous request to USF with any returned data stored in the
+   * given callback.
+   *
+   * @param req Request that should be issued to USF
+   * @param callback Helper callback function used to perform the synchronous
+   *     request and contains any response message after the method returns
+   * @return true if no errors were encountered issuing the request
+   */
+  bool sendUsfReqSync(usf::UsfReq *req, usf::UsfReqSyncCallback *callback);
+
+  /**
+   * Retrieves the response message from the synchronous callback. The memory
+   * associated with the message is owned by the callback itself and will be
+   * freed upon callback going out of scope.
+   *
+   * @param callback Synchronous callback previously used in a successful
+   *     sendUsfReqSync invocation
+   * @param respMsg Variable containing the response message if this method
+   *     succeeds
+   * @return true if the response message was decoded and verified successfully
+   *     and respMsg is valid.
+   */
+  template <class T>
+  bool getRespMsg(usf::UsfReqSyncCallback &callback, const T **respMsg);
+
+  /**
+   * Creates a CHRE sensor event from a USF sensor event
+   *
+   * @param sampleReport Valid decoded USF sensor sample report
+   * @param sensorType CHRE sensor type corresponding to the event
+   * @param sensorSample Upon success, populated with a valid CHRE sensor event
+   * @return true if the USF sensor event corresponds to a valid, active
+   *     sampling request and event creation was successful
+   */
+  bool createSensorEvent(const usf::UsfSensorSampleReport *sampleReport,
+                         uint8_t sensorType, UniquePtr<uint8_t> &sensorSample);
+
+  /**
+   * Converts a USF bias update event into the chreSensorThreeAxisData format.
+   *
+   * @param update USF bias update that needs to be converted.
+   * @return If successful, contains a populated UniquePtr. Otherwise, the
+   *     UniquePtr will be set to nullptr.
+   */
+  UniquePtr<struct chreSensorThreeAxisData> convertUsfBiasUpdateToData(
+      const usf::UsfSensorTransformConfigEvent *update);
+
+  /**
+   * Get the index into the calibrated sensor data array for the given sensor
+   * type.
+   *
+   * @param usfSensorType The USF sensor type to obtain the index for.
+   * @return The index into the data array for the given sensor type. If the
+   *     sensor type isn't present in the array, kNumUsfCalSensors is returned.
+   */
+  static size_t getCalArrayIndex(const usf::UsfSensorType usfSensorType);
+
+  //! A struct to store a sensor's calibration data.
+  struct UsfCalData {
+    uint64_t timestamp;
+    float bias[3];
+    bool hasBias;
+    uint8_t accuracy;
+  };
+
+  //! The list of calibrated USF sensors supported.
+  enum class UsfCalSensor : size_t {
+    AccelCal,
+    GyroCal,
+    MagCal,
+    NumCalSensors,
+  };
+
+  static constexpr size_t kNumUsfCalSensors =
+      static_cast<size_t>(UsfCalSensor::NumCalSensors);
+
+  //! Cal data of all the cal sensors.
+  UsfCalData mCalData[kNumUsfCalSensors] = {};
+
+  //! Client used to send messages to USF
+  refcount::reffed_ptr<usf::UsfTransportClient> mTransportClient;
+
+  //! UsfWorker used to dispatch messages to CHRE on its own thread
+  refcount::reffed_ptr<usf::UsfWorker> mWorker;
+
+  //! All registered USF event listeners.
+  DynamicVector<usf::UsfEventListener *> mUsfEventListeners;
+
+  //! Handle to the USF sensor manager
+  usf::UsfServerHandle mSensorMgrHandle;
+
+  //! Currently registered callback
+  UsfHelperCallbackInterface *mCallback = nullptr;
+
+  //! The error encountered during initialization, if any.
+  usf::UsfErr mInitError = usf::UsfErr::kErrNone;
+};
+
+}  // namespace chre
+
+#endif  // CHRE_PLATFORM_USF_USF_HELPER_H_
diff --git a/platform/usf/include/chre/target_platform/platform_sensor_base.h b/platform/usf/include/chre/target_platform/platform_sensor_base.h
new file mode 100644
index 0000000..a209d36
--- /dev/null
+++ b/platform/usf/include/chre/target_platform/platform_sensor_base.h
@@ -0,0 +1,77 @@
+/*
+ * Copyright (C) 2020 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 CHRE_PLATFORM_USF_PLATFORM_SENSOR_BASE_H_
+#define CHRE_PLATFORM_USF_PLATFORM_SENSOR_BASE_H_
+
+#include "chre/util/optional.h"
+
+#include "usf/usf.h"
+#include "usf/usf_sensor.h"
+
+namespace chre {
+
+//! The max length of sensorName
+constexpr size_t kSensorNameMaxLen = 64;
+
+class PlatformSensorBase {
+ public:
+  /**
+   * Initializes various members of PlatformSensorBase.
+   */
+  void initBase(refcount::reffed_ptr<usf::UsfSensor> &usfSensor,
+                uint8_t sensorType);
+
+  usf::UsfServerHandle getServerHandle() const {
+    return mUsfSensor->GetHandle();
+  }
+
+  bool isSamplingIdValid() const {
+    return mSamplingId.has_value();
+  }
+
+  void setSamplingIdInvalid() {
+    mSamplingId.reset();
+  }
+
+  void setSamplingId(uint32_t samplingId) {
+    mSamplingId = samplingId;
+  }
+
+  uint32_t getSamplingId() const {
+    return mSamplingId.value();
+  }
+
+  const refcount::reffed_ptr<usf::UsfSensor> &getUsfSensor() const {
+    return mUsfSensor;
+  }
+
+ protected:
+  //! The USF sensor instance for this sensor.
+  refcount::reffed_ptr<usf::UsfSensor> mUsfSensor;
+
+  //! The sampling ID of the active request with this sensor.
+  Optional<uint32_t> mSamplingId;
+
+  //! Sensor type of this sensor. Needed because USF shares the same sensor
+  //! type for two different CHRE sensors (ACCELEROMETER_TEMPERATURE and
+  //! GYROSCOPE_TEMPERATURE).
+  uint8_t mSensorType;
+};
+
+}  // namespace chre
+
+#endif  // CHRE_PLATFORM_USF_PLATFORM_SENSOR_BASE_H_
diff --git a/platform/usf/include/chre/target_platform/platform_sensor_manager_base.h b/platform/usf/include/chre/target_platform/platform_sensor_manager_base.h
new file mode 100644
index 0000000..24b882a
--- /dev/null
+++ b/platform/usf/include/chre/target_platform/platform_sensor_manager_base.h
@@ -0,0 +1,61 @@
+/*
+ * Copyright (C) 2020 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 CHRE_PLATFORM_USF_PLATFORM_SENSOR_MANAGER_BASE_H_
+#define CHRE_PLATFORM_USF_PLATFORM_SENSOR_MANAGER_BASE_H_
+
+#include "chre/platform/usf/usf_helper.h"
+#include "chre/util/unique_ptr.h"
+
+namespace chre {
+
+class PlatformSensorManagerBase : public UsfHelperCallbackInterface {
+ public:
+  void onSensorDataEvent(uint8_t sensorType,
+                         UniquePtr<uint8_t> &&eventData) override;
+
+  void onSamplingStatusUpdate(
+      uint8_t sensorType, const usf::UsfSensorSamplingEvent *update) override;
+
+  bool getSensorInfo(uint8_t sensorType, SensorInfo *sensorInfo) override;
+
+  void onFlushComplete(usf::UsfErr err, uint32_t requestId,
+                       void *cookie) override;
+
+  void onBiasUpdate(
+      uint8_t sensorType,
+      UniquePtr<struct chreSensorThreeAxisData> &&eventData) override;
+
+  void onHostWakeSuspendEvent(bool awake) override;
+
+  /**
+   * Converts the given UsfSensor into one or more CHRE sensors and adds them
+   * to the given dynamic vector.
+   *
+   * @param usfSensor UsfSensor to be converted to one or more CHRE sensors
+   * @param chreSensors Dynamic vector that converted sensors must be added to
+   */
+  void addSensorsWithInfo(refcount::reffed_ptr<usf::UsfSensor> &usfSensor,
+                          DynamicVector<Sensor> *chreSensors);
+
+ protected:
+  //! Helper used to communicate with USF.
+  UsfHelper mHelper;
+};
+
+}  // namespace chre
+
+#endif  // CHRE_PLATFORM_USF_PLATFORM_SENSOR_MANAGER_BASE_H_
diff --git a/platform/usf/include/chre/target_platform/platform_sensor_type_helpers_base.h b/platform/usf/include/chre/target_platform/platform_sensor_type_helpers_base.h
new file mode 100644
index 0000000..b262994
--- /dev/null
+++ b/platform/usf/include/chre/target_platform/platform_sensor_type_helpers_base.h
@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 2020 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 CHRE_TARGET_PLATFORM_SENSOR_TYPE_HELPERS_BASE_H_
+#define CHRE_TARGET_PLATFORM_SENSOR_TYPE_HELPERS_BASE_H_
+
+#include "usf/usf_sensor_defs.h"
+
+namespace chre {
+
+/**
+ * This SensorSampleType is designed to help classify sensor's data type in
+ * event handling.
+ * TODO: This is a placeholder for AOC and not fully implemented
+ */
+enum class SensorSampleType {
+  Byte,
+  Float,
+  Occurrence,
+  ThreeAxis,
+  Unknown,
+};
+
+/**
+ * Can be used to expose static methods to the PlatformSensorTypeHelpers class
+ * for use in working with vendor sensor types. Currently, this is stubbed out
+ * in the AOC implementation.
+ */
+class PlatformSensorTypeHelpersBase {
+ public:
+  /**
+   * Maps a sensorType to its SensorSampleType.
+   *
+   * @param sensorType The type of the sensor to obtain its SensorSampleType
+   *     for.
+   * @return The SensorSampleType of the sensorType.
+   */
+  static SensorSampleType getSensorSampleTypeFromSensorType(uint8_t sensorType);
+
+  /**
+   * @return Whether the given sensor type reports bias events.
+   */
+  static bool reportsBias(uint8_t sensorType);
+
+  //! Helper functions used to convert between USF and CHRE types
+  static usf::UsfSensorReportingMode getUsfReportingMode(ReportingMode mode);
+  static bool convertUsfToChreSensorType(usf::UsfSensorType usfSensorType,
+                                         uint8_t *chreSensorType);
+  static uint8_t convertUsfToChreSampleAccuracy(
+      usf::UsfSampleAccuracy usfSampleAccuracy);
+};
+
+}  // namespace chre
+
+#endif  // CHRE_TARGET_PLATFORM_SENSOR_TYPE_HELPERS_BASE_H_
diff --git a/platform/usf/platform_sensor.cc b/platform/usf/platform_sensor.cc
new file mode 100644
index 0000000..e4a310c
--- /dev/null
+++ b/platform/usf/platform_sensor.cc
@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) 2020 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 "chre/platform/platform_sensor.h"
+
+#include "chre/core/sensor_type_helpers.h"
+
+namespace chre {
+
+void PlatformSensorBase::initBase(
+    refcount::reffed_ptr<usf::UsfSensor> &usfSensor, uint8_t sensorType) {
+  mUsfSensor = usfSensor;
+  mSensorType = sensorType;
+}
+
+uint8_t PlatformSensor::getSensorType() const {
+  return mSensorType;
+}
+
+uint64_t PlatformSensor::getMinInterval() const {
+  return SensorTypeHelpers::isOneShot(mSensorType)
+             ? CHRE_SENSOR_INTERVAL_DEFAULT
+             : mUsfSensor->GetMinDelayNs();
+  ;
+}
+
+bool PlatformSensor::reportsBiasEvents() const {
+  return PlatformSensorTypeHelpersBase::reportsBias(getSensorType());
+}
+
+bool PlatformSensor::supportsPassiveMode() const {
+  return true;
+}
+
+const char *PlatformSensor::getSensorName() const {
+  return SensorTypeHelpers::getSensorTypeName(getSensorType());
+}
+
+PlatformSensor::PlatformSensor(PlatformSensor &&other) {
+  *this = std::move(other);
+}
+
+PlatformSensor &PlatformSensor::operator=(PlatformSensor &&other) {
+  // Note: if this implementation is ever changed to depend on "this" containing
+  // initialized values, the move constructor implementation must be updated.
+  mUsfSensor = other.mUsfSensor;
+  mSensorType = other.mSensorType;
+
+  return *this;
+}
+
+}  // namespace chre
diff --git a/platform/usf/platform_sensor_manager.cc b/platform/usf/platform_sensor_manager.cc
new file mode 100644
index 0000000..1b35b39
--- /dev/null
+++ b/platform/usf/platform_sensor_manager.cc
@@ -0,0 +1,323 @@
+/*
+ * Copyright (C) 2020 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 "chre/platform/platform_sensor_manager.h"
+
+#include "chre/core/event_loop_manager.h"
+#include "chre/util/nested_data_ptr.h"
+
+namespace chre {
+namespace {
+
+void addSensor(refcount::reffed_ptr<usf::UsfSensor> &usfSensor,
+               uint8_t sensorType, DynamicVector<Sensor> *chreSensors) {
+  if (!chreSensors->emplace_back()) {
+    FATAL_ERROR("Failed to allocate new sensor");
+  }
+
+  // The sensor base class must be initialized before the main Sensor init()
+  // can be invoked as init() is allowed to invoke base class methods.
+  chreSensors->back().initBase(usfSensor, sensorType);
+  chreSensors->back().init();
+
+  const Sensor &newSensor = chreSensors->back();
+  LOGI("%s, type %" PRIu8 ", minInterval %" PRIu64 " handle %" PRId32,
+       newSensor.getSensorName(), newSensor.getSensorType(),
+       newSensor.getMinInterval(), newSensor.getServerHandle());
+}
+
+ReportingMode getReportingMode(Sensor &sensor) {
+  if (sensor.isOneShot()) {
+    return ReportingMode::OneShot;
+  } else if (sensor.isOnChange()) {
+    return ReportingMode::OnChange;
+  } else {
+    return ReportingMode::Continuous;
+  }
+}
+
+void handleMissingSensor() {
+  // Try rebooting if a sensor is missing, which might help recover from a
+  // transient failure/race condition at startup. But to avoid endless crashes,
+  // only do this within 45 seconds of boot time - we rely on knowledge that
+  // getMonotonicTime() only resets when the device reboots and not from an SSR.
+#ifndef CHRE_LOG_ONLY_NO_SENSOR
+  if (SystemTime::getMonotonicTime() < (kDefaultUsfWaitTimeout + Seconds(15))) {
+    FATAL_ERROR("Missing required sensor(s)");
+  } else
+#endif
+  {
+    LOGE("Missing required sensor(s)");
+  }
+}
+
+}  // namespace
+
+PlatformSensorManager::~PlatformSensorManager() {}
+
+void PlatformSensorManager::init() {
+  mHelper.init(this);
+  if (!mHelper.registerForApPowerStateUpdates()) {
+    LOGE("Failed to register for AP power state updates.");
+  }
+}
+
+DynamicVector<Sensor> PlatformSensorManager::getSensors() {
+  DynamicVector<Sensor> sensors;
+
+  usf::UsfVector<refcount::reffed_ptr<usf::UsfSensor>> sensorList;
+  if (mHelper.getSensorList(&sensorList)) {
+    for (size_t i = 0; i < sensorList.size(); i++) {
+      refcount::reffed_ptr<usf::UsfSensor> &sensor = sensorList[i];
+      addSensorsWithInfo(sensor, &sensors);
+    }
+  }
+
+  // TODO: Determine how many sensors are expected to be available through USF.
+  if (sensors.empty()) {
+    handleMissingSensor();
+  }
+
+  return sensors;
+}
+
+bool PlatformSensorManager::configureSensor(Sensor &sensor,
+                                            const SensorRequest &request) {
+  bool success = false;
+
+  if (request.getMode() == SensorMode::Off && !sensor.isSamplingIdValid()) {
+    // If no existing sampling ID exists and the sensor should be turned off,
+    // return true. This can happen when the core platform tries to remove a
+    // request for a one-shot sensor after it fires which automatically happens
+    // inside USF.
+    success = true;
+  } else if (request.getMode() == SensorMode::Off) {
+    usf::UsfStopSamplingReq usfReq;
+    usfReq.SetReqType(usf::UsfMsgReqType_STOP_SAMPLING);
+    usfReq.SetServerHandle(sensor.getServerHandle());
+    usfReq.SetSamplingId(sensor.getSamplingId());
+
+    if (mHelper.stopSampling(&usfReq)) {
+      sensor.setSamplingIdInvalid();
+      success = true;
+    }
+  } else if (sensor.isSamplingIdValid()) {
+    // TODO: See if a reconfigure request can be the same as reissuing a start
+    // request.
+    usf::UsfReconfigSamplingReq usfReq;
+    usfReq.SetReqType(usf::UsfMsgReqType_RECONFIG_SAMPLING);
+    usfReq.SetServerHandle(sensor.getServerHandle());
+    usfReq.SetSamplingId(sensor.getSamplingId());
+    usfReq.SetPeriodNs(request.getInterval().toRawNanoseconds());
+    usfReq.SetMaxLatencyNs(
+        sensor.isContinuous() ? request.getLatency().toRawNanoseconds() : 0);
+
+    success = mHelper.reconfigureSampling(&usfReq);
+  } else {
+    usf::UsfStartSamplingReq usfReq;
+    usfReq.SetReqType(usf::UsfMsgReqType_START_SAMPLING);
+    usfReq.SetServerHandle(sensor.getServerHandle());
+    // TODO(147438885): Make setting the reporting mode of a sensor optional
+    usfReq.SetReportingMode(PlatformSensorTypeHelpersBase::getUsfReportingMode(
+        getReportingMode(sensor)));
+    usfReq.SetPeriodNs(request.getInterval().toRawNanoseconds());
+    usfReq.SetMaxLatencyNs(
+        sensor.isContinuous() ? request.getLatency().toRawNanoseconds() : 0);
+    usfReq.SetPassive(sensorModeIsPassive(request.getMode()));
+    usf::UsfSensorTransformLevel transformLevel =
+        sensor.isCalibrated() ? usf::kUsfSensorTransformLevelAll
+                              : usf::kUsfSensorTransformEnvCompensation;
+    usfReq.SetTransformLevel(transformLevel);
+
+    uint32_t samplingId;
+    if (mHelper.startSampling(&usfReq, &samplingId)) {
+      sensor.setSamplingId(samplingId);
+      success = true;
+    }
+  }
+
+  return success;
+}
+
+bool PlatformSensorManager::configureBiasEvents(const Sensor &sensor,
+                                                bool enable,
+                                                uint64_t /* latencyNs */) {
+  bool success = true;
+  if (enable) {
+    success = mHelper.registerForBiasUpdates(sensor.getUsfSensor());
+  } else {
+    // Unconditional success for unregistering
+    mHelper.unregisterForBiasUpdates(sensor.getUsfSensor());
+  }
+
+  return success;
+}
+
+bool PlatformSensorManager::getThreeAxisBias(
+    const Sensor &sensor, struct chreSensorThreeAxisData *bias) const {
+  bool success = sensor.reportsBiasEvents();
+  if (success) {
+    if (!mHelper.getThreeAxisBias(sensor.getUsfSensor(), bias)) {
+      // Set to zero bias + unknown accuracy per CHRE API requirements.
+      memset(bias, 0, sizeof(chreSensorThreeAxisData));
+      bias->header.readingCount = 1;
+      bias->header.accuracy = CHRE_SENSOR_ACCURACY_UNKNOWN;
+    }
+
+    // Overwrite sensorHandle to match the request type.
+    getSensorRequestManager().getSensorHandle(sensor.getSensorType(),
+                                              &bias->header.sensorHandle);
+  }
+  return success;
+}
+
+bool PlatformSensorManager::flush(const Sensor &sensor,
+                                  uint32_t *flushRequestId) {
+  NestedDataPtr<uint32_t> cookie(sensor.getSensorType());
+  return mHelper.flushAsync(sensor.getServerHandle(), cookie.dataPtr,
+                            flushRequestId);
+}
+
+void PlatformSensorManager::releaseSamplingStatusUpdate(
+    struct chreSensorSamplingStatus *status) {
+  memoryFree(status);
+}
+
+void PlatformSensorManager::releaseSensorDataEvent(void *data) {
+  memoryFree(data);
+}
+
+void PlatformSensorManager::releaseBiasEvent(void *biasData) {
+  memoryFree(biasData);
+}
+
+void PlatformSensorManagerBase::onSamplingStatusUpdate(
+    uint8_t sensorType, const usf::UsfSensorSamplingEvent *update) {
+  uint32_t sensorHandle;
+  if (getSensorRequestManager().getSensorHandle(sensorType, &sensorHandle)) {
+    // Memory will be freed via releaseSamplingStatusUpdate once core framework
+    // performs its updates.
+    auto statusUpdate = MakeUniqueZeroFill<struct chreSensorSamplingStatus>();
+    if (statusUpdate.isNull()) {
+      LOG_OOM();
+    } else {
+      statusUpdate->interval = update->GetPeriodNs();
+      statusUpdate->latency = update->GetMaxLatencyNs();
+      statusUpdate->enabled = update->GetActive();
+      getSensorRequestManager().handleSamplingStatusUpdate(
+          sensorHandle, statusUpdate.release());
+    }
+  }
+}
+
+bool PlatformSensorManagerBase::getSensorInfo(uint8_t sensorType,
+                                              SensorInfo *sensorInfo) {
+  bool success = false;
+
+  if (getSensorRequestManager().getSensorHandle(sensorType,
+                                                &sensorInfo->sensorHandle)) {
+    Sensor *sensor =
+        getSensorRequestManager().getSensor(sensorInfo->sensorHandle);
+    if (sensor != nullptr && sensor->isSamplingIdValid()) {
+      success = true;
+      sensorInfo->samplingId = sensor->getSamplingId();
+    } else {
+      sensorInfo->sensorHandle = 0;
+    }
+  }
+  return success;
+}
+
+void PlatformSensorManagerBase::onSensorDataEvent(
+    uint8_t sensorType, UniquePtr<uint8_t> &&eventData) {
+  uint32_t sensorHandle;
+  if (getSensorRequestManager().getSensorHandle(sensorType, &sensorHandle)) {
+    Sensor *sensor = getSensorRequestManager().getSensor(sensorHandle);
+    // Invalidate the sampling ID for one shot sensors after they've fired since
+    // USF automatically removes the sampling ID from its list.
+    if (sensor->isOneShot()) {
+      sensor->setSamplingIdInvalid();
+    }
+
+    getSensorRequestManager().handleSensorDataEvent(sensorHandle,
+                                                    eventData.release());
+  }
+}
+
+void PlatformSensorManagerBase::onFlushComplete(usf::UsfErr err,
+                                                uint32_t requestId,
+                                                void *cookie) {
+  NestedDataPtr<uint32_t> nestedSensorType;
+  nestedSensorType.dataPtr = cookie;
+
+  uint32_t sensorHandle;
+  if (getSensorRequestManager().getSensorHandle(nestedSensorType.data,
+                                                &sensorHandle)) {
+    getSensorRequestManager().handleFlushCompleteEvent(
+        sensorHandle, requestId, UsfHelper::usfErrorToChreError(err));
+  }
+}
+
+void PlatformSensorManagerBase::onBiasUpdate(
+    uint8_t sensorType, UniquePtr<struct chreSensorThreeAxisData> &&eventData) {
+  uint32_t sensorHandle;
+  if (getSensorRequestManager().getSensorHandle(sensorType, &sensorHandle)) {
+    eventData->header.sensorHandle = sensorHandle;
+    getSensorRequestManager().handleBiasEvent(sensorHandle,
+                                              eventData.release());
+  }
+}
+
+void PlatformSensorManagerBase::onHostWakeSuspendEvent(bool awake) {
+  EventLoopManagerSingleton::get()
+      ->getEventLoop()
+      .getPowerControlManager()
+      .onHostWakeSuspendEvent(awake);
+}
+
+void PlatformSensorManagerBase::addSensorsWithInfo(
+    refcount::reffed_ptr<usf::UsfSensor> &usfSensor,
+    DynamicVector<Sensor> *chreSensors) {
+  uint8_t sensorType;
+  if (PlatformSensorTypeHelpersBase::convertUsfToChreSensorType(
+          usfSensor->GetType(), &sensorType)) {
+    // Only register for a USF sensor once. If it maps to multiple sensors,
+    // code down the line will handle sending multiple updates.
+    if (!mHelper.registerForStatusUpdates(usfSensor)) {
+      LOGE("Failed to register for status updates for %s",
+           usfSensor->GetName());
+    }
+
+    addSensor(usfSensor, sensorType, chreSensors);
+
+    // USF shares the same sensor type for calibrated and uncalibrated sensors
+    // so populate a calibrated / uncalibrated sensor for known calibrated
+    // sensor types
+    uint8_t uncalibratedType =
+        SensorTypeHelpers::toUncalibratedSensorType(sensorType);
+    if (uncalibratedType != sensorType) {
+      addSensor(usfSensor, uncalibratedType, chreSensors);
+    }
+
+    // USF shares a sensor type for both gyro and accel temp.
+    if (sensorType == CHRE_SENSOR_TYPE_GYROSCOPE_TEMPERATURE) {
+      addSensor(usfSensor, CHRE_SENSOR_TYPE_ACCELEROMETER_TEMPERATURE,
+                chreSensors);
+    }
+  }
+}
+
+}  // namespace chre
diff --git a/platform/usf/platform_sensor_type_helpers.cc b/platform/usf/platform_sensor_type_helpers.cc
new file mode 100644
index 0000000..b961ad3
--- /dev/null
+++ b/platform/usf/platform_sensor_type_helpers.cc
@@ -0,0 +1,193 @@
+/*
+ * Copyright (C) 2020 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 "chre/platform/platform_sensor_type_helpers.h"
+#include "chre/target_platform/assert.h"
+#include "chre/util/macros.h"
+
+#ifdef CHREX_SENSOR_SUPPORT
+#include "chre/extensions/platform/vendor_sensor_types.h"
+#endif  // CHREX_SENSOR_SUPPORT
+
+namespace chre {
+
+ReportingMode PlatformSensorTypeHelpers::getVendorSensorReportingMode(
+    uint8_t /* sensorType */) {
+  // TODO: Stubbed out, implement this
+  return ReportingMode::Continuous;
+}
+
+bool PlatformSensorTypeHelpers::getVendorSensorIsCalibrated(
+    uint8_t /* sensorType */) {
+  // TODO: Stubbed out, implement this
+  return false;
+}
+
+bool PlatformSensorTypeHelpers::getVendorSensorBiasEventType(
+    uint8_t /* sensorType */, uint16_t * /* eventType */) {
+  // TODO: Stubbed out, implement this
+  return false;
+}
+
+const char *PlatformSensorTypeHelpers::getVendorSensorTypeName(
+    uint8_t sensorType) {
+#ifdef CHREX_SENSOR_SUPPORT
+  return extension::vendorSensorTypeName(sensorType);
+#else
+  UNUSED_VAR(sensorType);
+  return "";
+#endif
+}
+
+size_t PlatformSensorTypeHelpers::getVendorSensorLastEventSize(
+    uint8_t /* sensorType */) {
+  // TODO: Stubbed out, implement this
+  return 0;
+}
+
+void PlatformSensorTypeHelpers::getVendorLastSample(
+    uint8_t /* sensorType */, const ChreSensorData * /* event */,
+    ChreSensorData * /* lastEvent */) {
+  // TODO: Stubbed out, implement this
+}
+
+bool PlatformSensorTypeHelpersBase::reportsBias(uint8_t sensorType) {
+  switch (sensorType) {
+    case CHRE_SENSOR_TYPE_ACCELEROMETER:
+    case CHRE_SENSOR_TYPE_GYROSCOPE:
+    case CHRE_SENSOR_TYPE_GEOMAGNETIC_FIELD:
+    case CHRE_SENSOR_TYPE_UNCALIBRATED_ACCELEROMETER:
+    case CHRE_SENSOR_TYPE_UNCALIBRATED_GYROSCOPE:
+    case CHRE_SENSOR_TYPE_UNCALIBRATED_GEOMAGNETIC_FIELD:
+      return true;
+    default:
+      return false;
+  }
+}
+
+SensorSampleType
+PlatformSensorTypeHelpersBase::getSensorSampleTypeFromSensorType(
+    uint8_t sensorType) {
+  switch (sensorType) {
+    case CHRE_SENSOR_TYPE_ACCELEROMETER:
+    case CHRE_SENSOR_TYPE_GYROSCOPE:
+    case CHRE_SENSOR_TYPE_GEOMAGNETIC_FIELD:
+    case CHRE_SENSOR_TYPE_UNCALIBRATED_ACCELEROMETER:
+    case CHRE_SENSOR_TYPE_UNCALIBRATED_GYROSCOPE:
+    case CHRE_SENSOR_TYPE_UNCALIBRATED_GEOMAGNETIC_FIELD:
+      return SensorSampleType::ThreeAxis;
+    case CHRE_SENSOR_TYPE_PRESSURE:
+    case CHRE_SENSOR_TYPE_LIGHT:
+    case CHRE_SENSOR_TYPE_ACCELEROMETER_TEMPERATURE:
+    case CHRE_SENSOR_TYPE_GYROSCOPE_TEMPERATURE:
+    case CHRE_SENSOR_TYPE_GEOMAGNETIC_FIELD_TEMPERATURE:
+      return SensorSampleType::Float;
+    case CHRE_SENSOR_TYPE_INSTANT_MOTION_DETECT:
+    case CHRE_SENSOR_TYPE_STATIONARY_DETECT:
+    case CHRE_SENSOR_TYPE_STEP_DETECT:
+      return SensorSampleType::Occurrence;
+    case CHRE_SENSOR_TYPE_PROXIMITY:
+      return SensorSampleType::Byte;
+    default:
+#ifdef CHREX_SENSOR_SUPPORT
+      return extension::vendorSensorSampleTypeFromSensorType(sensorType);
+#else
+      // Update implementation to prevent undefined from being used.
+      CHRE_ASSERT(false);
+      return SensorSampleType::Unknown;
+#endif
+  }
+}
+
+usf::UsfSensorReportingMode PlatformSensorTypeHelpersBase::getUsfReportingMode(
+    ReportingMode mode) {
+  if (mode == ReportingMode::OnChange) {
+    return usf::kUsfSensorReportOnChange;
+  } else if (mode == ReportingMode::OneShot) {
+    return usf::kUsfSensorReportOneShot;
+  } else {
+    return usf::kUsfSensorReportContinuous;
+  }
+}
+
+bool PlatformSensorTypeHelpersBase::convertUsfToChreSensorType(
+    usf::UsfSensorType usfSensorType, uint8_t *chreSensorType) {
+  bool success = true;
+  switch (usfSensorType) {
+    case usf::UsfSensorType::kUsfSensorAccelerometer:
+      *chreSensorType = CHRE_SENSOR_TYPE_ACCELEROMETER;
+      break;
+    case usf::UsfSensorType::kUsfSensorGyroscope:
+      *chreSensorType = CHRE_SENSOR_TYPE_GYROSCOPE;
+      break;
+    case usf::UsfSensorType::kUsfSensorProx:
+      *chreSensorType = CHRE_SENSOR_TYPE_PROXIMITY;
+      break;
+    case usf::UsfSensorType::kUsfSensorBaro:
+      *chreSensorType = CHRE_SENSOR_TYPE_PRESSURE;
+      break;
+    case usf::UsfSensorType::kUsfSensorMag:
+      *chreSensorType = CHRE_SENSOR_TYPE_GEOMAGNETIC_FIELD;
+      break;
+    case usf::UsfSensorType::kUsfSensorMagTemp:
+      *chreSensorType = CHRE_SENSOR_TYPE_GEOMAGNETIC_FIELD_TEMPERATURE;
+      break;
+    case usf::UsfSensorType::kUsfSensorImuTemp:
+      *chreSensorType = CHRE_SENSOR_TYPE_GYROSCOPE_TEMPERATURE;
+      break;
+    case usf::UsfSensorType::kUsfSensorAmbientLight:
+      *chreSensorType = CHRE_SENSOR_TYPE_LIGHT;
+      break;
+    case usf::UsfSensorType::kUsfSensorMotionDetect:
+      *chreSensorType = CHRE_SENSOR_TYPE_INSTANT_MOTION_DETECT;
+      break;
+    case usf::UsfSensorType::kUsfSensorStationaryDetect:
+      *chreSensorType = CHRE_SENSOR_TYPE_STATIONARY_DETECT;
+      break;
+    case usf::UsfSensorType::kUsfSensorStepDetector:
+      *chreSensorType = CHRE_SENSOR_TYPE_STEP_DETECT;
+      break;
+    default:
+#ifdef CHREX_SENSOR_SUPPORT
+      success = extension::vendorConvertUsfToChreSensorType(usfSensorType,
+                                                            chreSensorType);
+#else
+      // Don't print anything as USF exposes sensor types CHRE doesn't care
+      // about (e.g. Camera Vsync, and color)
+      success = false;
+#endif
+      break;
+  }
+  return success;
+}
+
+uint8_t PlatformSensorTypeHelpersBase::convertUsfToChreSampleAccuracy(
+    usf::UsfSampleAccuracy usfSampleAccuracy) {
+  switch (usfSampleAccuracy) {
+    case usf::kUsfSampleAccuracyUnreliable:
+      return CHRE_SENSOR_ACCURACY_UNRELIABLE;
+    case usf::kUsfSampleAccuracyLow:
+      return CHRE_SENSOR_ACCURACY_LOW;
+    case usf::kUsfSampleAccuracyMedium:
+      return CHRE_SENSOR_ACCURACY_MEDIUM;
+    case usf::kUsfSampleAccuracyHigh:
+      return CHRE_SENSOR_ACCURACY_HIGH;
+    case usf::kUsfSampleAccuracyUnknown:
+    default:
+      return CHRE_SENSOR_ACCURACY_UNKNOWN;
+  }
+}
+
+}  // namespace chre
diff --git a/platform/usf/usf_helper.cc b/platform/usf/usf_helper.cc
new file mode 100644
index 0000000..f3336d4
--- /dev/null
+++ b/platform/usf/usf_helper.cc
@@ -0,0 +1,706 @@
+/*
+ * Copyright (C) 2020 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 "chre/platform/usf/usf_helper.h"
+
+#include <cinttypes>
+
+#include "chre/core/sensor_type_helpers.h"
+#include "chre/platform/fatal_error.h"
+#include "chre/util/macros.h"
+
+#include "usf/fbs/usf_msg_event_root_generated.h"
+#include "usf/fbs/usf_msg_sample_batch_root_generated.h"
+#include "usf/fbs/usf_msg_sensor_info_resp_root_generated.h"
+#include "usf/fbs/usf_msg_sensor_list_resp_root_generated.h"
+#include "usf/fbs/usf_msg_start_sampling_resp_root_generated.h"
+#include "usf/usf.h"
+#include "usf/usf_device.h"
+#include "usf/usf_flatbuffers.h"
+#include "usf/usf_sensor_defs.h"
+#include "usf/usf_sensor_mgr.h"
+#include "usf/usf_time.h"
+#include "usf/usf_work.h"
+
+using usf::UsfErr;
+using usf::UsfErr::kErrNone;
+
+#define LOG_USF_ERR(x) LOGE("USF failure %" PRIu8 ": line %d", x, __LINE__)
+
+namespace chre {
+namespace {
+
+//! Callback data delivered to async callback from USF. This struct must be
+//! freed using memoryFree.
+struct AsyncCallbackData {
+  UsfHelperCallbackInterface *callback;
+  void *cookie;
+};
+
+void eventHandler(void *context, usf::UsfEvent *event) {
+  const usf::UsfMsgEvent *msgEvent =
+      static_cast<usf::UsfTransportMsgEvent *>(event)->GetMsgEvent();
+
+  if (msgEvent != nullptr) {
+    auto *mgr = static_cast<UsfHelper *>(context);
+
+    switch (msgEvent->event_type()) {
+      case usf::UsfMsgEventType_kSensorReport:
+        mgr->processSensorReport(msgEvent);
+        break;
+      default:
+        LOGD("Received unknown event type %" PRIu8, msgEvent->event_type());
+        break;
+    }
+  }
+}
+
+void statusUpdateHandler(void *context, usf::UsfEvent *event) {
+  const usf::UsfSensorSamplingEvent *updateEvent =
+      static_cast<usf::UsfSensorSamplingEvent *>(event);
+
+  if (context != nullptr && updateEvent != nullptr) {
+    auto *mgr = static_cast<UsfHelper *>(context);
+    mgr->processStatusUpdate(updateEvent);
+  }
+}
+
+void biasUpdateHandler(void *context, usf::UsfEvent *event) {
+  const auto *updateEvent =
+      static_cast<usf::UsfSensorTransformConfigEvent *>(event);
+
+  if (context != nullptr && updateEvent != nullptr) {
+    auto *mgr = static_cast<UsfHelper *>(context);
+    mgr->processBiasUpdate(updateEvent);
+  }
+}
+
+void apPowerStateUpdateHandler(void *context, usf::UsfEvent *event) {
+  const auto *updateEvent = static_cast<usf::UsfApPowerStateEvent *>(event);
+
+  if (context != nullptr && updateEvent != nullptr) {
+    auto *mgr = static_cast<UsfHelper *>(context);
+    mgr->processApPowerStateUpdate(updateEvent);
+  }
+}
+
+void asyncCallback(usf::UsfReq *req, const usf::UsfResp *resp, void *data) {
+  auto callbackData = static_cast<AsyncCallbackData *>(data);
+  callbackData->callback->onFlushComplete(resp->GetErr(), req->GetReqId(),
+                                          callbackData->cookie);
+
+  memoryFree(data);
+  memoryFree(req);
+}
+
+void *allocateEvent(uint8_t sensorType, size_t numSamples) {
+  SensorSampleType sampleType =
+      PlatformSensorTypeHelpers::getSensorSampleTypeFromSensorType(sensorType);
+  size_t sampleSize = 0;
+  switch (sampleType) {
+    case SensorSampleType::ThreeAxis:
+      sampleSize =
+          sizeof(chreSensorThreeAxisData::chreSensorThreeAxisSampleData);
+      break;
+    case SensorSampleType::Float:
+      sampleSize = sizeof(chreSensorFloatData::chreSensorFloatSampleData);
+      break;
+    case SensorSampleType::Byte:
+      sampleSize = sizeof(chreSensorByteData::chreSensorByteSampleData);
+      break;
+    case SensorSampleType::Occurrence:
+      sampleSize =
+          sizeof(chreSensorOccurrenceData::chreSensorOccurrenceSampleData);
+      break;
+    default:
+      LOGE("Unhandled SensorSampleType for SensorType %" PRIu8,
+           static_cast<uint8_t>(sensorType));
+      sampleType = SensorSampleType::Unknown;
+  }
+
+  size_t memorySize =
+      (sampleType == SensorSampleType::Unknown)
+          ? 0
+          : (sizeof(chreSensorDataHeader) + numSamples * sampleSize);
+  void *event = (memorySize == 0) ? nullptr : memoryAlloc(memorySize);
+
+  if (event == nullptr && memorySize != 0) {
+    LOG_OOM();
+  }
+  return event;
+}
+
+/**
+ * Allocates the memory and sets up the chreSensorDataHeader used to deliver
+ * the sensor samples to nanoapps.
+ *
+ * @param numSamples The number of samples there should be space for in the
+ *     sensor event
+ * @param sensorHandle The handle to the sensor that produced the events
+ * @param sensor The CHRE sensor instance for the sensor that produced the
+ *     events
+ * @param sensorSamples A non-null UniquePtr used to hold the sensor samples
+ * @return If successful, sensorSamples will point to valid memory that
+ *     contains a valid chreSensorDataHeader and enough space to store all
+ *     sensor samples
+ */
+bool prepareSensorEvent(size_t numSamples, uint32_t sensorHandle,
+                        uint8_t sensorType, UniquePtr<uint8_t> &sensorSamples) {
+  bool success = false;
+
+  UniquePtr<uint8_t> buf(
+      static_cast<uint8_t *>(allocateEvent(sensorType, numSamples)));
+  sensorSamples = std::move(buf);
+
+  if (!sensorSamples.isNull()) {
+    success = true;
+
+    auto *header =
+        reinterpret_cast<chreSensorDataHeader *>(sensorSamples.get());
+    header->sensorHandle = sensorHandle;
+    header->readingCount = numSamples;
+    header->reserved = 0;
+  }
+
+  return success;
+}
+
+/**
+ * Populates CHRE sensor sample structure using USF sensor samples.
+ *
+ * @param sampleReport The USF report that contains sensor samples
+ * @param sensor The CHRE sensor instance for the sensor that produced the
+ *     events
+ * @param sensorSample Reference to a UniquePtr instance that points to non-null
+ *     memory that will be populated with sensor samples
+ */
+void populateSensorEvent(const usf::UsfSensorSampleReport *sampleReport,
+                         uint8_t sensorType, UniquePtr<uint8_t> &sensorSample) {
+  uint64_t prevSampleTimeNs = 0;
+
+  for (int i = 0; i < sampleReport->GetSampleCount(); i++) {
+    usf::UsfSampleEvent sampleEvent;
+    UsfErr err = sampleReport->GetSample(i, &sampleEvent);
+    if (err != kErrNone) {
+      LOG_USF_ERR(err);
+      continue;
+    }
+
+    SensorSampleType sampleType =
+        PlatformSensorTypeHelpers::getSensorSampleTypeFromSensorType(
+            sensorType);
+
+    uint32_t *timestampDelta = nullptr;
+    switch (sampleType) {
+      case SensorSampleType::ThreeAxis: {
+        auto *event =
+            reinterpret_cast<chreSensorThreeAxisData *>(sensorSample.get());
+
+        // TODO(b/143139477): Apply calibration to data from these sensors
+        for (size_t valIndex = 0; valIndex < 3; valIndex++) {
+          event->readings[i].values[valIndex] = sampleEvent.data[valIndex];
+        }
+        timestampDelta = &event->readings[i].timestampDelta;
+        break;
+      }
+      case SensorSampleType::Float: {
+        auto *event =
+            reinterpret_cast<chreSensorFloatData *>(sensorSample.get());
+        event->readings[i].value = sampleEvent.data[0];
+        timestampDelta = &event->readings[i].timestampDelta;
+        break;
+      }
+      case SensorSampleType::Byte: {
+        auto *event =
+            reinterpret_cast<chreSensorByteData *>(sensorSample.get());
+        event->readings[i].value = 0;
+        event->readings[i].isNear = (sampleEvent.data[0] > 0.5f);
+        timestampDelta = &event->readings[i].timestampDelta;
+        break;
+      }
+      case SensorSampleType::Occurrence: {
+        // Occurrence samples don't store any readings
+        auto *event =
+            reinterpret_cast<chreSensorOccurrenceData *>(sensorSample.get());
+        timestampDelta = &event->readings[0].timestampDelta;
+        break;
+      }
+      default:
+        LOGE("Invalid sample type %" PRIu8, static_cast<uint8_t>(sampleType));
+    }
+
+    // First sample determines the base timestamp and accuracy for all other
+    // sensor samples
+    if (i == 0) {
+      auto *header =
+          reinterpret_cast<chreSensorDataHeader *>(sensorSample.get());
+      header->baseTimestamp = sampleEvent.timestamp_ns;
+      if (timestampDelta != nullptr) {
+        *timestampDelta = 0;
+      }
+      auto usfAccuracy = sampleEvent.accuracy;
+      header->accuracy =
+          PlatformSensorTypeHelpersBase::convertUsfToChreSampleAccuracy(
+              usfAccuracy);
+
+    } else {
+      uint64_t delta = sampleEvent.timestamp_ns - prevSampleTimeNs;
+      if (delta > UINT32_MAX) {
+        LOGE("Sensor %" PRIu8 " timestampDelta overflow: prev %" PRIu64
+             " curr %" PRIu64,
+             sensorType, prevSampleTimeNs, sampleEvent.timestamp_ns);
+        delta = UINT32_MAX;
+      }
+      *timestampDelta = static_cast<uint32_t>(delta);
+    }
+
+    prevSampleTimeNs = sampleEvent.timestamp_ns;
+  }
+}
+
+}  // namespace
+
+UsfHelper::~UsfHelper() {
+  for (usf::UsfEventListener *listener : mUsfEventListeners) {
+    listener->event_type->RemoveListener(listener);
+  }
+
+  if (mWorker.get() != nullptr) {
+    mWorker->Stop();
+    mWorker.reset();
+  }
+
+  if (mTransportClient.get() != nullptr) {
+    mTransportClient->Disconnect();
+    mTransportClient.reset();
+  }
+}
+
+uint8_t UsfHelper::usfErrorToChreError(UsfErr err) {
+  switch (err) {
+    case UsfErr::kErrNone:
+      return CHRE_ERROR_NONE;
+    case UsfErr::kErrNotSupported:
+      return CHRE_ERROR_NOT_SUPPORTED;
+    case UsfErr::kErrMemAlloc:
+      return CHRE_ERROR_NO_MEMORY;
+    case UsfErr::kErrNotAvailable:
+      return CHRE_ERROR_BUSY;
+    case UsfErr::kErrTimedOut:
+      return CHRE_ERROR_TIMEOUT;
+    default:
+      return CHRE_ERROR;
+  }
+}
+
+void UsfHelper::init(UsfHelperCallbackInterface *callback,
+                     usf::UsfWorker *worker) {
+  CHRE_ASSERT(callback != nullptr);
+
+  usf::UsfDeviceMgr::GetDeviceProbeCompletePrecondition()->Wait();
+
+  UsfErr err = UsfErr::kErrAllocation;
+  if (worker != nullptr) {
+    mWorker.reset(worker, refcount::RefTakingMode::kCreate);
+    err = kErrNone;
+  } else {
+    err = usf::UsfWorkMgr::CreateWorker(&mWorker);
+  }
+
+  if (callback == nullptr) {
+    err = UsfErr::kErrBadValue;
+  } else if (!mUsfEventListeners.emplace_back()) {
+    LOG_OOM();
+  } else if ((err != kErrNone) ||
+             ((err = usf::UsfTransportClient::Create(
+                   &mTransportClient, usf::kUsfHeapLowPower)) != kErrNone) ||
+             ((err = mTransportClient->Connect()) != kErrNone) ||
+             ((err = mTransportClient->GetMsgEventType()->AddListener(
+                   mWorker.get(), eventHandler, this,
+                   &mUsfEventListeners.back())) != kErrNone) ||
+             ((err = usf::UsfClientGetServer(mTransportClient.get(),
+                                             &usf::kUsfSensorMgrServerUuid,
+                                             &mSensorMgrHandle)) != kErrNone)) {
+    LOG_USF_ERR(err);
+    // TODO(b/143139477): Debate removing the error capture if it proves to be
+    // unneeded in ramdump analysis.
+    mInitError = err;
+  } else {
+    mCallback = callback;
+  }
+
+  if (err != kErrNone) {
+    FATAL_ERROR("Failed to initialize UsfHelper: %" PRIu8, err);
+  }
+}
+
+bool UsfHelper::getSensorList(
+    usf::UsfVector<refcount::reffed_ptr<usf::UsfSensor>> *sensorList) {
+  UsfErr err = usf::UsfSensorMgr::GetSensorList(sensorList);
+  if (err != kErrNone) {
+    LOG_USF_ERR(err);
+  }
+  return err == kErrNone;
+}
+
+bool UsfHelper::startSampling(usf::UsfStartSamplingReq *request,
+                              uint32_t *samplingId) {
+  bool success = false;
+
+  usf::UsfReqSyncCallback callback;
+  const usf::UsfMsgStartSamplingResp *resp;
+  if (sendUsfReqSync(request, &callback) && getRespMsg(callback, &resp)) {
+    *samplingId = resp->sampling_id();
+    success = true;
+  }
+
+  return success;
+}
+
+bool UsfHelper::reconfigureSampling(usf::UsfReconfigSamplingReq *request) {
+  usf::UsfReqSyncCallback callback;
+  return sendUsfReqSync(request, &callback);
+}
+
+bool UsfHelper::stopSampling(usf::UsfStopSamplingReq *request) {
+  usf::UsfReqSyncCallback callback;
+  return sendUsfReqSync(request, &callback);
+}
+
+bool UsfHelper::registerForStatusUpdates(
+    refcount::reffed_ptr<usf::UsfSensor> &sensor) {
+  bool success = false;
+  if (!mUsfEventListeners.emplace_back()) {
+    LOG_OOM();
+  } else {
+    UsfErr err = sensor->GetSamplingEventType()->AddListener(
+        mWorker.get(), statusUpdateHandler, this, &mUsfEventListeners.back());
+    success = (err == kErrNone);
+    if (!success) {
+      LOG_USF_ERR(err);
+    }
+  }
+
+  return success;
+}
+
+bool UsfHelper::registerForBiasUpdates(
+    const refcount::reffed_ptr<usf::UsfSensor> &sensor) {
+  // TODO(b/147595659): Obtain the latest bias values when registering for bias
+  // updates to ensure chreSensorGetThreeAxisBias doesn't return stale values.
+  bool success = false;
+  if (!mUsfEventListeners.emplace_back()) {
+    LOG_OOM();
+  } else {
+    UsfErr err = sensor->GetTransformConfigEventType()->AddListener(
+        mWorker.get(), biasUpdateHandler, this, &mUsfEventListeners.back());
+    success = (err == kErrNone);
+    if (!success) {
+      LOG_USF_ERR(err);
+    }
+  }
+
+  return success;
+}
+
+bool UsfHelper::registerForApPowerStateUpdates() {
+  bool success = false;
+  if (!mUsfEventListeners.emplace_back()) {
+    LOG_OOM();
+  } else {
+    UsfErr err = usf::UsfPowerMgr::GetApPowerEventType()->AddListener(
+        mWorker.get(), apPowerStateUpdateHandler, this,
+        &mUsfEventListeners.back());
+    success = (err == kErrNone);
+    if (!success) {
+      LOG_USF_ERR(err);
+    }
+  }
+  return success;
+}
+
+void UsfHelper::unregisterForBiasUpdates(
+    const refcount::reffed_ptr<usf::UsfSensor> &sensor) {
+  for (size_t i = 0; i < mUsfEventListeners.size(); i++) {
+    usf::UsfEventListener *listener = mUsfEventListeners[i];
+    if (listener->event_type.get() == sensor->GetTransformConfigEventType()) {
+      listener->event_type->RemoveListener(listener);
+      mUsfEventListeners.erase(i);
+      break;
+    }
+  }
+}
+
+bool UsfHelper::getThreeAxisBias(
+    const refcount::reffed_ptr<usf::UsfSensor> &sensor,
+    struct chreSensorThreeAxisData *bias) const {
+  bool success = false;
+  size_t index = getCalArrayIndex(sensor->GetType());
+  if (bias != nullptr && index < kNumUsfCalSensors) {
+    const UsfCalData &data = mCalData[index];
+    if (data.hasBias) {
+      bias->header.baseTimestamp = data.timestamp;
+      bias->header.readingCount = 1;
+      bias->header.accuracy = data.accuracy;
+      bias->header.reserved = 0;
+      for (size_t i = 0; i < ARRAY_SIZE(data.bias); i++) {
+        bias->readings[0].bias[i] = data.bias[i];
+      }
+      bias->readings[0].timestampDelta = 0;
+      success = true;
+    }
+  }
+
+  return success;
+}
+
+bool UsfHelper::flushAsync(const usf::UsfServerHandle usfSensorHandle,
+                           void *cookie, uint32_t *requestId) {
+  bool success = false;
+  auto req = MakeUnique<usf::UsfReq>();
+  auto callbackData = MakeUnique<AsyncCallbackData>();
+  if (req.isNull() || callbackData.isNull()) {
+    LOG_OOM();
+  } else {
+    req->SetReqType(usf::UsfMsgReqType_FLUSH_SAMPLES);
+    req->SetServerHandle(usfSensorHandle);
+    callbackData->callback = mCallback;
+    callbackData->cookie = cookie;
+
+    UsfErr err = mTransportClient->SendRequest(req.get(), asyncCallback,
+                                               callbackData.get());
+    success = (err == kErrNone);
+    if (!success) {
+      LOG_USF_ERR(err);
+    } else {
+      *requestId = req->GetReqId();
+      req.release();
+      callbackData.release();
+    }
+  }
+
+  return success;
+}
+
+void UsfHelper::processSensorReport(const usf::UsfMsgEvent *event) {
+  usf::UsfSensorReport *sensorReport = nullptr;
+  UniquePtr<uint8_t> sensorSample;
+  UsfErr err = usf::UsfSensorReport::Get(event, &sensorReport);
+
+  if (err != kErrNone) {
+    LOG_USF_ERR(err);
+  } else if (sensorReport->GetType() == usf::UsfSensorReport::kTypeSample) {
+    auto *sampleReport =
+        static_cast<usf::UsfSensorSampleReport *>(sensorReport);
+    if (sampleReport->GetSampleCount() == 0) {
+      LOGE("Received empty sample batch");
+    } else {
+      auto usfType = sampleReport->GetSensorType();
+      uint8_t sensorType;
+      if (PlatformSensorTypeHelpersBase::convertUsfToChreSensorType(
+              usfType, &sensorType) &&
+          !createSensorEvent(sampleReport, sensorType, sensorSample)) {
+        // USF shares the same sensor type between calibrated and uncalibrated
+        // sensors. Try the uncalibrated type to see if the sampling ID matches.
+        uint8_t uncalType =
+            SensorTypeHelpers::toUncalibratedSensorType(sensorType);
+        if (uncalType != sensorType) {
+          sensorType = uncalType;
+          createSensorEvent(sampleReport, uncalType, sensorSample);
+          // USF shares a sensor type for both gyro and accel temp.
+        } else if (sensorType == CHRE_SENSOR_TYPE_GYROSCOPE_TEMPERATURE) {
+          createSensorEvent(sampleReport,
+                            CHRE_SENSOR_TYPE_ACCELEROMETER_TEMPERATURE,
+                            sensorSample);
+        }
+      }
+      if (!sensorSample.isNull() && mCallback != nullptr) {
+        mCallback->onSensorDataEvent(sensorType, std::move(sensorSample));
+      }
+    }
+  }
+  delete sensorReport;
+}
+
+void UsfHelper::processStatusUpdate(const usf::UsfSensorSamplingEvent *update) {
+  // TODO(stange): See if the latest status can be shared among sensor types
+  // with the same underlying physical sensor to avoid allocating multiple
+  // updates.
+  uint8_t sensorType;
+  if (PlatformSensorTypeHelpersBase::convertUsfToChreSensorType(
+          update->GetSensor()->GetType(), &sensorType)) {
+    mCallback->onSamplingStatusUpdate(sensorType, update);
+
+    // USF shares the same sensor type for calibrated and uncalibrated sensors
+    // so populate a calibrated / uncalibrated sensor for known calibrated
+    // sensor types
+    uint8_t uncalibratedType =
+        SensorTypeHelpers::toUncalibratedSensorType(sensorType);
+    if (uncalibratedType != sensorType) {
+      mCallback->onSamplingStatusUpdate(uncalibratedType, update);
+    }
+
+    // USF shares a sensor type for both gyro and accel temp.
+    if (sensorType == CHRE_SENSOR_TYPE_GYROSCOPE_TEMPERATURE) {
+      mCallback->onSamplingStatusUpdate(
+          CHRE_SENSOR_TYPE_ACCELEROMETER_TEMPERATURE, update);
+    }
+  }
+}
+
+void UsfHelper::processBiasUpdate(
+    const usf::UsfSensorTransformConfigEvent *update) {
+  uint8_t sensorType;
+  if (PlatformSensorTypeHelpersBase::convertUsfToChreSensorType(
+          update->GetSensor()->GetType(), &sensorType)) {
+    UniquePtr<struct chreSensorThreeAxisData> biasData =
+        convertUsfBiasUpdateToData(update);
+    if (!biasData.isNull()) {
+      // USF shares the same sensor type for calibrated and uncalibrated sensors
+      // so populate a calibrated / uncalibrated sensor for known calibrated
+      // sensor types
+      uint8_t uncalibratedType =
+          SensorTypeHelpers::toUncalibratedSensorType(sensorType);
+      if (uncalibratedType != sensorType) {
+        auto uncalBiasData =
+            MakeUniqueZeroFill<struct chreSensorThreeAxisData>();
+        if (uncalBiasData.isNull()) {
+          LOG_OOM();
+        } else {
+          *uncalBiasData = *biasData;
+          mCallback->onBiasUpdate(uncalibratedType, std::move(uncalBiasData));
+        }
+      }
+      mCallback->onBiasUpdate(sensorType, std::move(biasData));
+    }
+  }
+}
+
+void UsfHelper::processApPowerStateUpdate(
+    const usf::UsfApPowerStateEvent *update) {
+  usf::UsfApPowerState state = update->GetState();
+  if (state == usf::kUsfApPowerStateInvalid) {
+    LOGE("Invalid AP power state received.");
+  } else {
+    mCallback->onHostWakeSuspendEvent(state == usf::kUsfApPowerStateOn);
+  }
+}
+
+bool UsfHelper::createSensorEvent(
+    const usf::UsfSensorSampleReport *sampleReport, uint8_t sensorType,
+    UniquePtr<uint8_t> &sensorSample) {
+  bool success = false;
+
+  SensorInfo info;
+  if (mCallback != nullptr && mCallback->getSensorInfo(sensorType, &info) &&
+      (info.samplingId == sampleReport->GetSamplingId())) {
+    if (prepareSensorEvent(sampleReport->GetSampleCount(), info.sensorHandle,
+                           sensorType, sensorSample)) {
+      populateSensorEvent(sampleReport, sensorType, sensorSample);
+      success = true;
+    }
+  }
+
+  return success;
+}
+
+bool UsfHelper::sendUsfReqSync(usf::UsfReq *req,
+                               usf::UsfReqSyncCallback *callback) {
+  UsfErr err = mTransportClient->SendRequest(
+      req, usf::UsfReqSyncCallback::Callback, callback);
+  if (err != kErrNone) {
+    LOG_USF_ERR(err);
+  } else {
+    // TODO: Provide a different timeout for operations we expect to take longer
+    // e.g. initial sensor discovery.
+    callback->Wait(kDefaultUsfWaitTimeout.toRawNanoseconds());
+    if ((err = callback->GetResp()->GetErr()) != kErrNone) {
+      LOG_USF_ERR(err);
+    }
+  }
+
+  return err == kErrNone;
+}
+
+template <class T>
+bool UsfHelper::getRespMsg(usf::UsfReqSyncCallback &callback,
+                           const T **respMsg) {
+  UsfErr err = usf::UsfRespGetMsg(callback.GetResp(), respMsg);
+  if (err != kErrNone) {
+    LOG_USF_ERR(err);
+  }
+
+  return err == kErrNone;
+}
+
+UniquePtr<struct chreSensorThreeAxisData> UsfHelper::convertUsfBiasUpdateToData(
+    const usf::UsfSensorTransformConfigEvent *update) {
+  UniquePtr<struct chreSensorThreeAxisData> biasData;
+  size_t index = getCalArrayIndex(update->GetSensor()->GetType());
+  if (index < kNumUsfCalSensors &&
+      update->GetLevel() == usf::kUsfSensorTransformRunTimeCalibration) {
+    UsfCalData &data = mCalData[index];
+    UsfErr err = usf::UsfTimeMgr::GetAndroidTimeNs(&data.timestamp);
+    if (err != kErrNone) {
+      LOG_USF_ERR(err);
+    }
+    data.hasBias = (update->GetOffset() != nullptr);
+    for (size_t i = 0; i < ARRAY_SIZE(data.bias); i++) {
+      data.bias[i] = data.hasBias ? update->GetOffset()[i] : 0;
+    }
+    data.accuracy =
+        PlatformSensorTypeHelpersBase::convertUsfToChreSampleAccuracy(
+            update->GetAccuracy());
+
+    biasData = MakeUniqueZeroFill<struct chreSensorThreeAxisData>();
+    if (biasData.isNull()) {
+      LOG_OOM();
+    } else {
+      biasData->header.baseTimestamp = data.timestamp;
+      biasData->header.readingCount = 1;
+      biasData->header.accuracy = data.accuracy;
+      biasData->header.reserved = 0;
+      for (size_t i = 0; i < ARRAY_SIZE(data.bias); i++) {
+        biasData->readings[0].bias[i] = data.bias[i];
+      }
+      biasData->readings[0].timestampDelta = 0;
+    }
+  }
+
+  return biasData;
+}
+
+size_t UsfHelper::getCalArrayIndex(const usf::UsfSensorType usfSensorType) {
+  UsfCalSensor index;
+  switch (usfSensorType) {
+    case usf::UsfSensorType::kUsfSensorAccelerometer:
+      index = UsfCalSensor::AccelCal;
+      break;
+    case usf::UsfSensorType::kUsfSensorGyroscope:
+      index = UsfCalSensor::GyroCal;
+      break;
+    case usf::UsfSensorType::kUsfSensorMag:
+      index = UsfCalSensor::MagCal;
+      break;
+    default:
+      index = UsfCalSensor::NumCalSensors;
+      break;
+  }
+
+  return static_cast<size_t>(index);
+}
+
+}  // namespace chre
diff --git a/util/include/chre/util/macros.h b/util/include/chre/util/macros.h
index 92160b8..2fe7d7e 100644
--- a/util/include/chre/util/macros.h
+++ b/util/include/chre/util/macros.h
@@ -24,14 +24,26 @@
 /**
  * Obtains the number of elements in a C-style array.
  */
+#ifndef ARRAY_SIZE
 #define ARRAY_SIZE(array) (sizeof(array) / sizeof((array)[0]))
+#endif
+
+#ifndef ARRAY_END
 #define ARRAY_END(array) (array + ARRAY_SIZE(array))
+#endif
+
+/** Determines if the provided bit is set in the provided value. */
+#ifndef IS_BIT_SET
+#define IS_BIT_SET(value, bit) (((value) & (bit)) == (bit))
+#endif
 
 /**
  * Performs macro expansion then converts the value into a string literal
  */
+#ifndef STRINGIFY
 #define STRINGIFY(x) STRINGIFY2(x)
 #define STRINGIFY2(x) #x
+#endif
 
 // Compiler-specific functionality
 #if defined(__clang__) || defined(__GNUC__)
diff --git a/util/include/chre/util/system/napp_header_utils.h b/util/include/chre/util/system/napp_header_utils.h
new file mode 100644
index 0000000..e9ab416
--- /dev/null
+++ b/util/include/chre/util/system/napp_header_utils.h
@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2020 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 CHRE_UTIL_SYSTEM_NAPP_HEADER_UTILS_H_
+#define CHRE_UTIL_SYSTEM_NAPP_HEADER_UTILS_H_
+
+//! Defines various constants used in the nanoapp headers defined inside
+//! build/build_template.mk.
+#define CHRE_NAPP_HEADER_SIGNED 0x00000001
+#define CHRE_NAPP_HEADER_ENCRYPTED 0x00000002
+#define CHRE_NAPP_HEADER_TCM_CAPABLE 0x00000004
+
+#endif  // CHRE_UTIL_SYSTEM_NAPP_HEADER_UTILS_H_