diff --git a/aosp_trout_arm64.mk b/aosp_trout_arm64.mk
index a24db1d..65688d9 100644
--- a/aosp_trout_arm64.mk
+++ b/aosp_trout_arm64.mk
@@ -16,6 +16,12 @@
 
 $(call inherit-product, device/google/cuttlefish/vsoc_arm64/auto/aosp_cf.mk)
 
+# Audio Control HAL
+# TODO (chenhaosjtuacm, egranata): move them to kernel command line
+LOCAL_AUDIOCONTROL_PROPERTIES ?= \
+    ro.vendor.audiocontrol.server.cid=1000 \
+    ro.vendor.audiocontrol.server.port=9410 \
+
 include device/google/trout/aosp_trout_common.mk
 
 DEVICE_MANIFEST_FILE += device/google/trout/manifest.xml
@@ -29,15 +35,10 @@
 
 PRODUCT_COPY_FILES += \
     device/google/trout/product_files/odm/ueventd.rc:$(TARGET_COPY_OUT_ODM)/ueventd.rc \
-
-PRODUCT_COPY_FILES += \
-    device/google/trout/product_files/vendor/etc/input-port-associations.xml:$(TARGET_COPY_OUT_VENDOR)/etc/input-port-associations.xml \
+    device/google/trout/product_files/odm/usr/idc/Vendor_0fff_Product_0fff.idc:$(TARGET_COPY_OUT_ODM)/usr/idc/Vendor_0fff_Product_0fff.idc \
 
 PRODUCT_COPY_FILES += device/google/trout/product_files/vendor/etc/sensors/hals.conf:$(TARGET_COPY_OUT_VENDOR)/etc/sensors/hals.conf
 
