diff --git a/Android.mk b/Android.mk
index 0c77a12..03e16f0 100644
--- a/Android.mk
+++ b/Android.mk
@@ -32,6 +32,9 @@
 LOCAL_PATH := $(LOCAL_DIR_PATH)
 include $(LOCAL_PATH)/helium/Android.mk
 
+LOCAL_PATH := $(LOCAL_DIR_PATH)
+include $(LOCAL_PATH)/fmhalService/Android.mk
+
 #endif # is-vendor-board-platform
 #endif # BOARD_HAVE_QCOM_FM
 #endif # Not (TARGET_USES_AOSP)
diff --git a/fm_hci/fm_hci.c b/fm_hci/fm_hci.c
index f3554f2..0cf2de8 100644
--- a/fm_hci/fm_hci.c
+++ b/fm_hci/fm_hci.c
@@ -37,20 +37,34 @@
 #include "userial.h"
 #include "fm_hci.h"
 #include "wcnss_hci.h"
+#include <stdlib.h>
 #include <dlfcn.h>
 #include <sys/eventfd.h>
 #include <errno.h>
 #include <string.h>
+#include <sys/socket.h>
+#include <cutils/sockets.h>
+#include <pthread.h>
+#include <sys/select.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/un.h>
+#include <cutils/properties.h>
 
 int fm_fd;
+static int fm_hal_fd =0;
 fm_hal_cb *hal_cb;
 
+#define FM_VND_SERVICE_START "wc_transport.start_fmhci"
+#define WAIT_TIMEOUT 200000 /* 200*1000us */
+
 // The set of events one can send to the userial read thread.
 // Note that the values must be >= 0x8000000000000000 to guarantee delivery
 // of the message (see eventfd(2) for details on blocking behaviour).
 enum {
     USERIAL_RX_EXIT     = 0x8000000000000000ULL
 };
+bt_vendor_interface_t *fm_vnd_if = NULL;
 
 void event_notification(uint16_t event)
 {
@@ -60,8 +74,6 @@
     ALOGI("%s: Notifying worker thread with event: %d", __func__, event);
     pthread_mutex_unlock(&fmHCIControlBlock.event_lock);
 }
-
-bt_vendor_interface_t *fm_vnd_if = NULL;
 void init_vnd_if()
 {
     void *dlhandle;
@@ -254,7 +266,7 @@
                               ALOGI("%s: FM H/w Err Event Recvd. Event Code: 0x%2x", __func__, pbuf->evt_code);
                               lib_running =0;
                               // commented till bt vendor include added
-                             // fm_vnd_if->ssr_cleanup();
+                             // fm_vnd_if->ssr_cleanup(0x22);
                         } else {
                             ALOGI("%s: Not CS/CC Event: Recvd. Event Code: 0x%2x", __func__, pbuf->evt_code);
                             evt_type = -1;
@@ -289,13 +301,11 @@
 
                         ret = ret - (evt_len + 3);
                         ALOGD("%s: Length of available bytes @ HCI Layer: %d", __func__, ret);
-
                         if (ret > 0) {
                             ALOGD("%s: Remaining bytes of event/data: %d", __func__, ret);
                             pbuf = (FM_EVT_HDR *)&pbuf->cmd_params[evt_len];
                             ALOGD("%s: Protocol byte of next packet: 0x%2x", __func__, pbuf[0]);
                         }
-
                     }
                 } //end of processing the event
 
@@ -330,6 +340,28 @@
     return arg;
 }
 
