Merge GPS HAL with LA.AF.1.2.2

Excluding the stuff that doesn't play nice with our KK blobs.

Change-Id: If3aa0f3e8fd41e2bcb67d9deee6bb463bfc729b1

28 files changed, 841 insertions, 289 deletions

diff --git a/gps/core/Android.mk b/gps/core/Android.mk
index e8fb462..7f933b1 100644
--- a/gps/core/Android.mk
+++ b/gps/core/Android.mk
@@ -11,6 +11,7 @@ LOCAL_MODULE_TAGS := optional
 
 LOCAL_SHARED_LIBRARIES := \
     libutils \
+    liblog \
     libcutils \
     libgps.utils \
     libdl
@@ -25,7 +26,8 @@ LOCAL_SRC_FILES += \
 
 LOCAL_CFLAGS += \
      -fno-short-enums \
-     -D_ANDROID_
+     -D_ANDROID_ \
+     -Wno-unused-parameter
 
 LOCAL_C_INCLUDES:= \
     $(TARGET_OUT_HEADERS)/gps.utils
@@ -43,8 +45,6 @@ LOCAL_COPY_HEADERS:= \
     gps_extended.h \
     loc_core_log.h
 
-LOCAL_CLANG := false
-
 include $(BUILD_SHARED_LIBRARY)
 
 endif # not BUILD_TINY_ANDROID
diff --git a/gps/core/LocAdapterBase.h b/gps/core/LocAdapterBase.h
index d11e64a..38d969e 100644
--- a/gps/core/LocAdapterBase.h
+++ b/gps/core/LocAdapterBase.h
@@ -37,7 +37,7 @@ namespace loc_core {
 
 class LocAdapterBase {
 protected:
-    const LOC_API_ADAPTER_EVENT_MASK_T mEvtMask;
+    LOC_API_ADAPTER_EVENT_MASK_T mEvtMask;
     ContextBase* mContext;
     LocApiBase* mLocApi;
     const MsgTask* mMsgTask;
@@ -65,6 +65,15 @@ public:
         mMsgTask->sendMsg(msg);
     }
 
+    inline void updateEvtMask(LOC_API_ADAPTER_EVENT_MASK_T event,
+                       loc_registration_mask_status isEnabled)
+    {
+        mEvtMask =
+            isEnabled == LOC_REGISTRATION_MASK_ENABLED ? (mEvtMask|event):(mEvtMask&~event);
+
+        mLocApi->updateEvtMask();
+    }
+
     // This will be overridden by the individual adapters
     // if necessary.
     inline virtual void setUlpProxy(UlpProxyBase* ulp) {}
diff --git a/gps/core/LocApiBase.cpp b/gps/core/LocApiBase.cpp
index cbfbea6..3d1f488 100644
--- a/gps/core/LocApiBase.cpp
+++ b/gps/core/LocApiBase.cpp
@@ -126,7 +126,8 @@ struct LocOpenMsg : public LocMsg {
 
 LocApiBase::LocApiBase(const MsgTask* msgTask,
                        LOC_API_ADAPTER_EVENT_MASK_T excludedMask) :
-    mExcludedMask(excludedMask), mMsgTask(msgTask), mMask(0)
+    mExcludedMask(excludedMask), mMsgTask(msgTask),
+    mMask(0), mSupportedMsg(0)
 {
     memset(mLocAdapters, 0, sizeof(mLocAdapters));
 }
@@ -201,6 +202,11 @@ void LocApiBase::removeAdapter(LocAdapterBase* adapter)
     }
 }
 
+void LocApiBase::updateEvtMask()
+{
+    mMsgTask->sendMsg(new LocOpenMsg(this, getEvtMask()));
+}
+
 void LocApiBase::handleEngineUpEvent()
 {
     // This will take care of renegotiating the loc handle
@@ -342,6 +348,11 @@ void LocApiBase::requestNiNotify(GpsNiNotification &notify, const void* data)
     TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->requestNiNotify(notify, data));
 }
 
+void LocApiBase::saveSupportedMsgList(uint64_t supportedMsgList)
+{
+    mSupportedMsg = supportedMsgList;
+}
+
 void* LocApiBase :: getSibling()
     DEFAULT_IMPL(NULL)
 
@@ -494,7 +505,17 @@ int LocApiBase::
     setGpsLock(unsigned int lock)
 DEFAULT_IMPL(-1)
 
+void LocApiBase::
+    installAGpsCert(const DerEncodedCertificate* pData,
+                    size_t length,
+                    uint32_t slotBitMask)
+DEFAULT_IMPL()
+
 int LocApiBase::
     getGpsLock()
 DEFAULT_IMPL(-1)
+
+enum loc_api_adapter_err LocApiBase::
+    setXtraVersionCheck(enum xtra_version_check check)
+DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
 } // namespace loc_core
