n5110: initial commit

51 files changed, 6349 insertions, 0 deletions

diff --git a/Android.mk b/Android.mk
new file mode 100644
index 0000000..23ce42c
--- /dev/null
+++ b/Android.mk
@@ -0,0 +1,23 @@
+#
+# Copyright (C) 2012 The CyanogenMod 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.
+#
+
+LOCAL_PATH := $(call my-dir)
+
+ifeq ($(TARGET_DEVICE),n5110)
+
+include $(call all-makefiles-under,$(LOCAL_PATH))
+
+endif
diff --git a/AndroidProducts.mk b/AndroidProducts.mk
new file mode 100644
index 0000000..7143952
--- /dev/null
+++ b/AndroidProducts.mk
@@ -0,0 +1,18 @@
+#
+# Copyright (C) 2012 The CyanogenMod 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.
+#
+
+PRODUCT_MAKEFILES := \
+    $(LOCAL_DIR)/full_n5110.mk
diff --git a/BoardConfig.mk b/BoardConfig.mk
new file mode 100644
index 0000000..75a3671
--- /dev/null
+++ b/BoardConfig.mk
@@ -0,0 +1,44 @@
+#
+# Copyright (C) 2012 The CyanogenMod 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.
+#
+
+# This variable is set first, so it can be overridden
+# by BoardConfigVendor.mk
+-include device/samsung/smdk4412-common/BoardCommonConfig.mk
+
+LOCAL_PATH := device/samsung/n5110
+
+# Bluetooth
+BOARD_BLUETOOTH_BDROID_BUILDCFG_INCLUDE_DIR := $(LOCAL_PATH)/bluetooth
+BOARD_BLUEDROID_VENDOR_CONF := $(LOCAL_PATH)/bluetooth/vnd_n5110.txt
+
+# Inline kernel building
+TARGET_KERNEL_SOURCE := kernel/samsung/smdk4412
+TARGET_KERNEL_CONFIG := cyanogenmod_n5110_defconfig
+
+# Camera
+COMMON_GLOBAL_CFLAGS += -DCAMERA_WITH_CITYID_PARAM
+
+# Charging mode
+BOARD_CHARGING_MODE_BOOTING_LPM := /sys/class/power_supply/battery/batt_lp_charging
+BOARD_BATTERY_DEVICE_NAME := "battery"
+BOARD_CHARGER_RES := device/samsung/n5110/res/charger
+
+# Recovery
+# inherit from the proprietary version
+-include vendor/samsung/n5110/BoardConfigVendor.mk
+
+# assert
+TARGET_OTA_ASSERT_DEVICE := konawifixx,n5110,GT-N5110,konawifi
diff --git a/README b/README
new file mode 100644
index 0000000..0a398a0
--- /dev/null
+++ b/README
@@ -0,0 +1,10 @@
+Device configuration for the Samsung Galaxy Note 8.0 WiFi
+GT-N5110
+
+Copyright (C) 2013 The CyanogenMod 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
diff --git a/audio/Android.mk b/audio/Android.mk
new file mode 100644
index 0000000..4655db0
--- /dev/null
+++ b/audio/Android.mk
@@ -0,0 +1,33 @@
+# Copyright (C) 2011 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.
+
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := audio.primary.$(TARGET_BOOTLOADER_BOARD_NAME)
+LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/hw
+LOCAL_MODULE_TAGS := optional
+
+LOCAL_SRC_FILES := audio_hw.c ril_interface.c
+
+LOCAL_C_INCLUDES += \
+	external/tinyalsa/include \
+	external/expat/lib \
+	$(call include-path-for, audio-utils) \
+	$(call include-path-for, audio-effects)
+
+LOCAL_SHARED_LIBRARIES := liblog libcutils libtinyalsa libaudioutils libdl libexpat
+
+include $(BUILD_SHARED_LIBRARY)
diff --git a/audio/audio_hw.c b/audio/audio_hw.c
new file mode 100755
index 0000000..e4f5edf
--- /dev/null
+++ b/audio/audio_hw.c
@@ -0,0 +1,3027 @@
+/*
+ * Copyright (C) 2011 The Android Open Source Project
+ * Copyright (C) 2012 Wolfson Microelectronics plc
+ * Copyright (C) 2012 The CyanogenMod Project
+ *               Daniel Hillenbrand <codeworkx@cyanogenmod.com>
+ *               Guillaume "XpLoDWilD" Lesniak <xplodgui@gmail.com>
+ *
+ * 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_primary"
+#define LOG_NDEBUG 0
+
+#include <errno.h>
+#include <pthread.h>
+#include <stdint.h>
+#include <sys/time.h>
+#include <stdlib.h>
+#include <expat.h>
+
+#include <cutils/log.h>
+#include <cutils/str_parms.h>
+#include <cutils/properties.h>
+
+#include <hardware/hardware.h>
+#include <system/audio.h>
+#include <hardware/audio.h>
+
+#include <tinyalsa/asoundlib.h>
+#include <audio_utils/resampler.h>
+#include <audio_utils/echo_reference.h>
+#include <hardware/audio_effect.h>
+#include <audio_effects/effect_aec.h>
+
+#include "audio_hw.h"
+#include "ril_interface.h"
+
+struct pcm_config pcm_config_mm = {
+    .channels = 2,
+    .rate = MM_FULL_POWER_SAMPLING_RATE,
+    .period_size = DEEP_BUFFER_LONG_PERIOD_SIZE,
+    .period_count = PLAYBACK_DEEP_BUFFER_LONG_PERIOD_COUNT,
+    .format = PCM_FORMAT_S16_LE,
+};
+
+struct pcm_config pcm_config_tones = {
+    .channels = 2,
+    .rate = MM_FULL_POWER_SAMPLING_RATE,
+    .period_size = SHORT_PERIOD_SIZE,
+    .period_count = PLAYBACK_SHORT_PERIOD_COUNT,
+    .format = PCM_FORMAT_S16_LE,
+    .start_threshold = 0,
+    .avail_min = 0,
+};
+
+struct pcm_config pcm_config_capture = {
+    .channels = 2,
+    .rate = DEFAULT_IN_SAMPLING_RATE,
+    .period_size = CAPTURE_PERIOD_SIZE,
+    .period_count = CAPTURE_PERIOD_COUNT,
+    .format = PCM_FORMAT_S16_LE,
+};
+
+struct pcm_config pcm_config_vx = {
+    .channels = 2,
+    .rate = VX_NB_SAMPLING_RATE,
+    .period_size = 160,
+    .period_count = 2,
+    .format = PCM_FORMAT_S16_LE,
+};
+
+#define MIN(x, y) ((x) > (y) ? (y) : (x))
+
+struct m0_audio_device {
+    struct audio_hw_device hw_device;
+
+    pthread_mutex_t lock;       /* see note below on mutex acquisition order */
+    struct m0_dev_cfg *dev_cfgs;
+    int num_dev_cfgs;
+    struct mixer *mixer;
+    struct mixer_ctls mixer_ctls;
+    audio_mode_t mode;
+    int active_out_device;
+    int out_device;
+    int active_in_device;
+    int in_device;
+    struct pcm *pcm_modem_dl;
+    struct pcm *pcm_modem_ul;
+    int in_call;
+    float voice_volume;
+    struct m0_stream_in *active_input;
+    struct m0_stream_out *outputs[OUTPUT_TOTAL];
+    bool mic_mute;
+    int tty_mode;
+    struct echo_reference_itfe *echo_reference;
+    bool bluetooth_nrec;
+    int wb_amr;
+    bool screen_off;
+
+    /* RIL */
+    struct ril_handle ril;
+};
+
+struct m0_stream_out {
+    struct audio_stream_out stream;
+
+    pthread_mutex_t lock;       /* see note below on mutex acquisition order */
+    struct pcm_config config[PCM_TOTAL];
+    struct pcm *pcm[PCM_TOTAL];
+    struct resampler_itfe *resampler;
+    char *buffer;
+    size_t buffer_frames;
+    int standby;
+    struct echo_reference_itfe *echo_reference;
+    int write_threshold;
+    bool use_long_periods;
+    audio_channel_mask_t channel_mask;
+    audio_channel_mask_t sup_channel_masks[3];
+
+    struct m0_audio_device *dev;
+};
+
+#define MAX_PREPROCESSORS 3 /* maximum one AGC + one NS + one AEC per input stream */
+
+struct effect_info_s {
+    effect_handle_t effect_itfe;
+    size_t num_channel_configs;
+    channel_config_t* channel_configs;
+};
+
+#define NUM_IN_AUX_CNL_CONFIGS 2
+channel_config_t in_aux_cnl_configs[NUM_IN_AUX_CNL_CONFIGS] = {
+    { AUDIO_CHANNEL_IN_FRONT , AUDIO_CHANNEL_IN_BACK},
+    { AUDIO_CHANNEL_IN_STEREO , AUDIO_CHANNEL_IN_RIGHT}
+};
+
+struct m0_stream_in {
+    struct audio_stream_in stream;
+
+    pthread_mutex_t lock;       /* see note below on mutex acquisition order */
+    struct pcm_config config;
+    struct pcm *pcm;
+    int device;
+    struct resampler_itfe *resampler;
+    struct resampler_buffer_provider buf_provider;
+    unsigned int requested_rate;
+    int standby;
+    int source;
+    struct echo_reference_itfe *echo_reference;
+    bool need_echo_reference;
+
+    int16_t *read_buf;
+    size_t read_buf_size;
+    size_t read_buf_frames;
+
+    int16_t *proc_buf_in;
+    int16_t *proc_buf_out;
+    size_t proc_buf_size;
+    size_t proc_buf_frames;
+
+    int16_t *ref_buf;
+    size_t ref_buf_size;
+    size_t ref_buf_frames;
+
+    int read_status;
+
+    int num_preprocessors;
+    struct effect_info_s preprocessors[MAX_PREPROCESSORS];
+
+    bool aux_channels_changed;
+    uint32_t main_channels;
+    uint32_t aux_channels;
+    struct m0_audio_device *dev;
+};
+
+struct m0_dev_cfg {
+    int mask;
+
+    struct route_setting *on;
+    unsigned int on_len;
+
+    struct route_setting *off;
+    unsigned int off_len;
+};
+
+/**
+ * NOTE: when multiple mutexes have to be acquired, always respect the following order:
+ *        hw device > in stream > out stream
+ */
+
+static void select_output_device(struct m0_audio_device *adev);
+static void select_input_device(struct m0_audio_device *adev);
+static int adev_set_voice_volume(struct audio_hw_device *dev, float volume);
+static int do_input_standby(struct m0_stream_in *in);
+static int do_output_standby(struct m0_stream_out *out);
+static void in_update_aux_channels(struct m0_stream_in *in, effect_handle_t effect);
+
+/* The enable flag when 0 makes the assumption that enums are disabled by
+ * "Off" and integers/booleans by 0 */
+static int set_bigroute_by_array(struct mixer *mixer, struct route_setting *route,
+                              int enable)
+{
+    struct mixer_ctl *ctl;
+    unsigned int i, j, ret;
+
+    /* Go through the route array and set each value */
+    i = 0;
+    while (route[i].ctl_name) {
+        ctl = mixer_get_ctl_by_name(mixer, route[i].ctl_name);
+        if (!ctl) {
+        ALOGE("Unknown control '%s'\n", route[i].ctl_name);
+            return -EINVAL;
+        }
+
+        if (route[i].strval) {
+            if (enable) {
+                ret = mixer_ctl_set_enum_by_string(ctl, route[i].strval);
+                if (ret != 0) {
+                    ALOGE("Failed to set '%s' to '%s'\n", route[i].ctl_name, route[i].strval);
+                } else {
+                    ALOGV("Set '%s' to '%s'\n", route[i].ctl_name, route[i].strval);
+                }
+            } else {
+                ret = mixer_ctl_set_enum_by_string(ctl, "Off");
+                if (ret != 0) {
+                    ALOGE("Failed to set '%s' to '%s'\n", route[i].ctl_name, route[i].strval);
+                } else {
+                    ALOGV("Set '%s' to '%s'\n", route[i].ctl_name, "Off");
+                }
+            }
+        } else {
+            /* This ensures multiple (i.e. stereo) values are set jointly */
+            for (j = 0; j < mixer_ctl_get_num_values(ctl); j++) {
+                if (enable) {
+                    ret = mixer_ctl_set_value(ctl, j, route[i].intval);
+                    if (ret != 0) {
+                        ALOGE("Failed to set '%s' to '%d'\n", route[i].ctl_name, route[i].intval);
+                    } else {
+                        ALOGV("Set '%s' to '%d'\n", route[i].ctl_name, route[i].intval);
+                    }
+                } else {
+                    ret = mixer_ctl_set_value(ctl, j, 0);
+                    if (ret != 0) {
+                        ALOGE("Failed to set '%s' to '%d'\n", route[i].ctl_name, route[i].intval);
+                    } else {
+                        ALOGV("Set '%s' to '%d'\n", route[i].ctl_name, 0);
+                    }
+                }
+            }
+        }
+        i++;
+    }
+
+    return 0;
+}
+
+/* The enable flag when 0 makes the assumption that enums are disabled by
+ * "Off" and integers/booleans by 0 */
+static int set_route_by_array(struct mixer *mixer, struct route_setting *route,
+                  unsigned int len)
+{
+    struct mixer_ctl *ctl;
+    unsigned int i, j, ret;
+
+    /* Go through the route array and set each value */
+    for (i = 0; i < len; i++) {
+        ctl = mixer_get_ctl_by_name(mixer, route[i].ctl_name);
+        if (!ctl) {
+        ALOGE("Unknown control '%s'\n", route[i].ctl_name);
+            return -EINVAL;
+        }
+
+        if (route[i].strval) {
+        ret = mixer_ctl_set_enum_by_string(ctl, route[i].strval);
+        if (ret != 0) {
+        ALOGE("Failed to set '%s' to '%s'\n",
+             route[i].ctl_name, route[i].strval);
+        } else {
+        ALOGV("Set '%s' to '%s'\n",
+             route[i].ctl_name, route[i].strval);
+        }
+
+        } else {
+            /* This ensures multiple (i.e. stereo) values are set jointly */
+            for (j = 0; j < mixer_ctl_get_num_values(ctl); j++) {
+        ret = mixer_ctl_set_value(ctl, j, route[i].intval);
+        if (ret != 0) {
+            ALOGE("Failed to set '%s'.%d to %d\n",
+             route[i].ctl_name, j, route[i].intval);
+        } else {
+            ALOGV("Set '%s'.%d to %d\n",
+             route[i].ctl_name, j, route[i].intval);
+        }
+        }
+        }
+    }
+
+    return 0;
+}
+
+/* Must be called with lock */
+void select_devices(struct m0_audio_device *adev)
+{
+    int i;
+
+    if (adev->active_out_device == adev->out_device && adev->active_in_device == adev->in_device)
+    return;
+
+    ALOGV("Changing output device %x => %x\n", adev->active_out_device, adev->out_device);
+    ALOGV("Changing input device %x => %x\n", adev->active_in_device, adev->in_device);
+
+    /* Turn on new devices first so we don't glitch due to powerdown... */
+    for (i = 0; i < adev->num_dev_cfgs; i++)
+    if ((adev->out_device & adev->dev_cfgs[i].mask) &&
+        !(adev->active_out_device & adev->dev_cfgs[i].mask))
+        set_route_by_array(adev->mixer, adev->dev_cfgs[i].on,
+                   adev->dev_cfgs[i].on_len);
+
+    for (i = 0; i < adev->num_dev_cfgs; i++)
+    if ((adev->in_device & adev->dev_cfgs[i].mask) &&
+        !(adev->active_in_device & adev->dev_cfgs[i].mask))
+        set_route_by_array(adev->mixer, adev->dev_cfgs[i].on,
+                   adev->dev_cfgs[i].on_len);
+
+    /* ...then disable old ones. */
+    for (i = 0; i < adev->num_dev_cfgs; i++)
+    if (!(adev->out_device & adev->dev_cfgs[i].mask) &&
+        (adev->active_out_device & adev->dev_cfgs[i].mask))
+        set_route_by_array(adev->mixer, adev->dev_cfgs[i].off,
+                   adev->dev_cfgs[i].off_len);
+
+    for (i = 0; i < adev->num_dev_cfgs; i++)
+    if (!(adev->in_device & adev->dev_cfgs[i].mask) &&
+        (adev->active_in_device & adev->dev_cfgs[i].mask))
+        set_route_by_array(adev->mixer, adev->dev_cfgs[i].off,
+                   adev->dev_cfgs[i].off_len);
+
+    adev->active_out_device = adev->out_device;
+    adev->active_in_device = adev->in_device;
+}
+
+static int start_call(struct m0_audio_device *adev)
+{
+    ALOGE("Opening modem PCMs");
+    int bt_on;
+
+    bt_on = adev->out_device & AUDIO_DEVICE_OUT_ALL_SCO;
+    pcm_config_vx.rate = adev->wb_amr ? VX_WB_SAMPLING_RATE : VX_NB_SAMPLING_RATE;
+
+    /* Open modem PCM channels */
+    if (adev->pcm_modem_dl == NULL) {
+        if (bt_on)
+            adev->pcm_modem_dl = pcm_open(CARD_DEFAULT, PORT_BT, PCM_OUT, &pcm_config_vx);
+        else
+            adev->pcm_modem_dl = pcm_open(CARD_DEFAULT, PORT_MODEM, PCM_OUT, &pcm_config_vx);
+        if (!pcm_is_ready(adev->pcm_modem_dl)) {
+            ALOGE("cannot open PCM modem DL stream: %s", pcm_get_error(adev->pcm_modem_dl));
+            goto err_open_dl;
+        }
+    }
+
+    if (adev->pcm_modem_ul == NULL) {
+        adev->pcm_modem_ul = pcm_open(CARD_DEFAULT, PORT_MODEM, PCM_IN, &pcm_config_vx);
+        if (!pcm_is_ready(adev->pcm_modem_ul)) {
+            ALOGE("cannot open PCM modem UL stream: %s", pcm_get_error(adev->pcm_modem_ul));
+            goto err_open_ul;
+        }
+    }
+
+    pcm_start(adev->pcm_modem_dl);
+    pcm_start(adev->pcm_modem_ul);
+
+    return 0;
+
+err_open_ul:
+    pcm_close(adev->pcm_modem_ul);
+    adev->pcm_modem_ul = NULL;
+err_open_dl:
+    pcm_close(adev->pcm_modem_dl);
+    adev->pcm_modem_dl = NULL;
+
+    return -ENOMEM;
+}
+
+static void end_call(struct m0_audio_device *adev)
+{
+    ALOGE("Closing modem PCMs");
+    pcm_stop(adev->pcm_modem_dl);
+    pcm_stop(adev->pcm_modem_ul);
+    pcm_close(adev->pcm_modem_dl);
+    pcm_close(adev->pcm_modem_ul);
+    adev->pcm_modem_dl = NULL;
+    adev->pcm_modem_ul = NULL;
+
+    /* re-enable +30db boost on mics */
+    mixer_ctl_set_value(adev->mixer_ctls.mixinl_in1l_volume, 0, 1);
+    mixer_ctl_set_value(adev->mixer_ctls.mixinl_in2l_volume, 0, 1);
+}
+
+static void set_eq_filter(struct m0_audio_device *adev)
+{
+}
+
+void audio_set_wb_amr_callback(void *data, int enable)
+{
+    struct m0_audio_device *adev = (struct m0_audio_device *)data;
+
+    pthread_mutex_lock(&adev->lock);
+    if (adev->wb_amr != enable) {
+        adev->wb_amr = enable;
+
+        /* reopen the modem PCMs at the new rate */
+        if (adev->in_call) {
+            end_call(adev);
+            select_output_device(adev);
+            start_call(adev);
+        }
+    }
+    pthread_mutex_unlock(&adev->lock);
+}
+
+static void set_incall_device(struct m0_audio_device *adev)
+{
+    int device_type;
+
+    switch(adev->out_device) {
+        case AUDIO_DEVICE_OUT_EARPIECE:
+            device_type = SOUND_AUDIO_PATH_HANDSET;
+            break;
+        case AUDIO_DEVICE_OUT_SPEAKER:
+        case AUDIO_DEVICE_OUT_AUX_DIGITAL:
+        case AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET:
+            device_type = SOUND_AUDIO_PATH_SPEAKER;
+            break;
+        case AUDIO_DEVICE_OUT_WIRED_HEADSET:
+            device_type = SOUND_AUDIO_PATH_HEADSET;
+            break;
+        case AUDIO_DEVICE_OUT_WIRED_HEADPHONE:
+            device_type = SOUND_AUDIO_PATH_HEADPHONE;
+            break;
+        case AUDIO_DEVICE_OUT_BLUETOOTH_SCO:
+        case AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET:
+        case AUDIO_DEVICE_OUT_BLUETOOTH_SCO_CARKIT:
+            if (adev->bluetooth_nrec) {
+                device_type = SOUND_AUDIO_PATH_BLUETOOTH;
+            } else {
+                device_type = SOUND_AUDIO_PATH_BLUETOOTH_NO_NR;
+            }
+            break;
+        default:
+            device_type = SOUND_AUDIO_PATH_HANDSET;
+            break;
+    }
+
+    /* if output device isn't supported, open modem side to handset by default */
+    ALOGE("%s: ril_set_call_audio_path(%d)", __func__, device_type);
+    ril_set_call_audio_path(&adev->ril, device_type);
+}
+
+static void set_input_volumes(struct m0_audio_device *adev, int main_mic_on,
+                              int headset_mic_on, int sub_mic_on)
+{
+}
+
+static void set_output_volumes(struct m0_audio_device *adev, bool tty_volume)
+{
+}
+
+static void force_all_standby(struct m0_audio_device *adev)
+{
+    struct m0_stream_in *in;
+    struct m0_stream_out *out;
+
+    /* only needed for low latency output streams as other streams are not used
+     * for voice use cases */
+    if (adev->outputs[OUTPUT_LOW_LATENCY] != NULL &&
+            !adev->outputs[OUTPUT_LOW_LATENCY]->standby) {
+        out = adev->outputs[OUTPUT_LOW_LATENCY];
+        pthread_mutex_lock(&out->lock);
+        do_output_standby(out);
+        pthread_mutex_unlock(&out->lock);
+    }
+
+    if (adev->active_input) {
+        in = adev->active_input;
+        pthread_mutex_lock(&in->lock);
+        do_input_standby(in);
+        pthread_mutex_unlock(&in->lock);
+    }
+}
+
+static void select_mode(struct m0_audio_device *adev)
+{
+    if (adev->mode == AUDIO_MODE_IN_CALL) {
+        ALOGE("Entering IN_CALL state, in_call=%d", adev->in_call);
+        if (!adev->in_call) {
+            force_all_standby(adev);
+            /* force earpiece route for in call state if speaker is the
+            only currently selected route. This prevents having to tear
+            down the modem PCMs to change route from speaker to earpiece
+            after the ringtone is played, but doesn't cause a route
+            change if a headset or bt device is already connected. If
+            speaker is not the only thing active, just remove it from
+            the route. We'll assume it'll never be used initally during
+            a call. This works because we're sure that the audio policy
+            manager will update the output device after the audio mode
+            change, even if the device selection did not change. */
+            if (adev->out_device == AUDIO_DEVICE_OUT_SPEAKER) {
+                adev->out_device = AUDIO_DEVICE_OUT_EARPIECE;
+                adev->in_device = AUDIO_DEVICE_IN_BUILTIN_MIC & ~AUDIO_DEVICE_BIT_IN;
+            } else
+                adev->out_device &= ~AUDIO_DEVICE_OUT_SPEAKER;
+            select_output_device(adev);
+            start_call(adev);
+            ril_set_call_clock_sync(&adev->ril, SOUND_CLOCK_START);
+            adev_set_voice_volume(&adev->hw_device, adev->voice_volume);
+            adev->in_call = 1;
+        }
+    } else {
+        ALOGE("Leaving IN_CALL state, in_call=%d, mode=%d",
+             adev->in_call, adev->mode);
+        if (adev->in_call) {
+            adev->in_call = 0;
+            end_call(adev);
+            force_all_standby(adev);
+            select_output_device(adev);
+            select_input_device(adev);
+        }
+    }
+}
+
+static void select_output_device(struct m0_audio_device *adev)
+{
+    int headset_on;
+    int headphone_on;
+    int speaker_on;
+    int earpiece_on;
+    int bt_on;
+    bool tty_volume = false;
+    unsigned int channel;
+
+    headset_on = adev->out_device & AUDIO_DEVICE_OUT_WIRED_HEADSET;
+    headphone_on = adev->out_device & AUDIO_DEVICE_OUT_WIRED_HEADPHONE;
+    speaker_on = adev->out_device & AUDIO_DEVICE_OUT_SPEAKER;
+    earpiece_on = adev->out_device & AUDIO_DEVICE_OUT_EARPIECE;
+    bt_on = adev->out_device & AUDIO_DEVICE_OUT_ALL_SCO;
+
+    switch(adev->out_device) {
+        case AUDIO_DEVICE_OUT_SPEAKER:
+            ALOGD("%s: AUDIO_DEVICE_OUT_SPEAKER", __func__);
+            break;
+        case AUDIO_DEVICE_OUT_WIRED_HEADSET:
+            ALOGD("%s: AUDIO_DEVICE_OUT_WIRED_HEADSET", __func__);
+            break;
+        case AUDIO_DEVICE_OUT_WIRED_HEADPHONE:
+            ALOGD("%s: AUDIO_DEVICE_OUT_WIRED_HEADPHONE", __func__);
+            break;
+        case AUDIO_DEVICE_OUT_EARPIECE:
+            ALOGD("%s: AUDIO_DEVICE_OUT_EARPIECE", __func__);
+            break;
+        case AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET:
+            ALOGD("%s: AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET", __func__);
+            break;
+        case AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET:
+            ALOGD("%s: AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET", __func__);
+            break;
+        case AUDIO_DEVICE_OUT_ALL_SCO:
+            ALOGD("%s: AUDIO_DEVICE_OUT_ALL_SCO", __func__);
+            break;
+        default:
+            ALOGD("%s: AUDIO_DEVICE_OUT_ALL", __func__);
+            break;
+    }
+
+    select_devices(adev);
+
+    set_eq_filter(adev);
+
+    if (adev->mode == AUDIO_MODE_IN_CALL) {
+        if (!bt_on) {
+            /* force tx path according to TTY mode when in call */
+            switch(adev->tty_mode) {
+                case TTY_MODE_FULL:
+                case TTY_MODE_HCO:
+                    /* tx path from headset mic */
+                    headphone_on = 0;
+                    headset_on = 1;
+                    speaker_on = 0;
+                    earpiece_on = 0;
+                    break;
+                case TTY_MODE_VCO:
+                    /* tx path from device sub mic */
+                    headphone_on = 0;
+                    headset_on = 0;
+                    speaker_on = 1;
+                    earpiece_on = 0;
+                    break;
+                case TTY_MODE_OFF:
+                default:
+                    break;
+            }
+        }
+
+        if (headset_on || headphone_on || speaker_on || earpiece_on) {
+            ALOGD("%s: set voicecall route: voicecall_default", __func__);
+            set_bigroute_by_array(adev->mixer, voicecall_default, 1);
+        } else {
+            ALOGD("%s: set voicecall route: voicecall_default_disable", __func__);
+            set_bigroute_by_array(adev->mixer, voicecall_default_disable, 1);
+        }
+
+        if (speaker_on || earpiece_on || headphone_on) {
+            ALOGD("%s: set voicecall route: default_input", __func__);
+            set_bigroute_by_array(adev->mixer, default_input, 1);
+        } else {
+            ALOGD("%s: set voicecall route: default_input_disable", __func__);
+            set_bigroute_by_array(adev->mixer, default_input_disable, 1);
+        }
+
+        if (headset_on) {
+            ALOGD("%s: set voicecall route: headset_input", __func__);
+            set_bigroute_by_array(adev->mixer, headset_input, 1);
+        } else {
+            ALOGD("%s: set voicecall route: headset_input_disable", __func__);
+            set_bigroute_by_array(adev->mixer, headset_input_disable, 1);
+        }
+
+        if (bt_on) {
+            // bt uses a different port (PORT_BT) for playback, reopen the pcms
+            end_call(adev);
+            start_call(adev);
+            ALOGD("%s: set voicecall route: bt_input", __func__);
+            set_bigroute_by_array(adev->mixer, bt_input, 1);
+            ALOGD("%s: set voicecall route: bt_output", __func__);
+            set_bigroute_by_array(adev->mixer, bt_output, 1);
+        } else {
+            ALOGD("%s: set voicecall route: bt_disable", __func__);
+            set_bigroute_by_array(adev->mixer, bt_disable, 1);
+        }
+
+        set_incall_device(adev);
+    }
+}
+
+static void select_input_device(struct m0_audio_device *adev)
+{
+    switch(adev->in_device) {
+        case AUDIO_DEVICE_IN_BUILTIN_MIC:
+            ALOGD("%s: AUDIO_DEVICE_IN_BUILTIN_MIC", __func__);
+            break;
+        case AUDIO_DEVICE_IN_BACK_MIC:
+            ALOGD("%s: AUDIO_DEVICE_IN_BACK_MIC", __func__);
+            break;
+        case AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET:
+            ALOGD("%s: AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET", __func__);
+            break;
+        case AUDIO_DEVICE_IN_WIRED_HEADSET:
+            ALOGD("%s: AUDIO_DEVICE_IN_WIRED_HEADSET", __func__);
+            break;
+        default:
+            break;
+    }
+
+    select_devices(adev);
+}
+
+/* must be called with hw device and output stream mutexes locked */
+static int start_output_stream_low_latency(struct m0_stream_out *out)
+{
+    struct m0_audio_device *adev = out->dev;
+    unsigned int flags = PCM_OUT;
+    int i;
+    bool success = true;
+
+    if (adev->mode != AUDIO_MODE_IN_CALL) {
+        select_output_device(adev);
+    }
+
+    /* default to low power: will be corrected in out_write if necessary before first write to
+     * tinyalsa.
+     */
+
+    if (adev->out_device & ~(AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET | AUDIO_DEVICE_OUT_AUX_DIGITAL)) {
+        /* Something not a dock in use */
+        out->config[PCM_NORMAL] = pcm_config_tones;
+        out->config[PCM_NORMAL].rate = MM_FULL_POWER_SAMPLING_RATE;
+        out->pcm[PCM_NORMAL] = pcm_open(CARD_DEFAULT, PORT_PLAYBACK,
+                                            flags, &out->config[PCM_NORMAL]);
+    }
+
+    if (adev->out_device & AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET) {
+        /* SPDIF output in use */
+        out->config[PCM_SPDIF] = pcm_config_tones;
+        out->config[PCM_SPDIF].rate = MM_FULL_POWER_SAMPLING_RATE;
+        out->pcm[PCM_SPDIF] = pcm_open(CARD_DEFAULT, PORT_PLAYBACK,
+                                           flags, &out->config[PCM_SPDIF]);
+    }
+
+    /* Close any PCMs that could not be opened properly and return an error */
+    for (i = 0; i < PCM_TOTAL; i++) {
+        if (out->pcm[i] && !pcm_is_ready(out->pcm[i])) {
+            ALOGE("%s: cannot open pcm_out driver %d: %s", __func__ , i, pcm_get_error(out->pcm[i]));
+            pcm_close(out->pcm[i]);
+            out->pcm[i] = NULL;
+            success = false;
+        }
+    }
+
+    if (success) {
+        out->buffer_frames = pcm_config_tones.period_size * 2;
+        if (out->buffer == NULL)
+            out->buffer = malloc(out->buffer_frames * audio_stream_frame_size(&out->stream.common));
+
+        if (adev->echo_reference != NULL)
+            out->echo_reference = adev->echo_reference;
+        out->resampler->reset(out->resampler);
+
+        return 0;
+    }
+
+    return -ENOMEM;
+}
+
+/* must be called with hw device and output stream mutexes locked */
+static int start_output_stream_deep_buffer(struct m0_stream_out *out)
+{
+    struct m0_audio_device *adev = out->dev;
+
+    if (adev->mode != AUDIO_MODE_IN_CALL) {
+        select_output_device(adev);
+    }
+
+    out->write_threshold = PLAYBACK_DEEP_BUFFER_LONG_PERIOD_COUNT * DEEP_BUFFER_LONG_PERIOD_SIZE;
+    out->use_long_periods = true;
+
+    out->config[PCM_NORMAL] = pcm_config_mm;
+    out->config[PCM_NORMAL].rate = MM_FULL_POWER_SAMPLING_RATE;
+    out->pcm[PCM_NORMAL] = pcm_open(CARD_DEFAULT, PORT_PLAYBACK,
+                                        PCM_OUT | PCM_MMAP | PCM_NOIRQ, &out->config[PCM_NORMAL]);
+    if (out->pcm[PCM_NORMAL] && !pcm_is_ready(out->pcm[PCM_NORMAL])) {
+        ALOGE("%s: cannot open pcm_out driver: %s", __func__, pcm_get_error(out->pcm[PCM_NORMAL]));
+        pcm_close(out->pcm[PCM_NORMAL]);
+        out->pcm[PCM_NORMAL] = NULL;
+        return -ENOMEM;
+    }
+    out->buffer_frames = DEEP_BUFFER_SHORT_PERIOD_SIZE * 2;
+    if (out->buffer == NULL)
+        out->buffer = malloc(PLAYBACK_DEEP_BUFFER_LONG_PERIOD_COUNT * DEEP_BUFFER_LONG_PERIOD_SIZE);
+
+    return 0;
+}
+
+static int check_input_parameters(uint32_t sample_rate, audio_format_t format, int channel_count)
+{
+    if (format != AUDIO_FORMAT_PCM_16_BIT)
+        return -EINVAL;
+
+    if ((channel_count < 1) || (channel_count > 2))
+        return -EINVAL;
+
+    switch(sample_rate) {
+    case 8000:
+    case 11025:
+    case 16000:
+    case 22050:
+    case 24000:
+    case 32000:
+    case 44100:
+    case 48000:
+        break;
+    default:
+        return -EINVAL;
+    }
+
+    return 0;
+}
+
+static size_t get_input_buffer_size(uint32_t sample_rate, audio_format_t format, int channel_count)
+{
+    size_t size;
+    size_t device_rate;
+
+    if (check_input_parameters(sample_rate, format, channel_count) != 0)
+        return 0;
+
+    /* take resampling into account and return the closest majoring
+    multiple of 16 frames, as audioflinger expects audio buffers to
+    be a multiple of 16 frames */
+    size = (pcm_config_capture.period_size * sample_rate) / pcm_config_capture.rate;
+    size = ((size + 15) / 16) * 16;
+
+    return size * channel_count * sizeof(short);
+}
+
+static void add_echo_reference(struct m0_stream_out *out,
+                               struct echo_reference_itfe *reference)
+{
+    pthread_mutex_lock(&out->lock);
+    out->echo_reference = reference;
+    pthread_mutex_unlock(&out->lock);
+}
+
+static void remove_echo_reference(struct m0_stream_out *out,
+                                  struct echo_reference_itfe *reference)
+{
+    pthread_mutex_lock(&out->lock);
+    if (out->echo_reference == reference) {
+        /* stop writing to echo reference */
+        reference->write(reference, NULL);
+        out->echo_reference = NULL;
+    }
+    pthread_mutex_unlock(&out->lock);
+}
+
+static void put_echo_reference(struct m0_audio_device *adev,
+                          struct echo_reference_itfe *reference)
+{
+    if (adev->echo_reference != NULL &&
+            reference == adev->echo_reference) {
+        /* echo reference is taken from the low latency output stream used
+         * for voice use cases */
+        if (adev->outputs[OUTPUT_LOW_LATENCY] != NULL &&
+                !adev->outputs[OUTPUT_LOW_LATENCY]->standby)
+            remove_echo_reference(adev->outputs[OUTPUT_LOW_LATENCY], reference);
+        release_echo_reference(reference);
+        adev->echo_reference = NULL;
+    }
+}
+
+static struct echo_reference_itfe *get_echo_reference(struct m0_audio_device *adev,
+                                               audio_format_t format,
+                                               uint32_t channel_count,
+                                               uint32_t sampling_rate)
+{
+    put_echo_reference(adev, adev->echo_reference);
+    /* echo reference is taken from the low latency output stream used
+     * for voice use cases */
+    if (adev->outputs[OUTPUT_LOW_LATENCY] != NULL &&
+            !adev->outputs[OUTPUT_LOW_LATENCY]->standby) {
+        struct audio_stream *stream =
+                &adev->outputs[OUTPUT_LOW_LATENCY]->stream.common;
+        uint32_t wr_channel_count = popcount(stream->get_channels(stream));
+        uint32_t wr_sampling_rate = stream->get_sample_rate(stream);
+
+        int status = create_echo_reference(AUDIO_FORMAT_PCM_16_BIT,
+                                           channel_count,
+                                           sampling_rate,
+                                           AUDIO_FORMAT_PCM_16_BIT,
+                                           wr_channel_count,
+                                           wr_sampling_rate,
+                                           &adev->echo_reference);
+        if (status == 0)
+            add_echo_reference(adev->outputs[OUTPUT_LOW_LATENCY],
+                               adev->echo_reference);
+    }
+    return adev->echo_reference;
+}
+
+static int get_playback_delay(struct m0_stream_out *out,
+                       size_t frames,
+                       struct echo_reference_buffer *buffer)
+{
+    size_t kernel_frames;
+    int status;
+    int primary_pcm = 0;
+
+    /* Find the first active PCM to act as primary */
+    while ((primary_pcm < PCM_TOTAL) && !out->pcm[primary_pcm])
+        primary_pcm++;
+
+    status = pcm_get_htimestamp(out->pcm[primary_pcm], &kernel_frames, &buffer->time_stamp);
+    if (status < 0) {
+        buffer->time_stamp.tv_sec  = 0;
+        buffer->time_stamp.tv_nsec = 0;
+        buffer->delay_ns           = 0;
+        ALOGV("%s: pcm_get_htimestamp error,"
+                "setting playbackTimestamp to 0", __func__);
+        return status;
+    }
+
+    kernel_frames = pcm_get_buffer_size(out->pcm[primary_pcm]) - kernel_frames;
+
+    /* adjust render time stamp with delay added by current driver buffer.
+     * Add the duration of current frame as we want the render time of the last
+     * sample being written. */
+    buffer->delay_ns = (long)(((int64_t)(kernel_frames + frames)* 1000000000)/
+                            MM_FULL_POWER_SAMPLING_RATE);
+
+    return 0;
+}
+
+static uint32_t out_get_sample_rate(const struct audio_stream *stream)
+{
+    return DEFAULT_OUT_SAMPLING_RATE;
+}
+
+static int out_set_sample_rate(struct audio_stream *stream, uint32_t rate)
+{
+    return 0;
+}
+
+static size_t out_get_buffer_size_low_latency(const struct audio_stream *stream)
+{
+    struct m0_stream_out *out = (struct m0_stream_out *)stream;
+
+    /* take resampling into account and return the closest majoring
+    multiple of 16 frames, as audioflinger expects audio buffers to
+    be a multiple of 16 frames. Note: we use the default rate here
+    from pcm_config_tones.rate. */
+    size_t size = (SHORT_PERIOD_SIZE * DEFAULT_OUT_SAMPLING_RATE) / pcm_config_tones.rate;
+    size = ((size + 15) / 16) * 16;
+    return size * audio_stream_frame_size((struct audio_stream *)stream);
+}
+
+static size_t out_get_buffer_size_deep_buffer(const struct audio_stream *stream)
+{
+    struct m0_stream_out *out = (struct m0_stream_out *)stream;
+
+    /* take resampling into account and return the closest majoring
+    multiple of 16 frames, as audioflinger expects audio buffers to
+    be a multiple of 16 frames. Note: we use the default rate here
+    from pcm_config_mm.rate. */
+    size_t size = (DEEP_BUFFER_SHORT_PERIOD_SIZE * DEFAULT_OUT_SAMPLING_RATE) /
+                        pcm_config_mm.rate;
+    size = ((size + 15) / 16) * 16;
+    return size * audio_stream_frame_size((struct audio_stream *)stream);
+}
+
+static audio_channel_mask_t out_get_channels(const struct audio_stream *stream)
+{
+    struct m0_stream_out *out = (struct m0_stream_out *)stream;
+
+    return out->channel_mask;
+}
+
+static audio_format_t out_get_format(const struct audio_stream *stream)
+{
+    return AUDIO_FORMAT_PCM_16_BIT;
+}
+
+static int out_set_format(struct audio_stream *stream, audio_format_t format)
+{
+    return 0;
+}
+
+/* must be called with hw device and output stream mutexes locked */
+static int do_output_standby(struct m0_stream_out *out)
+{
+    struct m0_audio_device *adev = out->dev;
+    int i;
+    bool all_outputs_in_standby = true;
+
+    if (!out->standby) {
+        out->standby = 1;
+
+        for (i = 0; i < PCM_TOTAL; i++) {
+            if (out->pcm[i]) {
+                pcm_close(out->pcm[i]);
+                out->pcm[i] = NULL;
+            }
+        }
+
+        for (i = 0; i < OUTPUT_TOTAL; i++) {
+            if (adev->outputs[i] != NULL && !adev->outputs[i]->standby) {
+                all_outputs_in_standby = false;
+                break;
+            }
+        }
+
+        /* force standby on low latency output stream so that it can reuse HDMI driver if
+         * necessary when restarted */
+        if (out == adev->outputs[OUTPUT_HDMI]) {
+            if (adev->outputs[OUTPUT_LOW_LATENCY] != NULL &&
+                    !adev->outputs[OUTPUT_LOW_LATENCY]->standby) {
+                struct m0_stream_out *ll_out = adev->outputs[OUTPUT_LOW_LATENCY];
+                pthread_mutex_lock(&ll_out->lock);
+                do_output_standby(ll_out);
+                pthread_mutex_unlock(&ll_out->lock);
+            }
+        }
+
+        /* stop writing to echo reference */
+        if (out->echo_reference != NULL) {
+            out->echo_reference->write(out->echo_reference, NULL);
+            out->echo_reference = NULL;
+        }
+    }
+    return 0;
+}
+
+static int out_standby(struct audio_stream *stream)
+{
+    struct m0_stream_out *out = (struct m0_stream_out *)stream;
+    int status;
+
+    pthread_mutex_lock(&out->dev->lock);
+    pthread_mutex_lock(&out->lock);
+    status = do_output_standby(out);
+    pthread_mutex_unlock(&out->lock);
+    pthread_mutex_unlock(&out->dev->lock);
+    return status;
+}
+
+static int out_dump(const struct audio_stream *stream, int fd)
+{
+    return 0;
+}
+
+static int out_set_parameters(struct audio_stream *stream, const char *kvpairs)
+{
+    struct m0_stream_out *out = (struct m0_stream_out *)stream;
+    struct m0_audio_device *adev = out->dev;
+    struct m0_stream_in *in;
+    struct str_parms *parms;
+    char *str;
+    char value[32];
+    int ret, val = 0;
+    bool force_input_standby = false;
+
+    parms = str_parms_create_str(kvpairs);
+
+    ret = str_parms_get_str(parms, AUDIO_PARAMETER_STREAM_ROUTING, value, sizeof(value));
+    if (ret >= 0) {
+        val = atoi(value);
+        pthread_mutex_lock(&adev->lock);
+        pthread_mutex_lock(&out->lock);
+        if (((adev->out_device) != val) && (val != 0)) {
+            /* this is needed only when changing device on low latency output
+             * as other output streams are not used for voice use cases nor
+             * handle duplication to HDMI or SPDIF */
+            if (out == adev->outputs[OUTPUT_LOW_LATENCY] && !out->standby) {
+                /* a change in output device may change the microphone selection */
+                if (adev->active_input &&
+                        adev->active_input->source == AUDIO_SOURCE_VOICE_COMMUNICATION) {
+                    force_input_standby = true;
+                }
+                /* force standby if moving to/from HDMI/SPDIF or if the output
+                 * device changes when in HDMI/SPDIF mode */
+                /* FIXME also force standby when in call as some audio path switches do not work
+                 * while in call and an output stream is active (e.g BT SCO => earpiece) */
+
+                /* FIXME workaround for audio being dropped when switching path without forcing standby
+                 * (several hundred ms of audio can be lost: e.g beginning of a ringtone. We must understand
+                 * the root cause in audio HAL, driver or ABE.
+                if (((val & AUDIO_DEVICE_OUT_AUX_DIGITAL) ^
+                        (adev->out_device & AUDIO_DEVICE_OUT_AUX_DIGITAL)) ||
+                        ((val & AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET) ^
+                        (adev->out_device & AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET)) ||
+                        (adev->out_device & (AUDIO_DEVICE_OUT_AUX_DIGITAL |
+                                         AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET)))
+                */
+                if (((val & AUDIO_DEVICE_OUT_AUX_DIGITAL) ^
+                        (adev->out_device & AUDIO_DEVICE_OUT_AUX_DIGITAL)) ||
+                        ((val & AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET) ^
+                        (adev->out_device & AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET)) ||
+                        (adev->out_device & (AUDIO_DEVICE_OUT_AUX_DIGITAL |
+                                         AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET)) ||
+                        ((val & AUDIO_DEVICE_OUT_SPEAKER) ^
+                        (adev->out_device & AUDIO_DEVICE_OUT_SPEAKER)) ||
+                        (adev->mode == AUDIO_MODE_IN_CALL))
+                    do_output_standby(out);
+            }
+            if (out != adev->outputs[OUTPUT_HDMI]) {
+                adev->out_device = val;
+                select_output_device(adev);
+            }
+        }
+        pthread_mutex_unlock(&out->lock);
+        if (force_input_standby) {
+            in = adev->active_input;
+            pthread_mutex_lock(&in->lock);
+            do_input_standby(in);
+            pthread_mutex_unlock(&in->lock);
+        }
+        pthread_mutex_unlock(&adev->lock);
+    }
+
+    str_parms_destroy(parms);
+    return ret;
+}
+
+static char * out_get_parameters(const struct audio_stream *stream, const char *keys)
+{
+    struct m0_stream_out *out = (struct m0_stream_out *)stream;
+
+    struct str_parms *query = str_parms_create_str(keys);
+    char *str;
+    char value[256];
+    struct str_parms *reply = str_parms_create();
+    size_t i, j;
+    int ret;
+    bool first = true;
+
+    ret = str_parms_get_str(query, AUDIO_PARAMETER_STREAM_SUP_CHANNELS, value, sizeof(value));
+    if (ret >= 0) {
+        value[0] = '\0';
+        i = 0;
+        while (out->sup_channel_masks[i] != 0) {
+            for (j = 0; j < ARRAY_SIZE(out_channels_name_to_enum_table); j++) {
+                if (out_channels_name_to_enum_table[j].value == out->sup_channel_masks[i]) {
+                    if (!first) {
+                        strcat(value, "|");
+                    }
+                    strcat(value, out_channels_name_to_enum_table[j].name);
+                    first = false;
+                    break;
+                }
+            }
+            i++;
+        }
+        str_parms_add_str(reply, AUDIO_PARAMETER_STREAM_SUP_CHANNELS, value);
+        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_low_latency(const struct audio_stream_out *stream)
+{
+    struct m0_stream_out *out = (struct m0_stream_out *)stream;
+
+    /*  Note: we use the default rate here from pcm_config_mm.rate */
+    return (SHORT_PERIOD_SIZE * PLAYBACK_SHORT_PERIOD_COUNT * 1000) / pcm_config_tones.rate;
+}
+
+static uint32_t out_get_latency_deep_buffer(const struct audio_stream_out *stream)
+{
+    struct m0_stream_out *out = (struct m0_stream_out *)stream;
+
+    /*  Note: we use the default rate here from pcm_config_mm.rate */
+    return (DEEP_BUFFER_LONG_PERIOD_SIZE * PLAYBACK_DEEP_BUFFER_LONG_PERIOD_COUNT * 1000) /
+                    pcm_config_mm.rate;
+}
+
+static int out_set_volume(struct audio_stream_out *stream, float left,
+                          float right)
+{
+    return -ENOSYS;
+}
+
+static ssize_t out_write_low_latency(struct audio_stream_out *stream, const void* buffer,
+                         size_t bytes)
+{
+    int ret;
+    struct m0_stream_out *out = (struct m0_stream_out *)stream;
+    struct m0_audio_device *adev = out->dev;
+    size_t frame_size = audio_stream_frame_size(&out->stream.common);
+    size_t in_frames = bytes / frame_size;
+    size_t out_frames = in_frames;
+    bool force_input_standby = false;
+    struct m0_stream_in *in;
+    int i;
+
+    /* acquiring hw device mutex systematically is useful if a low priority thread is waiting
+     * on the output stream mutex - e.g. executing select_mode() while holding the hw device
+     * mutex
+     */
+    pthread_mutex_lock(&adev->lock);
+    pthread_mutex_lock(&out->lock);
+    if (out->standby) {
+        ret = start_output_stream_low_latency(out);
+        if (ret != 0) {
+            pthread_mutex_unlock(&adev->lock);
+            goto exit;
+        }
+        out->standby = 0;
+        /* a change in output device may change the microphone selection */
+        if (adev->active_input &&
+                adev->active_input->source == AUDIO_SOURCE_VOICE_COMMUNICATION)
+            force_input_standby = true;
+    }
+    pthread_mutex_unlock(&adev->lock);
+
+    for (i = 0; i < PCM_TOTAL; i++) {
+        /* only use resampler if required */
+        if (out->pcm[i] && (out->config[i].rate != DEFAULT_OUT_SAMPLING_RATE)) {
+            out_frames = out->buffer_frames;
+            out->resampler->resample_from_input(out->resampler,
+                                                (int16_t *)buffer,
+                                                &in_frames,
+                                                (int16_t *)out->buffer,
+                                                &out_frames);
+            break;
+        }
+    }
+
+    if (out->echo_reference != NULL) {
+        struct echo_reference_buffer b;
+        b.raw = (void *)buffer;
+        b.frame_count = in_frames;
+
+        get_playback_delay(out, out_frames, &b);
+        out->echo_reference->write(out->echo_reference, &b);
+    }
+
+    /* Write to all active PCMs */
+    for (i = 0; i < PCM_TOTAL; i++) {
+        if (out->pcm[i]) {
+            if (out->config[i].rate == DEFAULT_OUT_SAMPLING_RATE) {
+                /* PCM uses native sample rate */
+                ret = PCM_WRITE(out->pcm[i], (void *)buffer, bytes);
+            } else {
+                /* PCM needs resampler */
+                ret = PCM_WRITE(out->pcm[i], (void *)out->buffer, out_frames * frame_size);
+            }
+            if (ret)
+                break;
+        }
+    }
+
+exit:
+    pthread_mutex_unlock(&out->lock);
+
+    if (ret != 0) {
+        usleep(bytes * 1000000 / audio_stream_frame_size(&stream->common) /
+               out_get_sample_rate(&stream->common));
+    }
+
+    if (force_input_standby) {
+        pthread_mutex_lock(&adev->lock);
+        if (adev->active_input) {
+            in = adev->active_input;
+            pthread_mutex_lock(&in->lock);
+            do_input_standby(in);
+            pthread_mutex_unlock(&in->lock);
+        }
+        pthread_mutex_unlock(&adev->lock);
+    }
+
+    return bytes;
+}
+
+static ssize_t out_write_deep_buffer(struct audio_stream_out *stream, const void* buffer,
+                         size_t bytes)
+{
+    int ret;
+    struct m0_stream_out *out = (struct m0_stream_out *)stream;
+    struct m0_audio_device *adev = out->dev;
+    size_t frame_size = audio_stream_frame_size(&out->stream.common);
+    size_t in_frames = bytes / frame_size;
+    size_t out_frames;
+    bool use_long_periods;
+    int kernel_frames;
+    void *buf;
+
+    /* acquiring hw device mutex systematically is useful if a low priority thread is waiting
+     * on the output stream mutex - e.g. executing select_mode() while holding the hw device
+     * mutex
+     */
+    pthread_mutex_lock(&adev->lock);
+    pthread_mutex_lock(&out->lock);
+    if (out->standby) {
+        ret = start_output_stream_deep_buffer(out);
+        if (ret != 0) {
+            pthread_mutex_unlock(&adev->lock);
+            goto exit;
+        }
+        out->standby = 0;
+    }
+    use_long_periods = adev->screen_off && !adev->active_input;
+    pthread_mutex_unlock(&adev->lock);
+
+    if (use_long_periods != out->use_long_periods) {
+        size_t period_size;
+        size_t period_count;
+
+        if (use_long_periods) {
+            period_size = DEEP_BUFFER_LONG_PERIOD_SIZE;
+            period_count = PLAYBACK_DEEP_BUFFER_LONG_PERIOD_COUNT;
+        } else {
+            period_size = DEEP_BUFFER_SHORT_PERIOD_SIZE;
+            period_count = PLAYBACK_DEEP_BUFFER_SHORT_PERIOD_COUNT;
+        }
+        out->write_threshold = period_size * period_count;
+        pcm_set_avail_min(out->pcm[PCM_NORMAL], period_size);
+        out->use_long_periods = use_long_periods;
+    }
+
+    /* only use resampler if required */
+    if (out->config[PCM_NORMAL].rate != DEFAULT_OUT_SAMPLING_RATE) {
+        out_frames = out->buffer_frames;
+        out->resampler->resample_from_input(out->resampler,
+                                            (int16_t *)buffer,
+                                            &in_frames,
+                                            (int16_t *)out->buffer,
+                                            &out_frames);
+        buf = (void *)out->buffer;
+    } else {
+        out_frames = in_frames;
+        buf = (void *)buffer;
+    }
+
+    /* do not allow more than out->write_threshold frames in kernel pcm driver buffer */
+    do {
+        struct timespec time_stamp;
+
+        if (pcm_get_htimestamp(out->pcm[PCM_NORMAL],
+                               (unsigned int *)&kernel_frames, &time_stamp) < 0)
+            break;
+        kernel_frames = pcm_get_buffer_size(out->pcm[PCM_NORMAL]) - kernel_frames;
+
+        if (kernel_frames > out->write_threshold) {
+            unsigned long time = (unsigned long)
+                    (((int64_t)(kernel_frames - out->write_threshold) * 1000000) /
+                            MM_FULL_POWER_SAMPLING_RATE);
+            if (time < MIN_WRITE_SLEEP_US)
+                time = MIN_WRITE_SLEEP_US;
+            usleep(time);
+        }
+    } while (kernel_frames > out->write_threshold);
+
+    ret = pcm_mmap_write(out->pcm[PCM_NORMAL], buf, out_frames * frame_size);
+
+exit:
+    pthread_mutex_unlock(&out->lock);
+
+    if (ret != 0) {
+        usleep(bytes * 1000000 / audio_stream_frame_size(&stream->common) /
+               out_get_sample_rate(&stream->common));
+    }
+
+    return bytes;
+}
+
+static int out_get_render_position(const struct audio_stream_out *stream,
+                                   uint32_t *dsp_frames)
+{
+    return -EINVAL;
+}
+
+static int out_add_audio_effect(const struct audio_stream *stream, effect_handle_t effect)
+{
+    return 0;
+}
+
+static int out_remove_audio_effect(const struct audio_stream *stream, effect_handle_t effect)
+{
+    return 0;
+}
+
+/** audio_stream_in implementation **/
+
+/* must be called with hw device and input stream mutexes locked */
+static int start_input_stream(struct m0_stream_in *in)
+{
+    int ret = 0;
+    struct m0_audio_device *adev = in->dev;
+
+    adev->active_input = in;
+
+    if (adev->mode != AUDIO_MODE_IN_CALL) {
+        adev->in_device = in->device;
+        select_input_device(adev);
+    }
+
+    if (in->aux_channels_changed)
+    {
+        in->aux_channels_changed = false;
+        in->config.channels = popcount(in->main_channels | in->aux_channels);
+
+        if (in->resampler) {
+            /* release and recreate the resampler with the new number of channel of the input */
+            release_resampler(in->resampler);
+            in->resampler = NULL;
+            ret = create_resampler(in->config.rate,
+                               in->requested_rate,
+                               in->config.channels,
+                               RESAMPLER_QUALITY_DEFAULT,
+                               &in->buf_provider,
+                               &in->resampler);
+        }
+        ALOGV("%s: New channel configuration, "
+                "main_channels = [%04x], aux_channels = [%04x], config.channels = %d",
+                __func__, in->main_channels, in->aux_channels, in->config.channels);
+    }
+
+    if (in->need_echo_reference && in->echo_reference == NULL)
+        in->echo_reference = get_echo_reference(adev,
+                                        AUDIO_FORMAT_PCM_16_BIT,
+                                        popcount(in->main_channels),
+                                        in->requested_rate);
+
+    /* this assumes routing is done previously */
+    in->pcm = pcm_open(CARD_DEFAULT, PORT_CAPTURE, PCM_IN, &in->config);
+    if (!pcm_is_ready(in->pcm)) {
+        ALOGE("cannot open pcm_in driver: %s", pcm_get_error(in->pcm));
+        pcm_close(in->pcm);
+        adev->active_input = NULL;
+        return -ENOMEM;
+    }
+
+    /* force read and proc buf reallocation case of frame size or channel count change */
+    in->read_buf_frames = 0;
+    in->read_buf_size = 0;
+    in->proc_buf_frames = 0;
+    in->proc_buf_size = 0;
+    /* if no supported sample rate is available, use the resampler */
+    if (in->resampler) {
+        in->resampler->reset(in->resampler);
+    }
+    return 0;
+}
+
+static uint32_t in_get_sample_rate(const struct audio_stream *stream)
+{
+    struct m0_stream_in *in = (struct m0_stream_in *)stream;
+
+    return in->requested_rate;
+}
+
+static int in_set_sample_rate(struct audio_stream *stream, uint32_t rate)
+{
+    return 0;
+}
+
+static size_t in_get_buffer_size(const struct audio_stream *stream)
+{
+    struct m0_stream_in *in = (struct m0_stream_in *)stream;
+
+    return get_input_buffer_size(in->requested_rate,
+                                 AUDIO_FORMAT_PCM_16_BIT,
+                                 popcount(in->main_channels));
+}
+
+static audio_channel_mask_t in_get_channels(const struct audio_stream *stream)
+{
+    struct m0_stream_in *in = (struct m0_stream_in *)stream;
+
+    return in->main_channels;
+}
+
+static audio_format_t in_get_format(const struct audio_stream *stream)
+{
+    return AUDIO_FORMAT_PCM_16_BIT;
+}
+
+static int in_set_format(struct audio_stream *stream, audio_format_t format)
+{
+    return 0;
+}
+
+/* must be called with hw device and input stream mutexes locked */
+static int do_input_standby(struct m0_stream_in *in)
+{
+    struct m0_audio_device *adev = in->dev;
+
+    if (!in->standby) {
+        pcm_close(in->pcm);
+        in->pcm = NULL;
+
+        adev->active_input = 0;
+        if (adev->mode != AUDIO_MODE_IN_CALL) {
+            adev->in_device = AUDIO_DEVICE_NONE;
+            select_input_device(adev);
+        }
+
+        if (in->echo_reference != NULL) {
+            /* stop reading from echo reference */
+            in->echo_reference->read(in->echo_reference, NULL);
+            put_echo_reference(adev, in->echo_reference);
+            in->echo_reference = NULL;
+        }
+
+        in->standby = 1;
+    }
+    return 0;
+}
+
+static int in_standby(struct audio_stream *stream)
+{
+    struct m0_stream_in *in = (struct m0_stream_in *)stream;
+    int status;
+
+    pthread_mutex_lock(&in->dev->lock);
+    pthread_mutex_lock(&in->lock);
+    status = do_input_standby(in);
+    pthread_mutex_unlock(&in->lock);
+    pthread_mutex_unlock(&in->dev->lock);
+    return status;
+}
+
+static int in_dump(const struct audio_stream *stream, int fd)
+{
+    return 0;
+}
+
+static int in_set_parameters(struct audio_stream *stream, const char *kvpairs)
+{
+    struct m0_stream_in *in = (struct m0_stream_in *)stream;
+    struct m0_audio_device *adev = in->dev;
+    struct str_parms *parms;
+    char *str;
+    char value[32];
+    int ret, val = 0;
+    bool do_standby = false;
+
+    parms = str_parms_create_str(kvpairs);
+
+    ret = str_parms_get_str(parms, AUDIO_PARAMETER_STREAM_INPUT_SOURCE, value, sizeof(value));
+
+    pthread_mutex_lock(&adev->lock);
+    pthread_mutex_lock(&in->lock);
+    if (ret >= 0) {
+        val = atoi(value);
+        /* no audio source uses val == 0 */
+        if ((in->source != val) && (val != 0)) {
+            in->source = val;
+            do_standby = true;
+        }
+    }
+
+    ret = str_parms_get_str(parms, AUDIO_PARAMETER_STREAM_ROUTING, value, sizeof(value));
+    if (ret >= 0) {
+        val = atoi(value) & ~AUDIO_DEVICE_BIT_IN;
+        if ((in->device != val) && (val != 0)) {
+            in->device = val;
+            do_standby = true;
+            /* make sure new device selection is incompatible with multi-mic pre processing
+             * configuration */
+            in_update_aux_channels(in, NULL);
+        }
+    }
+
+    if (do_standby)
+        do_input_standby(in);
+    pthread_mutex_unlock(&in->lock);
+    pthread_mutex_unlock(&adev->lock);
+
+    str_parms_destroy(parms);
+    return ret;
+}
+
+static char * in_get_parameters(const struct audio_stream *stream,
+                                const char *keys)
+{
+    return strdup("");
+}
+
+static int in_set_gain(struct audio_stream_in *stream, float gain)
+{
+    return 0;
+}
+
+static void get_capture_delay(struct m0_stream_in *in,
+                       size_t frames,
+                       struct echo_reference_buffer *buffer)
+{
+
+    /* read frames available in kernel driver buffer */
+    size_t kernel_frames;
+    struct timespec tstamp;
+    long buf_delay;
+    long rsmp_delay;
+    long kernel_delay;
+    long delay_ns;
+
+    if (pcm_get_htimestamp(in->pcm, &kernel_frames, &tstamp) < 0) {
+        buffer->time_stamp.tv_sec  = 0;
+        buffer->time_stamp.tv_nsec = 0;
+        buffer->delay_ns           = 0;
+        ALOGW("%s: pcm_htimestamp error", __func__);
+        return;
+    }
+
+    /* read frames available in audio HAL input buffer
+     * add number of frames being read as we want the capture time of first sample
+     * in current buffer */
+    /* frames in in->buffer are at driver sampling rate while frames in in->proc_buf are
+     * at requested sampling rate */
+    buf_delay = (long)(((int64_t)(in->read_buf_frames) * 1000000000) / in->config.rate +
+                       ((int64_t)(in->proc_buf_frames) * 1000000000) /
+                           in->requested_rate);
+
+    /* add delay introduced by resampler */
+    rsmp_delay = 0;
+    if (in->resampler) {
+        rsmp_delay = in->resampler->delay_ns(in->resampler);
+    }
+
+    kernel_delay = (long)(((int64_t)kernel_frames * 1000000000) / in->config.rate);
+
+    delay_ns = kernel_delay + buf_delay + rsmp_delay;
+
+    buffer->time_stamp = tstamp;
+    buffer->delay_ns   = delay_ns;
+    ALOGV("%s: time_stamp = [%ld].[%ld], delay_ns: [%d],"
+         " kernel_delay:[%ld], buf_delay:[%ld], rsmp_delay:[%ld], kernel_frames:[%d], "
+         "in->read_buf_frames:[%d], in->proc_buf_frames:[%d], frames:[%d]",
+         __func__, buffer->time_stamp.tv_sec , buffer->time_stamp.tv_nsec, buffer->delay_ns,
+         kernel_delay, buf_delay, rsmp_delay, kernel_frames,
+         in->read_buf_frames, in->proc_buf_frames, frames);
+
+}
+
+static int32_t update_echo_reference(struct m0_stream_in *in, size_t frames)
+{
+    struct echo_reference_buffer b;
+    b.delay_ns = 0;
+
+    ALOGV("%s: frames = [%d], in->ref_frames_in = [%d],  "
+          "b.frame_count = [%d]",
+         __func__, frames, in->ref_buf_frames, frames - in->ref_buf_frames);
+    if (in->ref_buf_frames < frames) {
+        if (in->ref_buf_size < frames) {
+            in->ref_buf_size = frames;
+            in->ref_buf = (int16_t *)realloc(in->ref_buf, pcm_frames_to_bytes(in->pcm, frames));
+            ALOG_ASSERT((in->ref_buf != NULL),
+                        "%s failed to reallocate ref_buf", __func__);
+            ALOGV("%s: ref_buf %p extended to %d bytes",
+                      __func__, in->ref_buf, pcm_frames_to_bytes(in->pcm, frames));
+        }
+        b.frame_count = frames - in->ref_buf_frames;
+        b.raw = (void *)(in->ref_buf + in->ref_buf_frames * in->config.channels);
+
+        get_capture_delay(in, frames, &b);
+
+        if (in->echo_reference->read(in->echo_reference, &b) == 0)
+        {
+            in->ref_buf_frames += b.frame_count;
+            ALOGD("%s: in->ref_buf_frames:[%d], "
+                    "in->ref_buf_size:[%d], frames:[%d], b.frame_count:[%d]",
+                 __func__, in->ref_buf_frames, in->ref_buf_size, frames, b.frame_count);
+        }
+    } else
+        ALOGW("%s: NOT enough frames to read ref buffer", __func__);
+    return b.delay_ns;
+}
+
+static int set_preprocessor_param(effect_handle_t handle,
+                           effect_param_t *param)
+{
+    uint32_t size = sizeof(int);
+    uint32_t psize = ((param->psize - 1) / sizeof(int) + 1) * sizeof(int) +
+                        param->vsize;
+
+    int status = (*handle)->command(handle,
+                                   EFFECT_CMD_SET_PARAM,
+                                   sizeof (effect_param_t) + psize,
+                                   param,
+                                   &size,
+                                   &param->status);
+    if (status == 0)
+        status = param->status;
+
+    return status;
+}
+
+static int set_preprocessor_echo_delay(effect_handle_t handle,
+                                     int32_t delay_us)
+{
+    uint32_t buf[sizeof(effect_param_t) / sizeof(uint32_t) + 2];
+    effect_param_t *param = (effect_param_t *)buf;
+
+    param->psize = sizeof(uint32_t);
+    param->vsize = sizeof(uint32_t);
+    *(uint32_t *)param->data = AEC_PARAM_ECHO_DELAY;
+    *((int32_t *)param->data + 1) = delay_us;
+
+    return set_preprocessor_param(handle, param);
+}
+
+static void push_echo_reference(struct m0_stream_in *in, size_t frames)
+{
+    /* read frames from echo reference buffer and update echo delay
+     * in->ref_buf_frames is updated with frames available in in->ref_buf */
+    int32_t delay_us = update_echo_reference(in, frames)/1000;
+    int i;
+    audio_buffer_t buf;
+
+    if (in->ref_buf_frames < frames)
+        frames = in->ref_buf_frames;
+
+    buf.frameCount = frames;
+    buf.raw = in->ref_buf;
+
+    for (i = 0; i < in->num_preprocessors; i++) {
+        if ((*in->preprocessors[i].effect_itfe)->process_reverse == NULL)
+            continue;
+
+        (*in->preprocessors[i].effect_itfe)->process_reverse(in->preprocessors[i].effect_itfe,
+                                               &buf,
+                                               NULL);
+        set_preprocessor_echo_delay(in->preprocessors[i].effect_itfe, delay_us);
+    }
+
+    in->ref_buf_frames -= buf.frameCount;
+    if (in->ref_buf_frames) {
+        memcpy(in->ref_buf,
+               in->ref_buf + buf.frameCount * in->config.channels,
+               in->ref_buf_frames * in->config.channels * sizeof(int16_t));
+    }
+}
+
+static int get_next_buffer(struct resampler_buffer_provider *buffer_provider,
+                                   struct resampler_buffer* buffer)
+{
+    struct m0_stream_in *in;
+
+    if (buffer_provider == NULL || buffer == NULL)
+        return -EINVAL;
+
+    in = (struct m0_stream_in *)((char *)buffer_provider -
+                                   offsetof(struct m0_stream_in, buf_provider));
+
+    if (in->pcm == NULL) {
+        buffer->raw = NULL;
+        buffer->frame_count = 0;
+        in->read_status = -ENODEV;
+        return -ENODEV;
+    }
+
+    if (in->read_buf_frames == 0) {
+        size_t size_in_bytes = pcm_frames_to_bytes(in->pcm, in->config.period_size);
+        if (in->read_buf_size < in->config.period_size) {
+            in->read_buf_size = in->config.period_size;
+            in->read_buf = (int16_t *) realloc(in->read_buf, size_in_bytes);
+            ALOG_ASSERT((in->read_buf != NULL),
+                        "%s failed to reallocate read_buf", __func__);
+            ALOGV("%s: read_buf %p extended to %d bytes",
+                  __func__, in->read_buf, size_in_bytes);
+        }
+
+        in->read_status = pcm_read(in->pcm, (void*)in->read_buf, size_in_bytes);
+
+        if (in->read_status != 0) {
+            ALOGE("%s: pcm_read error %d", __func__, in->read_status);
+            buffer->raw = NULL;
+            buffer->frame_count = 0;
+            return in->read_status;
+        }
+        in->read_buf_frames = in->config.period_size;
+    }
+
+    buffer->frame_count = (buffer->frame_count > in->read_buf_frames) ?
+                                in->read_buf_frames : buffer->frame_count;
+    buffer->i16 = in->read_buf + (in->config.period_size - in->read_buf_frames) *
+                                                in->config.channels;
+
+    return in->read_status;
+
+}
+
+static void release_buffer(struct resampler_buffer_provider *buffer_provider,
+                                  struct resampler_buffer* buffer)
+{
+    struct m0_stream_in *in;
+
+    if (buffer_provider == NULL || buffer == NULL)
+        return;
+
+    in = (struct m0_stream_in *)((char *)buffer_provider -
+                                   offsetof(struct m0_stream_in, buf_provider));
+
+    in->read_buf_frames -= buffer->frame_count;
+}
+
+/* read_frames() reads frames from kernel driver, down samples to capture rate
+ * if necessary and output the number of frames requested to the buffer specified */
+static ssize_t read_frames(struct m0_stream_in *in, void *buffer, ssize_t frames)
+{
+    ssize_t frames_wr = 0;
+
+    while (frames_wr < frames) {
+        size_t frames_rd = frames - frames_wr;
+        if (in->resampler != NULL) {
+            in->resampler->resample_from_provider(in->resampler,
+                                                  (int16_t *)((char *)buffer +
+                                                      pcm_frames_to_bytes(in->pcm ,frames_wr)),
+                                                  &frames_rd);
+
+        } else {
+            struct resampler_buffer buf = {
+                    { raw : NULL, },
+                    frame_count : frames_rd,
+            };
+            get_next_buffer(&in->buf_provider, &buf);
+            if (buf.raw != NULL) {
+                memcpy((char *)buffer +
+                            pcm_frames_to_bytes(in->pcm, frames_wr),
+                        buf.raw,
+                        pcm_frames_to_bytes(in->pcm, buf.frame_count));
+                frames_rd = buf.frame_count;
+            }
+            release_buffer(&in->buf_provider, &buf);
+        }
+        /* in->read_status is updated by getNextBuffer() also called by
+         * in->resampler->resample_from_provider() */
+        if (in->read_status != 0)
+            return in->read_status;
+
+        frames_wr += frames_rd;
+    }
+    return frames_wr;
+}
+
+/* process_frames() reads frames from kernel driver (via read_frames()),
+ * calls the active audio pre processings and output the number of frames requested
+ * to the buffer specified */
+static ssize_t process_frames(struct m0_stream_in *in, void* buffer, ssize_t frames)
+{
+    ssize_t frames_wr = 0;
+    audio_buffer_t in_buf;
+    audio_buffer_t out_buf;
+    int i;
+    bool has_aux_channels = (~in->main_channels & in->aux_channels);
+    void *proc_buf_out;
+
+    if (has_aux_channels)
+        proc_buf_out = in->proc_buf_out;
+    else
+        proc_buf_out = buffer;
+
+    /* since all the processing below is done in frames and using the config.channels
+     * as the number of channels, no changes is required in case aux_channels are present */
+    while (frames_wr < frames) {
+        /* first reload enough frames at the end of process input buffer */
+        if (in->proc_buf_frames < (size_t)frames) {
+            ssize_t frames_rd;
+
+            if (in->proc_buf_size < (size_t)frames) {
+                size_t size_in_bytes = pcm_frames_to_bytes(in->pcm, frames);
+
+                in->proc_buf_size = (size_t)frames;
+                in->proc_buf_in = (int16_t *)realloc(in->proc_buf_in, size_in_bytes);
+                ALOG_ASSERT((in->proc_buf_in != NULL),
+                            "%s failed to reallocate proc_buf_in", __func__);
+                if (has_aux_channels) {
+                    in->proc_buf_out = (int16_t *)realloc(in->proc_buf_out, size_in_bytes);
+                    ALOG_ASSERT((in->proc_buf_out != NULL),
+                                "%s failed to reallocate proc_buf_out", __func__);
+                    proc_buf_out = in->proc_buf_out;
+                }
+                ALOGV("process_frames(): proc_buf_in %p extended to %d bytes",
+                     in->proc_buf_in, size_in_bytes);
+            }
+            frames_rd = read_frames(in,
+                                    in->proc_buf_in +
+                                        in->proc_buf_frames * in->config.channels,
+                                    frames - in->proc_buf_frames);
+            if (frames_rd < 0) {
+                frames_wr = frames_rd;
+                break;
+            }
+            in->proc_buf_frames += frames_rd;
+        }
+
+        if (in->echo_reference != NULL)
+            push_echo_reference(in, in->proc_buf_frames);
+
+         /* in_buf.frameCount and out_buf.frameCount indicate respectively
+          * the maximum number of frames to be consumed and produced by process() */
+        in_buf.frameCount = in->proc_buf_frames;
+        in_buf.s16 = in->proc_buf_in;
+        out_buf.frameCount = frames - frames_wr;
+        out_buf.s16 = (int16_t *)proc_buf_out + frames_wr * in->config.channels;
+
+        /* FIXME: this works because of current pre processing library implementation that
+         * does the actual process only when the last enabled effect process is called.
+         * The generic solution is to have an output buffer for each effect and pass it as
+         * input to the next.
+         */
+        for (i = 0; i < in->num_preprocessors; i++) {
+            (*in->preprocessors[i].effect_itfe)->process(in->preprocessors[i].effect_itfe,
+                                               &in_buf,
+                                               &out_buf);
+        }
+
+        /* process() has updated the number of frames consumed and produced in
+         * in_buf.frameCount and out_buf.frameCount respectively
+         * move remaining frames to the beginning of in->proc_buf_in */
+        in->proc_buf_frames -= in_buf.frameCount;
+
+        if (in->proc_buf_frames) {
+            memcpy(in->proc_buf_in,
+                   in->proc_buf_in + in_buf.frameCount * in->config.channels,
+                   in->proc_buf_frames * in->config.channels * sizeof(int16_t));
+        }
+
+        /* if not enough frames were passed to process(), read more and retry. */
+        if (out_buf.frameCount == 0) {
+            ALOGW("No frames produced by preproc");
+            continue;
+        }
+
+        if ((frames_wr + (ssize_t)out_buf.frameCount) <= frames) {
+            frames_wr += out_buf.frameCount;
+        } else {
+            /* The effect does not comply to the API. In theory, we should never end up here! */
+            ALOGE("%s: preprocessing produced too many frames: %d + %d  > %d !", __func__,
+                  (unsigned int)frames_wr, out_buf.frameCount, (unsigned int)frames);
+            frames_wr = frames;
+        }
+    }
+
+    /* Remove aux_channels that have been added on top of main_channels
+     * Assumption is made that the channels are interleaved and that the main
+     * channels are first. */
+    if (has_aux_channels)
+    {
+        size_t src_channels = in->config.channels;
+        size_t dst_channels = popcount(in->main_channels);
+        int16_t* src_buffer = (int16_t *)proc_buf_out;
+        int16_t* dst_buffer = (int16_t *)buffer;
+
+        if (dst_channels == 1) {
+            for (i = frames_wr; i > 0; i--)
+            {
+                *dst_buffer++ = *src_buffer;
+                src_buffer += src_channels;
+            }
+        } else {
+            for (i = frames_wr; i > 0; i--)
+            {
+                memcpy(dst_buffer, src_buffer, dst_channels*sizeof(int16_t));
+                dst_buffer += dst_channels;
+                src_buffer += src_channels;
+            }
+        }
+    }
+
+    return frames_wr;
+}
+
+static ssize_t in_read(struct audio_stream_in *stream, void* buffer,
+                       size_t bytes)
+{
+    int ret = 0;
+    struct m0_stream_in *in = (struct m0_stream_in *)stream;
+    struct m0_audio_device *adev = in->dev;
+    size_t frames_rq = bytes / audio_stream_frame_size(&stream->common);
+
+    /* acquiring hw device mutex systematically is useful if a low priority thread is waiting
+     * on the input stream mutex - e.g. executing select_mode() while holding the hw device
+     * mutex
+     */
+    pthread_mutex_lock(&adev->lock);
+    pthread_mutex_lock(&in->lock);
+    if (in->standby) {
+        ret = start_input_stream(in);
+        if (ret == 0)
+            in->standby = 0;
+    }
+    pthread_mutex_unlock(&adev->lock);
+
+    if (ret < 0)
+        goto exit;
+
+    if (in->num_preprocessors != 0)
+        ret = process_frames(in, buffer, frames_rq);
+    else if (in->resampler != NULL)
+        ret = read_frames(in, buffer, frames_rq);
+    else
+        ret = pcm_read(in->pcm, buffer, bytes);
+
+    if (ret > 0)
+        ret = 0;
+
+    if (ret == 0 && adev->mic_mute)
+        memset(buffer, 0, bytes);
+
+exit:
+    if (ret < 0)
+        usleep(bytes * 1000000 / audio_stream_frame_size(&stream->common) /
+               in_get_sample_rate(&stream->common));
+
+    pthread_mutex_unlock(&in->lock);
+    return bytes;
+}
+
+static uint32_t in_get_input_frames_lost(struct audio_stream_in *stream)
+{
+    return 0;
+}
+
+#define GET_COMMAND_STATUS(status, fct_status, cmd_status) \
+            do {                                           \
+                if (fct_status != 0)                       \
+                    status = fct_status;                   \
+                else if (cmd_status != 0)                  \
+                    status = cmd_status;                   \
+            } while(0)
+
+static int in_configure_reverse(struct m0_stream_in *in)
+{
+    int32_t cmd_status;
+    uint32_t size = sizeof(int);
+    effect_config_t config;
+    int32_t status = 0;
+    int32_t fct_status = 0;
+    int i;
+
+    if (in->num_preprocessors > 0) {
+        config.inputCfg.channels = in->main_channels;
+        config.outputCfg.channels = in->main_channels;
+        config.inputCfg.format = AUDIO_FORMAT_PCM_16_BIT;
+        config.outputCfg.format = AUDIO_FORMAT_PCM_16_BIT;
+        config.inputCfg.samplingRate = in->requested_rate;
+        config.outputCfg.samplingRate = in->requested_rate;
+        config.inputCfg.mask =
+                ( EFFECT_CONFIG_SMP_RATE | EFFECT_CONFIG_CHANNELS | EFFECT_CONFIG_FORMAT );
+        config.outputCfg.mask =
+                ( EFFECT_CONFIG_SMP_RATE | EFFECT_CONFIG_CHANNELS | EFFECT_CONFIG_FORMAT );
+
+        for (i = 0; i < in->num_preprocessors; i++)
+        {
+            if ((*in->preprocessors[i].effect_itfe)->process_reverse == NULL)
+                continue;
+            fct_status = (*(in->preprocessors[i].effect_itfe))->command(
+                                                        in->preprocessors[i].effect_itfe,
+                                                        EFFECT_CMD_SET_CONFIG_REVERSE,
+                                                        sizeof(effect_config_t),
+                                                        &config,
+                                                        &size,
+                                                        &cmd_status);
+            GET_COMMAND_STATUS(status, fct_status, cmd_status);
+        }
+    }
+    return status;
+}
+
+#define MAX_NUM_CHANNEL_CONFIGS 10
+
+static void in_read_audio_effect_channel_configs(struct m0_stream_in *in,
+                                                 struct effect_info_s *effect_info)
+{
+    /* size and format of the cmd are defined in hardware/audio_effect.h */
+    effect_handle_t effect = effect_info->effect_itfe;
+    uint32_t cmd_size = 2 * sizeof(uint32_t);
+    uint32_t cmd[] = { EFFECT_FEATURE_AUX_CHANNELS, MAX_NUM_CHANNEL_CONFIGS };
+    /* reply = status + number of configs (n) + n x channel_config_t */
+    uint32_t reply_size =
+            2 * sizeof(uint32_t) + (MAX_NUM_CHANNEL_CONFIGS * sizeof(channel_config_t));
+    int32_t reply[reply_size];
+    int32_t cmd_status;
+
+    ALOG_ASSERT((effect_info->num_channel_configs == 0),
+                "in_read_audio_effect_channel_configs() num_channel_configs not cleared");
+    ALOG_ASSERT((effect_info->channel_configs == NULL),
+                "in_read_audio_effect_channel_configs() channel_configs not cleared");
+
+    /* if this command is not supported, then the effect is supposed to return -EINVAL.
+     * This error will be interpreted as if the effect supports the main_channels but does not
+     * support any aux_channels */
+    cmd_status = (*effect)->command(effect,
+                                EFFECT_CMD_GET_FEATURE_SUPPORTED_CONFIGS,
+                                cmd_size,
+                                (void*)&cmd,
+                                &reply_size,
+                                (void*)&reply);
+
+    if (cmd_status != 0) {
+        ALOGI("%s: fx->command returned %d", __func__, cmd_status);
+        return;
+    }
+
+    if (reply[0] != 0) {
+        ALOGW("%s: "
+                "command EFFECT_CMD_GET_FEATURE_SUPPORTED_CONFIGS error %d num configs %d",
+                __func__, reply[0], (reply[0] == -ENOMEM) ? reply[1] : MAX_NUM_CHANNEL_CONFIGS);
+        return;
+    }
+
+    /* the feature is not supported */
+    ALOGI("in_read_audio_effect_channel_configs()(): "
+            "Feature supported and adding %d channel configs to the list", reply[1]);
+    effect_info->num_channel_configs = reply[1];
+    effect_info->channel_configs =
+            (channel_config_t *) malloc(sizeof(channel_config_t) * reply[1]); /* n x configs */
+    memcpy(effect_info->channel_configs, (reply + 2), sizeof(channel_config_t) * reply[1]);
+}
+
+
+static uint32_t in_get_aux_channels(struct m0_stream_in *in)
+{
+    int i;
+    channel_config_t new_chcfg = {0, 0};
+
+    if (in->num_preprocessors == 0)
+        return 0;
+
+    /* do not enable dual mic configurations when capturing from other microphones than
+     * main or sub */
+    if (!(in->device & (AUDIO_DEVICE_IN_BUILTIN_MIC | AUDIO_DEVICE_IN_BACK_MIC)))
+        return 0;
+
+    /* retain most complex aux channels configuration compatible with requested main channels and
+     * supported by audio driver and all pre processors */
+    for (i = 0; i < NUM_IN_AUX_CNL_CONFIGS; i++) {
+        channel_config_t *cur_chcfg = &in_aux_cnl_configs[i];
+        if (cur_chcfg->main_channels == in->main_channels) {
+            size_t match_cnt;
+            size_t idx_preproc;
+            for (idx_preproc = 0, match_cnt = 0;
+                 /* no need to continue if at least one preprocessor doesn't match */
+                 idx_preproc < (size_t)in->num_preprocessors && match_cnt == idx_preproc;
+                 idx_preproc++) {
+                struct effect_info_s *effect_info = &in->preprocessors[idx_preproc];
+                size_t idx_chcfg;
+
+                for (idx_chcfg = 0; idx_chcfg < effect_info->num_channel_configs; idx_chcfg++) {
+                    if (memcmp(effect_info->channel_configs + idx_chcfg,
+                               cur_chcfg,
+                               sizeof(channel_config_t)) == 0) {
+                        match_cnt++;
+                        break;
+                    }
+                }
+            }
+            /* if all preprocessors match, we have a candidate */
+            if (match_cnt == (size_t)in->num_preprocessors) {
+                /* retain most complex aux channels configuration */
+                if (popcount(cur_chcfg->aux_channels) > popcount(new_chcfg.aux_channels)) {
+                    new_chcfg = *cur_chcfg;
+                }
+            }
+        }
+    }
+
+    ALOGI("in_get_aux_channels(): return %04x", new_chcfg.aux_channels);
+
+    return new_chcfg.aux_channels;
+}
+
+static int in_configure_effect_channels(effect_handle_t effect,
+                                        channel_config_t *channel_config)
+{
+    int status = 0;
+    int fct_status;
+    int32_t cmd_status;
+    uint32_t reply_size;
+    effect_config_t config;
+    uint32_t cmd[(sizeof(uint32_t) + sizeof(channel_config_t) - 1) / sizeof(uint32_t) + 1];
+
+    ALOGI("in_configure_effect_channels(): configure effect with channels: [%04x][%04x]",
+            channel_config->main_channels,
+            channel_config->aux_channels);
+
+    config.inputCfg.mask = EFFECT_CONFIG_CHANNELS;
+    config.outputCfg.mask = EFFECT_CONFIG_CHANNELS;
+    reply_size = sizeof(effect_config_t);
+    fct_status = (*effect)->command(effect,
+                                EFFECT_CMD_GET_CONFIG,
+                                0,
+                                NULL,
+                                &reply_size,
+                                &config);
+    if (fct_status != 0) {
+        ALOGE("in_configure_effect_channels(): EFFECT_CMD_GET_CONFIG failed");
+        return fct_status;
+    }
+
+    config.inputCfg.channels = channel_config->main_channels | channel_config->aux_channels;
+    config.outputCfg.channels = config.inputCfg.channels;
+    reply_size = sizeof(uint32_t);
+    fct_status = (*effect)->command(effect,
+                                    EFFECT_CMD_SET_CONFIG,
+                                    sizeof(effect_config_t),
+                                    &config,
+                                    &reply_size,
+                                    &cmd_status);
+    GET_COMMAND_STATUS(status, fct_status, cmd_status);
+
+    cmd[0] = EFFECT_FEATURE_AUX_CHANNELS;
+    memcpy(cmd + 1, channel_config, sizeof(channel_config_t));
+    reply_size = sizeof(uint32_t);
+    fct_status = (*effect)->command(effect,
+                                EFFECT_CMD_SET_FEATURE_CONFIG,
+                                sizeof(cmd), //sizeof(uint32_t) + sizeof(channel_config_t),
+                                cmd,
+                                &reply_size,
+                                &cmd_status);
+    GET_COMMAND_STATUS(status, fct_status, cmd_status);
+
+    /* some implementations need to be re-enabled after a config change */
+    reply_size = sizeof(uint32_t);
+    fct_status = (*effect)->command(effect,
+                                  EFFECT_CMD_ENABLE,
+                                  0,
+                                  NULL,
+                                  &reply_size,
+                                  &cmd_status);
+    GET_COMMAND_STATUS(status, fct_status, cmd_status);
+
+    return status;
+}
+
+static int in_reconfigure_channels(struct m0_stream_in *in,
+                                   effect_handle_t effect,
+                                   channel_config_t *channel_config,
+                                   bool config_changed) {
+
+    int status = 0;
+
+    ALOGI("%s: config_changed %d effect %p",
+          __func__, config_changed, effect);
+
+    /* if config changed, reconfigure all previously added effects */
+    if (config_changed) {
+        int i;
+        for (i = 0; i < in->num_preprocessors; i++)
+        {
+            int cur_status = in_configure_effect_channels(in->preprocessors[i].effect_itfe,
+                                                  channel_config);
+            if (cur_status != 0) {
+                ALOGI("%s: error %d configuring effect "
+                        "%d with channels: [%04x][%04x]",
+                        __func__,
+                        cur_status,
+                        i,
+                        channel_config->main_channels,
+                        channel_config->aux_channels);
+                status = cur_status;
+            }
+        }
+    } else if (effect != NULL && channel_config->aux_channels) {
+        /* if aux channels config did not change but aux channels are present,
+         * we still need to configure the effect being added */
+        status = in_configure_effect_channels(effect, channel_config);
+    }
+    return status;
+}
+
+static void in_update_aux_channels(struct m0_stream_in *in,
+                                   effect_handle_t effect)
+{
+    uint32_t aux_channels;
+    channel_config_t channel_config;
+    int status;
+
+    aux_channels = in_get_aux_channels(in);
+
+    channel_config.main_channels = in->main_channels;
+    channel_config.aux_channels = aux_channels;
+    status = in_reconfigure_channels(in,
+                                     effect,
+                                     &channel_config,
+                                     (aux_channels != in->aux_channels));
+
+    if (status != 0) {
+        ALOGI("%s: in_reconfigure_channels error %d", __func__, status);
+        /* resetting aux channels configuration */
+        aux_channels = 0;
+        channel_config.aux_channels = 0;
+        in_reconfigure_channels(in, effect, &channel_config, true);
+    }
+    if (in->aux_channels != aux_channels) {
+        in->aux_channels_changed = true;
+        in->aux_channels = aux_channels;
+        do_input_standby(in);
+    }
+}
+
+static int in_add_audio_effect(const struct audio_stream *stream,
+                               effect_handle_t effect)
+{
+    struct m0_stream_in *in = (struct m0_stream_in *)stream;
+    int status;
+    effect_descriptor_t desc;
+
+    pthread_mutex_lock(&in->dev->lock);
+    pthread_mutex_lock(&in->lock);
+    if (in->num_preprocessors >= MAX_PREPROCESSORS) {
+        status = -ENOSYS;
+        goto exit;
+    }
+
+    status = (*effect)->get_descriptor(effect, &desc);
+    if (status != 0)
+        goto exit;
+
+    in->preprocessors[in->num_preprocessors].effect_itfe = effect;
+    /* add the supported channel of the effect in the channel_configs */
+    in_read_audio_effect_channel_configs(in, &in->preprocessors[in->num_preprocessors]);
+
+    in->num_preprocessors++;
+
+    /* check compatibility between main channel supported and possible auxiliary channels */
+    in_update_aux_channels(in, effect);
+
+    ALOGV("%s: effect type: %08x", __func__, desc.type.timeLow);
+
+    if (memcmp(&desc.type, FX_IID_AEC, sizeof(effect_uuid_t)) == 0) {
+        in->need_echo_reference = true;
+        do_input_standby(in);
+        in_configure_reverse(in);
+    }
+
+exit:
+
+    ALOGW_IF(status != 0, "%s: error %d", __func__, status);
+    pthread_mutex_unlock(&in->lock);
+    pthread_mutex_unlock(&in->dev->lock);
+    return status;
+}
+
+static int in_remove_audio_effect(const struct audio_stream *stream,
+                                  effect_handle_t effect)
+{
+    struct m0_stream_in *in = (struct m0_stream_in *)stream;
+    int i;
+    int status = -EINVAL;
+    effect_descriptor_t desc;
+
+    pthread_mutex_lock(&in->dev->lock);
+    pthread_mutex_lock(&in->lock);
+    if (in->num_preprocessors <= 0) {
+        status = -ENOSYS;
+        goto exit;
+    }
+
+    for (i = 0; i < in->num_preprocessors; i++) {
+        if (status == 0) { /* status == 0 means an effect was removed from a previous slot */
+            in->preprocessors[i - 1].effect_itfe = in->preprocessors[i].effect_itfe;
+            in->preprocessors[i - 1].channel_configs = in->preprocessors[i].channel_configs;
+            in->preprocessors[i - 1].num_channel_configs = in->preprocessors[i].num_channel_configs;
+            ALOGI("in_remove_audio_effect moving fx from %d to %d", i, i - 1);
+            continue;
+        }
+        if (in->preprocessors[i].effect_itfe == effect) {
+            ALOGI("in_remove_audio_effect found fx at index %d", i);
+            free(in->preprocessors[i].channel_configs);
+            status = 0;
+        }
+    }
+
+    if (status != 0)
+        goto exit;
+
+    in->num_preprocessors--;
+    /* if we remove one effect, at least the last preproc should be reset */
+    in->preprocessors[in->num_preprocessors].num_channel_configs = 0;
+    in->preprocessors[in->num_preprocessors].effect_itfe = NULL;
+    in->preprocessors[in->num_preprocessors].channel_configs = NULL;
+
+
+    /* check compatibility between main channel supported and possible auxiliary channels */
+    in_update_aux_channels(in, NULL);
+
+    status = (*effect)->get_descriptor(effect, &desc);
+    if (status != 0)
+        goto exit;
+
+    ALOGI("%s: effect type: %08x", __func__, desc.type.timeLow);
+
+    if (memcmp(&desc.type, FX_IID_AEC, sizeof(effect_uuid_t)) == 0) {
+        in->need_echo_reference = false;
+        do_input_standby(in);
+    }
+
+exit:
+
+    ALOGW_IF(status != 0, "%s: error %d", __func__, status);
+    pthread_mutex_unlock(&in->lock);
+    pthread_mutex_unlock(&in->dev->lock);
+    return status;
+}
+
+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)
+{
+    struct m0_audio_device *ladev = (struct m0_audio_device *)dev;
+    struct m0_stream_out *out;
+    int ret;
+    int output_type;
+    *stream_out = NULL;
+
+    out = (struct m0_stream_out *)calloc(1, sizeof(struct m0_stream_out));
+    if (!out)
+        return -ENOMEM;
+
+    out->sup_channel_masks[0] = AUDIO_CHANNEL_OUT_STEREO;
+    out->channel_mask = AUDIO_CHANNEL_OUT_STEREO;
+
+    if (ladev->outputs[OUTPUT_DEEP_BUF] != NULL) {
+        ret = -ENOSYS;
+        goto err_open;
+    }
+    output_type = OUTPUT_DEEP_BUF;
+    out->channel_mask = AUDIO_CHANNEL_OUT_STEREO;
+    out->stream.common.get_buffer_size = out_get_buffer_size_deep_buffer;
+    out->stream.common.get_sample_rate = out_get_sample_rate;
+    out->stream.get_latency = out_get_latency_deep_buffer;
+    out->stream.write = out_write_deep_buffer;
+
+    ret = create_resampler(DEFAULT_OUT_SAMPLING_RATE,
+                           MM_FULL_POWER_SAMPLING_RATE,
+                           2,
+                           RESAMPLER_QUALITY_DEFAULT,
+                           NULL,
+                           &out->resampler);
+    if (ret != 0)
+        goto err_open;
+
+    out->stream.common.set_sample_rate = out_set_sample_rate;
+    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.set_volume = out_set_volume;
+    out->stream.get_render_position = out_get_render_position;
+
+    out->dev = ladev;
+    out->standby = 1;
+
+    /* FIXME: when we support multiple output devices, we will want to
+     * do the following:
+     * adev->out_device = out->device;
+     * select_output_device(adev);
+     * This is because out_set_parameters() with a route is not
+     * guaranteed to be called after an output stream is opened. */
+
+    config->format = out->stream.common.get_format(&out->stream.common);
+    config->channel_mask = out->stream.common.get_channels(&out->stream.common);
+    config->sample_rate = out->stream.common.get_sample_rate(&out->stream.common);
+
+    *stream_out = &out->stream;
+    ladev->outputs[output_type] = out;
+
+    return 0;
+
+err_open:
+    free(out);
+    return ret;
+}
+
+static void adev_close_output_stream(struct audio_hw_device *dev,
+                                     struct audio_stream_out *stream)
+{
+    struct m0_audio_device *ladev = (struct m0_audio_device *)dev;
+    struct m0_stream_out *out = (struct m0_stream_out *)stream;
+    int i;
+
+    out_standby(&stream->common);
+    for (i = 0; i < OUTPUT_TOTAL; i++) {
+        if (ladev->outputs[i] == out) {
+            ladev->outputs[i] = NULL;
+            break;
+        }
+    }
+
+    if (out->buffer)
+        free(out->buffer);
+    if (out->resampler)
+        release_resampler(out->resampler);
+    free(stream);
+}
+
+static int adev_set_parameters(struct audio_hw_device *dev, const char *kvpairs)
+{
+    struct m0_audio_device *adev = (struct m0_audio_device *)dev;
+    struct str_parms *parms;
+    char *str;
+    char value[32];
+    int ret;
+
+    parms = str_parms_create_str(kvpairs);
+    ret = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_TTY_MODE, value, sizeof(value));
+    if (ret >= 0) {
+        int tty_mode;
+
+        if (strcmp(value, AUDIO_PARAMETER_VALUE_TTY_OFF) == 0)
+            tty_mode = TTY_MODE_OFF;
+        else if (strcmp(value, AUDIO_PARAMETER_VALUE_TTY_VCO) == 0)
+            tty_mode = TTY_MODE_VCO;
+        else if (strcmp(value, AUDIO_PARAMETER_VALUE_TTY_HCO) == 0)
+            tty_mode = TTY_MODE_HCO;
+        else if (strcmp(value, AUDIO_PARAMETER_VALUE_TTY_FULL) == 0)
+            tty_mode = TTY_MODE_FULL;
+        else
+            return -EINVAL;
+
+        pthread_mutex_lock(&adev->lock);
+        if (tty_mode != adev->tty_mode) {
+            adev->tty_mode = tty_mode;
+            if (adev->mode == AUDIO_MODE_IN_CALL)
+                select_output_device(adev);
+        }
+        pthread_mutex_unlock(&adev->lock);
+    }
+
+    ret = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_BT_NREC, value, sizeof(value));
+    if (ret >= 0) {
+        if (strcmp(value, AUDIO_PARAMETER_VALUE_ON) == 0)
+            adev->bluetooth_nrec = true;
+        else
+            adev->bluetooth_nrec = false;
+    }
+
+    ret = str_parms_get_str(parms, "screen_off", value, sizeof(value));
+    if (ret >= 0) {
+        if (strcmp(value, AUDIO_PARAMETER_VALUE_ON) == 0)
+            adev->screen_off = false;
+        else
+            adev->screen_off = true;
+    }
+
+    str_parms_destroy(parms);
+    return ret;
+}
+
+static char * adev_get_parameters(const struct audio_hw_device *dev,
+                                  const char *keys)
+{
+    return strdup("");
+}
+
+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)
+{
+    struct m0_audio_device *adev = (struct m0_audio_device *)dev;
+
+    adev->voice_volume = volume;
+
+    if (adev->mode == AUDIO_MODE_IN_CALL)
+        ril_set_call_volume(&adev->ril, SOUND_TYPE_VOICE, volume);
+
+    return 0;
+}
+
+static int adev_set_master_volume(struct audio_hw_device *dev, float volume)
+{
+    return -ENOSYS;
+}
+
+static int adev_set_mode(struct audio_hw_device *dev, audio_mode_t mode)
+{
+    struct m0_audio_device *adev = (struct m0_audio_device *)dev;
+
+    pthread_mutex_lock(&adev->lock);
+    if (adev->mode != mode) {
+        adev->mode = mode;
+        select_mode(adev);
+    }
+    pthread_mutex_unlock(&adev->lock);
+
+    return 0;
+}
+
+static int adev_set_mic_mute(struct audio_hw_device *dev, bool state)
+{
+    struct m0_audio_device *adev = (struct m0_audio_device *)dev;
+
+    adev->mic_mute = state;
+
+    return 0;
+}
+
+static int adev_get_mic_mute(const struct audio_hw_device *dev, bool *state)
+{
+    struct m0_audio_device *adev = (struct m0_audio_device *)dev;
+
+    *state = adev->mic_mute;
+
+    return 0;
+}
+
+static size_t adev_get_input_buffer_size(const struct audio_hw_device *dev,
+                                         const struct audio_config *config)
+{
+    size_t size;
+    int channel_count = popcount(config->channel_mask);
+    if (check_input_parameters(config->sample_rate, config->format, channel_count) != 0)
+        return 0;
+
+    return get_input_buffer_size(config->sample_rate, config->format, channel_count);
+}
+
+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)
+{
+    struct m0_audio_device *ladev = (struct m0_audio_device *)dev;
+    struct m0_stream_in *in;
+    int ret;
+    int channel_count = popcount(config->channel_mask);
+
+    *stream_in = NULL;
+
+    if (check_input_parameters(config->sample_rate, config->format, channel_count) != 0)
+        return -EINVAL;
+
+    in = (struct m0_stream_in *)calloc(1, sizeof(struct m0_stream_in));
+    if (!in)
+        return -ENOMEM;
+
+    in->stream.common.get_sample_rate = in_get_sample_rate;
+    in->stream.common.set_sample_rate = in_set_sample_rate;
+    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;
+    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;
+    in->stream.common.remove_audio_effect = in_remove_audio_effect;
+    in->stream.set_gain = in_set_gain;
+    in->stream.read = in_read;
+    in->stream.get_input_frames_lost = in_get_input_frames_lost;
+
+    in->requested_rate = config->sample_rate;
+
+    memcpy(&in->config, &pcm_config_capture, sizeof(pcm_config_capture));
+    in->config.channels = channel_count;
+
+    in->main_channels = config->channel_mask;
+
+    /* initialisation of preprocessor structure array is implicit with the calloc.
+     * same for in->aux_channels and in->aux_channels_changed */
+
+    if (in->requested_rate != in->config.rate) {
+        in->buf_provider.get_next_buffer = get_next_buffer;
+        in->buf_provider.release_buffer = release_buffer;
+
+        ret = create_resampler(in->config.rate,
+                               in->requested_rate,
+                               in->config.channels,
+                               RESAMPLER_QUALITY_DEFAULT,
+                               &in->buf_provider,
+                               &in->resampler);
+        if (ret != 0) {
+            ret = -EINVAL;
+            goto err;
+        }
+    }
+
+    in->dev = ladev;
+    in->standby = 1;
+    in->device = devices & ~AUDIO_DEVICE_BIT_IN;
+
+    *stream_in = &in->stream;
+    return 0;
+
+err:
+    if (in->resampler)
+        release_resampler(in->resampler);
+
+    free(in);
+    return ret;
+}
+
+static void adev_close_input_stream(struct audio_hw_device *dev,
+                                   struct audio_stream_in *stream)
+{
+    struct m0_stream_in *in = (struct m0_stream_in *)stream;
+    int i;
+
+    in_standby(&stream->common);
+
+    for (i = 0; i < in->num_preprocessors; i++) {
+        free(in->preprocessors[i].channel_configs);
+    }
+
+    free(in->read_buf);
+    if (in->resampler) {
+        release_resampler(in->resampler);
+    }
+    if (in->proc_buf_in)
+        free(in->proc_buf_in);
+    if (in->proc_buf_out)
+        free(in->proc_buf_out);
+    if (in->ref_buf)
+        free(in->ref_buf);
+
+    free(stream);
+    return;
+}
+
+static int adev_dump(const audio_hw_device_t *device, int fd)
+{
+    return 0;
+}
+
+static int adev_close(hw_device_t *device)
+{
+    struct m0_audio_device *adev = (struct m0_audio_device *)device;
+
+    /* RIL */
+    ril_close(&adev->ril);
+
+    mixer_close(adev->mixer);
+    free(device);
+    return 0;
+}
+
+struct config_parse_state {
+    struct m0_audio_device *adev;
+    struct m0_dev_cfg *dev;
+    bool on;
+
+    struct route_setting *path;
+    unsigned int path_len;
+};
+
+static const struct {
+    int mask;
+    const char *name;
+} dev_names[] = {
+    { AUDIO_DEVICE_OUT_SPEAKER, "speaker" },
+    { AUDIO_DEVICE_OUT_WIRED_HEADSET | AUDIO_DEVICE_OUT_WIRED_HEADPHONE, "headphone" },
+    { AUDIO_DEVICE_OUT_EARPIECE, "earpiece" },
+    { AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET, "analog-dock" },
+    { AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET, "digital-dock" },
+    { AUDIO_DEVICE_OUT_ALL_SCO, "sco-out" },
+
+    { AUDIO_DEVICE_IN_BUILTIN_MIC, "builtin-mic" },
+    { AUDIO_DEVICE_IN_BACK_MIC, "back-mic" },
+    { AUDIO_DEVICE_IN_WIRED_HEADSET, "headset-in" },
+    { AUDIO_DEVICE_IN_ALL_SCO, "sco-in" },
+};
+
+static void adev_config_start(void *data, const XML_Char *elem,
+                  const XML_Char **attr)
+{
+    struct config_parse_state *s = data;
+    struct m0_dev_cfg *dev_cfg;
+    const XML_Char *name = NULL;
+    const XML_Char *val = NULL;
+    unsigned int i, j;
+
+    for (i = 0; attr[i]; i += 2) {
+    if (strcmp(attr[i], "name") == 0)
+        name = attr[i + 1];
+
+    if (strcmp(attr[i], "val") == 0)
+        val = attr[i + 1];
+    }
+
+    if (strcmp(elem, "device") == 0) {
+    if (!name) {
+        ALOGE("Unnamed device\n");
+        return;
+    }
+
+    for (i = 0; i < sizeof(dev_names) / sizeof(dev_names[0]); i++) {
+        if (strcmp(dev_names[i].name, name) == 0) {
+        ALOGI("Allocating device %s\n", name);
+        dev_cfg = realloc(s->adev->dev_cfgs,
+                  (s->adev->num_dev_cfgs + 1)
+                  * sizeof(*dev_cfg));
+        if (!dev_cfg) {
+            ALOGE("Unable to allocate dev_cfg\n");
+            return;
+        }
+
+        s->dev = &dev_cfg[s->adev->num_dev_cfgs];
+        memset(s->dev, 0, sizeof(*s->dev));
+        s->dev->mask = dev_names[i].mask;
+
+        s->adev->dev_cfgs = dev_cfg;
+        s->adev->num_dev_cfgs++;
+        }
+    }
+
+    } else if (strcmp(elem, "path") == 0) {
+    if (s->path_len)
+        ALOGW("Nested paths\n");
+
+    /* If this a path for a device it must have a role */
+    if (s->dev) {
+        /* Need to refactor a bit... */
+        if (strcmp(name, "on") == 0) {
+        s->on = true;
+        } else if (strcmp(name, "off") == 0) {
+        s->on = false;
+        } else {
+        ALOGW("Unknown path name %s\n", name);
+        }
+    }
+
+    } else if (strcmp(elem, "ctl") == 0) {
+    struct route_setting *r;
+
+    if (!name) {
+        ALOGE("Unnamed control\n");
+        return;
+    }
+
+    if (!val) {
+        ALOGE("No value specified for %s\n", name);
+        return;
+    }
+
+    ALOGV("Parsing control %s => %s\n", name, val);
+
+    r = realloc(s->path, sizeof(*r) * (s->path_len + 1));
+    if (!r) {
+        ALOGE("Out of memory handling %s => %s\n", name, val);
+        return;
+    }
+
+    r[s->path_len].ctl_name = strdup(name);
+    r[s->path_len].strval = NULL;
+
+    /* This can be fooled but it'll do */
+    r[s->path_len].intval = atoi(val);
+    if (!r[s->path_len].intval && strcmp(val, "0") != 0)
+        r[s->path_len].strval = strdup(val);
+
+    s->path = r;
+    s->path_len++;
+    }
+}
+
+static void adev_config_end(void *data, const XML_Char *name)
+{
+    struct config_parse_state *s = data;
+    unsigned int i;
+
+    if (strcmp(name, "path") == 0) {
+    if (!s->path_len)
+        ALOGW("Empty path\n");
+
+    if (!s->dev) {
+        ALOGV("Applying %d element default route\n", s->path_len);
+
+        set_route_by_array(s->adev->mixer, s->path, s->path_len);
+
+        for (i = 0; i < s->path_len; i++) {
+        free(s->path[i].ctl_name);
+        free(s->path[i].strval);
+        }
+
+        free(s->path);
+
+        /* Refactor! */
+    } else if (s->on) {
+        ALOGV("%d element on sequence\n", s->path_len);
+        s->dev->on = s->path;
+        s->dev->on_len = s->path_len;
+
+    } else {
+        ALOGV("%d element off sequence\n", s->path_len);
+
+        /* Apply it, we'll reenable anything that's wanted later */
+        set_route_by_array(s->adev->mixer, s->path, s->path_len);
+
+        s->dev->off = s->path;
+        s->dev->off_len = s->path_len;
+    }
+
+    s->path_len = 0;
+    s->path = NULL;
+
+    } else if (strcmp(name, "device") == 0) {
+    s->dev = NULL;
+    }
+}
+
+static int adev_config_parse(struct m0_audio_device *adev)
+{
+    struct config_parse_state s;
+    FILE *f;
+    XML_Parser p;
+    int ret = 0;
+    bool eof = false;
+    int len;
+    char buf[1024];
+
+    ALOGV("Reading configuration from %s\n", CONFIG_FILE);
+    f = fopen(CONFIG_FILE, "r");
+    if (!f) {
+    ALOGE("Failed to open %s\n", CONFIG_FILE);
+    return -ENODEV;
+    }
+
+    p = XML_ParserCreate(NULL);
+    if (!p) {
+    ALOGE("Failed to create XML parser\n");
+    ret = -ENOMEM;
+    goto out;
+    }
+
+    memset(&s, 0, sizeof(s));
+    s.adev = adev;
+    XML_SetUserData(p, &s);
+
+    XML_SetElementHandler(p, adev_config_start, adev_config_end);
+
+    while (!eof) {
+    len = fread(buf, 1, sizeof(buf), f);
+    if (ferror(f)) {
+        ALOGE("I/O error reading config\n");
+        ret = -EIO;
+        goto out_parser;
+    }
+    eof = feof(f);
+
+    if (XML_Parse(p, buf, len, eof) == XML_STATUS_ERROR) {
+        ALOGE("Parse error at line %u:\n%s\n",
+         (unsigned int)XML_GetCurrentLineNumber(p),
+         XML_ErrorString(XML_GetErrorCode(p)));
+        ret = -EINVAL;
+        goto out_parser;
+    }
+    }
+
+ out_parser:
+    XML_ParserFree(p);
+ out:
+    fclose(f);
+
+    return ret;
+}
+
+static int adev_open(const hw_module_t* module, const char* name,
+                     hw_device_t** device)
+{
+    struct m0_audio_device *adev;
+    int ret;
+
+    if (strcmp(name, AUDIO_HARDWARE_INTERFACE) != 0)
+        return -EINVAL;
+
+    adev = calloc(1, sizeof(struct m0_audio_device));
+    if (!adev)
+        return -ENOMEM;
+
+    adev->hw_device.common.tag = HARDWARE_DEVICE_TAG;
+    adev->hw_device.common.version = AUDIO_DEVICE_API_VERSION_2_0;
+    adev->hw_device.common.module = (struct hw_module_t *) module;
+    adev->hw_device.common.close = adev_close;
+
+    adev->hw_device.init_check = adev_init_check;
+    adev->hw_device.set_voice_volume = adev_set_voice_volume;
+    adev->hw_device.set_master_volume = adev_set_master_volume;
+    adev->hw_device.set_mode = adev_set_mode;
+    adev->hw_device.set_mic_mute = adev_set_mic_mute;
+    adev->hw_device.get_mic_mute = adev_get_mic_mute;
+    adev->hw_device.set_parameters = adev_set_parameters;
+    adev->hw_device.get_parameters = adev_get_parameters;
+    adev->hw_device.get_input_buffer_size = adev_get_input_buffer_size;
+    adev->hw_device.open_output_stream = adev_open_output_stream;
+    adev->hw_device.close_output_stream = adev_close_output_stream;
+    adev->hw_device.open_input_stream = adev_open_input_stream;
+    adev->hw_device.close_input_stream = adev_close_input_stream;
+    adev->hw_device.dump = adev_dump;
+
+    adev->mixer = mixer_open(CARD_DEFAULT);
+    if (!adev->mixer) {
+        free(adev);
+        ALOGE("Unable to open the mixer, aborting.");
+        return -EINVAL;
+    }
+
+    /* +30db boost for mics */
+    adev->mixer_ctls.mixinl_in1l_volume = mixer_get_ctl_by_name(adev->mixer, "MIXINL IN1L Volume");
+    adev->mixer_ctls.mixinl_in2l_volume = mixer_get_ctl_by_name(adev->mixer, "MIXINL IN2L Volume");
+
+    ret = adev_config_parse(adev);
+    if (ret != 0)
+        goto err_mixer;
+
+    /* Set the default route before the PCM stream is opened */
+    pthread_mutex_lock(&adev->lock);
+    adev->mode = AUDIO_MODE_NORMAL;
+    adev->out_device = AUDIO_DEVICE_OUT_SPEAKER;
+    adev->in_device = AUDIO_DEVICE_IN_BUILTIN_MIC & ~AUDIO_DEVICE_BIT_IN;
+    select_devices(adev);
+
+    adev->pcm_modem_dl = NULL;
+    adev->pcm_modem_ul = NULL;
+    adev->voice_volume = 1.0f;
+    adev->tty_mode = TTY_MODE_OFF;
+    adev->bluetooth_nrec = true;
+    adev->wb_amr = 0;
+
+    /* RIL */
+    ril_open(&adev->ril);
+    pthread_mutex_unlock(&adev->lock);
+    /* register callback for wideband AMR setting */
+    ril_register_set_wb_amr_callback(audio_set_wb_amr_callback, (void *)adev);
+
+    *device = &adev->hw_device.common;
+
+    return 0;
+
+err_mixer:
+    mixer_close(adev->mixer);
+err:
+    return -EINVAL;
+}
+
+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 = "M0 audio HW HAL",
+        .author = "The CyanogenMod Project",
+        .methods = &hal_module_methods,
+    },
+};
diff --git a/audio/audio_hw.h b/audio/audio_hw.h
new file mode 100644
index 0000000..246cba8
--- /dev/null
+++ b/audio/audio_hw.h
@@ -0,0 +1,239 @@
+/*
+ * Copyright (C) 2011 The Android Open Source Project
+ * Copyright (C) 2012 Wolfson Microelectronics plc
+ * Copyright (C) 2012 The CyanogenMod Project
+ *               Daniel Hillenbrand <codeworkx@cyanogenmod.com>
+ *               Guillaume "XpLoDWilD" Lesniak <xplodgui@gmail.com>
+ *
+ * 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 CONFIG_FILE "/system/etc/sound/tiny_hw.xml"
+
+/* ALSA cards for WM1811 */
+#define CARD_DEFAULT  0
+
+#define PORT_PLAYBACK 0
+#define PORT_MODEM    1
+#define PORT_BT       2
+#define PORT_CAPTURE  3
+
+#define PCM_WRITE pcm_write
+
+#define PLAYBACK_PERIOD_SIZE  880
+#define PLAYBACK_PERIOD_COUNT 8
+#define PLAYBACK_SHORT_PERIOD_COUNT 2
+
+#define CAPTURE_PERIOD_SIZE   1024
+#define CAPTURE_PERIOD_COUNT  4
+
+#define SHORT_PERIOD_SIZE 192
+
+//
+// deep buffer
+//
+/* screen on */
+#define DEEP_BUFFER_SHORT_PERIOD_SIZE 1056
+#define PLAYBACK_DEEP_BUFFER_SHORT_PERIOD_COUNT 4
+/* screen off */
+#define DEEP_BUFFER_LONG_PERIOD_SIZE 880
+#define PLAYBACK_DEEP_BUFFER_LONG_PERIOD_COUNT 8
+
+
+/* minimum sleep time in out_write() when write threshold is not reached */
+#define MIN_WRITE_SLEEP_US 5000
+
+#define RESAMPLER_BUFFER_FRAMES (PLAYBACK_PERIOD_SIZE * 2)
+#define RESAMPLER_BUFFER_SIZE (4 * RESAMPLER_BUFFER_FRAMES)
+
+#define DEFAULT_OUT_SAMPLING_RATE 44100
+#define MM_LOW_POWER_SAMPLING_RATE 44100
+#define MM_FULL_POWER_SAMPLING_RATE 44100
+#define DEFAULT_IN_SAMPLING_RATE 44100
+
+/* sampling rate when using VX port for narrow band */
+#define VX_NB_SAMPLING_RATE 8000
+/* sampling rate when using VX port for wide band */
+#define VX_WB_SAMPLING_RATE 16000
+
+#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
+
+#define STRING_TO_ENUM(string) { #string, string }
+
+struct string_to_enum {
+    const char *name;
+    uint32_t value;
+};
+
+const struct string_to_enum out_channels_name_to_enum_table[] = {
+    STRING_TO_ENUM(AUDIO_CHANNEL_OUT_STEREO),
+    STRING_TO_ENUM(AUDIO_CHANNEL_OUT_5POINT1),
+    STRING_TO_ENUM(AUDIO_CHANNEL_OUT_7POINT1),
+};
+
+enum pcm_type {
+    PCM_NORMAL = 0,
+    PCM_SPDIF,
+    PCM_HDMI,
+    PCM_TOTAL,
+};
+
+enum output_type {
+    OUTPUT_DEEP_BUF,      // deep PCM buffers output stream
+    OUTPUT_LOW_LATENCY,   // low latency output stream
+    OUTPUT_HDMI,
+    OUTPUT_TOTAL
+};
+
+enum tty_modes {
+    TTY_MODE_OFF,
+    TTY_MODE_VCO,
+    TTY_MODE_HCO,
+    TTY_MODE_FULL
+};
+
+struct mixer_ctls
+{
+    struct mixer_ctl *mixinl_in1l_volume;
+    struct mixer_ctl *mixinl_in2l_volume;
+};
+
+struct route_setting
+{
+    char *ctl_name;
+    int intval;
+    char *strval;
+};
+
+struct route_setting voicecall_default[] = {
+    { .ctl_name = "AIF2DACL Source", .intval = 0, },
+    { .ctl_name = "AIF2DACR Source", .intval = 0, },
+    { .ctl_name = "AIF2 Mode", .intval = 0, },
+    { .ctl_name = "DAC1L Mixer AIF1.1 Switch", .intval = 1, },
+    { .ctl_name = "DAC1R Mixer AIF1.1 Switch", .intval = 1, },
+    { .ctl_name = "DAC1L Mixer AIF2 Switch", .intval = 1, },
+    { .ctl_name = "DAC1R Mixer AIF2 Switch", .intval = 1, },
+    { .ctl_name = "AIF2DAC Mux", .strval = "AIF2DACDAT", },
+    { .ctl_name = NULL, },
+};
+
+struct route_setting voicecall_default_disable[] = {
+    { .ctl_name = "AIF2DACL Source", .intval = 0, },
+    { .ctl_name = "AIF2DACR Source", .intval = 1, },
+    { .ctl_name = "AIF2 Mode", .intval = 0, },
+    { .ctl_name = "DAC1L Mixer AIF2 Switch", .intval = 0, },
+    { .ctl_name = "DAC1R Mixer AIF2 Switch", .intval = 0, },
+    { .ctl_name = "AIF2DAC Mux", .strval = "AIF3DACDAT", },
+    { .ctl_name = "Main Mic Switch", .intval = 0, },
+    { .ctl_name = "MIXINL IN1L Switch", .intval = 0, },
+    { .ctl_name = "Sub Mic Switch", .intval = 0, },
+    { .ctl_name = "MIXINR IN1R Switch", .intval = 0, },
+    { .ctl_name = NULL, },
+};
+
+struct route_setting default_input[] = {
+    { .ctl_name = "Main Mic Switch", .intval = 1, },
+    { .ctl_name = "IN1L Volume", .intval = 30, },
+    { .ctl_name = "MIXINL IN1L Switch", .intval = 1, },
+    { .ctl_name = "MIXINL IN1L Volume", .intval = 0, },
+    { .ctl_name = "AIF1ADC1 HPF Mode", .intval = 0, },
+    { .ctl_name = "AIF1ADC1 HPF Switch", .intval = 1, },
+    { .ctl_name = NULL, },
+};
+
+struct route_setting default_input_disable[] = {
+    { .ctl_name = "Main Mic Switch", .intval = 0, },
+    { .ctl_name = "IN1L Volume", .intval = 22, },
+    { .ctl_name = "MIXINL IN1L Switch", .intval = 0, },
+    { .ctl_name = "AIF1ADC1 HPF Switch", .intval = 0, },
+    { .ctl_name = NULL, },
+};
+
+struct route_setting headset_input[] = {
+    { .ctl_name = "MIXINL IN1L Switch", .intval = 0, },
+    { .ctl_name = "MIXINR IN1R Switch", .intval = 0, },
+    { .ctl_name = "Headset Mic Switch", .intval = 1, },
+    { .ctl_name = "IN2L Volume", .intval = 18, },
+    { .ctl_name = "MIXINL IN2L Switch", .intval = 1, },
+    { .ctl_name = "MIXINL IN2L Volume", .intval = 0, },
+    { .ctl_name = "AIF1ADC1 HPF Mode", .intval = 1, },
+    { .ctl_name = "AIF1ADC1 HPF Switch", .intval = 1, },
+    { .ctl_name = "AIF1ADC1 Volume", .intval = 96, },
+    { .ctl_name = "AIF1ADCL Source", .intval = 0, },
+    { .ctl_name = "AIF1ADCR Source", .intval = 0, },
+    { .ctl_name = "AIF2ADCL Source", .intval = 0, },
+    { .ctl_name = NULL, },
+};
+
+struct route_setting headset_input_disable[] = {
+    { .ctl_name = "Headset Mic Switch", .intval = 0, },
+    { .ctl_name = "MIXINL IN2L Switch", .intval = 0, },
+    { .ctl_name = "AIF1ADC1 HPF Mode", .intval = 0, },
+    { .ctl_name = "AIF1ADC1 HPF Switch", .intval = 0, },
+    { .ctl_name = NULL, },
+};
+
+struct route_setting bt_output[] = {
+    { .ctl_name = "DAC1L Mixer AIF1.1 Switch", .intval = 1, },
+    { .ctl_name = "DAC1R Mixer AIF1.1 Switch", .intval = 1, },
+    { .ctl_name = "AIF3ADC Mux", .intval = 1, },
+    { .ctl_name = "AIF2DAC2L Mixer AIF1.1 Switch", .intval = 1, },
+    { .ctl_name = "AIF2DAC2R Mixer AIF1.1 Switch", .intval = 1, },
+    { .ctl_name = "AIF2DAC Volume", .intval = 96, },
+    { .ctl_name = "DAC2 Volume", .intval = 96, },
+    { .ctl_name = "AIF2ADC Volume", .intval = 96, },
+    { .ctl_name = "Speaker Mixer Volume", .intval = 1, },
+    { .ctl_name = "MIXINL IN2L Volume", .intval = 1, },
+    { .ctl_name = "IN1L Volume", .intval = 25, },
+    { .ctl_name = "IN1R Volume", .intval = 25, },
+    { .ctl_name = "Speaker Boost Volume", .intval = 4, },
+    { .ctl_name = "LINEOUT1N Switch", .intval = 0, },
+    { .ctl_name = "LINEOUT1P Switch", .intval = 0, },
+    { .ctl_name = "AIF2DACR Source", .intval = 0, },
+    { .ctl_name = "AIF1ADC1 HPF Switch", .intval = 0, },
+    { .ctl_name = "AIF2ADC HPF Mode", .intval = 1, },
+    { .ctl_name = "AIF2ADC HPF Switch", .intval = 1, },
+    { .ctl_name = "AIF2DAC Mux", .strval = "AIF2DACDAT", },
+    { .ctl_name = "AIF2DAC2R Mixer AIF2 Switch", .intval = 1, },
+    { .ctl_name = "AIF2DAC2L Mixer AIF2 Switch", .intval = 1, },
+    { .ctl_name = NULL, },
+};
+
+struct route_setting bt_input[] = {
+    { .ctl_name = "AIF2ADC Mux", .intval = 1, },
+    { .ctl_name = "AIF1ADCL Source", .intval = 0, },
+    { .ctl_name = "AIF1ADCR Source", .intval = 1, },
+    { .ctl_name = "AIF2ADCL Source", .intval = 0, },
+    { .ctl_name = "AIF2ADCR Source", .intval = 1, },
+    { .ctl_name = "DAC1L Mixer AIF2 Switch", .intval = 1, },
+    { .ctl_name = "DAC1R Mixer AIF2 Switch", .intval = 1, },
+    { .ctl_name = "AIF1ADC1R Mixer AIF2 Switch", .intval = 1, },
+    { .ctl_name = "AIF1ADC1L Mixer AIF2 Switch", .intval = 1, },
+    { .ctl_name = "AIF1ADC1 Volume", .intval = 96, },
+    { .ctl_name = "AIF2DAC Volume", .intval = 96, },
+    { .ctl_name = NULL, },
+};
+
+struct route_setting bt_disable[] = {
+    { .ctl_name = "AIF2ADC Mux", .intval = 0, },
+    { .ctl_name = "MIXINL IN2L Volume", .intval = 0, },
+    { .ctl_name = "LINEOUT1N Switch", .intval = 1, },
+    { .ctl_name = "LINEOUT1P Switch", .intval = 1, },
+    { .ctl_name = "AIF2ADC HPF Mode", .intval = 0, },
+    { .ctl_name = "AIF2ADC HPF Switch", .intval = 0, },
+    { .ctl_name = "AIF2DAC2R Mixer AIF2 Switch", .intval = 0, },
+    { .ctl_name = "AIF2DAC2L Mixer AIF2 Switch", .intval = 0, },
+    { .ctl_name = "AIF1ADC1R Mixer AIF2 Switch", .intval = 0, },
+    { .ctl_name = "AIF1ADC1L Mixer AIF2 Switch", .intval = 0, },
+    { .ctl_name = NULL, },
+};
diff --git a/audio/ril_interface.c b/audio/ril_interface.c
new file mode 100755
index 0000000..89a0aef
--- /dev/null
+++ b/audio/ril_interface.c
@@ -0,0 +1,183 @@
+/*
+ * Copyright (C) 2011 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 ALOG_TAG "audio_hw_primary"
+/*#define ALOG_NDEBUG 0*/
+
+#include <dlfcn.h>
+#include <stdlib.h>
+
+#include <utils/Log.h>
+#include <cutils/properties.h>
+
+#include "ril_interface.h"
+
+#define VOLUME_STEPS_DEFAULT  "5"
+#define VOLUME_STEPS_PROPERTY "ro.config.vc_call_vol_steps"
+
+/* Function pointers */
+void *(*_ril_open_client)(void);
+int (*_ril_close_client)(void *);
+int (*_ril_connect)(void *);
+int (*_ril_is_connected)(void *);
+int (*_ril_disconnect)(void *);
+int (*_ril_set_call_volume)(void *, enum ril_sound_type, int);
+int (*_ril_set_call_audio_path)(void *, enum ril_audio_path);
+int (*_ril_set_call_clock_sync)(void *, enum ril_clock_state);
+int (*_ril_register_unsolicited_handler)(void *, int, void *);
+int (*_ril_get_wb_amr)(void *, void *);
+
+/* Audio WB AMR callback */
+void (*_audio_set_wb_amr_callback)(void *, int);
+void *callback_data = NULL;
+
+void ril_register_set_wb_amr_callback(void *function, void *data)
+{
+    _audio_set_wb_amr_callback = function;
+    callback_data = data;
+}
+
+/* This is the callback function that the RIL uses to
+set the wideband AMR state */
+static int ril_set_wb_amr_callback(void *ril_client,
+                                   const void *data,
+                                   size_t datalen)
+{
+    int enable = ((int *)data)[0];
+
+    if (!callback_data || !_audio_set_wb_amr_callback)
+        return -1;
+
+    _audio_set_wb_amr_callback(callback_data, enable);
+
+    return 0;
+}
+
+static int ril_connect_if_required(struct ril_handle *ril)
+{
+    if (_ril_is_connected(ril->client))
+        return 0;
+
+    if (_ril_connect(ril->client) != RIL_CLIENT_ERR_SUCCESS) {
+        ALOGE("ril_connect() failed");
+        return -1;
+    }
+
+    /* get wb amr status to set pcm samplerate depending on
+       wb amr status when ril is connected. */
+    if(_ril_get_wb_amr)
+        _ril_get_wb_amr(ril->client, ril_set_wb_amr_callback);
+
+    return 0;
+}
+
+int ril_open(struct ril_handle *ril)
+{
+    char property[PROPERTY_VALUE_MAX];
+
+    if (!ril)
+        return -1;
+
+    ril->handle = dlopen(RIL_CLIENT_LIBPATH, RTLD_NOW);
+
+    if (!ril->handle) {
+        ALOGE("Cannot open '%s'", RIL_CLIENT_LIBPATH);
+        return -1;
+    }
+
+    _ril_open_client = dlsym(ril->handle, "OpenClient_RILD");
+    _ril_close_client = dlsym(ril->handle, "CloseClient_RILD");
+    _ril_connect = dlsym(ril->handle, "Connect_RILD");
+    _ril_is_connected = dlsym(ril->handle, "isConnected_RILD");
+    _ril_disconnect = dlsym(ril->handle, "Disconnect_RILD");
+    _ril_set_call_volume = dlsym(ril->handle, "SetCallVolume");
+    _ril_set_call_audio_path = dlsym(ril->handle, "SetCallAudioPath");
+    _ril_set_call_clock_sync = dlsym(ril->handle, "SetCallClockSync");
+    _ril_register_unsolicited_handler = dlsym(ril->handle,
+                                              "RegisterUnsolicitedHandler");
+    /* since this function is not supported in all RILs, don't require it */
+    _ril_get_wb_amr = dlsym(ril->handle, "GetWB_AMR");
+
+    if (!_ril_open_client || !_ril_close_client || !_ril_connect ||
+        !_ril_is_connected || !_ril_disconnect || !_ril_set_call_volume ||
+        !_ril_set_call_audio_path || !_ril_set_call_clock_sync ||
+        !_ril_register_unsolicited_handler) {
+        ALOGE("Cannot get symbols from '%s'", RIL_CLIENT_LIBPATH);
+        dlclose(ril->handle);
+        return -1;
+    }
+
+    ril->client = _ril_open_client();
+    if (!ril->client) {
+        ALOGE("ril_open_client() failed");
+        dlclose(ril->handle);
+        return -1;
+    }
+
+    /* register the wideband AMR callback */
+    _ril_register_unsolicited_handler(ril->client, RIL_UNSOL_WB_AMR_STATE,
+                                      ril_set_wb_amr_callback);
+
+    property_get(VOLUME_STEPS_PROPERTY, property, VOLUME_STEPS_DEFAULT);
+    ril->volume_steps_max = atoi(property);
+    /* this catches the case where VOLUME_STEPS_PROPERTY does not contain
+    an integer */
+    if (ril->volume_steps_max == 0)
+        ril->volume_steps_max = atoi(VOLUME_STEPS_DEFAULT);
+
+    return 0;
+}
+
+int ril_close(struct ril_handle *ril)
+{
+    if (!ril || !ril->handle || !ril->client)
+        return -1;
+
+    if ((_ril_disconnect(ril->client) != RIL_CLIENT_ERR_SUCCESS) ||
+        (_ril_close_client(ril->client) != RIL_CLIENT_ERR_SUCCESS)) {
+        ALOGE("ril_disconnect() or ril_close_client() failed");
+        return -1;
+    }
+
+    dlclose(ril->handle);
+    return 0;
+}
+
+int ril_set_call_volume(struct ril_handle *ril, enum ril_sound_type sound_type,
+                        float volume)
+{
+    if (ril_connect_if_required(ril))
+        return 0;
+
+    return _ril_set_call_volume(ril->client, sound_type,
+                                (int)(volume * ril->volume_steps_max));
+}
+
+int ril_set_call_audio_path(struct ril_handle *ril, enum ril_audio_path path)
+{
+    if (ril_connect_if_required(ril))
+        return 0;
+
+    return _ril_set_call_audio_path(ril->client, path);
+}
+
+int ril_set_call_clock_sync(struct ril_handle *ril, enum ril_clock_state state)
+{
+    if (ril_connect_if_required(ril))
+        return 0;
+
+    return _ril_set_call_clock_sync(ril->client, state);
+}
diff --git a/audio/ril_interface.h b/audio/ril_interface.h
new file mode 100755
index 0000000..676772c
--- /dev/null
+++ b/audio/ril_interface.h
@@ -0,0 +1,72 @@
+/*
+ * Copyright (C) 2011 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 RIL_INTERFACE_H
+#define RIL_INTERFACE_H
+
+#define RIL_CLIENT_LIBPATH "libsecril-client.so"
+
+#define RIL_CLIENT_ERR_SUCCESS      0
+#define RIL_CLIENT_ERR_AGAIN        1
+#define RIL_CLIENT_ERR_INIT         2 // Client is not initialized
+#define RIL_CLIENT_ERR_INVAL        3 // Invalid value
+#define RIL_CLIENT_ERR_CONNECT      4 // Connection error
+#define RIL_CLIENT_ERR_IO           5 // IO error
+#define RIL_CLIENT_ERR_RESOURCE     6 // Resource not available
+#define RIL_CLIENT_ERR_UNKNOWN      7
+
+#define RIL_OEM_UNSOL_RESPONSE_BASE 11000 // RIL response base index
+#define RIL_UNSOL_WB_AMR_STATE \
+    (RIL_OEM_UNSOL_RESPONSE_BASE + 17)    // RIL AMR state index
+
+struct ril_handle
+{
+    void *handle;
+    void *client;
+    int volume_steps_max;
+};
+
+enum ril_sound_type {
+    SOUND_TYPE_VOICE,
+    SOUND_TYPE_SPEAKER,
+    SOUND_TYPE_HEADSET,
+    SOUND_TYPE_BTVOICE
+};
+
+enum ril_audio_path {
+    SOUND_AUDIO_PATH_HANDSET,
+    SOUND_AUDIO_PATH_HEADSET,
+    SOUND_AUDIO_PATH_SPEAKER,
+    SOUND_AUDIO_PATH_BLUETOOTH,
+    SOUND_AUDIO_PATH_BLUETOOTH_NO_NR,
+    SOUND_AUDIO_PATH_HEADPHONE
+};
+
+enum ril_clock_state {
+    SOUND_CLOCK_STOP,
+    SOUND_CLOCK_START
+};
+
+/* Function prototypes */
+int ril_open(struct ril_handle *ril);
+int ril_close(struct ril_handle *ril);
+int ril_set_call_volume(struct ril_handle *ril, enum ril_sound_type sound_type,
+                        float volume);
+int ril_set_call_audio_path(struct ril_handle *ril, enum ril_audio_path path);
+int ril_set_call_clock_sync(struct ril_handle *ril, enum ril_clock_state state);
+void ril_register_set_wb_amr_callback(void *function, void *data);
+#endif
+
diff --git a/bluetooth/bdroid_buildcfg.h b/bluetooth/bdroid_buildcfg.h
new file mode 100755
index 0000000..41d14f3
--- /dev/null
+++ b/bluetooth/bdroid_buildcfg.h
@@ -0,0 +1,23 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ * Copyright (C) 2012 The CyanogenMod Project <http://www.cyanogenmod.org>
+ *
+ * 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 _BDROID_BUILDCFG_H
+#define _BDROID_BUILDCFG_H
+
+#define BTM_DEF_LOCAL_NAME   "Galaxy Note 8.0"
+
+#endif
diff --git a/bluetooth/vnd_n5110.txt b/bluetooth/vnd_n5110.txt
new file mode 100755
index 0000000..670fbc7
--- /dev/null
+++ b/bluetooth/vnd_n5110.txt
@@ -0,0 +1,14 @@
+BLUETOOTH_UART_DEVICE_PORT = "/dev/ttySAC0"
+FW_PATCHFILE_LOCATION = "/system/bin"
+LPM_IDLE_TIMEOUT_MULTIPLE = 5
+BTVND_DBG = FALSE
+BTHW_DBG = TRUE
+VNDUSERIAL_DBG = FALSE
+UPIO_DBG = FALSE
+UART_TARGET_BAUD_RATE = 3000000
+FW_PATCH_SETTLEMENT_DELAY_MS = 50
+SCO_USE_I2S_INTERFACE = TRUE
+SCO_I2SPCM_IF_MODE = 1
+SCO_I2SPCM_IF_ROLE = 0
+SCO_I2SPCM_IF_SAMPLE_RATE = 0
+SCO_I2SPCM_IF_CLOCK_RATE = 1
diff --git a/cm.dependencies b/cm.dependencies
new file mode 100644
index 0000000..a78a94f
--- /dev/null
+++ b/cm.dependencies
@@ -0,0 +1,18 @@
+[
+    {
+        "repository": "android_device_samsung_smdk4412-common",
+        "target_path": "device/samsung/smdk4412-common"
+    },
+    {
+        "repository": "android_kernel_samsung_smdk4412",
+        "target_path": "kernel/samsung/smdk4412"
+    },
+    {
+        "repository": "android_packages_apps_SamsungServiceMode",
+        "target_path": "packages/apps/SamsungServiceMode"
+    },
+    {
+        "repository": "android_hardware_samsung",
+        "target_path": "hardware/samsung"
+    }
+]
diff --git a/cm.mk b/cm.mk
new file mode 100644
index 0000000..572b0e1
--- /dev/null
+++ b/cm.mk
@@ -0,0 +1,21 @@
+# Specify phone tech before including full_phone
+$(call inherit-product, vendor/cm/config/cdma.mk)
+
+# Release name
+PRODUCT_RELEASE_NAME := n5110
+
+# Inherit some common CM stuff.
+$(call inherit-product, vendor/cm/config/common_full_tablet_wifionly.mk)
+
+# Inherit device configuration
+$(call inherit-product, device/samsung/n5110/full_n5110.mk)
+
+# Device identifier. This must come after all inclusions
+PRODUCT_DEVICE := n5110
+PRODUCT_NAME := cm_n5110
+PRODUCT_BRAND := samsung
+PRODUCT_MODEL := GT-N5110
+PRODUCT_MANUFACTURER := samsung
+
+# Set build fingerprint / ID / Product Name ect.
+PRODUCT_BUILD_PROP_OVERRIDES += PRODUCT_NAME=konawifixx TARGET_DEVICE=konawifi BUILD_FINGERPRINT="samsung/konawifixx/konawifi:4.1.2/JZO54K/N5110XXBMF2:user/release-keys" PRIVATE_BUILD_DESC="konawifixx-user 4.1.2 JZO54K N5110XXBMF2 release-keys"
diff --git a/configs/Android.mk b/configs/Android.mk
new file mode 100644
index 0000000..c0d0384
--- /dev/null
+++ b/configs/Android.mk
@@ -0,0 +1,12 @@
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := tiny_hw
+LOCAL_MODULE_OWNER := samsung
+LOCAL_SRC_FILES := tiny_hw.xml
+LOCAL_MODULE_TAGS := optional
+LOCAL_MODULE_CLASS := ETC
+LOCAL_MODULE_SUFFIX := .xml
+LOCAL_MODULE_PATH := $(TARGET_OUT)/etc/sound
+include $(BUILD_PREBUILT)
+
diff --git a/configs/audio_policy.conf b/configs/audio_policy.conf
new file mode 100644
index 0000000..3a0a14c
--- /dev/null
+++ b/configs/audio_policy.conf
@@ -0,0 +1,82 @@
+# Global configuration section: lists input and output devices always present on the device
+# as well as the output device selected by default.
+# Devices are designated by a string that corresponds to the enum in audio.h
+
+global_configuration {
+  attached_output_devices AUDIO_DEVICE_OUT_SPEAKER
+  default_output_device AUDIO_DEVICE_OUT_SPEAKER
+  attached_input_devices AUDIO_DEVICE_IN_BUILTIN_MIC
+}
+
+# audio hardware module section: contains descriptors for all audio hw modules present on the
+# device. Each hw module node is named after the corresponding hw module library base name.
+# For instance, "primary" corresponds to audio.primary.<device>.so.
+# The "primary" module is mandatory and must include at least one output with
+# AUDIO_OUTPUT_FLAG_PRIMARY flag.
+# Each module descriptor contains one or more output profile descriptors and zero or more
+# input profile descriptors. Each profile lists all the parameters supported by a given output
+# or input stream category.
+# The "channel_masks", "formats", "devices" and "flags" are specified using strings corresponding
+# to enums in audio.h and audio_policy.h. They are concatenated by use of "|" without space or "\n".
+
+audio_hw_modules {
+  primary {
+    outputs {
+      primary {
+        sampling_rates 44100|48000
+        channel_masks AUDIO_CHANNEL_OUT_STEREO
+        formats AUDIO_FORMAT_PCM_16_BIT
+        devices AUDIO_DEVICE_OUT_SPEAKER|AUDIO_DEVICE_OUT_WIRED_HEADSET|AUDIO_DEVICE_OUT_WIRED_HEADPHONE|AUDIO_DEVICE_OUT_ALL_SCO|AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET
+        flags AUDIO_OUTPUT_FLAG_PRIMARY
+      }
+      deep_buffer {
+        sampling_rates 44100
+        channel_masks AUDIO_CHANNEL_OUT_STEREO
+        formats AUDIO_FORMAT_PCM_16_BIT
+        devices AUDIO_DEVICE_OUT_SPEAKER|AUDIO_DEVICE_OUT_WIRED_HEADSET|AUDIO_DEVICE_OUT_WIRED_HEADPHONE
+        flags AUDIO_OUTPUT_FLAG_DEEP_BUFFER
+      }
+      hdmi {
+        sampling_rates 44100|48000
+        channel_masks dynamic
+        formats AUDIO_FORMAT_PCM_16_BIT
+        devices AUDIO_DEVICE_OUT_AUX_DIGITAL
+        flags AUDIO_OUTPUT_FLAG_DIRECT
+      }
+    }
+    inputs {
+      primary {
+        sampling_rates 8000|11025|16000|22050|24000|32000|44100|48000
+        channel_masks AUDIO_CHANNEL_IN_MONO|AUDIO_CHANNEL_IN_STEREO
+        formats AUDIO_FORMAT_PCM_16_BIT
+        devices AUDIO_DEVICE_IN_BUILTIN_MIC|AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET|AUDIO_DEVICE_IN_WIRED_HEADSET
+      }
+    }
+  }
+  a2dp {
+    outputs {
+      a2dp {
+        sampling_rates 44100
+        channel_masks AUDIO_CHANNEL_OUT_STEREO
+        formats AUDIO_FORMAT_PCM_16_BIT
+        devices AUDIO_DEVICE_OUT_ALL_A2DP
+      }
+    }
+  }
+  usb {
+    outputs {
+      usb_accessory {
+        sampling_rates 44100
+        channel_masks AUDIO_CHANNEL_OUT_STEREO
+        formats AUDIO_FORMAT_PCM_16_BIT
+        devices AUDIO_DEVICE_OUT_USB_ACCESSORY
+      }
+      usb_device {
+        sampling_rates 44100
+        channel_masks AUDIO_CHANNEL_OUT_STEREO
+        formats AUDIO_FORMAT_PCM_16_BIT
+        devices AUDIO_DEVICE_OUT_USB_DEVICE
+      }
+    }
+  }
+}
diff --git a/configs/gps.xml b/configs/gps.xml
new file mode 100644
index 0000000..38f16ad
--- /dev/null
+++ b/configs/gps.xml
@@ -0,0 +1,72 @@
+<?xml version="1.0" encoding="utf-8"?>
+<glgps xmlns="http://www.glpals.com/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.glpals.com/glconfig.xsd" >
+  <!--HAL Confguration  -->
+  <hal
+       acPortName="/dev/ttySAC1"
+       lBaudRate="921600"
+       gpioNStdbyPath="/sys/class/sec/gps/GPS_PWR_EN/value"
+       gpioDelayMs="250"
+       acNvStoDir="/data/system/gps/"
+       FactoryTestFilePath="/data/"
+
+       Log="JAVA"
+       acLogDirectory="/storage/sdcard0/gps/broadcom/storage"
+
+       TISEnabled="true"
+       LPmode="false"
+       cp-cold-start="false"
+       cp-guard-time-sec="1"
+
+       arp-supl-enable="true"
+       arp-supl-cap-msb="true"
+       arp-supl-cap-msa="true"
+       arp-supl-cap-ecid="false"
+       arp-supl-use-apn="false"
+       acSuplServer="supl.google.com"
+       SuplPort="7276"
+       tlsCertPath="/system/bin/gps.cer"
+       tlsEnable="false"
+       ReAidingIntervalSec="1200"
+       SuplUT1Seconds="20"
+       SuplUT2Seconds="20"
+       SuplUT3Seconds="20"
+       SuplVersion="1"
+
+       LbsEnable="true"
+       LbsLocal="false"
+       LbsServer="BCMLS2.glpals.com"
+       LbsPort="7275"
+       LbsSyncLto="false"
+       SyncLto="true"
+       ltoFileName="lto2.dat"
+       acLtoDir="/data/system/gps/"
+       LbsSyncLtoThresholdDays="1"
+       LbsTAC="10101106"
+       ctrlPipe="/data/gps/glgpsctrl"
+       LbsWlanEnable="false"
+
+       IgnoreJniTime="true"
+       AssertEnabled="false"
+
+       SensorsEnable="false"
+       SensorsPowerSave="false"
+       SensorsLog="false"
+
+   />
+
+  <gll
+       LogPriMask="LOG_INFO"
+       LogFacMask="LOG_GLLIO | LOG_RAWDATA | LOG_DEVKF | LOG_GLLAPI | LOG_NMEA"
+       FrqPlan="FRQ_PLAN_26MHZ_2PPM_26MHZ_300PPB"
+       RfType="GL_RF_4752_BRCM_EXT_LNA"
+       WarmStandbyTimeout1Seconds="10"
+       WarmStandbyTimeout2Seconds="15"
+  >
+  </gll>
+
+  <gll_features
+       EnableLowPowerEls="false"
+       EnableLowPowerPmm="true"
+  />
+
+</glgps>
diff --git a/configs/nvram_mfg.txt b/configs/nvram_mfg.txt
new file mode 100644
index 0000000..efb5cad
--- /dev/null
+++ b/configs/nvram_mfg.txt
@@ -0,0 +1,146 @@
+# Kona Rev0.1 2012.10.29-TSSI
+
+manfid=0x2d0
+prodid=0x05de
+vendid=0x14e4
+devid=0x4380
+boardtype=0x05de
+boardrev=0x1205
+boardnum=22
+macaddr=00:90:4c:c5:12:38
+sromrev=3
+#boardflags: 5GHz FEM: has ext 5GHz PA + LNA
+#            2.4GHz FEM: has ext 2.4GHz PA + SP3T
+#            2.4GHz FEM: SP3T switch share with BT
+#            keep original 0x200
+boardflags=0x10081a01
+xtalfreq=37400
+nocrc=1
+ag0=0
+aa2g=1
+ccode=ALL
+pa0itssit=0x20
+#PA parameters for 2.4GHz-10/29 R01 TSSI
+pa0b0=0x141E
+pa0b1=0xFD89
+pa0b2=0xFF57
+
+tssifloor2g=30
+extpagain2g=2
+extpagain5g=2
+
+# rssi params for 2.4GHz
+rssismf2g=0xf
+rssismc2g=0x8
+rssisav2g=0x1
+# rssi params(RFMD) for 2.4GHz
+#rssismf2g=0x3
+#rssismc2g=0xa
+#rssisav2g=0x1
+
+cckPwrOffset=3
+cckdigfilttype=24
+#PwrOffset40mhz2g=-10
+# rssi params for 5GHz
+rssismf5g=0xf
+rssismc5g=0x7
+rssisav5g=0x1
+#PA parameters for lower a-band-10/29 R01 TSSI
+pa1lob0=0x1A12
+pa1lob1=0xFCE0
+pa1lob2=0xFF53
+tssifloor5gl=30
+#PA parameters for midband-10/29 R01 TSSI
+pa1b0=0x1B2F
+pa1b1=0xFCBB
+pa1b2=0xFF4E
+tssifloor5gm=30
+#PA paramasdeters for high band-10/29 R01 TSSI
+pa1hib0=0x1BDC
+pa1hib1=0xFCA3
+pa1hib2=0xFF4B
+tssifloor5gh=30
+rxpo5g=0
+maxp2ga0=72
+# 2GTxPwr Backoff
+ofdm2gpo=0x66666666
+mcs2gpo0=0x8888
+mcs2gpo1=0x8888
+maxp5ga0=62
+maxp5gla0=58
+maxp5gha0=54
+# 5GTxPwr Backoff
+ofdm5gpo=0x33333333
+ofdm5glpo=0x33333333
+ofdm5ghpo=0x33333333
+mcs5gpo0=0x4444
+mcs5gpo1=0x4444
+mcs5glpo0=0x4444
+mcs5glpo1=0x4444
+mcs5ghpo0=0x4444
+mcs5ghpo1=0x4444
+# 5GTxPwr HT40 Backoff
+mcs5gpo2=0x6666
+mcs5gpo3=0x6666
+mcs5glpo2=0x6666
+mcs5glpo3=0x6666
+mcs5ghpo2=0x6666
+mcs5ghpo3=0x6666
+# 4334B1FCBGA -16, 4334B2FCBGA 4, 4334B2WLBGA -7
+PwrOffset40mhz5g=-1
+
+#ofdmdigfilttype=3
+ofdmdigfilttype2g=3
+ofdmdigfilttype5g=3
+#ofdm40digfilttype=5 -8/21-comment out
+
+il0macaddr=00:90:4c:c5:12:38
+wl0id=0x431b
+pagc2g=0x10
+
+# Parameters for DAC2x mode and ALPF bypass
+dacrate2xen=1
+txalpfbyp=1
+txalpfpu=1
+
+#Murata 2G & 5G FEM switch control table
+swctrlmap_2g=0x00400040,0x06060606,0x02020202,0x10302,0x1ff
+swctrlmap_5g=0x08080808,0x30303030,0x10101010,0x10302,0x2f8
+
+#elna_off_gain_idx_2g=32
+#elna_off_gain_idx_5g=TBD
+gain=32
+triso2g=8
+triso5g=7
+
+muxenab=0x10
+dacpu.fab.4=1
+
+aci_detect_en_2g=1
+
+#EPA_or_PAD_lpbck5g=1
+lpbckmode5g=1
+txiqlopapu5g=0
+iqcalidx5g=50
+txiqlopapu2g=0
+dlorange_lowlimit=5
+loflag=1
+
+###iqlocalidx5g=50
+###iqlocalidx5g=70 75 80
+iqlocalidx5g=45
+
+### dlocalidx5g should be greater than iqlocalidx5g by at least 20 index steps
+###dlocalidx5g=90
+dlocalidx5g=65
+
+#gain_settle_dly_2g=4
+gain_settle_dly_5g=4
+#noise_cal_po_2g=-1
+#noise_cal_po_40_2g=-1
+#noise_cal_high_gain_2g=73
+#noise_cal_nf_substract_val_2g=346
+noise_cal_po_5g=-1
+noise_cal_po_40_5g=-1
+noise_cal_high_gain_5g=73
+noise_cal_nf_substract_val_5g=346
diff --git a/configs/nvram_mfg.txt_murata b/configs/nvram_mfg.txt_murata
new file mode 100644
index 0000000..a5e7448
--- /dev/null
+++ b/configs/nvram_mfg.txt_murata
@@ -0,0 +1,145 @@
+# Kona Emual Rev0.3 2012.08.21-TSSI

