diff --git a/Android.mk b/Android.mk
index 20bfbaf..c5cf773 100644
--- a/Android.mk
+++ b/Android.mk
@@ -20,9 +20,11 @@
 # to only building on ARM if they include assembly. Individual makefiles
 # are responsible for having their own logic, for fine-grained control.
 
+ifeq (panda,$(TARGET_DEVICE))
 LOCAL_PATH := $(call my-dir)
 
 # if some modules are built directly from this directory (not subdirectories),
 # their rules should be written here.
 
 include $(call all-makefiles-under,$(LOCAL_PATH))
+endif
diff --git a/BoardConfig.mk b/BoardConfig.mk
index 39f768d..9af06b8 100644
--- a/BoardConfig.mk
+++ b/BoardConfig.mk
@@ -16,7 +16,7 @@
 
 # These two variables are set first, so they can be overridden
 # by BoardConfigVendor.mk
-BOARD_USES_GENERIC_AUDIO := true
+BOARD_USES_GENERIC_AUDIO := false
 USE_CAMERA_STUB := true
 
 # Use the non-open-source parts, if they're present
@@ -28,12 +28,12 @@
 TARGET_ARCH_VARIANT := armv7-a-neon
 ARCH_ARM_HAVE_TLS_REGISTER := true
 
-BOARD_HAVE_BLUETOOTH := false
+BOARD_HAVE_BLUETOOTH := true
 TARGET_NO_BOOTLOADER := true
 TARGET_NO_RECOVERY := true
 
 BOARD_KERNEL_BASE := 0x80000000
-BOARD_KERNEL_CMDLINE := console=ttyO2,115200n8 mem=1024M androidboot.console=ttyO2 vram=20M omapfb.vram=0:16M
+#BOARD_KERNEL_CMDLINE :=
 
 TARGET_NO_RADIOIMAGE := true
 TARGET_BOARD_PLATFORM := omap4
@@ -44,13 +44,21 @@
 #BOARD_USES_HGL := true
 #BOARD_USES_OVERLAY := true
 USE_OPENGL_RENDERER := true
+BOARD_USES_PANDA_GRAPHICS := true
 
 TARGET_USERIMAGES_USE_EXT4 := true
 BOARD_SYSTEMIMAGE_PARTITION_SIZE := 268435456
 #BOARD_SYSTEMIMAGE_PARTITION_SIZE := 16777216
 BOARD_USERDATAIMAGE_PARTITION_SIZE := 536870912
+BOARD_CACHEIMAGE_PARTITION_SIZE := 268435456
+BOARD_CACHEIMAGE_FILE_SYSTEM_TYPE := ext4
 BOARD_FLASH_BLOCK_SIZE := 4096
 
+BOARD_WPA_SUPPLICANT_DRIVER      := NL80211
+WPA_SUPPLICANT_VERSION           := VER_0_8_X
+BOARD_WPA_SUPPLICANT_PRIVATE_LIB := lib_driver_cmd_wl12xx
+BOARD_WLAN_DEVICE                := wl12xx_mac80211
+
 #TARGET_PROVIDES_INIT_RC := true
 #TARGET_USERIMAGES_SPARSE_EXT_DISABLED := true
 
diff --git a/CleanSpec.mk b/CleanSpec.mk
index 07f668f..8494067 100644
--- a/CleanSpec.mk
+++ b/CleanSpec.mk
@@ -48,4 +48,4 @@
 # NEWER CLEAN STEPS MUST BE AT THE END OF THE LIST
 # ************************************************
 $(call add-clean-step, rm -f $(PRODUCT_OUT)/system/build.prop)
-$(call add-clean-step, rm -f $(PRODUCT_OUT)/system/build.prop)
\ No newline at end of file
+$(call add-clean-step, rm -f $(PRODUCT_OUT)/system/build.prop)
diff --git a/README b/README
index 5a261e5..f1bfd3e 100644
--- a/README
+++ b/README
@@ -1,14 +1,25 @@
 Running Android on pandaboard:
 
-This assumes that you have all the proper drivers. For Googlers working in
-Google's full internal tree (i.e. with vendor/ti/proprietary and related projects)
-or in equivalent situations, this is done automatically. Other situations TBD.
+This assumes that you have all the necessary proprietary binaries.
+
+When working with AOSP, download them from:
+http://code.google.com/android/nexus/drivers.html#panda
+The master branch in AOSP works with the latest version of those drivers.
+
+Unarchive each file at the root of your source tree (with tar zxvf), and
+execute the included shell script, still at the root of tour source tree.
+That will create a vendor tree that contains the necessary files.
+They can be unarchived and extracted in any order.
+
+For Googlers working in Google's full internal tree (i.e. with
+vendor/ti/proprietary and related projects) or in equivalent
+situations, this is done automatically.
 
 Board setup:
 Power supply
 Mini-USB to the PC
 USB keyboard and mouse
-Ethernet, on a network that supports DHCP
+(optional) Ethernet, on a network that supports DHCP
 HDMI-to-DVI-D on the P1 DVI-D connector
 
 # Initial setup, part 1: build fastboot
@@ -42,7 +53,7 @@
 # Post-boot setup, part 1: Set the date on the board:
 adb shell date $(date +%s)
 
-# Post-boot setup, part 2: Configure Ethernet
+# Post-boot setup, part 2: (optional) Configure Ethernet
 adb shell dhcpcd eth0
 
 =================================
@@ -54,11 +65,9 @@
 
 adb reboot bootloader doesn't work.
 
-Networking is hardcoded to use 8.8.8.8 and 8.8.4.4 DNS.
-
-The connectivity manager doesn't know that the network is available. As
-a result, the browser complains that the network is down, and the download
-manager refuses to download anything.
+Ethernet networking is initialized to use DHCP. The status bar will not
+show that there is an Ethernet connection established, but apps such as
+Browser will work.
 
 Everything camera-related crashes.
 
@@ -67,5 +76,3 @@
 Language selection crashes.
 
 No audio.
