diff --git a/fmapp2/src/com/caf/fmradio/FMStats.java b/fmapp2/src/com/caf/fmradio/FMStats.java
index a0bc184..f7254a2 100644
--- a/fmapp2/src/com/caf/fmradio/FMStats.java
+++ b/fmapp2/src/com/caf/fmradio/FMStats.java
@@ -748,7 +748,7 @@
                      return;
                  if(mService != null) {
                     try {
-                        mService.getRxRepeatCount();
+                        mService.setRxRepeatCount(textBoxVal);
                         setCmdSent = true;
                         lastCmdSent = CMD_DEFRD_REPEATCOUNT;
                     } catch (RemoteException e) {
@@ -773,7 +773,7 @@
                      (textBoxVal > MAX_BLEND_SINRHI))
                      return;
                  if(mReceiver != null) {
-                     mReceiver.getBlendSinr();
+                     mReceiver.setBlendSinr(textBoxVal);
                      setCmdSent = true;
                      lastCmdSent = CMD_BLENDTBL_SINR_HI;
                  }
@@ -795,7 +795,7 @@
                      (textBoxVal > MAX_BLEND_RMSSIHI))
                      return;
                  if(mReceiver != null) {
-                     mReceiver.getBlendRmssi();
+                     mReceiver.setBlendRmssi(textBoxVal);
                      setCmdSent = true;
                      lastCmdSent = CMD_BLENDTBL_RMSSI_HI;
                  }