diff --git a/gps/core/LocApiBase.h b/gps/core/LocApiBase.h
index 1603e6b..801e5f3 100644
--- a/gps/core/LocApiBase.h
+++ b/gps/core/LocApiBase.h
@@ -52,6 +52,13 @@ int decodeAddress(char *addr_string, int string_size,
 #define TO_1ST_HANDLING_ADAPTER(adapters, call)                              \
     for (int i = 0; i <MAX_ADAPTERS && NULL != (adapters)[i] && !(call); i++);
 
+enum xtra_version_check {
+    DISABLED,
+    AUTO,
+    XTRA2,
+    XTRA3
+};
+
 class LocAdapterBase;
 struct LocSsrMsg;
 struct LocOpenMsg;
@@ -71,6 +78,7 @@ class LocApiBase {
     friend class ContextBase;
     const MsgTask* mMsgTask;
     LocAdapterBase* mLocAdapters[MAX_ADAPTERS];
+    uint64_t mSupportedMsg;
 
 protected:
     virtual enum loc_api_adapter_err
@@ -118,6 +126,7 @@ public:
     void reportDataCallOpened();
     void reportDataCallClosed();
     void requestNiNotify(GpsNiNotification &notify, const void* data);
+    void saveSupportedMsgList(uint64_t supportedMsgList);
 
     // downward calls
     // All below functions are to be defined by adapter specific modules:
@@ -196,8 +205,19 @@ public:
     virtual int openAndStartDataCall();
     virtual void stopDataCall();
     virtual void closeDataCall();
-
+    virtual void installAGpsCert(const DerEncodedCertificate* pData,
+                                 size_t length,
+                                 uint32_t slotBitMask);
     inline virtual void setInSession(bool inSession) {}
+    inline bool isMessageSupported (LocCheckingMessagesID msgID) const {
+        if (msgID > (sizeof(mSupportedMsg) << 3)) {
+            return false;
+        } else {
+            uint32_t messageChecker = 1 << msgID;
+            return (messageChecker & mSupportedMsg) == messageChecker;
+        }
+    }
+    void updateEvtMask();
 
     /*Values for lock
       1 = Do not lock any position sessions
@@ -212,6 +232,7 @@ public:
       -1 on failure
      */
     virtual int getGpsLock(void);
+    virtual enum loc_api_adapter_err setXtraVersionCheck(enum xtra_version_check check);
 };
 
 typedef LocApiBase* (getLocApi_t)(const MsgTask* msgTask,
diff --git a/gps/core/LocDualContext.cpp b/gps/core/LocDualContext.cpp
index fa4c4d6..5b984e0 100644
--- a/gps/core/LocDualContext.cpp
+++ b/gps/core/LocDualContext.cpp
@@ -60,6 +60,8 @@ ContextBase* LocDualContext::mBgContext = NULL;
 const char* LocDualContext::mLocationHalName = "Loc_hal_worker";
 const char* LocDualContext::mIzatLibName = "liblbs_core.so";
 
+pthread_mutex_t LocDualContext::mGetLocContextMutex = PTHREAD_MUTEX_INITIALIZER;
+
 const MsgTask* LocDualContext::getMsgTask(MsgTask::tCreate tCreator,
                                           const char* name)
 {
@@ -83,22 +85,30 @@ const MsgTask* LocDualContext::getMsgTask(MsgTask::tAssociate tAssociate,
 ContextBase* LocDualContext::getLocFgContext(MsgTask::tCreate tCreator,
                                              const char* name)
 {
+    pthread_mutex_lock(&LocDualContext::mGetLocContextMutex);
+    LOC_LOGD("%s:%d]: querying ContextBase with tCreator", __func__, __LINE__);
     if (NULL == mFgContext) {
+        LOC_LOGD("%s:%d]: creating msgTask with tCreator", __func__, __LINE__);
         const MsgTask* msgTask = getMsgTask(tCreator, name);
         mFgContext = new LocDualContext(msgTask,
                                         mFgExclMask);
     }
+    pthread_mutex_unlock(&LocDualContext::mGetLocContextMutex);
     return mFgContext;
 }
 
 ContextBase* LocDualContext::getLocFgContext(MsgTask::tAssociate tAssociate,
-                                        const char* name)
+                                             const char* name)
 {
+    pthread_mutex_lock(&LocDualContext::mGetLocContextMutex);
+    LOC_LOGD("%s:%d]: querying ContextBase with tAssociate", __func__, __LINE__);
     if (NULL == mFgContext) {
+        LOC_LOGD("%s:%d]: creating msgTask with tAssociate", __func__, __LINE__);
         const MsgTask* msgTask = getMsgTask(tAssociate, name);
         mFgContext = new LocDualContext(msgTask,
                                         mFgExclMask);
     }
+    pthread_mutex_unlock(&LocDualContext::mGetLocContextMutex);
     return mFgContext;
 
 }
@@ -106,22 +116,30 @@ ContextBase* LocDualContext::getLocFgContext(MsgTask::tAssociate tAssociate,
 ContextBase* LocDualContext::getLocBgContext(MsgTask::tCreate tCreator,
                                              const char* name)
 {
+    pthread_mutex_lock(&LocDualContext::mGetLocContextMutex);
+    LOC_LOGD("%s:%d]: querying ContextBase with tCreator", __func__, __LINE__);
     if (NULL == mBgContext) {
+        LOC_LOGD("%s:%d]: creating msgTask with tCreator", __func__, __LINE__);
         const MsgTask* msgTask = getMsgTask(tCreator, name);
         mBgContext = new LocDualContext(msgTask,
                                         mBgExclMask);
     }
+    pthread_mutex_unlock(&LocDualContext::mGetLocContextMutex);
     return mBgContext;
 }
 
 ContextBase* LocDualContext::getLocBgContext(MsgTask::tAssociate tAssociate,
                                              const char* name)
 {
+    pthread_mutex_lock(&LocDualContext::mGetLocContextMutex);
+    LOC_LOGD("%s:%d]: querying ContextBase with tAssociate", __func__, __LINE__);
     if (NULL == mBgContext) {
+        LOC_LOGD("%s:%d]: creating msgTask with tAssociate", __func__, __LINE__);
         const MsgTask* msgTask = getMsgTask(tAssociate, name);
         mBgContext = new LocDualContext(msgTask,
                                         mBgExclMask);
     }
+    pthread_mutex_unlock(&LocDualContext::mGetLocContextMutex);
     return mBgContext;
 }
 
diff --git a/gps/core/LocDualContext.h b/gps/core/LocDualContext.h
index e761e76..0764f0f 100644
--- a/gps/core/LocDualContext.h
+++ b/gps/core/LocDualContext.h
@@ -45,6 +45,7 @@ class LocDualContext : public ContextBase {
                                      const char* name);
     static const MsgTask* getMsgTask(MsgTask::tAssociate tAssociate,
                                      const char* name);
+    static pthread_mutex_t mGetLocContextMutex;
 
 protected:
     LocDualContext(const MsgTask* msgTask,
diff --git a/gps/core/UlpProxyBase.h b/gps/core/UlpProxyBase.h
index 9009757..b9a8224 100644
--- a/gps/core/UlpProxyBase.h
+++ b/gps/core/UlpProxyBase.h
@@ -50,6 +50,7 @@ public:
         mPosMode = params;
         return false;
     }
+
     inline virtual bool reportPosition(UlpLocation &location,
                                        GpsLocationExtended &locationExtended,
                                        void* locationExt,
@@ -67,6 +68,16 @@ public:
     }
     inline virtual void setAdapter(LocAdapterBase* adapter) {}
     inline virtual void setCapabilities(unsigned long capabilities) {}
+    inline virtual bool reportBatchingSession(GpsExtBatchOptions &options,
+                                              bool active) {
+        return false;
+    }
+    inline virtual bool reportPositions(GpsExtLocation * locations,
+                                        int32_t number_of_locations,
+                                        enum loc_sess_status status,
+                                        LocPosTechMask techMask) {
+        return false;
+    }
 };
 
 } // namespace loc_core
diff --git a/gps/core/gps_extended_c.h b/gps/core/gps_extended_c.h
index a7ca4e6..5a286bf 100644
--- a/gps/core/gps_extended_c.h
+++ b/gps/core/gps_extended_c.h
@@ -1,4 +1,4 @@
-/* Copyright (c) 2013-2014, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2013-2015, 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
@@ -35,6 +35,7 @@ extern "C" {
 
 #include <ctype.h>
 #include <stdbool.h>
+#include <stdlib.h>
 #include <string.h>
 #include "hardware/gps.h"
 
@@ -61,12 +62,24 @@ extern "C" {
 #define ULP_LOCATION_IS_FROM_ZPP      0x0004
 /** Position is from a Geofence Breach Event */
 #define ULP_LOCATION_IS_FROM_GEOFENCE 0X0008
+/** Positioin is from Hardware FLP */
+#define ULP_LOCATION_IS_FROM_HW_FLP   0x0010
+/** Position is from PIP */
+#define ULP_LOCATION_IS_FROM_PIP      0x0040
 
 #define ULP_MIN_INTERVAL_INVALID 0xffffffff
 
 /*Emergency SUPL*/
 #define GPS_NI_TYPE_EMERGENCY_SUPL    4
 
+#define AGPS_CERTIFICATE_MAX_LENGTH 2000
+#define AGPS_CERTIFICATE_MAX_SLOTS 10
+
+enum loc_registration_mask_status {
+    LOC_REGISTRATION_MASK_ENABLED,
+    LOC_REGISTRATION_MASK_DISABLED
+};
+
 typedef struct {
     /** set to sizeof(UlpLocation) */
     size_t          size;
@@ -112,6 +125,14 @@ typedef struct {
     gps_request_utc_time request_utc_time_cb;
 } GpsExtCallbacks;
 
+/** GPS extended batch options */
+typedef struct {
+    double max_power_allocation_mW;
+    uint32_t sources_to_use;
+    uint32_t flags;
+    int64_t period_ns;
+} GpsExtBatchOptions;
+
 /** Callback to report the xtra server url to the client.
  *  The client should use this url when downloading xtra unless overwritten
  *  in the gps.conf file
@@ -235,6 +256,19 @@ typedef struct {
     float           speed_unc;
 } GpsLocationExtended;
 
+typedef struct GpsExtLocation_s {
+    size_t          size;
+    uint16_t        flags;
+    double          latitude;
+    double          longitude;
+    double          altitude;
+    float           speed;
+    float           bearing;
+    float           accuracy;
+    int64_t         timestamp;
+    uint32_t        sources_used;
+} GpsExtLocation;
+
 enum loc_sess_status {
     LOC_SESS_SUCCESS,
     LOC_SESS_INTERMEDIATE,
@@ -343,6 +377,12 @@ enum loc_api_adapter_event_index {
 
 typedef unsigned int LOC_API_ADAPTER_EVENT_MASK_T;
 
+typedef enum loc_api_adapter_msg_to_check_supported {
+    LOC_API_ADAPTER_MESSAGE_LOCATION_BATCHING,               // Batching
+    LOC_API_ADAPTER_MESSAGE_BATCHED_GENFENCE_BREACH,         // Geofence Batched Breach
+
+    LOC_API_ADAPTER_MESSAGE_MAX
+} LocCheckingMessagesID;
 
 #ifdef __cplusplus
 }
diff --git a/gps/etc/Android.mk b/gps/etc/Android.mk
new file mode 100644
index 0000000..611a548
--- /dev/null
+++ b/gps/etc/Android.mk
@@ -0,0 +1,18 @@
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := gps.conf
+LOCAL_MODULE_TAGS := optional
+LOCAL_MODULE_CLASS := ETC
+LOCAL_MODULE_PATH  := $(TARGET_OUT_ETC)/
+LOCAL_SRC_FILES := gps.conf
+include $(BUILD_PREBUILT)
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := sap.conf
+LOCAL_MODULE_TAGS := optional
+LOCAL_MODULE_CLASS := ETC
+LOCAL_MODULE_PATH  := $(TARGET_OUT_ETC)/
+LOCAL_SRC_FILES := sap.conf
+include $(BUILD_PREBUILT)
+
diff --git a/configs/gps.conf b/gps/etc/gps.conf
index 0c461f7..7af1d64 100644
--- a/configs/gps.conf
+++ b/gps/etc/gps.conf
@@ -1,8 +1,15 @@
 #Uncommenting these urls would only enable
 #the power up auto injection and force injection(test case).
-XTRA_SERVER_1=http://xtrapath1.izatcloud.net/xtra2.bin
-XTRA_SERVER_2=http://xtrapath2.izatcloud.net/xtra2.bin
-XTRA_SERVER_3=http://xtrapath3.izatcloud.net/xtra2.bin
+#XTRA_SERVER_1=http://xtrapath1.izatcloud.net/xtra2.bin
+#XTRA_SERVER_2=http://xtrapath2.izatcloud.net/xtra2.bin
+#XTRA_SERVER_3=http://xtrapath3.izatcloud.net/xtra2.bin
+
+#Version check for XTRA
+#DISABLE = 0
+#AUTO    = 1
+#XTRA2   = 2
+#XTRA3   = 3
+XTRA_VERSION_CHECK=0
 
 # Error Estimate
 # _SET = 1
@@ -10,7 +17,7 @@ XTRA_SERVER_3=http://xtrapath3.izatcloud.net/xtra2.bin
 ERR_ESTIMATE=0
 
 #Test
-NTP_SERVER=time.izatcloud.net
+NTP_SERVER=time.gpsonextra.net
 #Asia
 # NTP_SERVER=asia.pool.ntp.org
 #Europe
@@ -30,7 +37,12 @@ INTERMEDIATE_POS=0
 SUPL_VER=0x10000
 
 # Emergency SUPL, 1=enable, 0=disable
-SUPL_ES=1
+SUPL_ES=0
+
+#Choose PDN for Emergency SUPL
+#1 - Use emergency PDN
+#0 - Use regular SUPL PDN for Emergency SUPL
+USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL=0
 
 # GPS Capabilities bit mask
 # SCHEDULING = 0x01
@@ -57,6 +69,14 @@ CAPABILITIES=0x33
 # C2K_HOST=c2k.pde.com or IP
 # C2K_PORT=1234
 
+# Bitmask of slots that are available
+# for write/install to, where 1s indicate writable,
+# and the default value is 0 where no slots
+# are writable. For example, AGPS_CERT_WRITABLE_MASK
+# of b1000001010 makes 3 slots available
+# and the remaining 7 slots unwritable.
+#AGPS_CERT_WRITABLE_MASK=0
+
 ####################################
 #  LTE Positioning Profile Settings
 ####################################
@@ -64,13 +84,13 @@ CAPABILITIES=0x33
 # 1: Enable LPP_User_Plane on LTE
 # 2: Enable LPP_Control_Plane
 # 3: Enable both LPP_User_Plane and LPP_Control_Plane
-LPP_PROFILE = 0 # Sensor R&D : This will not be injected to MODEM
+LPP_PROFILE = 0
 
 ################################
 # EXTRA SETTINGS
 ################################
 # NMEA provider (1=Modem Processor, 0=Application Processor)
-NMEA_PROVIDER=1
+NMEA_PROVIDER=0
 
 # Mark if it is a SGLTE target (1=SGLTE, 0=nonSGLTE)
 SGLTE_TARGET=0
@@ -81,4 +101,4 @@ SGLTE_TARGET=0
 # 0x1: RRC CPlane
 # 0x2: RRLP UPlane
 # 0x4: LLP Uplane
-A_GLONASS_POS_PROTOCOL_SELECT = 0x0
+A_GLONASS_POS_PROTOCOL_SELECT = 0
diff --git a/configs/sap.conf b/gps/etc/sap.conf
index 8f5e396..8f5e396 100644
--- a/configs/sap.conf
+++ b/gps/etc/sap.conf
diff --git a/gps/loc_api/NOTICE b/gps/loc_api/NOTICE
deleted file mode 100644
index 85b5740..0000000
--- a/gps/loc_api/NOTICE
+++ /dev/null
@@ -1,13 +0,0 @@
-Copyright (c) 2009, QUALCOMM USA, INC.
-
-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 QUALCOMM USA, INC.  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 BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER 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.
diff --git a/gps/loc_api/libloc_api_50001/Android.mk b/gps/loc_api/libloc_api_50001/Android.mk
index e1b89e6..3233abd 100644
--- a/gps/loc_api/libloc_api_50001/Android.mk
+++ b/gps/loc_api/libloc_api_50001/Android.mk
@@ -36,7 +36,8 @@ LOCAL_SRC_FILES += \
 
 LOCAL_CFLAGS += \
      -fno-short-enums \
-     -D_ANDROID_
+     -D_ANDROID_ \
+     -Wno-unused-parameter
 
 LOCAL_C_INCLUDES:= \
     $(TARGET_OUT_HEADERS)/gps.utils \
diff --git a/gps/loc_api/libloc_api_50001/LocEngAdapter.cpp b/gps/loc_api/libloc_api_50001/LocEngAdapter.cpp
index 52a9402..d82f90f 100644
--- a/gps/loc_api/libloc_api_50001/LocEngAdapter.cpp
+++ b/gps/loc_api/libloc_api_50001/LocEngAdapter.cpp
@@ -66,7 +66,8 @@ LocEngAdapter::LocEngAdapter(LOC_API_ADAPTER_EVENT_MASK_T mask,
     mOwner(owner), mInternalAdapter(new LocInternalAdapter(this)),
     mUlp(new UlpProxyBase()), mNavigating(false),
     mSupportsAgpsRequests(false),
-    mSupportsPositionInjection(false)
+    mSupportsPositionInjection(false),
+    mSupportsTimeInjection(false)
 {
     memset(&mFixCriteria, 0, sizeof(mFixCriteria));
     mFixCriteria.mode = LOC_POSITION_MODE_INVALID;
@@ -302,3 +303,47 @@ void LocEngAdapter::handleEngineUpEvent()
 {
     sendMsg(new LocEngUp(mOwner));
 }
+
+enum loc_api_adapter_err LocEngAdapter::setTime(GpsUtcTime time,
+                                                int64_t timeReference,
+                                                int uncertainty)
+{
+    loc_api_adapter_err result = LOC_API_ADAPTER_ERR_SUCCESS;
+
+    LOC_LOGD("%s:%d]: mSupportsTimeInjection is %d",
+             __func__, __LINE__, mSupportsTimeInjection);
+
+    if (mSupportsTimeInjection) {
+        LOC_LOGD("%s:%d]: Injecting time", __func__, __LINE__);
+        result = mLocApi->setTime(time, timeReference, uncertainty);
+    } else {
+        mSupportsTimeInjection = true;
+    }
+    return result;
+}
+
+enum loc_api_adapter_err LocEngAdapter::setXtraVersionCheck(int check)
+{
+    enum loc_api_adapter_err ret;
+    ENTRY_LOG();
+    enum xtra_version_check eCheck;
+    switch (check) {
+    case 0:
+        eCheck = DISABLED;
+        break;
+    case 1:
+        eCheck = AUTO;
+        break;
+    case 2:
+        eCheck = XTRA2;
+        break;
+    case 3:
+        eCheck = XTRA3;
+        break;
+    default:
+        eCheck = DISABLED;
+    }
+    ret = mLocApi->setXtraVersionCheck(eCheck);
+    EXIT_LOG(%d, ret);
+    return ret;
+}
diff --git a/gps/loc_api/libloc_api_50001/LocEngAdapter.h b/gps/loc_api/libloc_api_50001/LocEngAdapter.h
index 932fea1..0dbd70c 100644
--- a/gps/loc_api/libloc_api_50001/LocEngAdapter.h
+++ b/gps/loc_api/libloc_api_50001/LocEngAdapter.h
@@ -78,6 +78,7 @@ class LocEngAdapter : public LocAdapterBase {
 public:
     bool mSupportsAgpsRequests;
     bool mSupportsPositionInjection;
+    bool mSupportsTimeInjection;
 
     LocEngAdapter(LOC_API_ADAPTER_EVENT_MASK_T mask,
                   void* owner,ContextBase* context,
@@ -130,11 +131,6 @@ public:
         return mLocApi->injectPosition(latitude, longitude, accuracy);
     }
     inline enum loc_api_adapter_err
-        setTime(GpsUtcTime time, int64_t timeReference, int uncertainty)
-    {
-        return mLocApi->setTime(time, timeReference, uncertainty);
-    }
-    inline enum loc_api_adapter_err
         setXtraData(char* data, int length)
     {
         return mLocApi->setXtraData(data, length);
@@ -249,7 +245,16 @@ public:
     {
         return mLocApi->getZppFix(zppLoc, tech_mask);
     }
-
+    enum loc_api_adapter_err setTime(GpsUtcTime time,
+                                     int64_t timeReference,
+                                     int uncertainty);
+    enum loc_api_adapter_err setXtraVersionCheck(int check);
+    inline virtual void installAGpsCert(const DerEncodedCertificate* pData,
+                                        size_t length,
+                                        uint32_t slotBitMask)
+    {
+        mLocApi->installAGpsCert(pData, length, slotBitMask);
+    }
     virtual void handleEngineDownEvent();
     virtual void handleEngineUpEvent();
     virtual void reportPosition(UlpLocation &location,
@@ -298,6 +303,7 @@ public:
     {
         return mLocApi->getGpsLock();
     }
+
 };
 
 #endif //LOC_API_ENG_ADAPTER_H
diff --git a/gps/loc_api/libloc_api_50001/gps.c b/gps/loc_api/libloc_api_50001/gps.c
index 87aca3d..a67277f 100644
--- a/gps/loc_api/libloc_api_50001/gps.c
+++ b/gps/loc_api/libloc_api_50001/gps.c
@@ -1,4 +1,4 @@
-/* Copyright (c) 2011 The Linux Foundation. All rights reserved.
+/* Copyright (c) 2011,2015 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
@@ -30,6 +30,7 @@
 #include "hardware/gps.h"
 
 #include <stdlib.h>
+#include <string.h>
 
 extern const GpsInterface* get_gps_interface();
 
diff --git a/gps/loc_api/libloc_api_50001/loc.cpp b/gps/loc_api/libloc_api_50001/loc.cpp
index 9e08677..b1380be 100644
--- a/gps/loc_api/libloc_api_50001/loc.cpp
+++ b/gps/loc_api/libloc_api_50001/loc.cpp
@@ -114,7 +114,7 @@ static const GpsXtraInterface sLocEngXTRAInterface =
 static void loc_ni_init(GpsNiCallbacks *callbacks);
 static void loc_ni_respond(int notif_id, GpsUserResponseType user_response);
 
-const GpsNiInterface sLocEngNiInterface =
+static const GpsNiInterface sLocEngNiInterface =
 {
    sizeof(GpsNiInterface),
    loc_ni_init,
@@ -139,9 +139,29 @@ static const AGpsRilInterface sLocEngAGpsRilInterface =
    loc_agps_ril_update_network_availability
 };
 
+static int loc_agps_install_certificates(const DerEncodedCertificate* certificates,
+                                         size_t length);
+static int loc_agps_revoke_certificates(const Sha1CertificateFingerprint* fingerprints,
+                                        size_t length);
+
+static const SuplCertificateInterface sLocEngAGpsCertInterface =
+{
+    sizeof(SuplCertificateInterface),
+    loc_agps_install_certificates,
+    loc_agps_revoke_certificates
+};
+
+static void loc_configuration_update(const char* config_data, int32_t length);
+
+static const GnssConfigurationInterface sLocEngConfigInterface =
+{
+    sizeof(GnssConfigurationInterface),
+    loc_configuration_update
+};
+
 static loc_eng_data_s_type loc_afw_data;
 static int gss_fd = -1;
-
+static int sGnssType = GNSS_UNKNOWN;
 /*===========================================================================
 FUNCTION    gps_get_hardware_interface
 
@@ -193,8 +213,8 @@ extern "C" const GpsInterface* get_gps_interface()
     target = loc_get_target();
     LOC_LOGD("Target name check returned %s", loc_get_target_name(target));
 
-    int gnssType = getTargetGnssType(target);
-    switch (gnssType)
+    sGnssType = getTargetGnssType(target);
+    switch (sGnssType)
     {
     case GNSS_GSS:
         //APQ8064
@@ -278,6 +298,7 @@ static int loc_init(GpsCallbacks* callbacks)
     loc_afw_data.adapter->requestUlp(gps_conf.CAPABILITIES);
     loc_afw_data.adapter->mSupportsAgpsRequests = !loc_afw_data.adapter->hasAgpsExtendedCapabilities();
     loc_afw_data.adapter->mSupportsPositionInjection = !loc_afw_data.adapter->hasCPIExtendedCapabilities();
+    loc_afw_data.adapter->mSupportsTimeInjection = !loc_afw_data.adapter->hasCPIExtendedCapabilities();
 
     EXIT_LOG(%d, retVal);
     return retVal;
@@ -463,6 +484,11 @@ static int loc_inject_location(double latitude, double longitude, float accuracy
 {
     ENTRY_LOG();
 
+    if (accuracy < 1000)
+    {
+      accuracy = 1000;
+    }
+
     int ret_val = 0;
     ret_val = loc_eng_inject_location(loc_afw_data, latitude, longitude, accuracy);
 
@@ -521,7 +547,7 @@ const GpsGeofencingInterface* get_geofence_interface(void)
     }
     dlerror();    /* Clear any existing error */
     get_gps_geofence_interface = (get_gps_geofence_interface_function)dlsym(handle, "gps_geofence_get_interface");
-    if ((error = dlerror()) != NULL)  {
+    if ((error = dlerror()) != NULL && NULL != get_gps_geofence_interface)  {
         LOC_LOGE ("%s, dlsym for get_gps_geofence_interface failed, error = %s\n", __func__, error);
         goto exit;
      }
@@ -581,6 +607,14 @@ const void* loc_get_extension(const char* name)
            ret_val = get_geofence_interface();
        }
    }
+   else if (strcmp(name, SUPL_CERTIFICATE_INTERFACE) == 0)
+   {
+       ret_val = &sLocEngAGpsCertInterface;
+   }
+   else if (strcmp(name, GNSS_CONFIGURATION_INTERFACE) == 0)
+   {
+       ret_val = &sLocEngConfigInterface;
+   }
    else
    {
       LOC_LOGE ("get_extension: Invalid interface passed in\n");
@@ -865,6 +899,39 @@ static void loc_agps_ril_update_network_availability(int available, const char*
     EXIT_LOG(%s, VOID_RET);
 }
 
+static int loc_agps_install_certificates(const DerEncodedCertificate* certificates,
+                                         size_t length)
+{
+    ENTRY_LOG();
+    int ret_val = loc_eng_agps_install_certificates(loc_afw_data, certificates, length);
+    EXIT_LOG(%d, ret_val);
+    return ret_val;
+}
+static int loc_agps_revoke_certificates(const Sha1CertificateFingerprint* fingerprints,
+                                        size_t length)
+{
+    ENTRY_LOG();
+    LOC_LOGE("%s:%d]: agps_revoke_certificates not supported");
+    int ret_val = AGPS_CERTIFICATE_ERROR_GENERIC;
+    EXIT_LOG(%d, ret_val);
+    return ret_val;
+}
+
+static void loc_configuration_update(const char* config_data, int32_t length)
+{
+    ENTRY_LOG();
+    loc_eng_configuration_update(loc_afw_data, config_data, length);
+    switch (sGnssType)
+    {
+    case GNSS_GSS:
+    case GNSS_QCA1530:
+        //APQ
+        gps_conf.CAPABILITIES &= ~(GPS_CAPABILITY_MSA | GPS_CAPABILITY_MSB);
+        break;
+    }
+    EXIT_LOG(%s, VOID_RET);
+}
+
 static void local_loc_cb(UlpLocation* location, void* locExt)
 {
     ENTRY_LOG();
diff --git a/gps/loc_api/libloc_api_50001/loc_eng.cpp b/gps/loc_api/libloc_api_50001/loc_eng.cpp
index 443c9e7..42ae0b4 100644
--- a/gps/loc_api/libloc_api_50001/loc_eng.cpp
+++ b/gps/loc_api/libloc_api_50001/loc_eng.cpp
@@ -101,6 +101,7 @@ static loc_param_s_type loc_parameter_table[] =
   {"NMEA_PROVIDER",                  &gps_conf.NMEA_PROVIDER,                  NULL, 'n'},
   {"SUPL_VER",                       &gps_conf.SUPL_VER,                       NULL, 'n'},
   {"CAPABILITIES",                   &gps_conf.CAPABILITIES,                   NULL, 'n'},
+  {"USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL",  &gps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL,          NULL, 'n'},
   {"GYRO_BIAS_RANDOM_WALK",          &sap_conf.GYRO_BIAS_RANDOM_WALK,          &sap_conf.GYRO_BIAS_RANDOM_WALK_VALID, 'f'},
   {"ACCEL_RANDOM_WALK_SPECTRAL_DENSITY",     &sap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY,    &sap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY_VALID, 'f'},
   {"ANGLE_RANDOM_WALK_SPECTRAL_DENSITY",     &sap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY,    &sap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY_VALID, 'f'},
@@ -121,20 +122,31 @@ static loc_param_s_type loc_parameter_table[] =
   {"LPP_PROFILE",                    &gps_conf.LPP_PROFILE,                    NULL, 'n'},
   {"A_GLONASS_POS_PROTOCOL_SELECT",  &gps_conf.A_GLONASS_POS_PROTOCOL_SELECT,  NULL, 'n'},
   {"SENSOR_PROVIDER",                &sap_conf.SENSOR_PROVIDER,                NULL, 'n'},
+  {"XTRA_VERSION_CHECK",             &gps_conf.XTRA_VERSION_CHECK,             NULL, 'n'},
   {"XTRA_SERVER_1",                  &gps_conf.XTRA_SERVER_1,                  NULL, 's'},
   {"XTRA_SERVER_2",                  &gps_conf.XTRA_SERVER_2,                  NULL, 's'},
-  {"XTRA_SERVER_3",                  &gps_conf.XTRA_SERVER_3,                  NULL, 's'}
+  {"XTRA_SERVER_3",                  &gps_conf.XTRA_SERVER_3,                  NULL, 's'},
+  {"AGPS_CERT_WRITABLE_MASK",        &gps_conf.AGPS_CERT_WRITABLE_MASK,        NULL, 'n'}
 };
 
 static void loc_default_parameters(void)
 {
-   /* defaults */
+   /*Defaults for gps.conf*/
    gps_conf.INTERMEDIATE_POS = 0;
    gps_conf.ACCURACY_THRES = 0;
    gps_conf.NMEA_PROVIDER = 0;
    gps_conf.SUPL_VER = 0x10000;
    gps_conf.CAPABILITIES = 0x7;
+   /* LTE Positioning Profile configuration is disable by default*/
+   gps_conf.LPP_PROFILE = 0;
+   /*By default no positioning protocol is selected on A-GLONASS system*/
+   gps_conf.A_GLONASS_POS_PROTOCOL_SELECT = 0;
+   /*XTRA version check is disabled by default*/
+   gps_conf.XTRA_VERSION_CHECK=0;
+   /*Use emergency PDN by default*/
+   gps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL = 1;
 
+   /*Defaults for sap.conf*/
    sap_conf.GYRO_BIAS_RANDOM_WALK = 0;
    sap_conf.SENSOR_ACCEL_BATCHES_PER_SEC = 2;
    sap_conf.SENSOR_ACCEL_SAMPLES_PER_BATCH = 5;
@@ -147,28 +159,22 @@ static void loc_default_parameters(void)
    sap_conf.SENSOR_CONTROL_MODE = 0; /* AUTO */
    sap_conf.SENSOR_USAGE = 0; /* Enabled */
    sap_conf.SENSOR_ALGORITHM_CONFIG_MASK = 0; /* INS Disabled = FALSE*/
-
    /* Values MUST be set by OEMs in configuration for sensor-assisted
       navigation to work. There are NO default values */
    sap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY = 0;
    sap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY = 0;
    sap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY = 0;
    sap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY = 0;
-
    sap_conf.GYRO_BIAS_RANDOM_WALK_VALID = 0;
    sap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY_VALID = 0;
    sap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY_VALID = 0;
    sap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY_VALID = 0;
    sap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY_VALID = 0;
-
-      /* LTE Positioning Profile configuration is disable by default*/
-   gps_conf.LPP_PROFILE = 0;
-
-   /*By default no positioning protocol is selected on A-GLONASS system*/
-   gps_conf.A_GLONASS_POS_PROTOCOL_SELECT = 0;
-
    /* default provider is SSC */
    sap_conf.SENSOR_PROVIDER = 1;
+
+   /* None of the 10 slots for agps certificates are writable by default */
+   gps_conf.AGPS_CERT_WRITABLE_MASK = 0;
 }
 
 // 2nd half of init(), singled out for
@@ -872,7 +878,6 @@ void LocEngReportNmea::proc() const {
     struct timeval tv;
     gettimeofday(&tv, (struct timezone *) NULL);
     int64_t now = tv.tv_sec * 1000LL + tv.tv_usec / 1000;
-    CALLBACK_LOG_CALLFLOW("nmea_cb", %d, mLen);
 
     if (locEng->nmea_cb != NULL)
         locEng->nmea_cb(now, mNmea, mLen);
@@ -1064,7 +1069,17 @@ void LocEngRequestSuplEs::proc() const {
         AgpsStateMachine* sm = locEng->ds_nif;
         DSSubscriber s(sm, mID);
         sm->subscribeRsrc((Subscriber*)&s);
-    } else {
+    }
+    else if (locEng->agnss_nif) {
+        AgpsStateMachine *sm = locEng->agnss_nif;
+        ATLSubscriber s(mID,
+                        sm,
+                        locEng->adapter,
+                        false);
+        sm->subscribeRsrc((Subscriber*)&s);
+        LOC_LOGD("%s:%d]: Using regular ATL for SUPL ES", __func__, __LINE__);
+    }
+    else {
         locEng->adapter->atlOpenStatus(mID, 0, NULL, -1, -1);
     }
 }
@@ -1463,6 +1478,51 @@ struct LocEngDataClientInit : public LocMsg {
     }
 };
 
+struct LocEngInstallAGpsCert : public LocMsg {
+    LocEngAdapter* mpAdapter;
+    const size_t mNumberOfCerts;
+    const uint32_t mSlotBitMask;
+    DerEncodedCertificate* mpData;
+    inline LocEngInstallAGpsCert(LocEngAdapter* adapter,
+                              const DerEncodedCertificate* pData,
+                              size_t numberOfCerts,
+                              uint32_t slotBitMask) :
+        LocMsg(), mpAdapter(adapter),
+        mNumberOfCerts(numberOfCerts), mSlotBitMask(slotBitMask),
+        mpData(new DerEncodedCertificate[mNumberOfCerts])
+    {
+        for (int i=0; i < mNumberOfCerts; i++) {
+            mpData[i].data = new u_char[pData[i].length];
+            if (mpData[i].data) {
+                memcpy(mpData[i].data, (void*)pData[i].data, pData[i].length);
+                mpData[i].length = pData[i].length;
+            } else {
+                LOC_LOGE("malloc failed for cert#%d", i);
+                break;
+            }
+        }
+        locallog();
+    }
+    inline ~LocEngInstallAGpsCert()
+    {
+        for (int i=0; i < mNumberOfCerts; i++) {
+            if (mpData[i].data) {
+                delete[] mpData[i].data;
+            }
+        }
+        delete[] mpData;
+    }
+    inline virtual void proc() const {
+        mpAdapter->installAGpsCert(mpData, mNumberOfCerts, mSlotBitMask);
+    }
+    inline void locallog() const {
+        LOC_LOGV("LocEngInstallAGpsCert - certs=%u mask=%u",
+                 mNumberOfCerts, mSlotBitMask);
+    }
+    inline virtual void log() const {
+        locallog();
+    }
+};
 
 /*********************************************************************
  * Initialization checking macros
@@ -1562,52 +1622,50 @@ static int loc_eng_reinit(loc_eng_data_s_type &loc_eng_data)
 {
     ENTRY_LOG();
     int ret_val = LOC_API_ADAPTER_ERR_SUCCESS;
+    LocEngAdapter* adapter = loc_eng_data.adapter;
 
-    if (LOC_API_ADAPTER_ERR_SUCCESS == ret_val) {
-        LOC_LOGD("loc_eng_reinit reinit() successful");
-
-        LocEngAdapter* adapter = loc_eng_data.adapter;
-        adapter->sendMsg(new LocEngSuplVer(adapter, gps_conf.SUPL_VER));
-        adapter->sendMsg(new LocEngLppConfig(adapter, gps_conf.LPP_PROFILE));
-        adapter->sendMsg(new LocEngSensorControlConfig(adapter, sap_conf.SENSOR_USAGE,
-                                                       sap_conf.SENSOR_PROVIDER));
-        adapter->sendMsg(new LocEngAGlonassProtocol(adapter, gps_conf.A_GLONASS_POS_PROTOCOL_SELECT));
-
-        /* Make sure at least one of the sensor property is specified by the user in the gps.conf file. */
-        if( sap_conf.GYRO_BIAS_RANDOM_WALK_VALID ||
-            sap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY_VALID ||
-            sap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY_VALID ||
-            sap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY_VALID ||
-            sap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY_VALID )
-        {
-            adapter->sendMsg(new LocEngSensorProperties(adapter,
-                                                        sap_conf.GYRO_BIAS_RANDOM_WALK_VALID,
-                                                        sap_conf.GYRO_BIAS_RANDOM_WALK,
-                                                        sap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY_VALID,
-                                                        sap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY,
-                                                        sap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY_VALID,
-                                                        sap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY,
-                                                        sap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY_VALID,
-                                                        sap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY,
-                                                        sap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY_VALID,
-                                                        sap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY));
-        }
-
-        adapter->sendMsg(new LocEngSensorPerfControlConfig(adapter,
-                                                           sap_conf.SENSOR_CONTROL_MODE,
-                                                           sap_conf.SENSOR_ACCEL_SAMPLES_PER_BATCH,
-                                                           sap_conf.SENSOR_ACCEL_BATCHES_PER_SEC,
-                                                           sap_conf.SENSOR_GYRO_SAMPLES_PER_BATCH,
-                                                           sap_conf.SENSOR_GYRO_BATCHES_PER_SEC,
-                                                           sap_conf.SENSOR_ACCEL_SAMPLES_PER_BATCH_HIGH,
-                                                           sap_conf.SENSOR_ACCEL_BATCHES_PER_SEC_HIGH,
-                                                           sap_conf.SENSOR_GYRO_SAMPLES_PER_BATCH_HIGH,
-                                                           sap_conf.SENSOR_GYRO_BATCHES_PER_SEC_HIGH,
-                                                           sap_conf.SENSOR_ALGORITHM_CONFIG_MASK));
-
-        adapter->sendMsg(new LocEngEnableData(adapter, NULL, 0, (agpsStatus ? 1:0)));
-    }
-
+    adapter->sendMsg(new LocEngSuplVer(adapter, gps_conf.SUPL_VER));
+    adapter->sendMsg(new LocEngLppConfig(adapter, gps_conf.LPP_PROFILE));
+    adapter->sendMsg(new LocEngSensorControlConfig(adapter, sap_conf.SENSOR_USAGE,
+                                                   sap_conf.SENSOR_PROVIDER));
+    adapter->sendMsg(new LocEngAGlonassProtocol(adapter, gps_conf.A_GLONASS_POS_PROTOCOL_SELECT));
+
+    /* Make sure at least one of the sensor property is specified by the user in the gps.conf file. */
+    if( sap_conf.GYRO_BIAS_RANDOM_WALK_VALID ||
+        sap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY_VALID ||
+        sap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY_VALID ||
+        sap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY_VALID ||
+        sap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY_VALID ) {
+        adapter->sendMsg(new LocEngSensorProperties(adapter,
+                                                    sap_conf.GYRO_BIAS_RANDOM_WALK_VALID,
+                                                    sap_conf.GYRO_BIAS_RANDOM_WALK,
+                                                    sap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY_VALID,
+                                                    sap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY,
+                                                    sap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY_VALID,
+                                                    sap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY,
+                                                    sap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY_VALID,
+                                                    sap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY,
+                                                    sap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY_VALID,
+                                                    sap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY));
+    }
+
+    adapter->sendMsg(new LocEngSensorPerfControlConfig(adapter,
+                                                       sap_conf.SENSOR_CONTROL_MODE,
+                                                       sap_conf.SENSOR_ACCEL_SAMPLES_PER_BATCH,
+                                                       sap_conf.SENSOR_ACCEL_BATCHES_PER_SEC,
+                                                       sap_conf.SENSOR_GYRO_SAMPLES_PER_BATCH,
+                                                       sap_conf.SENSOR_GYRO_BATCHES_PER_SEC,
+                                                       sap_conf.SENSOR_ACCEL_SAMPLES_PER_BATCH_HIGH,
+                                                       sap_conf.SENSOR_ACCEL_BATCHES_PER_SEC_HIGH,
+                                                       sap_conf.SENSOR_GYRO_SAMPLES_PER_BATCH_HIGH,
+                                                       sap_conf.SENSOR_GYRO_BATCHES_PER_SEC_HIGH,
+                                                       sap_conf.SENSOR_ALGORITHM_CONFIG_MASK));
+
+    adapter->sendMsg(new LocEngEnableData(adapter, NULL, 0, (agpsStatus ? 1:0)));
+
+    loc_eng_xtra_version_check(loc_eng_data, gps_conf.XTRA_VERSION_CHECK);
+
+    LOC_LOGD("loc_eng_reinit reinit() successful");
     EXIT_LOG(%d, ret_val);
     return ret_val;
 }
