diff --git a/fm_hci/fm_hci.c b/fm_hci/fm_hci.c
index 0cf2de8..d559b74 100644
--- a/fm_hci/fm_hci.c
+++ b/fm_hci/fm_hci.c
@@ -265,8 +265,7 @@
                         } else if (pbuf->evt_code == FM_HW_ERR_EVENT) {
                               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(0x22);
+                              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;
diff --git a/fmapp2/src/com/caf/fmradio/FMRadioService.java b/fmapp2/src/com/caf/fmradio/FMRadioService.java
index 866b196..0c5713b 100644
--- a/fmapp2/src/com/caf/fmradio/FMRadioService.java
+++ b/fmapp2/src/com/caf/fmradio/FMRadioService.java
@@ -2125,7 +2125,7 @@
             Log.d(LOGTAG, "fmOn: RdsStd      :"+ config.getRdsStd());
             Log.d(LOGTAG, "fmOn: LowerLimit  :"+ config.getLowerLimit());
             Log.d(LOGTAG, "fmOn: UpperLimit  :"+ config.getUpperLimit());
-            bStatus = mReceiver.enable(FmSharedPreferences.getFMConfiguration());
+            bStatus = mReceiver.enable(FmSharedPreferences.getFMConfiguration(), this);
             if (isSpeakerEnabled()) {
                 setAudioPath(false);
             } else {
@@ -2283,7 +2283,7 @@
       // This will disable the FM radio device
       if (mReceiver != null)
       {
-         bStatus = mReceiver.disable();
+         bStatus = mReceiver.disable(this);
          mReceiver = null;
       }
       fmOperationsOff();
diff --git a/fmapp2/src/com/caf/fmradio/FMStats.java b/fmapp2/src/com/caf/fmradio/FMStats.java
index 1c506c4..091b1b3 100644
--- a/fmapp2/src/com/caf/fmradio/FMStats.java
+++ b/fmapp2/src/com/caf/fmradio/FMStats.java
@@ -276,6 +276,7 @@
 
     private Thread mRecordUpdateHandlerThread = null;
     private Thread mRunTestThread = null;
+    private Thread mTuneCompleteThread = null;
     boolean mRecording = false;
 
 
@@ -465,12 +466,10 @@
                         if (lastCmdSent == CMD_STNPARAM_SINR)
                             nSINR = msg.arg1;
                     }
-                    if (mRunTestThread !=  null) {
-                        synchronized (obj) {
-                            obj.notify();
-                        }
-                    }
-                    lastCmdSent = 0;
+					synchronized (obj) {
+						obj.notify();
+					}
+					lastCmdSent = 0;
                     break;
                 case GET_STATION_DBG_PARAM:
                     status = msg.arg2;
@@ -484,12 +483,10 @@
                         if  (lastCmdSent == CMD_STNDBGPARAM_INFDETOUT)
                             nIntDet = msg.arg1;
                     }
-                    if (mRunTestThread !=  null) {
-                        synchronized (obj) {
-                            mRunTestThread.notify();
-                        }
-                    }
-                    break;
+					synchronized (obj) {
+						obj.notify();
+					}
+					break;
                 default:
                     Log.e(LOGTAG, "mCallbackHandler:Default");
                     break;
@@ -535,9 +532,6 @@
         if(mUIUpdateHandlerHandler != null) {
            mUIUpdateHandlerHandler.removeCallbacksAndMessages(null);
         }
-        if(mHandler != null) {
-           mHandler.removeCallbacksAndMessages(null);
-        }
         unRegisterBroadcastReceiver(mBandSweepDelayExprdListener);
         unRegisterBroadcastReceiver(mBandSweepDwellExprdListener);
         if(null != mFileCursor ) {
@@ -563,6 +557,28 @@
         }
     };
 
+     private Runnable mTuneComplete = new Runnable(){
+         public void run(){
+             if((null != mMultiUpdateThread) &&(null != mSync))
+             {
+                 synchronized(mSync){
+                     mSync.notify();
+                 }
+             }
+            if((mTestSelected == SEARCH_TEST) && (mService != null)) {
+                /* On every Tune Complete generate the result for the current
+                Frequency*/
+                Message updateUI = new Message();
+                updateUI.what = STATUS_UPDATE;
+                int freq = FmSharedPreferences.getTunedFrequency();
+                updateUI.obj = (Object)GetFMStatsForFreq(freq);
+                if (updateUI.obj == null)
+                    updateUI.what = STATUS_DONE;
+                mUIUpdateHandlerHandler.sendMessage(updateUI);
+            }
+         }
+     };
+
     private View.OnClickListener mOnRunListener = new View.OnClickListener() {
         public void onClick(View v) {
             Log.d(LOGTAG, "mTestRunning=" + mTestRunning);
@@ -2880,12 +2896,12 @@
     private boolean isCherokeeChip() {
         Log.d(LOGTAG, "isCherokeeChip");
 
-		String chip = SystemProperties.get("qcom.bluetooth.soc");
-		if (chip.equals("cherokee"))
-			return true;
-		else
-			return false;
-	}
+        String chip = SystemProperties.get("qcom.bluetooth.soc");
+        if (chip.equals("cherokee"))
+            return true;
+        else
+            return false;
+    }
 
     private boolean isRomeChip() {
         String chip = "";
@@ -3515,8 +3531,21 @@
           public void onTuneStatusChanged()
           {
              Log.d(LOGTAG, "mServiceCallbacks.onTuneStatusChanged :" + mTestRunning);
-             if (mTestRunning)
-                 mHandler.post(mTuneComplete);
+             if (mTestRunning) {
+                 if ((mTuneCompleteThread == null) || (mTuneCompleteThread.getState() == Thread.State.TERMINATED)) {
+                     mTuneCompleteThread = new Thread(mTuneComplete,
+                                                "mTuneCompleteThread");
+                 } else {
+                     Log.e(LOGTAG, "mTuneCompleteThread is already running");
+                     return;
+                 }
+                 if (mTuneCompleteThread != null) {
+                     mTuneCompleteThread.start();
+                 } else {
+                     Log.e(LOGTAG, "mTuneCompleteThread: new thread create failed");
+                     return;
+                 }
+             }
           }
 
           public void onProgramServiceChanged()
@@ -3737,30 +3766,6 @@
               mCallbackHandler.obtainMessage(GET_STATION_DBG_PARAM, val, status).sendToTarget();
           }
       };