+int connect_to_local_fmsocket(char* name) {
+       socklen_t len; int sk = -1;
+
+       ALOGE("%s: ACCEPT ", __func__);
+       sk  = socket(AF_LOCAL, SOCK_STREAM, 0);
+       if (sk < 0) {
+           ALOGE("Socket creation failure");
+           return -1;
+       }
+
+        if(socket_local_client_connect(sk, name,
+            ANDROID_SOCKET_NAMESPACE_ABSTRACT, SOCK_STREAM) < 0)
+        {
+             ALOGE("failed to connect (%s)", strerror(errno));
+             close(sk);
+             sk = -1;
+        } else {
+             ALOGE("%s: Connection succeeded\n", __func__);
+        }
+        return sk;
+}
+
 /*
  * Reads the FM-CMDs from the TX_Q and sends it down to WCNSS Filter
  * Reads events sent by the WCNSS Filter and copies onto RX_Q
@@ -360,6 +392,50 @@
     return arg;
 }
 
+void stop_fmhal_service() {
+       char value[PROPERTY_VALUE_MAX] = {'\0'};
+       ALOGI("%s: Entry ", __func__);
+       property_get(FM_VND_SERVICE_START, value, "false");
+       if (strcmp(value, "false") == 0) {
+           ALOGI("%s: fmhal service  has been stopped already", __func__);
+//         return;
+       }
+       close(fm_hal_fd);
+       fm_hal_fd = -1;
+       property_set(FM_VND_SERVICE_START, "false");
+       property_set("wc_transport.fm_service_status", "0");
+       ALOGI("%s: Exit ", __func__);
+}
+
+void start_fmhal_service() {
+       ALOGI("%s: Entry ", __func__);
+       int i, init_success = 0;
+       char value[PROPERTY_VALUE_MAX] = {'\0'};
+
+       property_get(FM_VND_SERVICE_START, value, false);
+
+       if (strcmp(value, "true") == 0) {
+           ALOGI("%s: hci_filter has been started already", __func__);
+           return;
+       }
+  //     property_set("wc_transport.fm_service_status", "0");
+       property_set(FM_VND_SERVICE_START, "true");
+       ALOGI("%s: %s set to true ", __func__, FM_VND_SERVICE_START );
+       for(i=0; i<45; i++) {
+          property_get("wc_transport.fm_service_status", value, "0");
+          if (strcmp(value, "1") == 0) {
+               ALOGI("%s: wc_transport.fm_service_status set to %s", __func__,value);
+               init_success = 1;
+               break;
+           } else {
+               usleep(WAIT_TIMEOUT);
+           }
+        }
+        ALOGI("start_fmhal_service status:%d after %f seconds \n", init_success, 0.2*i);
+
+        ALOGI("%s: Exit ", __func__);
+}
+
 int fm_hci_init(fm_hal_cb *p_cb)
 {
     pthread_attr_t thread_attr;
@@ -367,13 +443,17 @@
     int policy, result, hci_type;
 
     ALOGI("FM-HCI: init");
-
+    start_fmhal_service();
     /* Save the FM-HAL event notofication callback func. */
     hal_cb = p_cb;
-
-    ALOGI("FM-HCI: Loading the WCNSS HAL library...");
-    init_vnd_if();
-
+    fm_hal_fd =  connect_to_local_fmsocket("fmhal_sock");
+	if(fm_hal_fd != -1)
+    {
+       ALOGI("FM hal service socket connect success..");
+    }
+    ALOGI("fm_hal_fd = %d", fm_hal_fd);
+	//if(fm_hal_fd == -1)
+   //      return FM_HC_STATUS_FAIL;
     ALOGI("%s: Initializing FM-HCI layer...", __func__);
     lib_running = 1;
     ready_events = 0;
@@ -413,23 +493,61 @@
     } else
         ALOGI("FM-HCI: Failed to get the Scheduling parameters!!!");
 
+	ALOGI("FM-HCI: Loading the WCNSS HAL library...");
+    init_vnd_if();
     return FM_HC_STATUS_SUCCESS;
 }
 
 