+

+manfid=0x2d0

+prodid=0x05de

+vendid=0x14e4

+devid=0x4380

+boardtype=0x05de

+boardrev=0x1205

+boardnum=22

+macaddr=00:90:4c:c5:12:38

+sromrev=3

+#boardflags: 5GHz FEM: has ext 5GHz PA + LNA

+#            2.4GHz FEM: has ext 2.4GHz PA + SP3T

+#            2.4GHz FEM: SP3T switch share with BT

+#            keep original 0x200

+boardflags=0x10081a01

+xtalfreq=37400

+nocrc=1

+ag0=0

+aa2g=1

+ccode=ALL

+pa0itssit=0x20

+#PA parameters for 2.4GHz-8/21 TSSI

+pa0b0=0x14B6

+pa0b1=0xFD8C

+pa0b2=0xFF5E

+

+tssifloor2g=30

+extpagain2g=2

+extpagain5g=2

+

+# rssi params for 2.4GHz

+rssismf2g=0xf

+rssismc2g=0x8

+rssisav2g=0x1

+# rssi params(RFMD) for 2.4GHz

+#rssismf2g=0x3

+#rssismc2g=0xa

+#rssisav2g=0x1

+

+cckPwrOffset=3

+cckdigfilttype=24

+#PwrOffset40mhz2g=-10