-BOARD_VENDOR_KERNEL_MODULES += \
-    $(wildcard device/google/trout-kernel/5.4-arm64/*.ko) \
-
 PRODUCT_NAME := aosp_trout_arm64
 PRODUCT_DEVICE := vsoc_arm64
 PRODUCT_MODEL := arm64 trout
diff --git a/aosp_trout_common.mk b/aosp_trout_common.mk
index c4e5b50..ae7ec53 100644
--- a/aosp_trout_common.mk
+++ b/aosp_trout_common.mk
@@ -14,6 +14,16 @@
 # limitations under the License.
 #
 
+# Audio HAL
+LOCAL_AUDIO_PRODUCT_PACKAGE ?= \
+    audio.primary.trout \
+    audio.r_submix.default \
+    android.hardware.audio@6.0-impl:32 \
+    android.hardware.audio.effect@6.0-impl:32 \
+    android.hardware.audio.service \
+    android.hardware.soundtrigger@2.3-impl
+LOCAL_AUDIO_DEVICE_PACKAGE_OVERLAYS ?= device/google/trout/hal/audio/6.0/overlay
+
 # Audio Control HAL
 LOCAL_AUDIOCONTROL_HAL_PRODUCT_PACKAGE ?= android.hardware.audiocontrol@2.0-service.trout
 
@@ -34,8 +44,17 @@
 
 PRODUCT_PROPERTY_OVERRIDES += \
     ro.hardware.type=automotive \
+    ${LOCAL_AUDIOCONTROL_PROPERTIES} \
     ${LOCAL_DUMPSTATE_PROPERTIES}
 
 TARGET_BOARD_INFO_FILE ?= device/google/trout/board-info.txt
 
-include packages/services/Car/computepipe/products/computepipe.mk
+LOCAL_AUDIO_PRODUCT_COPY_FILES ?= \
+    device/google/trout/hal/audio/6.0/audio_policy_configuration.xml:$(TARGET_COPY_OUT_VENDOR)/etc/audio_policy_configuration.xml \
+    device/google/trout/hal/audio/6.0/car_audio_configuration.xml:$(TARGET_COPY_OUT_VENDOR)/etc/car_audio_configuration.xml \
+    frameworks/native/data/etc/android.hardware.broadcastradio.xml:system/etc/permissions/android.hardware.broadcastradio.xml \
+    frameworks/av/services/audiopolicy/config/a2dp_audio_policy_configuration.xml:$(TARGET_COPY_OUT_VENDOR)/etc/a2dp_audio_policy_configuration.xml \
+    frameworks/av/services/audiopolicy/config/usb_audio_policy_configuration.xml:$(TARGET_COPY_OUT_VENDOR)/etc/usb_audio_policy_configuration.xml
+
+# TODO(b/162901005): Include computepipe once this project points to main.
+# include packages/services/Car/cpp/computepipe/products/computepipe.mk
diff --git a/aosp_trout_x86.mk b/aosp_trout_x86.mk
index 59fb9d9..28bf246 100644
--- a/aosp_trout_x86.mk
+++ b/aosp_trout_x86.mk
@@ -16,14 +16,21 @@
 
 $(call inherit-product, device/google/cuttlefish/vsoc_x86/auto/device.mk)
 
+# Audio Control HAL
+# TODO (chenhaosjtuacm, egranata): move them to kernel command line
+LOCAL_AUDIOCONTROL_PROPERTIES ?= \
+    ro.vendor.audiocontrol.server.cid=3 \
+    ro.vendor.audiocontrol.server.port=9410 \
+
 include device/google/trout/aosp_trout_common.mk
 
 DEVICE_MANIFEST_FILE += device/google/trout/manifest_x86.xml
 DEVICE_MATRIX_FILE += device/google/trout/compatibility_matrix.xml
 DEVICE_FRAMEWORK_COMPATIBILITY_MATRIX_FILE := device/google/trout/framework_compatibility_matrix.xml
 
-PRODUCT_COPY_FILES += \
-    packages/services/Car/computepipe/products/init.computepipe.rc:$(TARGET_COPY_OUT_SYSTEM)/etc/init/computepipe.rc
+# TODO(b/162901005): Include computepipe once this project points to main.
+# PRODUCT_COPY_FILES += \
+#    packages/services/Car/cpp/computepipe/products/init.computepipe.rc:$(TARGET_COPY_OUT_SYSTEM)/etc/init/computepipe.rc
 
 PRODUCT_NAME := aosp_trout_x86
 PRODUCT_DEVICE := vsoc_x86
diff --git a/hal/audio/6.0/Android.bp b/hal/audio/6.0/Android.bp
new file mode 100644
index 0000000..1847f6f
--- /dev/null
+++ b/hal/audio/6.0/Android.bp
@@ -0,0 +1,46 @@
+//
+// Copyright (C) 2017 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.
+
+// Derived from device/generic/goldfish/audio/Android.mk
+
+cc_library_shared {
+
+    vendor: true,
+    // vintf_fragments: ["android.hardware.audio@6.0-trout-impl.xml"],
+    name: "audio.primary.trout",
+    relative_install_path: "hw",
+
+    srcs: [
+        "audio_hw.c",
+        "audio_vbuffer.c",
+        "ext_pcm.c",
+    ],
+
+    include_dirs: ["external/tinyalsa/include"],
+
+    shared_libs: [
+        "libcutils",
+        "liblog",
+        "libdl",
+        "libtinyalsa",
+    ],
+
+    cflags: ["-Wno-unused-parameter"],
+    header_libs: [
+        "libhardware_headers",
+        "libcutils_headers",
+    ],
+
+}
diff --git a/hal/audio/6.0/android.hardware.audio@6.0-trout-impl.xml b/hal/audio/6.0/android.hardware.audio@6.0-trout-impl.xml
new file mode 100644
index 0000000..2814739
--- /dev/null
+++ b/hal/audio/6.0/android.hardware.audio@6.0-trout-impl.xml
@@ -0,0 +1,25 @@
+<!-- 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.
+-->
+<manifest version="1.0" type="device">
+    <hal format="hidl">
+        <name>android.hardware.audio</name>
+        <transport>hwbinder</transport>
+        <version>6.0</version>
+        <interface>
+            <name>IDevicesFactory</name>
+            <instance>default</instance>
+        </interface>
+    </hal>
+</manifest>
\ No newline at end of file
diff --git a/hal/audio/6.0/audio_hw.c b/hal/audio/6.0/audio_hw.c
new file mode 100644
index 0000000..bc27e90
--- /dev/null
+++ b/hal/audio/6.0/audio_hw.c
@@ -0,0 +1,1581 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+
+/**
+ * Derived from goldfish/audio/audio_hw.c
+ * Changes made to adding support of AUDIO_DEVICE_OUT_BUS
+ */
+
+#define LOG_TAG "audio_hw_generic"
+
+#include <assert.h>
+#include <errno.h>
+#include <inttypes.h>
+#include <math.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <sys/time.h>
+#include <dlfcn.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+#include <log/log.h>
+#include <cutils/properties.h>
+#include <cutils/str_parms.h>
+
+#include <hardware/hardware.h>
+#include <system/audio.h>
+
+#include "audio_hw.h"
+#include "ext_pcm.h"
+
+#define PCM_CARD 0
+#define PCM_DEVICE 0
+
+#define OUT_PERIOD_MS 15
+#define OUT_PERIOD_COUNT 4
+
+#define IN_PERIOD_MS 15
+#define IN_PERIOD_COUNT 4
+
+#define PI 3.14159265
+#define TWO_PI  (2*PI)
+
+// 150 Hz
+#define DEFAULT_FREQUENCY 150
+// Increase in changes to tone frequency
+#define TONE_FREQUENCY_INCREASE 20
+// Max tone frequency to auto assign, don't want to generate too high of a pitch
+#define MAX_TONE_FREQUENCY 500
+
+#define _bool_str(x) ((x)?"true":"false")
+
+static const char * const PROP_KEY_SIMULATE_MULTI_ZONE_AUDIO = "ro.aae.simulateMultiZoneAudio";
+static const char * const AAE_PARAMETER_KEY_FOR_SELECTED_ZONE = "com.android.car.emulator.selected_zone";
+#define PRIMARY_ZONE_ID 0
+#define INVALID_ZONE_ID -1
+// Note the primary zone goes to left speaker so route other zone to right speaker
+#define DEFAULT_ZONE_TO_LEFT_SPEAKER (PRIMARY_ZONE_ID + 1)
+
+static const char * const TONE_ADDRESS_KEYWORD = "_tone_";
+static const char * const AUDIO_ZONE_KEYWORD = "_audio_zone_";
+
+#define SIZE_OF_PARSE_BUFFER 32
+
+static int adev_get_mic_mute(const struct audio_hw_device *dev, bool *state);
+
+static struct pcm_config pcm_config_out = {
+    .channels = 2,
+    .rate = 0,
+    .period_size = 0,
+    .period_count = OUT_PERIOD_COUNT,
+    .format = PCM_FORMAT_S16_LE,
+    .start_threshold = 0,
+};
+
+static int get_int_value(const struct str_parms *str_parms, const char *key, int *return_value) {
+    char value[SIZE_OF_PARSE_BUFFER];
+    int results = str_parms_get_str(str_parms, key, value, SIZE_OF_PARSE_BUFFER);
+    if (results >= 0) {
+        char *end = NULL;
+        errno = 0;
+        long val = strtol(value, &end, 10);
+        if ((errno == 0) && (end != NULL) && (*end == '\0') && ((int) val == val)) {
+            *return_value = val;
+        } else {
+            results = -EINVAL;
+        }
+    }
+    return results;
+}
+
+static struct pcm_config pcm_config_in = {
+    .channels = 2,
+    .rate = 0,
+    .period_size = 0,
+    .period_count = IN_PERIOD_COUNT,
+    .format = PCM_FORMAT_S16_LE,
+    .start_threshold = 0,
+    .stop_threshold = INT_MAX,
+};
+
+static pthread_mutex_t adev_init_lock = PTHREAD_MUTEX_INITIALIZER;
+static unsigned int audio_device_ref_count = 0;
+
+static bool is_zone_selected_to_play(struct audio_hw_device *dev, int zone_id) {
+    // play if current zone is enable or zone equal to primary zone
+    bool is_selected_zone = true;
+    if (zone_id != PRIMARY_ZONE_ID) {
+        struct generic_audio_device *adev = (struct generic_audio_device *)dev;
+        pthread_mutex_lock(&adev->lock);
+        is_selected_zone = adev->last_zone_selected_to_play == zone_id;
+        pthread_mutex_unlock(&adev->lock);
+    }
+    return is_selected_zone;
+}
+
+static uint32_t out_get_sample_rate(const struct audio_stream *stream) {
+    struct generic_stream_out *out = (struct generic_stream_out *)stream;
+    return out->req_config.sample_rate;
+}
+
+static int out_set_sample_rate(struct audio_stream *stream, uint32_t rate) {
+    return -ENOSYS;
+}
+
+static size_t out_get_buffer_size(const struct audio_stream *stream) {
+    struct generic_stream_out *out = (struct generic_stream_out *)stream;
+    int size = out->pcm_config.period_size *
+                audio_stream_out_frame_size(&out->stream);
+
+    return size;
+}
+
+static audio_channel_mask_t out_get_channels(const struct audio_stream *stream) {
+    struct generic_stream_out *out = (struct generic_stream_out *)stream;
+    return out->req_config.channel_mask;
+}
+
+static audio_format_t out_get_format(const struct audio_stream *stream) {
+    struct generic_stream_out *out = (struct generic_stream_out *)stream;
+    return out->req_config.format;
+}
+
+static int out_set_format(struct audio_stream *stream, audio_format_t format) {
+    return -ENOSYS;
+}
+
+static int out_dump(const struct audio_stream *stream, int fd) {
+    struct generic_stream_out *out = (struct generic_stream_out *)stream;
+    pthread_mutex_lock(&out->lock);
+    dprintf(fd, "\tout_dump:\n"
+                "\t\taddress: %s\n"
+                "\t\tsample rate: %u\n"
+                "\t\tbuffer size: %zu\n"
+                "\t\tchannel mask: %08x\n"
+                "\t\tformat: %d\n"
+                "\t\tdevice: %08x\n"
+                "\t\tamplitude ratio: %f\n"
+                "\t\tenabled channels: %d\n"
+                "\t\taudio dev: %p\n\n",
+                out->bus_address,
+                out_get_sample_rate(stream),
+                out_get_buffer_size(stream),
+                out_get_channels(stream),
+                out_get_format(stream),
+                out->device,
+                out->amplitude_ratio,
+                out->enabled_channels,
+                out->dev);
+    pthread_mutex_unlock(&out->lock);
+    return 0;
+}
+
+static int out_set_parameters(struct audio_stream *stream, const char *kvpairs) {
+    struct generic_stream_out *out = (struct generic_stream_out *)stream;
+    struct str_parms *parms;
+    int ret = 0;
+
+    pthread_mutex_lock(&out->lock);
+    if (!out->standby) {
+        //Do not support changing params while stream running
+        ret = -ENOSYS;
+    } else {
+        parms = str_parms_create_str(kvpairs);
+        int val = 0;
+        ret = get_int_value(parms, AUDIO_PARAMETER_STREAM_ROUTING, &val);
+        if (ret >= 0) {
+            out->device = (int)val;
+            ret = 0;
+        }
+        str_parms_destroy(parms);
+    }
+    pthread_mutex_unlock(&out->lock);
+    return ret;
+}
+
+static char *out_get_parameters(const struct audio_stream *stream, const char *keys) {
+    struct generic_stream_out *out = (struct generic_stream_out *)stream;
+    struct str_parms *query = str_parms_create_str(keys);
+    char *str;
+    char value[256];
+    struct str_parms *reply = str_parms_create();
+    int ret;
+
+    ret = str_parms_get_str(query, AUDIO_PARAMETER_STREAM_ROUTING, value, sizeof(value));
+    if (ret >= 0) {
+        pthread_mutex_lock(&out->lock);
+        str_parms_add_int(reply, AUDIO_PARAMETER_STREAM_ROUTING, out->device);
+        pthread_mutex_unlock(&out->lock);
+        str = strdup(str_parms_to_str(reply));
+    } else {
+        str = strdup(keys);
+    }
+
+    str_parms_destroy(query);
+    str_parms_destroy(reply);
+    return str;
+}
+
+static uint32_t out_get_latency(const struct audio_stream_out *stream) {
+    struct generic_stream_out *out = (struct generic_stream_out *)stream;
+    return (out->pcm_config.period_size * 1000) / out->pcm_config.rate;
+}
+
+static int out_set_volume(struct audio_stream_out *stream,
+        float left, float right) {
+    return -ENOSYS;
+}
+
+static int get_zone_id_from_address(const char *address) {
+    int zone_id = INVALID_ZONE_ID;
+    char *zone_start = strstr(address, AUDIO_ZONE_KEYWORD);
+    if (zone_start) {
+        char *end = NULL;
+        zone_id = strtol(zone_start + strlen(AUDIO_ZONE_KEYWORD), &end, 10);
+        if (end == NULL || zone_id < 0) {
+            return INVALID_ZONE_ID;
+        }
+    }
+    return zone_id;
+}
+
+static void *out_write_worker(void *args) {
+    struct generic_stream_out *out = (struct generic_stream_out *)args;
+    struct ext_pcm *ext_pcm = NULL;
+    uint8_t *buffer = NULL;
+    int buffer_frames;
+    int buffer_size;
+    bool restart = false;
+    bool shutdown = false;
+    int zone_id = PRIMARY_ZONE_ID;
+    // If it is a audio zone keyword bus address then get zone id
+    if (strstr(out->bus_address, AUDIO_ZONE_KEYWORD)) {
+        zone_id = get_zone_id_from_address(out->bus_address);
+        if (zone_id == INVALID_ZONE_ID) {
+            ALOGE("%s Found invalid zone id, defaulting device %s to zone %d", __func__,
+                out->bus_address, DEFAULT_ZONE_TO_LEFT_SPEAKER);
+            zone_id = DEFAULT_ZONE_TO_LEFT_SPEAKER;
+        }
+    }
+    ALOGD("Out worker:%s zone id %d", out->bus_address, zone_id);
+
+    while (true) {
+        pthread_mutex_lock(&out->lock);
+        while (out->worker_standby || restart) {
+            restart = false;
+            if (ext_pcm) {
+                ext_pcm_close(ext_pcm); // Frees pcm
+                ext_pcm = NULL;
+                free(buffer);
+                buffer=NULL;
+            }
+            if (out->worker_exit) {
+                break;
+            }
+            pthread_cond_wait(&out->worker_wake, &out->lock);
+        }
+
+        if (out->worker_exit) {
+            if (!out->worker_standby) {
+                ALOGE("Out worker:%s not in standby before exiting", out->bus_address);
+            }
+            shutdown = true;
+        }
+
+        while (!shutdown && audio_vbuffer_live(&out->buffer) == 0) {
+            pthread_cond_wait(&out->worker_wake, &out->lock);
+        }
+
+        if (shutdown) {
+            pthread_mutex_unlock(&out->lock);
+            break;
+        }
+
+        if (!ext_pcm) {
+            ext_pcm = ext_pcm_open(PCM_CARD, PCM_DEVICE,
+                    PCM_OUT | PCM_MONOTONIC, &out->pcm_config);
+            if (!ext_pcm_is_ready(ext_pcm)) {
+                ALOGE("pcm_open(out) failed: %s: address %s channels %d format %d rate %d",
+                        ext_pcm_get_error(ext_pcm),
+                        out->bus_address,
+                        out->pcm_config.channels,
+                        out->pcm_config.format,
+                        out->pcm_config.rate);
+                pthread_mutex_unlock(&out->lock);
+                break;
+            }
+            buffer_frames = out->pcm_config.period_size;
+            buffer_size = ext_pcm_frames_to_bytes(ext_pcm, buffer_frames);
+            buffer = malloc(buffer_size);
+            if (!buffer) {
+                ALOGE("could not allocate write buffer");
+                pthread_mutex_unlock(&out->lock);
+                break;
+            }
+        }
+        int frames = audio_vbuffer_read(&out->buffer, buffer, buffer_frames);
+        pthread_mutex_unlock(&out->lock);
+
+        if (is_zone_selected_to_play(out->dev, zone_id)) {
+            int write_error = ext_pcm_write(ext_pcm, out->bus_address,
+                buffer, ext_pcm_frames_to_bytes(ext_pcm, frames));
+            if (write_error) {
+                ALOGE("pcm_write failed %s address %s",
+                    ext_pcm_get_error(ext_pcm), out->bus_address);
+                restart = true;
+            } else {
+                ALOGV("pcm_write succeed address %s", out->bus_address);
+            }
+        }
+    }
+    if (buffer) {
+        free(buffer);
+    }
+
+    return NULL;
+}
+
+// Call with in->lock held
+static void get_current_output_position(struct generic_stream_out *out,
+        uint64_t *position, struct timespec * timestamp) {
+    struct timespec curtime = { .tv_sec = 0, .tv_nsec = 0 };
+    clock_gettime(CLOCK_MONOTONIC, &curtime);
+    const int64_t now_us = (curtime.tv_sec * 1000000000LL + curtime.tv_nsec) / 1000;
+    if (timestamp) {
+        *timestamp = curtime;
+    }
+    int64_t position_since_underrun;
+    if (out->standby) {
+        position_since_underrun = 0;
+    } else {
+        const int64_t first_us = (out->underrun_time.tv_sec * 1000000000LL +
+                                  out->underrun_time.tv_nsec) / 1000;
+        position_since_underrun = (now_us - first_us) *
+                out_get_sample_rate(&out->stream.common) /
+                1000000;
+        if (position_since_underrun < 0) {
+            position_since_underrun = 0;
+        }
+    }
+    *position = out->underrun_position + position_since_underrun;
+
+    // The device will reuse the same output stream leading to periods of
+    // underrun.
+    if (*position > out->frames_written) {
+        ALOGW("Not supplying enough data to HAL, expected position %" PRIu64 " , only wrote "
+              "%" PRIu64,
+              *position, out->frames_written);
+
+        *position = out->frames_written;
+        out->underrun_position = *position;
+        out->underrun_time = curtime;
+        out->frames_total_buffered = 0;
+    }
+}
+
+// Applies gain naively, assumes AUDIO_FORMAT_PCM_16_BIT and stereo output
+static void out_apply_gain(struct generic_stream_out *out, const void *buffer, size_t bytes) {
+    int16_t *int16_buffer = (int16_t *)buffer;
+    size_t int16_size = bytes / sizeof(int16_t);
+    for (int i = 0; i < int16_size; i++) {
+        if ((i % 2) && !(out->enabled_channels & RIGHT_CHANNEL)) {
+            int16_buffer[i] = 0;
+        } else if (!(i % 2) && !(out->enabled_channels & LEFT_CHANNEL)) {
+            int16_buffer[i] = 0;
+        } else {
+            float multiplied = int16_buffer[i] * out->amplitude_ratio;
+            if (multiplied > INT16_MAX) int16_buffer[i] = INT16_MAX;
+            else if (multiplied < INT16_MIN) int16_buffer[i] = INT16_MIN;
+            else int16_buffer[i] = (int16_t)multiplied;
+        }
+    }
+}
+
+static ssize_t out_write(struct audio_stream_out *stream, const void *buffer, size_t bytes) {
+    struct generic_stream_out *out = (struct generic_stream_out *)stream;
+    ALOGV("%s: to device %s", __func__, out->bus_address);
+    const size_t frames =  bytes / audio_stream_out_frame_size(stream);
+
+    pthread_mutex_lock(&out->lock);
+
+    if (out->worker_standby) {
+        out->worker_standby = false;
+    }
+
+    uint64_t current_position;
+    struct timespec current_time;
+
+    get_current_output_position(out, &current_position, &current_time);
+    const uint64_t now_us = (current_time.tv_sec * 1000000000LL +
+                             current_time.tv_nsec) / 1000;
+    if (out->standby) {
+        out->standby = false;
+        out->underrun_time = current_time;
+        out->frames_rendered = 0;
+        out->frames_total_buffered = 0;
+    }
+
+    size_t frames_written = frames;
+    if (out->dev->master_mute) {
+        ALOGV("%s: ignored due to master mute", __func__);
+    } else {
+        out_apply_gain(out, buffer, bytes);
+        frames_written = audio_vbuffer_write(&out->buffer, buffer, frames);
+        pthread_cond_signal(&out->worker_wake);
+    }
+
+    /* Implementation just consumes bytes if we start getting backed up */
+    out->frames_written += frames;
+    out->frames_rendered += frames;
+    out->frames_total_buffered += frames;
+
+    // We simulate the audio device blocking when it's write buffers become
+    // full.
+
+    // At the beginning or after an underrun, try to fill up the vbuffer.
+    // This will be throttled by the PlaybackThread
+    int frames_sleep = out->frames_total_buffered < out->buffer.frame_count ? 0 : frames;
+
+    uint64_t sleep_time_us = frames_sleep * 1000000LL /
+                            out_get_sample_rate(&stream->common);
+
+    // If the write calls are delayed, subtract time off of the sleep to
+    // compensate
+    uint64_t time_since_last_write_us = now_us - out->last_write_time_us;
+    if (time_since_last_write_us < sleep_time_us) {
+        sleep_time_us -= time_since_last_write_us;
+    } else {
+        sleep_time_us = 0;
+    }
+    out->last_write_time_us = now_us + sleep_time_us;
+
+    pthread_mutex_unlock(&out->lock);
+
+    if (sleep_time_us > 0) {
+        usleep(sleep_time_us);
+    }
+
+    if (frames_written < frames) {
+        ALOGW("%s Hardware backing HAL too slow, could only write %zu of %zu frames",
+            __func__, frames_written, frames);
+    }
+
+    /* Always consume all bytes */
+    return bytes;
+}
+
+static int out_get_presentation_position(const struct audio_stream_out *stream,
+        uint64_t *frames, struct timespec *timestamp) {
+    int ret = -EINVAL;
+    if (stream == NULL || frames == NULL || timestamp == NULL) {
+        return -EINVAL;
+    }
+    struct generic_stream_out *out = (struct generic_stream_out *)stream;
+
+    pthread_mutex_lock(&out->lock);
+    get_current_output_position(out, frames, timestamp);
+    pthread_mutex_unlock(&out->lock);
+
+    return 0;
+}
+
+static int out_get_render_position(const struct audio_stream_out *stream, uint32_t *dsp_frames) {
+    if (stream == NULL || dsp_frames == NULL) {
+        return -EINVAL;
+    }
+    struct generic_stream_out *out = (struct generic_stream_out *)stream;
+    pthread_mutex_lock(&out->lock);
+    *dsp_frames = out->frames_rendered;
+    pthread_mutex_unlock(&out->lock);
+    return 0;
+}
+
+// Must be called with out->lock held
+static void do_out_standby(struct generic_stream_out *out) {
+    int frames_sleep = 0;
+    uint64_t sleep_time_us = 0;
+    if (out->standby) {
+        return;
+    }
+    while (true) {
+        get_current_output_position(out, &out->underrun_position, NULL);
+        frames_sleep = out->frames_written - out->underrun_position;
+
+        if (frames_sleep == 0) {
+            break;
+        }
+
+        sleep_time_us = frames_sleep * 1000000LL /
+                        out_get_sample_rate(&out->stream.common);
+
+        pthread_mutex_unlock(&out->lock);
+        usleep(sleep_time_us);
+        pthread_mutex_lock(&out->lock);
+    }
+    out->worker_standby = true;
+    out->standby = true;
+}
+
+static int out_standby(struct audio_stream *stream) {
+    struct generic_stream_out *out = (struct generic_stream_out *)stream;
+    pthread_mutex_lock(&out->lock);
+    do_out_standby(out);
+    pthread_mutex_unlock(&out->lock);
+    return 0;
+}
+
+static int out_add_audio_effect(const struct audio_stream *stream, effect_handle_t effect) {
+    // out_add_audio_effect is a no op
+    return 0;
+}
+
+static int out_remove_audio_effect(const struct audio_stream *stream, effect_handle_t effect) {
+    // out_remove_audio_effect is a no op
+    return 0;
+}
+
+static int out_get_next_write_timestamp(const struct audio_stream_out *stream,
+        int64_t *timestamp) {
+    return -ENOSYS;
+}
+
+static uint32_t in_get_sample_rate(const struct audio_stream *stream) {
+    struct generic_stream_in *in = (struct generic_stream_in *)stream;
+    return in->req_config.sample_rate;
+}
+
+static int in_set_sample_rate(struct audio_stream *stream, uint32_t rate) {
+    return -ENOSYS;
+}
+
+static int refine_output_parameters(uint32_t *sample_rate, audio_format_t *format,
+        audio_channel_mask_t *channel_mask) {
+    static const uint32_t sample_rates [] = {
+        8000, 11025, 16000, 22050, 24000, 32000, 44100, 48000
+    };
+    static const int sample_rates_count = sizeof(sample_rates)/sizeof(uint32_t);
+    bool inval = false;
+    if (*format != AUDIO_FORMAT_PCM_16_BIT) {
+        *format = AUDIO_FORMAT_PCM_16_BIT;
+        inval = true;
+    }
+
+    int channel_count = popcount(*channel_mask);
+    if (channel_count != 1 && channel_count != 2) {
+        *channel_mask = AUDIO_CHANNEL_IN_STEREO;
+        inval = true;
+    }
+
+    int i;
+    for (i = 0; i < sample_rates_count; i++) {
+        if (*sample_rate < sample_rates[i]) {
+            *sample_rate = sample_rates[i];
+            inval=true;
+            break;
+        }
+        else if (*sample_rate == sample_rates[i]) {
+            break;
+        }
+        else if (i == sample_rates_count-1) {
+            // Cap it to the highest rate we support
+            *sample_rate = sample_rates[i];
+            inval=true;
+        }
+    }
+
+    if (inval) {
+        return -EINVAL;
+    }
+    return 0;
+}
+
+static int refine_input_parameters(uint32_t *sample_rate, audio_format_t *format,
+        audio_channel_mask_t *channel_mask) {
+    static const uint32_t sample_rates [] = {
+        8000, 11025, 16000, 22050, 44100, 48000
+    };
+    static const int sample_rates_count = sizeof(sample_rates)/sizeof(uint32_t);
+    bool inval = false;
+    // Only PCM_16_bit is supported. If this is changed, stereo to mono drop
+    // must be fixed in in_read
+    if (*format != AUDIO_FORMAT_PCM_16_BIT) {
+        *format = AUDIO_FORMAT_PCM_16_BIT;
+        inval = true;
+    }
+
+    int channel_count = popcount(*channel_mask);
+    if (channel_count != 1 && channel_count != 2) {
+        *channel_mask = AUDIO_CHANNEL_IN_STEREO;
+        inval = true;
+    }
+
+    int i;
+    for (i = 0; i < sample_rates_count; i++) {
+        if (*sample_rate < sample_rates[i]) {
+            *sample_rate = sample_rates[i];
+            inval=true;
+            break;
+        }
+        else if (*sample_rate == sample_rates[i]) {
+            break;
+        }
+        else if (i == sample_rates_count-1) {
+            // Cap it to the highest rate we support
+            *sample_rate = sample_rates[i];
+            inval=true;
+        }
+    }
+
+    if (inval) {
+        return -EINVAL;
+    }
+    return 0;
+}
+
+static size_t get_input_buffer_size(uint32_t sample_rate, audio_format_t format,
+        audio_channel_mask_t channel_mask) {
+    size_t size;
+    size_t device_rate;
+    int channel_count = popcount(channel_mask);
+    if (refine_input_parameters(&sample_rate, &format, &channel_mask) != 0)
+        return 0;
+
+    size = sample_rate*IN_PERIOD_MS/1000;
+    // Audioflinger expects audio buffers to be multiple of 16 frames
+    size = ((size + 15) / 16) * 16;
+    size *= sizeof(short) * channel_count;
+
+    return size;
+}
+
+static size_t in_get_buffer_size(const struct audio_stream *stream) {
+    struct generic_stream_in *in = (struct generic_stream_in *)stream;
+    int size = get_input_buffer_size(in->req_config.sample_rate,
+                                 in->req_config.format,
+                                 in->req_config.channel_mask);
+
+    return size;
+}
+
+static audio_channel_mask_t in_get_channels(const struct audio_stream *stream) {
+    struct generic_stream_in *in = (struct generic_stream_in *)stream;
+    return in->req_config.channel_mask;
+}
+
+static audio_format_t in_get_format(const struct audio_stream *stream) {
+    struct generic_stream_in *in = (struct generic_stream_in *)stream;
+    return in->req_config.format;
+}
+
+static int in_set_format(struct audio_stream *stream, audio_format_t format) {
+    return -ENOSYS;
+}
+
+static int in_dump(const struct audio_stream *stream, int fd) {
+    struct generic_stream_in *in = (struct generic_stream_in *)stream;
+
+    pthread_mutex_lock(&in->lock);
+    dprintf(fd, "\tin_dump:\n"
+                "\t\tsample rate: %u\n"
+                "\t\tbuffer size: %zu\n"
+                "\t\tchannel mask: %08x\n"
+                "\t\tformat: %d\n"
+                "\t\tdevice: %08x\n"
+                "\t\taudio dev: %p\n\n",
+                in_get_sample_rate(stream),
+                in_get_buffer_size(stream),
+                in_get_channels(stream),
+                in_get_format(stream),
+                in->device,
+                in->dev);
+    pthread_mutex_unlock(&in->lock);
+    return 0;
+}
+
+static int in_set_parameters(struct audio_stream *stream, const char *kvpairs) {
+    struct generic_stream_in *in = (struct generic_stream_in *)stream;
+    struct str_parms *parms;
+    int ret = 0;
+
+    pthread_mutex_lock(&in->lock);
+    if (!in->standby) {
+        ret = -ENOSYS;
+    } else {
+        parms = str_parms_create_str(kvpairs);
+        int val = 0;
+        ret = get_int_value(parms, AUDIO_PARAMETER_STREAM_ROUTING, &val);
+        if (ret >= 0) {
+            in->device = (int)val;
+            ret = 0;
+        }
+
+        str_parms_destroy(parms);
+    }
+    pthread_mutex_unlock(&in->lock);
+    return ret;
+}
+
+static char *in_get_parameters(const struct audio_stream *stream, const char *keys) {
+    struct generic_stream_in *in = (struct generic_stream_in *)stream;
+    struct str_parms *query = str_parms_create_str(keys);
+    char *str;
+    char value[256];
+    struct str_parms *reply = str_parms_create();
+    int ret;
+
+    ret = str_parms_get_str(query, AUDIO_PARAMETER_STREAM_ROUTING, value, sizeof(value));
+    if (ret >= 0) {
+        str_parms_add_int(reply, AUDIO_PARAMETER_STREAM_ROUTING, in->device);
+        str = strdup(str_parms_to_str(reply));
+    } else {
+        str = strdup(keys);
+    }
+
+    str_parms_destroy(query);
+    str_parms_destroy(reply);
+    return str;
+}
+
+static int in_set_gain(struct audio_stream_in *stream, float gain) {
+    // TODO(hwwang): support adjusting input gain
+    return 0;
+}
+
+// Call with in->lock held
+static void get_current_input_position(struct generic_stream_in *in,
+        int64_t * position, struct timespec * timestamp) {
+    struct timespec t = { .tv_sec = 0, .tv_nsec = 0 };
+    clock_gettime(CLOCK_MONOTONIC, &t);
+    const int64_t now_us = (t.tv_sec * 1000000000LL + t.tv_nsec) / 1000;
+    if (timestamp) {
+        *timestamp = t;
+    }
+    int64_t position_since_standby;
+    if (in->standby) {
+        position_since_standby = 0;
+    } else {
+        const int64_t first_us = (in->standby_exit_time.tv_sec * 1000000000LL +
+                                  in->standby_exit_time.tv_nsec) / 1000;
+        position_since_standby = (now_us - first_us) *
+                in_get_sample_rate(&in->stream.common) /
+                1000000;
+        if (position_since_standby < 0) {
+            position_since_standby = 0;
+        }
+    }
+    *position = in->standby_position + position_since_standby;
+}
+
+// Must be called with in->lock held
+static void do_in_standby(struct generic_stream_in *in) {
+    if (in->standby) {
+        return;
+    }
+    in->worker_standby = true;
+    get_current_input_position(in, &in->standby_position, NULL);
+    in->standby = true;
+}
+
+static int in_standby(struct audio_stream *stream) {
+    struct generic_stream_in *in = (struct generic_stream_in *)stream;
+    pthread_mutex_lock(&in->lock);
+    do_in_standby(in);
+    pthread_mutex_unlock(&in->lock);
+    return 0;
+}
+
+// Generates pure tone for FM_TUNER and bus_device
+static int pseudo_pcm_read(void *data, unsigned int count, struct oscillator *oscillator) {
+    unsigned int length = count / sizeof(int16_t);
+    int16_t *sdata = (int16_t *)data;
+    for (int index = 0; index < length; index++) {
+        sdata[index] = (int16_t)(sin(oscillator->phase) * 4096);
+        oscillator->phase += oscillator->phase_increment;
+        oscillator->phase = oscillator->phase > TWO_PI ?
+            oscillator->phase - TWO_PI : oscillator->phase;
+    }
+
+    return count;
+}
+
+static void *in_read_worker(void *args) {
+    struct generic_stream_in *in = (struct generic_stream_in *)args;
+    struct pcm *pcm = NULL;
+    uint8_t *buffer = NULL;
+    size_t buffer_frames;
+    int buffer_size;
+
+    bool restart = false;
+    bool shutdown = false;
+    while (true) {
+        pthread_mutex_lock(&in->lock);
+        while (in->worker_standby || restart) {
+            restart = false;
+            if (pcm) {
+                pcm_close(pcm); // Frees pcm
+                pcm = NULL;
+                free(buffer);
+                buffer=NULL;
+            }
+            if (in->worker_exit) {
+                break;
+            }
+            pthread_cond_wait(&in->worker_wake, &in->lock);
+        }
+
+        if (in->worker_exit) {
+            if (!in->worker_standby) {
+                ALOGE("In worker not in standby before exiting");
+            }
+            shutdown = true;
+        }
+        if (shutdown) {
+            pthread_mutex_unlock(&in->lock);
+            break;
+        }
+        if (!pcm) {
+            pcm = pcm_open(PCM_CARD, PCM_DEVICE,
+                    PCM_IN | PCM_MONOTONIC, &in->pcm_config);
+            if (!pcm_is_ready(pcm)) {
+                ALOGE("pcm_open(in) failed: %s: channels %d format %d rate %d",
+                        pcm_get_error(pcm),
+                        in->pcm_config.channels,
+                        in->pcm_config.format,
+                        in->pcm_config.rate);
+                pthread_mutex_unlock(&in->lock);
+                break;
+            }
+            buffer_frames = in->pcm_config.period_size;
+            buffer_size = pcm_frames_to_bytes(pcm, buffer_frames);
+            buffer = malloc(buffer_size);
+            if (!buffer) {
+                ALOGE("could not allocate worker read buffer");
+                pthread_mutex_unlock(&in->lock);
+                break;
+            }
+        }
+        pthread_mutex_unlock(&in->lock);
+        int ret = pcm_read(pcm, buffer, pcm_frames_to_bytes(pcm, buffer_frames));
+        if (ret != 0) {
+            ALOGW("pcm_read failed %s", pcm_get_error(pcm));
+            restart = true;
+        }
+
+        pthread_mutex_lock(&in->lock);
+        size_t frames_written = audio_vbuffer_write(&in->buffer, buffer, buffer_frames);
+        pthread_mutex_unlock(&in->lock);
+
+        if (frames_written != buffer_frames) {
+            ALOGW("in_read_worker only could write %zu / %zu frames",
+                    frames_written, buffer_frames);
+        }
+    }
+    if (buffer) {
+        free(buffer);
+    }
+    return NULL;
+}
+
+static bool address_has_tone_keyword(char * address) {
+    return strstr(address, TONE_ADDRESS_KEYWORD) != NULL;
+}
+
+static bool is_tone_generator_device(struct generic_stream_in *in) {
+    return in->device == AUDIO_DEVICE_IN_FM_TUNER || ((in->device == AUDIO_DEVICE_IN_BUS) &&
+        address_has_tone_keyword(in->bus_address));
+}
+
+static ssize_t in_read(struct audio_stream_in *stream, void *buffer, size_t bytes) {
+    struct generic_stream_in *in = (struct generic_stream_in *)stream;
+    struct generic_audio_device *adev = in->dev;
+    const size_t frames =  bytes / audio_stream_in_frame_size(stream);
+    int ret = 0;
+    bool mic_mute = false;
+    size_t read_bytes = 0;
+
+    adev_get_mic_mute(&adev->device, &mic_mute);
+    pthread_mutex_lock(&in->lock);
+
+    if (in->worker_standby) {
+        in->worker_standby = false;
+    }
+
+    // Tone generators fill the buffer via pseudo_pcm_read directly
+    if (!is_tone_generator_device(in)) {
+        pthread_cond_signal(&in->worker_wake);
+    }
+
+    int64_t current_position;
+    struct timespec current_time;
+
+    get_current_input_position(in, &current_position, &current_time);
+    if (in->standby) {
+        in->standby = false;
+        in->standby_exit_time = current_time;
+        in->standby_frames_read = 0;
+    }
+
+    const int64_t frames_available =
+        current_position - in->standby_position - in->standby_frames_read;
+    assert(frames_available >= 0);
+
+    const size_t frames_wait =
+        ((uint64_t)frames_available > frames) ? 0 : frames - frames_available;
+
+    int64_t sleep_time_us  = frames_wait * 1000000LL / in_get_sample_rate(&stream->common);
+
+    pthread_mutex_unlock(&in->lock);
+
+    if (sleep_time_us > 0) {
+        usleep(sleep_time_us);
+    }
+
+    pthread_mutex_lock(&in->lock);
+    int read_frames = 0;
+    if (in->standby) {
+        ALOGW("Input put to sleep while read in progress");
+        goto exit;
+    }
+    in->standby_frames_read += frames;
+
+    if (is_tone_generator_device(in)) {
+        int read_bytes = pseudo_pcm_read(buffer, bytes, &in->oscillator);
+        read_frames = read_bytes / audio_stream_in_frame_size(stream);
+    } else if (popcount(in->req_config.channel_mask) == 1 &&
+        in->pcm_config.channels == 2) {
+        // Need to resample to mono
+        if (in->stereo_to_mono_buf_size < bytes*2) {
+            in->stereo_to_mono_buf = realloc(in->stereo_to_mono_buf, bytes*2);
+            if (!in->stereo_to_mono_buf) {
+                ALOGE("Failed to allocate stereo_to_mono_buff");
+                goto exit;
+            }
+        }
+
+        read_frames = audio_vbuffer_read(&in->buffer, in->stereo_to_mono_buf, frames);
+
+        // Currently only pcm 16 is supported.
+        uint16_t *src = (uint16_t *)in->stereo_to_mono_buf;
+        uint16_t *dst = (uint16_t *)buffer;
+        size_t i;
+        // Resample stereo 16 to mono 16 by dropping one channel.
+        // The stereo stream is interleaved L-R-L-R
+        for (i = 0; i < frames; i++) {
+            *dst = *src;
+            src += 2;
+            dst += 1;
+        }
+    } else {
+        read_frames = audio_vbuffer_read(&in->buffer, buffer, frames);
+    }
+
+exit:
+    read_bytes = read_frames*audio_stream_in_frame_size(stream);
+
+    if (mic_mute) {
+        read_bytes = 0;
+    }
+
+    if (read_bytes < bytes) {
+        memset (&((uint8_t *)buffer)[read_bytes], 0, bytes-read_bytes);
+    }
+
+    pthread_mutex_unlock(&in->lock);
+
+    return bytes;
+}
+
+static uint32_t in_get_input_frames_lost(struct audio_stream_in *stream) {
+    return 0;
+}
+
+static int in_get_capture_position(const struct audio_stream_in *stream,
+        int64_t *frames, int64_t *time) {
+    struct generic_stream_in *in = (struct generic_stream_in *)stream;
+    pthread_mutex_lock(&in->lock);
+    struct timespec current_time;
+    get_current_input_position(in, frames, &current_time);
+    *time = (current_time.tv_sec * 1000000000LL + current_time.tv_nsec);
+    pthread_mutex_unlock(&in->lock);
+    return 0;
+}
+
+static int in_add_audio_effect(const struct audio_stream *stream, effect_handle_t effect) {
+    // in_add_audio_effect is a no op
+    return 0;
+}
+
+static int in_remove_audio_effect(const struct audio_stream *stream, effect_handle_t effect) {
+    // in_add_audio_effect is a no op
+    return 0;
+}
+
+static int adev_open_output_stream(struct audio_hw_device *dev,
+        audio_io_handle_t handle, audio_devices_t devices, audio_output_flags_t flags,
+        struct audio_config *config, struct audio_stream_out **stream_out, const char *address) {
+    struct generic_audio_device *adev = (struct generic_audio_device *)dev;
+    struct generic_stream_out *out;
+    int ret = 0;
+
+    if (refine_output_parameters(&config->sample_rate, &config->format, &config->channel_mask)) {
+        ALOGE("Error opening output stream format %d, channel_mask %04x, sample_rate %u",
+              config->format, config->channel_mask, config->sample_rate);
+        ret = -EINVAL;
+        goto error;
+    }
+
+    out = (struct generic_stream_out *)calloc(1, sizeof(struct generic_stream_out));
+
+    if (!out)
+        return -ENOMEM;
+
+    out->stream.common.get_sample_rate = out_get_sample_rate;
+    out->stream.common.set_sample_rate = out_set_sample_rate;
+    out->stream.common.get_buffer_size = out_get_buffer_size;
+    out->stream.common.get_channels = out_get_channels;
+    out->stream.common.get_format = out_get_format;
+    out->stream.common.set_format = out_set_format;
+    out->stream.common.standby = out_standby;
+    out->stream.common.dump = out_dump;
+    out->stream.common.set_parameters = out_set_parameters;
+    out->stream.common.get_parameters = out_get_parameters;
+    out->stream.common.add_audio_effect = out_add_audio_effect;
+    out->stream.common.remove_audio_effect = out_remove_audio_effect;
+    out->stream.get_latency = out_get_latency;
+    out->stream.set_volume = out_set_volume;
+    out->stream.write = out_write;
+    out->stream.get_render_position = out_get_render_position;
+    out->stream.get_presentation_position = out_get_presentation_position;
+    out->stream.get_next_write_timestamp = out_get_next_write_timestamp;
+
+    pthread_mutex_init(&out->lock, (const pthread_mutexattr_t *) NULL);
+    out->dev = adev;
+    out->device = devices;
+    memcpy(&out->req_config, config, sizeof(struct audio_config));
+    memcpy(&out->pcm_config, &pcm_config_out, sizeof(struct pcm_config));
+    out->pcm_config.rate = config->sample_rate;
+    out->pcm_config.period_size = out->pcm_config.rate*OUT_PERIOD_MS/1000;
+
+    out->standby = true;
+    out->underrun_position = 0;
+    out->underrun_time.tv_sec = 0;
+    out->underrun_time.tv_nsec = 0;
+    out->last_write_time_us = 0;
+    out->frames_total_buffered = 0;
+    out->frames_written = 0;
+    out->frames_rendered = 0;
+
+    ret = audio_vbuffer_init(&out->buffer,
+            out->pcm_config.period_size*out->pcm_config.period_count,
+            out->pcm_config.channels *
+            pcm_format_to_bits(out->pcm_config.format) >> 3);
+    if (ret == 0) {
+        pthread_cond_init(&out->worker_wake, NULL);
+        out->worker_standby = true;
+        out->worker_exit = false;
+        pthread_create(&out->worker_thread, NULL, out_write_worker, out);
+    }
+
+    out->enabled_channels = BOTH_CHANNELS;
+    if (address) {
+        out->bus_address = calloc(strlen(address) + 1, sizeof(char));
+        strncpy(out->bus_address, address, strlen(address));
+        hashmapPut(adev->out_bus_stream_map, out->bus_address, out);
+        /* TODO: read struct audio_gain from audio_policy_configuration */
+        out->gain_stage = (struct audio_gain) {
+            .min_value = -3200,
+            .max_value = 600,
+            .step_value = 100,
+        };
+        out->amplitude_ratio = 1.0;
+        if (property_get_bool(PROP_KEY_SIMULATE_MULTI_ZONE_AUDIO, false)) {
+            out->enabled_channels = strstr(out->bus_address, AUDIO_ZONE_KEYWORD)
+                ? RIGHT_CHANNEL: LEFT_CHANNEL;
+            ALOGD("%s Routing %s to %s channel", __func__,
+             out->bus_address, out->enabled_channels == RIGHT_CHANNEL ? "Right" : "Left");
+        }
+    }
+    *stream_out = &out->stream;
+    ALOGD("%s bus: %s", __func__, out->bus_address);
+
+error:
+    return ret;
+}
+
+static void adev_close_output_stream(struct audio_hw_device *dev,
+        struct audio_stream_out *stream) {
+    struct generic_audio_device *adev = (struct generic_audio_device *)dev;
+    struct generic_stream_out *out = (struct generic_stream_out *)stream;
+    ALOGD("%s bus:%s", __func__, out->bus_address);
+    pthread_mutex_lock(&out->lock);
+    do_out_standby(out);
+
+    out->worker_exit = true;
+    pthread_cond_signal(&out->worker_wake);
+    pthread_mutex_unlock(&out->lock);
+
+    pthread_join(out->worker_thread, NULL);
+    pthread_mutex_destroy(&out->lock);
+    audio_vbuffer_destroy(&out->buffer);
+
+    if (out->bus_address) {
+        hashmapRemove(adev->out_bus_stream_map, out->bus_address);
+        free(out->bus_address);
+    }
+    free(stream);
+}
+
+static int adev_set_parameters(struct audio_hw_device *dev, const char *kvpairs) {
+    struct generic_audio_device *adev = (struct generic_audio_device *)dev;
+    pthread_mutex_lock(&adev->lock);
+    struct str_parms *parms = str_parms_create_str(kvpairs);
+    int value = 0;
+    int results = get_int_value(parms, AAE_PARAMETER_KEY_FOR_SELECTED_ZONE, &value);
+    if (results >= 0) {
+        adev->last_zone_selected_to_play = value;
+        results = 0;
+        ALOGD("%s Changed play zone id to %d", __func__, adev->last_zone_selected_to_play);
+    }
+    str_parms_destroy(parms);
+    pthread_mutex_unlock(&adev->lock);
+    return results;
+}
+
+static char *adev_get_parameters(const struct audio_hw_device * dev, const char *keys) {
+    return NULL;
+}
+
+static int adev_init_check(const struct audio_hw_device *dev) {
+    return 0;
+}
+
+static int adev_set_voice_volume(struct audio_hw_device *dev, float volume) {
+    // adev_set_voice_volume is a no op (simulates phones)
+    return 0;
+}
+
+static int adev_set_master_volume(struct audio_hw_device *dev, float volume) {
+    return -ENOSYS;
+}
+
+static int adev_get_master_volume(struct audio_hw_device *dev, float *volume) {
+    return -ENOSYS;
+}
+
+static int adev_set_master_mute(struct audio_hw_device *dev, bool muted) {
+    ALOGD("%s: %s", __func__, _bool_str(muted));
+    struct generic_audio_device *adev = (struct generic_audio_device *)dev;
+    pthread_mutex_lock(&adev->lock);
+    adev->master_mute = muted;
+    pthread_mutex_unlock(&adev->lock);
+    return 0;
+}
+
+static int adev_get_master_mute(struct audio_hw_device *dev, bool *muted) {
+    struct generic_audio_device *adev = (struct generic_audio_device *)dev;
+    pthread_mutex_lock(&adev->lock);
+    *muted = adev->master_mute;
+    pthread_mutex_unlock(&adev->lock);
+    ALOGD("%s: %s", __func__, _bool_str(*muted));
+    return 0;
+}
+
+static int adev_set_mode(struct audio_hw_device *dev, audio_mode_t mode) {
+    // adev_set_mode is a no op (simulates phones)
+    return 0;
+}
+
+static int adev_set_mic_mute(struct audio_hw_device *dev, bool state) {
+    struct generic_audio_device *adev = (struct generic_audio_device *)dev;
+    pthread_mutex_lock(&adev->lock);
+    adev->mic_mute = state;
+    pthread_mutex_unlock(&adev->lock);
+    return 0;
+}
+
+static int adev_get_mic_mute(const struct audio_hw_device *dev, bool *state) {
+    struct generic_audio_device *adev = (struct generic_audio_device *)dev;
+    pthread_mutex_lock(&adev->lock);
+    *state = adev->mic_mute;
+    pthread_mutex_unlock(&adev->lock);
+    return 0;
+}
+
+static size_t adev_get_input_buffer_size(const struct audio_hw_device *dev,
+        const struct audio_config *config) {
+    return get_input_buffer_size(config->sample_rate, config->format, config->channel_mask);
+}
+
+static void adev_close_input_stream(struct audio_hw_device *dev,
+        struct audio_stream_in *stream) {
+    struct generic_stream_in *in = (struct generic_stream_in *)stream;
+    pthread_mutex_lock(&in->lock);
+    do_in_standby(in);
+
+    in->worker_exit = true;
+    pthread_cond_signal(&in->worker_wake);
+    pthread_mutex_unlock(&in->lock);
+    pthread_join(in->worker_thread, NULL);
+
+    if (in->stereo_to_mono_buf != NULL) {
+        free(in->stereo_to_mono_buf);
+        in->stereo_to_mono_buf_size = 0;
+    }
+
+    if (in->bus_address) {
+        free(in->bus_address);
+    }
+
+    pthread_mutex_destroy(&in->lock);
+    audio_vbuffer_destroy(&in->buffer);
+    free(stream);
+}
+
+static void increase_next_tone_frequency(struct generic_audio_device *adev) {
+    adev->next_tone_frequency_to_assign += TONE_FREQUENCY_INCREASE;
+    if (adev->next_tone_frequency_to_assign > MAX_TONE_FREQUENCY) {
+        adev->next_tone_frequency_to_assign = DEFAULT_FREQUENCY;
+    }
+}
+
+static int create_or_fetch_tone_frequency(struct generic_audio_device *adev,
+        char *address, int update_frequency) {
+    int *frequency = hashmapGet(adev->in_bus_tone_frequency_map, address);
+    if (frequency == NULL) {
+        frequency = calloc(1, sizeof(int));
+        *frequency = update_frequency;
+        hashmapPut(adev->in_bus_tone_frequency_map, strdup(address), frequency);
+        ALOGD("%s assigned frequency %d to %s", __func__, *frequency, address);
+    }
+    return *frequency;
+}
+
+static int adev_open_input_stream(struct audio_hw_device *dev,
+        audio_io_handle_t handle, audio_devices_t devices, struct audio_config *config,
+        struct audio_stream_in **stream_in, audio_input_flags_t flags __unused, const char *address,
+        audio_source_t source) {
+    ALOGV("%s: audio_source_t: %d", __func__, source);
+    struct generic_audio_device *adev = (struct generic_audio_device *)dev;
+    struct generic_stream_in *in;
+    int ret = 0;
+    if (refine_input_parameters(&config->sample_rate, &config->format, &config->channel_mask)) {
+        ALOGE("Error opening input stream format %d, channel_mask %04x, sample_rate %u",
+              config->format, config->channel_mask, config->sample_rate);
+        ret = -EINVAL;
+        goto error;
+    }
+
+    in = (struct generic_stream_in *)calloc(1, sizeof(struct generic_stream_in));
+    if (!in) {
+        ret = -ENOMEM;
+        goto error;
+    }
+
+    in->stream.common.get_sample_rate = in_get_sample_rate;
+    in->stream.common.set_sample_rate = in_set_sample_rate;         // no op
+    in->stream.common.get_buffer_size = in_get_buffer_size;
+    in->stream.common.get_channels = in_get_channels;
+    in->stream.common.get_format = in_get_format;
+    in->stream.common.set_format = in_set_format;                   // no op
+    in->stream.common.standby = in_standby;
+    in->stream.common.dump = in_dump;
+    in->stream.common.set_parameters = in_set_parameters;
+    in->stream.common.get_parameters = in_get_parameters;
+    in->stream.common.add_audio_effect = in_add_audio_effect;       // no op
+    in->stream.common.remove_audio_effect = in_remove_audio_effect; // no op
+    in->stream.set_gain = in_set_gain;                              // no op
+    in->stream.read = in_read;
+    in->stream.get_input_frames_lost = in_get_input_frames_lost;    // no op
+    in->stream.get_capture_position = in_get_capture_position;
+
+    pthread_mutex_init(&in->lock, (const pthread_mutexattr_t *) NULL);
+    in->dev = adev;
+    in->device = devices;
+    memcpy(&in->req_config, config, sizeof(struct audio_config));
+    memcpy(&in->pcm_config, &pcm_config_in, sizeof(struct pcm_config));
+    in->pcm_config.rate = config->sample_rate;
+    in->pcm_config.period_size = in->pcm_config.rate*IN_PERIOD_MS/1000;
+
+    in->stereo_to_mono_buf = NULL;
+    in->stereo_to_mono_buf_size = 0;
+
+    in->standby = true;
+    in->standby_position = 0;
+    in->standby_exit_time.tv_sec = 0;
+    in->standby_exit_time.tv_nsec = 0;
+    in->standby_frames_read = 0;
+
+    ret = audio_vbuffer_init(&in->buffer,
+            in->pcm_config.period_size*in->pcm_config.period_count,
+            in->pcm_config.channels *
+            pcm_format_to_bits(in->pcm_config.format) >> 3);
+    if (ret == 0) {
+        pthread_cond_init(&in->worker_wake, NULL);
+        in->worker_standby = true;
+        in->worker_exit = false;
+        pthread_create(&in->worker_thread, NULL, in_read_worker, in);
+    }
+
+    if (address) {
+        in->bus_address = strdup(address);
+        if (is_tone_generator_device(in)) {
+            int update_frequency = adev->next_tone_frequency_to_assign;
+            int frequency = create_or_fetch_tone_frequency(adev, address, update_frequency);
+            if (update_frequency == frequency) {
+                increase_next_tone_frequency(adev);
+            }
+            in->oscillator.phase = 0.0f;
+            in->oscillator.phase_increment = (TWO_PI*(frequency))
+                / ((float) in_get_sample_rate(&in->stream.common));
+        }
+    }
+
+    *stream_in = &in->stream;
+
+error:
+    return ret;
+}
+
+static int adev_dump(const audio_hw_device_t *dev, int fd) {
+    return 0;
+}
+
+static int adev_set_audio_port_config(struct audio_hw_device *dev,
+        const struct audio_port_config *config) {
+    int ret = 0;
+    struct generic_audio_device *adev = (struct generic_audio_device *)dev;
+    const char *bus_address = config->ext.device.address;
+    struct generic_stream_out *out = hashmapGet(adev->out_bus_stream_map, bus_address);
+    if (out) {
+        pthread_mutex_lock(&out->lock);
+        int gainIndex = (config->gain.values[0] - out->gain_stage.min_value) /
+            out->gain_stage.step_value;
+        int totalSteps = (out->gain_stage.max_value - out->gain_stage.min_value) /
+            out->gain_stage.step_value;
+        int minDb = out->gain_stage.min_value / 100;
+        int maxDb = out->gain_stage.max_value / 100;
+        // curve: 10^((minDb + (maxDb - minDb) * gainIndex / totalSteps) / 20)
+        out->amplitude_ratio = pow(10,
+                (minDb + (maxDb - minDb) * (gainIndex / (float)totalSteps)) / 20);
+        pthread_mutex_unlock(&out->lock);
+        ALOGD("%s: set audio gain: %f on %s",
+                __func__, out->amplitude_ratio, bus_address);
+    } else {
+        ALOGE("%s: can not find output stream by bus_address:%s", __func__, bus_address);
+        ret = -EINVAL;
+    }
+    return ret;
+}
+
+static int adev_create_audio_patch(struct audio_hw_device *dev,
+        unsigned int num_sources,
+        const struct audio_port_config *sources,
+        unsigned int num_sinks,
+        const struct audio_port_config *sinks,
+        audio_patch_handle_t *handle) {
+    struct generic_audio_device *audio_dev = (struct generic_audio_device *)dev;
+    for (int i = 0; i < num_sources; i++) {
+        ALOGD("%s: source[%d] type=%d address=%s", __func__, i, sources[i].type,
+                sources[i].type == AUDIO_PORT_TYPE_DEVICE
+                ? sources[i].ext.device.address
+                : "");
+    }
+    for (int i = 0; i < num_sinks; i++) {
+        ALOGD("%s: sink[%d] type=%d address=%s", __func__, i, sinks[i].type,
+                sinks[i].type == AUDIO_PORT_TYPE_DEVICE ? sinks[i].ext.device.address
+                : "N/A");
+    }
+    if (num_sources == 1 && num_sinks == 1 &&
+            sources[0].type == AUDIO_PORT_TYPE_DEVICE &&
+            sinks[0].type == AUDIO_PORT_TYPE_DEVICE) {
+        pthread_mutex_lock(&audio_dev->lock);
+        audio_dev->last_patch_id += 1;
+        pthread_mutex_unlock(&audio_dev->lock);
+        *handle = audio_dev->last_patch_id;
+        ALOGD("%s: handle: %d", __func__, *handle);
+    }
+    return 0;
+}
+
+static int adev_release_audio_patch(struct audio_hw_device *dev,
+        audio_patch_handle_t handle) {
+    ALOGD("%s: handle: %d", __func__, handle);
+    return 0;
+}
+
+static int adev_close(hw_device_t *dev) {
+    struct generic_audio_device *adev = (struct generic_audio_device *)dev;
+    int ret = 0;
+    if (!adev)
+        return 0;
+
+    pthread_mutex_lock(&adev_init_lock);
+
+    if (audio_device_ref_count == 0) {
+        ALOGE("adev_close called when ref_count 0");
+        ret = -EINVAL;
+        goto error;
+    }
+
+    if ((--audio_device_ref_count) == 0) {
+        if (adev->mixer) {
+            mixer_close(adev->mixer);
+        }
+        if (adev->out_bus_stream_map) {
+            hashmapFree(adev->out_bus_stream_map);
+        }
+        if (adev->in_bus_tone_frequency_map) {
+            hashmapFree(adev->in_bus_tone_frequency_map);
+        }
+        free(adev);
+    }
+
+error:
+    pthread_mutex_unlock(&adev_init_lock);
+    return ret;
+}
+
+/* copied from libcutils/str_parms.c */
+static bool str_eq(void *key_a, void *key_b) {
+    return !strcmp((const char *)key_a, (const char *)key_b);
+}
+
+/**
+ * use djb hash unless we find it inadequate.
+ * copied from libcutils/str_parms.c
+ */
+#ifdef __clang__
+__attribute__((no_sanitize("integer")))
+#endif
+static int str_hash_fn(void *str) {
+    uint32_t hash = 5381;
+    char *p;
+    for (p = str; p && *p; p++) {
+        hash = ((hash << 5) + hash) + *p;
+    }
+    return (int)hash;
+}
+
+static int adev_open(const hw_module_t *module,
+        const char *name, hw_device_t **device) {
+    static struct generic_audio_device *adev;
+
+    if (strcmp(name, AUDIO_HARDWARE_INTERFACE) != 0)
+        return -EINVAL;
+
+    pthread_mutex_lock(&adev_init_lock);
+    if (audio_device_ref_count != 0) {
+        *device = &adev->device.common;
+        audio_device_ref_count++;
+        ALOGV("%s: returning existing instance of adev", __func__);
+        ALOGV("%s: exit", __func__);
+        goto unlock;
+    }
+    adev = calloc(1, sizeof(struct generic_audio_device));
+
+    pthread_mutex_init(&adev->lock, (const pthread_mutexattr_t *) NULL);
+
+    adev->device.common.tag = HARDWARE_DEVICE_TAG;
+    adev->device.common.version = AUDIO_DEVICE_API_VERSION_3_0;
+    adev->device.common.module = (struct hw_module_t *) module;
+    adev->device.common.close = adev_close;
+
+    adev->device.init_check = adev_init_check;               // no op
+    adev->device.set_voice_volume = adev_set_voice_volume;   // no op
+    adev->device.set_master_volume = adev_set_master_volume; // no op
+    adev->device.get_master_volume = adev_get_master_volume; // no op
+    adev->device.set_master_mute = adev_set_master_mute;
+    adev->device.get_master_mute = adev_get_master_mute;
+    adev->device.set_mode = adev_set_mode;                   // no op
+    adev->device.set_mic_mute = adev_set_mic_mute;
+    adev->device.get_mic_mute = adev_get_mic_mute;
+    adev->device.set_parameters = adev_set_parameters;       // no op
+    adev->device.get_parameters = adev_get_parameters;       // no op
+    adev->device.get_input_buffer_size = adev_get_input_buffer_size;
+    adev->device.open_output_stream = adev_open_output_stream;
+    adev->device.close_output_stream = adev_close_output_stream;
+    adev->device.open_input_stream = adev_open_input_stream;
+    adev->device.close_input_stream = adev_close_input_stream;
+    adev->device.dump = adev_dump;
+
+    // New in AUDIO_DEVICE_API_VERSION_3_0
+    adev->device.set_audio_port_config = adev_set_audio_port_config;
+    adev->device.create_audio_patch = adev_create_audio_patch;
+    adev->device.release_audio_patch = adev_release_audio_patch;
+
+    *device = &adev->device.common;
+
+    adev->mixer = mixer_open(PCM_CARD);
+
+    ALOGD("%s Mixer name %s", __func__, mixer_get_name(adev->mixer));
+    struct mixer_ctl *ctl;
+
+    // Set default mixer ctls
+    // Enable channels and set volume
+    for (int i = 0; i < (int)mixer_get_num_ctls(adev->mixer); i++) {
+        ctl = mixer_get_ctl(adev->mixer, i);
+        ALOGD("mixer %d name %s", i, mixer_ctl_get_name(ctl));
+        if (!strcmp(mixer_ctl_get_name(ctl), "Master Playback Volume") ||
+            !strcmp(mixer_ctl_get_name(ctl), "Capture Volume")) {
+            for (int z = 0; z < (int)mixer_ctl_get_num_values(ctl); z++) {
+                ALOGD("set ctl %d to %d", z, 100);
+                mixer_ctl_set_percent(ctl, z, 100);
+            }
+            continue;
+        }
+        if (!strcmp(mixer_ctl_get_name(ctl), "Master Playback Switch") ||
+            !strcmp(mixer_ctl_get_name(ctl), "Capture Switch")) {
+            for (int z = 0; z < (int)mixer_ctl_get_num_values(ctl); z++) {
+                ALOGD("set ctl %d to %d", z, 1);
+                mixer_ctl_set_value(ctl, z, 1);
+            }
+            continue;
+        }
+    }
+
+    // Initialize the bus address to output stream map
+    adev->out_bus_stream_map = hashmapCreate(5, str_hash_fn, str_eq);
+
+    // Initialize the bus address to input stream map
+    adev->in_bus_tone_frequency_map = hashmapCreate(5, str_hash_fn, str_eq);
+
+    adev->next_tone_frequency_to_assign = DEFAULT_FREQUENCY;
+
+    adev->last_zone_selected_to_play = DEFAULT_ZONE_TO_LEFT_SPEAKER;
+
+    audio_device_ref_count++;
+
+unlock:
+    pthread_mutex_unlock(&adev_init_lock);
+    return 0;
+}
+
+static struct hw_module_methods_t hal_module_methods = {
+    .open = adev_open,
+};
+
+struct audio_module HAL_MODULE_INFO_SYM = {
+    .common = {
+        .tag = HARDWARE_MODULE_TAG,
+        .module_api_version = AUDIO_MODULE_API_VERSION_0_1,
+        .hal_api_version = HARDWARE_HAL_API_VERSION,
+        .id = AUDIO_HARDWARE_MODULE_ID,
+        .name = "Generic car audio HW HAL",
+        .author = "The Android Open Source Project",
+        .methods = &hal_module_methods,
+    },
+};
diff --git a/hal/audio/6.0/audio_hw.h b/hal/audio/6.0/audio_hw.h
new file mode 100644
index 0000000..d195a53
--- /dev/null
+++ b/hal/audio/6.0/audio_hw.h
@@ -0,0 +1,111 @@
+/*
+ * Copyright (C) 2018 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 AUDIO_HW_H
+#define AUDIO_HW_H
+
+#include <pthread.h>
+
+#include <cutils/hashmap.h>
+#include <hardware/audio.h>
+#include <tinyalsa/asoundlib.h>
+
+#include "audio_vbuffer.h"
+
+struct generic_audio_device {
+  struct audio_hw_device device;  // Constant after init
+  pthread_mutex_t lock;
+  unsigned int last_patch_id;   // Protected by this->lock
+  bool master_mute;             // Protected by this->lock
+  bool mic_mute;                // Protected by this->lock
+  struct mixer *mixer;          // Protected by this->lock
+  Hashmap *out_bus_stream_map;  // Extended field. Constant after init
+  Hashmap *in_bus_tone_frequency_map;  // Extended field. Constant after init
+  int next_tone_frequency_to_assign; // Protected by this->lock
+  // Play on Speaker zone selection
+  int last_zone_selected_to_play; // Protected by this->lock
+};
+
+enum output_channel_enable {
+  LEFT_CHANNEL = 1,
+  RIGHT_CHANNEL = 1 << 1,
+  BOTH_CHANNELS = LEFT_CHANNEL | RIGHT_CHANNEL
+};
+
+struct generic_stream_out {
+  struct audio_stream_out stream;  // Constant after init
+  pthread_mutex_t lock;
+  struct generic_audio_device *dev;  // Constant after init
+  audio_devices_t device;            // Protected by this->lock
+  struct audio_config req_config;    // Constant after init
+  struct pcm_config pcm_config;      // Constant after init
+  audio_vbuffer_t buffer;            // Constant after init
+  const char *bus_address;           // Extended field. Constant after init
+  struct audio_gain gain_stage;      // Constant after init
+  float amplitude_ratio;             // Protected by this->lock
+  enum output_channel_enable enabled_channels;  // Constant after init
+
+  // Time & Position Keeping
+  bool standby;                    // Protected by this->lock
+  uint64_t underrun_position;      // Protected by this->lock
+  struct timespec underrun_time;   // Protected by this->lock
+  uint64_t last_write_time_us;     // Protected by this->lock
+  uint64_t frames_total_buffered;  // Protected by this->lock
+  uint64_t frames_written;         // Protected by this->lock
+  uint64_t frames_rendered;        // Protected by this->lock
+
+  // Worker
+  pthread_t worker_thread;     // Constant after init
+  pthread_cond_t worker_wake;  // Protected by this->lock
+  bool worker_standby;         // Protected by this->lock
+  bool worker_exit;            // Protected by this->lock
+};
+
+struct oscillator {
+    float phase;
+    float phase_increment;
+};
+
+struct generic_stream_in {
+  struct audio_stream_in stream;  // Constant after init
+  pthread_mutex_t lock;
+  struct generic_audio_device *dev;  // Constant after init
+  audio_devices_t device;            // Protected by this->lock
+  struct audio_config req_config;    // Constant after init
+  struct pcm *pcm;                   // Protected by this->lock
+  struct pcm_config pcm_config;      // Constant after init
+  int16_t *stereo_to_mono_buf;       // Protected by this->lock
+  size_t stereo_to_mono_buf_size;    // Protected by this->lock
+  audio_vbuffer_t buffer;            // Protected by this->lock
+  const char *bus_address;           // Extended field. Constant after init
+
+  // Time & Position Keeping
+  bool standby;                       // Protected by this->lock
+  int64_t standby_position;           // Protected by this->lock
+  struct timespec standby_exit_time;  // Protected by this->lock
+  int64_t standby_frames_read;        // Protected by this->lock
+
+  // Worker
+  pthread_t worker_thread;     // Constant after init
+  pthread_cond_t worker_wake;  // Protected by this->lock
+  bool worker_standby;         // Protected by this->lock
+  bool worker_exit;            // Protected by this->lock
+
+   // Tone Oscillator
+   struct oscillator oscillator; // Protected by this->lock
+};
+
+#endif  // AUDIO_HW_H
diff --git a/hal/audio/6.0/audio_policy_configuration.xml b/hal/audio/6.0/audio_policy_configuration.xml
new file mode 100644
index 0000000..ed0f4a6
--- /dev/null
+++ b/hal/audio/6.0/audio_policy_configuration.xml
@@ -0,0 +1,330 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<!-- Copyright (C) 2018 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.
+-->
+
+<audioPolicyConfiguration version="1.0" xmlns:xi="http://www.w3.org/2001/XInclude">
+    <!-- version section contains a “version” tag in the form “major.minor” e.g version=”1.0” -->
+
+    <!-- Global configuration Decalaration -->
+    <globalConfiguration speaker_drc_enabled="true"/>
+
+    <!-- Modules section:
+        There is one section per audio HW module present on the platform.
+        Each module section will contains two mandatory tags for audio HAL “halVersion” and “name”.
+        The module names are the same as in current .conf file:
+                “primary”, “A2DP”, “remote_submix”, “USB”
+        Each module will contain the following sections:
+        “devicePorts”: a list of device descriptors for all input and output devices accessible via this
+        module.
+        This contains both permanently attached devices and removable devices.
+            "gain": constraints applied to the millibel values:
+                - maxValueMB >= minValueMB
+                - defaultValueMB >= minValueMB && defaultValueMB <= maxValueMB
+                - (maxValueMB - minValueMB) % stepValueMB == 0
+                - (defaultValueMB - minValueMB) % stepValueMB == 0
+        “mixPorts”: listing all output and input streams exposed by the audio HAL
+        “routes”: list of possible connections between input and output devices or between stream and
+        devices.
+            "route": is defined by an attribute:
+                -"type": <mux|mix> means all sources are mutual exclusive (mux) or can be mixed (mix)
+                -"sink": the sink involved in this route
+                -"sources": all the sources than can be connected to the sink via vis route
+        “attachedDevices”: permanently attached devices.
+        The attachedDevices section is a list of devices names. The names correspond to device names
+        defined in <devicePorts> section.
+        “defaultOutputDevice”: device to be used by default when no policy rule applies
+    -->
+    <modules>
+        <!-- Primary Audio HAL -->
+        <module name="primary" halVersion="3.0">
+            <attachedDevices>
+                <!-- One bus per context -->
+                <item>bus0_media_out</item>
+                <item>bus1_navigation_out</item>
+                <item>bus2_voice_command_out</item>
+                <item>bus3_call_ring_out</item>
+                <item>bus4_call_out</item>
+                <item>bus5_alarm_out</item>
+                <item>bus6_notification_out</item>
+                <item>bus7_system_sound_out</item>
+                <!-- names with _audio_zone_# are used for defined an emulator rear seat audio zone
+                    where each number # is the zone id number -->
+                <item>bus100_audio_zone_1</item>
+                <item>bus200_audio_zone_2</item>
+                <item>Built-In Mic</item>
+                <item>Built-In Back Mic</item>
+                <item>Echo-Reference Mic</item>
+                <item>FM Tuner</item>
+                <item>Tone Generator 0</item>
+                <item>Tone Generator 1</item>
+            </attachedDevices>
+            <defaultOutputDevice>bus0_media_out</defaultOutputDevice>
+            <mixPorts>
+                <mixPort name="mixport_bus0_media_out" role="source"
+                        flags="AUDIO_OUTPUT_FLAG_PRIMARY">
+                    <profile name="" format="AUDIO_FORMAT_PCM_16_BIT"
+                             samplingRates="48000"
+                             channelMasks="AUDIO_CHANNEL_OUT_STEREO"/>
+                </mixPort>
+                <mixPort name="mixport_bus1_navigation_out" role="source"
+                        flags="AUDIO_OUTPUT_FLAG_PRIMARY">
+                    <profile name="" format="AUDIO_FORMAT_PCM_16_BIT"
+                             samplingRates="48000"
+                             channelMasks="AUDIO_CHANNEL_OUT_STEREO"/>
+                </mixPort>
+                <mixPort name="mixport_bus2_voice_command_out" role="source"
+                        flags="AUDIO_OUTPUT_FLAG_PRIMARY">
+                    <profile name="" format="AUDIO_FORMAT_PCM_16_BIT"
+                             samplingRates="48000"
+                             channelMasks="AUDIO_CHANNEL_OUT_STEREO"/>
+                </mixPort>
+                <mixPort name="mixport_bus3_call_ring_out" role="source"
+                        flags="AUDIO_OUTPUT_FLAG_PRIMARY">
+                    <profile name="" format="AUDIO_FORMAT_PCM_16_BIT"
+                             samplingRates="48000"
+                             channelMasks="AUDIO_CHANNEL_OUT_STEREO"/>
+                </mixPort>
+                <mixPort name="mixport_bus4_call_out" role="source"
+                        flags="AUDIO_OUTPUT_FLAG_PRIMARY">
+                    <profile name="" format="AUDIO_FORMAT_PCM_16_BIT"
+                             samplingRates="48000"
+                             channelMasks="AUDIO_CHANNEL_OUT_STEREO"/>
+                </mixPort>
+                <mixPort name="mixport_bus5_alarm_out" role="source"
+                        flags="AUDIO_OUTPUT_FLAG_PRIMARY">
+                    <profile name="" format="AUDIO_FORMAT_PCM_16_BIT"
+                             samplingRates="48000"
+                             channelMasks="AUDIO_CHANNEL_OUT_STEREO"/>
+                </mixPort>
+                <mixPort name="mixport_bus6_notification_out" role="source"
+                        flags="AUDIO_OUTPUT_FLAG_PRIMARY">
+                    <profile name="" format="AUDIO_FORMAT_PCM_16_BIT"
+                             samplingRates="48000"
+                             channelMasks="AUDIO_CHANNEL_OUT_STEREO"/>
+                </mixPort>
+                <mixPort name="mixport_bus7_system_sound_out" role="source"
+                        flags="AUDIO_OUTPUT_FLAG_PRIMARY">
+                    <profile name="" format="AUDIO_FORMAT_PCM_16_BIT"
+                             samplingRates="48000"
+                             channelMasks="AUDIO_CHANNEL_OUT_STEREO"/>
+                </mixPort>
+                <mixPort name="mixport_bus100_audio_zone_1" role="source"
+                        flags="AUDIO_OUTPUT_FLAG_PRIMARY">
+                    <profile name="" format="AUDIO_FORMAT_PCM_16_BIT"
+                             samplingRates="48000"
+                             channelMasks="AUDIO_CHANNEL_OUT_STEREO"/>
+                </mixPort>
+                <mixPort name="mixport_bus200_audio_zone_2" role="source"
+                         flags="AUDIO_OUTPUT_FLAG_PRIMARY">
+                    <profile name="" format="AUDIO_FORMAT_PCM_16_BIT"
+                             samplingRates="48000"
+                             channelMasks="AUDIO_CHANNEL_OUT_STEREO"/>
+                </mixPort>
+                <mixPort name="primary input" role="sink">
+                    <profile name="" format="AUDIO_FORMAT_PCM_16_BIT"
+                             samplingRates="8000,11025,12000,16000,22050,24000,32000,44100,48000"
+                             channelMasks="AUDIO_CHANNEL_IN_MONO,AUDIO_CHANNEL_IN_STEREO,AUDIO_CHANNEL_IN_FRONT_BACK"/>
+                </mixPort>
+                <mixPort name="mixport_tuner0" role="sink">
+                    <profile name="" format="AUDIO_FORMAT_PCM_16_BIT"
+                             samplingRates="48000"
+                             channelMasks="AUDIO_CHANNEL_IN_STEREO"/>
+                </mixPort>
+                <mixPort name="mixport_input_bus_tone_zone_0" role="sink">
+                    <profile name="" format="AUDIO_FORMAT_PCM_16_BIT"
+                             samplingRates="48000"
+                             channelMasks="AUDIO_CHANNEL_IN_STEREO"/>
+                </mixPort>
+                <mixPort name="mixport_input_bus_tone_zone_1" role="sink">
+                    <profile name="" format="AUDIO_FORMAT_PCM_16_BIT"
+                             samplingRates="48000"
+                             channelMasks="AUDIO_CHANNEL_IN_STEREO"/>
+                </mixPort>
+            </mixPorts>
+            <devicePorts>
+                <devicePort tagName="bus0_media_out" role="sink" type="AUDIO_DEVICE_OUT_BUS"
+                        address="bus0_media_out">
+                    <profile name="" format="AUDIO_FORMAT_PCM_16_BIT"
+                            samplingRates="48000" channelMasks="AUDIO_CHANNEL_OUT_STEREO"/>
+                    <gains>
+                        <gain name="" mode="AUDIO_GAIN_MODE_JOINT"
+                                minValueMB="-3200" maxValueMB="600" defaultValueMB="0" stepValueMB="100"/>
+                    </gains>
+                </devicePort>
+                <devicePort tagName="bus1_navigation_out" role="sink" type="AUDIO_DEVICE_OUT_BUS"
+                        address="bus1_navigation_out">
+                    <profile name="" format="AUDIO_FORMAT_PCM_16_BIT"
+                            samplingRates="48000" channelMasks="AUDIO_CHANNEL_OUT_STEREO"/>
+                    <gains>
+                        <gain name="" mode="AUDIO_GAIN_MODE_JOINT"
+                                minValueMB="-3200" maxValueMB="600" defaultValueMB="0" stepValueMB="100"/>
+                    </gains>
+                </devicePort>
+                <devicePort tagName="bus2_voice_command_out" role="sink" type="AUDIO_DEVICE_OUT_BUS"
+                        address="bus2_voice_command_out">
+                    <profile name="" format="AUDIO_FORMAT_PCM_16_BIT"
+                            samplingRates="48000" channelMasks="AUDIO_CHANNEL_OUT_STEREO"/>
+                    <gains>
+                        <gain name="" mode="AUDIO_GAIN_MODE_JOINT"
+                                minValueMB="-3200" maxValueMB="600" defaultValueMB="0" stepValueMB="100"/>
+                    </gains>
+                </devicePort>
+                <devicePort tagName="bus3_call_ring_out" role="sink" type="AUDIO_DEVICE_OUT_BUS"
+                        address="bus3_call_ring_out">
+                    <profile name="" format="AUDIO_FORMAT_PCM_16_BIT"
+                            samplingRates="48000" channelMasks="AUDIO_CHANNEL_OUT_STEREO"/>
+                    <gains>
+                        <gain name="" mode="AUDIO_GAIN_MODE_JOINT"
+                                minValueMB="-3200" maxValueMB="600" defaultValueMB="0" stepValueMB="100"/>
+                    </gains>
+                </devicePort>
+                <devicePort tagName="bus4_call_out" role="sink" type="AUDIO_DEVICE_OUT_BUS"
+                        address="bus4_call_out">
+                    <profile name="" format="AUDIO_FORMAT_PCM_16_BIT"
+                            samplingRates="48000" channelMasks="AUDIO_CHANNEL_OUT_STEREO"/>
+                    <gains>
+                        <gain name="" mode="AUDIO_GAIN_MODE_JOINT"
+                                minValueMB="-3200" maxValueMB="600" defaultValueMB="0" stepValueMB="100"/>
+                    </gains>
+                </devicePort>
+                <devicePort tagName="bus5_alarm_out" role="sink" type="AUDIO_DEVICE_OUT_BUS"
+                        address="bus5_alarm_out">
+                    <profile name="" format="AUDIO_FORMAT_PCM_16_BIT"
+                            samplingRates="48000" channelMasks="AUDIO_CHANNEL_OUT_STEREO"/>
+                    <gains>
+                        <gain name="" mode="AUDIO_GAIN_MODE_JOINT"
+                                minValueMB="-3200" maxValueMB="600" defaultValueMB="0" stepValueMB="100"/>
+                    </gains>
+                </devicePort>
+                <devicePort tagName="bus6_notification_out" role="sink" type="AUDIO_DEVICE_OUT_BUS"
+                        address="bus6_notification_out">
+                    <profile name="" format="AUDIO_FORMAT_PCM_16_BIT"
+                            samplingRates="48000" channelMasks="AUDIO_CHANNEL_OUT_STEREO"/>
+                    <gains>
+                        <gain name="" mode="AUDIO_GAIN_MODE_JOINT"
+                                minValueMB="-3200" maxValueMB="600" defaultValueMB="0" stepValueMB="100"/>
+                    </gains>
+                </devicePort>
+                <devicePort tagName="bus7_system_sound_out" role="sink" type="AUDIO_DEVICE_OUT_BUS"
+                        address="bus7_system_sound_out">
+                    <profile name="" format="AUDIO_FORMAT_PCM_16_BIT"
+                            samplingRates="48000" channelMasks="AUDIO_CHANNEL_OUT_STEREO"/>
+                    <gains>
+                        <gain name="" mode="AUDIO_GAIN_MODE_JOINT"
+                                minValueMB="-3200" maxValueMB="600" defaultValueMB="0" stepValueMB="100"/>
+                    </gains>
+                </devicePort>
+                <devicePort tagName="bus100_audio_zone_1" role="sink" type="AUDIO_DEVICE_OUT_BUS"
+                        address="bus100_audio_zone_1">
+                    <profile name="" format="AUDIO_FORMAT_PCM_16_BIT"
+                            samplingRates="48000" channelMasks="AUDIO_CHANNEL_OUT_STEREO"/>
+                    <gains>
+                        <gain name="" mode="AUDIO_GAIN_MODE_JOINT"
+                                minValueMB="-3200" maxValueMB="600" defaultValueMB="0" stepValueMB="100"/>
+                    </gains>
+                </devicePort>
+                <devicePort tagName="bus200_audio_zone_2" role="sink" type="AUDIO_DEVICE_OUT_BUS"
+                            address="bus200_audio_zone_2">
+                    <profile name="" format="AUDIO_FORMAT_PCM_16_BIT"
+                             samplingRates="48000" channelMasks="AUDIO_CHANNEL_OUT_STEREO"/>
+                    <gains>
+                        <gain name="" mode="AUDIO_GAIN_MODE_JOINT"
+                              minValueMB="-3200" maxValueMB="600" defaultValueMB="0" stepValueMB="100"/>
+                    </gains>
+                </devicePort>
+                <devicePort tagName="Built-In Mic" type="AUDIO_DEVICE_IN_BUILTIN_MIC" role="source">
+                    <profile name="" format="AUDIO_FORMAT_PCM_16_BIT"
+                            samplingRates="8000,11025,12000,16000,22050,24000,32000,44100,48000"
+                            channelMasks="AUDIO_CHANNEL_IN_MONO,AUDIO_CHANNEL_IN_STEREO,AUDIO_CHANNEL_IN_FRONT_BACK"/>
+                </devicePort>
+                <devicePort tagName="Built-In Back Mic" type="AUDIO_DEVICE_IN_BACK_MIC" role="source">
+                    <profile name="" format="AUDIO_FORMAT_PCM_16_BIT"
+                            samplingRates="8000,11025,12000,16000,22050,24000,32000,44100,48000"
+                            channelMasks="AUDIO_CHANNEL_IN_MONO,AUDIO_CHANNEL_IN_STEREO,AUDIO_CHANNEL_IN_FRONT_BACK"/>
+                </devicePort>
+                <devicePort tagName="Echo-Reference Mic" type="AUDIO_DEVICE_IN_ECHO_REFERENCE" role="source">
+                    <profile name="" format="AUDIO_FORMAT_PCM_16_BIT"
+                            samplingRates="8000,11025,12000,16000,22050,24000,32000,44100,48000"
+                            channelMasks="AUDIO_CHANNEL_IN_MONO,AUDIO_CHANNEL_IN_STEREO,AUDIO_CHANNEL_IN_FRONT_BACK"/>
+                </devicePort>
+                <devicePort tagName="FM Tuner" type="AUDIO_DEVICE_IN_FM_TUNER" role="source"
+                        address="tuner0">
+                    <profile name="" format="AUDIO_FORMAT_PCM_16_BIT"
+                            samplingRates="48000" channelMasks="AUDIO_CHANNEL_IN_STEREO"/>
+                    <gains>
+                        <gain name="" mode="AUDIO_GAIN_MODE_JOINT"
+                                minValueMB="-3200" maxValueMB="600" defaultValueMB="0" stepValueMB="100"/>
+                    </gains>
+                </devicePort>
+                <devicePort tagName="Tone Generator 0" type="AUDIO_DEVICE_IN_BUS" role="source"
+                            address="input_bus_tone_zone_0">
+                    <profile name="" format="AUDIO_FORMAT_PCM_16_BIT"
+                             samplingRates="48000" channelMasks="AUDIO_CHANNEL_IN_STEREO"/>
+                    <gains>
+                        <gain name="" mode="AUDIO_GAIN_MODE_JOINT"
+                              minValueMB="-3200" maxValueMB="600" defaultValueMB="0" stepValueMB="100"/>
+                    </gains>
+                </devicePort>
+                <devicePort tagName="Tone Generator 1" type="AUDIO_DEVICE_IN_BUS" role="source"
+                            address="input_bus_tone_zone_1">
+                    <profile name="" format="AUDIO_FORMAT_PCM_16_BIT"
+                             samplingRates="48000" channelMasks="AUDIO_CHANNEL_IN_STEREO"/>
+                    <gains>
+                        <gain name="" mode="AUDIO_GAIN_MODE_JOINT"
+                              minValueMB="-3200" maxValueMB="600" defaultValueMB="0" stepValueMB="100"/>
+                    </gains>
+                </devicePort>
+            </devicePorts>
+            <!-- route declaration, i.e. list all available sources for a given sink -->
+            <routes>
+                <route type="mix" sink="bus0_media_out" sources="mixport_bus0_media_out"/>
+                <route type="mix" sink="bus1_navigation_out" sources="mixport_bus1_navigation_out"/>
+                <route type="mix" sink="bus2_voice_command_out" sources="mixport_bus2_voice_command_out"/>
+                <route type="mix" sink="bus3_call_ring_out" sources="mixport_bus3_call_ring_out"/>
+                <route type="mix" sink="bus4_call_out" sources="mixport_bus4_call_out"/>
+                <route type="mix" sink="bus5_alarm_out" sources="mixport_bus5_alarm_out"/>
+                <route type="mix" sink="bus6_notification_out" sources="mixport_bus6_notification_out"/>
+                <route type="mix" sink="bus7_system_sound_out" sources="mixport_bus7_system_sound_out"/>
+                <route type="mix" sink="bus100_audio_zone_1" sources="mixport_bus100_audio_zone_1"/>
+                <route type="mix" sink="bus200_audio_zone_2" sources="mixport_bus200_audio_zone_2"/>
+                <route type="mix" sink="primary input" sources="Built-In Mic,Built-In Back Mic,Echo-Reference Mic"/>
+                <route type="mix" sink="mixport_tuner0" sources="FM Tuner"/>
+                <route type="mix" sink="mixport_input_bus_tone_zone_0" sources="Tone Generator 0"/>
+                <route type="mix" sink="mixport_input_bus_tone_zone_1" sources="Tone Generator 1"/>
+            </routes>
+
+        </module>
+
+        <!-- A2dp Audio HAL -->
+        <xi:include href="a2dp_audio_policy_configuration.xml"/>
+
+        <!-- Usb Audio HAL -->
+        <xi:include href="usb_audio_policy_configuration.xml"/>
+
+        <!-- Remote Submix Audio HAL -->
+        <xi:include href="r_submix_audio_policy_configuration.xml"/>
+
+    </modules>
+    <!-- End of Modules section -->
+
+    <!-- Volume section -->
+
+    <xi:include href="audio_policy_volumes.xml"/>
+    <xi:include href="default_volume_tables.xml"/>
+
+    <!-- End of Volume section -->
+    <!-- End of Modules section -->
+
+</audioPolicyConfiguration>
diff --git a/hal/audio/6.0/audio_vbuffer.c b/hal/audio/6.0/audio_vbuffer.c
new file mode 100644
index 0000000..79be545
--- /dev/null
+++ b/hal/audio/6.0/audio_vbuffer.c
@@ -0,0 +1,137 @@
+/*
+ * Copyright (C) 2018 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.
+ */
+
+#define LOG_TAG "audio_hw_generic"
+
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <log/log.h>
+
+#include "audio_vbuffer.h"
+
+#define MIN(a, b) (((a) < (b)) ? (a) : (b))
+
+int audio_vbuffer_init(audio_vbuffer_t *audio_vbuffer, size_t frame_count,
+                       size_t frame_size) {
+  if (!audio_vbuffer) {
+    return -EINVAL;
+  }
+  audio_vbuffer->frame_size = frame_size;
+  audio_vbuffer->frame_count = frame_count;
+  size_t bytes = frame_count * frame_size;
+  audio_vbuffer->data = calloc(bytes, 1);
+  if (!audio_vbuffer->data) {
+    return -ENOMEM;
+  }
+  audio_vbuffer->head = 0;
+  audio_vbuffer->tail = 0;
+  audio_vbuffer->live = 0;
+  pthread_mutex_init(&audio_vbuffer->lock, (const pthread_mutexattr_t *)NULL);
+  return 0;
+}
+
+int audio_vbuffer_destroy(audio_vbuffer_t *audio_vbuffer) {
+  if (!audio_vbuffer) {
+    return -EINVAL;
+  }
+  free(audio_vbuffer->data);
+  pthread_mutex_destroy(&audio_vbuffer->lock);
+  return 0;
+}
+
+int audio_vbuffer_live(audio_vbuffer_t *audio_vbuffer) {
+  if (!audio_vbuffer) {
+    return -EINVAL;
+  }
+  pthread_mutex_lock(&audio_vbuffer->lock);
+  int live = audio_vbuffer->live;
+  pthread_mutex_unlock(&audio_vbuffer->lock);
+  return live;
+}
+
+int audio_vbuffer_dead(audio_vbuffer_t *audio_vbuffer) {
+  if (!audio_vbuffer) {
+    return -EINVAL;
+  }
+  pthread_mutex_lock(&audio_vbuffer->lock);
+  int dead = audio_vbuffer->frame_count - audio_vbuffer->live;
+  pthread_mutex_unlock(&audio_vbuffer->lock);
+  return dead;
+}
+
+size_t audio_vbuffer_write(audio_vbuffer_t *audio_vbuffer, const void *buffer,
+                           size_t frame_count) {
+  size_t frames_written = 0;
+  pthread_mutex_lock(&audio_vbuffer->lock);
+
+  while (frame_count != 0) {
+    int frames = 0;
+    if (audio_vbuffer->live == 0 || audio_vbuffer->head > audio_vbuffer->tail) {
+      frames =
+          MIN(frame_count, audio_vbuffer->frame_count - audio_vbuffer->head);
+    } else if (audio_vbuffer->head < audio_vbuffer->tail) {
+      frames = MIN(frame_count, audio_vbuffer->tail - (audio_vbuffer->head));
+    } else {
+      ALOGD("%s audio_vbuffer is full", __func__);
+      break;
+    }
+    memcpy(
+        &audio_vbuffer->data[audio_vbuffer->head * audio_vbuffer->frame_size],
+        &((uint8_t *)buffer)[frames_written * audio_vbuffer->frame_size],
+        frames * audio_vbuffer->frame_size);
+    audio_vbuffer->live += frames;
+    frames_written += frames;
+    frame_count -= frames;
+    audio_vbuffer->head =
+        (audio_vbuffer->head + frames) % audio_vbuffer->frame_count;
+  }
+
+  pthread_mutex_unlock(&audio_vbuffer->lock);
+  return frames_written;
+}
+
+size_t audio_vbuffer_read(audio_vbuffer_t *audio_vbuffer, void *buffer,
+                          size_t frame_count) {
+  size_t frames_read = 0;
+  pthread_mutex_lock(&audio_vbuffer->lock);
+
+  while (frame_count != 0) {
+    int frames = 0;
+    if (audio_vbuffer->live == audio_vbuffer->frame_count ||
+        audio_vbuffer->tail > audio_vbuffer->head) {
+      frames =
+          MIN(frame_count, audio_vbuffer->frame_count - audio_vbuffer->tail);
+    } else if (audio_vbuffer->tail < audio_vbuffer->head) {
+      frames = MIN(frame_count, audio_vbuffer->head - audio_vbuffer->tail);
+    } else {
+      break;
+    }
+    memcpy(
+        &((uint8_t *)buffer)[frames_read * audio_vbuffer->frame_size],
+        &audio_vbuffer->data[audio_vbuffer->tail * audio_vbuffer->frame_size],
+        frames * audio_vbuffer->frame_size);
+    audio_vbuffer->live -= frames;
+    frames_read += frames;
+    frame_count -= frames;
+    audio_vbuffer->tail =
+        (audio_vbuffer->tail + frames) % audio_vbuffer->frame_count;
+  }
+
+  pthread_mutex_unlock(&audio_vbuffer->lock);
+  return frames_read;
+}
diff --git a/hal/audio/6.0/audio_vbuffer.h b/hal/audio/6.0/audio_vbuffer.h
new file mode 100644
index 0000000..24bf986
--- /dev/null
+++ b/hal/audio/6.0/audio_vbuffer.h
@@ -0,0 +1,47 @@
+/*
+ * Copyright (C) 2018 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 AUDIO_VBUFFER_H
+#define AUDIO_VBUFFER_H
+
+#include <pthread.h>
+
+typedef struct audio_vbuffer {
+  pthread_mutex_t lock;
+  uint8_t *data;
+  size_t frame_size;
+  size_t frame_count;
+  size_t head;
+  size_t tail;
+  size_t live;
+} audio_vbuffer_t;
+
+int audio_vbuffer_init(audio_vbuffer_t *audio_vbuffer, size_t frame_count,
+                       size_t frame_size);
+
+int audio_vbuffer_destroy(audio_vbuffer_t *audio_vbuffer);
+
+int audio_vbuffer_live(audio_vbuffer_t *audio_vbuffer);
+
+int audio_vbuffer_dead(audio_vbuffer_t *audio_vbuffer);
+
+size_t audio_vbuffer_write(audio_vbuffer_t *audio_vbuffer, const void *buffer,
+                           size_t frame_count);
+
+size_t audio_vbuffer_read(audio_vbuffer_t *audio_vbuffer, void *buffer,
+                          size_t frame_count);
+
+#endif  // AUDIO_VBUFFER_H
diff --git a/hal/audio/6.0/car_audio_configuration.xml b/hal/audio/6.0/car_audio_configuration.xml
new file mode 100644
index 0000000..4a8f372
--- /dev/null
+++ b/hal/audio/6.0/car_audio_configuration.xml
@@ -0,0 +1,113 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 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.
+-->
+
+<!--
+  Defines the audio configuration in a car, including
+    - Audio zones
+    - Context to audio bus mappings
+    - Volume groups
+  in the car environment.
+-->
+
+<!-- TODO (chenhaosjtuacm):
+    Copied from device/generic/car/emulator/audio/car_audio_configuration.xml
+    Needs to be updated.
+-->
+
+<carAudioConfiguration version="2">
+    <zones>
+        <zone name="primary zone" isPrimary="true" occupantZoneId="0">
+            <volumeGroups>
+                <group>
+                    <device address="bus0_media_out">
+                        <context context="music"/>
+                    </device>
+                    <device address="bus3_call_ring_out">
+                        <context context="call_ring"/>
+                    </device>
+                    <device address="bus6_notification_out">
+                        <context context="notification"/>
+                    </device>
+                    <device address="bus7_system_sound_out">
+                        <context context="system_sound"/>
+                        <context context="emergency"/>
+                        <context context="safety"/>
+                        <context context="vehicle_status"/>
+                        <context context="announcement"/>
+                    </device>
+                </group>
+                <group>
+                    <device address="bus1_navigation_out">
+                        <context context="navigation"/>
+                    </device>
+                    <device address="bus2_voice_command_out">
+                        <context context="voice_command"/>
+                    </device>
+                </group>
+                <group>
+                    <device address="bus4_call_out">
+                        <context context="call"/>
+                    </device>
+                </group>
+                <group>
+                    <device address="bus5_alarm_out">
+                        <context context="alarm"/>
+                    </device>
+                </group>
+            </volumeGroups>
+        </zone>
+        <zone name="rear seat zone 1" audioZoneId="1">
+            <volumeGroups>
+                <group>
+                    <device address="bus100_audio_zone_1">
+                        <context context="music"/>
+                        <context context="navigation"/>
+                        <context context="voice_command"/>
+                        <context context="call_ring"/>
+                        <context context="call"/>
+                        <context context="alarm"/>
+                        <context context="notification"/>
+                        <context context="system_sound"/>
+                        <context context="emergency"/>
+                        <context context="safety"/>
+                        <context context="vehicle_status"/>
+                        <context context="announcement"/>
+                    </device>
+                </group>
+            </volumeGroups>
+        </zone>
+        <zone name="rear seat zone 2"  audioZoneId="2">
+            <volumeGroups>
+                <group>
+                    <device address="bus200_audio_zone_2">
+                        <context context="music"/>
+                        <context context="navigation"/>
+                        <context context="voice_command"/>
+                        <context context="call_ring"/>
+                        <context context="call"/>
+                        <context context="alarm"/>
+                        <context context="notification"/>
+                        <context context="system_sound"/>
+                        <context context="emergency"/>
+                        <context context="safety"/>
+                        <context context="vehicle_status"/>
+                        <context context="announcement"/>
+                    </device>
+                </group>
+            </volumeGroups>
+        </zone>
+    </zones>
+</carAudioConfiguration>
diff --git a/hal/audio/6.0/ext_pcm.c b/hal/audio/6.0/ext_pcm.c
new file mode 100644
index 0000000..b1519f5
--- /dev/null
+++ b/hal/audio/6.0/ext_pcm.c
@@ -0,0 +1,195 @@
+/*
+ * Copyright (C) 2018 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.
+ */
+
+#define LOG_TAG "audio_hw_generic"
+
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <log/log.h>
+#include <cutils/str_parms.h>
+
+#include "ext_pcm.h"
+
+static pthread_mutex_t ext_pcm_init_lock = PTHREAD_MUTEX_INITIALIZER;
+static struct ext_pcm *shared_ext_pcm = NULL;
+
+// Sleep 10ms between each mixing, this interval value is arbitrary chosen
+#define MIXER_INTERVAL_MS 10
+#define MAX(a, b) (((a) > (b)) ? (a) : (b))
+#define MIN(a, b) (((a) < (b)) ? (a) : (b))
+
+/* copied from libcutils/str_parms.c */
+static bool str_eq(void *key_a, void *key_b) {
+  return !strcmp((const char *)key_a, (const char *)key_b);
+}
+
+/**
+ * use djb hash unless we find it inadequate.
+ * copied from libcutils/str_parms.c
+ */
+#ifdef __clang__
+__attribute__((no_sanitize("integer")))
+#endif
+static int str_hash_fn(void *str) {
+  uint32_t hash = 5381;
+  char *p;
+  for (p = str; p && *p; p++) {
+    hash = ((hash << 5) + hash) + *p;
+  }
+  return (int)hash;
+}
+
+static bool mixer_thread_mix(__unused void *key, void *value, void *context) {
+  struct ext_mixer_pipeline *pipeline_out = (struct ext_mixer_pipeline *)context;
+  struct ext_mixer_pipeline *pipeline_in = (struct ext_mixer_pipeline *)value;
+  pipeline_out->position = MAX(pipeline_out->position, pipeline_in->position);
+  for (int i = 0; i < pipeline_out->position; i++) {
+    float mixed = pipeline_out->buffer[i] + pipeline_in->buffer[i];
+    if (mixed > INT16_MAX) pipeline_out->buffer[i] = INT16_MAX;
+    else if (mixed < INT16_MIN) pipeline_out->buffer[i] = INT16_MIN;
+    else pipeline_out->buffer[i] = (int16_t)mixed;
+  }
+  memset(pipeline_in, 0, sizeof(struct ext_mixer_pipeline));
+  return true;
+}
+
+static void *mixer_thread_loop(void *context) {
+  ALOGD("%s: __enter__", __func__);
+  struct ext_pcm *ext_pcm = (struct ext_pcm *)context;
+  do {
+    pthread_mutex_lock(&ext_pcm->mixer_lock);
+    ext_pcm->mixer_pipeline.position = 0;
+    // Combine the output from every pipeline into one output buffer
+    hashmapForEach(ext_pcm->mixer_pipeline_map, mixer_thread_mix,
+        &ext_pcm->mixer_pipeline);
+    if (ext_pcm->mixer_pipeline.position > 0) {
+      pcm_write(ext_pcm->pcm, (void *)ext_pcm->mixer_pipeline.buffer,
+          ext_pcm->mixer_pipeline.position * sizeof(int16_t));
+    }
+    memset(&ext_pcm->mixer_pipeline, 0, sizeof(struct ext_mixer_pipeline));
+    pthread_mutex_unlock(&ext_pcm->mixer_lock);
+    usleep(MIXER_INTERVAL_MS * 1000);
+  } while (1);
+}
+
+static int mixer_pipeline_write(struct ext_pcm *ext_pcm, const char *bus_address,
+                                const void *data, unsigned int count) {
+  pthread_mutex_lock(&ext_pcm->mixer_lock);
+  struct ext_mixer_pipeline *pipeline = hashmapGet(
+      ext_pcm->mixer_pipeline_map, bus_address);
+  if (!pipeline) {
+    pipeline = calloc(1, sizeof(struct ext_mixer_pipeline));
+    hashmapPut(ext_pcm->mixer_pipeline_map, bus_address, pipeline);
+  }
+  unsigned int byteCount = MIN(count,
+      (MIXER_BUFFER_SIZE - pipeline->position) * sizeof(int16_t));
+  unsigned int int16Count = byteCount / sizeof(int16_t);
+  if (int16Count > 0) {
+    memcpy(&pipeline->buffer[pipeline->position], data, byteCount);
+    pipeline->position += int16Count;
+  }
+  pthread_mutex_unlock(&ext_pcm->mixer_lock);
+  return 0;
+}
+
+struct ext_pcm *ext_pcm_open(unsigned int card, unsigned int device,
+                             unsigned int flags, struct pcm_config *config) {
+  pthread_mutex_lock(&ext_pcm_init_lock);
+  if (shared_ext_pcm == NULL) {
+    shared_ext_pcm = calloc(1, sizeof(struct ext_pcm));
+    pthread_mutex_init(&shared_ext_pcm->lock, (const pthread_mutexattr_t *) NULL);
+    shared_ext_pcm->pcm = pcm_open(card, device, flags, config);
+    pthread_mutex_init(&shared_ext_pcm->mixer_lock, (const pthread_mutexattr_t *)NULL);
+    pthread_create(&shared_ext_pcm->mixer_thread, (const pthread_attr_t *)NULL,
+            mixer_thread_loop, shared_ext_pcm);
+    shared_ext_pcm->mixer_pipeline_map = hashmapCreate(8, str_hash_fn, str_eq);
+  }
+  pthread_mutex_unlock(&ext_pcm_init_lock);
+
+  pthread_mutex_lock(&shared_ext_pcm->lock);
+  shared_ext_pcm->ref_count += 1;
+  pthread_mutex_unlock(&shared_ext_pcm->lock);
+
+  return shared_ext_pcm;
+}
+
+static bool mixer_free_pipeline(__unused void *key, void *value, void *context) {
+  struct ext_mixer_pipeline *pipeline = (struct ext_mixer_pipeline *)value;
+  free(pipeline);
+  return true;
+}
+
+int ext_pcm_close(struct ext_pcm *ext_pcm) {
+  if (ext_pcm == NULL || ext_pcm->pcm == NULL) {
+    return -EINVAL;
+  }
+
+  pthread_mutex_lock(&ext_pcm->lock);
+  ext_pcm->ref_count -= 1;
+  pthread_mutex_unlock(&ext_pcm->lock);
+
+  pthread_mutex_lock(&ext_pcm_init_lock);
+  if (ext_pcm->ref_count <= 0) {
+    pthread_mutex_destroy(&ext_pcm->lock);
+    pcm_close(ext_pcm->pcm);
+    pthread_mutex_destroy(&ext_pcm->mixer_lock);
+    hashmapForEach(ext_pcm->mixer_pipeline_map, mixer_free_pipeline,
+        (void *)NULL);
+    hashmapFree(ext_pcm->mixer_pipeline_map);
+    pthread_kill(ext_pcm->mixer_thread, SIGINT);
+    free(ext_pcm);
+    shared_ext_pcm = NULL;
+  }
+  pthread_mutex_unlock(&ext_pcm_init_lock);
+  return 0;
+}
+
+int ext_pcm_is_ready(struct ext_pcm *ext_pcm) {
+  if (ext_pcm == NULL || ext_pcm->pcm == NULL) {
+    return 0;
+  }
+
+  return pcm_is_ready(ext_pcm->pcm);
+}
+
+int ext_pcm_write(struct ext_pcm *ext_pcm, const char *address,
+                  const void *data, unsigned int count) {
+  if (ext_pcm == NULL || ext_pcm->pcm == NULL) {
+    return -EINVAL;
+  }
+
+  return mixer_pipeline_write(ext_pcm, address, data, count);
+}
+
+const char *ext_pcm_get_error(struct ext_pcm *ext_pcm) {
+  if (ext_pcm == NULL || ext_pcm->pcm == NULL) {
+    return NULL;
+  }
+
+  return pcm_get_error(ext_pcm->pcm);
+}
+
+unsigned int ext_pcm_frames_to_bytes(struct ext_pcm *ext_pcm,
+                                     unsigned int frames) {
+  if (ext_pcm == NULL || ext_pcm->pcm == NULL) {
+    return -EINVAL;
+  }
+
+  return pcm_frames_to_bytes(ext_pcm->pcm, frames);
+}
diff --git a/hal/audio/6.0/ext_pcm.h b/hal/audio/6.0/ext_pcm.h
new file mode 100644
index 0000000..0bc8df5
--- /dev/null
+++ b/hal/audio/6.0/ext_pcm.h
@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2018 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 EXT_PCM_H
+#define EXT_PCM_H
+
+#include <pthread.h>
+
+#include <cutils/hashmap.h>
+#include <tinyalsa/asoundlib.h>
+
+// Holds up to 4KB buffer for each mixer pipeline, this value is arbitrary chosen
+#define MIXER_BUFFER_SIZE (1024 * 4)
+
+struct ext_mixer_pipeline {
+  int16_t buffer[MIXER_BUFFER_SIZE];
+  unsigned int position;
+};
+
+struct ext_pcm {
+  struct pcm *pcm;
+  pthread_mutex_t lock;
+  unsigned int ref_count;
+  pthread_mutex_t mixer_lock;
+  struct ext_mixer_pipeline mixer_pipeline;
+  pthread_t mixer_thread;
+  Hashmap *mixer_pipeline_map;
+};
+
+struct ext_pcm *ext_pcm_open(unsigned int card, unsigned int device,
+                             unsigned int flags, struct pcm_config *config);
+int ext_pcm_close(struct ext_pcm *ext_pcm);
+int ext_pcm_is_ready(struct ext_pcm *ext_pcm);
+int ext_pcm_write(struct ext_pcm *ext_pcm, const char *bus_address,
+                  const void *data, unsigned int count);
+const char *ext_pcm_get_error(struct ext_pcm *ext_pcm);
+unsigned int ext_pcm_frames_to_bytes(struct ext_pcm *ext_pcm,
+                                     unsigned int frames);
+
+#endif  // EXT_PCM_H
diff --git a/hal/audio/6.0/overlay/frameworks/base/core/res/res/values/config.xml b/hal/audio/6.0/overlay/frameworks/base/core/res/res/values/config.xml
new file mode 100644
index 0000000..b256c8b
--- /dev/null
+++ b/hal/audio/6.0/overlay/frameworks/base/core/res/res/values/config.xml
@@ -0,0 +1,8 @@
+<resources>
+    <!-- Car uses hardware amplifier for volume. -->
+    <bool name="config_useFixedVolume">true</bool>
+    <!--
+      Handle volume keys directly in CarAudioService without passing them to the foreground app
+    -->
+    <bool name="config_handleVolumeKeysInWindowManager">true</bool>
+</resources>
diff --git a/hal/audio/6.0/overlay/packages/services/Car/service/res/values/config.xml b/hal/audio/6.0/overlay/packages/services/Car/service/res/values/config.xml
new file mode 100644
index 0000000..28857b3
--- /dev/null
+++ b/hal/audio/6.0/overlay/packages/services/Car/service/res/values/config.xml
@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+/*
+** Copyright 2018, 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.
+*/
+-->
+
+<!--
+  Overlay resources to configure car service based on each OEM's preference.
+  See also packages/services/Car/service/res/values/config.xml
+-->
+<resources>
+    <bool name="audioUseDynamicRouting">true</bool>
+</resources>
diff --git a/hal/dumpstate/1.1/DumpstateDevice.cpp b/hal/dumpstate/1.1/DumpstateDevice.cpp
index 4eebc6a..5e419fe 100644
--- a/hal/dumpstate/1.1/DumpstateDevice.cpp
+++ b/hal/dumpstate/1.1/DumpstateDevice.cpp
@@ -119,14 +119,14 @@
     return true;
 }
 