-void fm_power(fm_power_state state)
+int fm_power(fm_power_state state)
 {
-    int val;
-
-    if (state) {
-        ALOGI("FM-HCI: %s: Turning FM ON", __func__);
-        val = state;
-        fm_vnd_if->op(FM_VND_OP_POWER_CTRL, &val);
-    } else {
-        ALOGI("FM-HCI: %s: Turning FM OFF", __func__);
-        val = state;
-        fm_vnd_if->op(FM_VND_OP_POWER_CTRL, &val);
+    int i,opcode,ret;
+ 	int init_success = 0;
+    char value[PROPERTY_VALUE_MAX] = {'\0'};
+    if (fm_hal_fd)
+    {
+        if (state)
+            opcode = 2;
+        else {
+            opcode = 1;
+        }
+        ALOGI("%s:opcode: %x", LOG_TAG, opcode);
+        ret = write(fm_hal_fd,&opcode, 1);
+	    if (ret < 0)
+	 	{
+            ALOGE("failed to write fm hal socket");
+	 	}
     }
+    else {
+  	    ALOGE("Connect to socket failed ..");
+           ret = -1;
+    }
+    if(state == FM_RADIO_DISABLE) {
+		for (i=0; i<10; i++) {
+	       property_get("wc_transport.fm_power_status", value, "0");
+		   if (strcmp(value, "0") == 0) {
+			   init_success = 1;
+			   break;
+           } else {
+                usleep(WAIT_TIMEOUT);
+           }
+       }
+        ALOGI("fm power OFF status:%d after %f seconds \n", init_success, 0.2*i);
+	 	stop_fmhal_service();
+    }
+    if (state == FM_RADIO_ENABLE) {
+	   for (i=0; i<10; i++) {
+	       property_get("wc_transport.fm_power_status", value, "0");
+		   if (strcmp(value, "1") == 0) {
+			   init_success = 1;
+			   break;
+           } else {
+                usleep(WAIT_TIMEOUT);
+           }
+       }
+       ALOGI("fm power ON status:%d after %f seconds \n", init_success, 0.2*i);
+    }
+     return ret;
 }
 
 #define CH_MAX 3
diff --git a/fm_hci/fm_hci.h b/fm_hci/fm_hci.h
index 2d5e4a1..cfacb84 100644
--- a/fm_hci/fm_hci.h
+++ b/fm_hci/fm_hci.h
@@ -100,7 +100,7 @@
 
 int transmit(FM_HDR *pbuf);
 int  fm_hci_init(fm_hal_cb *);
-void fm_power(fm_power_state state);
+int fm_power(fm_power_state state);
 int open_serial_port(void);
 void fm_userial_close(void);
 
diff --git a/fmhalService/Android.mk b/fmhalService/Android.mk
new file mode 100644
index 0000000..ad67eb9
--- /dev/null
+++ b/fmhalService/Android.mk
@@ -0,0 +1,37 @@
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+
+# Setup bdroid local make variables for handling configuration
+ifneq ($(BOARD_BLUETOOTH_BDROID_BUILDCFG_INCLUDE_DIR),)
+  bdroid_C_INCLUDES := $(BOARD_BLUETOOTH_BDROID_BUILDCFG_INCLUDE_DIR)
+  bdroid_CFLAGS += -DHAS_BDROID_BUILDCFG
+else
+  bdroid_C_INCLUDES :=
+  bdroid_CFLAGS += -DHAS_NO_BDROID_BUILDCFG
+endif
+
+BDROID_DIR:= system/bt
+
+LOCAL_CFLAGS += $(bdroid_CFLAGS)
+
+LOCAL_SRC_FILES := \
+	     main.c
+
+LOCAL_SHARED_LIBRARIES := \
+         libdl \
+         libcutils
+
+LOCAL_CFLAGS := -Wno-unused-parameter
+
+LOCAL_C_INCLUDES += \
+        $(BDROID_DIR)/hci/include \
+        $(BDROID_DIR)/stack/include \
+        $(BDROID_DIR)/osi/include \
+        $(LOCAL_PATH)/../helium \
+        $(LOCAL_PATH)/../fm_hci
+
+LOCAL_MODULE := fmhal_service
+LOCAL_MODULE_TAGS := optional
+
+include $(BUILD_EXECUTABLE)
diff --git a/fmhalService/main.c b/fmhalService/main.c
new file mode 100644
index 0000000..558f681
--- /dev/null
+++ b/fmhalService/main.c
@@ -0,0 +1,390 @@
+/*
+ * Copyright (c) 2016, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *        * Redistributions of source code must retain the above copyright
+ *            notice, this list of conditions and the following disclaimer.
+ *        * Redistributions in binary form must reproduce the above
+ *            copyright notice, this list of conditions and the following
+ *            disclaimer in the documentation and/or other materials provided
+ *            with the distribution.
+ *        * Neither the name of The Linux Foundation nor the names of its
+ *            contributors may be used to endorse or promote products derived
+ *            from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+ * FMhal service used to access RFKILL
+
+**/
+
+#include <cutils/log.h>
+#include <sys/socket.h>
+#include <cutils/sockets.h>
+#include <pthread.h>
+#include <sys/select.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <stdlib.h>
+#include <termios.h>
+#include <fcntl.h>
+#include <sys/un.h>
+#include <sys/eventfd.h>
+#include <errno.h>
+#include <string.h>
+
+#include <cutils/properties.h>
+#include "private/android_filesystem_config.h"
+
+
+//#include "bt_hci_bdroid.h"
+#include "bt_vendor_lib.h"
+#include "fm_hci.h"
+#include "wcnss_fmhci.h"
+#include <dlfcn.h>
+
+
+#define LOG_TAG "FMHalService"
+
+#define FM_HAL_SOCK "fmhal_sock"
+
+
+#define BT_SSR_TRIGGERED 0xee
+
+#define FM_POWER_OFF      0x01
+#define FM_POWER_ON       0x02
+#define FM_USERIAL_OPEN   0x03
+#define FM_USERIAL_CLOSE  0x04
+
+#define FM_CMD_PACKET_TYPE     0x11
+#define FM_EVT_PACKET_TYPE     0x14
+
+#ifndef BLUETOOTH_UID
+#define BLUETOOTH_UID 1002
+#endif
+#ifndef SYSTEM_UID
+#define SYSTEM_UID 1000
+#endif
+
+#ifndef ROOT_UID
+#define ROOT_UID 0
+#endif
+
+pthread_mutex_t signal_mutex;
+
+bt_vendor_interface_t *fm_if = NULL;
+int remote_fm_hal_fd;
+
+int do_write(int fd, unsigned char *buf,int len);
+
+unsigned char reset_cmpl[] = {0x04, 0x0e, 0x04, 0x01,0x03, 0x0c, 0x00};
+
+static int extract_uid(int uuid)
+{
+    int userid;
+    int appid;
+
+    appid = userid =  uuid % AID_USER;
+    if (userid > BLUETOOTH_UID)
+    {
+        appid = userid % AID_APP;
+    }
+    ALOGD("%s appid = %d",__func__,appid);
+    return appid;
+}
+ void service_cleanup()
+{
+    char ref_count[PROPERTY_VALUE_MAX];
+    char cleanup[PROPERTY_VALUE_MAX];
+    int ref_val,clean;
+
+    ALOGE("Service is stopped ");
+    property_get("wc_transport.clean_up", cleanup, "0");
+    property_set("wc_transport.fm_service_status", "0");
+    property_set("wc_transport.start_fmhci", "0");
+    property_set("wc_transport.fm_power_status", "0");
+    clean = atoi(cleanup);
+    ALOGE("clean Value =  %d",clean);
+}
+
+static int establish_fm_remote_socket(char *name)
+{
+    int fd = -1;
+    struct sockaddr_un client_address;
+    socklen_t clen;
+    int sock_id, ret;
+    struct ucred creds;
+    int c_uid;
+    ALOGI("%s(%s) Entry  ", __func__, name);
+
+    sock_id = socket(AF_LOCAL, SOCK_STREAM, 0);
+    if (sock_id < 0) {
+        ALOGE("%s: server Socket creation failure", __func__);
+        return fd;
+    }
+
+    ALOGI("convert name to android abstract name:%s %d", name, sock_id);
+    if (socket_local_server_bind(sock_id,
+        name, ANDROID_SOCKET_NAMESPACE_ABSTRACT) >= 0) {
+        if (listen(sock_id, 5) == 0) {
+            ALOGI("listen to local socket:%s, fd:%d", name, sock_id);
+        } else {
+            ALOGE("listen to local socket:failed");
+            close(sock_id);
+            return fd;
+        }
+    } else {
+        close(sock_id);
+        ALOGE("%s: server bind failed for socket : %s", __func__, name);
+        return fd;
+    }
+
+    clen = sizeof(client_address);
+    /*Indicate that, server is ready to accept*/
+    property_set("wc_transport.fm_service_status", "1");
+    ALOGI("%s: wc_transport.fm_service_status set to 1 ", __func__);
+    ALOGI("%s: before accept_server_socket", name);
+    fd = accept(sock_id, (struct sockaddr *)&client_address, &clen);
+    if (fd > 0) {
+        ALOGI("%s accepted fd:%d for server fd:%d", name, fd, sock_id);
+        close(sock_id);
+
+        memset(&creds, 0, sizeof(creds));
+        socklen_t szCreds = sizeof(creds);
+        ret = getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &creds, &szCreds);
+        if (ret < 0) {
+            ALOGE("%s: error getting remote socket creds: %d\n", __func__, ret);
+            close(fd);
+            return -1;
+        }
+        c_uid = creds.uid;
+        if (c_uid > BLUETOOTH_UID)
+            c_uid = extract_uid(creds.uid);
+        if (c_uid != BLUETOOTH_UID && c_uid != SYSTEM_UID
+                && c_uid != ROOT_UID) {
+            ALOGE("%s: client doesn't have required credentials", __func__);
+            ALOGE("<%s req> client uid: %d", name, creds.uid);
+            close(fd);
+            return -1;
+        }
+
+        ALOGI("%s: Remote socket credentials: %d\n", __func__, creds.uid);
+        return fd;
+    } else {
+        ALOGE("BTC accept failed fd:%d sock d:%d error %s", fd, sock_id, strerror(errno));
+        close(sock_id);
+        return fd;
+    }
+
+    close(sock_id);
+    return fd;
+}
+
+
+int handle_fmcommand_writes(int fd) {
+    ALOGI("%s: ", __func__);
+    unsigned char first_byte;
+    int retval,val;
+	int fd_array[CH_MAX];
+
+    ALOGE("%s: FMHAL: read 1st byte to determine the power on/off ", __func__);
+
+    retval = read (fd, &first_byte, 1);
+    if (retval < 0) {
+        ALOGE("%s:read returns err: %d\n", __func__,retval);
+        return -1;
+    }
+    if (retval == 0) {
+        ALOGE("%s: This indicates the close of other end", __func__);
+        return -99;
+    }
+
+    ALOGE("%s: FM command type: 0x%x", __func__, first_byte);
+    switch(first_byte) {
+        case FM_POWER_OFF:
+             ALOGE("%s: Received power off command from FM stack: %d", __func__, first_byte);
+             val = 0;
+             retval = fm_if->op(BT_VND_OP_POWER_CTRL, &val);
+             if (retval < 0)
+             {
+                ALOGE("Failed to turn off power from  bt vendor interface");
+               //   return -1;
+             }
+             else {
+                 property_set("wc_transport.fm_power_status", "0");
+                 retval = -99;
+             }
+             break;
+
+        case FM_POWER_ON:
+             ALOGE("%s: Received power ON command from FM stack: %d", __func__, first_byte);
+             val = 1;
+             retval =fm_if->op(FM_VND_OP_POWER_CTRL, &val);
+             if (retval < 0)
+             {
+               ALOGE("Failed to turn on power from  bt vendor interface");
+             }
+             else
+                property_set("wc_transport.fm_power_status", "1");
+             break;
+        default:
+            ALOGE("%s: Unexpected data format!!",__func__);
+            retval = -1;
+    }
+    return retval;
+}
+
+
+int do_read(int fd, unsigned char* buf, size_t len) {
+   int bytes_left, bytes_read = 0, read_offset;
+
+   bytes_left = len;
+   read_offset = 0;
+
+   do {
+       bytes_read = read(fd, buf+read_offset, bytes_left);
+       if (bytes_read < 0) {
+           ALOGE("%s: Read error: %d (%s)", __func__, bytes_left, strerror(errno));
+           return -1;
+       } else if (bytes_read == 0) {
+            ALOGE("%s: read returned 0, err = %s, read bytes: %d, expected: %d",
+                              __func__, strerror(errno), (len-bytes_left), len);
+            return (len-bytes_left);
+       }
+       else {
+           if (bytes_read < bytes_left) {
+              ALOGV("Still there are %d bytes to read", bytes_left-bytes_read);
+              bytes_left = bytes_left-bytes_read;
+              read_offset = read_offset+bytes_read;
+           } else {
+              ALOGV("%s: done with read",__func__);
+              break;
+           }
+       }
+   }while(1);
+   return len;
+}
+
+int do_write(int fd, unsigned char *buf,int len)
+{
+    int ret = 0;
+    int write_offset = 0;
+    int write_len = len;
+    do {
+        ret = write(fd, buf+write_offset, write_len);
+        if (ret < 0)
+        {
+            ALOGE("%s: write failed ret = %d err = %s",__func__,ret,strerror(errno));
+            return -1;
+
+        } else if (ret == 0) {
+            ALOGE("%s: Write returned 0, err = %s, Written bytes: %d, expected: %d",
+                        __func__, strerror(errno), (len-write_len), len);
+            return (len-write_len);
+
+        } else {
+            if (ret < write_len)
+            {
+               ALOGD("%s, Write pending,do write ret = %d err = %s",__func__,ret,
+                       strerror(errno));
+               write_len = write_len - ret;
+               write_offset = ret;
+            } else if (ret > write_len) {
+               ALOGE("%s: FATAL wrote more than expected: written bytes: %d expected: %d",
+                      __func__, write_len, ret);
+               break;
+            } else {
+               ALOGV("Write successful");
+               break;
+            }
+        }
+    } while(1);
+    return len;
+}
+
+void vnd_load_if()
+{
+    void *dlhandle;
+    unsigned char bdaddr[] = {0xaa, 0xbb, 0xcc, 0x11, 0x22, 0x33};
+
+    dlhandle = dlopen("libbt-vendor.so", RTLD_NOW);
+    if (!dlhandle)
+    {
+        ALOGE("!!! Failed to load libbt-vendor.so !!!");
+        return;
+    }
+
+    fm_if = (bt_vendor_interface_t *) dlsym(dlhandle, "BLUETOOTH_VENDOR_LIB_INTERFACE");
+    if (!fm_if)
+    {
+        ALOGE("!!! Failed to get bt vendor interface !!!");
+        return;
+    }
+
+    ALOGI("FM-HCI: Registering the WCNSS HAL library by passing CBs and BD addr.");
+    fm_if->init(&fmhci_vendor_callbacks, bdaddr);
+}
+
+
+int main()  {
+   fd_set client_fds;
+    int retval, n;
+
+    ALOGI("%s: Entry ", __func__);
+    ALOGI("FM HAL SERVICE: Loading the WCNSS HAL library...");
+    vnd_load_if();
+    ALOGI("create socket");
+    remote_fm_hal_fd = establish_fm_remote_socket(FM_HAL_SOCK);
+    if (remote_fm_hal_fd < 0) {
+       ALOGE("%s: invalid remote socket", __func__);
+       return -1;
+    }
+
+     FD_ZERO(&client_fds);
+     FD_SET(remote_fm_hal_fd, &client_fds);
+
+     do {
+            ALOGI("%s: Step 1-FM-HAL SERVICE: Waiting for FM HAL cmd ", __func__);
+            n = select(remote_fm_hal_fd+1, &client_fds, NULL, NULL, NULL);
+            if(n < 0){
+                ALOGE("Select: failed: %s", strerror(errno));
+                break;
+            }
+            ALOGI("%s: Step 2-FM-HAL SERVICE: FM  POWER CMD available for processing...\n", __func__);
+            if (FD_ISSET(remote_fm_hal_fd, &client_fds)) {
+                retval = handle_fmcommand_writes(remote_fm_hal_fd);
+                ALOGI("%s: handle_fmcommand_writes . %d", __func__, retval);
+               if(retval < 0) {
+                   if (retval == -99) {
+                       ALOGI("%s:End of wait loop", __func__);
+                       break;
+                   }
+                   ALOGI("%s: handle_fmcommand_writes returns: %d: ", __func__, retval);
+                 //  break;
+                }
+            }
+        } while(1);
+
+        service_cleanup();
+        ALOGI("%s: FM turned off or power off failed .service kill itself", __func__);
+        close(remote_fm_hal_fd);
+       remote_fm_hal_fd = 0;
+
+    ALOGI("%s: Exit: %d", __func__, retval);
+    return retval;
+}
+
diff --git a/fmhalService/wcnss_fmhci.h b/fmhalService/wcnss_fmhci.h
new file mode 100644
index 0000000..22029bf
--- /dev/null
+++ b/fmhalService/wcnss_fmhci.h
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 2016, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *        * Redistributions of source code must retain the above copyright
+ *            notice, this list of conditions and the following disclaimer.
+ *        * Redistributions in binary form must reproduce the above
+ *            copyright notice, this list of conditions and the following
+ *            disclaimer in the documentation and/or other materials provided
+ *            with the distribution.
+ *        * Neither the name of The Linux Foundation nor the names of its
+ *            contributors may be used to endorse or promote products derived
+ *            from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __WCNSS_FMHCI__
+#define __WCNSS_FMHCI__
+static void vendor_fwcfg_cb(bt_vendor_op_result_t result) {
+}
+
+static void vendor_scocfg_cb(bt_vendor_op_result_t result) {
+}
+
+static void vendor_lpm_vnd_cb(bt_vendor_op_result_t result) {
+}
+
+static void sco_audiostate_cb(bt_vendor_op_result_t result) {
+}
+
+static void* vendor_alloc(int size) {
+    return NULL;
+}
+
+static void vendor_dealloc(void *p_buf) {
+}
+
+static uint8_t vendor_xmit_cb(uint16_t opcode, void *p_buf, tINT_CMD_CBACK p_cback) {
+    return 0;
+}
+
+static void vendor_epilog_cb(bt_vendor_op_result_t result) {
+}
+
+
+static const bt_vendor_callbacks_t fmhci_vendor_callbacks = {
+  sizeof(fmhci_vendor_callbacks),
+   vendor_fwcfg_cb,
+   vendor_scocfg_cb,
+   vendor_lpm_vnd_cb,
+   sco_audiostate_cb,
+   vendor_alloc,
+   vendor_dealloc,
+   vendor_xmit_cb,
+   vendor_epilog_cb
+};
+#endif
diff --git a/helium/radio-helium.h b/helium/radio-helium.h
index 05fc309..989bb55 100644
--- a/helium/radio-helium.h
+++ b/helium/radio-helium.h
@@ -140,6 +140,7 @@
 /* HCI timeouts */
 #define RADIO_HCI_TIMEOUT   (10000) /* 10 seconds */
 