@@ -834,7 +834,7 @@
               Log.d(LOGTAG, "Value of Sinr Samples count is : " + textBoxVal);
               if(mService != null) {
                  try {
-                     mService.getSinrSamplesCnt();
+                     mService.setSinrSamplesCnt(textBoxVal);
                      setCmdSent = true;
                      lastCmdSent = CMD_CHDET_SINR_SAMPLE;
                  }catch (RemoteException e) {
@@ -857,7 +857,7 @@
               Log.d(LOGTAG, "Value of Sinr Th is : " + textBoxVal);
               if(mService != null) {
                  try {
-                     mService.getSinrTh();
+                     mService.setSinrTh(textBoxVal);
                      setCmdSent = true;
                      lastCmdSent = CMD_CHDET_SINR_TH;
                  }catch (RemoteException e) {
@@ -881,7 +881,7 @@
               Log.d(LOGTAG, "Value of Intf Det Low Th is : " + textBoxVal);
               if(mService != null) {
                  try {
-                     mService.getIntfDetLowTh();
+                     mService.setIntfDetLowTh(textBoxVal);
                      setCmdSent =  true;
                      lastCmdSent = CMD_CHDET_INTF_TH_LOW;
                  }catch (RemoteException e) {
@@ -904,7 +904,7 @@
               Log.d(LOGTAG, "Value of Intf Det Low Th is : " + textBoxVal);
               if(mService != null) {
                  try {
-                     mService.getIntfDetHighTh();
+                     mService.setIntfDetHighTh(textBoxVal);
                      setCmdSent = true;
                      lastCmdSent = CMD_CHDET_INTF_TH_HIGH;
                  }catch (RemoteException e) {
@@ -931,7 +931,7 @@
                   return;
               if(mService != null) {
                  try {
-                     mService.getSinrFirstStage();
+                     mService.setSinrFirstStage(textBoxVal);
                      setCmdSent = true;
                      lastCmdSent = CMD_DEFRD_SINR_FIRST_STAGE;
                  }catch (RemoteException e) {
@@ -958,7 +958,7 @@
                   return;
               if(mService != null) {
                  try {
-                     mService.getRmssiFirstStage();
+                     mService.setRmssiFirstStage(textBoxVal);
                      setCmdSent = true;
                      lastCmdSent = CMD_DEFRD_RMSSI_FIRST_STAGE;
                  }catch (RemoteException e) {
@@ -985,7 +985,7 @@
                   return;
               if(mService != null) {
                  try {
-                     mService.getCFOMeanTh();
+                     mService.setCFOMeanTh(textBoxVal);
                      setCmdSent = true;
                      lastCmdSent = CMD_DEFRD_CF0TH12;
                  }catch (RemoteException e) {
@@ -1005,7 +1005,7 @@
           Log.d(LOGTAG, "Value entered for search is: MPX DCC");
           if(mService != null) {
              try {
-                 mService.getSearchAlgoType();
+                 mService.setSearchAlgoType(MPX_DCC);
                  setCmdSent = true;
                  algo_type = MPX_DCC;
                  lastCmdSent = CMD_DEFRD_SEARCH_ALGO;
@@ -1022,7 +1022,7 @@
           Log.d(LOGTAG, "Value entered for search is: SINR INTF");
           if(mService != null) {
              try {
-                 mService.getSearchAlgoType();
+                 mService.setSearchAlgoType(SINR_INTF);
                  setCmdSent = true;
                  algo_type = SINR_INTF;
                  lastCmdSent = CMD_DEFRD_SEARCH_ALGO;
@@ -1046,7 +1046,7 @@
                   return;
               if(mService != null) {
                  try {
-                     mService.getAfJmpRmssiTh();
+                     mService.setAfJmpRmssiTh(textBoxVal);
                      setCmdSent = true;
                      lastCmdSent = CMD_DEFRD_AF_RMSSI_TH;
                  }catch (RemoteException e) {
@@ -1073,7 +1073,7 @@
                   return;
               if(mService != null) {
                  try {
-                     mService.getGoodChRmssiTh();
+                     mService.setGoodChRmssiTh(textBoxVal);
                      setCmdSent = true;
                      lastCmdSent = CMD_DEFRD_GD_CH_RMSSI_TH;
                  }catch (RemoteException e) {
@@ -1100,7 +1100,7 @@
                   return;
               if(mService != null) {
                  try {
-                     mService.getAfJmpRmssiSamplesCnt();
+                     mService.setAfJmpRmssiSamplesCnt(textBoxVal);
                      setCmdSent = true;
                      lastCmdSent = CMD_DEFRD_AF_RMSSI_SAMPLE;
                  }catch (RemoteException e) {
@@ -3652,49 +3652,12 @@
           }
           public void getSigThCb(int val, int status) {
               Log.d(LOGTAG, "getSigThCb ");
-
-              if (setCmdSent) {
-                  setCmdSent = false;
-                  if (mService != null) {
-                      try {
-                          mService.setSinrSamplesCnt(textBoxVal);
-                      } catch (RemoteException e) {
-                          e.printStackTrace();
-                      }
-                  } else {
-                      Log.e(LOGTAG, "getSigTh: Service is null");
-                  }
-              } else {
-                  Log.e(LOGTAG, "Send message: SIGNAL_THRESHOLD");
-                  mCallbackHandler.obtainMessage(SIGNAL_THRESHOLD, val, status).sendToTarget();
-              }
+              mCallbackHandler.obtainMessage(SIGNAL_THRESHOLD, val, status).sendToTarget();
           }
 
           public void getChDetThCb(int val, int status) {
               Log.d(LOGTAG, "getChDetThCb");
-
-              if (setCmdSent) {
-                  setCmdSent = false;
-                  if (mService != null) {
-                      try {
-                          if (lastCmdSent == CMD_CHDET_SINR_TH)
-                              mService.setSinrTh(textBoxVal);
-                          else if (lastCmdSent == CMD_CHDET_SINR_SAMPLE)
-                              mService.setSinrSamplesCnt(textBoxVal);
-                          else if (lastCmdSent == CMD_CHDET_INTF_TH_LOW)
-                              mService.setIntfDetLowTh(textBoxVal);
-                          else if (lastCmdSent == CMD_CHDET_INTF_TH_HIGH)
-                              mService.setIntfDetHighTh(textBoxVal);
-                      } catch (RemoteException e) {
-                          Log.e(LOGTAG, "getChDetTh: exception");
-                          e.printStackTrace();
-                      }
-                  }
-                  lastCmdSent = 0;
-              } else {
-                  Log.e(LOGTAG, "Send message: GET_CHANNEL_DET_THRESHOLD");
-                  mCallbackHandler.obtainMessage(GET_CHANNEL_DET_THRESHOLD, val, status).sendToTarget();
-              }
+              mCallbackHandler.obtainMessage(GET_CHANNEL_DET_THRESHOLD, val, status).sendToTarget();
           }
 
           public void setChDetThCb(int status)
@@ -3705,40 +3668,7 @@
 
           public void DefDataRdCb(int val, int status) {
               Log.d(LOGTAG, "DefDataRdCb");
-
-              if (setCmdSent) {
-                  setCmdSent = false;
-                  if (mService != null) {
-                      try {
-                          if (lastCmdSent == CMD_DEFRD_AF_RMSSI_TH)
-                               mService.setAfJmpRmssiTh(textBoxVal);
-                          else if (lastCmdSent == CMD_DEFRD_AF_RMSSI_SAMPLE)
-                              mService.setAfJmpRmssiSamplesCnt(textBoxVal);
-                          else if (lastCmdSent == CMD_DEFRD_GD_CH_RMSSI_TH)
-                              mService.setGoodChRmssiTh(textBoxVal);
-                          else if (lastCmdSent == CMD_DEFRD_SEARCH_ALGO)
-                              mService.setSearchAlgoType(algo_type);
-                          else if (lastCmdSent == CMD_DEFRD_SINR_FIRST_STAGE)
-                              mService.setSinrFirstStage(textBoxVal);
-                          else if (lastCmdSent == CMD_DEFRD_RMSSI_FIRST_STAGE)
-                              mService.setRmssiFirstStage(textBoxVal);
-                          else if (lastCmdSent == CMD_DEFRD_CF0TH12)
-                              mService.setCFOMeanTh(textBoxVal);
-                          else if (lastCmdSent == CMD_DEFRD_REPEATCOUNT)
-                              mService.setRxRepeatCount(textBoxVal);
-                      } catch (RemoteException e) {
-                          Log.e(LOGTAG,"DefDataRd: exception");
-                          lastCmdSent = 0;
-                          e.printStackTrace();
-                      }
-                  } else {
-                      Log.e(LOGTAG, "DefDataRd:Service is null");
-                  }
-                  lastCmdSent = 0;
-              } else {
-                  Log.e(LOGTAG, "Send message: DEFAULT_DATA_READ");
-                  mCallbackHandler.obtainMessage(DEFAULT_DATA_READ, val, status).sendToTarget();
-              }
+              mCallbackHandler.obtainMessage(DEFAULT_DATA_READ, val, status).sendToTarget();
           }
 
           public void DefDataWrtCb(int status)
@@ -3749,22 +3679,7 @@
 
           public void getBlendCb(int val, int status) {
               Log.d(LOGTAG, "getBlend");
-
-              if (setCmdSent) {
-                  setCmdSent = false;
-                  if (mReceiver != null) {
-                      if (lastCmdSent == CMD_BLENDTBL_SINR_HI)
-                          mReceiver.setBlendSinr(textBoxVal);
-                      else if (lastCmdSent == CMD_BLENDTBL_RMSSI_HI)
-                          mReceiver.setBlendRmssi(textBoxVal);
-                  } else {
-                      Log.e(LOGTAG, "getBlend: Service is null");
-                  }
-                  lastCmdSent = 0;
-              } else {
-                  Log.e(LOGTAG, "Send message: GET_BLEND_TBL");
-                  mCallbackHandler.obtainMessage(GET_BLEND_TBL, val, status).sendToTarget();
-              }
+              mCallbackHandler.obtainMessage(GET_BLEND_TBL, val, status).sendToTarget();
           }
 
           public void setBlendCb(int status)
diff --git a/helium/radio-helium.h b/helium/radio-helium.h
index adf6f93..067a40b 100644
--- a/helium/radio-helium.h
+++ b/helium/radio-helium.h
@@ -32,6 +32,7 @@
 
 #include <stdbool.h>
 
+#define HELIUM_CMD_TIME_OUT (5)
 #define MIN_TX_TONE_VAL  0x00
 #define MAX_TX_TONE_VAL  0x07
 #define MIN_HARD_MUTE_VAL  0x00
@@ -1248,6 +1249,9 @@
     struct radio_helium_device *radio;
     fm_hal_callbacks_t *jni_cb;
     void *private_data;
+    pthread_mutex_t cmd_lock;
+    pthread_cond_t cmd_cond;
+    bool set_cmd_sent;
 };
 
 struct fm_interface_t {
diff --git a/helium/radio_helium_hal.c b/helium/radio_helium_hal.c
index 2fd849a..f356f5f 100644
--- a/helium/radio_helium_hal.c
+++ b/helium/radio_helium_hal.c
@@ -118,6 +118,13 @@
     if (hal->radio->mode == FM_TURNING_OFF) {
         ALOGD("%s:calling fm close\n", LOG_TAG );
         fm_hci_close(hal->private_data);
+        free(hal->radio);
+        hal->radio = NULL;
+        hal->jni_cb = NULL;
+        pthread_cond_destroy(&hal->cmd_cond);
+        pthread_mutex_destroy(&hal->cmd_lock);
+        free(hal);
+        hal = NULL;
     }
 }
 
@@ -244,7 +251,14 @@
             val = hal->radio->ch_det_threshold.high_th;
     }
     clear_all_bit(ch_det_th_mask_flag);
-    hal->jni_cb->fm_get_ch_det_thr_cb(val, status);
+
+    if (!hal->set_cmd_sent)
+        hal->jni_cb->fm_get_ch_det_thr_cb(val, status);
+    else {
+        pthread_mutex_lock(&hal->cmd_lock);
+        pthread_cond_broadcast(&hal->cmd_cond);
+        pthread_mutex_unlock(&hal->cmd_lock);
+    }
 }
 
 static void hci_cc_set_ch_det_threshold_rsp(char *ev_buff)
@@ -327,7 +341,15 @@
     } else {
         ALOGE("%s: Error: Status= 0x%x", __func__, status);
     }
-    hal->jni_cb->fm_def_data_read_cb(val, status);
+    if (!hal->set_cmd_sent)
+        hal->jni_cb->fm_def_data_read_cb(val, status);
+    else {
+        pthread_mutex_lock(&hal->cmd_lock);
+        pthread_cond_broadcast(&hal->cmd_cond);
+        pthread_mutex_unlock(&hal->cmd_lock);
+    }
+
+
 }
 
 static void hci_cc_default_data_write_rsp(char *ev_buff)
@@ -353,18 +375,28 @@
         memcpy(&hal->radio->blend_tbl, &ev_buff[1],
                 sizeof(struct hci_fm_blend_table));
 
-        ALOGE("hci_cc_get_blend_tbl_rsp: data");
+        ALOGD("hci_cc_get_blend_tbl_rsp: data");
         int i;
         for (i = 0; i < 8; i++)
             ALOGE("data[%d] = 0x%x", i, ev_buff[1 + i]);
         if (test_bit(blend_tbl_mask_flag, CMD_BLENDTBL_SINR_HI)) {
             val = hal->radio->blend_tbl.BlendSinrHi;
+            ALOGE("%s: Sinrhi val = %d", LOG_TAG, val);
+            clear_bit(blend_tbl_mask_flag, CMD_BLENDTBL_SINR_HI);
         } else if (test_bit(blend_tbl_mask_flag, CMD_BLENDTBL_RMSSI_HI)) {
             val = hal->radio->blend_tbl.BlendRmssiHi;
+            ALOGE("%s: BlendRmssiHi val = %d", LOG_TAG, val);
+            clear_bit(blend_tbl_mask_flag, CMD_BLENDTBL_RMSSI_HI);
         }
     }
-    clear_all_bit(blend_tbl_mask_flag);
-    hal->jni_cb->fm_get_blend_cb(val, status);
+
+    if (!hal->set_cmd_sent)
+        hal->jni_cb->fm_get_blend_cb(val, status);
+    else {
+        pthread_mutex_lock(&hal->cmd_lock);
+        pthread_cond_broadcast(&hal->cmd_cond);
+        pthread_mutex_unlock(&hal->cmd_lock);
+    }
 }
 
 static void hci_cc_set_blend_tbl_rsp(char *ev_buff)
@@ -1167,6 +1199,59 @@
     return retval;
 }
 
+static int helium_send_hci_cmd(int cmd, void *cmd_param)
+{
+    int ret = FM_HC_STATUS_FAIL;
+    struct timespec ts;
+    struct hci_fm_default_data_read_req *rd;
+
+    pthread_mutex_lock(&(hal->cmd_lock));
+    hal->set_cmd_sent = true;
+    switch (cmd) {
+        case HCI_FM_HELIUM_SINR_SAMPLES:
+        case HCI_FM_HELIUM_SINR_THRESHOLD:
+        case HCI_FM_HELIUM_INTF_LOW_THRESHOLD:
+        case HCI_FM_HELIUM_INTF_HIGH_THRESHOLD:
+            ret = hci_fm_get_ch_det_th();
+            break;
+        case HCI_FM_HELIUM_SINRFIRSTSTAGE:
+        case HCI_FM_HELIUM_RMSSIFIRSTSTAGE:
+        case HCI_FM_HELIUM_CF0TH12:
+        case HCI_FM_HELIUM_SRCHALGOTYPE:
+        case HCI_FM_HELIUM_AF_RMSSI_TH:
+        case HCI_FM_HELIUM_GOOD_CH_RMSSI_TH:
+        case HCI_FM_HELIUM_AF_RMSSI_SAMPLES:
+        case HCI_FM_HELIUM_RXREPEATCOUNT:
+        case HCI_FM_HELIUM_AF_ALGO:
+        case HCI_FM_HELIUM_AF_SINR_GD_CH_TH:
+        case HCI_FM_HELIUM_AF_SINR_TH:
+            rd = (struct hci_fm_default_data_read_req *) cmd_param;
+            ret = hci_fm_default_data_read_req(rd);
+            break;
+        case HCI_FM_HELIUM_BLEND_SINRHI:
+            ret = hci_fm_get_blend_req();
+            break;
+        case HCI_FM_HELIUM_BLEND_RMSSIHI:
+            ret = hci_fm_get_blend_req();
+            break;
+    }
+    if (ret == FM_HC_STATUS_SUCCESS) {
+        if ((ret = clock_gettime(CLOCK_REALTIME, &ts)) == 0) {
+            ts.tv_sec += HELIUM_CMD_TIME_OUT;
+            ALOGD("%s:waiting for cmd %d response ", LOG_TAG, cmd);
+            ret = pthread_cond_timedwait(&hal->cmd_cond, &hal->cmd_lock,
+                    &ts);
+            ALOGD("%s: received %d cmd response.", LOG_TAG, cmd);
+        } else {
+            ALOGE("%s: clock gettime failed. err = %d(%s)", LOG_TAG,
+                    errno, strerror(errno));
+        }
+    }
+    hal->set_cmd_sent = false;
+    pthread_mutex_unlock(&hal->cmd_lock);
+
+    return ret;
+}
 
 /* Callback function to be registered with FM-HCI for event notification */
 static struct fm_hci_callbacks_t hal_cb = {
@@ -1191,6 +1276,11 @@
     }
     memset(hal, 0, sizeof(struct fm_hal_t));
     hal->jni_cb = cb;
+
+    pthread_mutex_init(&hal->cmd_lock, NULL);
+    pthread_cond_init(&hal->cmd_cond, NULL);
+    hal->set_cmd_sent = false;
+
     hal->radio = malloc(sizeof(struct radio_helium_device));
     if (!hal->radio) {
         ALOGE("%s:Failed to allocate memory for device", __func__);
@@ -1220,6 +1310,8 @@
             hal->radio = NULL;
         }
         hal->jni_cb = NULL;
+        pthread_cond_destroy(&hal->cmd_cond);
+        pthread_mutex_destroy(&hal->cmd_lock);
         free(hal);
         hal = NULL;
     }
@@ -1235,6 +1327,7 @@
     unsigned int rds_grps_proc = 0;
     char *data;
     struct hci_fm_def_data_wr_req def_data_wrt;
+    struct hci_fm_def_data_rd_req def_data_rd;
 
     if (!hal) {
         ALOGE("%s:ALERT: command sent before hal init", __func__);
@@ -1522,7 +1615,12 @@
              ret = -1;
              goto end;
          }
-         hal->radio->ch_det_threshold.sinr_samples = val;
+         ret = helium_send_hci_cmd(cmd, NULL);
+         if (ret != FM_HC_STATUS_SUCCESS) {
+             ALOGE("%s: 0x%x cmd failed", LOG_TAG, cmd);
+             goto end;
+         }
+         hal->radio->ch_det_threshold.sinr_samples = (char)val;
          ret = set_ch_det_thresholds_req(&hal->radio->ch_det_threshold);
          if (ret < 0) {
              ALOGE("Failed to set SINR samples  %d", ret);
@@ -1535,7 +1633,12 @@
              ret = -1;
              goto end;
          }
-         hal->radio->ch_det_threshold.sinr = val;
+         ret = helium_send_hci_cmd(cmd, NULL);
+         if (ret != FM_HC_STATUS_SUCCESS) {
+             ALOGE("%s: 0x%x cmd failed", LOG_TAG, cmd);
+             goto end;
+         }
+         hal->radio->ch_det_threshold.sinr = (char)val;
          ret = set_ch_det_thresholds_req(&hal->radio->ch_det_threshold);
          break;
     case HCI_FM_HELIUM_INTF_LOW_THRESHOLD:
@@ -1544,7 +1647,12 @@
              ret = -1;
              goto end;
          }
-         hal->radio->ch_det_threshold.low_th = val;
+         ret = helium_send_hci_cmd(cmd, NULL);
+         if (ret != FM_HC_STATUS_SUCCESS) {
+             ALOGE("%s: 0x%x cmd failed", LOG_TAG, cmd);
+             goto end;
+         }
+         hal->radio->ch_det_threshold.low_th = (char)val;
          ret = set_ch_det_thresholds_req(&hal->radio->ch_det_threshold);
          break;
     case HCI_FM_HELIUM_INTF_HIGH_THRESHOLD:
@@ -1553,10 +1661,25 @@
              ret = -1;
              goto end;
          }
-         hal->radio->ch_det_threshold.high_th = val;
+         ret = helium_send_hci_cmd(cmd, NULL);
+         if (ret != FM_HC_STATUS_SUCCESS) {
+             ALOGE("%s: 0x%x cmd failed", LOG_TAG, cmd);
+             goto end;
+         }
+         hal->radio->ch_det_threshold.high_th = (char)val;
          ret = set_ch_det_thresholds_req(&hal->radio->ch_det_threshold);
          break;
     case HCI_FM_HELIUM_SINRFIRSTSTAGE:
+         def_data_rd.mode = FM_SRCH_CONFG_MODE;
+         def_data_rd.length = FM_SRCH_CNFG_LEN;
+         def_data_rd.param_len = 0;
+         def_data_rd.param = 0;
+
+         ret = helium_send_hci_cmd(cmd, (void *)&def_data_rd);
+         if (ret != FM_HC_STATUS_SUCCESS) {
+             ALOGE("%s: 0x%x cmd failed", LOG_TAG, cmd);
+             goto end;
+         }
          def_data_wrt.mode = FM_SRCH_CONFG_MODE;
          def_data_wrt.length = FM_SRCH_CNFG_LEN;
          memcpy(&def_data_wrt.data, &hal->radio->def_data.data,
@@ -1565,6 +1688,16 @@
          ret = hci_fm_default_data_write_req(&def_data_wrt);
          break;
     case HCI_FM_HELIUM_RMSSIFIRSTSTAGE:
+         def_data_rd.mode = FM_SRCH_CONFG_MODE;
+         def_data_rd.length = FM_SRCH_CNFG_LEN;
+         def_data_rd.param_len = 0;
+         def_data_rd.param = 0;
+
+         ret = helium_send_hci_cmd(cmd, (void *)&def_data_rd);
+         if (ret != FM_HC_STATUS_SUCCESS) {
+             ALOGE("%s: 0x%x cmd failed", LOG_TAG, cmd);
+             goto end;
+         }
          def_data_wrt.mode = FM_SRCH_CONFG_MODE;
          def_data_wrt.length = FM_SRCH_CNFG_LEN;
          memcpy(&def_data_wrt.data, &hal->radio->def_data.data,
@@ -1573,6 +1706,16 @@
          ret = hci_fm_default_data_write_req(&def_data_wrt);
          break;
     case HCI_FM_HELIUM_CF0TH12:
+         def_data_rd.mode = FM_SRCH_CONFG_MODE;
+         def_data_rd.length = FM_SRCH_CNFG_LEN;
+         def_data_rd.param_len = 0;
+         def_data_rd.param = 0;
+
+         ret = helium_send_hci_cmd(cmd, (void *)&def_data_rd);
+         if (ret != FM_HC_STATUS_SUCCESS) {
+             ALOGE("%s: 0x%x cmd failed", LOG_TAG, cmd);
+             goto end;
+         }
          def_data_wrt.mode = FM_SRCH_CONFG_MODE;
          def_data_wrt.length = FM_SRCH_CNFG_LEN;
          memcpy(&def_data_wrt.data, &hal->radio->def_data.data,
@@ -1582,6 +1725,16 @@
          ret = hci_fm_default_data_write_req(&def_data_wrt);
          break;
     case HCI_FM_HELIUM_SRCHALGOTYPE:
+         def_data_rd.mode = FM_SRCH_CONFG_MODE;
+         def_data_rd.length = FM_SRCH_CNFG_LEN;
+         def_data_rd.param_len = 0;
+         def_data_rd.param = 0;
+
+         ret = helium_send_hci_cmd(cmd, (void *)&def_data_rd);
+         if (ret != FM_HC_STATUS_SUCCESS) {
+             ALOGE("%s: 0x%x cmd failed", LOG_TAG, cmd);
+             goto end;
+         }
          def_data_wrt.mode = FM_SRCH_CONFG_MODE;
          def_data_wrt.length = FM_SRCH_CNFG_LEN;
          memcpy(&def_data_wrt.data, &hal->radio->def_data.data,
@@ -1590,6 +1743,16 @@
          ret = hci_fm_default_data_write_req(&def_data_wrt);
          break;
     case HCI_FM_HELIUM_AF_RMSSI_TH:
+         def_data_rd.mode = FM_AFJUMP_CONFG_MODE;
+         def_data_rd.length = FM_AFJUMP_CNFG_LEN;
+         def_data_rd.param_len = 0;
+         def_data_rd.param = 0;
+
+         ret = helium_send_hci_cmd(cmd, (void *)&def_data_rd);
+         if (ret != FM_HC_STATUS_SUCCESS) {
+             ALOGE("%s: 0x%x cmd failed", LOG_TAG, cmd);
+             goto end;
+         }
          def_data_wrt.mode = FM_AFJUMP_CONFG_MODE;
          def_data_wrt.length = FM_AFJUMP_CNFG_LEN;
          memcpy(&def_data_wrt.data, &hal->radio->def_data.data,
@@ -1598,6 +1761,16 @@
          ret = hci_fm_default_data_write_req(&def_data_wrt);
          break;
     case HCI_FM_HELIUM_GOOD_CH_RMSSI_TH:
+         def_data_rd.mode = FM_AFJUMP_CONFG_MODE;
+         def_data_rd.length = FM_AFJUMP_CNFG_LEN;
+         def_data_rd.param_len = 0;
+         def_data_rd.param = 0;
+
+         ret = helium_send_hci_cmd(cmd, (void *)&def_data_rd);
+         if (ret != FM_HC_STATUS_SUCCESS) {
+             ALOGE("%s: 0x%x cmd failed", LOG_TAG, cmd);
+             goto end;
+         }
          def_data_wrt.mode = FM_AFJUMP_CONFG_MODE;
          def_data_wrt.length = FM_AFJUMP_CNFG_LEN;
          memcpy(&def_data_wrt.data, &hal->radio->def_data.data,
@@ -1606,6 +1779,16 @@
          ret = hci_fm_default_data_write_req(&def_data_wrt);
          break;
     case HCI_FM_HELIUM_AF_RMSSI_SAMPLES:
+         def_data_rd.mode = FM_AFJUMP_CONFG_MODE;
+         def_data_rd.length = FM_AFJUMP_CNFG_LEN;
+         def_data_rd.param_len = 0;
+         def_data_rd.param = 0;
+
+         ret = helium_send_hci_cmd(cmd, (void *)&def_data_rd);
+         if (ret != FM_HC_STATUS_SUCCESS) {
+             ALOGE("%s: 0x%x cmd failed", LOG_TAG, cmd);
+             goto end;
+         }
          def_data_wrt.mode = FM_AFJUMP_CONFG_MODE;
          def_data_wrt.length = FM_AFJUMP_CNFG_LEN;
          memcpy(&def_data_wrt.data, &hal->radio->def_data.data,
@@ -1614,6 +1797,16 @@
          ret = hci_fm_default_data_write_req(&def_data_wrt);
          break;
     case HCI_FM_HELIUM_RXREPEATCOUNT:
+         def_data_rd.mode = RDS_PS0_XFR_MODE;
+         def_data_rd.length = RDS_PS0_LEN;
+         def_data_rd.param_len = 0;
+         def_data_rd.param = 0;
+
+         ret = helium_send_hci_cmd(cmd, (void *)&def_data_rd);
+         if (ret != FM_HC_STATUS_SUCCESS) {
+             ALOGE("%s: 0x%x cmd failed", LOG_TAG, cmd);
+             goto end;
+         }
          def_data_wrt.mode = RDS_PS0_XFR_MODE;
          def_data_wrt.length = RDS_PS0_LEN;
          memcpy(&def_data_wrt.data, &hal->radio->def_data.data,
@@ -1622,6 +1815,16 @@
          ret = hci_fm_default_data_write_req(&def_data_wrt);
          break;
     case HCI_FM_HELIUM_AF_ALGO:
+         def_data_rd.mode = FM_AFJUMP_CONFG_MODE;
+         def_data_rd.length = FM_AFJUMP_CNFG_LEN;
+         def_data_rd.param_len = 0;
+         def_data_rd.param = 0;
+
+         ret = helium_send_hci_cmd(cmd, (void *)&def_data_rd);
+         if (ret != FM_HC_STATUS_SUCCESS) {
+             ALOGE("%s: 0x%x cmd failed", LOG_TAG, cmd);
+             goto end;
+         }
          def_data_wrt.mode = FM_AFJUMP_CONFG_MODE;
          def_data_wrt.length = FM_AFJUMP_CNFG_LEN;
          memcpy(&def_data_wrt.data, &hal->radio->def_data.data,
@@ -1630,6 +1833,16 @@
          ret = hci_fm_default_data_write_req(&def_data_wrt);
          break;
     case HCI_FM_HELIUM_AF_SINR_GD_CH_TH:
+         def_data_rd.mode = FM_AFJUMP_CONFG_MODE;
+         def_data_rd.length = FM_AFJUMP_CNFG_LEN;
+         def_data_rd.param_len = 0;
+         def_data_rd.param = 0;
+
+         ret = helium_send_hci_cmd(cmd, (void *)&def_data_rd);
+         if (ret != FM_HC_STATUS_SUCCESS) {
+             ALOGE("%s: 0x%x cmd failed", LOG_TAG, cmd);
+             goto end;
+         }
          def_data_wrt.mode = FM_AFJUMP_CONFG_MODE;
          def_data_wrt.length = FM_AFJUMP_CNFG_LEN;
          memcpy(&def_data_wrt.data, &hal->radio->def_data.data,
@@ -1638,6 +1851,16 @@
          ret = hci_fm_default_data_write_req(&def_data_wrt);
          break;
     case HCI_FM_HELIUM_AF_SINR_TH:
+         def_data_rd.mode = FM_AFJUMP_CONFG_MODE;
+         def_data_rd.length = FM_AFJUMP_CNFG_LEN;
+         def_data_rd.param_len = 0;
+         def_data_rd.param = 0;
+
+         ret = helium_send_hci_cmd(cmd, (void *)&def_data_rd);
+         if (ret != FM_HC_STATUS_SUCCESS) {
+             ALOGE("%s: 0x%x cmd failed", LOG_TAG, cmd);
+             goto end;
+         }
          def_data_wrt.mode = FM_AFJUMP_CONFG_MODE;
          def_data_wrt.length = FM_AFJUMP_CNFG_LEN;
          memcpy(&def_data_wrt.data, &hal->radio->def_data.data,
@@ -1651,7 +1874,13 @@
              ret = -1;
              goto end;
          }
-         hal->radio->blend_tbl.BlendSinrHi = val;
+         ret = helium_send_hci_cmd(cmd, NULL);
+         if (ret != FM_HC_STATUS_SUCCESS) {
+             ALOGE("%s: 0x%x cmd failed", LOG_TAG, cmd);
+             goto end;
+         }
+
+         hal->radio->blend_tbl.BlendSinrHi = (char)val;
          ret = hci_fm_set_blend_tbl_req(&hal->radio->blend_tbl);
          break;
     case HCI_FM_HELIUM_BLEND_RMSSIHI:
@@ -1660,13 +1889,19 @@
              ret = -1;
              goto end;
          }
-         hal->radio->blend_tbl.BlendRmssiHi = val;
+         ret = helium_send_hci_cmd(cmd, NULL);
+         if (ret != FM_HC_STATUS_SUCCESS) {
+             ALOGE("%s: 0x%x cmd failed", LOG_TAG, cmd);
+             goto end;
+         }
+
+         hal->radio->blend_tbl.BlendRmssiHi = (char)val;
          ret = hci_fm_set_blend_tbl_req(&hal->radio->blend_tbl);
          break;
     case HCI_FM_HELIUM_ENABLE_LPF:
          ALOGI("%s: val: %x", __func__, val);
          if (!(ret = hci_fm_enable_lpf(val))) {
-             ALOGI("%s: command sent sucessfully", __func__, val);
+             ALOGI("%s: command sent sucessfully", __func__);
          }
          break;
     case HCI_FM_HELIUM_AUDIO:
@@ -1680,7 +1915,7 @@
     }
 end:
     if (ret < 0)
-        ALOGE("%s:%s: %d cmd failed", LOG_TAG, __func__, cmd);
+        ALOGE("%s:%s: 0x%x cmd failed", LOG_TAG, __func__, cmd);
     return ret;
 }
 
@@ -1813,6 +2048,7 @@
         ret = hci_fm_get_blend_req();
         if (ret != FM_HC_STATUS_SUCCESS)
             clear_bit(blend_tbl_mask_flag, CMD_BLENDTBL_SINR_HI);
+        break;
     case HCI_FM_HELIUM_BLEND_RMSSIHI:
         set_bit(blend_tbl_mask_flag, CMD_BLENDTBL_RMSSI_HI);
         ret = hci_fm_get_blend_req();
diff --git a/jni/android_hardware_fm.cpp b/jni/android_hardware_fm.cpp
index 7895e4c..5cb7318 100644
--- a/jni/android_hardware_fm.cpp
+++ b/jni/android_hardware_fm.cpp
@@ -539,7 +539,7 @@
 static void fm_enable_slimbus_cb(int status)
 {
     ALOGD("++fm_enable_slimbus_cb mCallbacksObjCreated: %d", mCallbacksObjCreated);
-
+    slimbus_flag = 1;
     if (mCallbacksObjCreated == false) {
         jobject javaObjectRef =  mCallbackEnv->NewObject(javaClassRef, method_enableSlimbusCallback);
         mCallbacksObj = javaObjectRef;
@@ -551,8 +551,7 @@
         return;
 
     mCallbackEnv->CallVoidMethod(mCallbacksObj, method_enableSlimbusCallback, status);
-    slimbus_flag = 1;
-    ALOGV("--fm_enable_slimbus_cb");
+    ALOGD("--fm_enable_slimbus_cb");
 }
 
 typedef struct {