-void DumpstateDevice::dumpHelperSystem(int textFd, int binFd) {
+bool DumpstateDevice::dumpHelperSystem(int textFd, int binFd) {
     std::string helperSystemLogDir =
             android::base::GetProperty(VENDOR_HELPER_SYSTEM_LOG_LOC_PROPERTY, "");
 
     if (helperSystemLogDir.empty()) {
         LOG(ERROR) << "Helper system log location '" << VENDOR_HELPER_SYSTEM_LOG_LOC_PROPERTY
                    << "' not set";
-        return;
+        return false;
     }
 
     std::error_code error;
@@ -135,14 +135,22 @@
     if (!fs::create_directories(helperSysLogPath, error)) {
         LOG(ERROR) << "Failed to create the dumping log directory " << helperSystemLogDir << ": "
                    << error;
-        return;
+        return false;
     }
 
     if (!fs::is_directory(helperSysLogPath)) {
         LOG(ERROR) << helperSystemLogDir << " is not a directory";
-        return;
+        return false;
     }
 
+    if (!isHealthy()) {
+        LOG(ERROR) << "Failed to connect to the dumpstate server";
+        return false;
+    }
+
+    // When start dumping, we always return success to keep dumped logs
+    // even if some of them are failed
+
     {
         // Dumping system logs
         ::grpc::ClientContext context;
@@ -170,6 +178,7 @@
         LOG(ERROR) << "Failed to clear the dumping log directory " << helperSystemLogDir << ": "
                    << error;
     }
+    return true;
 }
 
 bool DumpstateDevice::isHealthy() {
@@ -222,7 +231,9 @@
     const int textFd = handle->data[0];
     const int binFd = handle->numFds >= 2 ? handle->data[1] : -1;
 
-    dumpHelperSystem(textFd, binFd);
+    if (!dumpHelperSystem(textFd, binFd)) {
+        return DumpstateStatus::DEVICE_LOGGING_NOT_ENABLED;
+    }
 
     return DumpstateStatus::OK;
 }
@@ -236,6 +247,26 @@
     return android::base::GetBoolProperty(VENDOR_VERBOSE_LOGGING_ENABLED_PROPERTY, false);
 }
 