-      /* Radio Vars */
-     private Handler mHandler = new Handler();
-
-     private Runnable mTuneComplete = new Runnable(){
-         public void run(){
-             if((null != mMultiUpdateThread) &&(null != mSync))
-             {
-                 synchronized(mSync){
-                     mSync.notify();
-                 }
-             }
-            if((mTestSelected == SEARCH_TEST) && (mService != null)) {
-                /* On every Tune Complete generate the result for the current
-                Frequency*/
-                Message updateUI = new Message();
-                updateUI.what = STATUS_UPDATE;
-                int freq = FmSharedPreferences.getTunedFrequency();
-                updateUI.obj = (Object)GetFMStatsForFreq(freq);
-                if (updateUI.obj == null)
-                    updateUI.what = STATUS_DONE;
-                mUIUpdateHandlerHandler.sendMessage(updateUI);
-            }
-         }
-     };
 
      private void stopCurTest() {
          if (mRunTestThread != null) {
@@ -3779,7 +3784,8 @@
                       mMultiUpdateThread.interrupt();
                   break;
              case SEARCH_TEST:
-                  mHandler.removeCallbacks(mTuneComplete);
+                  if (mTuneCompleteThread != null)
+                      mTuneCompleteThread.interrupt();
                   if (mService != null) {
                       try {
                            Message updateStop = new Message();
diff --git a/fmapp2/src/com/caf/fmradio/FMTransmitterService.java b/fmapp2/src/com/caf/fmradio/FMTransmitterService.java
index 021e468..e3cf3d6 100644
--- a/fmapp2/src/com/caf/fmradio/FMTransmitterService.java
+++ b/fmapp2/src/com/caf/fmradio/FMTransmitterService.java
@@ -530,7 +530,7 @@
       /* Disable Receiver */
       if (mReceiver != null)
       {
-         bStatus = mReceiver.disable();
+         bStatus = mReceiver.disable(this);
          mReceiver = null;
       }
       RText = " ";
@@ -585,7 +585,7 @@
       /* Disable Receiver */
       if (mReceiver != null)
       {
-         bStatus = mReceiver.disable();
+         bStatus = mReceiver.disable(this);
          mReceiver = null;
       }
       try {
@@ -705,7 +705,7 @@
            mFMOn = false;
        }
        if(null != mReceiver) {
-           mReceiver.disable();
+           mReceiver.disable(this);
            mReceiver = null;
        }
        try {
@@ -723,14 +723,14 @@
             throw new RuntimeException("FmTx service not available!");
            }
            if (mReceiver.getFMState() == mReceiver.FMState_Turned_Off) {
-               bStatus = mReceiver.enable(config);
+               bStatus = mReceiver.enable(config, this);
            } else {
                try {
                    Thread.sleep(100);
                } catch (Exception ex) {
                    Log.d( LOGTAG,  "RunningThread InterruptedException");
                }
-               bStatus = mReceiver.enable(config);
+               bStatus = mReceiver.enable(config, this);
            }
            if (!bStatus) {
                Log.e( LOGTAG,  "Search for weak station failed");
diff --git a/helium/radio-helium-commands.h b/helium/radio-helium-commands.h
index 352017e..c5dfba9 100644
--- a/helium/radio-helium-commands.h
+++ b/helium/radio-helium-commands.h
@@ -97,8 +97,10 @@
     HCI_FM_HELIUM_AF_JUMP_RSSI_TH,
     HCI_FM_HELIUM_BLEND_SINRHI,
     HCI_FM_HELIUM_BLEND_RMSSIHI,
+    HCI_FM_HELIUM_RDS_GRP_COUNTERS_EXT,
     HCI_FM_HELIUM_AGC_UCCTRL = 0x8000043, /* 0x8000043 */
     HCI_FM_HELIUM_AGC_GAIN_STATE,
+    HCI_FM_HELIUM_ENABLE_LPF,
 
     /*using private CIDs under userclass*/
     HCI_FM_HELIUM_READ_DEFAULT = 0x00980928,
diff --git a/helium/radio-helium.h b/helium/radio-helium.h
index cb72cd5..30c3d0c 100644
--- a/helium/radio-helium.h
+++ b/helium/radio-helium.h
@@ -164,6 +164,7 @@
 typedef void (*disable_cb)();
 typedef void (*callback_thread_event)(unsigned int evt);
 typedef void (*rds_grp_cntrs_cb)(char *rds_params);
+typedef void (*rds_grp_cntrs_ext_cb)(char *rds_params);
 typedef void (*fm_peek_cb)(char *peek_rsp);
 typedef void (*fm_ssbi_peek_cb)(char *ssbi_peek_rsp);
 typedef void (*fm_agc_gain_cb)(char *agc_gain_rsp);
@@ -197,6 +198,7 @@
     ert_cb  ert_update_cb;
     disable_cb  disabled_cb;
     rds_grp_cntrs_cb rds_grp_cntrs_rsp_cb;
+	rds_grp_cntrs_ext_cb rds_grp_cntrs_ext_rsp_cb;
     fm_peek_cb fm_peek_rsp_cb;
     fm_ssbi_peek_cb fm_ssbi_peek_rsp_cb;
     fm_agc_gain_cb fm_agc_gain_rsp_cb;
@@ -281,6 +283,7 @@
 #define HCI_OCF_FM_GET_CH_DET_THRESHOLD     0x0018
 #define HCI_OCF_FM_SET_BLND_TBL             0x001B
 #define HCI_OCF_FM_GET_BLND_TBL             0x001C
+#define HCI_OCF_FM_LOW_PASS_FILTER_CTRL     0x001F
 /* HCI trans control commans opcode*/
 #define HCI_OCF_FM_ENABLE_TRANS_REQ         0x0001
 #define HCI_OCF_FM_DISABLE_TRANS_REQ        0x0002
@@ -304,6 +307,9 @@
 /*HCI Status parameters commands*/
 #define HCI_OCF_FM_READ_GRP_COUNTERS        0x0001
 
+#define HCI_OCF_FM_READ_GRP_COUNTERS_EXT    0x0002
+
+
 /*HCI Diagnostic commands*/
 #define HCI_OCF_FM_PEEK_DATA                0x0002
 #define HCI_OCF_FM_POKE_DATA                0x0003
@@ -1250,6 +1256,7 @@
 int hci_fm_set_recv_conf_req (struct hci_fm_recv_conf_req *conf);
 int hci_fm_get_program_service_req ();
 int hci_fm_get_rds_grpcounters_req (int val);
+int hci_fm_get_rds_grpcounters_ext_req (int val);
 int hci_fm_set_notch_filter_req (int val);
 int helium_set_sig_threshold_req(char th);
 int helium_rds_grp_mask_req(struct hci_fm_rds_grp_req *rds_grp_msk);
@@ -1269,6 +1276,7 @@
 int hci_fm_default_data_read_req(struct hci_fm_def_data_rd_req *def_data_rd);
 int hci_fm_get_blend_req();
 int hci_fm_set_blend_tbl_req(struct hci_fm_blend_table *blnd_tbl);
+int hci_fm_enable_lpf(int enable);
 int hci_fm_default_data_write_req(struct hci_fm_def_data_wr_req * data_wrt);
 int hci_fm_get_station_dbg_param_req();
 int hci_fm_get_station_cmd_param_req();
diff --git a/helium/radio_helium_hal.c b/helium/radio_helium_hal.c
index 2412b42..e6ab1b1 100644
--- a/helium/radio_helium_hal.c
+++ b/helium/radio_helium_hal.c
@@ -105,7 +105,7 @@
 static void hci_cc_fm_disable_rsp(char *ev_buff)
 {
     char status;
-	int ret;
+    int ret;
 
     if (ev_buff == NULL) {
         ALOGE("%s:%s, buffer is null\n", LOG_TAG, __func__);
@@ -115,15 +115,13 @@
     status = (char) *ev_buff;
     radio_hci_req_complete(status);
     if (radio->mode == FM_TURNING_OFF) {
-        jni_cb->disabled_cb();
         radio->mode = FM_OFF;
         jni_cb->disabled_cb();
         jni_cb->thread_evt_cb(1);
         //close the userial port and power off the chip
         ret = fm_power(FM_RADIO_DISABLE);
         ALOGI("fm power off status = %d", ret);
-    	ALOGE("%s:calling fm userial close\n", LOG_TAG );
-	//	sleep(1);
+        ALOGI("%s:calling fm userial close\n", LOG_TAG );
         fm_userial_close();
     //  fm_power(FM_RADIO_DISABLE);
     }
@@ -150,14 +148,29 @@
         return;
     }
     status = ev_buff[0];
-    ALOGE("%s:%s, status =%d\n", LOG_TAG, __func__,status);
-    if(status < 0)
-    {
+    ALOGI("%s:%s, status =%d\n", LOG_TAG, __func__,status);
+    if (status < 0) {
         ALOGE("%s:%s, read rds_grp_cntrs failed status=%d\n", LOG_TAG, __func__,status);
     }
     jni_cb->rds_grp_cntrs_rsp_cb(&ev_buff[1]);
 }
 
+static void hci_cc_rds_grp_cntrs_ext_rsp(char *ev_buff)
+{
+    char status;
+    int i;
+    if (ev_buff == NULL) {
+        ALOGE("%s:%s, buffer is null\n", LOG_TAG, __func__);
+        return;
+    }
+    status = ev_buff[0];
+    ALOGI("%s:%s, status =%d\n", LOG_TAG, __func__,status);
+    if (status < 0) {
+        ALOGE("%s:%s, read rds_grp_cntrs_ext failed status=%d\n", LOG_TAG, __func__,status);
+    }
+    jni_cb->rds_grp_cntrs_ext_rsp_cb(&ev_buff[1]);
+}
+
 static void hci_cc_riva_peek_rsp(char *ev_buff)
 {
     char status;
@@ -440,6 +453,9 @@
     case hci_status_param_op_pack(HCI_OCF_FM_READ_GRP_COUNTERS):
             hci_cc_rds_grp_cntrs_rsp(pbuf);
             break;
+    case hci_status_param_op_pack(HCI_OCF_FM_READ_GRP_COUNTERS_EXT):
+            hci_cc_rds_grp_cntrs_ext_rsp(pbuf);
+            break;
     case hci_diagnostic_cmd_op_pack(HCI_OCF_FM_PEEK_DATA):
             hci_cc_riva_peek_rsp(buff);
             break;
@@ -472,6 +488,11 @@
             hci_cc_station_rsp(pbuf);
             break;
 
+    case hci_recv_ctrl_cmd_op_pack(HCI_OCF_FM_LOW_PASS_FILTER_CTRL):
+            ALOGI("%s: recived LPF enable event", __func__);
+            hci_cc_rsp(pbuf);
+            break;
+
     case hci_diagnostic_cmd_op_pack(HCI_OCF_FM_STATION_DBG_PARAM):
             hci_cc_dbg_param_rsp(pbuf);
             break;
@@ -761,7 +782,7 @@
 static void  hci_ev_ext_country_code(char *buff)
 {
     char *data = NULL;
-    int len = 15;
+    int len = ECC_EVENT_BUFSIZE;
     ALOGD("%s:%s: start", LOG_TAG, __func__);
     data = malloc(len);
     if (data != NULL) {
@@ -1293,6 +1314,15 @@
          }
          break;
 
+    case HCI_FM_HELIUM_RDS_GRP_COUNTERS_EXT:
+         ALOGD("%s: rds_grp counter read  value=%d ", LOG_TAG,val);
+         ret = hci_fm_get_rds_grpcounters_ext_req(val);
+         if (ret < 0) {
+            radio->g_rds_grp_proc_ps = saved_val;
+            goto end ;
+         }
+         break;
+
     case HCI_FM_HELIUM_SET_NOTCH_FILTER:
          ALOGD("%s: set notch filter  notch=%d ", LOG_TAG,val);
          ret = hci_fm_set_notch_filter_req(val);
@@ -1534,6 +1564,12 @@
          radio->blend_tbl.BlendRmssiHi = val;
          ret = hci_fm_set_blend_tbl_req(&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);
+         }
+         break;
     default:
         ALOGE("%s:%s: Not a valid FM CMD!!", LOG_TAG, __func__);
         ret = 0;
diff --git a/helium/radio_helium_hal_cmds.c b/helium/radio_helium_hal_cmds.c
index f9c307a..7945023 100644
--- a/helium/radio_helium_hal_cmds.c
+++ b/helium/radio_helium_hal_cmds.c
@@ -178,6 +178,16 @@
     return send_fm_cmd_pkt(opcode, sizeof(val), &val);
 }
 
+int hci_fm_get_rds_grpcounters_ext_req (int val)
+{
+    uint16_t opcode = 0;
+
+   opcode = hci_opcode_pack(HCI_OGF_FM_STATUS_PARAMETERS_CMD_REQ,
+                         HCI_OCF_FM_READ_GRP_COUNTERS_EXT);
+    return send_fm_cmd_pkt(opcode, sizeof(val), &val);
+}
+
+
 int hci_fm_set_notch_filter_req (int val)
 {
     uint16_t opcode = 0;
@@ -437,3 +447,15 @@
             HCI_OCF_FM_STATION_DBG_PARAM);
     return send_fm_cmd_pkt(opcode, 0, NULL);
 }
+
+int hci_fm_enable_lpf(int enable)
+{
+    ALOGI("%s: enable: %x", __func__, enable);
+
+    uint16_t opcode = 0;
+    int enable_lpf = enable;
+
+    opcode = hci_opcode_pack(HCI_OGF_FM_RECV_CTRL_CMD_REQ,
+                                  HCI_OCF_FM_LOW_PASS_FILTER_CTRL);
+    return send_fm_cmd_pkt(opcode, sizeof(enable_lpf), &enable_lpf);
+}
diff --git a/jni/android_hardware_fm.cpp b/jni/android_hardware_fm.cpp
index dd439fc..163ce9b 100644
--- a/jni/android_hardware_fm.cpp
+++ b/jni/android_hardware_fm.cpp
@@ -104,6 +104,8 @@
 typedef void (*disable_cb)();
 typedef void (*callback_thread_event)(unsigned int evt);
 typedef void (*rds_grp_cntrs_cb)(char *rds_params);
+typedef void (*rds_grp_cntrs_ext_cb)(char *rds_params);
+
 typedef void (*fm_peek_cb)(char *peek_rsp);
 typedef void (*fm_ssbi_peek_cb)(char *ssbi_peek_rsp);
 typedef void (*fm_agc_gain_cb)(char *agc_gain_rsp);
@@ -363,6 +365,11 @@
    ALOGD("rds_grp_cntrs_rsp_cb");
 }
 
+void rds_grp_cntrs_ext_rsp_cb(char * evt_buffer)
+{
+   ALOGE("rds_grp_cntrs_ext_rsp_cb");
+}
+
 void fm_disabled_cb()
 {
     ALOGE("DISABLE");
@@ -485,6 +492,7 @@
    ert_cb  ert_update_cb;
    disable_cb  disabled_cb;
    rds_grp_cntrs_cb rds_grp_cntrs_rsp_cb;
+   rds_grp_cntrs_ext_cb rds_grp_cntrs_ext_rsp_cb;
    fm_peek_cb fm_peek_rsp_cb;
    fm_ssbi_peek_cb fm_ssbi_peek_rsp_cb;
    fm_agc_gain_cb fm_agc_gain_rsp_cb;
@@ -527,6 +535,7 @@
     fm_ert_update_cb,
     fm_disabled_cb,
     rds_grp_cntrs_rsp_cb,
+    rds_grp_cntrs_ext_rsp_cb,
     fm_peek_rsp_cb,
     fm_ssbi_peek_rsp_cb,
     fm_agc_gain_rsp_cb,
diff --git a/qcom/fmradio/FmReceiver.java b/qcom/fmradio/FmReceiver.java
index c61b78e..5ba27c8 100644
--- a/qcom/fmradio/FmReceiver.java
+++ b/qcom/fmradio/FmReceiver.java
@@ -28,10 +28,20 @@
 
 package qcom.fmradio;
 
+import android.content.Context;
+import android.os.Bundle;
+import android.telephony.TelephonyManager;
+import android.telephony.PhoneStateListener;
 import android.util.Log;
 import android.os.SystemProperties;
 import java.util.Arrays;
 import java.lang.Runnable;
+import android.content.BroadcastReceiver;
+import android.content.Intent;
+import android.net.wifi.WifiManager;
+import android.content.IntentFilter;
+import android.bluetooth.BluetoothAdapter;
+
 /**
  * This class contains all interfaces and types needed to
  * Control the FM receiver.
@@ -41,11 +51,38 @@
 {
 
    public static int mSearchState = subSrchLevel_NoSearch;
+   private IntentFilter mIntentFilter;
+   private IntentFilter mBtIntentFilter;
 
    static final int STD_BUF_SIZE = 256;
    static final int GRP_3A = 64;
+   static final int ENABLE_LPF = 1;
+   static final int DISABLE_LPF = 0;
    private static final String TAG = "FMRadio";
 
+
+   private static int  mEnableLpfGprs = 0x1;
+   private static int  mEnableLpfEdge = 0x2;
+   private static int  mEnableLpfUmts = 0x4;
+   private static int  mEnableLpfCdma = 0x8;
+   private static int  mEnableLpfEvdo0 = 0x10;
+   private static int  mEnableLpfEvdoA = 0x20;
+   private static int  mEnableLpf1xRtt = 0x40;
+   private static int  mEnableLpfHsdpa = 0x80;
+   private static int  mEnableLpfHsupa = 0x100;
+   private static int  mEnableLpfHspa = 0x200;
+   private static int  mEnableLpfIden = 0x400;
+   private static int  mEnableLpfEvdoB = 0x800;
+   private static int  mEnableLpfLte = 0x1000;
+   private static int  mEnableLpfEhrpd = 0x2000;
+   private static int  mEnableLpfHspap = 0x4000;
+   private static int  mEnableLpfGsm = 0x8000;
+   private static int  mEnableLpfScdma = 0x10000;
+   private static int  mEnableLpfIwlan = 0x20000;
+   private static int  mEnableLpfLteCa = 0x40000;
+
+   private static int  mIsBtLpfEnabled = 0x01;
+   private static int  mIsWlanLpfEnabled = 0x2;
    /**
    * Search (seek/scan/searchlist) by decrementing the frequency
    *
@@ -306,7 +343,6 @@
    private static final int SEARCH_MPXDCC = 0;
    private static final int SEARCH_SINR_INT = 1;
 
-
    public boolean isSmdTransportLayer() {
        String transportLayer = SystemProperties.get("ro.qualcomm.bt.hci_transport");
        if (transportLayer.equals("smd"))
@@ -331,6 +367,79 @@
            return false;
    }
 
+   public PhoneStateListener  mDataConnectionStateListener = new PhoneStateListener(){
+        public void onDataConnectionStateChanged(int state, int networkType) {
+              Log.d (TAG, "state: " + Integer.toString(state) +  " networkType: " + Integer.toString(networkType));
+              if (state == TelephonyManager.DATA_CONNECTED) {
+                  FMcontrolLowPassFilter(state, networkType, ENABLE_LPF);
+              } else {
+                  mControl.enableLPF(sFd, DISABLE_LPF);
+              }
+       }
+   };
+
+   /* Register for wan state changes to support wan-fm concurrency */
+   public void registerDataConnectionStateListener(Context mContext) {
+       Log.d (TAG, "registerDataConnectionStateListener");
+       TelephonyManager tm = (TelephonyManager) mContext.getSystemService(Context.TELEPHONY_SERVICE);
+       tm.listen(mDataConnectionStateListener, PhoneStateListener.LISTEN_DATA_CONNECTION_STATE);
+   }
+
+   /* UnRegister */
+   public void unregisterDataConnectionStateListener(Context mContext) {
+       Log.d (TAG, "unregisterDataConnectionStateListener: ");
+       TelephonyManager tm = (TelephonyManager) mContext.getSystemService(Context.TELEPHONY_SERVICE);
+       tm.listen(mDataConnectionStateListener, PhoneStateListener.LISTEN_NONE);
+   }
+
+   private final BroadcastReceiver mReceiver = new BroadcastReceiver() {
+
+       @Override
+       public void onReceive(Context context, Intent intent) {
+
+           Log.d (TAG, "onReceive: Wifi State change intent");
+
+           if (WifiManager.WIFI_STATE_CHANGED_ACTION.equals(intent.getAction())) {
+               int newState = intent.getIntExtra(WifiManager.EXTRA_WIFI_STATE,
+                        WifiManager.WIFI_STATE_UNKNOWN);
+               if (newState == WifiManager.WIFI_STATE_ENABLED) {
+                   Log.d (TAG, "enable LPF on wifi enabled " + newState);
+                   int mBtWlanLpf = SystemProperties.getInt("persist.btwlan.lpfenabler", 0);
+                   if ((mBtWlanLpf & mIsWlanLpfEnabled) == mIsWlanLpfEnabled)
+                       mControl.enableLPF(sFd, ENABLE_LPF);
+               } else {
+                   Log.d (TAG, "Disable LPF on wifi state other than enabled " + newState);
+                   mControl.enableLPF(sFd, DISABLE_LPF);
+               }
+           } else {
+               Log.d (TAG, "WIFI_STATE_CHANGED_ACTION failed");
+           }
+       }
+   };
+
+   private final BroadcastReceiver mBtReceiver = new BroadcastReceiver() {
+       @Override
+       public void onReceive(Context context, Intent intent) {
+
+           Log.d (TAG, "onReceive: Bluetooth State change intent");
+
+           if (BluetoothAdapter.ACTION_STATE_CHANGED.equals(intent.getAction())) {
+               int newState = intent.getIntExtra(BluetoothAdapter.EXTRA_STATE, BluetoothAdapter.ERROR);
+               if (newState == BluetoothAdapter.STATE_ON) {
+                   Log.d (TAG, "enable LPF on BT enabled " + newState);
+                   int mBtWlanLpf = SystemProperties.getInt("persist.btwlan.lpfenabler", 0);
+                   if ((mBtWlanLpf & mIsBtLpfEnabled) == mIsBtLpfEnabled)
+                       mControl.enableLPF(sFd, ENABLE_LPF);
+               } else {
+                   Log.d (TAG, "Disable LPF on BT state other than enabled " + newState);
+                   mControl.enableLPF(sFd, DISABLE_LPF);
+               }
+           } else {
+               Log.d (TAG, "ACTION_STATE_CHANGED failed");
+           }
+       }
+   };
+
    /**
     * Constructor for the receiver Object
     */
@@ -461,13 +570,17 @@
    *    @see #disable
    *
    */
-   public boolean enable (FmConfig configSettings){
+   public boolean enable (FmConfig configSettings, Context app_context){
       boolean status = false;
       /*
        * Check for FM State.
        * If FMRx already on, then return.
       */
       int state = getFMState();
+
+      mIntentFilter = new IntentFilter(WifiManager.WIFI_STATE_CHANGED_ACTION);
+      mBtIntentFilter = new IntentFilter(BluetoothAdapter.ACTION_STATE_CHANGED);
+
       if (state == FMState_Rx_Turned_On || state == FMState_Srch_InProg) {
          Log.d(TAG, "enable: FM already turned On and running");
          return status;
@@ -493,6 +606,19 @@
               status = registerClient(mCallback);
           }
           mRdsData = new FmRxRdsData(sFd);
+          registerDataConnectionStateListener(app_context);
+          app_context.registerReceiver(mReceiver, mIntentFilter);
+         WifiManager wifiManager = (WifiManager)app_context.getSystemService(app_context.WIFI_SERVICE);
+         if (wifiManager.getWifiState() == WifiManager.WIFI_STATE_ENABLED) {
+               Log.d(TAG, "enable LPF if WIFI is already on");
+               mControl.enableLPF(sFd, ENABLE_LPF);
+         }
+         app_context.registerReceiver(mBtReceiver, mBtIntentFilter);
+         BluetoothAdapter btAdapter = BluetoothAdapter.getDefaultAdapter();
+         if (btAdapter != null) {
+               Log.d(TAG, "enable LPF if BT is already on");
+               mControl.enableLPF(sFd, ENABLE_LPF);
+         }
       }
       else {
          status = false;
@@ -559,7 +685,7 @@
    *    @see #enable
    *    @see #registerClient
    */
-   public boolean disable(){
+   public boolean disable(Context app_context){
       boolean status = false;
       /*
        * Check for FM State. If search is in progress, then cancel the search prior
@@ -617,7 +743,9 @@
       setFMPowerState(subPwrLevel_FMTurning_Off);
       Log.v(TAG, "disable: CURRENT-STATE : FMRxOn ---> NEW-STATE : FMTurningOff");
       super.disable();
-
+      unregisterDataConnectionStateListener(app_context);
+      app_context.unregisterReceiver(mBtReceiver);
+      app_context.unregisterReceiver(mReceiver);
       return true;
    }
 
@@ -2820,4 +2948,149 @@
      }
      return;
    }
+   public void FMcontrolLowPassFilter(int state, int net_type, int enable) {
+       int RatConf = SystemProperties.getInt("persist.fm_wan.ratconf", 0);
+       Log.v (TAG, "FMcontrolLowPassFilter " + RatConf);
+       switch (net_type)
+       {
+
+           case TelephonyManager.NETWORK_TYPE_GPRS:
+               if ((state == TelephonyManager.DATA_CONNECTED) &&
+                      ((mEnableLpfGprs  & RatConf) == mEnableLpfGprs)) {
+                   Log.d (TAG, "enabling LPF for net_type: " + Integer.toString(net_type));
+                   mControl.enableLPF(sFd, enable);
+               }
+               break;
+           case TelephonyManager.NETWORK_TYPE_EDGE:
+               if ((state == TelephonyManager.DATA_CONNECTED) &&
+                      ((mEnableLpfEdge  & RatConf) == mEnableLpfEdge)) {
+                   Log.d (TAG, "enabling LPF for net_type: " + Integer.toString(net_type));
+                   mControl.enableLPF(sFd, enable);
+               }
+               break;
+           case TelephonyManager.NETWORK_TYPE_UMTS:
+               if ((state == TelephonyManager.DATA_CONNECTED) &&
+                      ((mEnableLpfUmts  & RatConf) == mEnableLpfUmts )) {
+                   Log.d (TAG, "enabling LPF for net_type: " + Integer.toString(net_type));
+                   mControl.enableLPF(sFd, enable);
+               }
+               break;
+           case TelephonyManager.NETWORK_TYPE_CDMA:
+               if ((state == TelephonyManager.DATA_CONNECTED) &&
+                      ((mEnableLpfCdma & RatConf) == mEnableLpfCdma)) {
+                   Log.d (TAG, "enabling LPF for net_type: " + Integer.toString(net_type));
+                   mControl.enableLPF(sFd, enable);
+               }
+               break;
+           case TelephonyManager.NETWORK_TYPE_EVDO_0:
+               if ((state == TelephonyManager.DATA_CONNECTED) &&
+                      ((mEnableLpfEvdo0  & RatConf) == mEnableLpfEvdo0 )) {
+                   Log.d (TAG, "enabling LPF for net_type: " + Integer.toString(net_type));
+                   mControl.enableLPF(sFd, enable);
+               }
+               break;
+           case TelephonyManager.NETWORK_TYPE_EVDO_A:
+               if ((state == TelephonyManager.DATA_CONNECTED) &&
+                      ((mEnableLpfEvdoA  & RatConf) == mEnableLpfEvdoA )) {
+                   Log.d (TAG, "enabling LPF for net_type: " + Integer.toString(net_type));
+                   mControl.enableLPF(sFd, enable);
+               }
+               break;
+           case TelephonyManager.NETWORK_TYPE_1xRTT:
+               if ((state == TelephonyManager.DATA_CONNECTED) &&
+                      ((mEnableLpf1xRtt  & RatConf) == mEnableLpf1xRtt )) {
+                   Log.d (TAG, "enabling LPF for net_type: " + Integer.toString(net_type));
+                   mControl.enableLPF(sFd, enable);
+               }
+               break;
+           case TelephonyManager.NETWORK_TYPE_HSDPA:
+               if ((state == TelephonyManager.DATA_CONNECTED) &&
+                      ((mEnableLpfHsdpa  & RatConf) == mEnableLpfHsdpa )) {
+                   Log.d (TAG, "enabling LPF for net_type: " + Integer.toString(net_type));
+                   mControl.enableLPF(sFd, enable);
+               }
+               break;
+           case TelephonyManager.NETWORK_TYPE_HSUPA:
+               if ((state == TelephonyManager.DATA_CONNECTED) &&
+                      ((mEnableLpfHsupa & RatConf) == mEnableLpfHsupa)) {
+                   Log.d (TAG, "enabling LPF for net_type: " + Integer.toString(net_type));
+                   mControl.enableLPF(sFd, enable);
+               }
+               break;
+           case TelephonyManager.NETWORK_TYPE_HSPA:
+               if ((state == TelephonyManager.DATA_CONNECTED) &&
+                      ((mEnableLpfHspa  & RatConf) == mEnableLpfHspa )) {
+                   Log.d (TAG, "enabling LPF for net_type: " + Integer.toString(net_type));
+                   mControl.enableLPF(sFd, enable);
+               }
+               break;
+           case TelephonyManager.NETWORK_TYPE_IDEN:
+               if ((state == TelephonyManager.DATA_CONNECTED) &&
+                      ((mEnableLpfIden  & RatConf) == mEnableLpfIden )) {
+                   Log.d (TAG, "enabling LPF for net_type: " + Integer.toString(net_type));
+                   mControl.enableLPF(sFd, enable);
+               }
+               break;
+           case TelephonyManager.NETWORK_TYPE_EVDO_B:
+               if ((state == TelephonyManager.DATA_CONNECTED) &&
+                      ((mEnableLpfEvdoB  & RatConf) == mEnableLpfEvdoB )) {
+                   Log.d (TAG, "enabling LPF for net_type: " + Integer.toString(net_type));
+                   mControl.enableLPF(sFd, enable);
+               }
+               break;
+           case TelephonyManager.NETWORK_TYPE_LTE:
+               if ((state == TelephonyManager.DATA_CONNECTED) &&
+                      ((mEnableLpfLte  & RatConf) == mEnableLpfLte )) {
+                   Log.d (TAG, "enabling LPF for net_type: " + Integer.toString(net_type));
+                   mControl.enableLPF(sFd, enable);
+               }
+               break;
+           case TelephonyManager.NETWORK_TYPE_EHRPD:
+               if ((state == TelephonyManager.DATA_CONNECTED) &&
+                      ((mEnableLpfEhrpd  & RatConf) == mEnableLpfEhrpd )) {
+                   Log.d (TAG, "enabling LPF for net_type: " + Integer.toString(net_type));
+                   mControl.enableLPF(sFd, enable);
+               }
+               break;
+           case TelephonyManager.NETWORK_TYPE_HSPAP:
+               if ((state == TelephonyManager.DATA_CONNECTED) &&
+                      ((mEnableLpfHspap  & RatConf) == mEnableLpfHspap)) {
+                   Log.d (TAG, "enabling LPF for net_type: " + Integer.toString(net_type));
+                   mControl.enableLPF(sFd, enable);
+               }
+               break;
+           case TelephonyManager.NETWORK_TYPE_GSM:
+               if ((state == TelephonyManager.DATA_CONNECTED) &&
+                      ((mEnableLpfGsm & RatConf) == mEnableLpfGsm)) {
+                   Log.d (TAG, "enabling LPF for net_type: " + Integer.toString(net_type));
+                   mControl.enableLPF(sFd, enable);
+               }
+               break;
+           case TelephonyManager.NETWORK_TYPE_TD_SCDMA:
+               if ((state == TelephonyManager.DATA_CONNECTED) &&
+                      ((mEnableLpfScdma & RatConf) == mEnableLpfScdma)) {
+                   Log.d (TAG, "enabling LPF for net_type: " + Integer.toString(net_type));
+                   mControl.enableLPF(sFd, enable);
+               }
+               break;
+          case TelephonyManager.NETWORK_TYPE_IWLAN:
+               if ((state == TelephonyManager.DATA_CONNECTED) &&
+                      ((mEnableLpfIwlan  & RatConf) == mEnableLpfIwlan )) {
+                   Log.d (TAG, "enabling LPF for net_type: " + Integer.toString(net_type));
+                   mControl.enableLPF(sFd, enable);
+               }
+               break;
+          case TelephonyManager.NETWORK_TYPE_LTE_CA:
+               if ((state == TelephonyManager.DATA_CONNECTED) &&
+                      ((mEnableLpfLteCa  & RatConf) == mEnableLpfLteCa )) {
+                   Log.d (TAG, "enabling LPF for net_type: " + Integer.toString(net_type));
+                   mControl.enableLPF(sFd, enable);
+               }
+               break;
+           default:
+               Log.d (TAG, "net_type " + Integer.toString(net_type) + " doesn't need LPF enabling");
+               mControl.enableLPF(sFd, enable);
+               break;
+       }
+   }
 }
diff --git a/qcom/fmradio/FmRxControls.java b/qcom/fmradio/FmRxControls.java
index 701448f..7b9fb7c 100644
--- a/qcom/fmradio/FmRxControls.java
+++ b/qcom/fmradio/FmRxControls.java
@@ -100,6 +100,7 @@
    private static final int V4L2_CID_PRIVATE_AF_JUMP_RSSI_TH               = V4L2_CID_PRIVATE_BASE + 0x3F;
    private static final int V4L2_CID_PRIVATE_BLEND_SINRHI                  = V4L2_CID_PRIVATE_BASE + 0x40;
    private static final int V4L2_CID_PRIVATE_BLEND_RMSSIHI                 = V4L2_CID_PRIVATE_BASE + 0x41;
+   private static final int ENABLE_LOW_PASS_FILTER                         = V4L2_CID_PRIVATE_BASE + 0x45;
 
    private static final int V4L2_CTRL_CLASS_USER = 0x980000;
    private static final int V4L2_CID_BASE        = V4L2_CTRL_CLASS_USER | 0x900;
@@ -196,6 +197,14 @@
       return re;
    }
 
+   public int enableLPF(int fd, int sBuff)
+   {
+      int re = FmReceiverJNI.setControlNative(fd, ENABLE_LOW_PASS_FILTER, sBuff);
+      if ( re < 0)
+         Log.e(TAG, "Failed to enable LPF");
+      return re;
+   }
+
    /*
     * Set Off channel threshold
     */