-
-No wifi.
diff --git a/android.hardware.bluetooth.xml b/android.hardware.bluetooth.xml
new file mode 100644
index 0000000..569f857
--- /dev/null
+++ b/android.hardware.bluetooth.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 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.
+-->
+
+<!-- This is the standard feature indicating that the device includes
+Bluetooth -->
+<permissions>
+    <feature name="android.hardware.bluetooth" />
+</permissions>
diff --git a/audio/Android.mk b/audio/Android.mk
new file mode 100644
index 0000000..33e9e32
--- /dev/null
+++ b/audio/Android.mk
@@ -0,0 +1,35 @@
+# Copyright (C) 2011 Texas Instruments
+#
+# 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)
+
+ifneq (,$(findstring panda, $(TARGET_PRODUCT)))
+    LOCAL_MODULE := audio.primary.panda
+else
+    LOCAL_MODULE := audio.primary.generic
+endif
+
+LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/hw
+LOCAL_SRC_FILES := audio_hw.c
+
+LOCAL_C_INCLUDES += \
+	external/tinyalsa/include \
+	system/media/audio_utils/include \
+	system/media/audio_effects/include
+LOCAL_SHARED_LIBRARIES := liblog libcutils libtinyalsa libaudioutils libdl
+LOCAL_MODULE_TAGS := optional
+
+include $(BUILD_SHARED_LIBRARY)
diff --git a/audio/audio_hw.c b/audio/audio_hw.c
new file mode 100644
index 0000000..e5babe1
--- /dev/null
+++ b/audio/audio_hw.c
@@ -0,0 +1,3016 @@
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ * Copyright (C) 2011 Texas Instruments Inc.
+ *
+ * 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 module is a derived work from the original contribution of
+ * the /device/samsung/tuna/audio/audio_hw.c by Simon Wilson
+ *
+ */
+
+#define LOG_TAG "audio_hw_primary"
+/*#define LOG_NDEBUG 0*/
+/*#define LOG_NDEBUG_FUNCTION*/
+#ifndef LOG_NDEBUG_FUNCTION
+#define LOGFUNC(...) ((void)0)
+#else
+#define LOGFUNC(...) (ALOGV(__VA_ARGS__))
+#endif
+
+#include <errno.h>
+#include <pthread.h>
+#include <stdint.h>
+#include <sys/time.h>
+#include <stdlib.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>
+
+/* Mixer control names */
+#define MIXER_DL1_EQUALIZER                 "DL1 Equalizer"
+#define MIXER_DL2_LEFT_EQUALIZER            "DL2 Left Equalizer"
+#define MIXER_DL2_RIGHT_EQUALIZER           "DL2 Right Equalizer"
+#define MIXER_DL1_MEDIA_PLAYBACK_VOLUME     "DL1 Media Playback Volume"
+#define MIXER_DL1_VOICE_PLAYBACK_VOLUME     "DL1 Voice Playback Volume"
+#define MIXER_DL2_MEDIA_PLAYBACK_VOLUME     "DL2 Media Playback Volume"
+#define MIXER_DL2_VOICE_PLAYBACK_VOLUME     "DL2 Voice Playback Volume"
+#define MIXER_SDT_DL_VOLUME                 "SDT DL Volume"
+#define MIXER_SDT_UL_VOLUME                 "SDT UL Volume"
+
+#define MIXER_DL1_CAPTURE_PLAYBACK_VOLUME   "DL1 Capture Playback Volume"
+#define MIXER_DL2_CAPTURE_PLAYBACK_VOLUME   "DL2 Capture Playback Volume"
+#define MIXER_HEADSET_PLAYBACK_VOLUME       "Headset Playback Volume"
+#define MIXER_HANDSFREE_PLAYBACK_VOLUME     "Handsfree Playback Volume"
+#define MIXER_EARPHONE_PLAYBACK_VOLUME      "Earphone Playback Volume"
+#define MIXER_BT_UL_VOLUME                  "BT UL Volume"
+
+#define MIXER_DL1_EQUALIZER                 "DL1 Equalizer"
+#define MIXER_DL1_MIXER_MULTIMEDIA          "DL1 Mixer Multimedia"
+#define MIXER_DL1_MIXER_VOICE               "DL1 Mixer Voice"
+#define MIXER_DL1_MONO_MIXER                "DL1 Mono Mixer"
+#define MIXER_DL2_MIXER_MULTIMEDIA          "DL2 Mixer Multimedia"
+#define MIXER_DL2_MIXER_VOICE               "DL2 Mixer Voice"
+#define MIXER_DL2_MONO_MIXER                "DL2 Mono Mixer"
+#define MIXER_SIDETONE_MIXER_PLAYBACK       "Sidetone Mixer Playback"
+#define MIXER_SIDETONE_MIXER_CAPTURE        "Sidetone Mixer Capture"
+#define MIXER_DL1_PDM_SWITCH                "DL1 PDM Switch"
+#define MIXER_DL1_BT_VX_SWITCH              "DL1 BT_VX Switch"
+#define MIXER_DL1_MM_EXT_SWITCH             "DL1 MM_EXT Switch"
+#define MIXER_VOICE_CAPTURE_MIXER_CAPTURE   "Voice Capture Mixer Capture"
+
+#define MIXER_HS_LEFT_PLAYBACK              "HS Left Playback"
+#define MIXER_HS_RIGHT_PLAYBACK             "HS Right Playback"
+#define MIXER_HF_LEFT_PLAYBACK              "HF Left Playback"
+#define MIXER_HF_RIGHT_PLAYBACK             "HF Right Playback"
+#define MIXER_EARPHONE_ENABLE_SWITCH        "Earphone Enable Switch"
+
+#define MIXER_ANALOG_LEFT_CAPTURE_ROUTE     "Analog Left Capture Route"
+#define MIXER_ANALOG_RIGHT_CAPTURE_ROUTE    "Analog Right Capture Route"
+#define MIXER_CAPTURE_PREAMPLIFIER_VOLUME   "Capture Preamplifier Volume"
+#define MIXER_CAPTURE_VOLUME                "Capture Volume"
+#define MIXER_AMIC_UL_VOLUME                "AMIC UL Volume"
+#define MIXER_AUDUL_VOICE_UL_VOLUME         "AUDUL Voice UL Volume"
+#define MIXER_DMIC1_UL_VOLUME               "DMIC1 UL Volume"
+#define MIXER_MUX_VX0                       "MUX_VX0"
+#define MIXER_MUX_VX1                       "MUX_VX1"
+#define MIXER_MUX_UL10                      "MUX_UL10"
+#define MIXER_MUX_UL11                      "MUX_UL11"
+
+/* Mixer control gain and route values */
+#define MIXER_ABE_GAIN_0DB                  120
+#define MIXER_PLAYBACK_HS_DAC               "HS DAC"
+#define MIXER_PLAYBACK_HF_DAC               "HF DAC"
+#define MIXER_MAIN_MIC                      "Main Mic"
+#define MIXER_SUB_MIC                       "Sub Mic"
+#define MIXER_HS_MIC                        "Headset Mic"
+#define MIXER_AMIC0                         "AMic0"
+#define MIXER_AMIC1                         "AMic1"
+#define MIXER_DMIC0L                        "DMic0L"
+#define MIXER_DMIC0R                        "DMic0R"
+#define MIXER_BT_LEFT                       "BT Left"
+#define MIXER_BT_RIGHT                      "BT Right"
+#define MIXER_AUX_LEFT                      "Aux/FM Left"
+#define MIXER_AUX_RIGHT                     "Aux/FM Right"
+#define MIXER_450HZ_HIGH_PASS               "450Hz High-pass"
+#define MIXER_0DB_HIGH_PASS                 "High-pass 0dB"
+#define MIXER_FLAT_RESPONSE                 "Flat Response"
+#define MIXER_4KHZ_LPF_0DB                  "4Khz LPF   0dB"
+
+
+/* ALSA cards for OMAP4 */
+#define CARD_OMAP4_ABE 0
+#define CARD_OMAP4_HDMI 1
+#define CARD_OMAP4_USB 2
+#define CARD_BLAZE_DEFAULT CARD_OMAP4_ABE
+
+/* ALSA ports for OMAP4 */
+#define PORT_MM 0
+#define PORT_MM2_UL 1
+#define PORT_VX 2
+#define PORT_TONES 3
+#define PORT_VIBRA 4
+#define PORT_MODEM 5
+#define PORT_MM_LP 6
+
+/* constraint imposed by ABE for CBPr mode: all period sizes must be multiples of 24 */
+#define ABE_BASE_FRAME_COUNT 24
+/* number of base blocks in a short period (low latency) */
+#define SHORT_PERIOD_MULTIPLIER 80  /* 40 ms */
+/* number of frames per short period (low latency) */
+#define SHORT_PERIOD_SIZE (ABE_BASE_FRAME_COUNT * SHORT_PERIOD_MULTIPLIER)
+/* number of short periods in a long period (low power) */
+#define LONG_PERIOD_MULTIPLIER 1  /* 40 ms */
+/* number of frames per long period (low power) */
+#define LONG_PERIOD_SIZE (SHORT_PERIOD_SIZE * LONG_PERIOD_MULTIPLIER)
+/* number of periods for playback */
+#define PLAYBACK_PERIOD_COUNT 4
+/* number of periods for capture */
+#define CAPTURE_PERIOD_COUNT 2
+/* minimum sleep time in out_write() when write threshold is not reached */
+#define MIN_WRITE_SLEEP_US 5000
+
+#define RESAMPLER_BUFFER_FRAMES (SHORT_PERIOD_SIZE * 2)
+#define RESAMPLER_BUFFER_SIZE (4 * RESAMPLER_BUFFER_FRAMES)
+
+#define DEFAULT_OUT_SAMPLING_RATE 44100
+
+/* sampling rate when using MM low power port */
+#define MM_LOW_POWER_SAMPLING_RATE 44100
+/* sampling rate when using MM full power port */
+#define MM_FULL_POWER_SAMPLING_RATE 48000
+/* 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
+
+/* conversions from dB to ABE and codec gains */
+#define DB_TO_ABE_GAIN(x) ((x) + MIXER_ABE_GAIN_0DB)
+#define DB_TO_CAPTURE_PREAMPLIFIER_VOLUME(x) (((x) + 6) / 6)
+#define DB_TO_CAPTURE_VOLUME(x) (((x) - 6) / 6)
+#define DB_TO_HEADSET_VOLUME(x) (((x) + 30) / 2)
+#define DB_TO_SPEAKER_VOLUME(x) (((x) + 52) / 2)
+#define DB_TO_EARPIECE_VOLUME(x) (((x) + 24) / 2)
+
+/* use-case specific mic volumes, all in dB */
+#define CAPTURE_DIGITAL_MIC_VOLUME            26
+#define CAPTURE_MAIN_MIC_VOLUME               15
+#define CAPTURE_SUB_MIC_VOLUME                15
+#define CAPTURE_HEADSET_MIC_VOLUME            15
+
+#define VOICE_RECOGNITION_MAIN_MIC_VOLUME     25
+#define VOICE_RECOGNITION_SUB_MIC_VOLUME      25
+#define VOICE_RECOGNITION_HEADSET_MIC_VOLUME  25
+
+#define CAMCORDER_MAIN_MIC_VOLUME             15
+#define CAMCORDER_SUB_MIC_VOLUME              15
+#define CAMCORDER_HEADSET_MIC_VOLUME          15
+
+#define VOIP_MAIN_MIC_VOLUME                  15
+#define VOIP_SUB_MIC_VOLUME                   15
+#define VOIP_HEADSET_MIC_VOLUME               15
+
+#define VOICE_CALL_MAIN_MIC_VOLUME            15
+#define VOICE_CALL_SUB_MIC_VOLUME             15
+#define VOICE_CALL_HEADSET_MIC_VOLUME         15
+
+/* use-case specific output volumes */
+#define NORMAL_SPEAKER_VOLUME                 0
+#define VOICE_CALL_SPEAKER_VOLUME             0
+
+#define HEADSET_VOLUME                        0
+#define HEADPHONE_VOLUME                      0 /* allow louder output for headphones */
+
+/* product-specific defines */
+#define PRODUCT_DEVICE_PROPERTY "ro.product.device"
+#define PRODUCT_DEVICE_BLAZE    "blaze"
+#define PRODUCT_DEVICE_TABLET   "blaze_tablet"
+#define PRODUCT_DEVICE_PANDA    "panda"
+
+enum supported_boards {
+    BLAZE,
+    TABLET,
+    PANDA
+};
+
+enum tty_modes {
+    TTY_MODE_OFF,
+    TTY_MODE_VCO,
+    TTY_MODE_HCO,
+    TTY_MODE_FULL
+};
+
+struct pcm_config pcm_config_mm = {
+    .channels = 2,
+    .rate = DEFAULT_OUT_SAMPLING_RATE,
+    .period_size = LONG_PERIOD_SIZE,
+    .period_count = PLAYBACK_PERIOD_COUNT,
+    .format = PCM_FORMAT_S16_LE,
+};
+
+struct pcm_config pcm_config_mm_ul = {
+    .channels = 2,
+    .rate = MM_FULL_POWER_SAMPLING_RATE,
+    .period_size = SHORT_PERIOD_SIZE,
+    .period_count = CAPTURE_PERIOD_COUNT,
+    .format = PCM_FORMAT_S16_LE,
+};
+
+struct pcm_config pcm_config_vx = {
+    .channels = 2,
+    .rate = VX_WB_SAMPLING_RATE,
+    .period_size = 160,
+    .period_count = 2,
+    .format = PCM_FORMAT_S16_LE,
+};
+
+#define MIN(x, y) ((x) > (y) ? (y) : (x))
+
+struct route_setting
+{
+    char *ctl_name;
+    int intval;
+    char *strval;
+};
+
+/* These are values that never change */
+struct route_setting defaults[] = {
+    /* general */
+    {
+        .ctl_name = MIXER_DL2_LEFT_EQUALIZER,
+        .strval = MIXER_0DB_HIGH_PASS,
+    },
+    {
+        .ctl_name = MIXER_DL2_RIGHT_EQUALIZER,
+        .strval = MIXER_0DB_HIGH_PASS,
+    },
+    {
+        .ctl_name = MIXER_DL1_EQUALIZER,
+        .strval = MIXER_FLAT_RESPONSE,
+    },
+    {
+        .ctl_name = MIXER_DL1_MEDIA_PLAYBACK_VOLUME,
+        .intval = MIXER_ABE_GAIN_0DB - 2,
+    },
+    {
+        .ctl_name = MIXER_DL2_MEDIA_PLAYBACK_VOLUME,
+        .intval = MIXER_ABE_GAIN_0DB - 2,
+    },
+    {
+        .ctl_name = MIXER_DL1_VOICE_PLAYBACK_VOLUME,
+        .intval = MIXER_ABE_GAIN_0DB,
+    },
+    {
+        .ctl_name = MIXER_DL2_VOICE_PLAYBACK_VOLUME,
+        .intval = MIXER_ABE_GAIN_0DB,
+    },
+    {
+        .ctl_name = MIXER_SDT_DL_VOLUME,
+        .intval = MIXER_ABE_GAIN_0DB,
+    },
+    {
+        .ctl_name = MIXER_EARPHONE_PLAYBACK_VOLUME,
+        .intval = DB_TO_EARPIECE_VOLUME(6),
+    },
+    {
+        .ctl_name = MIXER_AUDUL_VOICE_UL_VOLUME,
+        .intval = MIXER_ABE_GAIN_0DB,
+    },
+    {
+        .ctl_name = MIXER_CAPTURE_PREAMPLIFIER_VOLUME,
+        .intval = DB_TO_CAPTURE_PREAMPLIFIER_VOLUME(0),
+    },
+    {
+        .ctl_name = MIXER_CAPTURE_VOLUME,
+        .intval = DB_TO_CAPTURE_VOLUME(30),
+    },
+    {
+        .ctl_name = MIXER_SDT_UL_VOLUME,
+        .intval = MIXER_ABE_GAIN_0DB - 19,
+    },
+    {
+        .ctl_name = MIXER_SIDETONE_MIXER_CAPTURE,
+        .intval = 0,
+    },
+
+    /* headset */
+    {
+        .ctl_name = MIXER_SIDETONE_MIXER_PLAYBACK,
+        .intval = 1,
+    },
+    {
+        .ctl_name = MIXER_DL1_PDM_SWITCH,
+        .intval = 1,
+    },
+
+    /* bt */
+    {
+        .ctl_name = MIXER_BT_UL_VOLUME,
+        .intval = MIXER_ABE_GAIN_0DB,
+    },
+    {
+        .ctl_name = NULL,
+    },
+};
+
+struct route_setting hf_output[] = {
+    {
+        .ctl_name = MIXER_HF_LEFT_PLAYBACK,
+        .strval = MIXER_PLAYBACK_HF_DAC,
+    },
+    {
+        .ctl_name = MIXER_HF_RIGHT_PLAYBACK,
+        .strval = MIXER_PLAYBACK_HF_DAC,
+    },
+    {
+        .ctl_name = NULL,
+    },
+};
+
+struct route_setting hs_output[] = {
+    {
+        .ctl_name = MIXER_HS_LEFT_PLAYBACK,
+        .strval = MIXER_PLAYBACK_HS_DAC,
+    },
+    {
+        .ctl_name = MIXER_HS_RIGHT_PLAYBACK,
+        .strval = MIXER_PLAYBACK_HS_DAC,
+    },
+    {
+        .ctl_name = NULL,
+    },
+};
+
+struct route_setting fmtx_output_on[] ={
+   {
+        .ctl_name = MIXER_DL1_MM_EXT_SWITCH,
+        .intval = 1,
+   },
+   {
+        .ctl_name = MIXER_DL1_PDM_SWITCH,
+        .intval = 0,
+   },
+   {
+        .ctl_name = NULL,
+   },
+};
+
+struct route_setting fmtx_output_off[] ={
+   {
+        .ctl_name = MIXER_DL1_MM_EXT_SWITCH,
+        .intval = 0,
+   },
+   {
+        .ctl_name = MIXER_DL1_PDM_SWITCH,
+        .intval = 1,
+   },
+   {
+        .ctl_name = NULL,
+   },
+};
+
+/* MM UL front-end paths */
+struct route_setting mm_ul2_bt[] = {
+    {
+        .ctl_name = MIXER_MUX_UL10,
+        .strval = MIXER_BT_LEFT,
+    },
+    {
+        .ctl_name = MIXER_MUX_UL11,
+        .strval = MIXER_BT_LEFT,
+    },
+    {
+        .ctl_name = NULL,
+    },
+};
+
+struct route_setting mm_ul2_fmradio[] = {
+     {
+        .ctl_name = MIXER_MUX_UL10,
+        .strval = MIXER_AMIC1,
+     },
+     {
+        .ctl_name = MIXER_MUX_UL11,
+        .strval = MIXER_AMIC0,
+     },
+     {
+        .ctl_name =  MIXER_DL1_CAPTURE_PLAYBACK_VOLUME,  // Enable FM on wired headset only.
+        .intval = MIXER_ABE_GAIN_0DB,
+     },
+     {
+        .ctl_name = NULL,
+     },
+};
+
+struct route_setting mm_ul2_amic_left[] = {
+    {
+        .ctl_name = MIXER_MUX_UL10,
+        .strval = MIXER_AMIC0,
+    },
+    {
+        .ctl_name = MIXER_MUX_UL11,
+        .strval = MIXER_AMIC0,
+    },
+    {
+        .ctl_name = NULL,
+    },
+};
+
+struct route_setting mm_ul2_amic_right[] = {
+    {
+        .ctl_name = MIXER_MUX_UL10,
+        .strval = MIXER_AMIC1,
+    },
+    {
+        .ctl_name = MIXER_MUX_UL11,
+        .strval = MIXER_AMIC1,
+    },
+    {
+        .ctl_name = NULL,
+    },
+};
+
+struct route_setting mm_ul2_dmic0[] = {
+    {
+        .ctl_name = MIXER_MUX_UL10,
+        .strval = MIXER_DMIC0L,
+    },
+    {
+        .ctl_name = MIXER_MUX_UL11,
+        .strval = MIXER_DMIC0L,
+    },
+    {
+        .ctl_name = NULL,
+    },
+};
+
+/* VX UL front-end paths */
+struct route_setting vx_ul_amic_left[] = {
+    {
+        .ctl_name = MIXER_MUX_VX0,
+        .strval = MIXER_AMIC0,
+    },
+    {
+        .ctl_name = MIXER_MUX_VX1,
+        .strval = MIXER_AMIC0,
+    },
+    {
+        .ctl_name = MIXER_VOICE_CAPTURE_MIXER_CAPTURE,
+        .intval = 1,
+    },
+    {
+        .ctl_name = NULL,
+    },
+};
+
+struct route_setting vx_ul_amic_right[] = {
+    {
+        .ctl_name = MIXER_MUX_VX0,
+        .strval = MIXER_AMIC1,
+    },
+    {
+        .ctl_name = MIXER_MUX_VX1,
+        .strval = MIXER_AMIC1,
+    },
+    {
+        .ctl_name = MIXER_VOICE_CAPTURE_MIXER_CAPTURE,
+        .intval = 1,
+    },
+    {
+        .ctl_name = NULL,
+    },
+};
+struct route_setting vx_ul_dmic0[] = {
+    {
+        .ctl_name = MIXER_MUX_VX0,
+        .strval = MIXER_DMIC0L,
+    },
+    {
+        .ctl_name = MIXER_MUX_VX1,
+        .strval = MIXER_DMIC0L,
+    },
+    {
+        .ctl_name = MIXER_VOICE_CAPTURE_MIXER_CAPTURE,
+        .intval = 1,
+    },
+    {
+        .ctl_name = NULL,
+    },
+};
+
+struct route_setting vx_ul_bt[] = {
+    {
+        .ctl_name = MIXER_MUX_VX0,
+        .strval = MIXER_BT_LEFT,
+    },
+    {
+        .ctl_name = MIXER_MUX_VX1,
+        .strval = MIXER_BT_LEFT,
+    },
+    {
+        .ctl_name = MIXER_VOICE_CAPTURE_MIXER_CAPTURE,
+        .intval = 1,
+    },
+    {
+        .ctl_name = NULL,
+    },
+};
+
+struct buffer_remix;
+
+/* buffer_remix: functor for doing in-place buffer manipulations.
+ *
+ * NB. When remix_func is called, the memory at `buf` must be at least
+ * as large as frames * sample_size * MAX(in_chans, out_chans).
+ */
+struct buffer_remix {
+    void (*remix_func)(struct buffer_remix *data, void *buf, size_t frames);
+    size_t sample_size; /* size of one audio sample, in bytes */
+    size_t in_chans;    /* number of input channels */
+    size_t out_chans;   /* number of output channels */
+};
+
+
+struct mixer_ctls
+{
+    struct mixer_ctl *dl1_eq;
+    struct mixer_ctl *mm_dl1;
+    struct mixer_ctl *mm_dl2;
+    struct mixer_ctl *vx_dl1;
+    struct mixer_ctl *vx_dl2;
+    struct mixer_ctl *earpiece_enable;
+    struct mixer_ctl *dl2_mono;
+    struct mixer_ctl *dl1_mono;
+    struct mixer_ctl *dl1_headset;
+    struct mixer_ctl *dl1_bt;
+    struct mixer_ctl *left_capture;
+    struct mixer_ctl *right_capture;
+    struct mixer_ctl *amic_ul_volume;
+    struct mixer_ctl *dmic1_ul_volume;
+    struct mixer_ctl *voice_ul_volume;
+    struct mixer_ctl *sidetone_capture;
+    struct mixer_ctl *headset_volume;
+    struct mixer_ctl *speaker_volume;
+};
+
+struct omap4_audio_device {
+    struct audio_hw_device hw_device;
+
+    pthread_mutex_t lock;       /* see note below on mutex acquisition order */
+    struct mixer *mixer;
+    struct mixer_ctls mixer_ctls;
+    int mode;
+    int devices;
+    struct pcm *pcm_modem_dl;
+    struct pcm *pcm_modem_ul;
+    int in_call;
+    float voice_volume;
+    struct omap4_stream_in *active_input;
+    struct omap4_stream_out *active_output;
+    bool mic_mute;
+    int tty_mode;
+    int sidetone_capture;
+    int board_type;
+    struct echo_reference_itfe *echo_reference;
+    int input_requires_stereo;
+    bool low_power;
+    bool bluetooth_nrec;
+};
+
+struct omap4_stream_out {
+    struct audio_stream_out stream;
+
+    pthread_mutex_t lock;       /* see note below on mutex acquisition order */
+    struct pcm_config config;
+    struct pcm *pcm;
+    struct resampler_itfe *resampler;
+    char *buffer;
+    int standby;
+    struct echo_reference_itfe *echo_reference;
+    int write_threshold;
+    bool low_power;
+
+    struct omap4_audio_device *dev;
+};
+
+#define MAX_PREPROCESSORS 3 /* maximum one AGC + one NS + one AEC per input stream */
+
+struct omap4_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;
+    int16_t *buffer;
+    size_t frames_in;
+    unsigned int requested_rate;
+    int standby;
+    int source;
+    struct echo_reference_itfe *echo_reference;
+    bool need_echo_reference;
+    effect_handle_t preprocessors[MAX_PREPROCESSORS];
+    int num_preprocessors;
+    int16_t *proc_buf;
+    size_t proc_buf_size;
+    size_t proc_frames_in;
+    int16_t *ref_buf;
+    size_t ref_buf_size;
+    size_t ref_frames_in;
+    int read_status;
+    struct buffer_remix *remix_at_driver; /* adapt hw chan count to client */
+
+    struct omap4_audio_device *dev;
+};
+
+/**
+ * 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 omap4_audio_device *adev);
+static void select_input_device(struct omap4_audio_device *adev);
+static int adev_set_voice_volume(struct audio_hw_device *dev, float volume);
+static int do_input_standby(struct omap4_stream_in *in);
+static int do_output_standby(struct omap4_stream_out *out);
+
+/* Implementation of buffer_remix::remix_func that removes
+ * channels in place without doing any other processing.  The
+ * extra channels are truncated.
+ */
+static void remove_channels_from_buf(struct buffer_remix *data, void *buf, size_t frames)
+{
+    size_t samp_size, in_frame, out_frame;
+    size_t N, c;
+    char *s, *d;
+
+    LOGFUNC("%s(%p, %p, %d)", __FUNCTION__, data, buf, frames);
+    if (frames == 0)
+        return;
+
+
+    samp_size = data->sample_size;
+    in_frame = data->in_chans * samp_size;
+    out_frame = data->out_chans * samp_size;
+
+    if (out_frame >= in_frame) {
+        ALOGE("BUG: remove_channels_from_buf() can not add channels to a buffer.\n");
+        return;
+    }
+
+    N = frames - 1;
+    d = (char*)buf + out_frame;
+    s = (char*)buf + in_frame;
+
+    /* take the first several channels and
+     * truncate the rest
+     */
+    while (N--) {
+        for (c=0 ; c < out_frame ; ++c)
+            d[c] = s[c];
+        d += out_frame;
+        s += in_frame;
+    }
+}
+
+static void setup_stereo_to_mono_input_remix(struct omap4_stream_in *in)
+{
+    struct buffer_remix *br = (struct buffer_remix *)malloc(sizeof(struct buffer_remix));
+
+    LOGFUNC("%s(%p)", __FUNCTION__, in);
+
+
+    if (br) {
+        br->remix_func = remove_channels_from_buf;
+        br->sample_size = audio_stream_frame_size(&in->stream.common) / in->config.channels;
+        br->in_chans = 2;
+        br->out_chans = 1;
+    } else
+        ALOGE("Could not allocate memory for struct buffer_remix\n");
+
+    if (in->buffer) {
+        size_t chans = (br->in_chans > br->out_chans) ? br->in_chans : br->out_chans;
+        free(in->buffer);
+        in->buffer = malloc(in->config.period_size * br->sample_size * chans);
+        if (!in->buffer)
+            ALOGE("Could not reallocate memory for input buffer\n");
+    }
+
+    if (in->remix_at_driver)
+        free(in->remix_at_driver);
+    in->remix_at_driver = br;
+}
+
+static int get_boardtype(struct omap4_audio_device *adev)
+{
+    char board[PROPERTY_VALUE_MAX];
+    int status = 0;
+    int board_type = 0;
+
+    LOGFUNC("%s(%p)", __FUNCTION__, adev);
+
+    property_get(PRODUCT_DEVICE_PROPERTY, board, PRODUCT_DEVICE_BLAZE);
+    /* return true if the property matches the given value */
+    if(!strcmp(board, PRODUCT_DEVICE_BLAZE)) {
+            adev->board_type = BLAZE;
+          /*true on devices that must use sidetone capture */
+            adev->sidetone_capture = 1;
+    }
+    else if(!strcmp(board, PRODUCT_DEVICE_TABLET)) {
+            adev->board_type = TABLET;
+            adev->sidetone_capture = 0;
+    }
+    else if(!strcmp(board, PRODUCT_DEVICE_PANDA)) {
+            adev->board_type = PANDA;
+            adev->sidetone_capture = 0;
+    }
+    else
+        return -EINVAL;
+
+    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,
+                              int enable)
+{
+    struct mixer_ctl *ctl;
+    unsigned int i, j;
+
+    LOGFUNC("%s(%p, %p, %d)", __FUNCTION__, mixer, route, enable);
+
+    /* 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)
+            return -EINVAL;
+
+        if (route[i].strval) {
+            if (enable)
+                mixer_ctl_set_enum_by_string(ctl, route[i].strval);
+            else
+                mixer_ctl_set_enum_by_string(ctl, "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)
+                    mixer_ctl_set_value(ctl, j, route[i].intval);
+                else
+                    mixer_ctl_set_value(ctl, j, 0);
+            }
+        }
+        i++;
+    }
+
+    return 0;
+}
+
+static int start_call(struct omap4_audio_device *adev)
+{
+    ALOGE("Opening modem PCMs");
+    LOGFUNC("%s(%p)", __FUNCTION__, adev);
+
+    pcm_config_vx.rate = VX_NB_SAMPLING_RATE;
+
+    /* Open modem PCM channels */
+    if (adev->pcm_modem_dl == NULL) {
+        adev->pcm_modem_dl = pcm_open(0, 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(0, 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 omap4_audio_device *adev)
+{
+    ALOGE("Closing modem PCMs");
+    LOGFUNC("%s(%p)", __FUNCTION__, adev);
+
+    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;
+}
+
+static void set_eq_filter(struct omap4_audio_device *adev)
+{
+    LOGFUNC("%s(%p)", __FUNCTION__, adev);
+}
+
+static void set_incall_device(struct omap4_audio_device *adev)
+{
+	return;
+}
+
+static void set_input_volumes(struct omap4_audio_device *adev, int main_mic_on,
+                              int headset_mic_on, int sub_mic_on)
+{
+    unsigned int channel;
+    int volume = MIXER_ABE_GAIN_0DB;
+
+    LOGFUNC("%s(%p, %d, %d, %d)", __FUNCTION__, adev, main_mic_on,
+                                headset_mic_on, sub_mic_on);
+
+    if (adev->mode == AUDIO_MODE_IN_CALL) {
+        /* special case: don't look at input source for IN_CALL state */
+        volume = DB_TO_ABE_GAIN(main_mic_on ? VOICE_CALL_MAIN_MIC_VOLUME :
+                (headset_mic_on ? VOICE_CALL_HEADSET_MIC_VOLUME :
+                (sub_mic_on ? VOICE_CALL_SUB_MIC_VOLUME : 0)));
+    } else if (adev->active_input) {
+        /* determine input volume by use case */
+        switch (adev->active_input->source) {
+        case AUDIO_SOURCE_MIC: /* general capture */
+            if(adev->board_type == BLAZE) {
+                volume = DB_TO_ABE_GAIN(main_mic_on ? CAPTURE_MAIN_MIC_VOLUME :
+                    (headset_mic_on ? CAPTURE_HEADSET_MIC_VOLUME :
+                    (sub_mic_on ? CAPTURE_SUB_MIC_VOLUME : 0)));
+            }else if(adev->board_type == TABLET) {
+                volume = DB_TO_ABE_GAIN(main_mic_on ? CAPTURE_DIGITAL_MIC_VOLUME :
+                    (headset_mic_on ? CAPTURE_HEADSET_MIC_VOLUME :
+                     (sub_mic_on ? CAPTURE_SUB_MIC_VOLUME : 0)));
+            }
+            break;
+
+        case AUDIO_SOURCE_CAMCORDER:
+            volume = DB_TO_ABE_GAIN(main_mic_on ? CAMCORDER_MAIN_MIC_VOLUME :
+                    (headset_mic_on ? CAMCORDER_HEADSET_MIC_VOLUME :
+                    (sub_mic_on ? CAMCORDER_SUB_MIC_VOLUME : 0)));
+            break;
+
+        case AUDIO_SOURCE_VOICE_RECOGNITION:
+            volume = DB_TO_ABE_GAIN(main_mic_on ? VOICE_RECOGNITION_MAIN_MIC_VOLUME :
+                    (headset_mic_on ? VOICE_RECOGNITION_HEADSET_MIC_VOLUME :
+                    (sub_mic_on ? VOICE_RECOGNITION_SUB_MIC_VOLUME : 0)));
+            break;
+
+        case AUDIO_SOURCE_VOICE_COMMUNICATION: /* VoIP */
+            volume = DB_TO_ABE_GAIN(main_mic_on ? VOIP_MAIN_MIC_VOLUME :
+                    (headset_mic_on ? VOIP_HEADSET_MIC_VOLUME :
+                    (sub_mic_on ? VOIP_SUB_MIC_VOLUME : 0)));
+            break;
+
+        default:
+            /* nothing to do */
+            break;
+        }
+    }
+
+    for (channel = 0; channel < 2; channel++) {
+        if(adev->board_type == BLAZE) {
+            mixer_ctl_set_value(adev->mixer_ctls.amic_ul_volume, channel, volume);
+        }else if(adev->board_type == TABLET) {
+            if (headset_mic_on)
+                mixer_ctl_set_value(adev->mixer_ctls.amic_ul_volume, channel, volume);
+            else
+                mixer_ctl_set_value(adev->mixer_ctls.dmic1_ul_volume, channel, volume);
+        }
+    }
+}
+
+static void set_output_volumes(struct omap4_audio_device *adev)
+{
+    unsigned int channel;
+    int speaker_volume;
+    int headset_volume;
+
+    speaker_volume = adev->mode == AUDIO_MODE_IN_CALL ? VOICE_CALL_SPEAKER_VOLUME :
+                                                        NORMAL_SPEAKER_VOLUME;
+    headset_volume = adev->devices & AUDIO_DEVICE_OUT_WIRED_HEADSET ?
+                                                        HEADSET_VOLUME :
+                                                        HEADPHONE_VOLUME;
+
+    for (channel = 0; channel < 2; channel++) {
+        mixer_ctl_set_value(adev->mixer_ctls.speaker_volume, channel,
+            DB_TO_SPEAKER_VOLUME(speaker_volume));
+        mixer_ctl_set_value(adev->mixer_ctls.headset_volume, channel,
+            DB_TO_HEADSET_VOLUME(headset_volume));
+    }
+}
+
+static void force_all_standby(struct omap4_audio_device *adev)
+{
+    struct omap4_stream_in *in;
+    struct omap4_stream_out *out;
+
+    LOGFUNC("%s(%p)", __FUNCTION__, adev);
+
+    if (adev->active_output) {
+        out = adev->active_output;
+        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 omap4_audio_device *adev)
+{
+    LOGFUNC("%s(%p)", __FUNCTION__, 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->devices & AUDIO_DEVICE_OUT_ALL) == AUDIO_DEVICE_OUT_SPEAKER)
+                adev->devices = AUDIO_DEVICE_OUT_EARPIECE |
+                                AUDIO_DEVICE_IN_BUILTIN_MIC;
+            else
+                adev->devices &= ~AUDIO_DEVICE_OUT_SPEAKER;
+            select_output_device(adev);
+            start_call(adev);
+            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 omap4_audio_device *adev)
+{
+    int headset_on;
+    int headphone_on;
+    int speaker_on;
+    int earpiece_on;
+    int bt_on;
+    int dl1_on;
+    int fmtx_on;
+    int sidetone_capture_on = 0;
+    unsigned int channel, voice_ul_volume[2];
+
+    LOGFUNC("%s(%p)", __FUNCTION__, adev);
+
+    if(adev->board_type ==  PANDA) {
+        headset_on = 0;
+        speaker_on = 1;
+        mixer_ctl_set_value(adev->mixer_ctls.mm_dl1, 0, 1);
+        set_route_by_array(adev->mixer, hs_output, 1);
+        set_input_volumes(adev, 0,
+                        headset_on, speaker_on);
+    } else {
+        headset_on = adev->devices & AUDIO_DEVICE_OUT_WIRED_HEADSET;
+        headphone_on = adev->devices & AUDIO_DEVICE_OUT_WIRED_HEADPHONE;
+        speaker_on = adev->devices & AUDIO_DEVICE_OUT_SPEAKER;
+        earpiece_on = adev->devices & AUDIO_DEVICE_OUT_EARPIECE;
+        bt_on = adev->devices & AUDIO_DEVICE_OUT_ALL_SCO;
+
+        /* force rx path according to TTY mode when in call */
+        if (adev->mode == AUDIO_MODE_IN_CALL && !bt_on) {
+            switch(adev->tty_mode) {
+                case TTY_MODE_FULL:
+                case TTY_MODE_VCO:
+                    /* rx path to headphones */
+                    headphone_on = 1;
+                    headset_on = 0;
+                    speaker_on = 0;
+                    earpiece_on = 0;
+                    break;
+                case TTY_MODE_HCO:
+                    /* rx path to device speaker */
+                    headphone_on = 0;
+                    headset_on = 0;
+                    speaker_on = 1;
+                    earpiece_on = 0;
+                    break;
+                case TTY_MODE_OFF:
+                default:
+                    /* force speaker on when in call and HDMI is selected as voice DL audio
+                     * cannot be routed to HDMI by ABE */
+                    if (adev->devices & AUDIO_DEVICE_OUT_AUX_DIGITAL)
+                        speaker_on = 1;
+                    break;
+            }
+        }
+
+        dl1_on = headset_on | headphone_on | earpiece_on | bt_on;
+
+        /* Select front end */
+        mixer_ctl_set_value(adev->mixer_ctls.mm_dl2, 0, speaker_on);
+        mixer_ctl_set_value(adev->mixer_ctls.vx_dl2, 0,
+                            speaker_on && (adev->mode == AUDIO_MODE_IN_CALL));
+        mixer_ctl_set_value(adev->mixer_ctls.mm_dl1, 0, dl1_on);
+        mixer_ctl_set_value(adev->mixer_ctls.vx_dl1, 0,
+                            dl1_on && (adev->mode == AUDIO_MODE_IN_CALL));
+        /* Select back end */
+        mixer_ctl_set_value(adev->mixer_ctls.dl1_headset, 0,
+                            headset_on | headphone_on | earpiece_on);
+        mixer_ctl_set_value(adev->mixer_ctls.dl1_bt, 0, bt_on);
+        mixer_ctl_set_value(adev->mixer_ctls.earpiece_enable, 0, earpiece_on);
+
+        /* select output stage */
+        set_route_by_array(adev->mixer, hs_output, headset_on | headphone_on);
+        set_route_by_array(adev->mixer, hf_output, speaker_on);
+
+        set_route_by_array(adev->mixer, fmtx_output_off, 1);
+
+        set_output_volumes(adev);
+        /* Special case: select input path if in a call, otherwise
+           in_set_parameters is used to update the input route
+           todo: use sub mic for handsfree case */
+        if (adev->mode == AUDIO_MODE_IN_CALL) {
+            if (bt_on)
+                set_route_by_array(adev->mixer, vx_ul_bt, bt_on);
+            else {
+                /* force tx path according to TTY mode when in call */
+                switch(adev->tty_mode) {
+                    case TTY_MODE_FULL:
+                    case TTY_MODE_VCO:
+                        /* rx path to headphones */
+                        headphone_on = 1;
+                        headset_on = 0;
+                        speaker_on = 0;
+                        earpiece_on = 0;
+                        break;
+                    case TTY_MODE_HCO:
+                        /* rx path to device speaker */
+                        headphone_on = 0;
+                        headset_on = 0;
+                        speaker_on = 1;
+                        earpiece_on = 0;
+                        break;
+                    case TTY_MODE_OFF:
+                    default:
+                        /* force speaker on when in call and HDMI is selected as voice DL audio
+                         * cannot be routed to HDMI by ABE */
+                        if (adev->devices & AUDIO_DEVICE_OUT_AUX_DIGITAL)
+                            speaker_on = 1;
+                        break;
+                }
+            }
+
+            dl1_on = headset_on | headphone_on | earpiece_on | bt_on;
+
+            /* Select front end */
+            mixer_ctl_set_value(adev->mixer_ctls.mm_dl2, 0, speaker_on);
+            mixer_ctl_set_value(adev->mixer_ctls.vx_dl2, 0,
+                    speaker_on && (adev->mode == AUDIO_MODE_IN_CALL));
+            mixer_ctl_set_value(adev->mixer_ctls.mm_dl1, 0, dl1_on);
+            mixer_ctl_set_value(adev->mixer_ctls.vx_dl1, 0,
+                    dl1_on && (adev->mode == AUDIO_MODE_IN_CALL));
+            /* Select back end */
+            mixer_ctl_set_value(adev->mixer_ctls.dl1_headset, 0,
+                    headset_on | headphone_on | earpiece_on);
+            mixer_ctl_set_value(adev->mixer_ctls.dl1_bt, 0, bt_on);
+            mixer_ctl_set_value(adev->mixer_ctls.earpiece_enable, 0, earpiece_on);
+
+            /* select output stage */
+            set_route_by_array(adev->mixer, hs_output, headset_on | headphone_on);
+            set_route_by_array(adev->mixer, hf_output, speaker_on);
+
+            set_output_volumes(adev);
+            /* Special case: select input path if in a call, otherwise
+               in_set_parameters is used to update the input route
+               todo: use sub mic for handsfree case */
+            if (adev->mode == AUDIO_MODE_IN_CALL) {
+                if (bt_on)
+                    set_route_by_array(adev->mixer, vx_ul_bt, bt_on);
+                else {
+                    /* 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 || earpiece_on)
+                        set_route_by_array(adev->mixer, vx_ul_amic_left, 1);
+                    else if (speaker_on) {
+                        if(adev->board_type == BLAZE)
+                            set_route_by_array(adev->mixer, vx_ul_amic_right, 1);
+                        else if(adev->board_type == TABLET)
+                            set_route_by_array(adev->mixer, vx_ul_dmic0,1);
+                    }
+                    else {
+                        if(adev->board_type == BLAZE)
+                            set_route_by_array(adev->mixer, vx_ul_amic_left, 0);
+                        else if(adev->board_type == TABLET)
+                            set_route_by_array(adev->mixer, vx_ul_dmic0,0);
+                    }
+                    if(adev->board_type == BLAZE) {
+                        mixer_ctl_set_enum_by_string(adev->mixer_ctls.left_capture,
+                                (earpiece_on || headphone_on) ? MIXER_MAIN_MIC :
+                                (headset_on ? MIXER_HS_MIC : "Off"));
+                        mixer_ctl_set_enum_by_string(adev->mixer_ctls.right_capture,
+                                speaker_on ? MIXER_SUB_MIC : "Off");
+                    } else if(adev->board_type == TABLET) {
+                        mixer_ctl_set_enum_by_string(adev->mixer_ctls.left_capture,
+                                (headset_on ? MIXER_HS_MIC : "Off"));
+                        mixer_ctl_set_enum_by_string(adev->mixer_ctls.right_capture, "off");
+                    }
+
+                    set_input_volumes(adev, earpiece_on || headphone_on,
+                            headset_on, speaker_on);
+
+                    /* enable sidetone mixer capture if needed */
+                    sidetone_capture_on = earpiece_on && adev->sidetone_capture;
+                }
+                set_incall_device(adev);
+            }
+
+            mixer_ctl_set_value(adev->mixer_ctls.sidetone_capture, 0, sidetone_capture_on);
+        }
+    }
+}
+
+static void select_input_device(struct omap4_audio_device *adev)
+{
+    int headset_on = 0;
+    int main_mic_on = 0;
+    int sub_mic_on = 0;
+    int bt_on = adev->devices & AUDIO_DEVICE_IN_ALL_SCO;
+    int hw_is_stereo_only = 0;
+
+    LOGFUNC("%s(%p)", __FUNCTION__, adev);
+
+    if(adev->board_type == PANDA) {
+        /*panda only supports headset mic */
+        main_mic_on = 0;
+        headset_on = 1;
+        sub_mic_on = 0;
+        set_route_by_array(adev->mixer, mm_ul2_amic_left, 1);
+        /* Select back end */
+        mixer_ctl_set_enum_by_string(adev->mixer_ctls.right_capture, MIXER_HS_MIC);
+        mixer_ctl_set_enum_by_string(adev->mixer_ctls.left_capture, MIXER_HS_MIC);
+        set_input_volumes(adev, main_mic_on, headset_on, sub_mic_on);
+    } else {
+        if (!bt_on) {
+            if ((adev->mode != AUDIO_MODE_IN_CALL) && (adev->active_input != 0)) {
+                /* sub mic is used for camcorder or VoIP on speaker phone */
+                sub_mic_on = (adev->active_input->source == AUDIO_SOURCE_CAMCORDER) ||
+                    ((adev->devices & AUDIO_DEVICE_OUT_SPEAKER) &&
+                     (adev->active_input->source == AUDIO_SOURCE_VOICE_COMMUNICATION));
+            }
+            if (!sub_mic_on) {
+                headset_on = adev->devices & AUDIO_DEVICE_IN_WIRED_HEADSET;
+                main_mic_on = adev->devices & AUDIO_DEVICE_IN_BUILTIN_MIC;
+            }
+        }
+
+        /* TODO: check how capture is possible during voice calls or if
+         * both use cases are mutually exclusive.
+         */
+        if (bt_on)
+            set_route_by_array(adev->mixer, mm_ul2_bt, 1);
+        else {
+            if(adev->board_type == BLAZE) {
+                /* Select front end */
+                if (main_mic_on || headset_on)
+                    set_route_by_array(adev->mixer, mm_ul2_amic_left, 1);
+                else if (sub_mic_on)
+                    set_route_by_array(adev->mixer, mm_ul2_amic_right, 1);
+                else
+                    set_route_by_array(adev->mixer, mm_ul2_amic_left, 0);
+                /* Select back end */
+                mixer_ctl_set_enum_by_string(adev->mixer_ctls.right_capture,
+                        sub_mic_on ? MIXER_SUB_MIC : "Off");
+                mixer_ctl_set_enum_by_string(adev->mixer_ctls.left_capture,
+                        main_mic_on ? MIXER_MAIN_MIC :
+                        (headset_on ? MIXER_HS_MIC : "Off"));
+            } else if(adev->board_type == TABLET) {
+                /* Select front end */
+                if (headset_on)
+                    set_route_by_array(adev->mixer, mm_ul2_amic_left, 1);
+                else if (main_mic_on || sub_mic_on) {
+                    set_route_by_array(adev->mixer, mm_ul2_dmic0, 1);
+                    hw_is_stereo_only = 1;
+                } else {
+                    set_route_by_array(adev->mixer, mm_ul2_dmic0, 0);
+                    hw_is_stereo_only = 1;
+                }
+
+                /* Select back end */
+                mixer_ctl_set_enum_by_string(adev->mixer_ctls.right_capture, "off");
+                mixer_ctl_set_enum_by_string(adev->mixer_ctls.left_capture,
+                        main_mic_on ? "off" :
+                        (headset_on ? MIXER_HS_MIC : "Off"));
+            }
+        }
+
+        adev->input_requires_stereo = hw_is_stereo_only;
+
+        set_input_volumes(adev, main_mic_on, headset_on, sub_mic_on);
+    }
+}
+
+/* must be called with hw device and output stream mutexes locked */
+static int start_output_stream(struct omap4_stream_out *out)
+{
+    struct omap4_audio_device *adev = out->dev;
+    unsigned int card = CARD_BLAZE_DEFAULT;
+    unsigned int port = PORT_MM_LP;
+
+    LOGFUNC("%s(%p)", __FUNCTION__, adev);
+
+    adev->active_output = out;
+    if (adev->devices & AUDIO_DEVICE_OUT_ALL_SCO)
+        out->config.rate = MM_FULL_POWER_SAMPLING_RATE;
+    else
+        out->config.rate = DEFAULT_OUT_SAMPLING_RATE;
+
+    if (adev->mode != AUDIO_MODE_IN_CALL) {
+        /* FIXME: only works if only one output can be active at a time */
+        select_output_device(adev);
+    }
+
+    /* in the case of multiple devices, this will cause use of HDMI only */
+    if(adev->devices & AUDIO_DEVICE_OUT_AUX_DIGITAL) {
+        card = CARD_OMAP4_HDMI;
+        port = PORT_MM;
+    }
+    if((adev->devices & AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET) ||
+        (adev->devices & AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET)) {
+        card = CARD_OMAP4_USB;
+        port = PORT_MM;
+    }
+    /* default to low power:
+     *  NOTE: PCM_NOIRQ mode is required to dynamically scale avail_min
+     */
+    out->write_threshold = PLAYBACK_PERIOD_COUNT * LONG_PERIOD_SIZE;
+    out->config.start_threshold = SHORT_PERIOD_SIZE * 2;
+    out->config.avail_min = LONG_PERIOD_SIZE,
+    out->low_power = 1;
+
+    out->pcm = pcm_open(card, port, PCM_OUT | PCM_MMAP, &out->config);
+
+    if (!pcm_is_ready(out->pcm)) {
+        ALOGE("cannot open pcm_out driver: %s", pcm_get_error(out->pcm));
+        pcm_close(out->pcm);
+        adev->active_output = NULL;
+        return -ENOMEM;
+    }
+
+    if (adev->echo_reference != NULL)
+        out->echo_reference = adev->echo_reference;
+    if (out->resampler)
+        out->resampler->reset(out->resampler);
+
+    return 0;
+}
+
+static int check_input_parameters(uint32_t sample_rate, int format, int channel_count)
+{
+    LOGFUNC("%s(%d, %d, %d)", __FUNCTION__, sample_rate, format, 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, int format, int channel_count)
+{
+    size_t size;
+    size_t device_rate;
+
+    LOGFUNC("%s(%d, %d, %d)", __FUNCTION__, sample_rate, format, channel_count);
+
+    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_mm_ul.period_size * sample_rate) / pcm_config_mm_ul.rate;
+    size = ((size + 15) / 16) * 16;
+
+    return size * channel_count * sizeof(short);
+}
+
+static void add_echo_reference(struct omap4_stream_out *out,
+                               struct echo_reference_itfe *reference)
+{
+    LOGFUNC("%s(%p, %p)", __FUNCTION__, out, reference);
+
+    pthread_mutex_lock(&out->lock);
+    out->echo_reference = reference;
+    pthread_mutex_unlock(&out->lock);
+}
+
+static void remove_echo_reference(struct omap4_stream_out *out,
+                                  struct echo_reference_itfe *reference)
+{
+    LOGFUNC("%s(%p, %p)", __FUNCTION__, out, 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 omap4_audio_device *adev,
+                          struct echo_reference_itfe *reference)
+{
+    LOGFUNC("%s(%p, %p)", __FUNCTION__, adev, reference);
+
+    if (adev->echo_reference != NULL &&
+            reference == adev->echo_reference) {
+        if (adev->active_output != NULL)
+            remove_echo_reference(adev->active_output, reference);
+        release_echo_reference(reference);
+        adev->echo_reference = NULL;
+    }
+}
+
+static struct echo_reference_itfe *get_echo_reference(struct omap4_audio_device *adev,
+                                               audio_format_t format,
+                                               uint32_t channel_count,
+                                               uint32_t sampling_rate)
+{
+    LOGFUNC("%s(%p, 0x%08x, 0x%04x, %d)", __FUNCTION__, adev, format,
+                                                channel_count, sampling_rate);
+
+    put_echo_reference(adev, adev->echo_reference);
+    if (adev->active_output != NULL) {
+        struct audio_stream *stream = &adev->active_output->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->active_output, adev->echo_reference);
+    }
+    return adev->echo_reference;
+}
+
+static int get_playback_delay(struct omap4_stream_out *out,
+                       size_t frames,
+                       struct echo_reference_buffer *buffer)
+{
+    size_t kernel_frames;
+    int status;
+
+    LOGFUNC("%s(%p, %ul, %p)", __FUNCTION__, out, frames, buffer);
+
+    status = pcm_get_htimestamp(out->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("get_playback_delay(): pcm_get_htimestamp error,"
+                "setting playbackTimestamp to 0");
+        return status;
+    }
+
+    kernel_frames = pcm_get_buffer_size(out->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)
+{
+    LOGFUNC("%s(%p)", __FUNCTION__, stream);
+
+    return DEFAULT_OUT_SAMPLING_RATE;
+}
+
+static int out_set_sample_rate(struct audio_stream *stream, uint32_t rate)
+{
+    LOGFUNC("%s(%p, %d)", __FUNCTION__, stream, rate);
+
+    return 0;
+}
+
+static size_t out_get_buffer_size(const struct audio_stream *stream)
+{
+    struct omap4_stream_out *out = (struct omap4_stream_out *)stream;
+
+    LOGFUNC("%s(%p)", __FUNCTION__, 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 */
+    size_t size = (SHORT_PERIOD_SIZE * DEFAULT_OUT_SAMPLING_RATE) / out->config.rate;
+    size = ((size + 15) / 16) * 16;
+    return size * audio_stream_frame_size((struct audio_stream *)stream);
+}
+
+static uint32_t out_get_channels(const struct audio_stream *stream)
+{
+    LOGFUNC("%s(%p)", __FUNCTION__, stream);
+
+    return AUDIO_CHANNEL_OUT_STEREO;
+}
+
+static int out_get_format(const struct audio_stream *stream)
+{
+    LOGFUNC("%s(%p)", __FUNCTION__, stream);
+
+    return AUDIO_FORMAT_PCM_16_BIT;
+}
+
+static int out_set_format(struct audio_stream *stream, int format)
+{
+    LOGFUNC("%s(%p)", __FUNCTION__, stream);
+
+    return 0;
+}
+
+/* must be called with hw device and output stream mutexes locked */
+static int do_output_standby(struct omap4_stream_out *out)
+{
+    struct omap4_audio_device *adev = out->dev;
+
+    LOGFUNC("%s(%p)", __FUNCTION__, out);
+
+    if (!out->standby) {
+        pcm_close(out->pcm);
+        out->pcm = NULL;
+
+        adev->active_output = 0;
+
+        /* if in call, don't turn off the output stage. This will
+        be done when the call is ended */
+        if (adev->mode != AUDIO_MODE_IN_CALL) {
+            /* FIXME: only works if only one output can be active at a time */
+            set_route_by_array(adev->mixer, hs_output, 0);
+            set_route_by_array(adev->mixer, hf_output, 0);
+        }
+
+        /* stop writing to echo reference */
+        if (out->echo_reference != NULL) {
+            out->echo_reference->write(out->echo_reference, NULL);
+            out->echo_reference = NULL;
+        }
+        out->standby = 1;
+    }
+
+    return 0;
+}
+
+static int out_standby(struct audio_stream *stream)
+{
+    struct omap4_stream_out *out = (struct omap4_stream_out *)stream;
+    int status;
+
+    LOGFUNC("%s(%p)", __FUNCTION__, stream);
+
+    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)
+{
+    LOGFUNC("%s(%p, %d)", __FUNCTION__, stream, fd);
+
+    return 0;
+}
+
+static int out_set_parameters(struct audio_stream *stream, const char *kvpairs)
+{
+    struct omap4_stream_out *out = (struct omap4_stream_out *)stream;
+    struct omap4_audio_device *adev = out->dev;
+    struct omap4_stream_in *in;
+    struct str_parms *parms;
+    char *str;
+    char value[32];
+    int ret, val = 0;
+    bool force_input_standby = false;
+
+    LOGFUNC("%s(%p, %s)", __FUNCTION__, stream, kvpairs);
+
+    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->devices & AUDIO_DEVICE_OUT_ALL) != val) && (val != 0)) {
+            if (out == adev->active_output) {
+                do_output_standby(out);
+                /* 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 */
+                if ((val & AUDIO_DEVICE_OUT_AUX_DIGITAL) ^
+                    (adev->devices & AUDIO_DEVICE_OUT_AUX_DIGITAL))
+                        do_output_standby(out);
+            }
+            adev->devices &= ~AUDIO_DEVICE_OUT_ALL;
+            adev->devices |= 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)
+{
+    LOGFUNC("%s(%p, %s)", __FUNCTION__, stream, keys);
+
+    return strdup("");
+}
+
+static uint32_t out_get_latency(const struct audio_stream_out *stream)
+{
+    struct omap4_stream_out *out = (struct omap4_stream_out *)stream;
+
+    LOGFUNC("%s(%p)", __FUNCTION__, stream);
+    return (SHORT_PERIOD_SIZE * PLAYBACK_PERIOD_COUNT * 1000) / out->config.rate;
+}
+
+static int out_set_volume(struct audio_stream_out *stream, float left,
+                          float right)
+{
+    LOGFUNC("%s(%p, %f, %f)", __FUNCTION__, stream, left, right);
+
+    return -ENOSYS;
+}
+
+static ssize_t out_write(struct audio_stream_out *stream, const void* buffer,
+                         size_t bytes)
+{
+    int ret;
+    struct omap4_stream_out *out = (struct omap4_stream_out *)stream;
+    struct omap4_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 = RESAMPLER_BUFFER_SIZE / frame_size;
+    bool force_input_standby = false;
+    struct omap4_stream_in *in;
+    int kernel_frames;
+    void *buf;
+
+    LOGFUNC("%s(%p, %p, %d)", __FUNCTION__, stream, buffer, bytes);
+
+    /* 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(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);
+
+    /* only use resampler if required */
+    if (out->config.rate != DEFAULT_OUT_SAMPLING_RATE) {
+        if (out->resampler) {
+            out->resampler->resample_from_input(out->resampler,
+                    (int16_t *)buffer,
+                    &in_frames,
+                    (int16_t *)out->buffer,
+                    &out_frames);
+            buf = out->buffer;
+        }
+        else {
+            ret = create_resampler(DEFAULT_OUT_SAMPLING_RATE,
+                    MM_FULL_POWER_SAMPLING_RATE,
+                    2,
+                    RESAMPLER_QUALITY_DEFAULT,
+                    NULL,
+                    &out->resampler);
+            if (ret != 0)
+                goto exit;
+            out->buffer = malloc(RESAMPLER_BUFFER_SIZE); /* todo: allow for reallocing */
+        }
+
+    } else {
+        out_frames = in_frames;
+        buf = (void *)buffer;
+    }
+    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);
+    }
+
+    /* 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, (unsigned int *)&kernel_frames, &time_stamp) < 0)
+            break;
+        kernel_frames = pcm_get_buffer_size(out->pcm) - 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, (void *)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));
+    }
+
+    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 int out_get_render_position(const struct audio_stream_out *stream,
+                                   uint32_t *dsp_frames)
+{
+    LOGFUNC("%s(%p, %p)", __FUNCTION__, stream, dsp_frames);
+
+    return -EINVAL;
+}
+
+static int out_add_audio_effect(const struct audio_stream *stream, effect_handle_t effect)
+{
+    LOGFUNC("%s(%p, %p)", __FUNCTION__, stream, effect);
+
+    return 0;
+}
+
+static int out_remove_audio_effect(const struct audio_stream *stream, effect_handle_t effect)
+{
+    LOGFUNC("%s(%p, %p)", __FUNCTION__, stream, effect);
+
+    return 0;
+}
+
+/** audio_stream_in implementation **/
+
+/* must be called with hw device and input stream mutexes locked */
+static int start_input_stream(struct omap4_stream_in *in)
+{
+    int ret = 0;
+    unsigned int card = CARD_BLAZE_DEFAULT;
+    unsigned int device = PORT_MM2_UL;
+    struct omap4_audio_device *adev = in->dev;
+
+    LOGFUNC("%s(%p)", __FUNCTION__, in);
+
+    adev->active_input = in;
+
+    if (adev->mode != AUDIO_MODE_IN_CALL) {
+        adev->devices &= ~AUDIO_DEVICE_IN_ALL;
+        adev->devices |= in->device;
+        select_input_device(adev);
+    }
+
+    if (adev->input_requires_stereo && (in->config.channels == 1))
+        setup_stereo_to_mono_input_remix(in);
+
+    if (in->need_echo_reference && in->echo_reference == NULL)
+        in->echo_reference = get_echo_reference(adev,
+                                        AUDIO_FORMAT_PCM_16_BIT,
+                                        in->config.channels,
+                                        in->requested_rate);
+
+    /* this assumes routing is done previously */
+    if (in->remix_at_driver)
+        in->config.channels = in->remix_at_driver->in_chans;
+
+    in->pcm = pcm_open(card, device, PCM_IN, &in->config);
+    if (in->remix_at_driver)
+        in->config.channels = in->remix_at_driver->out_chans;
+    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;
+    }
+
+    /* if no supported sample rate is available, use the resampler */
+    if (in->resampler) {
+        in->resampler->reset(in->resampler);
+        in->frames_in = 0;
+    }
+    return 0;
+}
+
+static uint32_t in_get_sample_rate(const struct audio_stream *stream)
+{
+    struct omap4_stream_in *in = (struct omap4_stream_in *)stream;
+
+    LOGFUNC("%s(%p)", __FUNCTION__, stream);
+
+    return in->requested_rate;
+}
+
+static int in_set_sample_rate(struct audio_stream *stream, uint32_t rate)
+{
+    LOGFUNC("%s(%p, %d)", __FUNCTION__, stream, rate);
+
+    return 0;
+}
+
+static size_t in_get_buffer_size(const struct audio_stream *stream)
+{
+    struct omap4_stream_in *in = (struct omap4_stream_in *)stream;
+
+    LOGFUNC("%s(%p)", __FUNCTION__, stream);
+
+    return get_input_buffer_size(in->requested_rate,
+                                 AUDIO_FORMAT_PCM_16_BIT,
+                                 in->config.channels);
+}
+
+static uint32_t in_get_channels(const struct audio_stream *stream)
+{
+    struct omap4_stream_in *in = (struct omap4_stream_in *)stream;
+
+    LOGFUNC("%s(%p)", __FUNCTION__, stream);
+
+    if (in->config.channels == 1) {
+        return AUDIO_CHANNEL_IN_MONO;
+    } else {
+        return AUDIO_CHANNEL_IN_STEREO;
+    }
+}
+
+static int in_get_format(const struct audio_stream *stream)
+{
+    LOGFUNC("%s(%p)", __FUNCTION__, stream);
+
+    return AUDIO_FORMAT_PCM_16_BIT;
+}
+
+static int in_set_format(struct audio_stream *stream, int format)
+{
+    LOGFUNC("%s(%p, %d)", __FUNCTION__, stream, format);
+
+    return 0;
+}
+
+/* must be called with hw device and input stream mutexes locked */
+static int do_input_standby(struct omap4_stream_in *in)
+{
+    struct omap4_audio_device *adev = in->dev;
+
+    LOGFUNC("%s(%p)", __FUNCTION__, in);
+
+    if (!in->standby) {
+        pcm_close(in->pcm);
+        in->pcm = NULL;
+
+        adev->active_input = 0;
+        if (adev->mode != AUDIO_MODE_IN_CALL) {
+            adev->devices &= ~AUDIO_DEVICE_IN_ALL;
+            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 omap4_stream_in *in = (struct omap4_stream_in *)stream;
+    int status;
+
+    LOGFUNC("%s(%p)", __FUNCTION__, stream);
+
+    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)
+{
+    LOGFUNC("%s(%p, %d)", __FUNCTION__, stream, fd);
+
+    return 0;
+}
+static int in_fm_routing(struct audio_stream *stream)
+{
+    struct omap4_stream_in *in = (struct omap4_stream_in *)stream;
+    int ret;
+
+   LOGFUNC("%s(%p)", __FUNCTION__, stream);
+
+    if (in->standby) {
+        ret = start_input_stream(in);
+        if (ret == 0)
+            in->standby = 0;
+    }
+    return 0;
+}
+
+static int in_set_parameters(struct audio_stream *stream, const char *kvpairs)
+{
+    struct omap4_stream_in *in = (struct omap4_stream_in *)stream;
+    struct omap4_audio_device *adev = in->dev;
+    struct str_parms *parms;
+    char *str;
+    char value[32];
+    int ret, val = 0;
+    bool do_standby = false;
+
+    LOGFUNC("%s(%p, %s)", __FUNCTION__, stream, kvpairs);
+
+    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);
+        if ((in->device != val) && (val != 0)) {
+            in->device = val;
+            do_standby = true;
+        }
+    }
+
+    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)
+{
+    LOGFUNC("%s(%p, %s)", __FUNCTION__, stream, keys);
+
+    return strdup("");
+}
+
+static int in_set_gain(struct audio_stream_in *stream, float gain)
+{
+    LOGFUNC("%s(%p, %f)", __FUNCTION__, stream, gain);
+
+    return 0;
+}
+
+static void get_capture_delay(struct omap4_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;
+
+    LOGFUNC("%s(%p, %ul, %p)", __FUNCTION__, in, frames, buffer);
+
+    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("read get_capture_delay(): pcm_htimestamp error");
+        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 */
+    buf_delay = (long)(((int64_t)(in->frames_in + in->proc_frames_in) * 1000000000)
+                                    / in->config.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("get_capture_delay time_stamp = [%ld].[%ld], delay_ns: [%d],"
+         " kernel_delay:[%ld], buf_delay:[%ld], rsmp_delay:[%ld], kernel_frames:[%d], "
+         "in->frames_in:[%d], in->proc_frames_in:[%d], frames:[%d]",
+         buffer->time_stamp.tv_sec , buffer->time_stamp.tv_nsec, buffer->delay_ns,
+         kernel_delay, buf_delay, rsmp_delay, kernel_frames,
+         in->frames_in, in->proc_frames_in, frames);
+
+}
+
+static int32_t update_echo_reference(struct omap4_stream_in *in, size_t frames)
+{
+    struct echo_reference_buffer b;
+    b.delay_ns = 0;
+
+    LOGFUNC("%s(%p, %ul)", __FUNCTION__, in, frames);
+
+    ALOGV("update_echo_reference, frames = [%d], in->ref_frames_in = [%d],  "
+          "b.frame_count = [%d]",
+         frames, in->ref_frames_in, frames - in->ref_frames_in);
+    if (in->ref_frames_in < frames) {
+        if (in->ref_buf_size < frames) {
+            in->ref_buf_size = frames;
+            in->ref_buf = (int16_t *)realloc(in->ref_buf,
+                                             in->ref_buf_size *
+                                                 in->config.channels * sizeof(int16_t));
+        }
+
+        b.frame_count = frames - in->ref_frames_in;
+        b.raw = (void *)(in->ref_buf + in->ref_frames_in * in->config.channels);
+
+        get_capture_delay(in, frames, &b);
+
+        if (in->echo_reference->read(in->echo_reference, &b) == 0)
+        {
+            in->ref_frames_in += b.frame_count;
+            ALOGV("update_echo_reference: in->ref_frames_in:[%d], "
+                    "in->ref_buf_size:[%d], frames:[%d], b.frame_count:[%d]",
+                 in->ref_frames_in, in->ref_buf_size, frames, b.frame_count);
+        }
+    } else
+        ALOGW("update_echo_reference: NOT enough frames to read ref buffer");
+    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;
+
+    LOGFUNC("%s(%p, %p)", __FUNCTION__, handle, param);
+
+    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;
+
+    LOGFUNC("%s(%p, %d)", __FUNCTION__, handle, delay_us);
+
+    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 omap4_stream_in *in, size_t frames)
+{
+    /* read frames from echo reference buffer and update echo delay
+     * in->ref_frames_in 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;
+
+    LOGFUNC("%s(%p, %ul)", __FUNCTION__, in, frames);
+
+    if (in->ref_frames_in < frames)
+        frames = in->ref_frames_in;
+
+    buf.frameCount = frames;
+    buf.raw = in->ref_buf;
+
+    for (i = 0; i < in->num_preprocessors; i++) {
+        if ((*in->preprocessors[i])->process_reverse == NULL)
+            continue;
+
+        (*in->preprocessors[i])->process_reverse(in->preprocessors[i],
+                                               &buf,
+                                               NULL);
+        set_preprocessor_echo_delay(in->preprocessors[i], delay_us);
+    }
+
+    in->ref_frames_in -= buf.frameCount;
+    if (in->ref_frames_in) {
+        memcpy(in->ref_buf,
+               in->ref_buf + buf.frameCount * in->config.channels,
+               in->ref_frames_in * in->config.channels * sizeof(int16_t));
+    }
+}
+
+static int get_next_buffer(struct resampler_buffer_provider *buffer_provider,
+                                   struct resampler_buffer* buffer)
+{
+    struct omap4_stream_in *in;
+    struct buffer_remix *remix;
+    size_t hw_frame_size;
+
+    LOGFUNC("%s(%p, %p)", __FUNCTION__, buffer_provider, buffer);
+
+    if (buffer_provider == NULL || buffer == NULL)
+        return -EINVAL;
+
+    in = (struct omap4_stream_in *)((char *)buffer_provider -
+                                   offsetof(struct omap4_stream_in, buf_provider));
+    remix = in->remix_at_driver;
+
+    if (in->pcm == NULL) {
+        buffer->raw = NULL;
+        buffer->frame_count = 0;
+        in->read_status = -ENODEV;
+        return -ENODEV;
+    }
+
+    if (remix)
+        hw_frame_size = remix->in_chans * remix->sample_size;
+    else
+        hw_frame_size = audio_stream_frame_size(&in->stream.common);
+
+    if (in->frames_in == 0) {
+        in->read_status = pcm_read(in->pcm,
+                                   (void*)in->buffer,
+                                   in->config.period_size * hw_frame_size);
+        if (in->read_status != 0) {
+            ALOGE("get_next_buffer() pcm_read error %d", in->read_status);
+            buffer->raw = NULL;
+            buffer->frame_count = 0;
+            return in->read_status;
+        }
+        in->frames_in = in->config.period_size;
+
+        if (remix)
+            remix->remix_func(remix, in->buffer, in->frames_in);
+    }
+
+    buffer->frame_count = (buffer->frame_count > in->frames_in) ?
+                                in->frames_in : buffer->frame_count;
+    buffer->i16 = in->buffer + (in->config.period_size - in->frames_in) *
+                                                in->config.channels;
+
+    return in->read_status;
+
+}
+
+static void release_buffer(struct resampler_buffer_provider *buffer_provider,
+                                  struct resampler_buffer* buffer)
+{
+    struct omap4_stream_in *in;
+
+    LOGFUNC("%s(%p, %p)", __FUNCTION__, buffer_provider, buffer);
+
+    if (buffer_provider == NULL || buffer == NULL)
+        return;
+
+    in = (struct omap4_stream_in *)((char *)buffer_provider -
+                                   offsetof(struct omap4_stream_in, buf_provider));
+
+    in->frames_in -= 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 omap4_stream_in *in, void *buffer, ssize_t frames)
+{
+    ssize_t frames_wr = 0;
+    size_t frame_size;
+
+    LOGFUNC("%s(%p, %p, %ld)", __FUNCTION__, in, buffer, frames);
+
+    if (in->remix_at_driver)
+        frame_size = in->remix_at_driver->out_chans * in->remix_at_driver->sample_size;
+    else
+        frame_size = audio_stream_frame_size(&in->stream.common);
+
+    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 + frames_wr * frame_size),
+                    &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 +
+                        frames_wr * frame_size,
+                        buf.raw,
+                        buf.frame_count * frame_size);
+                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 omap4_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;
+
+    LOGFUNC("%s(%p, %p, %ld)", __FUNCTION__, in, buffer, frames);
+
+    while (frames_wr < frames) {
+        /* first reload enough frames at the end of process input buffer */
+        if (in->proc_frames_in < (size_t)frames) {
+            ssize_t frames_rd;
+
+            if (in->proc_buf_size < (size_t)frames) {
+                in->proc_buf_size = (size_t)frames;
+                in->proc_buf = (int16_t *)realloc(in->proc_buf,
+                                         in->proc_buf_size *
+                                             in->config.channels * sizeof(int16_t));
+                ALOGV("process_frames(): in->proc_buf %p size extended to %d frames",
+                     in->proc_buf, in->proc_buf_size);
+            }
+            frames_rd = read_frames(in,
+                                    in->proc_buf +
+                                        in->proc_frames_in * in->config.channels,
+                                    frames - in->proc_frames_in);
+            if (frames_rd < 0) {
+                frames_wr = frames_rd;
+                break;
+            }
+            in->proc_frames_in += frames_rd;
+        }
+
+        if (in->echo_reference != NULL)
+            push_echo_reference(in, in->proc_frames_in);
+
+         /* 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_frames_in;
+        in_buf.s16 = in->proc_buf;
+        out_buf.frameCount = frames - frames_wr;
+        out_buf.s16 = (int16_t *)buffer + frames_wr * in->config.channels;
+
+        for (i = 0; i < in->num_preprocessors; i++)
+            (*in->preprocessors[i])->process(in->preprocessors[i],
+                                               &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->proc_frames_in -= in_buf.frameCount;
+        if (in->proc_frames_in) {
+            memcpy(in->proc_buf,
+                   in->proc_buf + in_buf.frameCount * in->config.channels,
+                   in->proc_frames_in * in->config.channels * sizeof(int16_t));
+        }
+
+        /* if not enough frames were passed to process(), read more and retry. */
+        if (out_buf.frameCount == 0)
+            continue;
+
+        frames_wr += out_buf.frameCount;
+    }
+    return frames_wr;
+}
+
+static ssize_t in_read(struct audio_stream_in *stream, void* buffer,
+                       size_t bytes)
+{
+    int ret = 0;
+    struct omap4_stream_in *in = (struct omap4_stream_in *)stream;
+    struct omap4_audio_device *adev = in->dev;
+    size_t frames_rq = bytes / audio_stream_frame_size(&stream->common);
+
+    LOGFUNC("%s(%p, %p, %d)", __FUNCTION__, stream, buffer, bytes);
+
+    /* 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 || in->remix_at_driver)
+        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)
+{
+    LOGFUNC("%s(%p)", __FUNCTION__, stream);
+
+    return 0;
+}
+
+static int in_add_audio_effect(const struct audio_stream *stream,
+                               effect_handle_t effect)
+{
+    struct omap4_stream_in *in = (struct omap4_stream_in *)stream;
+    int status;
+    effect_descriptor_t desc;
+
+    LOGFUNC("%s(%p, %p)", __FUNCTION__, stream, effect);
+
+    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;
+
+    if (memcmp(&desc.type, FX_IID_AEC, sizeof(effect_uuid_t)) == 0) {
+        in->need_echo_reference = true;
+        do_input_standby(in);
+    }
+
+exit:
+
+    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 omap4_stream_in *in = (struct omap4_stream_in *)stream;
+    int i;
+    int status = -EINVAL;
+    bool found = false;
+    effect_descriptor_t desc;
+
+    LOGFUNC("%s(%p, %p)", __FUNCTION__, stream, effect);
+
+    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 (found) {
+            in->preprocessors[i - 1] = in->preprocessors[i];
+            continue;
+        }
+        if (in->preprocessors[i] == effect) {
+            in->preprocessors[i] = NULL;
+            status = 0;
+            found = true;
+        }
+    }
+
+    if (status != 0)
+        goto exit;
+
+    in->num_preprocessors--;
+
+    status = (*effect)->get_descriptor(effect, &desc);
+    if (status != 0)
+        goto exit;
+    if (memcmp(&desc.type, FX_IID_AEC, sizeof(effect_uuid_t)) == 0) {
+        in->need_echo_reference = false;
+        do_input_standby(in);
+    }
+
+exit:
+
+    pthread_mutex_unlock(&in->lock);
+    pthread_mutex_unlock(&in->dev->lock);
+    return status;
+}
+
+
+static int adev_open_output_stream(struct audio_hw_device *dev,
+                                   uint32_t devices, int *format,
+                                   uint32_t *channels, uint32_t *sample_rate,
+                                   struct audio_stream_out **stream_out)
+{
+    struct omap4_audio_device *ladev = (struct omap4_audio_device *)dev;
+    struct omap4_stream_out *out;
+    int ret;
+
+    LOGFUNC("%s(%p, 0x%04x,%d, 0x%04x, %d, %p)", __FUNCTION__, dev, devices,
+                        *format, *channels, *sample_rate, stream_out);
+
+    out = (struct omap4_stream_out *)calloc(1, sizeof(struct omap4_stream_out));
+    if (!out)
+        return -ENOMEM;
+    if (devices & AUDIO_DEVICE_OUT_ALL_SCO) {
+        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->buffer = malloc(RESAMPLER_BUFFER_SIZE); /* todo: allow for reallocing */
+    } else
+       out->resampler = NULL;
+
+    out->stream.common.get_sample_rate = out_get_sample_rate;
+    out->stream.common.set_sample_rate = out_set_sample_rate;
+    out->stream.common.get_buffer_size = out_get_buffer_size;
+    out->stream.common.get_channels = out_get_channels;
+    out->stream.common.get_format = out_get_format;
+    out->stream.common.set_format = out_set_format;
+    out->stream.common.standby = out_standby;
+    out->stream.common.dump = out_dump;
+    out->stream.common.set_parameters = out_set_parameters;
+    out->stream.common.get_parameters = out_get_parameters;
+    out->stream.common.add_audio_effect = out_add_audio_effect;
+    out->stream.common.remove_audio_effect = out_remove_audio_effect;
+    out->stream.get_latency = out_get_latency;
+    out->stream.set_volume = out_set_volume;
+    out->stream.write = out_write;
+    out->stream.get_render_position = out_get_render_position;
+
+    out->config = pcm_config_mm;
+
+    out->dev = ladev;
+    out->standby = 1;
+
+    /* FIXME: when we support multiple output devices, we will want to
+     * do the following:
+     * adev->devices &= ~AUDIO_DEVICE_OUT_ALL;
+     * adev->devices |= 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. */
+
+    *format = out_get_format(&out->stream.common);
+    *channels = out_get_channels(&out->stream.common);
+    *sample_rate = out_get_sample_rate(&out->stream.common);
+
+    *stream_out = &out->stream;
+    return 0;
+
+err_open:
+    free(out);
+    *stream_out = NULL;
+    return ret;
+}
+
+static void adev_close_output_stream(struct audio_hw_device *dev,
+                                     struct audio_stream_out *stream)
+{
+    struct omap4_stream_out *out = (struct omap4_stream_out *)stream;
+
+    LOGFUNC("%s(%p, %p)", __FUNCTION__, dev, stream);
+
+    out_standby(&stream->common);
+    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 omap4_audio_device *adev = (struct omap4_audio_device *)dev;
+    struct str_parms *parms;
+    char *str;
+    char value[32];
+    int ret;
+
+    LOGFUNC("%s(%p, %s)", __FUNCTION__, dev, kvpairs);
+
+    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_state", value, sizeof(value));
+    if (ret >= 0) {
+        if (strcmp(value, AUDIO_PARAMETER_VALUE_ON) == 0)
+            adev->low_power = false;
+        else
+            adev->low_power = true;
+    }
+
+    str_parms_destroy(parms);
+    return ret;
+}
+
+static char * adev_get_parameters(const struct audio_hw_device *dev,
+                                  const char *keys)
+{
+    LOGFUNC("%s(%p, %s)", __FUNCTION__, dev, keys);
+
+    return strdup("");
+}
+
+static int adev_init_check(const struct audio_hw_device *dev)
+{
+    LOGFUNC("%s(%p)", __FUNCTION__, dev);
+    return 0;
+}
+
+static int adev_set_voice_volume(struct audio_hw_device *dev, float volume)
+{
+    struct omap4_audio_device *adev = (struct omap4_audio_device *)dev;
+
+    LOGFUNC("%s(%p, %f)", __FUNCTION__, dev, volume);
+    adev->voice_volume = volume;
+
+    return 0;
+}
+
+static int adev_set_master_volume(struct audio_hw_device *dev, float volume)
+{
+    LOGFUNC("%s(%p, %f)", __FUNCTION__, dev, volume);
+
+    return -ENOSYS;
+}
+
+static int adev_set_mode(struct audio_hw_device *dev, int mode)
+{
+    struct omap4_audio_device *adev = (struct omap4_audio_device *)dev;
+
+    LOGFUNC("%s(%p, %d)", __FUNCTION__, dev, mode);
+
+    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 omap4_audio_device *adev = (struct omap4_audio_device *)dev;
+
+    LOGFUNC("%s(%p, %d)", __FUNCTION__, dev, state);
+
+    adev->mic_mute = state;
+
+    return 0;
+}
+
+static int adev_get_mic_mute(const struct audio_hw_device *dev, bool *state)
+{
+    struct omap4_audio_device *adev = (struct omap4_audio_device *)dev;
+
+    LOGFUNC("%s(%p, %p)", __FUNCTION__, dev, state);
+
+    *state = adev->mic_mute;
+
+    return 0;
+}
+
+static size_t adev_get_input_buffer_size(const struct audio_hw_device *dev,
+                                         uint32_t sample_rate, int format,
+                                         int channel_count)
+{
+    size_t size;
+
+    LOGFUNC("%s(%p, %d, %d, %d)", __FUNCTION__, dev, sample_rate,
+                                format, channel_count);
+
+    if (check_input_parameters(sample_rate, format, channel_count) != 0) {
+        return 0;
+    }
+
+    return get_input_buffer_size(sample_rate, format, channel_count);
+}
+
+static int adev_open_input_stream(struct audio_hw_device *dev, uint32_t devices,
+                                  int *format, uint32_t *channel_mask,
+                                  uint32_t *sample_rate,
+                                  audio_in_acoustics_t acoustics,
+                                  struct audio_stream_in **stream_in)
+{
+    struct omap4_audio_device *ladev = (struct omap4_audio_device *)dev;
+    struct omap4_stream_in *in;
+    int ret;
+    int channel_count = popcount(*channel_mask);
+    /*audioflinger expects return variable to be NULL incase of failure */
+    *stream_in = NULL;
+    LOGFUNC("%s(%p, 0x%04x, %d, 0x%04x, %d, 0x%04x, %p)", __FUNCTION__, dev,
+        devices, *format, *channel_mask, *sample_rate, acoustics, stream_in);
+
+    if (check_input_parameters(*sample_rate, *format, channel_count) != 0)
+        return -EINVAL;
+
+    in = (struct omap4_stream_in *)calloc(1, sizeof(struct omap4_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->remix_at_driver = NULL;
+
+    in->requested_rate = *sample_rate;
+
+    memcpy(&in->config, &pcm_config_mm_ul, sizeof(pcm_config_mm_ul));
+    in->config.channels = channel_count;
+
+    in->buffer = malloc(2 * in->config.period_size * audio_stream_frame_size(&in->stream.common));
+    if (!in->buffer) {
+        ret = -ENOMEM;
+        goto err;
+    }
+
+    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;
+
+    *stream_in = &in->stream;
+    return 0;
+
+err:
+    if (in->resampler)
+        release_resampler(in->resampler);
+
+    free(in);
+    *stream_in = NULL;
+    return ret;
+}
+
+static void adev_close_input_stream(struct audio_hw_device *dev,
+                                   struct audio_stream_in *stream)
+{
+    struct omap4_stream_in *in = (struct omap4_stream_in *)stream;
+
+    LOGFUNC("%s(%p, %p)", __FUNCTION__, dev, stream);
+
+    in_standby(&stream->common);
+
+    if (in->resampler) {
+        free(in->buffer);
+        release_resampler(in->resampler);
+    }
+
+    if (in->remix_at_driver)
+        free(in->remix_at_driver);
+
+    free(stream);
+    return;
+}
+
+static int adev_dump(const audio_hw_device_t *device, int fd)
+{
+    LOGFUNC("%s(%p, %d)", __FUNCTION__, device, fd);
+
+    return 0;
+}
+
+static int adev_close(hw_device_t *device)
+{
+    struct omap4_audio_device *adev = (struct omap4_audio_device *)device;
+
+    LOGFUNC("%s(%p)", __FUNCTION__, device);
+
+    mixer_close(adev->mixer);
+    free(device);
+    return 0;
+}
+
+static uint32_t adev_get_supported_devices(const struct audio_hw_device *dev)
+{
+    LOGFUNC("%s(%p)", __FUNCTION__, dev);
+
+    return (/* OUT */
+            AUDIO_DEVICE_OUT_EARPIECE |
+            AUDIO_DEVICE_OUT_SPEAKER |
+            AUDIO_DEVICE_OUT_WIRED_HEADSET |
+            AUDIO_DEVICE_OUT_WIRED_HEADPHONE |
+            AUDIO_DEVICE_OUT_AUX_DIGITAL |
+            AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET |
+            AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET |
+            AUDIO_DEVICE_OUT_ALL_SCO |
+            AUDIO_DEVICE_OUT_DEFAULT |
+            /* IN */
+            AUDIO_DEVICE_IN_COMMUNICATION |
+            AUDIO_DEVICE_IN_AMBIENT |
+            AUDIO_DEVICE_IN_BUILTIN_MIC |
+            AUDIO_DEVICE_IN_WIRED_HEADSET |
+            AUDIO_DEVICE_IN_AUX_DIGITAL |
+            AUDIO_DEVICE_IN_BACK_MIC |
+            AUDIO_DEVICE_IN_ALL_SCO |
+            AUDIO_DEVICE_IN_DEFAULT);
+}
+
+static int adev_open(const hw_module_t* module, const char* name,
+                     hw_device_t** device)
+{
+    struct omap4_audio_device *adev;
+    int ret;
+    pthread_mutexattr_t mta;
+
+    LOGFUNC("%s(%p, %s, %p)", __FUNCTION__, module, name, device);
+
+    if (strcmp(name, AUDIO_HARDWARE_INTERFACE) != 0)
+        return -EINVAL;
+
+    adev = calloc(1, sizeof(struct omap4_audio_device));
+    if (!adev)
+        return -ENOMEM;
+
+    adev->hw_device.common.tag = HARDWARE_DEVICE_TAG;
+    adev->hw_device.common.version = 0;
+    adev->hw_device.common.module = (struct hw_module_t *) module;
+    adev->hw_device.common.close = adev_close;
+
+    adev->hw_device.get_supported_devices = adev_get_supported_devices;
+    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(0);
+    if (!adev->mixer) {
+        free(adev);
+        ALOGE("Unable to open the mixer, aborting.");
+        return -EINVAL;
+    }
+
+    adev->mixer_ctls.dl1_eq = mixer_get_ctl_by_name(adev->mixer,
+                                           MIXER_DL1_EQUALIZER);
+    adev->mixer_ctls.mm_dl1 = mixer_get_ctl_by_name(adev->mixer,
+                                           MIXER_DL1_MIXER_MULTIMEDIA);
+    adev->mixer_ctls.vx_dl1 = mixer_get_ctl_by_name(adev->mixer,
+                                           MIXER_DL1_MIXER_VOICE);
+    adev->mixer_ctls.mm_dl2 = mixer_get_ctl_by_name(adev->mixer,
+                                           MIXER_DL2_MIXER_MULTIMEDIA);
+    adev->mixer_ctls.vx_dl2 = mixer_get_ctl_by_name(adev->mixer,
+                                           MIXER_DL2_MIXER_VOICE);
+    adev->mixer_ctls.dl2_mono = mixer_get_ctl_by_name(adev->mixer,
+                                           MIXER_DL2_MONO_MIXER);
+    adev->mixer_ctls.dl1_mono = mixer_get_ctl_by_name(adev->mixer,
+                                           MIXER_DL1_MONO_MIXER);
+    adev->mixer_ctls.dl1_headset = mixer_get_ctl_by_name(adev->mixer,
+                                           MIXER_DL1_PDM_SWITCH);
+    adev->mixer_ctls.dl1_bt = mixer_get_ctl_by_name(adev->mixer,
+                                           MIXER_DL1_BT_VX_SWITCH);
+    adev->mixer_ctls.earpiece_enable = mixer_get_ctl_by_name(adev->mixer,
+                                           MIXER_EARPHONE_ENABLE_SWITCH);
+    adev->mixer_ctls.left_capture = mixer_get_ctl_by_name(adev->mixer,
+                                           MIXER_ANALOG_LEFT_CAPTURE_ROUTE);
+    adev->mixer_ctls.right_capture = mixer_get_ctl_by_name(adev->mixer,
+                                           MIXER_ANALOG_RIGHT_CAPTURE_ROUTE);
+    adev->mixer_ctls.amic_ul_volume = mixer_get_ctl_by_name(adev->mixer,
+                                           MIXER_AMIC_UL_VOLUME);
+    adev->mixer_ctls.dmic1_ul_volume = mixer_get_ctl_by_name(adev->mixer,
+                                           MIXER_DMIC1_UL_VOLUME);
+    adev->mixer_ctls.voice_ul_volume = mixer_get_ctl_by_name(adev->mixer,
+                                           MIXER_AUDUL_VOICE_UL_VOLUME);
+    adev->mixer_ctls.sidetone_capture = mixer_get_ctl_by_name(adev->mixer,
+                                           MIXER_SIDETONE_MIXER_CAPTURE);
+    adev->mixer_ctls.headset_volume = mixer_get_ctl_by_name(adev->mixer,
+                                           MIXER_HEADSET_PLAYBACK_VOLUME);
+    adev->mixer_ctls.speaker_volume = mixer_get_ctl_by_name(adev->mixer,
+                                           MIXER_HANDSFREE_PLAYBACK_VOLUME);
+
+    if (!adev->mixer_ctls.mm_dl1 || !adev->mixer_ctls.vx_dl1 ||
+        !adev->mixer_ctls.mm_dl2 || !adev->mixer_ctls.vx_dl2 ||
+        !adev->mixer_ctls.dl2_mono || !adev->mixer_ctls.dl1_mono ||
+        !adev->mixer_ctls.dl1_headset || !adev->mixer_ctls.dl1_bt ||
+        !adev->mixer_ctls.earpiece_enable || !adev->mixer_ctls.left_capture ||
+        !adev->mixer_ctls.right_capture || !adev->mixer_ctls.amic_ul_volume ||
+        !adev->mixer_ctls.sidetone_capture || !adev->mixer_ctls.headset_volume ||
+        !adev->mixer_ctls.speaker_volume || !adev->mixer_ctls.dmic1_ul_volume ||
+        !adev->mixer_ctls.dl1_eq || !adev->mixer_ctls.voice_ul_volume) {
+        mixer_close(adev->mixer);
+        free(adev);
+        ALOGE("Unable to locate all mixer controls, aborting.");
+        return -EINVAL;
+    }
+
+    pthread_mutexattr_init(&mta);
+    pthread_mutexattr_settype(&mta, PTHREAD_MUTEX_NORMAL);
+    pthread_mutex_init(&adev->lock, &mta);
+    pthread_mutexattr_destroy(&mta);
+
+    /* Set the default route before the PCM stream is opened */
+    pthread_mutex_lock(&adev->lock);
+    set_route_by_array(adev->mixer, defaults, 1);
+    adev->mode = AUDIO_MODE_NORMAL;
+    adev->devices = AUDIO_DEVICE_OUT_SPEAKER | AUDIO_DEVICE_IN_BUILTIN_MIC;
+    select_output_device(adev);
+
+    adev->pcm_modem_dl = NULL;
+    adev->pcm_modem_ul = NULL;
+    adev->voice_volume = 1.0f;
+    adev->tty_mode = TTY_MODE_OFF;
+    if(get_boardtype(adev)) {
+        pthread_mutex_unlock(&adev->lock);
+        mixer_close(adev->mixer);
+        free(adev);
+        ALOGE("Unsupported boardtype, aborting.");
+        return -EINVAL;
+    }
+
+    adev->input_requires_stereo = 0;
+    adev->bluetooth_nrec = true;
+    pthread_mutex_unlock(&adev->lock);
+    *device = &adev->hw_device.common;
+
+    return 0;
+}
+
+static struct hw_module_methods_t hal_module_methods = {
+    .open = adev_open,
+};
+
+struct audio_module HAL_MODULE_INFO_SYM = {
+    .common = {
+        .tag = HARDWARE_MODULE_TAG,
+        .version_major = 1,
+        .version_minor = 0,
+        .id = AUDIO_HARDWARE_MODULE_ID,
+        .name = "OMAP4 audio HW HAL",
+        .author = "Texas Instruments",
+        .methods = &hal_module_methods,
+    },
+};
diff --git a/audio/test/.gitignore b/audio/test/.gitignore
new file mode 100644
index 0000000..62b9ead
--- /dev/null
+++ b/audio/test/.gitignore
@@ -0,0 +1,2 @@
+*.pyc
+test-log-*.txt
diff --git a/audio/test/TestFlinger.py b/audio/test/TestFlinger.py
new file mode 100644
index 0000000..219d21a
--- /dev/null
+++ b/audio/test/TestFlinger.py
@@ -0,0 +1,257 @@
+#!/usr/bin/env python
+###
+### Copyright (C) 2011 Texas Instruments
+###
+### 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.
+###
+
+"""TestFlinger meta-test execution framework
+
+When writing a master test script that runs several scripts, this module
+can be used to execute those tests in a detached process (sandbox).
+Thus, if the test case fails by a segfault or timeout, this can be
+detected and the upper-level script simply moves on to the next script.
+"""
+
+import os
+import time
+import subprocess
+import sys
+import time
+
+g_default_timeout = 300
+
+class TestCase:
+    """Test running wrapper object."""
+
+    def __init__(self, TestDict = {}, Logfile = None):
+        """Set up the test runner object.
+
+        TestDict: dictionary with the test properties.  (string: value).  The
+                  recognized properties are:
+
+                  filename - name of executable test file
+                      Type: string
+                      Required: yes
+
+                  args - command line arguments for test
+                      Type: list of strings, or None
+                      Required: no
+                      Default: None
+
+                  timeout - upper limit on execution time (secs).  If test takes
+                      this long to run, then it is deemed a failure
+                      Type: integer
+                      Required: no
+                      Default: TestFlinger.g_default_timeout (typ. 300 sec)
+
+                  expect-fail - If the test is expected to fail (return non-zero)
+                      in order to pass, set this to True
+                      Type: bool
+                      Required: no
+                      Default: False
+
+                  expect-signal If the test is expected to fail because of
+                      a signal (e.g. SIGTERM, SIGSEGV) then this is considered success
+                      Type: bool
+                      Required: no
+                      Default: False
+
+        Logfile: a file object where stdout/stderr for the tests should be dumped.
+            If null, then no logging will be done.  (See also TestFlinger.setup_logfile()
+            and TestFlinger.close_logfile().
+        """
+        global g_default_timeout
+
+        self._program = None
+        self._args = None
+        self._timeout = g_default_timeout # Default timeout
+        self._verdict = None
+        self._expect_fail = False
+        self._expect_signal = False
+        self._logfile = Logfile
+
+        self._proc = None
+        self._time_expire = None
+
+        self._program = TestDict['filename']
+        if 'args' in TestDict:
+            self._args = TestDict['args']
+        if 'timeout' in TestDict and TestDict['timeout'] is not None:
+            self._timeout = TestDict['timeout']
+        if 'expect-fail' in TestDict and TestDict['expect-fail'] is not None:
+            self._expect_fail = TestDict['expect-fail']
+        if 'expect-signal' in TestDict and TestDict['expect-signal'] is not None:
+            self._expect_signal = TestDict['expect-signal']
+
+    def __del__(self):
+        pass
+
+    def start(self):
+        """Starts the test in another process.  Returns True if the
+        test was successfully spawned.  False if there was an error.
+        """
+
+        command = os.path.abspath(self._program)
+
+        if not os.path.exists(command):
+            print "ERROR: The program to execute does not exist (%s)" % (command,)
+            return False
+
+        timestamp = time.strftime("%Y.%m.%d %H:%M:%S")
+        now = time.time()
+        self._time_expire = self._timeout + now
+        self._kill_timeout = False
+
+        self._log_write("====================================================================\n")
+        self._log_write("BEGINNG TEST '%s' at %s\n" % (self._program, timestamp))
+        self._log_write("--------------------------------------------------------------------\n")
+        self._log_flush()
+
+        self._proc = subprocess.Popen(args=command, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+
+        return (self._proc is not None)
+
+    def wait(self):
+        """Blocks until the test completes or times out, whichever
+        comes first.  If test fails, returns False.  Otherwise returns
+        true.
+        """
+
+        if self._proc is None:
+            print "ERROR: Test was never started"
+            return False
+
+        self._proc.poll()
+        while (time.time() < self._time_expire) and (self._proc.poll() is None):
+            self._process_logs()
+            time.sleep(.5)
+
+        if self._proc.returncode is None:
+            self.kill()
+            return False
+
+        self._process_logs()
+        self._finalize_log()
+
+        return True
+
+    def kill(self):
+        """Kill the currently running test (if there is one).
+        """
+
+        if self._proc is None:
+            print "WARNING: killing a test was never started"
+            return False
+
+        self._kill_timeout = True
+        self._proc.terminate()
+        time.sleep(2)
+        self._proc.kill()
+        self._log_write("\nKilling process by request...\n")
+        self._log_flush()
+        self._finalize_log()
+
+        return True
+
+
+    def verdict(self):
+        """Returns a string, either 'PASS', 'FAIL', 'FAIL/TIMEOUT', or 'FAIL/SIGNAL(n)
+        '"""
+        self._proc.poll()
+
+        rc = self._proc.returncode
+
+        if rc is None:
+            print "ERROR: test is still running"
+
+        if self._kill_timeout:
+            return "FAIL/TIMOUT"
+
+        if rc < 0 and self._expect_signal:
+            return "PASS"
+        elif rc < 0:
+            return "FAIL/SIGNAL(%d)" % (-rc,)
+
+        if self._expect_fail:
+            if rc != 0:
+                return "PASS"
+            else:
+                return "FAIL"
+        else:
+            if rc == 0:
+                return "PASS"
+            else:
+                return "FAIL"
+
+    def _process_logs(self):
+        if self._logfile is not None:
+            data = self._proc.stdout.read()
+            self._logfile.write(data)
+            self._logfile.flush()
+
+    def _finalize_log(self):
+        timestamp = time.strftime("%Y.%m.%d %H:%M:%S")
+        self._log_write("--------------------------------------------------------------------\n")
+        self._log_write("ENDING TEST '%s' at %s\n" % (self._program, timestamp))
+        self._log_write("====================================================================\n")
+        self._log_flush()
+
+    def _log_write(self, data):
+        if self._logfile is not None:
+            self._logfile.write(data)
+
+    def _log_flush(self):
+        if self._logfile is not None:
+            self._logfile.flush()
+
+def setup_logfile(override_logfile_name = None):
+    """Open a logfile and prepare it for use with TestFlinger logging.
+    The filename will be generated based on the current date/time.
+
+    If override_logfile_name is not None, then that filename will be
+    used instead.
+
+    See also: close_logfile()
+    """
+
+    tmpfile = None
+    if override_logfile_name is not None:
+        tmpfile = override_logfile_name
+        if os.path.exists(tmpfile):
+            os.unlink(tmpfile)
+    else:
+        tmpfile = time.strftime("test-log-%Y.%m.%d.%H%M%S.txt")
+        while os.path.exists(tmpfile):
+            tmpfile = time.strftime("test-log-%Y.%m.%d.%H%M%S.txt")
+    fobj = open(tmpfile, 'wt')
+    print "Logging to", tmpfile
+    timestamp = time.strftime("%Y.%m.%d %H:%M:%S")
+    fobj.write("BEGINNING TEST SET %s\n" % (timestamp,))
+    fobj.write("====================================================================\n")
+    return fobj
+
+def close_logfile(fobj):
+    """Convenience function for closing a TestFlinger log file.
+
+    fobj: an open and writeable file object
+
+    See also : setup_logfile()
+    """
+
+    timestamp = time.strftime("%Y.%m.%d %H:%M:%S")
+    fobj.write("====================================================================\n")
+    fobj.write("CLOSING TEST SET %s\n" % (timestamp,))
+
+if __name__ == "__main__":
+    pass
diff --git a/audio/test/music-monkey.py b/audio/test/music-monkey.py
new file mode 100755
index 0000000..945f112
--- /dev/null
+++ b/audio/test/music-monkey.py
@@ -0,0 +1,94 @@
+#!/usr/bin/env monkeyrunner
+# Imports the monkeyrunner modules used by this program
+from com.android.monkeyrunner import MonkeyRunner, MonkeyDevice
+import time
+import random
+
+# Connects to the current device, returning a MonkeyDevice object
+device = MonkeyRunner.waitForConnection()
+
+# sets a variable with the package's internal name
+package = 'com.android.music'
+
+# sets a variable with the name of an Activity in the package
+activity = 'com.android.music.MediaPlaybackActivity'
+
+# sets the name of the component to start
+runComponent = package + '/' + activity
+
+# Runs the component
+device.startActivity(component=runComponent)
+
+def play():
+	print "push play"
+	device.press('KEYCODE_MEDIA_PLAY','DOWN_AND_UP')
+
+def pause():
+	print "push pause"
+	device.press('KEYCODE_MEDIA_PAUSE', 'DOWN_AND_UP')
+
+def skip_next(n):
+	print "skip the next", n, "tracks"
+	for x in range(n):
+		device.press('KEYCODE_MEDIA_NEXT', 'DOWN_AND_UP')
+
+def skip_previous(n):
+        print "skip backwards", n, "tracks"
+        for x in range(n):
+                device.press('KEYCODE_MEDIA_PREVIOUS', 'DOWN_AND_UP')
+
+def ff(n):
+	print "fast forward for", n, "seconds"
+	if n < 1:
+		device.press('KEYCODE_MEDIA_FAST_FORWARD', 'DOWN_AND_UP')
+	else:
+		device.press('KEYCODE_MEDIA_FAST_FORWARD', 'DOWN')
+		time.sleep(n)
+		device.press('KEYCODE_MEDIA_FAST_FORWARD', 'UP')
+
+def rw(n):
+        print "rewind for", n, "seconds"
+        if n < 1:
+                device.press('KEYCODE_MEDIA_REWIND', 'DOWN_AND_UP')
+        else:
+                device.press('KEYCODE_MEDIA_REWIND', 'DOWN') 
+                time.sleep(n)
+                device.press('KEYCODE_MEDIA_REWIND', 'UP')
+
+
+
+## main flow starts here
+actions = ['play', 'pause', 'skip_next', 'skip_prev', 'ff', 'rw', 'wait']
+
+start_time = time.time()
+run_time = 60 * 15
+end_time = start_time + run_time
+
+while True:
+	action_id = random.randint(1, 10)
+	action_time = random.randint(1, 15)
+	if action_id == 1:
+		play()
+	elif action_id == 2:
+		pause()
+	elif action_id == 3:
+		skip_next(action_time)
+	elif action_id == 4:
+		skip_previous(action_time)
+	elif action_id == 5:
+		pass
+		#ff(action_time)
+	elif action_id == 6:
+		pass
+		#rw(action_time)
+	elif action_id == 7:
+		time.sleep(action_time)
+	else:
+		pass
+
+	time.sleep(1)
+
+	if time.time() > end_time:
+		break
+
+pause()
diff --git a/audio/test/run-tests.py b/audio/test/run-tests.py
new file mode 100755
index 0000000..84af812
--- /dev/null
+++ b/audio/test/run-tests.py
@@ -0,0 +1,183 @@
+#!/usr/bin/python
+###
+### Copyright (C) 2011 Texas Instruments
+###
+### 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.
+###
+
+#
+# TI Android Audio team master test runner script.
+#
+
+import sys, os, os.path, time
+import signal
+import TestFlinger
+
+###
+### Configure tests here
+###
+### Each element is a dict that will be passed to the TestCase
+### constructor.  See the documentation for TestCase.__init__()
+### for key/value pair documentation.
+###
+
+g_tests = [
+    # These first tests are simply to verify that the test
+    # framework is working.
+    { 'filename': '/bin/true',
+      'args':     None,
+      'timeout':  None,
+      'expect-fail': False, },
+    { 'filename': '/bin/false',
+      'args':     None,
+      'timeout':  None,
+      'expect-fail': True, },
+    { 'filename': 'test-signal',
+      'args':     None,
+      'timeout':  None,
+      'expect-signal': True, },
+
+    # Actual product tests here
+
+    { 'filename': 'music-monkey.py',
+      'timeout':  60*30, },
+    ]
+
+# These executables are known to be needed for the tests.
+# They must be available explicitly or in the current PATH.
+
+g_required_executables = [
+    '/bin/bash',
+    '/bin/false',
+    '/bin/sh',
+    '/bin/true',
+    'adb',
+    'bash',
+    'monkeyrunner',
+    'pgrep',
+    'python',
+    'sh',
+    ]
+
+# These are files that
+g_required_files = [
+    ]
+
+###
+### Signal handler
+###
+
+g_tcase = None
+def sigint_handler(signum, stack_frame):
+    global g_tcase
+    print
+    print "Received SIGINT, aborting current test..."
+    if g_tcase is not None:
+        g_tcase.kill()
+    sys.exit(signum)
+
+###
+### Utility functions
+###
+
+def check_for_executable(name):
+    """Checks that executable is available (either explicitly or in the PATH
+    returns True if so, False if not.
+    """
+    err = os.system("which %s > /dev/null" % (name,))
+    return (err == 0)
+
+def check_for_file(name):
+    return os.path.exists(name)
+
+def check_adb_server_running():
+    """Checks that the ADB server is currently running.  Returns  True if
+    so, False otherwise.  Uses the pgrep command.
+    """
+    err = os.system("pgrep adb > /dev/null")
+    return (err == 0)
+
+def sanity_check():
+    """Checks that required binaries are available and functioning in a sane manner,
+    returns True if so, False if something is missing.  It checks that things like
+    adb and monkeyrunner are in the path
+    """
+
+    rv = True
+    for F in g_required_executables:
+        ok = check_for_executable(F)
+        if not ok:
+            print "ERROR: cannot find the executable '%s'" % (F,)
+            rv = False
+    for F in g_required_files:
+        ok = check_for_file(F)
+        if not ok:
+            print "ERROR: cannot find the file '%s'" % (F,)
+            rv = False
+
+    ok = check_adb_server_running()
+    if not ok:
+        print "ERROR: the adb server must be running before starting tests"
+        rv = False
+
+    return rv
+
+###
+### Main test script
+###
+
+def main(argv = []):
+    global g_tests, g_tcase
+
+    g_tcase = None
+    signal.signal(signal.SIGINT, sigint_handler)
+
+    if not sanity_check():
+        return 1
+
+    err = os.system("adb root")
+    if err != 0:
+        print "ERROR: could not set adb to run as root.  Aborting."
+        return 1
+
+    time.sleep(2.0) # Wait for device to restart its server
+
+    log = TestFlinger.setup_logfile()
+
+    for N in g_tests:
+        tcase = TestFlinger.TestCase(N, log)
+        g_tcase = tcase
+
+        ok = tcase.start()
+        if not ok:
+            print "ERROR: could not start test '%s'.  Skipping" % (N['filename'],)
+
+        if ok:
+            tcase.wait()
+            verdict = tcase.verdict()
+            verdict = N['filename'] + ": " + verdict
+        else:
+            verdict = N['filename'] + ": FAIL"
+
+        print verdict
+        log.write("\n" + verdict + "\n")
+        log.flush()
+
+    TestFlinger.close_logfile(log)
+
+    return 0
+
+if __name__ == "__main__":
+    rv = main(sys.argv)
+    sys.exit(rv)
+
diff --git a/audio/test/test-signal b/audio/test/test-signal
new file mode 100755
index 0000000..b689151
--- /dev/null
+++ b/audio/test/test-signal
@@ -0,0 +1,13 @@
+#!/bin/bash
+
+cat <<EOF
+Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do
+eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad
+minim veniam, quis nostrud exercitation ullamco laboris nisi ut
+aliquip ex ea commodo consequat. Duis aute irure dolor in
+reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla
+pariatur. Excepteur sint occaecat cupidatat non proident, sunt in
+culpa qui officia deserunt mollit anim id est laborum.
+EOF
+
+kill -TERM $$
diff --git a/bootloader.bin b/bootloader.bin
index 9e23319..b67ec81 100644
--- a/bootloader.bin
+++ b/bootloader.bin
Binary files differ
diff --git a/device.mk b/device.mk
index 3a436f8..dff6ff1 100644
--- a/device.mk
+++ b/device.mk
@@ -26,7 +26,9 @@
 	device/ti/panda/init.omap4pandaboard.usb.rc:root/init.omap4pandaboard.usb.rc \
 	device/ti/panda/ueventd.omap4pandaboard.rc:root/ueventd.omap4pandaboard.rc \
 	device/ti/panda/media_profiles.xml:system/etc/media_profiles.xml \
+	device/ti/panda/android.hardware.bluetooth.xml:system/etc/permissions/android.hardware.bluetooth.xml \
 	frameworks/base/data/etc/android.hardware.usb.host.xml:system/etc/permissions/android.hardware.usb.host.xml \
+	frameworks/base/data/etc/android.hardware.wifi.xml:system/etc/permissions/android.hardware.wifi.xml \
 	frameworks/base/data/etc/android.hardware.usb.accessory.xml:system/etc/permissions/android.hardware.usb.accessory.xml
 
 PRODUCT_PACKAGES := \
@@ -34,6 +36,7 @@
 	com.android.future.usb.accessory
 
 PRODUCT_PROPERTY_OVERRIDES := \
+	wifi.interface=wlan0 \
 	hwui.render_dirty_regions=false
 
 PRODUCT_CHARACTERISTICS := tablet,nosdcard
@@ -41,17 +44,39 @@
 DEVICE_PACKAGE_OVERLAYS := \
     device/ti/panda/overlay
 
+#HWC Hal
+PRODUCT_PACKAGES += \
+    hwcomposer.omap4
+
 PRODUCT_TAGS += dalvik.gc.type-precise
 
 PRODUCT_PACKAGES += \
 	librs_jni \
 	com.android.future.usb.accessory
 
+PRODUCT_PACKAGES += \
+	audio.primary.panda \
+	audio.a2dp.default \
+	libaudioutils
+
+
+PRODUCT_PACKAGES += \
+	dhcpcd.conf \
+	TQS_D_1.7.ini \
+	calibrator
+
 # Filesystem management tools
 PRODUCT_PACKAGES += \
 	make_ext4fs
 
+# BlueZ test tools
+PRODUCT_PACKAGES += \
+	hciconfig \
+	hcitool
+
 $(call inherit-product-if-exists, vendor/ti/panda/device-vendor.mk)
 $(call inherit-product, frameworks/base/build/tablet-dalvik-heap.mk)
 $(call inherit-product, hardware/ti/omap4xxx/omap4.mk)
 $(call inherit-product-if-exists, vendor/ti/proprietary/omap4/ti-omap4-vendor.mk)
+$(call inherit-product, device/ti/panda/wl12xx/ti-wl12xx-vendor.mk)
+$(call inherit-product, device/ti/panda/wl12xx/ti-wpan-products.mk)
diff --git a/full_panda.mk b/full_panda.mk
index 9a1f7fd..46b188f 100644
--- a/full_panda.mk
+++ b/full_panda.mk
@@ -41,4 +41,5 @@
 PRODUCT_NAME := full_panda
 PRODUCT_DEVICE := panda
 PRODUCT_BRAND := Android
-PRODUCT_MODEL := Full AOSP on Panda
+PRODUCT_MODEL := Panda
+PRODUCT_MANUFACTURER := Texas_Instruments_Inc
diff --git a/init.omap4pandaboard.rc b/init.omap4pandaboard.rc
index 6947e81..928c4b9 100644
--- a/init.omap4pandaboard.rc
+++ b/init.omap4pandaboard.rc
@@ -13,6 +13,7 @@
     setprop vold.post_fs_data_done 1
     mkdir /data/misc/dhcp 0770 dhcp dhcp
     chown dhcp dhcp /data/misc/dhcp
+    mkdir /data/misc/wifi/sockets 0770 wifi wifi
 
 on boot
 	mount debugfs /sys/kernel/debug /sys/kernel/debug
@@ -23,6 +24,13 @@
 	mount ext4 /dev/block/platform/omap/omap_hsmmc.0/by-name/userdata /data wait noatime nosuid nodev
 	mount ext4 /dev/block/platform/omap/omap_hsmmc.0/by-name/cache /cache wait noatime nosuid nodev
 
+# change permissions for Bluetooth/FM/GPS
+    chmod 0600 /sys/class/rfkill/rfkill0/state
+    chown bluetooth bluetooth /sys/class/rfkill/rfkill0/state
+    chmod 0600 /dev/ttyO1
+    chown bluetooth bluetooth /dev/ttyO1
+
+
 # take a wakelock on boot until PM is working
 	write /sys/power/wake_lock hack
 
@@ -32,8 +40,35 @@
 	group root
 	oneshot
 
+#shared transport user space mgr service for Bluetooth, FM and GPS
+service uim /system/bin/uim-sysfs
+	class core
+	user bluetooth
+	group bluetooth net_bt_admin
+
 # 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 will be created with user and group media_rw (1023)
 service sdcard /system/bin/sdcard /data/media 1023 1023
     class late_start
+
+service wpa_supplicant /system/bin/wpa_supplicant -Dnl80211 -iwlan0 -c/data/misc/wifi/wpa_supplicant.conf -dd
+    socket wpa_wlan0 dgram 660 wifi wifi
+    disabled
+    oneshot
+
+service dhcpcd_wlan0 /system/bin/dhcpcd -ABKL
+    disabled
+    oneshot
+
+service iprenew_wlan0 /system/bin/dhcpcd -n
+    disabled
+    oneshot
+
+service dhcpcd_eth0 /system/bin/dhcpcd -ABKL
+    disabled
+    oneshot
+
+service iprenew_eth0 /system/bin/dhcpcd -n
+    disabled
+    oneshot
diff --git a/init.omap4pandaboard.usb.rc b/init.omap4pandaboard.usb.rc
index 1db210a..6ea54b0 100644
--- a/init.omap4pandaboard.usb.rc
+++ b/init.omap4pandaboard.usb.rc
@@ -3,5 +3,16 @@
     write /sys/class/android_usb/android0/iProduct $ro.product.model
     write /sys/class/android_usb/android0/iSerial $ro.serialno
 
-# currently Panda only supports the adb only configuration,
-# which is configured in init.rc
\ No newline at end of file
+on property:sys.usb.config=none
+    stop adbd
+    write /sys/class/android_usb/android0/enable 0
+    write /sys/class/android_usb/android0/bDeviceClass 0
+    setprop sys.usb.state $sys.usb.config
+
+on property:sys.usb.config=adb
+    write /sys/class/android_usb/android0/enable 0
+    write /sys/class/android_usb/android0/idVendor 0451
+    write /sys/class/android_usb/android0/idProduct D101
+    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/kernel b/kernel
index dc4886a..1fbfc0e 100755
--- a/kernel
+++ b/kernel
Binary files differ
diff --git a/overlay/frameworks/base/core/res/res/values/config.xml b/overlay/frameworks/base/core/res/res/values/config.xml
index cc86b46..9fd3f40 100644
--- a/overlay/frameworks/base/core/res/res/values/config.xml
+++ b/overlay/frameworks/base/core/res/res/values/config.xml
@@ -27,22 +27,28 @@
     <!-- This device does not allow sms service. -->
     <bool name="config_sms_capable">false</bool>
 
+    <!-- Boolean indicating where bluetooth is always powered on but kept at
+         low power mode -->
+    <bool translatable="false" name="config_bluetooth_adapter_quick_switch">false</bool>
+
     <!-- XXXXX NOTE THE FOLLOWING RESOURCES USE THE WRONG NAMING CONVENTION.
          Please don't copy them, copy anything else. -->
 
-    <!-- This string array should be overridden by the device to present a list of network
-         attributes.  This is used by the connectivity manager to decide which networks can coexist
-         based on the hardware -->
-    <!-- An Array of "[Connection name],[ConnectivityManager connection type],
-         [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
+        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 translatable="false" name="networkAttributes">
         <item>"wifi,1,1,1,-1,true"</item>
-        <item>"bluetooth,7,7,0,-1,true"</item>
-        <item>"ethernet,9,9,2,-1,true"</item>
+       <item>"mobile,0,0,0,-1,true"</item>
+        <item>"mobile_mms,2,0,2,60000,true"</item>
+        <item>"mobile_supl,3,0,2,60000,true"</item>
+        <item>"mobile_hipri,5,0,3,60000,true"</item>
+        <item>"mobile_fota,10,0,2,60000,true"</item>
+        <item>"mobile_ims,11,0,2,60000,true"</item>
+        <item>"mobile_cbs,12,0,2,60000,true"</item>
+        <item>"wifi_p2p,13,1,0,-1,true"</item>
+        <item>"ethernet,9,9,0,-1,true"</item>
     </string-array>
 
     <!-- This string array should be overridden by the device to present a list of radio
@@ -52,8 +58,9 @@
                       [# simultaneous connection types]"  -->
     <string-array translatable="false" name="radioAttributes">
         <item>"1,1"</item>
-        <item>"7,1"</item>
+        <item>"0,1"</item>
         <item>"9,1"</item>
     </string-array>
 
+
 </resources>
diff --git a/self-extractors/imgtec/LICENSE b/self-extractors/imgtec/LICENSE
index 08ac7aa..4a64a5c 100644
--- a/self-extractors/imgtec/LICENSE
+++ b/self-extractors/imgtec/LICENSE
@@ -22,8 +22,8 @@
           open-source contribution developed by You, designed to operate with
           Android that does not contain or incorporate any of the Software.
 
-      c.  The term "Authorized Android Enabled Device" means the device
-          known as the Nexus S only.
+      c.  The term "Authorized Android Enabled Device" means only the device
+          identified on the site from which You downloaded the Software.
           The term "Software" means the Licensor's proprietary software and
           libraries in object code form, designed for use on the Authorized
           Android Enabled Device.
@@ -42,7 +42,7 @@
           machine-readable (i.e., object code) form and the Documentation for
           non-commercial use on an Authorized Android Enabled Device and
           non-commercial redistribution of the Authorized Android Enabled
-          Device Software (the “Limited Purpose”). You may grant your end users
+          Device Software (the "Limited Purpose"). You may grant your end users
           the right to use the Software for the Limited Purpose. The license to
           the Software granted to You hereunder is solely for the Limited
           Purpose set forth in this section, and the Software shall not be used
diff --git a/ueventd.omap4pandaboard.rc b/ueventd.omap4pandaboard.rc
index e69de29..a5de1c1 100644
--- a/ueventd.omap4pandaboard.rc
+++ b/ueventd.omap4pandaboard.rc
@@ -0,0 +1,9 @@
+/dev/pvrsrvkm             0666   system     system
+
+#for DSSCOMP
+/dev/dsscomp              0666   system     system
+/dev/tiler                0666   system     system
+
+#for SYSLINK
+/dev/rpmsg-omx0           0666   system     system
+/dev/rpmsg-omx1           0666   system     system
diff --git a/usbboot b/usbboot
index ae088fb..fe7dc5b 100755
--- a/usbboot
+++ b/usbboot
Binary files differ
diff --git a/wl12xx/Android.mk b/wl12xx/Android.mk
new file mode 100644
index 0000000..7435e1e
--- /dev/null
+++ b/wl12xx/Android.mk
@@ -0,0 +1,89 @@
+LOCAL_PATH := $(my-dir)
+TARGET_OUT_WLAN_FW := $(TARGET_OUT_ETC)/firmware/ti-connectivity
+
+# WLAN FW file for wl1271
+include $(CLEAR_VARS)
+LOCAL_MODULE := wl1271-fw-2.bin
+LOCAL_MODULE_CLASS := ETC
+LOCAL_MODULE_PATH := $(TARGET_OUT_WLAN_FW)
+LOCAL_SRC_FILES := $(LOCAL_MODULE)
+LOCAL_MODULE_TAGS := optional
+include $(BUILD_PREBUILT)
+
+# WLAN NVS file for wl1271
+include $(CLEAR_VARS)
+LOCAL_MODULE := wl1271-nvs.bin
+LOCAL_MODULE_CLASS := ETC
+LOCAL_MODULE_PATH := $(TARGET_OUT_WLAN_FW)
+LOCAL_SRC_FILES := $(LOCAL_MODULE)
+LOCAL_MODULE_TAGS := optional
+include $(BUILD_PREBUILT)
+
+#############################################
+# Install from ti-wpan.tgz:
+# TIInit_10.6.15.bts
+# TIInit_7.2.31.bts
+# TIInit_7.6.15.bts
+
+ti-wpan.untarred_intermediates := $(call intermediates-dir-for, ETC, ti-wpan.untarred)
+ti-wpan.untarred_timestamp := $(ti-wpan.untarred_intermediates)/stamp
+ti-wpan.untarred_bluetooth_dir := $(ti-wpan.untarred_intermediates)/bluetooth
+
+$(ti-wpan.untarred_timestamp) : $(LOCAL_PATH)/ti-wpan.tgz
+	@echo "Unzip $(dir $@) <- $<)"
+	$(hide) rm -rf $(dir $@) && mkdir -p $(dir $@)
+	$(hide) tar -C $(dir $@) -zxf $<
+	$(hide) touch $@
+
+
+#############################################
+include $(CLEAR_VARS)
+LOCAL_MODULE := TIInit_10.6.15.bts
+LOCAL_MODULE_CLASS := ETC
+LOCAL_MODULE_TAGS := optional
+LOCAL_MODULE_PATH := $(TARGET_OUT_ETC)/firmware
+
+include $(BUILD_SYSTEM)/base_rules.mk
+
+$(LOCAL_BUILT_MODULE): PRIVATE_SRC := $(ti-wpan.untarred_bluetooth_dir)/$(LOCAL_MODULE)
+$(LOCAL_BUILT_MODULE) : $(ti-wpan.untarred_timestamp) | $(ACP)
+	@echo "Copy $@ <- $(PRIVATE_SRC)"
+	@mkdir -p $(dir $@)
+	$(hide) $(ACP) -fp $(PRIVATE_SRC) $@
+
+#############################################
+include $(CLEAR_VARS)
+LOCAL_MODULE := TIInit_7.2.31.bts
+LOCAL_MODULE_CLASS := ETC
+LOCAL_MODULE_TAGS := optional
+LOCAL_MODULE_PATH := $(TARGET_OUT_ETC)/firmware
+
+include $(BUILD_SYSTEM)/base_rules.mk
+
+$(LOCAL_BUILT_MODULE): PRIVATE_SRC := $(ti-wpan.untarred_bluetooth_dir)/$(LOCAL_MODULE)
+$(LOCAL_BUILT_MODULE) : $(ti-wpan.untarred_timestamp) | $(ACP)
+	@echo "Copy $@ <- $(PRIVATE_SRC)"
+	@mkdir -p $(dir $@)
+	$(hide) $(ACP) -fp $(PRIVATE_SRC) $@
+
+#############################################
+include $(CLEAR_VARS)
+LOCAL_MODULE := TIInit_7.6.15.bts
+LOCAL_MODULE_CLASS := ETC
+LOCAL_MODULE_TAGS := optional
+LOCAL_MODULE_PATH := $(TARGET_OUT_ETC)/firmware
+
+include $(BUILD_SYSTEM)/base_rules.mk
+
+$(LOCAL_BUILT_MODULE): PRIVATE_SRC := $(ti-wpan.untarred_bluetooth_dir)/$(LOCAL_MODULE)
+$(LOCAL_BUILT_MODULE) : $(ti-wpan.untarred_timestamp) | $(ACP)
+	@echo "Copy $@ <- $(PRIVATE_SRC)"
+	@mkdir -p $(dir $@)
+	$(hide) $(ACP) -fp $(PRIVATE_SRC) $@
+
+#############################################
+
+# Clean up tmp vars
+ti-wpan.untarred_intermediates :=
+ti-wpan.untarred_timestamp :=
+ti-wpan.untarred_bluetooth_dir :=
diff --git a/wl12xx/LICENCE b/wl12xx/LICENCE
new file mode 100644
index 0000000..085f6c7
--- /dev/null
+++ b/wl12xx/LICENCE
@@ -0,0 +1,151 @@
+Texas Instruments Incorporated
+Technology and Software Publicly Available
+Software (Object Code) License Agreement
+
+
+IMPORTANT - PLEASE READ THE FOLLOWING LICENSE AGREEMENT CAREFULLY. THIS IS
+	A LEGALLY BINDING AGREEMENT.  DO NOT DOWNLOAD THE LICENSED MATERIALS
+	UNLESS: (1) YOU ARE AUTHORIZED TO ACCEPT AND AGREE TO THE TERMS OF THIS
+	LICENSE AGREEMENT AND (2) YOU INTEND TO ENTER INTO AND TO BE BOUND BY
+	THE TERMS OF THIS AGREEMENT.
+
+This Software License Agreement ("Agreement") is a legal agreement between you
+	(either an individual or entity) and Texas Instruments Incorporated
+	("TI").  The "Licensed Materials" subject to this Agreement include,
+	in whole or in part, the software programs that accompany this Agreement
+	and any "on-line" or electronic documentation associated with these
+	programs.  By installing, copying or otherwise using the Licensed
+	Materials you agree to abide by the terms of this Agreement.
+	If you choose not to accept or agree with these terms, do not download
+	or install the Licensed Materials.
+
+
+1. Object Code License.  TI hereby grants to you a limited, non-exclusive
+	license to reproduce and use the Licensed Materials provided to you in
+	object code format and to distribute an unlimited number of object or
+	executable copies of such Licensed Materials, provided that such object
+	or executable copies are used solely and exclusively on devices
+	manufactured by or for TI.
+
+2. Termination.  This license is effective until terminated.  Without prejudice
+	to any other rights, TI may terminate your right to use the Licensed
+	Materials under this Agreement if you fail to comply with the terms of
+	this Agreement.  In such event, you shall destroy all copies of the
+	Licensed Materials, including all portions and derivatives thereof.
+
+3. Intellectual Property Rights.  The Licensed Materials being provided to you
+	hereunder are being made publicly available by TI, even though they
+	contain copyrighted material of TI and its licensors, if applicable.
+	In no event may you alter, remove or destroy any copyright notice
+	included in the Licensed Materials.  To the extent that any of the
+	Licensed Materials are provided in binary or object code only, you may
+	not unlock, decompile, reverse engineer, disassemble or otherwise
+	translate such binary or object code to human-perceivable form. The
+	source code of such reverse engineered code may contain TI trade secret
+	and other proprietary information.  Further, nothing shall obligate TI
+	to provide you with source code for the Licensed Materials licensed to
+	you in binary or object code only under this Agreement.  TI reserves all
+	rights not specifically granted under this Agreement.
+
+4. Warranties and Limitations.  THE LICENSED MATERIALS ARE PROVIDED "AS IS". TI
+	MAKES NO WARRANTY OR REPRESENTATION, EXPRESS, IMPLIED OR STATUTORY,
+	INCLUDING ANY IMPLIED WARRANTIES OF MERCHANTIBILITY, FITNESS FOR A
+	PARTICULAR PURPOSE, LACK OF VIRUSES, ACCURACY OR COMPLETENESS OF
+	RESPONSES, RESULTS AND LACK OF NEGLIGENCE.  TI DISCLAIMS ANY WARRANTY OF
+	TITLE, QUIET ENJOYMENT, QUIET POSESSION, AND NON-INFRINGEMENT OF ANY
+	THIRD PARTY INTELLECTUAL PROPERTY RIGHTS WITH REGARD TO THE LICENSED
+	MATERIALS OR USE OF THOSE MATERIALS.
+
+YOU ACKNOWLEDGE AND AGREE THAT THE LICENSED MATERIALS MAY NOT BE INTENDED FOR
+	PRODUCTION APPLICATIONS AND MAY CONTAIN IRREGULARITIES AND DEFECTS NOT
+	FOUND IN PRODUCTION SOFTWARE.  FURTHERMORE, YOU ACKNOWLEDGE AND AGREE
+	THAT THE LICENSED MATERIALS HAVE NOT BEEN TESTED OR CERTIFIED BY ANY
+	GOVERNMENT AGENCY OR INDUSTRY REGULATORY ORGANIZATION OR ANY OTHER THIRD
+	PARTY ORGANIZATION.  YOU AGREE THAT PRIOR TO USING, INCORPORATING OR
+	DISTRIBUTING THE LICENSED MATERIALS IN OR WITH ANY COMMERCIAL PRODUCT
+	THAT YOU WILL THOROUGHLY TEST THE PRODUCT AND THE FUNCTIONALITY OF THE
+	LICENSED MATERIALS IN OR WITH THAT PRODUCT AND BE SOLELY RESPONSIBLE FOR
+	ANY PROBLEMS OR FAILURES.
+
+IN NO EVENT SHALL TI, OR ANY APPLICABLE LICENSOR, BE LIABLE FOR ANY SPECIAL,
+	INDIRECT, INCIDENTAL, PUNITIVE OR CONSEQUENTIAL DAMAGES, HOWEVER CAUSED
+	ON ANY THEORY OF LIABILITY, ARISING IN ANY WAY OUT OF THIS AGREEMENT,
+	OR YOUR USE OF THE LICENSED MATERIALS, WHETHER OR NOT TI HAS BEEN
+	ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.  EXCLUDED DAMAGES INCLUDE,
+	BUT ARE NOT LIMITED TO, COST OF REMOVAL OR REINSTALLATION, OUTSIDE
+	COMPUTER TIME, LABOR COSTS, LOSS OR CORRUPTION OF DATA, LOSS OF
+	GOODWILL, LOSS OF PROFITS, LOSS OF SAVINGS, OR LOSS OF USE OR
+	INTERRUPTION OF BUSINESS OR ANY OTHER ECONOMIC LOSS.  IN NO EVENT WILL
+	TI'S AGGREGATE LIABILITY UNDER THIS AGREEMENT OR ARISING OUT OF YOUR USE
+	OF THE LICENSED MATERIALS EXCEED FIVE HUNDRED U.S. DOLLARS (US$500).
+
+Because some jurisdictions do not allow the exclusion or limitation of
+	incidental or consequential damages or limitation on how long an implied
+	warranty lasts, the above limitations or exclusions may not apply to
+	you.
+
+5. Export Control. Thesoftware programs and any "on-line" documentation as well
+	as any updates or upgrades to such software programs or documentation
+	may be subject to the export or import regulations of certain countries.
+	You agree to comply with all such regulations and acknowledge that you
+	have the responsibility to obtain any licenses or other authorizations
+	that may be required to export, re-export or import the Licensed
+	Materials.
+
+6. Governing Law, Jurisdiction and Severability.  This Agreement will be
+	governed by and interpreted in accordance with the laws of the State of
+	Texas, without reference to that state's conflict of laws principles.
+	This Agreement shall not be governed by the United Nations Convention on
+	Contracts for the International Sale of Goods, nor shall it be governed
+	by the Uniform Computer Information Transactions Act (UCITA).  Any
+	dispute arising out of or related to this Agreement will be brought in,
+	and each party consents to the exclusive jurisdiction and venue in the
+	state and federal courts sitting in Dallas Country, Texas. Each party
+	waives all defenses of lack of personal jurisdiction and forum
+	non-conveniens and agrees that process may be served on either party in
+	a manner authorized by applicable law or court rule.  If for any reason
+	a court of competent jurisdiction finds any provision of the Agreement
+	to be unenforceable, that provision will be enforced to the maximum
+	extent possible to effectuate the intent of the parties and the
+	remainder of the Agreement shall continue in full force and effect.
+
+7. PRC Provisions.  If you are located in the People's Republic of China ("PRC")
+	or if the Licensed Materials will be sent to the PRC, the following
+	provisions shall apply and shall supersede any other provisions in this
+	Agreement concerning the same subject matter as the following
+	provisions:
+
+	a.	Registration Requirements.  You shall be solely responsible for
+	performing all acts and obtaining all approvals that may be required in
+	connection with this Agreement by the government of the PRC, including
+	but not limited to registering pursuant to, and otherwise complying
+	with, the PRC Measures on the Administration of Software Products,
+	Management Regulations on Technology Import-Export, and Technology
+	Import and Export Contract Registration Management Rules. Upon receipt
+	of such approvals from the government authorities, you shall forward
+	evidence of all such approvals to TI for its records.  In the event that
+	you fail to obtain any such approval or registration, you shall be
+	solely responsible for any and all losses, damages or costs resulting
+	therefrom, and shall indemnify TI for all such losses, damages or costs.
+
+	b.	Governing Language.  This Agreement is written and executed in
+	the English language.  If a translation of this Agreement is required
+	for any purpose, including but not limited to registration of the
+	Agreement pursuant to any governmental laws, regulations or rules, you
+	shall be solely responsible for creating such translation.  Any
+	translation of this Agreement into a language other than English is
+	intended solely in order to comply with such laws or for reference
+	purposes, and the English language version shall be authoritative and
+	controlling.
+
+8. Entire Agreement.  This is the entire Agreement between you and TI and
+	supersedes any prior agreement between the parties related to the
+	subject matter of this Agreement. No amendment or modification of this
+	Agreement will be effective unless in writing and signed by a duly
+	authorized representative of TI.  You hereby warrant and represent that
+	you have obtained all authorizations and other applicable consents
+	required empowering you to enter into this Agreement.
+
+1
+TILAW-#236402v3
+
diff --git a/wl12xx/LICENSE_for_WPAN_BT b/wl12xx/LICENSE_for_WPAN_BT
new file mode 100644
index 0000000..606c12d
--- /dev/null
+++ b/wl12xx/LICENSE_for_WPAN_BT
@@ -0,0 +1,46 @@
+   1 TECHNOLOGY AND SOFTWARE PUBLICLY AVAILABLE
+   2 SOFTWARE LICENSE
+   3
+   4 Copyright (c) 2011, Texas Instruments Incorporated.
+   5
+   6 All rights reserved.
+   7
+   8 Redistribution.
+   9
+  10 Redistribution and use in binary form, without modification, are
+  11 permitted provided that the following conditions are met:
+  12
+  13  * Redistributions must preserve existing copyright notices and reproduce
+  14    this license (including the above copyright notice and the disclaimer below)
+  15    in the documentation and/or other materials provided with the distribution.
+  16
+  17  * Neither the name of Texas Instruments Incorporated nor the names of
+  18    its suppliers may be used to endorse or promote products derived
+  19    from this software without specific prior written permission.
+  20
+  21  * No reverse engineering, decompilation, or disassembly of this
+  22    software is permitted.
+  23
+  24 Limited patent license.
+  25
+  26 Texas Instruments Incorporated grants a world-wide, royalty-free,
+  27 non-exclusive license under patents it now or hereafter owns or controls
+  28 to make, have made, use, import, offer to sell and sell ("Utilize") this
+  29 software, but solely to the extent that any such patent is necessary
+  30 to Utilize the software alone.  The patent license shall not apply to
+  31 any combinations which include this software.  No hardware per se is
+  32 licensed hereunder.
+  33
+  34 DISCLAIMER.
+  35
+  36 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+  37 "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+  38 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+  39 A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+  40 OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+  41 SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+  42 LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+  43 DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+  44 THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+  45 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+  46 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/wl12xx/ti-wl12xx-vendor.mk b/wl12xx/ti-wl12xx-vendor.mk
new file mode 100644
index 0000000..cca2a75
--- /dev/null
+++ b/wl12xx/ti-wl12xx-vendor.mk
@@ -0,0 +1,3 @@
+PRODUCT_PACKAGES += \
+	wl1271-fw-2.bin \
+	wl1271-nvs.bin 
diff --git a/wl12xx/ti-wpan-products.mk b/wl12xx/ti-wpan-products.mk
new file mode 100755
index 0000000..dcd349f
--- /dev/null
+++ b/wl12xx/ti-wpan-products.mk
@@ -0,0 +1,24 @@
+# Copyright (C) 2012 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.
+#
+
+# This file lists the firmware, software that are specific to
+# WiLink connectivity chip on OMAPx platforms.
+
+PRODUCT_PACKAGES += uim-sysfs \
+        bt_sco_app \
+        BluetoothSCOApp \
+        TIInit_10.6.15.bts \
+        TIInit_7.2.31.bts \
+        TIInit_7.6.15.bts
diff --git a/wl12xx/ti-wpan.tgz b/wl12xx/ti-wpan.tgz
new file mode 100644
index 0000000..780addf
--- /dev/null
+++ b/wl12xx/ti-wpan.tgz
Binary files differ
diff --git a/wl12xx/wl1271-fw-2.bin b/wl12xx/wl1271-fw-2.bin
new file mode 100644
index 0000000..8d18611
--- /dev/null
+++ b/wl12xx/wl1271-fw-2.bin
Binary files differ
diff --git a/wl12xx/wl1271-nvs.bin b/wl12xx/wl1271-nvs.bin
new file mode 100644
index 0000000..91978f9
--- /dev/null
+++ b/wl12xx/wl1271-nvs.bin
Binary files differ
diff --git a/xloader.bin b/xloader.bin
index a12a8b9..4140845 100644
--- a/xloader.bin
+++ b/xloader.bin
Binary files differ