+Return<void> DumpstateDevice::debug(const hidl_handle& h, const hidl_vec<hidl_string>& options) {
+    if (h.getNativeHandle() == nullptr || h->numFds == 0) {
+        LOG(ERROR) << "Invalid FD passed to debug() function";
+        return Void();
+    }
+
+    const int fd = h->data[0];
+    auto pf = [fd](std::string s) -> void { dprintf(fd, "%s\n", s.c_str()); };
+    debugDumpServices(pf);
+
+    return Void();
+}
+
+void DumpstateDevice::debugDumpServices(std::function<void(std::string)> f) {
+    f("Available services for Dumpstate:");
+    for (const auto& svc : getAvailableServices()) {
+        f("  " + svc);
+    }
+}
+
 sp<DumpstateDevice> makeVirtualizationDumpstateDevice(const std::string& addr) {
     return new DumpstateDevice(addr);
 }
diff --git a/hal/dumpstate/1.1/DumpstateDevice.h b/hal/dumpstate/1.1/DumpstateDevice.h
index c199f9c..0b40a11 100644
--- a/hal/dumpstate/1.1/DumpstateDevice.h
+++ b/hal/dumpstate/1.1/DumpstateDevice.h
@@ -18,6 +18,7 @@
 #include <android/hardware/dumpstate/1.1/IDumpstateDevice.h>
 
 #include <automotive/filesystem>