+# rssi params for 5GHz

+rssismf5g=0xf

+rssismc5g=0x7

+rssisav5g=0x1

+#PA parameters for lower a-band-8/21 TSSI

+pa1lob0=0x1AF2

+pa1lob1=0xFCC8

+pa1lob2=0xFF52

+tssifloor5gl=30

+#PA parameters for midband-8/21 TSSI

+pa1b0=0x1AA0

+pa1b1=0xFCC9

+pa1b2=0xFF45

+tssifloor5gm=30

+#PA paramasdeters for high band-8/21 TSSI

+pa1hib0=0x1D27

+pa1hib1=0xFC8E

+pa1hib2=0xFF59

+tssifloor5gh=30

+rxpo5g=0

+maxp2ga0=72

+# 2GTxPwr Backoff

+ofdm2gpo=0x66666666

+mcs2gpo0=0x8888

+mcs2gpo1=0x8888

+maxp5ga0=66

+maxp5gla0=66

+maxp5gha0=66

+# 5GTxPwr Backoff

+ofdm5gpo=0x33333333

+ofdm5glpo=0x33333333

+ofdm5ghpo=0x33333333

+mcs5gpo0=0x4444

+mcs5gpo1=0x4444

+mcs5glpo0=0x4444

+mcs5glpo1=0x4444