+#define ECC_EVENT_BUFSIZE   12
 typedef enum {
     ASSOCIATE_JVM,
     DISASSOCIATE_JVM
diff --git a/helium/radio_helium_hal.c b/helium/radio_helium_hal.c
index 2a29f64..5437bad 100644
--- a/helium/radio_helium_hal.c
+++ b/helium/radio_helium_hal.c
@@ -105,6 +105,7 @@
 static void hci_cc_fm_disable_rsp(char *ev_buff)
 {
     char status;
+	int ret;
 
     if (ev_buff == NULL) {
         ALOGE("%s:%s, buffer is null\n", LOG_TAG, __func__);
@@ -119,7 +120,10 @@
         jni_cb->disabled_cb();
         jni_cb->thread_evt_cb(1);
         //close the userial port and power off the chip
-        ALOGE("%s:calling fm userial close\n", LOG_TAG );
+        ret = fm_power(FM_RADIO_DISABLE);
+        ALOGI("fm power off status = %d", ret);
+    	ALOGE("%s:calling fm userial close\n", LOG_TAG );
+	//	sleep(1);
         fm_userial_close();
     //  fm_power(FM_RADIO_DISABLE);
     }
@@ -1105,7 +1109,7 @@
     ret = fm_hci_init(&hal_cb);
 
     ALOGE("%s:%s: Turning FM ON...", LOG_TAG, __func__);
-    fm_power(FM_RADIO_ENABLE);
+    ret = fm_power(FM_RADIO_ENABLE);
 
     ALOGE("%s:%s: Firmware download and HCI Initialization in-progress...", LOG_TAG, __func__);
     /* TODO : Start the preload timer */