@@ -1712,7 +1770,6 @@ static int loc_eng_start_handler(loc_eng_data_s_type &loc_eng_data)
            ret_val == LOC_API_ADAPTER_ERR_INTERNAL)
        {
            loc_eng_data.adapter->setInSession(TRUE);
-           loc_inform_gps_status(loc_eng_data, GPS_STATUS_SESSION_BEGIN);
        }
    }
 
@@ -1758,11 +1815,6 @@ static int loc_eng_stop_handler(loc_eng_data_s_type &loc_eng_data)
    if (loc_eng_data.adapter->isInSession()) {
 
        ret_val = loc_eng_data.adapter->stopFix();
-       if (ret_val == LOC_API_ADAPTER_ERR_SUCCESS)
-       {
-           loc_inform_gps_status(loc_eng_data, GPS_STATUS_SESSION_END);
-       }
-
        loc_eng_data.adapter->setInSession(FALSE);
    }
 
@@ -1815,14 +1867,12 @@ int loc_eng_set_position_mode(loc_eng_data_s_type &loc_eng_data,
     ENTRY_LOG_CALLFLOW();
     INIT_CHECK(loc_eng_data.adapter, return -1);
 
-    int gnssType = getTargetGnssType(loc_get_target());
-
-    // The position mode for GSS/QCA1530 can only be standalone
-    bool is1530 = gnssType == GNSS_QCA1530;
-    bool isAPQ = gnssType == GNSS_GSS;
-    if ((isAPQ || is1530) && params.mode != LOC_POSITION_MODE_STANDALONE) {
+    // The position mode for AUTO/GSS/QCA1530 can only be standalone
+    if (!(gps_conf.CAPABILITIES & GPS_CAPABILITY_MSB) &&
+        !(gps_conf.CAPABILITIES & GPS_CAPABILITY_MSA) &&
+        (params.mode != LOC_POSITION_MODE_STANDALONE)) {
         params.mode = LOC_POSITION_MODE_STANDALONE;
-        LOC_LOGD("Position mode changed to standalone for target with GSS/qca1530.");
+        LOC_LOGD("Position mode changed to standalone for target with AUTO/GSS/qca1530.");
     }
 
     if(! loc_eng_data.adapter->getUlpProxy()->sendFixMode(params))
@@ -1970,7 +2020,6 @@ static int loc_eng_get_zpp_handler(loc_eng_data_s_type &loc_eng_data)
    GpsLocationExtended locationExtended;
    memset(&locationExtended, 0, sizeof (GpsLocationExtended));
    locationExtended.size = sizeof(locationExtended);
-   memset(&location, 0, sizeof location);
 
    ret_val = loc_eng_data.adapter->getZpp(location.gpsLocation, tech_mask);
   //Mark the location source as from ZPP
@@ -2095,18 +2144,17 @@ void loc_eng_agps_init(loc_eng_data_s_type &loc_eng_data, AGpsExtCallbacks* call
                                                  AGPS_TYPE_WIFI,
                                                  true);
 
-    int gnssType = getTargetGnssType(loc_get_target());
-    bool isAPQ = (gnssType == GNSS_GSS);
-    bool is1530 = (gnssType == GNSS_QCA1530);
-    if (!isAPQ && !is1530) {
+    if ((gps_conf.CAPABILITIES & GPS_CAPABILITY_MSA) ||
+        (gps_conf.CAPABILITIES & GPS_CAPABILITY_MSB)) {
         loc_eng_data.agnss_nif = new AgpsStateMachine(servicerTypeAgps,
                                                       (void *)loc_eng_data.agps_status_cb,
                                                       AGPS_TYPE_SUPL,
                                                       false);
 
         if (adapter->mSupportsAgpsRequests) {
-            loc_eng_data.adapter->sendMsg(new LocEngDataClientInit(&loc_eng_data));
-
+            if(gps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL) {
+                loc_eng_data.adapter->sendMsg(new LocEngDataClientInit(&loc_eng_data));
+            }
             loc_eng_dmn_conn_loc_api_server_launch(callbacks->create_thread_cb,
                                                    NULL, NULL, &loc_eng_data);
         }
@@ -2138,7 +2186,9 @@ getAgpsStateMachine(loc_eng_data_s_type &locEng, AGpsExtType agpsType) {
         break;
     }
     case AGPS_TYPE_SUPL_ES: {
-        stateMachine = locEng.ds_nif;
+        locEng.ds_nif ?
+            stateMachine = locEng.ds_nif:
+            stateMachine = locEng.agnss_nif;
         break;
     }
     default:
@@ -2368,29 +2418,29 @@ int loc_eng_set_server_proxy(loc_eng_data_s_type &loc_eng_data,
     ENTRY_LOG_CALLFLOW();
     int ret_val = 0;
 
+    LOC_LOGV("save the address, type: %d, hostname: %s, port: %d",
+             (int) type, hostname, port);
+    switch (type)
+    {
+    case LOC_AGPS_SUPL_SERVER:
+        strlcpy(loc_eng_data.supl_host_buf, hostname,
+                sizeof(loc_eng_data.supl_host_buf));
+        loc_eng_data.supl_port_buf = port;
+        loc_eng_data.supl_host_set = 1;
+        break;
+    case LOC_AGPS_CDMA_PDE_SERVER:
+        strlcpy(loc_eng_data.c2k_host_buf, hostname,
+                sizeof(loc_eng_data.c2k_host_buf));
+        loc_eng_data.c2k_port_buf = port;
+        loc_eng_data.c2k_host_set = 1;
+        break;
+    default:
+        LOC_LOGE("loc_eng_set_server_proxy, unknown server type = %d", (int) type);
+    }
+
     if (NULL != loc_eng_data.adapter)
     {
         ret_val = loc_eng_set_server(loc_eng_data, type, hostname, port);
-    } else {
-        LOC_LOGW("set_server called before init. save the address, type: %d, hostname: %s, port: %d",
-                 (int) type, hostname, port);
-        switch (type)
-        {
-        case LOC_AGPS_SUPL_SERVER:
-            strlcpy(loc_eng_data.supl_host_buf, hostname,
-                    sizeof(loc_eng_data.supl_host_buf));
-            loc_eng_data.supl_port_buf = port;
-            loc_eng_data.supl_host_set = 1;
-            break;
-        case LOC_AGPS_CDMA_PDE_SERVER:
-            strlcpy(loc_eng_data.c2k_host_buf, hostname,
-                    sizeof(loc_eng_data.c2k_host_buf));
-            loc_eng_data.c2k_port_buf = port;
-            loc_eng_data.c2k_host_set = 1;
-            break;
-        default:
-            LOC_LOGE("loc_eng_set_server_proxy, unknown server type = %d", (int) type);
-        }
     }
 
     EXIT_LOG(%d, ret_val);
@@ -2437,6 +2487,84 @@ void loc_eng_agps_ril_update_network_availability(loc_eng_data_s_type &loc_eng_d
     EXIT_LOG(%s, VOID_RET);
 }
 
+int loc_eng_agps_install_certificates(loc_eng_data_s_type &loc_eng_data,
+                                      const DerEncodedCertificate* certificates,
+                                      size_t numberOfCerts)
+{
+    ENTRY_LOG_CALLFLOW();
+    int ret_val = AGPS_CERTIFICATE_OPERATION_SUCCESS;
+
+    uint32_t slotBitMask = gps_conf.AGPS_CERT_WRITABLE_MASK;
+    uint32_t slotCount = 0;
+    for (uint32_t slotBitMaskCounter=slotBitMask; slotBitMaskCounter; slotCount++) {
+        slotBitMaskCounter &= slotBitMaskCounter - 1;
+    }
+    LOC_LOGD("SlotBitMask=%u SlotCount=%u NumberOfCerts=%u",
+             slotBitMask, slotCount, numberOfCerts);
+
+    LocEngAdapter* adapter = loc_eng_data.adapter;
+
+    if (numberOfCerts == 0) {
+        LOC_LOGE("No certs to install, since numberOfCerts is zero");
+        ret_val = AGPS_CERTIFICATE_OPERATION_SUCCESS;
+    } else if (!adapter) {
+        LOC_LOGE("adapter is null!");
+        ret_val = AGPS_CERTIFICATE_ERROR_GENERIC;
+    } else if (slotCount < numberOfCerts) {
+        LOC_LOGE("Not enough cert slots (%u) to install %u certs!",
+                 slotCount, numberOfCerts);
+        ret_val = AGPS_CERTIFICATE_ERROR_TOO_MANY_CERTIFICATES;
+    } else {
+        for (int i=0; i < numberOfCerts; ++i)
+        {
+            if (certificates[i].length > AGPS_CERTIFICATE_MAX_LENGTH) {
+                LOC_LOGE("cert#(%u) length of %u is too big! greater than %u",
+                        certificates[i].length, AGPS_CERTIFICATE_MAX_LENGTH);
+                ret_val = AGPS_CERTIFICATE_ERROR_GENERIC;
+                break;
+            }
+        }
+
+        if (ret_val == AGPS_CERTIFICATE_OPERATION_SUCCESS) {
+            adapter->sendMsg(new LocEngInstallAGpsCert(adapter,
+                                                       certificates,
+                                                       numberOfCerts,
+                                                       slotBitMask));
+        }
+    }
+
+    EXIT_LOG(%d, ret_val);
+    return ret_val;
+}
+
+void loc_eng_configuration_update (loc_eng_data_s_type &loc_eng_data,
+                                   const char* config_data, int32_t length)
+{
+    ENTRY_LOG_CALLFLOW();
+
+    if (config_data && length > 0) {
+        loc_gps_cfg_s_type gps_conf_old = gps_conf;
+        UTIL_UPDATE_CONF(config_data, length, loc_parameter_table);
+        LocEngAdapter* adapter = loc_eng_data.adapter;
+
+        // it is possible that HAL is not init'ed at this time
+        if (adapter) {
+            if (gps_conf_old.SUPL_VER != gps_conf.SUPL_VER) {
+                adapter->sendMsg(new LocEngSuplVer(adapter, gps_conf.SUPL_VER));
+            }
+            if (gps_conf_old.LPP_PROFILE != gps_conf.LPP_PROFILE) {
+                adapter->sendMsg(new LocEngLppConfig(adapter, gps_conf.LPP_PROFILE));
+            }
+            if (gps_conf_old.A_GLONASS_POS_PROTOCOL_SELECT != gps_conf.A_GLONASS_POS_PROTOCOL_SELECT) {
+                adapter->sendMsg(new LocEngAGlonassProtocol(adapter,
+                                                            gps_conf.A_GLONASS_POS_PROTOCOL_SELECT));
+            }
+        }
+    }
+
+    EXIT_LOG(%s, VOID_RET);
+}
+
 /*===========================================================================
 FUNCTION    loc_eng_report_status
 
@@ -2545,8 +2673,6 @@ void loc_eng_handle_engine_up(loc_eng_data_s_type &loc_eng_data)
         loc_eng_agps_reinit(loc_eng_data);
     }
 
-    loc_eng_report_status(loc_eng_data, GPS_STATUS_ENGINE_ON);
-
     // modem is back up.  If we crashed in the middle of navigating, we restart.
     if (loc_eng_data.adapter->isInSession()) {
         // This sets the copy in adapter to modem
diff --git a/gps/loc_api/libloc_api_50001/loc_eng.h b/gps/loc_api/libloc_api_50001/loc_eng.h
index 5d4e5de..fe51657 100644
--- a/gps/loc_api/libloc_api_50001/loc_eng.h
+++ b/gps/loc_api/libloc_api_50001/loc_eng.h
@@ -140,34 +140,37 @@ typedef struct loc_eng_data_s
 /* GPS.conf support */
 typedef struct loc_gps_cfg_s
 {
-    unsigned long  INTERMEDIATE_POS;
-    unsigned long  ACCURACY_THRES;
-    unsigned long  SUPL_VER;
-    unsigned long  CAPABILITIES;
-    unsigned long  QUIPC_ENABLED;
-    unsigned long  LPP_PROFILE;
+    uint32_t       INTERMEDIATE_POS;
+    uint32_t       ACCURACY_THRES;
+    uint32_t       SUPL_VER;
+    uint32_t       CAPABILITIES;
+    uint32_t       QUIPC_ENABLED;
+    uint32_t       LPP_PROFILE;
     uint8_t        NMEA_PROVIDER;
-    unsigned long  A_GLONASS_POS_PROTOCOL_SELECT;
+    uint32_t       XTRA_VERSION_CHECK;
     char           XTRA_SERVER_1[MAX_XTRA_SERVER_URL_LENGTH];
     char           XTRA_SERVER_2[MAX_XTRA_SERVER_URL_LENGTH];
     char           XTRA_SERVER_3[MAX_XTRA_SERVER_URL_LENGTH];
+    uint32_t       USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL;
+    uint32_t       A_GLONASS_POS_PROTOCOL_SELECT;
+    uint32_t       AGPS_CERT_WRITABLE_MASK;
 } loc_gps_cfg_s_type;
 
 typedef struct
 {
     uint8_t        GYRO_BIAS_RANDOM_WALK_VALID;
     double         GYRO_BIAS_RANDOM_WALK;
-    unsigned long  SENSOR_ACCEL_BATCHES_PER_SEC;
-    unsigned long  SENSOR_ACCEL_SAMPLES_PER_BATCH;
-    unsigned long  SENSOR_GYRO_BATCHES_PER_SEC;
-    unsigned long  SENSOR_GYRO_SAMPLES_PER_BATCH;
-    unsigned long  SENSOR_ACCEL_BATCHES_PER_SEC_HIGH;
-    unsigned long  SENSOR_ACCEL_SAMPLES_PER_BATCH_HIGH;
-    unsigned long  SENSOR_GYRO_BATCHES_PER_SEC_HIGH;
-    unsigned long  SENSOR_GYRO_SAMPLES_PER_BATCH_HIGH;
-    unsigned long  SENSOR_CONTROL_MODE;
-    unsigned long  SENSOR_USAGE;
-    unsigned long  SENSOR_ALGORITHM_CONFIG_MASK;
+    uint32_t       SENSOR_ACCEL_BATCHES_PER_SEC;
+    uint32_t       SENSOR_ACCEL_SAMPLES_PER_BATCH;
+    uint32_t       SENSOR_GYRO_BATCHES_PER_SEC;
+    uint32_t       SENSOR_GYRO_SAMPLES_PER_BATCH;
+    uint32_t       SENSOR_ACCEL_BATCHES_PER_SEC_HIGH;
+    uint32_t       SENSOR_ACCEL_SAMPLES_PER_BATCH_HIGH;
+    uint32_t       SENSOR_GYRO_BATCHES_PER_SEC_HIGH;
+    uint32_t       SENSOR_GYRO_SAMPLES_PER_BATCH_HIGH;
+    uint32_t       SENSOR_CONTROL_MODE;
+    uint32_t       SENSOR_USAGE;
+    uint32_t       SENSOR_ALGORITHM_CONFIG_MASK;
     uint8_t        ACCEL_RANDOM_WALK_SPECTRAL_DENSITY_VALID;
     double         ACCEL_RANDOM_WALK_SPECTRAL_DENSITY;
     uint8_t        ANGLE_RANDOM_WALK_SPECTRAL_DENSITY_VALID;
@@ -176,12 +179,13 @@ typedef struct
     double         RATE_RANDOM_WALK_SPECTRAL_DENSITY;
     uint8_t        VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY_VALID;
     double         VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY;
-    unsigned long  SENSOR_PROVIDER;
+    uint32_t       SENSOR_PROVIDER;
 } loc_sap_cfg_s_type;
 
 extern loc_gps_cfg_s_type gps_conf;
 extern loc_sap_cfg_s_type sap_conf;
 
+//loc_eng functions
 int  loc_eng_init(loc_eng_data_s_type &loc_eng_data,
                   LocCallbacks* callbacks,
                   LOC_API_ADAPTER_EVENT_MASK_T event,
@@ -201,35 +205,33 @@ int  loc_eng_set_position_mode(loc_eng_data_s_type &loc_eng_data,
                                LocPosMode &params);
 const void* loc_eng_get_extension(loc_eng_data_s_type &loc_eng_data,
                                   const char* name);
+int  loc_eng_set_server_proxy(loc_eng_data_s_type &loc_eng_data,
+                              LocServerType type, const char *hostname, int port);
+void loc_eng_mute_one_session(loc_eng_data_s_type &loc_eng_data);
+int loc_eng_read_config(void);
+
+//loc_eng_agps functions
 void loc_eng_agps_init(loc_eng_data_s_type &loc_eng_data,
                        AGpsExtCallbacks* callbacks);
 int  loc_eng_agps_open(loc_eng_data_s_type &loc_eng_data, AGpsExtType agpsType,
                       const char* apn, AGpsBearerType bearerType);
 int  loc_eng_agps_closed(loc_eng_data_s_type &loc_eng_data, AGpsExtType agpsType);
 int  loc_eng_agps_open_failed(loc_eng_data_s_type &loc_eng_data, AGpsExtType agpsType);
-
-int  loc_eng_set_server_proxy(loc_eng_data_s_type &loc_eng_data,
-                              LocServerType type, const char *hostname, int port);
-
-
 void loc_eng_agps_ril_update_network_availability(loc_eng_data_s_type &loc_eng_data,
                                                   int avaiable, const char* apn);
+int loc_eng_agps_install_certificates(loc_eng_data_s_type &loc_eng_data,
+                                      const DerEncodedCertificate* certificates,
+                                      size_t length);
 
-
-bool loc_eng_inject_raw_command(loc_eng_data_s_type &loc_eng_data,
-                                char* command, int length);
-
-
-void loc_eng_mute_one_session(loc_eng_data_s_type &loc_eng_data);
-
-int loc_eng_xtra_init (loc_eng_data_s_type &loc_eng_data,
+//loc_eng_xtra functions
+int  loc_eng_xtra_init (loc_eng_data_s_type &loc_eng_data,
                        GpsXtraExtCallbacks* callbacks);
-
-int loc_eng_xtra_inject_data(loc_eng_data_s_type &loc_eng_data,
+int  loc_eng_xtra_inject_data(loc_eng_data_s_type &loc_eng_data,
                              char* data, int length);
+int  loc_eng_xtra_request_server(loc_eng_data_s_type &loc_eng_data);
+void loc_eng_xtra_version_check(loc_eng_data_s_type &loc_eng_data, int check);
 
-int loc_eng_xtra_request_server(loc_eng_data_s_type &loc_eng_data);
-
+//loc_eng_ni functions
 extern void loc_eng_ni_init(loc_eng_data_s_type &loc_eng_data,
                             GpsNiExtCallbacks *callbacks);
 extern void loc_eng_ni_respond(loc_eng_data_s_type &loc_eng_data,
@@ -238,7 +240,9 @@ extern void loc_eng_ni_request_handler(loc_eng_data_s_type &loc_eng_data,
                                    const GpsNiNotification *notif,
                                    const void* passThrough);
 extern void loc_eng_ni_reset_on_engine_restart(loc_eng_data_s_type &loc_eng_data);
-int loc_eng_read_config(void);
+
+void loc_eng_configuration_update (loc_eng_data_s_type &loc_eng_data,
+                                   const char* config_data, int32_t length);
 
 #ifdef __cplusplus
 }
diff --git a/gps/loc_api/libloc_api_50001/loc_eng_nmea.cpp b/gps/loc_api/libloc_api_50001/loc_eng_nmea.cpp
index 842eda1..2485c59 100644
--- a/gps/loc_api/libloc_api_50001/loc_eng_nmea.cpp
+++ b/gps/loc_api/libloc_api_50001/loc_eng_nmea.cpp
@@ -59,7 +59,6 @@ void loc_eng_nmea_send(char *pNmea, int length, loc_eng_data_s_type *loc_eng_dat
     struct timeval tv;
     gettimeofday(&tv, (struct timezone *) NULL);
     int64_t now = tv.tv_sec * 1000LL + tv.tv_usec / 1000;
-    CALLBACK_LOG_CALLFLOW("nmea_cb", %p, pNmea);
     if (loc_eng_data_p->nmea_cb != NULL)
         loc_eng_data_p->nmea_cb(now, pNmea, length);
     LOC_LOGD("NMEA <%s", pNmea);
@@ -119,14 +118,17 @@ void loc_eng_nmea_generate_pos(loc_eng_data_s_type *loc_eng_data_p,
                                unsigned char generate_nmea)
 {
     ENTRY_LOG();
+    time_t utcTime(location.gpsLocation.timestamp/1000);
+    tm * pTm = gmtime(&utcTime);
+    if (NULL == pTm) {
+        LOC_LOGE("gmtime failed");
+        return;
+    }
 
     char sentence[NMEA_SENTENCE_MAX_LENGTH] = {0};
     char* pMarker = sentence;
     int lengthRemaining = sizeof(sentence);
     int length = 0;
-
-    time_t utcTime(location.gpsLocation.timestamp/1000);
-    tm * pTm = gmtime(&utcTime);
     int utcYear = pTm->tm_year % 100; // 2 digit year
     int utcMonth = pTm->tm_mon + 1; // tm_mon starts at zero
     int utcDay = pTm->tm_mday;
diff --git a/gps/loc_api/libloc_api_50001/loc_eng_xtra.cpp b/gps/loc_api/libloc_api_50001/loc_eng_xtra.cpp
index 4582286..7bb8083 100644
--- a/gps/loc_api/libloc_api_50001/loc_eng_xtra.cpp
+++ b/gps/loc_api/libloc_api_50001/loc_eng_xtra.cpp
@@ -82,6 +82,25 @@ struct LocEngInjectXtraData : public LocMsg {
     }
 };
 
+struct LocEngSetXtraVersionCheck : public LocMsg {
+    LocEngAdapter *mAdapter;
+    int mCheck;
+    inline LocEngSetXtraVersionCheck(LocEngAdapter* adapter,
+                                        int check):
+        mAdapter(adapter), mCheck(check) {}
+    inline virtual void proc() const {
+        locallog();
+        mAdapter->setXtraVersionCheck(mCheck);
+    }
+    inline void locallog() const {
+        LOC_LOGD("%s:%d]: mCheck: %d",
+                 __func__, __LINE__, mCheck);
+    }
+    inline virtual void log() const {
+        locallog();
+    }
+};
+
 /*===========================================================================
 FUNCTION    loc_eng_xtra_init
 
@@ -103,6 +122,7 @@ int loc_eng_xtra_init (loc_eng_data_s_type &loc_eng_data,
 {
     int ret_val = -1;
     loc_eng_xtra_data_s_type *xtra_module_data_ptr;
+    ENTRY_LOG();
 
     if(callbacks == NULL) {
         LOC_LOGE("loc_eng_xtra_init: failed, cb is NULL");
@@ -113,6 +133,7 @@ int loc_eng_xtra_init (loc_eng_data_s_type &loc_eng_data,
 
         ret_val = 0;
     }
+    EXIT_LOG(%d, ret_val);
     return ret_val;
 }
 
@@ -126,8 +147,7 @@ DEPENDENCIES
    N/A
 
 RETURN VALUE
-   0: success
-   >0: failure
+   0
 
 SIDE EFFECTS
    N/A
@@ -136,9 +156,10 @@ SIDE EFFECTS
 int loc_eng_xtra_inject_data(loc_eng_data_s_type &loc_eng_data,
                              char* data, int length)
 {
+    ENTRY_LOG();
     LocEngAdapter* adapter = loc_eng_data.adapter;
     adapter->sendMsg(new LocEngInjectXtraData(adapter, data, length));
-
+    EXIT_LOG(%d, 0);
     return 0;
 }
 /*===========================================================================
@@ -151,7 +172,7 @@ DEPENDENCIES
    N/A
 
 RETURN VALUE
-   length of server string
+   0
 
 SIDE EFFECTS
    N/A
@@ -159,9 +180,34 @@ SIDE EFFECTS
 ===========================================================================*/
 int loc_eng_xtra_request_server(loc_eng_data_s_type &loc_eng_data)
 {
+    ENTRY_LOG();
     LocEngAdapter* adapter = loc_eng_data.adapter;
     adapter->sendMsg(new LocEngRequestXtraServer(adapter));
-
+    EXIT_LOG(%d, 0);
     return 0;
+}
+/*===========================================================================
+FUNCTION    loc_eng_xtra_version_check
+
+DESCRIPTION
+   Injects the enable/disable value for checking XTRA version
+   that is specified in gps.conf
 
+DEPENDENCIES
+   N/A
+
+RETURN VALUE
+   none
+
+SIDE EFFECTS
+   N/A
+
+===========================================================================*/
+void loc_eng_xtra_version_check(loc_eng_data_s_type &loc_eng_data,
+                                int check)
+{
+    ENTRY_LOG();
+    LocEngAdapter *adapter = loc_eng_data.adapter;
+    adapter->sendMsg(new LocEngSetXtraVersionCheck(adapter, check));
+    EXIT_LOG(%d, 0);
 }
diff --git a/gps/utils/Android.mk b/gps/utils/Android.mk
index 453166c..771afa4 100644
--- a/gps/utils/Android.mk
+++ b/gps/utils/Android.mk
@@ -25,9 +25,12 @@ LOCAL_SRC_FILES += \
 
 LOCAL_CFLAGS += \
      -fno-short-enums \
-     -D_ANDROID_
+     -D_ANDROID_ \
+     -Wno-unused-parameter
 
-LOCAL_CLANG := false
+ifeq ($(TARGET_BUILD_VARIANT),user)
+   LOCAL_CFLAGS += -DTARGET_BUILD_VARIANT_USER
+endif
 
 LOCAL_LDFLAGS += -Wl,--export-dynamic
 
@@ -54,6 +57,5 @@ LOCAL_MODULE := libgps.utils
 
 LOCAL_MODULE_TAGS := optional
 
-LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)
 include $(BUILD_SHARED_LIBRARY)
 endif # not BUILD_TINY_ANDROID
diff --git a/gps/utils/loc_cfg.cpp b/gps/utils/loc_cfg.cpp
index dc8e3a7..3d9b947 100644
--- a/gps/utils/loc_cfg.cpp
+++ b/gps/utils/loc_cfg.cpp
@@ -56,12 +56,12 @@ static uint8_t DEBUG_LEVEL = 0xff;
 static uint8_t TIMESTAMP = 0;
 
 /* Parameter spec table */
-static loc_param_s_type loc_parameter_table[] =
+static loc_param_s_type loc_param_table[] =
 {
     {"DEBUG_LEVEL",    &DEBUG_LEVEL, NULL,    'n'},
     {"TIMESTAMP",      &TIMESTAMP,   NULL,    'n'},
 };
-int loc_param_num = sizeof(loc_parameter_table) / sizeof(loc_param_s_type);
+int loc_param_num = sizeof(loc_param_table) / sizeof(loc_param_s_type);
 
 typedef struct loc_param_v_type
 {
@@ -117,7 +117,8 @@ int loc_set_config_entry(loc_param_s_type* config_entry, loc_param_v_type* confi
                         LOC_MAX_PARAM_STRING + 1);
             }
             /* Log INI values */
-            LOC_LOGD("%s: PARAM %s = %s", __FUNCTION__, config_entry->param_name, (char*)config_entry->param_ptr);
+            LOC_LOGD("%s: PARAM %s = %s", __FUNCTION__,
+                     config_entry->param_name, (char*)config_entry->param_ptr);
 
             if(NULL != config_entry->param_set)
             {
@@ -128,7 +129,8 @@ int loc_set_config_entry(loc_param_s_type* config_entry, loc_param_v_type* confi
         case 'n':
             *((int *)config_entry->param_ptr) = config_value->param_int_value;
             /* Log INI values */
-            LOC_LOGD("%s: PARAM %s = %d", __FUNCTION__, config_entry->param_name, config_value->param_int_value);
+            LOC_LOGD("%s: PARAM %s = %d", __FUNCTION__,
+                     config_entry->param_name, config_value->param_int_value);
 
             if(NULL != config_entry->param_set)
             {
@@ -139,7 +141,8 @@ int loc_set_config_entry(loc_param_s_type* config_entry, loc_param_v_type* confi
         case 'f':
             *((double *)config_entry->param_ptr) = config_value->param_double_value;
             /* Log INI values */
-            LOC_LOGD("%s: PARAM %s = %f", __FUNCTION__, config_entry->param_name, config_value->param_double_value);
+            LOC_LOGD("%s: PARAM %s = %f", __FUNCTION__,
+                     config_entry->param_name, config_value->param_double_value);
 
             if(NULL != config_entry->param_set)
             {
@@ -148,13 +151,86 @@ int loc_set_config_entry(loc_param_s_type* config_entry, loc_param_v_type* confi
             ret = 0;
             break;
         default:
-            LOC_LOGE("%s: PARAM %s parameter type must be n, f, or s", __FUNCTION__, config_entry->param_name);
+            LOC_LOGE("%s: PARAM %s parameter type must be n, f, or s",
+                     __FUNCTION__, config_entry->param_name);
         }
     }
     return ret;
 }
 
 /*===========================================================================
+FUNCTION loc_fill_conf_item
+
+DESCRIPTION
+   Takes a line of configuration item and sets defined values based on
+   the passed in configuration table. This table maps strings to values to
+   set along with the type of each of these values.
+
+PARAMETERS:
+   input_buf : buffer contanis config item
+   config_table: table definition of strings to places to store information
+   table_length: length of the configuration table
+
+DEPENDENCIES
+   N/A
+
+RETURN VALUE
+   0: No config or incomplete config or invalid parameter
+   1: Filled a record
+
+SIDE EFFECTS
+   N/A
+===========================================================================*/
+int loc_fill_conf_item(char* input_buf,
+                       loc_param_s_type* config_table, uint32_t table_length)
+{
+    int ret = 0;
+
+    if (input_buf && config_table) {
+        char *lasts;
+        loc_param_v_type config_value;
+        memset(&config_value, 0, sizeof(config_value));
+
+        /* Separate variable and value */
+        config_value.param_name = strtok_r(input_buf, "=", &lasts);
+        /* skip lines that do not contain "=" */
+        if (config_value.param_name) {
+            config_value.param_str_value = strtok_r(NULL, "=", &lasts);
+
+            /* skip lines that do not contain two operands */
+            if (config_value.param_str_value) {
+                /* Trim leading and trailing spaces */
+                loc_util_trim_space(config_value.param_name);
+                loc_util_trim_space(config_value.param_str_value);
+
+                /* Parse numerical value */
+                if ((strlen(config_value.param_str_value) >=3) &&
+                    (config_value.param_str_value[0] == '0') &&
+                    (tolower(config_value.param_str_value[1]) == 'x'))
+                {
+                    /* hex */
+                    config_value.param_int_value = (int) strtol(&config_value.param_str_value[2],
+                                                                (char**) NULL, 16);
+                }
+                else {
+                    config_value.param_double_value = (double) atof(config_value.param_str_value); /* float */
+                    config_value.param_int_value = atoi(config_value.param_str_value); /* dec */
+                }
+
+                for(uint32_t i = 0; NULL != config_table && i < table_length; i++)
+                {
+                    if(!loc_set_config_entry(&config_table[i], &config_value)) {
+                        ret = 1;
+                    }
+                }
+            }
+        }
+    }
+
+    return ret;
+}
+
+/*===========================================================================
 FUNCTION loc_read_conf_r (repetitive)
 
 DESCRIPTION
@@ -185,10 +261,6 @@ SIDE EFFECTS
 ===========================================================================*/
 int loc_read_conf_r(FILE *conf_fp, loc_param_s_type* config_table, uint32_t table_length)
 {
-    char input_buf[LOC_MAX_PARAM_LINE];  /* declare a char array */
-    char *lasts;
-    loc_param_v_type config_value;
-    uint32_t i;
     int ret=0;
 
     unsigned int num_params=table_length;
@@ -199,13 +271,16 @@ int loc_read_conf_r(FILE *conf_fp, loc_param_s_type* config_table, uint32_t tabl
     }
 
     /* Clear all validity bits */
-    for(i = 0; NULL != config_table && i < table_length; i++)
+    for(uint32_t i = 0; NULL != config_table && i < table_length; i++)
     {
         if(NULL != config_table[i].param_set)
         {
             *(config_table[i].param_set) = 0;
         }
     }
+
+    char input_buf[LOC_MAX_PARAM_LINE];  /* declare a char array */
+
     LOC_LOGD("%s:%d]: num_params: %d\n", __func__, __LINE__, num_params);
     while(num_params)
     {
@@ -214,43 +289,70 @@ int loc_read_conf_r(FILE *conf_fp, loc_param_s_type* config_table, uint32_t tabl
             break;
         }
 
-        memset(&config_value, 0, sizeof(config_value));
+        num_params -= loc_fill_conf_item(input_buf, config_table, table_length);
+    }
 
-        /* Separate variable and value */
-        config_value.param_name = strtok_r(input_buf, "=", &lasts);
-        /* skip lines that do not contain "=" */
-        if (config_value.param_name == NULL) continue;
-        config_value.param_str_value = strtok_r(NULL, "=", &lasts);
-        /* skip lines that do not contain two operands */
-        if (config_value.param_str_value == NULL) continue;
-
-        /* Trim leading and trailing spaces */
-        loc_util_trim_space(config_value.param_name);
-        loc_util_trim_space(config_value.param_str_value);
-
-        /* Parse numerical value */
-        if ((strlen(config_value.param_str_value) >=3) &&
-            (config_value.param_str_value[0] == '0') &&
-            (tolower(config_value.param_str_value[1]) == 'x'))
-        {
-            /* hex */
-            config_value.param_int_value = (int) strtol(&config_value.param_str_value[2],
-                                                        (char**) NULL, 16);
-        }
-        else {
-            config_value.param_double_value = (double) atof(config_value.param_str_value); /* float */
-            config_value.param_int_value = atoi(config_value.param_str_value); /* dec */
-        }
+err:
+    return ret;
+}
+
+/*===========================================================================
+FUNCTION loc_udpate_conf
+
+DESCRIPTION
+   Parses the passed in buffer for configuration items, and update the table
+   that is also passed in.
+
+Reads the specified configuration file and sets defined values based on
+   the passed in configuration table. This table maps strings to values to
+   set along with the type of each of these values.
 
-        for(i = 0; NULL != config_table && i < table_length; i++)
+PARAMETERS:
+   conf_data: configuration items in bufferas a string
+   length: strlen(conf_data)
+   config_table: table definition of strings to places to store information
+   table_length: length of the configuration table
+
+DEPENDENCIES
+   N/A
+
+RETURN VALUE
+   number of the records in the table that is updated at time of return.
+
+SIDE EFFECTS
+   N/A
+===========================================================================*/
+int loc_update_conf(const char* conf_data, int32_t length,
+                    loc_param_s_type* config_table, uint32_t table_length)
+{
+    int ret = -1;
+
+    if (conf_data && length && config_table && table_length) {
+        // make a copy, so we do not tokenize the original data
+        char* conf_copy = (char*)malloc(length+1);
+
+        if (conf_copy != NULL)
         {
-            if(!loc_set_config_entry(&config_table[i], &config_value)) {
-                num_params--;
+            memcpy(conf_copy, conf_data, length);
+            // we hard NULL the end of string to be safe
+            conf_copy[length] = 0;
+
+            // start with one record off
+            uint32_t num_params = table_length - 1;
+            char* saveptr = NULL;
+            char* input_buf = strtok_r(conf_copy, "\n", &saveptr);
+            ret = 0;
+
+            LOC_LOGD("%s:%d]: num_params: %d\n", __func__, __LINE__, num_params);
+            while(num_params && input_buf) {
+                ret++;
+                num_params -= loc_fill_conf_item(input_buf, config_table, table_length);
+                input_buf = strtok_r(NULL, "\n", &saveptr);
             }
+            free(conf_copy);
         }
     }
 
-err:
     return ret;
 }
 
@@ -279,20 +381,20 @@ SIDE EFFECTS
 void loc_read_conf(const char* conf_file_name, loc_param_s_type* config_table,
                    uint32_t table_length)
 {
-    FILE *gps_conf_fp = NULL;
+    FILE *conf_fp = NULL;
     char *lasts;
     loc_param_v_type config_value;
     uint32_t i;
 
-    if((gps_conf_fp = fopen(conf_file_name, "r")) != NULL)
+    if((conf_fp = fopen(conf_file_name, "r")) != NULL)
     {
         LOC_LOGD("%s: using %s", __FUNCTION__, conf_file_name);
         if(table_length && config_table) {
-            loc_read_conf_r(gps_conf_fp, config_table, table_length);
-            rewind(gps_conf_fp);
+            loc_read_conf_r(conf_fp, config_table, table_length);
+            rewind(conf_fp);
         }
-        loc_read_conf_r(gps_conf_fp, loc_parameter_table, loc_param_num);
-        fclose(gps_conf_fp);
+        loc_read_conf_r(conf_fp, loc_param_table, loc_param_num);
+        fclose(conf_fp);
     }
     /* Initialize logging mechanism with parsed data */
     loc_logger_init(DEBUG_LEVEL, TIMESTAMP);
diff --git a/gps/utils/loc_cfg.h b/gps/utils/loc_cfg.h
index f575f71..ea4865b 100644
--- a/gps/utils/loc_cfg.h
+++ b/gps/utils/loc_cfg.h
@@ -37,11 +37,15 @@
 #define LOC_MAX_PARAM_STRING               80
 #define LOC_MAX_PARAM_LINE    (LOC_MAX_PARAM_NAME + LOC_MAX_PARAM_STRING)
 
+#define UTIL_UPDATE_CONF(conf_data, len, config_table) \
+    loc_update_conf((conf_data), (len), (config_table), \
+                    sizeof(config_table) / sizeof(config_table[0]))
+
 #define UTIL_READ_CONF_DEFAULT(filename) \
     loc_read_conf((filename), NULL, 0);
 
 #define UTIL_READ_CONF(filename, config_table) \
-            loc_read_conf((filename), (config_table), sizeof(config_table) / sizeof(config_table[0]))
+    loc_read_conf((filename), (config_table), sizeof(config_table) / sizeof(config_table[0]))
 
 /*=============================================================================
  *
@@ -73,10 +77,13 @@ extern "C" {
  *                       MODULE EXPORTED FUNCTIONS
  *
  *============================================================================*/
-extern void loc_read_conf(const char* conf_file_name,
-                          loc_param_s_type* config_table,
-                          uint32_t table_length);
-extern int loc_read_conf_r(FILE *conf_fp, loc_param_s_type* config_table, uint32_t table_length);
+void loc_read_conf(const char* conf_file_name,
+                   loc_param_s_type* config_table,
+                   uint32_t table_length);
+int loc_read_conf_r(FILE *conf_fp, loc_param_s_type* config_table,
+                    uint32_t table_length);
+int loc_update_conf(const char* conf_data, int32_t length,
+                    loc_param_s_type* config_table, uint32_t table_length);
 #ifdef __cplusplus
 }
 #endif
diff --git a/gps/utils/loc_log.cpp b/gps/utils/loc_log.cpp
index 597b5b6..6b4ce10 100644
--- a/gps/utils/loc_log.cpp
+++ b/gps/utils/loc_log.cpp
@@ -51,6 +51,7 @@ const char FROM_MODEM[] = "<---";
 const char TO_AFW[]     = "<===";
 const char EXIT_TAG[]   = "Exiting";
 const char ENTRY_TAG[]  = "Entering";
+const char EXIT_ERROR_TAG[]  = "Exiting with error";
 
 /* Logging Mechanism */
 loc_logger_s_type loc_logger;
@@ -200,6 +201,12 @@ SIDE EFFECTS
 void loc_logger_init(unsigned long debug, unsigned long timestamp)
 {
    loc_logger.DEBUG_LEVEL = debug;
+#ifdef TARGET_BUILD_VARIANT_USER
+   // force user builds to 2 or less
+   if (loc_logger.DEBUG_LEVEL > 2) {
+       loc_logger.DEBUG_LEVEL = 2;
+   }
+#endif
    loc_logger.TIMESTAMP   = timestamp;
 }
 
diff --git a/gps/utils/loc_target.cpp b/gps/utils/loc_target.cpp
index 36a1e4f..f5d249c 100644
--- a/gps/utils/loc_target.cpp
+++ b/gps/utils/loc_target.cpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2012-2014, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2012-2015, 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
@@ -57,7 +57,10 @@
 #define LENGTH(s) (sizeof(s) - 1)
 #define GPS_CHECK_NO_ERROR 0
 #define GPS_CHECK_NO_GPS_HW 1
-#define QCA1530_DETECT_TIMEOUT 30
+/* When system server is started, it uses 20 seconds as ActivityManager
+ * timeout. After that it sends SIGSTOP signal to process.
+ */
+#define QCA1530_DETECT_TIMEOUT 15
 #define QCA1530_DETECT_PRESENT "yes"
 #define QCA1530_DETECT_PROGRESS "detect"
 
@@ -99,7 +102,7 @@ static int read_a_line(const char * file_path, char * line, int line_size)
  */
 static bool is_qca1530(void)
 {
-    static const char qca1530_property_name[] = "persist.qca1530";
+    static const char qca1530_property_name[] = "sys.qca1530";
     bool res = false;
     int ret, i;
     char buf[PROPERTY_VALUE_MAX];
diff --git a/gps/utils/log_util.h b/gps/utils/log_util.h
index 8ff6b5a..944d3d9 100644
--- a/gps/utils/log_util.h
+++ b/gps/utils/log_util.h
@@ -81,6 +81,8 @@ extern const char FROM_MODEM[];
 extern const char TO_AFW[];
 extern const char EXIT_TAG[];
 extern const char ENTRY_TAG[];
+extern const char EXIT_ERROR_TAG[];
+
 /*=============================================================================
  *
  *                        MODULE EXPORTED FUNCTIONS
@@ -106,37 +108,19 @@ extern char* get_timestamp(char* str, unsigned long buf_size);
 
 #define IF_LOC_LOGV if((loc_logger.DEBUG_LEVEL >= 5) && (loc_logger.DEBUG_LEVEL <= 5))
 
-#define LOC_LOGE(...) \
-IF_LOC_LOGE { ALOGE("E/" __VA_ARGS__); } \
-else if (loc_logger.DEBUG_LEVEL == 0xff) { ALOGE("E/" __VA_ARGS__); }
-
-#define LOC_LOGW(...) \
-IF_LOC_LOGW { ALOGE("W/" __VA_ARGS__); }  \
-else if (loc_logger.DEBUG_LEVEL == 0xff) { ALOGW("W/" __VA_ARGS__); }
-
-#define LOC_LOGI(...) \
-IF_LOC_LOGI { ALOGE("I/" __VA_ARGS__); }   \
-else if (loc_logger.DEBUG_LEVEL == 0xff) { ALOGI("I/" __VA_ARGS__); }
-
-#define LOC_LOGD(...) \
-IF_LOC_LOGD { ALOGE("D/" __VA_ARGS__); }   \
-else if (loc_logger.DEBUG_LEVEL == 0xff) { ALOGD("D/" __VA_ARGS__); }
-
-#define LOC_LOGV(...) \
-IF_LOC_LOGV { ALOGE("V/" __VA_ARGS__); }   \
-else if (loc_logger.DEBUG_LEVEL == 0xff) { ALOGV("V/" __VA_ARGS__); }
+#define LOC_LOGE(...) IF_LOC_LOGE { ALOGE(__VA_ARGS__); }
+#define LOC_LOGW(...) IF_LOC_LOGW { ALOGW(__VA_ARGS__); }
+#define LOC_LOGI(...) IF_LOC_LOGI { ALOGI(__VA_ARGS__); }
+#define LOC_LOGD(...) IF_LOC_LOGD { ALOGD(__VA_ARGS__); }
+#define LOC_LOGV(...) IF_LOC_LOGV { ALOGV(__VA_ARGS__); }
 
 #else /* DEBUG_DMN_LOC_API */
 
-#define LOC_LOGE(...) ALOGE("E/" __VA_ARGS__)
-
-#define LOC_LOGW(...) ALOGW("W/" __VA_ARGS__)
-
-#define LOC_LOGI(...) ALOGI("I/" __VA_ARGS__)
-
-#define LOC_LOGD(...) ALOGD("D/" __VA_ARGS__)
-
-#define LOC_LOGV(...) ALOGV("V/" __VA_ARGS__)
+#define LOC_LOGE(...) ALOGE(__VA_ARGS__)
+#define LOC_LOGW(...) ALOGW(__VA_ARGS__)
+#define LOC_LOGI(...) ALOGI(__VA_ARGS__)
+#define LOC_LOGD(...) ALOGD(__VA_ARGS__)
+#define LOC_LOGV(...) ALOGV(__VA_ARGS__)
 
 #endif /* DEBUG_DMN_LOC_API */
 
@@ -157,20 +141,26 @@ else if (loc_logger.DEBUG_LEVEL == 0xff) { ALOGV("V/" __VA_ARGS__); }
         }                                                                     \
     } while(0)
 
-
 #define LOG_I(ID, WHAT, SPEC, VAL) LOG_(LOC_LOGI, ID, WHAT, SPEC, VAL)
 #define LOG_V(ID, WHAT, SPEC, VAL) LOG_(LOC_LOGV, ID, WHAT, SPEC, VAL)
+#define LOG_E(ID, WHAT, SPEC, VAL) LOG_(LOC_LOGE, ID, WHAT, SPEC, VAL)
 
-#define ENTRY_LOG() LOG_V(ENTRY_TAG, __func__, %s, "")
-#define EXIT_LOG(SPEC, VAL) LOG_V(EXIT_TAG, __func__, SPEC, VAL)
+#define ENTRY_LOG() LOG_V(ENTRY_TAG, __FUNCTION__, %s, "")
+#define EXIT_LOG(SPEC, VAL) LOG_V(EXIT_TAG, __FUNCTION__, SPEC, VAL)
+#define EXIT_LOG_WITH_ERROR(SPEC, VAL)                       \
+    if (VAL != 0) {                                          \
+        LOG_E(EXIT_ERROR_TAG, __FUNCTION__, SPEC, VAL);      \
+    } else {                                                 \
+        LOG_V(EXIT_TAG, __FUNCTION__, SPEC, VAL);            \
+    }
 
 
 // Used for logging callflow from Android Framework
-#define ENTRY_LOG_CALLFLOW() LOG_I(FROM_AFW, __func__, %s, "")
+#define ENTRY_LOG_CALLFLOW() LOG_I(FROM_AFW, __FUNCTION__, %s, "")
 // Used for logging callflow to Modem
-#define EXIT_LOG_CALLFLOW(SPEC, VAL) LOG_I(TO_MODEM, __func__, SPEC, VAL)
-// Used for logging callflow from Modem(TO_MODEM, __func__, %s, "")
-#define MODEM_LOG_CALLFLOW(SPEC, VAL) LOG_I(FROM_MODEM, __func__, SPEC, VAL)
+#define EXIT_LOG_CALLFLOW(SPEC, VAL) LOG_I(TO_MODEM, __FUNCTION__, SPEC, VAL)
+// Used for logging callflow from Modem(TO_MODEM, __FUNCTION__, %s, "")
+#define MODEM_LOG_CALLFLOW(SPEC, VAL) LOG_I(FROM_MODEM, __FUNCTION__, SPEC, VAL)
 // Used for logging callflow to Android Framework
 #define CALLBACK_LOG_CALLFLOW(CB, SPEC, VAL) LOG_I(TO_AFW, CB, SPEC, VAL)
 
diff --git a/serrano-common.mk b/serrano-common.mk
index d6ee7d6..9dcac6d 100644
--- a/serrano-common.mk
+++ b/serrano-common.mk
@@ -85,11 +85,6 @@ PRODUCT_COPY_FILES += \
 PRODUCT_COPY_FILES += \
     $(LOCAL_PATH)/configs/sec_config:system/etc/sec_config
 
-# GPS config
-PRODUCT_COPY_FILES += \
-    $(LOCAL_PATH)/configs/gps.conf:system/etc/gps.conf \
-    $(LOCAL_PATH)/configs/sap.conf:system/etc/sap.conf
-
 # Prima opensource driver files
 PRODUCT_COPY_FILES += \
     $(LOCAL_PATH)/prima/WCNSS_cfg.dat:system/etc/firmware/wlan/prima/WCNSS_cfg.dat \
@@ -98,7 +93,9 @@ PRODUCT_COPY_FILES += \
 
 # GPS HAL
 PRODUCT_PACKAGES += \
-    gps.msm8960
+    gps.msm8960 \
+    gps.conf \
+    sap.conf
 
 # FM radio
 PRODUCT_PACKAGES += \