+#include <functional>
 
 #include <grpc++/grpc++.h>
 
@@ -43,11 +44,15 @@
 
     bool isHealthy();
 
+    Return<void> debug(const hidl_handle& fd, const hidl_vec<hidl_string>& options);
+
   private:
     bool dumpRemoteLogs(::grpc::ClientReaderInterface<dumpstate_proto::DumpstateBuffer>* reader,
                         const fs::path& dumpPath);
 
-    void dumpHelperSystem(int textFd, int binFd);
+    bool dumpHelperSystem(int textFd, int binFd);
+
+    void debugDumpServices(std::function<void(std::string)> f);
 
     std::vector<std::string> getAvailableServices();
 
diff --git a/hal/dumpstate/1.1/service.cpp b/hal/dumpstate/1.1/service.cpp
index 09ead42..5c0f08a 100644
--- a/hal/dumpstate/1.1/service.cpp
+++ b/hal/dumpstate/1.1/service.cpp
@@ -60,7 +60,7 @@
 
     auto dumpstate = makeVirtualizationDumpstateDevice(si->str());
     // This method MUST be called before interacting with any HIDL interfaces.
-    configureRpcThreadpool(1, true);
+    configureRpcThreadpool(2, true);
     if (dumpstate->registerAsService() != OK) {
         ALOGE("Could not register service.");
         return 1;
diff --git a/hal/sensors/2.0/Sensor.cpp b/hal/sensors/2.0/Sensor.cpp
index a525754..b5288e2 100644
--- a/hal/sensors/2.0/Sensor.cpp
+++ b/hal/sensors/2.0/Sensor.cpp
@@ -122,30 +122,25 @@
 
 void HWSensorBase::processScanData(uint8_t* data, Event* evt) {
     float channelData[NUM_OF_CHANNEL_SUPPORTED - 1];
-    int64_t ts;
     unsigned int chanIdx;
     evt->sensorHandle = mSensorInfo.sensorHandle;
     evt->sensorType = mSensorInfo.type;
     for (auto i = 0u; i < miio_data.channelInfo.size(); i++) {
         chanIdx = miio_data.channelInfo[i].index;
-        if (miio_data.channelInfo[i].sign) {
-            int64_t val = *reinterpret_cast<int64_t*>(
-                    data + chanIdx * miio_data.channelInfo[i].storage_bytes);
-            if (chanIdx == (miio_data.channelInfo.size() - 1)) {
-                ts = val;
-            } else {
-                channelData[chanIdx] = (static_cast<float>(val) * miio_data.resolution);
-            }
+        const int64_t val = *reinterpret_cast<int64_t*>(
+                data + chanIdx * miio_data.channelInfo[i].storage_bytes);
+
+        // If the channel index is the last, it is timestamp
+        // else it is sensor data
+        if (chanIdx == miio_data.channelInfo.size() - 1) {
+            evt->timestamp = val;
         } else {
-            uint64_t val = *reinterpret_cast<uint64_t*>(
-                    data + chanIdx * miio_data.channelInfo[i].storage_bytes);
             channelData[chanIdx] = (static_cast<float>(val) * miio_data.resolution);
         }
     }
     evt->u.vec3.x = channelData[0];
     evt->u.vec3.y = channelData[1];
     evt->u.vec3.z = channelData[2];
-    evt->timestamp = ts;
     evt->u.vec3.status = SensorStatus::ACCURACY_HIGH;
 }
 
diff --git a/product_files/odm/usr/idc/Vendor_0fff_Product_0fff.idc b/product_files/odm/usr/idc/Vendor_0fff_Product_0fff.idc
new file mode 100644
index 0000000..8e9d4d6
--- /dev/null
+++ b/product_files/odm/usr/idc/Vendor_0fff_Product_0fff.idc
@@ -0,0 +1 @@
+device.internal = 1
diff --git a/product_files/vendor/etc/input-port-associations.xml b/product_files/vendor/etc/input-port-associations.xml
deleted file mode 100644
index ed849a1..0000000
--- a/product_files/vendor/etc/input-port-associations.xml
+++ /dev/null
@@ -1,4 +0,0 @@
-<ports>
-    <port display="0" input="virtio0/input0"/>
-    <port display="0" input="virtio1/input0"/>
-</ports>
diff --git a/tests/hal/dumpstate/1.1/Android.bp b/tests/hal/dumpstate/1.1/Android.bp
new file mode 100644
index 0000000..7142fb2
--- /dev/null
+++ b/tests/hal/dumpstate/1.1/Android.bp
@@ -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.
+
+android_test {
+    name: "TroutDumpstateTest",
+    srcs: ["src/**/*.java"],
+    sdk_version: "current",
+    static_libs: [
+        "android.hardware.dumpstate-V1.1-java",
+        "android-support-test",
+        "apache-commons-compress",
+        "hwbinder",
+    ],
+    certificate: "platform",
+    test_suites: ["device-tests"],
+}
diff --git a/tests/hal/dumpstate/1.1/AndroidManifest.xml b/tests/hal/dumpstate/1.1/AndroidManifest.xml
new file mode 100644
index 0000000..5f97988
--- /dev/null
+++ b/tests/hal/dumpstate/1.1/AndroidManifest.xml
@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 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.
+-->
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="com.android.trout.dumpstate.tests" >
+
+    <application>
+        <uses-library android:name="android.test.runner" />
+    </application>
+
+    <instrumentation android:name="android.support.test.runner.AndroidJUnitRunner"
+                     android:targetPackage="com.android.trout.dumpstate.tests" />
+</manifest>
diff --git a/tests/hal/dumpstate/1.1/src/com/android/trout/dumpstate/tests/DumpstateE2eTests.java b/tests/hal/dumpstate/1.1/src/com/android/trout/dumpstate/tests/DumpstateE2eTests.java
new file mode 100644
index 0000000..bbe2f9c
--- /dev/null
+++ b/tests/hal/dumpstate/1.1/src/com/android/trout/dumpstate/tests/DumpstateE2eTests.java
@@ -0,0 +1,90 @@
+/*
+ * 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.
+ */
+package com.android.trout.dumpstate.tests;
+
+import android.hardware.dumpstate.V1_1.DumpstateMode;
+import android.hardware.dumpstate.V1_1.DumpstateStatus;
+import android.hardware.dumpstate.V1_1.IDumpstateDevice;
+import android.os.NativeHandle;
+import android.support.test.filters.MediumTest;
+import android.util.Log;
+import java.io.File;
+import java.io.FileDescriptor;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import org.apache.commons.compress.archivers.ArchiveStreamFactory;
+import org.apache.commons.compress.archivers.tar.TarArchiveEntry;
+import org.apache.commons.compress.archivers.tar.TarArchiveInputStream;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Tests used to validate Trout dumpstate E2E functionality.
+ */
+@RunWith(JUnit4.class)
+public class DumpstateE2eTests {
+    private static final String TAG = DumpstateE2eTests.class.getSimpleName();
+    private IDumpstateDevice mDevice;
+
+    @Rule public TemporaryFolder mTempFolder = new TemporaryFolder();
+
+    @Before
+    public void setUp() throws Exception {
+        mDevice = android.hardware.dumpstate.V1_1.IDumpstateDevice.getService(true /* retry */);
+    }
+
+    @Test
+    @MediumTest
+    public void testDumpstateBoard() throws Exception {
+        File dumpstate_board_txt_file = mTempFolder.newFile();
+        File dumpstate_board_bin_file = mTempFolder.newFile();
+
+        try (FileOutputStream dumpstate_board_txt_ostream =
+                        new FileOutputStream(dumpstate_board_txt_file.getPath());
+                FileOutputStream dumpstate_board_bin_ostream =
+                        new FileOutputStream(dumpstate_board_bin_file.getPath());) {
+            NativeHandle handle = new NativeHandle(
+                    new FileDescriptor[] {
+                            dumpstate_board_txt_ostream.getFD(),
+                            dumpstate_board_bin_ostream.getFD(),
+                    },
+                    new int[0], false);
+            int dumping_status = mDevice.dumpstateBoard_1_1(
+                    handle, DumpstateMode.DEFAULT, 10 * 1000 /* milliseconds */);
+            Assert.assertEquals(DumpstateStatus.OK, dumping_status);
+        }
+
+        Assert.assertNotEquals(0, dumpstate_board_txt_file.length());
+        Assert.assertNotEquals(0, dumpstate_board_bin_file.length());
+
+        try (FileInputStream dumpstate_board_tar_istream =
+                        new FileInputStream(dumpstate_board_bin_file.getPath());
+                TarArchiveInputStream tar_stream =
+                        (TarArchiveInputStream) new ArchiveStreamFactory().createArchiveInputStream(
+                                "tar", dumpstate_board_tar_istream);) {
+            // Traversing the tar package to make sure it is valid
+            TarArchiveEntry tar_entry = null;
+            while ((tar_entry = (TarArchiveEntry) tar_stream.getNextEntry()) != null) {
+                Log.d(TAG, tar_entry.getName());
+            }
+        }
+    }
+}