+mcs5ghpo0=0x4444

+mcs5ghpo1=0x4444

+# 5GTxPwr HT40 Backoff

+mcs5gpo2=0x6666

+mcs5gpo3=0x6666

+mcs5glpo2=0x6666

+mcs5glpo3=0x6666

+mcs5ghpo2=0x6666

+mcs5ghpo3=0x6666

+# 4334B1FCBGA -16, 4334B2FCBGA 4, 4334B2WLBGA -7

+PwrOffset40mhz5g=-7

+

+#ofdmdigfilttype=3

+ofdmdigfilttype2g=3

+ofdmdigfilttype5g=3

+#ofdm40digfilttype=5 -8/21-comment out

+

+il0macaddr=00:90:4c:c5:12:38

+wl0id=0x431b

+pagc2g=0x10

+

+# Parameters for DAC2x mode and ALPF bypass

+dacrate2xen=1

+txalpfbyp=1

+txalpfpu=1

+

+#Murata 2G & 5G FEM switch control table

+swctrlmap_2g=0x00400040,0x06060606,0x02020202,0x10302,0x1ff

+swctrlmap_5g=0x08080808,0x30303030,0x10101010,0x10302,0x2f8

+

+elna_off_gain_idx_2g=32

+#elna_off_gain_idx_5g=TBD

+triso2g=8

+triso5g=7

+

+muxenab=0x10

+dacpu.fab.4=1

+

+aci_detect_en_2g=1

+

+#EPA_or_PAD_lpbck5g=1

+lpbckmode5g=1

+txiqlopapu5g=0

+iqcalidx5g=50

+txiqlopapu2g=0

+dlorange_lowlimit=5

+loflag=1

+

+###iqlocalidx5g=50

+###iqlocalidx5g=70 75 80

+iqlocalidx5g=45

+

+### dlocalidx5g should be greater than iqlocalidx5g by at least 20 index steps

+###dlocalidx5g=90

+dlocalidx5g=65

+

+gain_settle_dly_2g=4

+gain_settle_dly_5g=4

+noise_cal_po_2g=-1

+noise_cal_po_40_2g=-1

+noise_cal_high_gain_2g=73

+noise_cal_nf_substract_val_2g=346

+noise_cal_po_5g=-1

+noise_cal_po_40_5g=-1

+noise_cal_high_gain_5g=73

+noise_cal_nf_substract_val_5g=346

diff --git a/configs/nvram_net.txt b/configs/nvram_net.txt
new file mode 100644
index 0000000..e35db20
--- /dev/null
+++ b/configs/nvram_net.txt
@@ -0,0 +1,152 @@
+# Kona Rev0.1 2012.10.29-TSSI
+
+manfid=0x2d0
+prodid=0x05de
+vendid=0x14e4
+devid=0x4380
+boardtype=0x05de
+boardrev=0x1205
+boardnum=22
+macaddr=00:90:4c:c5:12:38
+sromrev=3
+#boardflags: 5GHz FEM: has ext 5GHz PA + LNA
+#            2.4GHz FEM: has ext 2.4GHz PA + SP3T
+#            2.4GHz FEM: SP3T switch share with BT
+#            keep original 0x200
+boardflags=0x10081a01
+xtalfreq=37400
+nocrc=1
+ag0=0
+aa2g=1
+ccode=GB
+pa0itssit=0x20
+#PA parameters for 2.4GHz-10/29 R01 TSSI
+pa0b0=0x141E
+pa0b1=0xFD89
+pa0b2=0xFF57
+
+tssifloor2g=30
+extpagain2g=2
+extpagain5g=2
+
+# rssi params for 2.4GHz
+rssismf2g=0xf
+rssismc2g=0x8
+rssisav2g=0x1
+# rssi params(RFMD) for 2.4GHz
+#rssismf2g=0x3
+#rssismc2g=0xa
+#rssisav2g=0x1
+
+cckPwrOffset=3
+cckdigfilttype=24
+#PwrOffset40mhz2g=-10
+# rssi params for 5GHz
+rssismf5g=0xf
+rssismc5g=0x7
+rssisav5g=0x1
+#PA parameters for lower a-band-10/29 R01 TSSI
+pa1lob0=0x1A12
+pa1lob1=0xFCE0
+pa1lob2=0xFF53
+tssifloor5gl=30
+#PA parameters for midband-10/29 R01 TSSI
+pa1b0=0x1B2F
+pa1b1=0xFCBB
+pa1b2=0xFF4E
+tssifloor5gm=30
+#PA paramasdeters for high band-10/29 R01 TSSI
+pa1hib0=0x1BDC
+pa1hib1=0xFCA3
+pa1hib2=0xFF4B
+tssifloor5gh=30
+rxpo5g=0
+maxp2ga0=72
+# 2GTxPwr Backoff
+ofdm2gpo=0x66666666
+mcs2gpo0=0x8888
+mcs2gpo1=0x8888
+maxp5ga0=62
+maxp5gla0=58
+maxp5gha0=54
+# 5GTxPwr Backoff
+ofdm5gpo=0x33333333
+ofdm5glpo=0x33333333
+ofdm5ghpo=0x33333333
+mcs5gpo0=0x4444
+mcs5gpo1=0x4444
+mcs5glpo0=0x4444
+mcs5glpo1=0x4444
+mcs5ghpo0=0x4444
+mcs5ghpo1=0x4444
+# 5GTxPwr HT40 Backoff
+mcs5gpo2=0x6666
+mcs5gpo3=0x6666
+mcs5glpo2=0x6666
+mcs5glpo3=0x6666
+mcs5ghpo2=0x6666
+mcs5ghpo3=0x6666
+# 4334B1FCBGA -16, 4334B2FCBGA 4, 4334B2WLBGA -7
+PwrOffset40mhz5g=-1
+
+#ofdmdigfilttype=3
+ofdmdigfilttype2g=3
+ofdmdigfilttype5g=3
+#ofdm40digfilttype=5 -8/21-comment out
+
+il0macaddr=00:90:4c:c5:12:38
+wl0id=0x431b
+pagc2g=0x10
+
+# Parameters for DAC2x mode and ALPF bypass
+dacrate2xen=1
+txalpfbyp=1
+txalpfpu=1
+
+#Murata 2G & 5G FEM switch control table
+swctrlmap_2g=0x00400040,0x06060606,0x02020202,0x10302,0x1ff
+swctrlmap_5g=0x08080808,0x30303030,0x10101010,0x10302,0x2f8
+
+#elna_off_gain_idx_2g=32
+#elna_off_gain_idx_5g=TBD
+gain=32
+triso2g=8
+triso5g=7
+
+muxenab=0x10
+dacpu.fab.4=1
+
+aci_detect_en_2g=1
+
+#EPA_or_PAD_lpbck5g=1
+lpbckmode5g=1
+txiqlopapu5g=0
+iqcalidx5g=50
+txiqlopapu2g=0
+dlorange_lowlimit=5
+loflag=1
+
+###iqlocalidx5g=50
+###iqlocalidx5g=70 75 80
+iqlocalidx5g=45
+
+### dlocalidx5g should be greater than iqlocalidx5g by at least 20 index steps
+###dlocalidx5g=90
+dlocalidx5g=65
+
+#gain_settle_dly_2g=4
+gain_settle_dly_5g=4
+#noise_cal_po_2g=-1
+#noise_cal_po_40_2g=-1
+#noise_cal_high_gain_2g=73
+#noise_cal_nf_substract_val_2g=346
+noise_cal_po_5g=-1
+noise_cal_po_40_5g=-1
+noise_cal_high_gain_5g=73
+noise_cal_nf_substract_val_5g=346
+
+# BT / WIFI coex parameter 
+
+btc_params80=0
+btc_params6=10
+btc_params95=53
\ No newline at end of file
diff --git a/configs/nvram_net.txt_murata b/configs/nvram_net.txt_murata
new file mode 100644
index 0000000..e8ecdad
--- /dev/null
+++ b/configs/nvram_net.txt_murata
@@ -0,0 +1,156 @@
+# Kona Emual Rev0.3 2012.08.21-TSSI
+
+manfid=0x2d0
+prodid=0x05de
+vendid=0x14e4
+devid=0x4380
+boardtype=0x05de
+boardrev=0x1205
+boardnum=22
+macaddr=00:90:4c:c5:12:38
+sromrev=3
+#boardflags: 5GHz FEM: has ext 5GHz PA + LNA
+#            2.4GHz FEM: has ext 2.4GHz PA + SP3T
+#            2.4GHz FEM: SP3T switch share with BT
+#            keep original 0x200
+boardflags=0x10081a01
+xtalfreq=37400
+nocrc=1
+ag0=0
+aa2g=1
+ccode=XZ
+regrev=11
+pa0itssit=0x20
+#PA parameters for 2.4GHz-8/21 TSSI
+pa0b0=0x14B6
+pa0b1=0xFD8C
+pa0b2=0xFF5E
+
+tssifloor2g=30
+extpagain2g=2
+extpagain5g=2
+
+# rssi params for 2.4GHz
+rssismf2g=0xf
+rssismc2g=0x8
+rssisav2g=0x1
+# rssi params(RFMD) for 2.4GHz
+#rssismf2g=0x3
+#rssismc2g=0xa
+#rssisav2g=0x1
+
+cckPwrOffset=3
+cckdigfilttype=24
+#PwrOffset40mhz2g=-10
+# rssi params for 5GHz
+rssismf5g=0xf
+rssismc5g=0x7
+rssisav5g=0x1
+#PA parameters for lower a-band-8/21 TSSI
+pa1lob0=0x1AF2
+pa1lob1=0xFCC8
+pa1lob2=0xFF52
+tssifloor5gl=30
+#PA parameters for midband-8/21 TSSI
+pa1b0=0x1AA0
+pa1b1=0xFCC9
+pa1b2=0xFF45
+tssifloor5gm=30
+#PA paramasdeters for high band-8/21 TSSI
+pa1hib0=0x1D27
+pa1hib1=0xFC8E
+pa1hib2=0xFF59
+tssifloor5gh=30
+rxpo5g=0
+maxp2ga0=72
+# 2GTxPwr Backoff
+ofdm2gpo=0x66666666
+mcs2gpo0=0x8888
+mcs2gpo1=0x8888
+maxp5ga0=66
+maxp5gla0=66
+maxp5gha0=66
+# 5GTxPwr Backoff
+ofdm5gpo=0x33333333
+ofdm5glpo=0x33333333
+ofdm5ghpo=0x33333333
+mcs5gpo0=0x4444
+mcs5gpo1=0x4444
+mcs5glpo0=0x4444
+mcs5glpo1=0x4444
+mcs5ghpo0=0x4444
+mcs5ghpo1=0x4444
+# 5GTxPwr HT40 Backoff
+mcs5gpo2=0x6666
+mcs5gpo3=0x6666
+mcs5glpo2=0x6666
+mcs5glpo3=0x6666
+mcs5ghpo2=0x6666
+mcs5ghpo3=0x6666
+# 4334B1FCBGA -16, 4334B2FCBGA 4, 4334B2WLBGA -7
+PwrOffset40mhz5g=-7
+
+#ofdmdigfilttype=3
+ofdmdigfilttype2g=3
+ofdmdigfilttype5g=3
+#ofdm40digfilttype=5 -8/21-comment out
+
+il0macaddr=00:90:4c:c5:12:38
+wl0id=0x431b
+pagc2g=0x10
+
+# Parameters for DAC2x mode and ALPF bypass
+dacrate2xen=1
+txalpfbyp=1
+txalpfpu=1
+
+#Murata 2G & 5G FEM switch control table
+swctrlmap_2g=0x00400040,0x06060606,0x02020202,0x10302,0x1ff
+swctrlmap_5g=0x08080808,0x30303030,0x10101010,0x10302,0x2f8
+
+elna_off_gain_idx_2g=32
+#elna_off_gain_idx_5g=TBD
+triso2g=8
+triso5g=7
+
+muxenab=0x10
+dacpu.fab.4=1
+
+aci_detect_en_2g=1
+
+#EPA_or_PAD_lpbck5g=1
+lpbckmode5g=1
+txiqlopapu5g=0
+iqcalidx5g=50
+txiqlopapu2g=0
+dlorange_lowlimit=5
+loflag=1
+
+###iqlocalidx5g=50
+###iqlocalidx5g=70 75 80
+iqlocalidx5g=45
+
+### dlocalidx5g should be greater than iqlocalidx5g by at least 20 index steps
+###dlocalidx5g=90
+dlocalidx5g=65
+
+gain_settle_dly_2g=4
+gain_settle_dly_5g=4
+noise_cal_po_2g=-1
+noise_cal_po_40_2g=-1
+noise_cal_high_gain_2g=73
+noise_cal_nf_substract_val_2g=346
+noise_cal_po_5g=-1
+noise_cal_po_40_5g=-1
+noise_cal_high_gain_5g=73
+noise_cal_nf_substract_val_5g=346
+
+# BT / WIFI coex parameter 
+
+btc_params80=0
+
+btc_params6=10
+
+btc_params95=53
+
+
diff --git a/configs/tiny_hw.xml b/configs/tiny_hw.xml
new file mode 100644
index 0000000..0fe8edf
--- /dev/null
+++ b/configs/tiny_hw.xml
@@ -0,0 +1,316 @@
+<!-- TinyHAL configuration file for Samsung Galaxy S III -->
+<tinyhal>
+<!--
+We are able to have most of our routing static so do that
+-->
+<path>
+    <!-- AIF1->DAC1 -->
+    <ctl name="DAC1 Switch" val="1"/>
+
+    <ctl name="IN1L ZC Switch" val="0"/>
+    <ctl name="IN1R ZC Switch" val="0"/>
+    <ctl name="IN2L ZC Switch" val="0"/>
+    <ctl name="IN2R ZC Switch" val="0"/>
+    <ctl name="Output ZC Switch" val="0"/>
+    <ctl name="Speaker ZC Switch" val="0"/>
+    <ctl name="Headphone ZC Switch" val="0"/>
+
+    <!-- AIF1->DAC1 -->
+    <ctl name="DAC1L Mixer AIF1.1 Switch" val="1"/>
+    <ctl name="DAC1R Mixer AIF1.1 Switch" val="1"/>
+    <ctl name="DAC1 Switch" val="1"/>
+
+    <!-- ADC->AIF2 -->
+    <ctl name="AIF2DAC2L Mixer Left Sidetone Switch" val="1"/>
+    <ctl name="AIF2DAC2L Mixer Right Sidetone Switch" val="0"/>
+    <ctl name="AIF2DAC2R Mixer Left Sidetone Switch" val="0"/>
+    <ctl name="AIF2DAC2R Mixer Right Sidetone Switch" val="1"/>
+    <ctl name="DAC2 Left Sidetone Volume" val="12"/>
+    <ctl name="DAC2 Right Sidetone Volume" val="12"/>
+    <ctl name="DAC2 Switch" val="1"/>
+
+    <!-- DAC1->HP -->
+    <ctl name="Left Headphone Mux" val="Mixer"/>
+    <ctl name="Right Headphone Mux" val="Mixer"/>
+
+    <!-- DAC1->SPKL/R->SPKL/R Boost->SPK -->
+    <ctl name="SPKL DAC1 Switch" val="1"/>
+    <ctl name="SPKR DAC1 Switch" val="1"/>
+    <ctl name="SPKL Boost SPKL Switch" val="1"/>
+    <ctl name="SPKL Boost SPKR Switch" val="0"/>
+    <ctl name="SPKR Boost SPKL Switch" val="0"/>
+    <ctl name="SPKR Boost SPKR Switch" val="1"/>
+    <ctl name="Speaker Mixer Volume" val="3"/>
+
+    <!-- DAC->Output mixer->Earpiece -->
+    <ctl name="Left Output Mixer DAC Switch" val="1"/>
+    <ctl name="Right Output Mixer DAC Switch" val="1"/>
+    <ctl name="Earpiece Mixer Left Output Switch" val="1"/>
+    <ctl name="Earpiece Mixer Right Output Switch" val="1"/>
+    <ctl name="Earpiece Switch" val="1"/>
+
+    <!-- LINEOUT -->
+    <ctl name="LINEOUT2N Mixer Left Output Switch" val="1"/>
+    <ctl name="LINEOUT2P Mixer Right Output Switch" val="1"/>
+    <ctl name="LINEOUT1N Mixer Right Output Switch" val="1"/>
+    <ctl name="LINEOUT1P Mixer Left Output Switch" val="1"/>
+
+    <!-- Input mixer->ADC->AIF1.1 -->
+    <ctl name="AIF1ADC1L Mixer ADC/DMIC Switch" val="1"/>
+    <ctl name="AIF1ADC1R Mixer ADC/DMIC Switch" val="1"/>
+
+    <!-- Main Mic->IN1LP/N->Input Mixer with +30dB at mixer -->
+    <ctl name="IN1L PGA IN1LP Switch" val="1"/>
+    <ctl name="IN1L PGA IN1LN Switch" val="1"/>
+    <ctl name="MIXINL IN1L Volume" val="1"/>
+    <ctl name="IN1L Switch" val="1"/>
+
+    <!-- Sub Mic->IN1RP/N->Input Mixer with +30dB at mixer -->
+    <ctl name="IN1R PGA IN1RP Switch" val="1"/>
+    <ctl name="IN1R PGA IN1RN Switch" val="1"/>
+    <ctl name="MIXINR IN1R Volume" val="1"/>
+    <ctl name="IN1R Switch" val="1"/>
+
+    <!-- FM Radio->IN2RP/N->Input Mixer with +30dB at mixer -->
+    <ctl name="IN2R PGA IN2RP Switch" val="1"/>
+    <ctl name="IN2R PGA IN2RN Switch" val="1"/>
+    <ctl name="MIXINR IN2R Volume" val="1"/>
+    <ctl name="IN2R Switch" val="1"/>
+
+    <!-- Ear Mic->IN2LP/N->Input Mixer with +30dB at mixer -->
+    <ctl name="IN2L PGA IN2LP Switch" val="1"/>
+    <ctl name="IN2L PGA IN2LN Switch" val="1"/>
+    <ctl name="MIXINL IN2L Volume" val="1"/>
+    <ctl name="IN2L Switch" val="1"/>
+
+    <!-- Input mixer->ADC->AIF1 -->
+    <ctl name="AIF1ADC1L Mixer ADC/DMIC Switch" val="1"/>
+    <ctl name="AIF1ADC1R Mixer ADC/DMIC Switch" val="1"/>
+    <ctl name="ADCL Mux" val="ADC"/>
+
+    <!-- HPF on to take out some bounce -->
+    <ctl name="Sidetone HPF Switch" val="0"/>
+
+    <!-- Work around core issue -->
+    <ctl name="ADCL Mux" val="DMIC"/>
+    <ctl name="ADCL Mux" val="ADC"/>
+    <ctl name="ADCR Mux" val="DMIC"/>
+    <ctl name="ADCR Mux" val="ADC"/>
+
+    <!-- AIF2ADCDAT to AIF3ADC mux -->
+    <ctl name="AIF3ADC Mux" val="1"/>
+
+    <!-- Default all outputs off -->
+    <ctl name="HP Switch" val="0"/>
+    <ctl name="SPK Switch" val="0"/>
+    <ctl name="RCV Switch" val="0"/>
+    <ctl name="LINE Switch" val="0"/>
+    <ctl name="HDMI Switch" val="1"/>
+
+    <!-- Default all inputs off -->
+    <ctl name="Main Mic Switch" val="0"/>
+    <ctl name="Sub Mic Switch" val="0"/>
+    <ctl name="Headset Mic Switch" val="0"/>
+    <ctl name="FM In Switch" val="0"/>
+
+</path>
+<device name="speaker">
+    <path name="on">
+        <ctl name="SPK Switch" val="1"/>
+        <ctl name="AIF1DAC1 Volume" val="96"/>
+        <ctl name="AIF1 Boost Volume" val="0"/>
+        <ctl name="DAC1 Volume" val="96"/>
+        <ctl name="SPKL DAC1 Volume" val="1"/>
+        <ctl name="SPKR DAC1 Volume" val="1"/>
+        <ctl name="Speaker Mixer Volume" val="3"/>
+        <ctl name="Speaker Boost Volume" val="5"/>
+        <ctl name="Speaker Volume" val="60"/>
+    </path>
+    <path name="off">
+        <ctl name="SPK Switch" val="0"/>
+        <ctl name="AIF1DAC1 Volume" val="96"/>
+        <ctl name="AIF1 Boost Volume" val="0"/>
+        <ctl name="DAC1 Volume" val="96"/>
+        <ctl name="SPKL DAC1 Volume" val="1"/>
+        <ctl name="SPKR DAC1 Volume" val="1"/>
+        <ctl name="Speaker Mixer Volume" val="0"/>
+        <ctl name="Speaker Volume" val="57"/>
+        <ctl name="Speaker Boost Volume" val="0"/>
+    </path>
+</device>
+<device name="headphone">
+    <path name="on">
+        <ctl name="HP Switch" val="1"/>
+        <ctl name="Headphone Volume" val="50"/>
+        <ctl name="Headphone ZC Switch" val="0"/>
+        <ctl name="AIF1DAC1 Volume" val="96"/>
+        <ctl name="AIF1 Boost Volume" val="0"/>
+        <ctl name="DAC1 Volume" val="96"/>
+    </path>
+    <path name="off">
+        <ctl name="HP Switch" val="0"/>
+        <ctl name="Headphone ZC Switch" val="0"/>
+        <ctl name="AIF1DAC1 Volume" val="96"/>
+        <ctl name="AIF1 Boost Volume" val="0"/>
+        <ctl name="DAC1 Volume" val="96"/>
+	<ctl name="Headphone Volume" val="45"/>
+    </path>
+</device>
+<device name="sco-out">
+    <path name="on">
+        <ctl name="AIF3ADC Mux" val="1"/>
+        <ctl name="AIF2DAC2L Mixer AIF1.1 Switch" val="1"/>
+        <ctl name="AIF2DAC2R Mixer AIF1.1 Switch" val="1"/>
+        <ctl name="AIF1 Boost Volume" val="0"/>
+        <ctl name="AIF2DAC Volume" val="96"/>
+        <ctl name="DAC2 Volume" val="96"/>
+        <ctl name="AIF1DAC1 Volume" val="96"/>
+    </path>
+    <path name="off">
+        <ctl name="AIF2DAC2L Mixer AIF1.1 Switch" val="0"/>
+        <ctl name="AIF2DAC2R Mixer AIF1.1 Switch" val="0"/>
+        <ctl name="AIF1DAC1 Volume" val="96"/>
+        <ctl name="AIF1 Boost Volume" val="0"/>
+        <ctl name="DAC2 Volume" val="96"/>
+        <ctl name="AIF2DAC Volume" val="96"/>
+    </path>
+</device>
+<device name="analog-dock">
+    <path name="on">
+        <ctl name="LINEOUT2N Switch" val="1"/>
+        <ctl name="LINEOUT2P Switch" val="1"/>
+        <ctl name="LINEOUT2N Mixer Left Output Switch" val="1"/>
+        <ctl name="LINEOUT2P Mixer Right Output Switch" val="1"/>
+        <ctl name="LINE Switch" val="1"/>
+        <ctl name="AIF1DAC1 Volume" val="96"/>
+        <ctl name="AIF1 Boost Volume" val="0"/>
+        <ctl name="DAC1 Volume" val="96"/>
+        <ctl name="Left Output Mixer DAC Volume" val="7"/>
+        <ctl name="Right Output Mixer DAC Volume" val="7"/>
+        <ctl name="Output Volume" val="55"/>
+        <ctl name="LINEOUT2 Volume" val="1"/>
+    </path>
+    <path name="off">
+        <ctl name="LINEOUT2N Switch" val="0"/>
+        <ctl name="LINEOUT2P Switch" val="0"/>
+        <ctl name="LINE Switch" val="0"/>
+        <ctl name="AIF1DAC1 Volume" val="96"/>
+        <ctl name="AIF1 Boost Volume" val="0"/>
+        <ctl name="DAC1 Volume" val="96"/>
+        <ctl name="Left Output Mixer DAC Volume" val="7"/>
+        <ctl name="Right Output Mixer DAC Volume" val="7"/>
+        <ctl name="Output Volume" val="57"/>
+        <ctl name="LINEOUT2 Volume" val="1"/>
+    </path>
+</device>
+<device name="digital-dock">
+    <path name="on">
+        <ctl name="LINEOUT1N Switch" val="1"/>
+        <ctl name="LINEOUT1P Switch" val="1"/>
+        <ctl name="HDMI Switch" val="1"/>
+        <ctl name="AIF1DAC1 Volume" val="96"/>
+    </path>
+    <path name="off">
+        <ctl name="LINEOUT1N Switch" val="1"/>
+        <ctl name="LINEOUT1P Switch" val="1"/>
+        <ctl name="HDMI Switch" val="1"/>
+        <ctl name="AIF1DAC1 Volume" val="96"/>
+        <ctl name="AIF1 Boost Volume" val="0"/>
+        <ctl name="DAC1 Volume" val="96"/>
+        <ctl name="SPKL DAC1 Volume" val="1"/>
+        <ctl name="SPKR DAC1 Volume" val="1"/>
+        <ctl name="Speaker Mixer Volume" val="0"/>
+        <ctl name="Speaker Boost Volume" val="0"/>
+    </path>
+</device>
+<device name="builtin-mic">
+    <path name="on">
+        <ctl name="Sub Mic Switch" val="1"/>
+        <ctl name="AIF1ADCL Source" val="1"/>
+        <ctl name="IN2R Volume" val="28"/>
+        <ctl name="AIF1ADCR Source" val="1"/>
+        <ctl name="AIF1ADC1 HPF Mode" val="1"/>
+        <ctl name="MIXINR IN2R Volume" val="0"/>
+        <ctl name="MIXINR IN2R Switch" val="1"/>
+        <ctl name="AIF1ADC1 Volume" val="96"/>
+    </path>
+    <path name="off">
+        <ctl name="Sub Mic Switch" val="0"/>
+        <ctl name="MIXINR IN2R Switch" val="0"/>
+        <ctl name="AIF1ADC1 HPF Switch" val="0"/>
+        <ctl name="AIF1ADC1 HPF Mode" val="0"/>
+        <ctl name="AIF1ADC1 Volume" val="96"/>
+        <ctl name="MIXINR IN2R Volume" val="0"/>
+        <ctl name="IN2R Volume" val="11"/>
+    </path>
+</device>
+<device name="back-mic">
+    <path name="on">
+        <ctl name="Sub Mic Switch" val="1"/>
+        <ctl name="IN1R Volume" val="22"/>
+        <ctl name="MIXINR IN1R Switch" val="1"/>
+        <ctl name="MIXINR IN1R Volume" val="1"/>
+        <ctl name="AIF1ADCR Source" val="1"/>
+        <ctl name="AIF2ADCR Source" val="1"/>
+        <ctl name="AIF1ADC1 HPF Mode" val="1"/>
+        <ctl name="AIF1ADC1 HPF Switch" val="1"/>
+        <ctl name="AIF1ADC1 Volume" val="96"/>
+    </path>
+    <path name="off">
+        <ctl name="Sub Mic Switch" val="0"/>
+        <ctl name="MIXINR IN1R Switch" val="0"/>
+        <ctl name="IN1R Volume" val="10"/>
+    </path>
+</device>
+<device name="headset-in">
+    <path name="on">
+        <ctl name="Headset Mic Switch" val="1"/>
+        <ctl name="AIF1ADC1 Volume" val="96"/>
+        <ctl name="AIF1ADCL Source" val="1"/>
+        <ctl name="AIF1ADCR Source" val="1"/>
+        <ctl name="AIF1ADC1 HPF Mode" val="1"/>
+        <ctl name="AIF1ADC1 HPF Switch" val="1"/>
+        <ctl name="IN1R Volume" val="28"/>
+        <ctl name="MIXINR IN1R Volume" val="0"/>
+    </path>
+    <path name="off">
+        <ctl name="Headset Mic Switch" val="0"/>
+        <ctl name="MIXINR IN1R Switch" val="0"/>
+        <ctl name="AIF1ADC1 HPF Mode" val="0"/>
+        <ctl name="AIF1ADC1 HPF Switch" val="0"/>
+        <ctl name="IN1R Volume" val="11"/>
+        <ctl name="AIF1ADC1 HPF Switch" val="0"/>
+        <ctl name="AIF1ADC1 Volume" val="96"/>
+    </path>
+</device>
+<device name="sco-in">
+    <path name="on">
+        <ctl name="AIF2ADC Mux" val="1"/>
+        <ctl name="AIF1ADCL Source" val="0"/>
+        <ctl name="AIF1ADCR Source" val="1"/>
+        <ctl name="AIF2ADCL Source" val="0"/>
+        <ctl name="AIF2ADCR Source" val="1"/>
+        <ctl name="AIF1ADC1R Mixer AIF2 Switch" val="1"/>
+        <ctl name="AIF1ADC1L Mixer AIF2 Switch" val="1"/>
+        <ctl name="AIF1ADC1 Volume" val="96"/>
+        <ctl name="AIF2DAC Volume" val="96"/>
+    </path>
+    <path name="off">
+        <ctl name="AIF2ADC Mux" val="0"/>
+        <ctl name="AIF1ADC1R Mixer AIF2 Switch" val="0"/>
+        <ctl name="AIF1ADC1L Mixer AIF2 Switch" val="0"/>
+        <ctl name="AIF1ADC1 Volume" val="96"/>
+        <ctl name="AIF2DAC Volume" val="96"/>
+    </path>
+</device>
+<device name="fmradio">
+    <path name="on">
+        <ctl name="DAC1L Mixer AIF1.1 Switch" val="1"/>
+        <ctl name="DAC1L Mixer AIF1.1 Switch" val="1"/>
+    </path>
+    <path name="off">
+        <ctl name="MIXINL Output Record Volume" val="0"/>
+        <ctl name="MIXINR Output Record Volume" val="0"/>
+    </path>
+</device>
+</tinyhal>
diff --git a/extract-files.sh b/extract-files.sh
new file mode 100755
index 0000000..768f8d8
--- /dev/null
+++ b/extract-files.sh
@@ -0,0 +1,105 @@
+#!/bin/sh
+
+# Copyright (C) 2013 The CyanogenMod 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.
+
+# This file is generated by device/common/generate-blob-scripts.sh - DO NOT EDIT
+
+VENDOR=samsung
+DEVICE=i925
+
+mkdir -p ../../../vendor/$VENDOR/$DEVICE/proprietary
+
+adb root
+adb wait-for-device
+
+echo "Pulling proprietary files..."
+for FILE in `cat ../$DEVICE/proprietary-files.txt | grep -v ^# | grep -v ^$`; do
+    DIR=`dirname $FILE`
+    if [ ! -d ../../../vendor/$VENDOR/$DEVICE/proprietary/$DIR ]; then
+        mkdir -p ../../../vendor/$VENDOR/$DEVICE/proprietary/$DIR
+    fi
+    adb pull /$FILE ../../../vendor/$VENDOR/$DEVICE/proprietary/$FILE
+done
+
+
+(cat << EOF) | sed s/__DEVICE__/$DEVICE/g | sed s/__VENDOR__/$VENDOR/g > ../../../vendor/$VENDOR/$DEVICE/$DEVICE-vendor-blobs.mk
+# Copyright (C) 2013 The CyanogenMod 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.
+
+LOCAL_PATH := vendor/__VENDOR__/__DEVICE__
+
+PRODUCT_COPY_FILES += \\
+EOF
+
+LINEEND=" \\"
+COUNT=`cat proprietary-files.txt | grep -v ^# | grep -v ^$ | wc -l | awk {'print $1'}`
+for FILE in `cat proprietary-files.txt | grep -v ^# | grep -v ^$`; do
+    COUNT=`expr $COUNT - 1`
+    if [ $COUNT = "0" ]; then
+        LINEEND=""
+    fi
+    echo "    \$(LOCAL_PATH)/proprietary/$FILE:$FILE$LINEEND" >> ../../../vendor/$VENDOR/$DEVICE/$DEVICE-vendor-blobs.mk
+done
+
+(cat << EOF) | sed s/__DEVICE__/$DEVICE/g | sed s/__VENDOR__/$VENDOR/g > ../../../vendor/$VENDOR/$DEVICE/$DEVICE-vendor.mk
+# Copyright (C) 2013 The CyanogenMod 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.
+
+# Pick up overlay for features that depend on non-open-source files
+DEVICE_PACKAGE_OVERLAYS += vendor/__VENDOR__/__DEVICE__/overlay
+
+\$(call inherit-product, vendor/__VENDOR__/__DEVICE__/__DEVICE__-vendor-blobs.mk)
+EOF
+
+(cat << EOF) | sed s/__DEVICE__/$DEVICE/g | sed s/__VENDOR__/$VENDOR/g > ../../../vendor/$VENDOR/$DEVICE/BoardConfigVendor.mk
+# Copyright (C) 2013 The CyanogenMod 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.
+
+EOF
+
+./../../../device/samsung/p4notelte-common/extract-files.sh
diff --git a/full_n5110.mk b/full_n5110.mk
new file mode 100644
index 0000000..d3fbc49
--- /dev/null
+++ b/full_n5110.mk
@@ -0,0 +1,35 @@
+# Copyright (C) 2012 The CyanogenMod 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.
+
+#
+# This file is the build configuration for a full Android
+# build for toro hardware. This cleanly combines a set of
+# device-specific aspects (drivers) with a device-agnostic
+# product configuration (apps). Except for a few implementation
+# details, it only fundamentally contains two inherit-product
+# lines, full and toro, hence its name.
+#
+
+# Inherit from those products. Most specific first.
+$(call inherit-product, $(SRC_TARGET_DIR)/product/full_base.mk)
+# This is where we'd set a backup provider if we had one
+#$(call inherit-product, device/sample/products/backup_overlay.mk)
+$(call inherit-product, device/samsung/n5110/n5110.mk)
+
+# Discard inherited values and use our own instead.
+PRODUCT_NAME := full_n5110
+PRODUCT_DEVICE := n5110
+PRODUCT_BRAND := samsung
+PRODUCT_MANUFACTURER := samsung
+PRODUCT_MODEL := GT-N5110
diff --git a/n5110.mk b/n5110.mk
new file mode 100644
index 0000000..68ca0b1
--- /dev/null
+++ b/n5110.mk
@@ -0,0 +1,70 @@
+#
+# Copyright (C) 2012 The CyanogenMod 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.
+#
+
+LOCAL_PATH := device/samsung/n5110
+
+DEVICE_PACKAGE_OVERLAYS += $(LOCAL_PATH)/overlay
+
+PRODUCT_AAPT_CONFIG := xlarge mdpi
+PRODUCT_AAPT_PREF_CONFIG := mdpi
+
+TARGET_SCREEN_HEIGHT := 1280
+TARGET_SCREEN_WIDTH := 800
+
+# Init files
+PRODUCT_COPY_FILES += \
+    $(LOCAL_PATH)/rootdir/init.smdk4x12.rc:root/init.smdk4x12.rc \
+    $(LOCAL_PATH)/rootdir/init.smdk4x12.usb.rc:root/init.smdk4x12.usb.rc \
+    $(LOCAL_PATH)/rootdir/ueventd.smdk4x12.rc:root/ueventd.smdk4x12.rc \
+    $(LOCAL_PATH)/rootdir/ueventd.smdk4x12.rc:recovery/root/ueventd.smdk4x12.rc \
+    $(LOCAL_PATH)/rootdir/lpm.rc:root/lpm.rc \
+    $(LOCAL_PATH)/rootdir/fstab.smdk4x12:root/fstab.smdk4x12
+
+# Packages
+PRODUCT_PACKAGES += \
+    tiny_hw \
+    libsecril-client \
+    DeviceSettings \
+    SamsungServiceMode
+
+PRODUCT_COPY_FILES += \
+    $(LOCAL_PATH)/configs/gps.xml:system/etc/gps.xml \
+    $(LOCAL_PATH)/configs/nvram_mfg.txt:system/etc/wifi/nvram_mfg.txt \
+    $(LOCAL_PATH)/configs/nvram_mfg.txt_murata:system/etc/wifi/nvram_mfg.txt_murata \
+    $(LOCAL_PATH)/configs/nvram_net.txt:system/etc/wifi/nvram_net.txt \
+    $(LOCAL_PATH)/configs/nvram_net.txt_murata:system/etc/wifi/nvram_net.txt_murata
+
+# RIL
+PRODUCT_PROPERTY_OVERRIDES += \
+    mobiledata.interfaces=wlan0
+
+# Charger
+PRODUCT_PACKAGES += \
+    charger \
+    charger_res_images
+
+# These are the hardware-specific features
+PRODUCT_COPY_FILES += \
+    frameworks/native/data/etc/tablet_core_hardware.xml:system/etc/permissions/tablet_core_hardware.xml
+    
+# Set product characteristic to tablet, needed for some ui elements
+PRODUCT_CHARACTERISTICS := tablet
+
+$(call inherit-product, frameworks/native/build/tablet-10in-xhdpi-2048-dalvik-heap.mk)
+
+$(call inherit-product, device/samsung/smdk4412-common/common.mk)
+
+$(call inherit-product-if-exists, vendor/samsung/n5110/n5110-vendor.mk)
\ No newline at end of file
diff --git a/overlay/device/samsung/smdk4412-common/DeviceSettings/res/values/config.xml b/overlay/device/samsung/smdk4412-common/DeviceSettings/res/values/config.xml
new file mode 100644
index 0000000..1da977a
--- /dev/null
+++ b/overlay/device/samsung/smdk4412-common/DeviceSettings/res/values/config.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2013 The CyanogenMod 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.
+-->
+
+<!-- These resources are around just to allow their values to be customized
+     for different hardware and product builds. -->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+
+    <!-- HSPA -->
+    <bool name="has_hspa">false</bool>
+  
+    <!-- Audio Tuning -->
+    <bool name="has_incall_audio_tuning">false</bool>
+    <bool name="has_output_audio_tuning">true</bool>
+
+</resources>
diff --git a/overlay/frameworks/base/core/res/res/values/config.xml b/overlay/frameworks/base/core/res/res/values/config.xml
new file mode 100644
index 0000000..76d54b9
--- /dev/null
+++ b/overlay/frameworks/base/core/res/res/values/config.xml
@@ -0,0 +1,92 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+/*
+** Copyright 2011, 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.
+*/
+-->
+
+<!-- These resources are around just to allow their values to be customized
+     for different hardware and product builds. -->
+<resources>
+    <!-- Allow the menu hard key to be disabled in LockScreen on some devices -->
+    <bool name="config_disableMenuKeyInLockScreen">true</bool>
+
+    <!-- Workaround for devices with broken keyboards -->
+    <bool name="config_forceDisableHardwareKeyboard">true</bool>
+
+    <!-- Boolean to enable stylus gestures -->
+    <bool name="config_stylusGestures">true</bool>
+    
+   <bool name="config_allowAllRotations">true</bool>
+   <integer name="config_lidOpenRotation">-1</integer>
+   <integer name="config_deskDockKeepsScreenOn">0</integer>
+   <integer name="config_lidNavigationAccessibility">1</integer>
+   
+
+    <!-- This device is not "voice capable"; it's data-only. -->
+    <bool name="config_voice_capable">false</bool>
+
+    <!-- This device does allow sms service. -->
+    <bool name="config_sms_capable">false</bool>
+
+    <!-- The default iface on which to monitor data use -->
+    <string name="config_datause_iface">wlan0</string>
+
+    <!-- An Array of "[Connection name],[ConnectivityManager.TYPE_xxxx],
+         [associated radio-type],[priority],[restoral-timer(ms)],[dependencyMet]  -->
+    <!-- the 5th element "resore-time" indicates the number of milliseconds to delay
+         before automatically restore the default connection.  Set -1 if the connection
+         does not require auto-restore. -->
+    <!-- the 6th element indicates boot-time dependency-met value. -->
+    <string-array name="networkAttributes">
+        <item>wifi,1,1,1,-1,true</item>
+        <item>bluetooth,7,7,2,-1,true</item>
+        <item>wifi_p2p,13,1,0,-1,true</item>
+    </string-array>
+
+    <!-- An Array of "[ConnectivityManager connectionType],
+         [# simultaneous connection types]"  -->
+    <string-array name="radioAttributes">
+        <item>1,1</item>
+        <item>0,1</item>
+        <item>7,1</item>
+    </string-array>
+
+    <!-- List of regexpressions describing the interface (if any) that represent tetherable
+         USB interfaces.  If the device doesn't want to support tething over USB this should
+         be empty.  An example would be "usb.*" -->
+    <string-array translatable="false" name="config_tether_usb_regexs">
+        <item>"rndis0"</item>
+    </string-array>
+	
+    <integer-array name="config_data_usage_network_types">
+        <item>0</item>
+        <item>2</item>
+        <item>3</item>
+        <item>4</item>
+        <item>5</item>
+        <item>10</item>
+        <item>11</item>
+        <item>12</item>
+    </integer-array>
+
+    <!-- Array of ConnectivityManager.TYPE_xxxx values allowable for tethering -->
+    <!-- Common options are [1, 4] for TYPE_WIFI and TYPE_MOBILE_DUN or
+    <!== [0,1,5,7] for TYPE_MOBILE, TYPE_WIFI, TYPE_MOBILE_HIPRI and TYPE_BLUETOOTH -->
+    <integer-array name="config_tether_upstream_types">
+        <item>1</item>
+        <item>7</item>
+    </integer-array>
+</resources>
diff --git a/overlay/frameworks/base/core/res/res/xml/power_profile.xml b/overlay/frameworks/base/core/res/res/xml/power_profile.xml
new file mode 100644
index 0000000..ad5f292
--- /dev/null
+++ b/overlay/frameworks/base/core/res/res/xml/power_profile.xml
@@ -0,0 +1,61 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+**
+** Copyright 2009, 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.
+*/
+-->
+
+<device name="Android">
+    <item name="none">0</item>
+    <item name="screen.on">302</item>
+    <item name="screen.full">445.8</item>
+    <item name="bluetooth.active">107.6</item>
+    <item name="bluetooth.on">0.6</item>
+    <item name="wifi.on">0.4</item>
+    <item name="wifi.active">31.0</item>
+    <item name="wifi.scan">6.5</item>
+    <item name="dsp.audio">33.5</item>
+    <item name="dsp.video">624.5</item>
+    <item name="gps.on">0.2</item>
+    <item name="radio.active">140.9</item>
+    <item name="radio.scanning">18.5</item>
+    <array name="radio.on">
+        <value>4.3</value>
+        <value>4.3</value>
+    </array>
+    <array name="cpu.speeds">
+        <value>216000</value>
+        <value>312000</value>
+        <value>456000</value>
+        <value>608000</value>
+        <value>760000</value>
+        <value>816000</value>
+        <value>912000</value>
+        <value>1000000</value>
+    </array>
+    <item name="cpu.idle">2.2</item>
+    <item name="cpu.awake">54.6</item>
+    <array name="cpu.active">
+        <value>100</value>
+        <value>107</value>
+        <value>116</value>
+        <value>123</value>
+        <value>135</value>
+        <value>138</value>
+        <value>142</value>
+        <value>148</value>
+    </array>
+    <item name="battery.capacity">4600</item>
+</device>
diff --git a/overlay/frameworks/base/core/res/res/xml/storage_list.xml b/overlay/frameworks/base/core/res/res/xml/storage_list.xml
new file mode 100644
index 0000000..30c5bd6
--- /dev/null
+++ b/overlay/frameworks/base/core/res/res/xml/storage_list.xml
@@ -0,0 +1,51 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+**
+** Copyright 2011, 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.
+*/
+-->
+
+<!-- The <device> element should contain one or more <storage> elements.
+     Exactly one of these should have the attribute primary="true".
+     This storage will be the primary external storage and should have mountPoint="/mnt/sdcard".
+     Each storage should have both a mountPoint and storageDescription attribute.
+     The following attributes are optional:
+
+        primary:    (boolean) this storage is the primary external storage
+        removable:  (boolean) this is removable storage (for example, a real SD card)
+        emulated:   (boolean) the storage is emulated via the FUSE sdcard daemon
+        mtpReserve: (integer) number of megabytes of storage MTP should reserve for free storage
+                     (used for emulated storage that is shared with system's data partition)
+
+      A storage should not have both emulated and removable set to true
+-->
+
+<StorageList xmlns:android="http://schemas.android.com/apk/res/android">
+    <storage android:mountPoint="/storage/sdcard0"
+             android:storageDescription="@string/storage_internal"
+             android:primary="true"
+             android:emulated="true"
+             android:mtpReserve="100" />
+
+    <storage android:mountPoint="/storage/sdcard1"
+             android:storageDescription="@string/storage_sd_card"
+             android:primary="false"
+             android:removable="true" />
+
+    <storage android:mountPoint="/storage/usbdisk0"
+             android:storageDescription="@string/storage_usb"
+             android:primary="false"
+             android:removable="true" />
+</StorageList>
diff --git a/overlay/packages/apps/Browser/res/values/bools.xml b/overlay/packages/apps/Browser/res/values/bools.xml
new file mode 100644
index 0000000..3218656
--- /dev/null
+++ b/overlay/packages/apps/Browser/res/values/bools.xml
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2011 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.
+-->
+<resources
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <bool name="isTablet">true</bool>
+</resources>
diff --git a/overlay/packages/apps/Camera/res/values/config.xml b/overlay/packages/apps/Camera/res/values/config.xml
new file mode 100644
index 0000000..122b4d2
--- /dev/null
+++ b/overlay/packages/apps/Camera/res/values/config.xml
@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+/*
+** Copyright 2011, The CyanogenMod 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.
+*/
+-->
+
+<resources>
+  <!-- Do not use ZSL mode -->
+  <bool name="enableZSL">false</bool>
+</resources>
diff --git a/overlay/packages/apps/Launcher2/res/values/config.xml b/overlay/packages/apps/Launcher2/res/values/config.xml
new file mode 100644
index 0000000..22a4ed5
--- /dev/null
+++ b/overlay/packages/apps/Launcher2/res/values/config.xml
@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2013 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.
+-->
+<resources>
+    <bool name="config_largeHeap">true</bool>
+</resources>
diff --git a/overlay/packages/apps/Settings/res/values/arrays.xml b/overlay/packages/apps/Settings/res/values/arrays.xml
new file mode 100644
index 0000000..3b47031
--- /dev/null
+++ b/overlay/packages/apps/Settings/res/values/arrays.xml
@@ -0,0 +1,46 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+/*
+**
+** Copyright 2011 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.
+*/
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <!-- Display settings.  The delay in inactivity before the screen is turned off. These are shown in a list dialog. -->
+    <string-array name="screen_timeout_entries">
+        <item msgid="3342301044271143016">15 seconds</item>
+        <item msgid="8881760709354815449">30 seconds</item>
+        <item msgid="7589406073232279088">1 minute</item>
+        <item msgid="7001195990902244174">2 minutes</item>
+        <item msgid="7489864775127957179">5 minutes</item>
+        <item msgid="2314124409517439288">10 minutes</item>
+    </string-array>
+
+    <!-- Do not translate. -->
+    <string-array name="screen_timeout_values" translatable="false">
+        <!-- Do not translate. -->
+        <item>15000</item>
+        <!-- Do not translate. -->
+        <item>30000</item>
+        <!-- Do not translate. -->
+        <item>60000</item>
+        <!-- Do not translate. -->
+        <item>120000</item>
+        <!-- Do not translate. -->
+        <item>300000</item>
+        <!-- Do not translate. -->
+        <item>600000</item>
+    </string-array>
+</resources>
diff --git a/overlay/packages/apps/Settings/res/values/bools.xml b/overlay/packages/apps/Settings/res/values/bools.xml
new file mode 100644
index 0000000..2ebd9dd
--- /dev/null
+++ b/overlay/packages/apps/Settings/res/values/bools.xml
@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2011 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.
+-->
+
+<resources>
+    <!-- Powercontrol widget for tablets -->
+    <bool name="has_powercontrol_widget">true</bool>
+
+    <!-- Whether or not the dock settings are to be displayed for this device when docked -->
+    <bool name="has_dock_settings">true</bool>
+</resources>
diff --git a/overlay/packages/apps/Settings/res/values/config.xml b/overlay/packages/apps/Settings/res/values/config.xml
new file mode 100644
index 0000000..a4a7315
--- /dev/null
+++ b/overlay/packages/apps/Settings/res/values/config.xml
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+     Copyright (C) 2012 The CyanogenMod 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.
+-->
+
+<resources xmlns:xliff="urnasis:names:tc:xliff:document:1.2 ">
+    <bool name="config_show_expandedDesktop">true</bool>
+</resources>
diff --git a/overlay/packages/apps/Torch/res/values/config.xml b/overlay/packages/apps/Torch/res/values/config.xml
new file mode 100644
index 0000000..d13de94
--- /dev/null
+++ b/overlay/packages/apps/Torch/res/values/config.xml
@@ -0,0 +1,36 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+/*
+** Copyright 2011, The CyanogenMod 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.
+*/
+-->
+
+<!-- These resources are around just to allow their values to be customized
+     for different hardware and product builds. -->
+<resources>
+    <!-- If there is no sysfs-based control mechanism, enable this -->
+    <bool name="useCameraInterface">false</bool>
+
+    <!-- Full path to the sysfs toggle -->
+    <string name="flashDevice">/sys/class/camera/rear/rear_flash</string>
+
+    <!-- Lowest setting -->
+    <integer name="valueOn">1</integer>
+    <!-- Middle setting -->
+    <integer name="valueHigh">-1</integer>
+    <!-- Highest setting, leave -1 if it doesn't exist -->
+    <integer name="valueDeathRay">-1</integer>
+
+</resources>
diff --git a/proprietary-files.txt b/proprietary-files.txt
new file mode 100644
index 0000000..25c0d21
--- /dev/null
+++ b/proprietary-files.txt
@@ -0,0 +1,3 @@
+system/lib/libril-qc-qmi-1.so
+system/lib/libril-qcril-hook-oem.so
+system/lib/libril.so
diff --git a/recovery.fstab b/recovery.fstab
new file mode 100644
index 0000000..d1e7503
--- /dev/null
+++ b/recovery.fstab
@@ -0,0 +1,12 @@
+# mount point	fstype		device					device2
+/efs			ext4		/dev/block/mmcblk0p3
+/boot			emmc		/dev/block/mmcblk0p5
+/recovery		emmc		/dev/block/mmcblk0p6
+/cache			ext4		/dev/block/mmcblk0p8
+/system			ext4		/dev/block/mmcblk0p9
+/data			ext4		/dev/block/mmcblk0p12	length=-16384
+/preload		ext4		/dev/block/mmcblk0p10
+/modem			emmc		/dev/block/mmcblk0p7
+
+/sdcard			datamedia   /dev/null
+/external_sd	vfat		/dev/block/mmcblk1p1 fstype2=ext4
diff --git a/res/charger/battery_0.png b/res/charger/battery_0.png
new file mode 100644
index 0000000..38b888c
--- /dev/null
+++ b/res/charger/battery_0.png
diff --git a/res/charger/battery_1.png b/res/charger/battery_1.png
new file mode 100644
index 0000000..03f4226
--- /dev/null
+++ b/res/charger/battery_1.png
diff --git a/res/charger/battery_2.png b/res/charger/battery_2.png
new file mode 100644
index 0000000..296959e
--- /dev/null
+++ b/res/charger/battery_2.png
diff --git a/res/charger/battery_3.png b/res/charger/battery_3.png
new file mode 100644
index 0000000..97a5dfd
--- /dev/null
+++ b/res/charger/battery_3.png
diff --git a/res/charger/battery_4.png b/res/charger/battery_4.png
new file mode 100644
index 0000000..63865c2
--- /dev/null
+++ b/res/charger/battery_4.png
diff --git a/res/charger/battery_5.png b/res/charger/battery_5.png
new file mode 100644
index 0000000..eec62b0
--- /dev/null
+++ b/res/charger/battery_5.png
diff --git a/res/charger/battery_charge.png b/res/charger/battery_charge.png
new file mode 100644
index 0000000..c1d2856
--- /dev/null
+++ b/res/charger/battery_charge.png
diff --git a/res/charger/battery_fail.png b/res/charger/battery_fail.png
new file mode 100644
index 0000000..9099d02
--- /dev/null
+++ b/res/charger/battery_fail.png
diff --git a/rootdir/fstab.smdk4x12 b/rootdir/fstab.smdk4x12
new file mode 100644
index 0000000..62f53ac
--- /dev/null
+++ b/rootdir/fstab.smdk4x12
@@ -0,0 +1,11 @@
+# Android fstab file.
+#<src>                  <mnt_point>         <type>    <mnt_flags and options>                               <fs_mgr_flags>
+# The filesystem that contains the filesystem checker binary (typically /system) cannot
+# specify MF_CHECK, and must come before any filesystems that do specify MF_CHECK
+# data partition must be located at the bottom for supporting device encryption
+
+/dev/block/mmcblk0p9    /system             ext4      ro,errors=panic                                                                   wait
+/dev/block/mmcblk0p3    /efs                ext4      nosuid,nodev,noatime,noauto_da_alloc,discard,journal_async_commit,errors=panic    wait,check
+/dev/block/mmcblk0p8    /cache              ext4      nosuid,nodev,noatime,noauto_da_alloc,discard,journal_async_commit,errors=panic    wait,check
+/dev/block/mmcblk0p12   /data               ext4      nosuid,nodev,noatime,noauto_da_alloc,discard,journal_async_commit,errors=panic    wait,check,encryptable=footer
+
diff --git a/rootdir/init.smdk4x12.rc b/rootdir/init.smdk4x12.rc
new file mode 100644
index 0000000..f549179
--- /dev/null
+++ b/rootdir/init.smdk4x12.rc
@@ -0,0 +1,584 @@
+import init.smdk4x12.usb.rc
+import init.bt.rc
+
+on init
+    mkdir /mnt/shell/emulated 0700 shell shell
+    mkdir /storage 0550 system sdcard_r
+    mkdir /storage/emulated 0555 root root
+    mkdir /storage/sdcard1 0775 system system
+    mkdir /storage/usbdisk0 0775 system system
+
+    export EXTERNAL_STORAGE /storage/emulated/legacy
+    export SECONDARY_STORAGE /storage/sdcard1
+    export EMULATED_STORAGE_SOURCE /mnt/shell/emulated
+    export EMULATED_STORAGE_TARGET /storage/emulated
+
+    # for backwards compatibility
+    symlink /storage/emulated/legacy /sdcard
+    symlink /storage/emulated/legacy /mnt/sdcard
+    symlink /storage/emulated/legacy /storage/sdcard0
+    symlink /mnt/shell/emulated/0 /storage/emulated/legacy
+    symlink /storage/sdcard1 /extSdCard
+    symlink /storage/sdcard1 /mnt/extSdCard
+    symlink /storage/usbdisk0 /usbdisk0
+    symlink /storage/usbdisk0 /mnt/usbdisk0
+
+    mkdir /efs 0771 radio system
+    mkdir /tombstones
+    symlink /efs /factory
+
+   
+# ko files for FM Radio
+    #insmod /system/lib/modules/Si4709_driver.ko
+
+on init
+
+    # Vibetonz
+    export VIBE_PIPE_PATH /dev/pipes
+    mkdir /dev/pipes 0771 shell shell
+
+on fs
+    mount_all /fstab.smdk4x12
+
+    setprop ro.crypto.fuse_sdcard true
+    
+    chown radio system /efs
+    chmod 0771 /efs
+
+on post-fs-data
+     # we will remap this as /mnt/sdcard with the sdcard fuse tool
+     mkdir /data/media 0775 media_rw media_rw
+     chown media_rw media_rw /data/media
+
+# for AT distributor
+    chown system radio /sys/module/cpuidle_exynos4/parameters/enable_mask
+    chmod 0664 /sys/module/cpuidle_exynos4/parameters/enable_mask
+    
+# data/log
+    mkdir /data/log 0775 system log
+    chown system log /data/log
+    chmod 0775 /data/log
+    chmod 0775 /data/anr
+
+    # create data/gps for GPS demon
+    chown root system /dev/ttySAC1
+    chmod 0660 /dev/ttySAC1
+    chown root system /sys/class/sec/gps/GPS_PWR_EN/value
+    chmod 0664 /sys/class/sec/gps/GPS_PWR_EN/value
+    chown root system /sys/class/sec/gps/GPS_nRST/value
+    chmod 0664 /sys/class/sec/gps/GPS_nRST/value
+    mkdir /data/gps 771 system system
+    chown system system /data/gps
+
+    mkdir /data/misc/radio 0775 radio system
+    chmod 0775 /data/misc/radio
+    mkdir /efs/imei 0775 radio system
+    
+    mkdir /data/local/audio 0775 media audio
+    chown media audio /data/local/audio
+
+# HDCP 2.x
+    mkdir /data/system/hdcp2 0775 system system
+
+# h2k permission
+    chmod 0644 /efs/redata.bin
+    chmod 0644 /efs/h2k.dat
+
+# Camera firmware
+    mkdir /data/cfw 0775 system system
+    chown system media /data/cfw/SlimISP_GK.bin
+    chmod 0775 /data/cfw/SlimISP_GK.bin
+    chown system media /data/cfw/SlimISP_ZK.bin
+    chmod 0775 /data/cfw/SlimISP_ZK.bin
+
+# Camera
+    chown system radio /sys/class/camera/rear/rear_camfw
+    chown system radio /sys/class/camera/rear/rear_camtype
+    chown system radio /sys/class/camera/rear/rear_flash
+    chmod 0666 /sys/class/camera/flash/rear_flash
+    chown system radio /sys/class/camera/rear/isp_core
+    chown system radio /sys/class/camera/front/front_camfw
+    chown system radio /sys/class/camera/front/front_camtype
+    chown system radio /sys/class/camera/flash/rear_flash
+    chown radio system /sys/devices/platform/samsung-pd.5/s3c-fimc.2/range_mode
+    chmod 0660 /sys/devices/platform/samsung-pd.5/s3c-fimc.2/range_mode
+
+    symlink /dev/block/mmcblk0p4 /dev/block/param
+
+# Permissions for bluetooth
+    setprop ro.bt.bdaddr_path "/efs/bluetooth/bt_addr"
+    chown bluetooth bluetooth ro.bt.bdaddr_path
+    chown bluetooth bluetooth /dev/ttySAC0
+    chmod 0600 /dev/ttySAC0
+    chmod 0660 /sys/class/rfkill/rfkill0/state
+    chown bluetooth bluetooth /sys/class/rfkill/rfkill0/state
+    chown bluetooth bluetooth /sys/class/rfkill/rfkill0/type
+
+# Vibrator
+    chmod 0660 /dev/tspdrv
+    chown root shell /dev/tspdrv
+    chmod 0660 /sys/vibrator/pwm_val
+    chown system system /sys/vibrator/pwm_val
+    
+# serial keyboard port
+	chown root system /dev/ttySAC3
+	chmod 0660 /dev/ttySAC3
+	
+# for datarouter
+    chown system system /dev/dun
+    chown system system /dev/ttyGS0
+    chown system system /dev/ttyGS1
+    chown system system /dev/ttyGS2
+    chown system system /dev/ttyGS3
+    
+# NFC
+    setprop ro.nfc.port "I2C"
+    chmod 0600 /dev/pn544
+    chown nfc nfc /dev/pn544
+
+# Permissions for LCD
+    chown system radio /sys/class/lcd/panel/lcd_type
+    chown system system /sys/class/backlight/panel/auto_brightness
+
+# Permissions for mDNIe
+    chown system media_rw /sys/class/mdnie/mdnie/mode
+    chown system media_rw /sys/class/mdnie/mdnie/outdoor
+    chown system media_rw /sys/class/mdnie/mdnie/scenario
+    chown system system /sys/class/mdnie/mdnie/negative
+    chown system system /sys/class/mdnie/mdnie/ebook
+    chown system system /sys/class/mdnie/mdnie/accessibility
+    write /sys/class/mdnie/mdnie/scenario 0
+    write /sys/class/mdnie/mdnie/mode 0
+    
+# Permissions for Touchkey
+    chown system radio /sys/class/sec/sec_touchkey/touchkey_dummy_btn1
+    chown system radio /sys/class/sec/sec_touchkey/touchkey_dummy_btn3
+    chown system radio /sys/class/sec/sec_touchkey/touchkey_dummy_btn5
+    chown system radio /sys/class/sec/sec_touchkey/extra_button_event
+    chown system radio /sys/class/sec/sec_touchkey/touchkey_button_all
+    chown system radio /sys/class/sec/sec_touchkey/touchkey_threshold
+    chmod 0660 /sys/class/sec/sec_touchkey/extra_button_event
+
+# Permissions for Hall IC
+	chown system radio /sys/class/sec/sec_key/hall_detect
+
+# Permissions for System Server and daemons.
+    chown radio system /sys/android_power/state
+    chown radio system /sys/android_power/request_state
+    chown radio system /sys/android_power/acquire_full_wake_lock
+    chown radio system /sys/android_power/acquire_partial_wake_lock
+    chown radio system /sys/android_power/release_wake_lock
+    chown radio system /sys/power/state
+    chown radio system /sys/power/wake_lock
+    chown radio system /sys/power/wake_unlock
+    chown radio system /sys/power/cpufreq_table
+    chown radio system /sys/power/cpufreq_max_limit
+    chown radio system /sys/power/cpufreq_min_limit
+    chown radio system /sys/power/mali_lock
+    chown radio system /sys/class/power_supply/battery/siop_activated
+    chown radio system /sys/devices/system/cpu/cpufreq/pegasusq/max_cpu_lock
+    chown radio system /sys/devices/system/cpu/cpufreq/pegasusq/hotplug_lock
+    chown radio system /sys/devices/system/cpu/busfreq/curr_freq
+    chown radio system /sys/module/mali/parameters/mali_dvfs_control
+    chown system radio /sys/bus/platform/devices/s5p-tmu/lot_id
+    chmod 0660 /sys/power/state
+    chmod 0660 /sys/power/wake_lock
+    chmod 0660 /sys/power/wake_unlock
+    chmod 0660 /sys/power/cpufreq_table
+    chmod 0660 /sys/power/cpufreq_max_limit
+    chmod 0660 /sys/power/cpufreq_min_limit
+    chmod 0660 /sys/power/mali_lock
+    chmod 0660 /sys/class/power_supply/battery/siop_activated
+    chmod 0660 /sys/devices/system/cpu/cpufreq/pegasusq/max_cpu_lock
+    chmod 0660 /sys/devices/system/cpu/cpufreq/pegasusq/hotplug_lock
+    chmod 0660 /sys/devices/system/cpu/busfreq/curr_freq
+    chmod 0660 /sys/module/mali/parameters/mali_dvfs_control
+    chmod 0664 /sys/bus/platform/devices/s5p-tmu/lot_id
+    chown system system /sys/class/timed_output/vibrator/enable
+    chown system system /sys/class/leds/keyboard-backlight/brightness
+    chown system system /sys/class/leds/lcd-backlight/brightness
+    chown system system /sys/class/backlight/panel/brightness
+    chown system system /sys/class/leds/button-backlight/brightness
+    chown system system /sys/class/sec/sec_touchkey/brightness
+    chown system system /sys/class/leds/jogball-backlight/brightness
+    chown system system /sys/class/leds/red/brightness
+    chown system system /sys/class/leds/green/brightness
+    chown system system /sys/class/leds/blue/brightness
+    chown system system /sys/class/leds/red/device/grpfreq
+    chown system system /sys/class/leds/red/device/grppwm
+    chown system system /sys/class/leds/red/device/blink
+    chown system system /sys/class/leds/red/brightness
+    chown system system /sys/class/leds/green/brightness
+    chown system system /sys/class/leds/blue/brightness
+    chown system system /sys/class/leds/red/device/grpfreq
+    chown system system /sys/class/leds/red/device/grppwm
+    chown system system /sys/class/leds/red/device/blink
+    chown system system /sys/class/timed_output/vibrator/enable
+    chown system system /sys/module/sco/parameters/disable_esco
+    chown system system /sys/kernel/ipv4/tcp_wmem_min
+    chown system system /sys/kernel/ipv4/tcp_wmem_def
+    chown system system /sys/kernel/ipv4/tcp_wmem_max
+    chown system system /sys/kernel/ipv4/tcp_rmem_min
+    chown system system /sys/kernel/ipv4/tcp_rmem_def
+    chown system system /sys/kernel/ipv4/tcp_rmem_max
+    chown root radio /proc/cmdline
+
+# Audio (Earjack)
+    chown system radio /sys/class/audio/earjack/select_jack
+    chown system radio /sys/class/audio/earjack/key_state
+    chown system radio /sys/class/audio/earjack/state
+    chown media system /sys/class/audio/earjack/reselect_jack
+
+# Battery node
+    chown system radio /sys/class/power_supply/battery/batt_charging_source
+    chown system radio /sys/class/power_supply/battery/batt_error_test
+    chown system radio /sys/class/power_supply/battery/batt_lp_charging
+    chown system radio /sys/class/power_supply/battery/batt_read_adj_soc
+    chown system radio /sys/class/power_supply/battery/batt_read_raw_soc
+    chown system radio /sys/class/power_supply/battery/batt_reset_soc
+    chown system radio /sys/class/power_supply/battery/batt_slate_mode
+    chown system radio /sys/class/power_supply/battery/batt_temp_adc
+    chown system radio /sys/class/power_supply/battery/batt_temp_adc_aver
+    chown system radio /sys/class/power_supply/battery/batt_temp_adc_cal
+    chown system radio /sys/class/power_supply/battery/batt_temp_aver
+    chown system radio /sys/class/power_supply/battery/batt_type
+    chown system radio /sys/class/power_supply/battery/batt_vf_adc
+    chown system radio /sys/class/power_supply/battery/batt_vfocv
+    chown system radio /sys/class/power_supply/battery/batt_vol_adc
+    chown system radio /sys/class/power_supply/battery/batt_vol_adc_aver
+    chown system radio /sys/class/power_supply/battery/batt_vol_adc_cal
+    chown system radio /sys/class/power_supply/battery/batt_vol_aver
+    chown system radio /sys/class/power_supply/battery/factory_mode
+    chown system radio /sys/class/power_supply/battery/siop_activated
+    chown system radio /sys/class/power_supply/battery/siop_level
+    chown system radio /sys/class/power_supply/battery/update
+    chown system radio /sys/class/power_supply/battery/wc_status
+    chown system radio /sys/class/power_supply/battery/wpc_pin_state
+
+# CTIA event
+   chown sdcard_rw sdcard_rw /sys/class/power_supply/battery/call
+   chown sdcard_rw sdcard_rw /sys/class/power_supply/battery/video
+   chown sdcard_rw sdcard_rw /sys/class/power_supply/battery/music
+   chown sdcard_rw sdcard_rw /sys/class/power_supply/battery/browser
+   chown sdcard_rw sdcard_rw /sys/class/power_supply/battery/hotspot
+   chown sdcard_rw sdcard_rw /sys/class/power_supply/battery/camera
+   chown system radio /sys/class/power_supply/battery/talk_wcdma
+   chown system radio /sys/class/power_supply/battery/talk_gsm
+   chown system radio /sys/class/power_supply/battery/call
+   chown system radio /sys/class/power_supply/battery/data_call
+   chown gps radio /sys/class/power_supply/battery/gps
+   chown system radio /sys/class/power_supply/battery/wifi
+   chown system radio /sys/class/power_supply/battery/lte
+
+# Thermistor node
+    chown radio system /sys/devices/platform/sec-thermistor/temp_adc
+    chown radio system /sys/devices/platform/sec-thermistor/temperature
+
+# Permissions for touch
+    chown system radio /sys/class/sec/tsp/cmd
+    
+# Permissions for Touchkey
+	chown system radio /sys/class/sec/sec_touchkey/enable_disable
+	chown system radio /sys/class/sec/sec_touchkey/touchkey_brightness
+	chown system radio /sys/class/sec/sec_touchkey/touchkey_menu
+	chown system radio /sys/class/sec/sec_touchkey/touchkey_back
+	chown system radio /sys/class/sec/sec_touchkey/touch_update
+	chown system radio /sys/class/sec/sec_touchkey/touch_version
+	chown system radio /sys/class/sec/sec_touchkey/touchkey_firm_version_panel
+	chown system radio /sys/class/sec/sec_touchkey/touchkey_firm_version_phone
+	chown system radio /sys/class/sec/sec_touchkey/touchkey_firm_update_status
+	chown system radio /sys/class/sec/sec_touchkey/touchkey_firm_update
+	chown system radio /sys/class/sec/sec_touchkey/touch_sensitivity
+	chown system radio /sys/class/sec/sec_touchkey/touchkey_threshold
+	chown system system /sys/devices/virtual/sec/sec_touchkey/brightness
+
+# Permissions for gpio_keys
+    chown radio system /sys/class/sec/sec_key/wakeup_keys 
+    write /sys/class/sec/sec_key/wakeup_keys 116,172,544
+
+# Switch Device
+    chown system system /sys/class/sec/switch/uart_sel
+    chown system system /sys/class/sec/switch/usb_sel
+    chown system system /sys/class/sec/switch/otg_test
+    chown system radio /sys/class/sec/switch/adc
+    
+# IPC sysfs
+    chown radio radio /sys/devices/virtual/misc/multipdp/waketime
+    symlink /dev/block/mmcblk0p7 /dev/mbin0
+
+# <Sensors & NFC>
+# Input Events
+    chown system input /sys/class/input/input2/enable
+    chown system input /sys/class/input/input2/poll_delay
+    chown system input /sys/class/input/input3/enable
+    chown system input /sys/class/input/input3/poll_delay
+    chown system input /sys/class/input/input4/enable
+    chown system input /sys/class/input/input4/poll_delay
+    chown system input /sys/class/input/input5/enable
+    chown system input /sys/class/input/input5/poll_delay
+    chown system input /sys/class/input/input6/enable
+    chown system input /sys/class/input/input6/poll_delay
+    chown system input /sys/class/input/input7/enable
+    chown system input /sys/class/input/input7/poll_delay
+    chown system input /sys/class/input/input8/enable
+    chown system input /sys/class/input/input8/poll_delay
+    chown system input /sys/class/input/input9/enable
+    chown system input /sys/class/input/input9/poll_delay
+    chown system input /sys/class/input/input2/delay
+    chown system input /sys/class/input/input3/delay
+    chown system input /sys/class/input/input4/delay
+    chown system input /sys/class/input/input5/delay
+    chown system input /sys/class/input/input6/delay
+    chown system input /sys/class/input/input6/delay
+    chown system input /sys/class/input/input7/delay
+    chown system input /sys/class/input/input8/delay
+    chown system input /sys/class/input/input9/delay
+# Accelerometer_sensor
+    chown system radio /dev/accelerometer
+    chown system radio /sys/class/sensors/accelerometer_sensor
+    chown system radio /sys/class/sensors/accelerometer_sensor/raw_data
+    chown system radio /sys/class/sensors/accelerometer_sensor/calibration
+    chown system radio /sys/class/sensors/accelerometer_sensor/reactive_alert
+    chown system radio /sys/class/sensors/accelerometer_sensor/vendor
+    chown system radio /sys/class/sensors/accelerometer_sensor/name
+# Proximity_sensor
+    chown system radio /sys/class/sensors/proximity_sensor/state
+    chown system radio /sys/class/sensors/proximity_sensor/prox_avg
+    chown system radio /sys/class/sensors/proximity_sensor/prox_cal
+    chown system radio /sys/class/sensors/proximity_sensor/vendor
+    chown system radio /sys/class/sensors/proximity_sensor/name
+    chown system radio /sys/class/sensors/proximity_sensor/prox_thresh
+# Light_sensor
+    chown system radio /sys/class/sensors/light_sensor/lux
+    chown system radio /sys/class/sensors/light_sensor/raw_data
+    chown system radio /sys/class/sensors/light_sensor/vendor
+    chown system radio /sys/class/sensors/light_sensor/name
+# Magnetic_sensor
+    chmod 0777 /dev/i2c-10
+    chown system radio /sys/class/sensors/magnetic_sensor/raw_data
+    chown system radio /sys/class/sensors/magnetic_sensor/vendor
+    chown system radio /sys/class/sensors/magnetic_sensor/name
+    chown compass input /sys/class/input/input6/offsets
+    chown compass input /sys/class/input/input6/dynamic_matrix
+    chown system input /sys/class/input/input6/threshold
+    chown system input /sys/class/input/input6/distortion
+    chown system input /sys/class/input/input6/shape
+    write /sys/class/input/input6/distortion "350 50 15"
+    write /sys/class/input/input6/static_matrix "10602 -980 25 -830 10470 -188 2753 1005 9019"
+    write /sys/class/input/input6/ellipsoid_mode "1"
+
+    chown system input /sys/class/input/input6/filter_enable
+    chown system input /sys/class/input/input6/filter_len
+    chown system input /sys/class/input/input6/data
+    chown system input /sys/class/input/input6/status
+    chown system input /sys/class/input/input6/wake
+    chown system input /sys/class/input/input6/position
+# Magnetic_sensor
+    chown compass input /sys/class/input/input5/offsets
+    chown compass input /sys/class/input/input5/dynamic_matrix
+    chown system input /sys/class/input/input5/threshold
+    chown system input /sys/class/input/input5/distortion
+    chown system input /sys/class/input/input5/shape
+    write /sys/class/input/input5/distortion "350 50 15"
+    write /sys/class/input/input5/static_matrix "10602 -980 25 -830 10470 -188 2753 1005 9019"
+    write /sys/class/input/input5/ellipsoid_mode "1"
+
+    chown system input /sys/class/input/input5/filter_enable
+    chown system input /sys/class/input/input5/filter_len
+    chown system input /sys/class/input/input5/data
+    chown system input /sys/class/input/input5/status
+    chown system input /sys/class/input/input5/wake
+    chown system input /sys/class/input/input5/position
+
+# NFC
+    setprop ro.nfc.port "I2C"
+    chmod 0600 /dev/pn544
+    chown nfc nfc /dev/pn544
+
+# Vibetonz
+    chmod 0660 /dev/tspdrv
+    chown root shell /dev/tspdrv
+
+# IR_LED
+	chown system system /sys/class/sec/sec_ir/ir_send
+	chown system system /sys/class/sec/sec_ir/ir_send_result
+	
+# Permissions for backlight
+    chown system system /sys/class/backlight/panel/brightness
+
+# for wifi
+    mkdir /data/misc/wifi/sockets 0770 wifi wifi
+    mkdir /data/misc/dhcp 0775 dhcp dhcp
+    chown dhcp dhcp /data/misc/dhcp
+
+# for TRP/TIS
+    write /data/.psm.info 1
+    chown system root /data/.psm.info
+    chmod 0660 /data/.psm.info
+
+    # Set indication (checked by vold) that we have finished this action
+    setprop vold.post_fs_data_done 1
+
+on boot
+    mount debugfs /sys/kernel/debug /sys/kernel/debug
+
+    setprop ro.build.product smdk4x12
+    setprop ro.product.device smdk4x12
+    setprop ro.radio.noril yes
+    setprop wifi.interface wlan0
+
+# fake some battery state
+    setprop status.battery.state Slow
+    setprop status.battery.level 5
+    setprop status.battery.level_raw  50
+    setprop status.battery.level_scale 9
+
+# wifi display
+    write /proc/sys/net/core/wmem_max   262144
+
+    # Set permission for Widevine DRM temporarily
+    chmod 0777 /dev/s5p-smem
+    rm /data/app/tlcd_sock
+
+    # make param block device link for SysScope
+    symlink /dev/block/mmcblk0p7 /dev/block/param
+
+# touchscreen
+    chown radio system /sys/class/sec/tsp/cmd
+    chown media_rw media_rw /sys/class/sec/tsp/set_jitter    
+
+# epen
+    chown radio system /sys/class/sec/sec_epen/epen_firm_update
+    chown radio system /sys/class/sec/sec_epen/epen_checksum
+    chown radio system /sys/class/sec/sec_epen/epen_checksum_result
+    chown radio system /sys/class/sec/sec_epen/epen_reset
+    chown system system /sys/class/sec/sec_epen/epen_saving_mode
+    chmod 660 /sys/class/sec/sec_epen/epen_saving_mode
+    
+# wakeup keys
+    chown radio system /sys/class/sec/sec_key/wakeup_keys
+    write /sys/class/sec/sec_key/wakeup_keys 116,172
+
+# serial keyboard daemon
+service sec_keyboard /system/bin/sec_keyboard /dev/ttySAC3
+	class late_start
+	disabled
+	group system
+
+# SISO-ANDR_PERF :: START Changing scheduler to cfq and reseting cpu min freq to -1 after boot complete
+on property:sys.boot_completed=1
+    write /sys/block/mmcblk0/queue/scheduler cfq
+    write /sys/power/cpufreq_min_limit -1
+# SISO-ANDR_PERF :: END
+
+on property:ro.uart_debug=0
+	start sec_keyboard
+	
+# create filesystem if necessary
+#service setup_fs /system/bin/setup_fs \
+#            /dev/block/mmcblk0p3 \
+#            /dev/block/mmcblk0p4
+#    class core
+#    user root
+#    group root
+#    oneshot
+
+service at_distributor /system/bin/at_distributor
+    class main
+    user root
+    group radio lo
+
+# create virtual SD card at /mnt/sdcard, based on the /data/media directory
+# daemon will drop to user/group system/media_rw after initializing
+# underlying files in /data/media wil be created with user and group media_rw (1023)
+service sdcard /system/bin/sdcard /data/media /mnt/shell/emulated 1023 1023
+    class late_start
+
+service p2p_supplicant /system/bin/wpa_supplicant \
+    -iwlan0 -Dnl80211 -c/data/misc/wifi/wpa_supplicant.conf -N \
+    -ip2p0 -Dnl80211 -c/data/misc/wifi/p2p_supplicant.conf -e/data/misc/wifi/entropy.bin \
+    -puse_p2p_group_interface=1
+    #   we will start as root and wpa_supplicant will switch to user wifi
+    #   after setting up the capabilities required for WEXT
+    #   user wifi
+    #   group wifi inet keystore
+    class main
+    socket wpa_wlan0 dgram 660 wifi wifi
+    disabled
+    oneshot
+
+service wpa_supplicant /system/bin/wpa_supplicant \
+    -Dnl80211 -iwlan0 -e/data/misc/wifi/entropy.bin \
+    -c/data/misc/wifi/wpa_supplicant.conf
+    #   we will start as root and wpa_supplicant will switch to user wifi
+    #   after setting up the capabilities required for WEXT
+    #   user wifi
+    #   group wifi inet keystore
+    class main
+    socket wpa_wlan0 dgram 660 wifi wifi
+    disabled
+    oneshot
+
+service dhcpcd_wlan0 /system/bin/dhcpcd -ABKL
+    class main
+    disabled
+    oneshot
+
+service dhcpcd_p2p /system/bin/dhcpcd -aABKL
+    class main
+    disabled
+    oneshot
+
+service dhcpcd_bnep0 /system/bin/dhcpcd -ABKL
+	class main
+	disabled
+	oneshot
+
+service iprenew_wlan0 /system/bin/dhcpcd -n
+    class main
+    disabled
+    oneshot
+
+service iprenew_p2p /system/bin/dhcpcd -n
+    class main
+    disabled
+    oneshot
+
+service iprenew_bnep0 /system/bin/dhcpcd -n
+	class main
+	disabled
+	oneshot
+	
+# GPS
+service gpsd /system/bin/gpsd -c /system/etc/gps.xml
+    class main
+    socket gps seqpacket 0660 gps system
+    user gps
+    group system inet sdcard_rw
+    ioprio be 0
+
+service macloader /system/bin/macloader
+    class main
+    oneshot
+    
+service orientationd /system/bin/orientationd
+    class main
+    user compass
+    group input
+
+service geomagneticd /system/bin/geomagneticd
+    class main
+    user compass
+    group system input
+    
+on property:init.svc.macloader=stopped
+    chown system root /data/.cid.info
+    chmod 0664 /data/.cid.info
+    chown system root /data/.rev
+    chmod 0660 /data/.rev
+# end of wifi
+
+service SMD-daemon /system/bin/smdexe
+    class main
+    user root
+    group system radio inet net_raw
diff --git a/rootdir/init.smdk4x12.usb.rc b/rootdir/init.smdk4x12.usb.rc
new file mode 100755
index 0000000..6c4bca2
--- /dev/null
+++ b/rootdir/init.smdk4x12.usb.rc
@@ -0,0 +1,134 @@
+on init
+    write /sys/class/android_usb/android0/iSerial $ro.serialno
+    write /sys/class/android_usb/android0/f_rndis/manufacturer Samsung
+    write /sys/class/android_usb/android0/f_rndis/vendorID 04e8
+    write /sys/class/android_usb/android0/f_rndis/wceis 1
+
+on boot
+    write /sys/class/android_usb/android0/iManufacturer $ro.product.manufacturer
+    write /sys/class/android_usb/android0/iProduct $ro.product.model
+    write /sys/class/android_usb/android0/iSerial $ro.serialno
+    write /sys/class/android_usb/f_mass_storage/inquiry_string "Samsung"
+
+on property:sys.usb.config=mtp
+    write /sys/class/android_usb/android0/enable 0
+    write /sys/class/android_usb/android0/idVendor 04e8
+    write /sys/class/android_usb/android0/idProduct 6860
+    write /sys/class/android_usb/android0/functions ${sys.usb.config}
+    write /sys/class/android_usb/android0/enable 1
+    setprop sys.usb.state ${sys.usb.config}
+
+
+on property:sys.usb.config=mtp,adb
+    write /sys/class/android_usb/android0/enable 0
+    write /sys/class/android_usb/android0/idVendor 04e8
+    write /sys/class/android_usb/android0/idProduct 6860
+    write /sys/class/android_usb/android0/functions ${sys.usb.config}
+    write /sys/class/android_usb/android0/enable 1
+    start adbd
+    setprop sys.usb.state ${sys.usb.config}
+
+on property:sys.usb.config=rndis
+    write /sys/class/android_usb/android0/enable 0
+    write /sys/class/android_usb/android0/idVendor 04e8
+    write /sys/class/android_usb/android0/idProduct 6863
+    write /sys/class/android_usb/android0/functions ${sys.usb.config}
+    write /sys/class/android_usb/android0/bDeviceClass 224
+    write /sys/class/android_usb/android0/enable 1
+    setprop sys.usb.state ${sys.usb.config}
+
+on property:sys.usb.config=rndis,adb
+    write /sys/class/android_usb/android0/enable 0
+    write /sys/class/android_usb/android0/idVendor 04e8
+    write /sys/class/android_usb/android0/idProduct 6864
+    write /sys/class/android_usb/android0/functions ${sys.usb.config}
+    write /sys/class/android_usb/android0/bDeviceClass 224
+    write /sys/class/android_usb/android0/enable 1
+    start adbd
+    setprop sys.usb.state ${sys.usb.config}
+on property:sys.usb.config=ptp
+    write /sys/class/android_usb/android0/enable 0
+    write /sys/class/android_usb/android0/idVendor 04e8
+    write /sys/class/android_usb/android0/idProduct 6865
+    write /sys/class/android_usb/android0/functions ${sys.usb.config}
+    write /sys/class/android_usb/android0/enable 1
+    setprop sys.usb.state ${sys.usb.config}
+
+on property:sys.usb.config=ptp,adb
+    write /sys/class/android_usb/android0/enable 0
+    write /sys/class/android_usb/android0/idVendor 04e8
+    write /sys/class/android_usb/android0/idProduct 6866
+    write /sys/class/android_usb/android0/functions ${sys.usb.config}
+    write /sys/class/android_usb/android0/enable 1
+    start adbd
+    setprop sys.usb.state ${sys.usb.config}
+
+on property:sys.usb.config=rndis,dm
+    write /sys/class/android_usb/android0/enable 0
+    write /sys/class/android_usb/android0/idVendor 04e8
+    write /sys/class/android_usb/android0/idProduct 6862
+    write /sys/class/android_usb/android0/functions ${sys.usb.config}
+    write /sys/class/android_usb/android0/enable 1
+    setprop sys.usb.state ${sys.usb.config}
+
+on property:sys.usb.config=rndis,acm,dm
+    write /sys/class/android_usb/android0/enable 0
+    write /sys/class/android_usb/android0/idVendor 04e8
+    write /sys/class/android_usb/android0/idProduct 6862
+    write /sys/class/android_usb/android0/functions ${sys.usb.config}
+    write /sys/class/android_usb/android0/enable 1
+    setprop sys.usb.state ${sys.usb.config}
+
+on property:sys.usb.config=mass_storage
+    write /sys/class/android_usb/android0/enable 0
+    write /sys/class/android_usb/android0/idVendor 04e8
+    write /sys/class/android_usb/android0/idProduct 685B
+    write /sys/class/android_usb/android0/functions ${sys.usb.config}
+    write /sys/class/android_usb/android0/enable 1
+    setprop sys.usb.state ${sys.usb.config}
+
+on property:sys.usb.config=mass_storage,adb
+    write /sys/class/android_usb/android0/enable 0
+    write /sys/class/android_usb/android0/idVendor 04e8
+    write /sys/class/android_usb/android0/idProduct 685e
+    write /sys/class/android_usb/android0/functions ${sys.usb.config}
+    write /sys/class/android_usb/android0/enable 1
+    start adbd
+    setprop sys.usb.state ${sys.usb.config}
+
+on property:sys.usb.config=mass_storage,acm
+    write /sys/class/android_usb/android0/enable 0
+    write /sys/class/android_usb/android0/idVendor 04e8
+    write /sys/class/android_usb/android0/idProduct 685e
+    write /sys/class/android_usb/android0/functions ${sys.usb.config}
+    write /sys/class/android_usb/android0/enable 1
+    setprop sys.usb.state ${sys.usb.config}
+# rndis,acm,diag and diag,acm,adb used for Hidden Menu
+
+on property:sys.usb.config=rndis,diag
+    write /sys/class/android_usb/android0/enable 0
+    write /sys/class/android_usb/android0/idVendor 04e8
+    write /sys/class/android_usb/android0/idProduct 6862
+    write /sys/class/android_usb/android0/f_diag/clients diag_mdm
+    write /sys/class/android_usb/android0/functions ${sys.usb.config}
+    write /sys/class/android_usb/android0/enable 1
+    setprop sys.usb.state ${sys.usb.config}
+
+on property:sys.usb.config=diag,acm,adb
+    write /sys/class/android_usb/android0/enable 0
+    write /sys/class/android_usb/android0/idVendor 04E8
+    write /sys/class/android_usb/android0/idProduct 6860
+    write /sys/class/android_usb/android0/f_diag/clients diag_mdm
+    write /sys/class/android_usb/android0/functions ${sys.usb.config}
+    write /sys/class/android_usb/android0/enable 1
+    start adbd
+    setprop sys.usb.state ${sys.usb.config}
+
+on property:sys.usb.config=rndis,acm,diag
+    write /sys/class/android_usb/android0/enable 0
+    write /sys/class/android_usb/android0/idVendor 04E8
+    write /sys/class/android_usb/android0/idProduct 6864
+    write /sys/class/android_usb/android0/f_diag/clients diag_mdm
+    write /sys/class/android_usb/android0/functions ${sys.usb.config}
+    write /sys/class/android_usb/android0/enable 1
+    setprop sys.usb.state ${sys.usb.config}
diff --git a/rootdir/lpm.rc b/rootdir/lpm.rc
new file mode 100644
index 0000000..7e5d382
--- /dev/null
+++ b/rootdir/lpm.rc
@@ -0,0 +1,80 @@
+on early-init
+    start ueventd
+
+on init
+
+    export PATH /sbin:/vendor/bin:/system/sbin:/system/bin:/system/xbin
+    export LD_LIBRARY_PATH /vendor/lib:/system/lib
+    export ANDROID_ROOT /system
+    export ANDROID_DATA /data
+    export EXTERNAL_STORAGE /sdcard
+
+    symlink /system/etc /etc
+
+    mkdir /sdcard
+    mkdir /preload
+    mkdir /system
+    mkdir /data
+    mkdir /cache
+    mkdir /efs
+    mkdir /tmp
+    mkdir /dbdata
+    mkdir /mnt 0775 root root
+    #mount /tmp /tmp tmpfs   
+
+on early-fs
+	insmod /lib/modules/vibrator.ko
+
+    mount ext4 /dev/block/mmcblk0p9 /system ro wait noatime
+
+	mkdir /data/log 0777
+
+	chmod 0666 /dev/log/radio
+	chmod 0666 /dev/log/main
+	chmod 0666 /dev/log/event    
+
+on boot
+#	write /sys/class/sec/switch/usb_sel PDA
+
+# CPU Frequency Governor
+	write /sys/devices/system/cpu/cpu0/cpufreq/scaling_governor pegasusq
+
+# EHCI runtime enable for LPA
+	write /sys/devices/platform/s5p-ehci/power/control auto
+
+	ifup lo
+	hostname localhost
+	domainname localdomain
+
+	class_start default
+
+service debuggerd /system/bin/debuggerd
+
+	service ueventd /sbin/ueventd
+    	critical
+
+#service console /bin/sh
+service console /system/bin/sh
+	console
+
+service immvibed /system/bin/immvibed 
+	oneshot
+
+service charger /charger
+    class default
+    user root
+
+# adbd is controlled by the persist.service.adb.enable system property
+service adbd /sbin/adbd
+    disabled
+
+# adbd on at boot in emulator
+on property:ro.kernel.qemu=1
+    start adbd
+
+on property:persist.service.adb.enable=1
+    start adbd
+
+on property:persist.service.adb.enable=0
+    stop adbd
+
diff --git a/rootdir/ueventd.smdk4x12.rc b/rootdir/ueventd.smdk4x12.rc
new file mode 100644
index 0000000..3129961
--- /dev/null
+++ b/rootdir/ueventd.smdk4x12.rc
@@ -0,0 +1,83 @@
+/dev/mali                 0666   system     system
+/dev/ump                  0666   system     graphics
+/dev/ion                  0666   system     system
+/dev/exynos-mem           0666   system     graphics
+
+/dev/media0               0660   system     system
+/dev/media1               0660   system     camera
+/dev/media2               0660   system     camera
+/dev/v4l-subdev0          0660   system     system
+/dev/v4l-subdev1          0660   system     system
+/dev/v4l-subdev3          0660   system     system
+/dev/v4l-subdev4          0660   system     system
+/dev/v4l-subdev5          0660   system     system
+/dev/v4l-subdev6          0660   system     system
+/dev/v4l-subdev7          0660   system     system
+/dev/v4l-subdev8          0660   system     system
+/dev/v4l-subdev9          0660   system     system
+/dev/v4l-subdev10         0660   system     system
+/dev/v4l-subdev11         0660   system     system
+/dev/v4l-subdev12         0660   system     system
+/dev/v4l-subdev13         0660   system     system
+/dev/v4l-subdev14         0660   system     system
+/dev/v4l-subdev15         0660   system     system
+/dev/v4l-subdev16         0660   system     system
+/dev/v4l-subdev17         0660   system     system
+
+/dev/video0               0660   system     camera
+/dev/video1               0660   system     camera
+/dev/video2               0660   system     camera
+/dev/video3               0660   system     camera
+/dev/video4               0666   system     m2m
+/dev/video11              0666   system     system
+/dev/video12              0666   system     system
+/dev/video20              0660   system     system
+/dev/video6               0660   media      graphics
+/dev/video7               0660   media      graphics
+
+/dev/video11              0666   system     graphics
+/dev/video12              0660   system     camera
+
+/dev/video16              0660   system     system
+/dev/video17              0660   system     system
+/dev/video18              0660   system     system
+/dev/video19              0660   system     system
+
+# Rotator
+/dev/video21              0660   system     system
+
+/dev/video23              0660   system     system
+/dev/video24              0660   system     system
+/dev/video25              0660   system     camera
+/dev/video26              0666   media      m2m
+/dev/video29              0666   media      m2m
+/dev/video32              0660   media      m2m
+
+/dev/video33              0660   system     system
+/dev/video34              0660   system     system
+
+/dev/video40              0660   system     camera
+/dev/video41              0660   system     camera
+/dev/video42              0660   system     camera
+/dev/video43              0660   system     camera
+
+/dev/i2c-2                0660   system     system
+/dev/i2c-5                0660   system     system
+/dev/CEC                  0660   system     system
+/dev/HPD                  0660   system     system
+/dev/fimg2d               0666   system     graphics
+/dev/fmradio              0660   system     audio
+
+#ALP Audio
+/dev/srp                  0660   system     audio
+
+/dev/s3c-mfc              0660   system     graphics
+/dev/s5p-mfc              0666   system     graphics
+
+/dev/umts*                0660   system     radio
+/dev/ttyUSB0              0666   system     system
+/dev/ttyUSB1              0666   system     system
+/dev/ttyUSB2              0666   system     system
+/dev/usb/lp*              0660   system     usb
+/dev/block/mmcblk0p4	  0660	 system	    system
+/dev/block/mmcblk0p7	  0660	 system	    radio
diff --git a/system.prop b/system.prop
new file mode 100755
index 0000000..b2928cb
--- /dev/null
+++ b/system.prop
@@ -0,0 +1,12 @@
+#
+# system.prop for smdk4x12
+#
+dalvik.vm.dexopt-data-only=1
+rild.libpath=/system/lib/libsec-ril.so
+rild.libargs=-d /dev/ttyS0
+ro.sf.hwrotation=270
+ro.sf.lcd_density=213
+ro.lcd_min_brightness=20
+ro.hdcp2.rx=tz
+
+