gps: upgrade GPS HAL to latest

Change-Id: Idd560ad408ad4e9265d212ab42990b8683548599

14 files changed, 471 insertions, 243 deletions

diff --git a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/Android.mk b/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/Android.mk
index 58ad37e..bb3d924 100644
--- a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/Android.mk
+++ b/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/Android.mk
@@ -31,6 +31,7 @@ LOCAL_SHARED_LIBRARIES:= \
 LOCAL_STATIC_LIBRARIES := \
     libloc_api_rpcgen
 
+LOCAL_PRELINK_MODULE:= false
 
 LOCAL_C_INCLUDES:= \
     $(LOCAL_PATH) \
diff --git a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/Android.mk b/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/Android.mk
index 1f542e4..c0987e6 100644
--- a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/Android.mk
+++ b/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/Android.mk
@@ -32,4 +32,5 @@ LOCAL_COPY_HEADERS += inc/loc_api_rpcgen_cb_rpc.h
 LOCAL_COPY_HEADERS += inc/loc_apicb_appinit.h
 
 LOCAL_LDLIBS += -lpthread
+LOCAL_PRELINK_MODULE := false
 include $(BUILD_STATIC_LIBRARY)
diff --git a/loc_api/libloc_api_50001/Android.mk b/loc_api/libloc_api_50001/Android.mk
index 4ef3c50..27c53cf 100644
--- a/loc_api/libloc_api_50001/Android.mk
+++ b/loc_api/libloc_api_50001/Android.mk
@@ -54,6 +54,7 @@ LOCAL_COPY_HEADERS:= \
    loc_eng_msg.h \
    loc_eng_log.h
 
+LOCAL_PRELINK_MODULE := false
 
 include $(BUILD_SHARED_LIBRARY)
 
@@ -75,13 +76,16 @@ LOCAL_SHARED_LIBRARIES := \
     libgps.utils \
     libdl
 
+ifneq ($(filter $(TARGET_DEVICE), apq8084 msm8960), false)
+endif
+
 LOCAL_SRC_FILES += \
     loc.cpp \
     gps.c
 
 LOCAL_CFLAGS += \
     -fno-short-enums \
-    -D_ANDROID_
+    -D_ANDROID_ \
 
 ifeq ($(TARGET_USES_QCOM_BSP), true)
 LOCAL_CFLAGS += -DTARGET_USES_QCOM_BSP
@@ -92,10 +96,20 @@ LOCAL_C_INCLUDES:= \
     $(TARGET_OUT_HEADERS)/gps.utils \
     $(TARGET_OUT_HEADERS)/libloc_core
 
-ifneq ($(filter msm8084,$(TARGET_BOARD_PLATFORM)),)
-  LOCAL_CFLAGS += -DPLATFORM_MSM8084
+ifeq ($(filter $(TARGET_DEVICE), apq8064 msm8960),)
+$(call print-vars, $(TARGET_DEVICE))
+LOCAL_SHARED_LIBRARIES += \
+    libmdmdetect \
+    libperipheral_client
+
+LOCAL_C_INCLUDES += \
+    $(TARGET_OUT_HEADERS)/libmdmdetect/inc \
+    $(TARGET_OUT_HEADERS)/libperipheralclient/inc
+LOCAL_CFLAGS += \
+    -DMODEM_POWER_VOTE
 endif
 
+LOCAL_PRELINK_MODULE := false
 LOCAL_MODULE_RELATIVE_PATH := hw
 
 include $(BUILD_SHARED_LIBRARY)
diff --git a/loc_api/libloc_api_50001/LocEngAdapter.cpp b/loc_api/libloc_api_50001/LocEngAdapter.cpp
index 16a150d..2f025af 100644
--- a/loc_api/libloc_api_50001/LocEngAdapter.cpp
+++ b/loc_api/libloc_api_50001/LocEngAdapter.cpp
@@ -70,7 +70,9 @@ LocEngAdapter::LocEngAdapter(LOC_API_ADAPTER_EVENT_MASK_T mask,
     mOwner(owner), mInternalAdapter(new LocInternalAdapter(this)),
     mUlp(new UlpProxyBase()), mNavigating(false),
     mSupportsAgpsRequests(false),
-    mSupportsPositionInjection(false), mPowerVote(0)
+    mSupportsPositionInjection(false),
+    mSupportsTimeInjection(false),
+    mPowerVote(0)
 {
     memset(&mFixCriteria, 0, sizeof(mFixCriteria));
     mFixCriteria.mode = LOC_POSITION_MODE_INVALID;
@@ -346,6 +348,50 @@ 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;
+}
+
 void LocEngAdapter::reportGpsMeasurementData(GpsData &gpsMeasurementData)
 {
     sendMsg(new LocEngReportGpsMeasurement(mOwner,
diff --git a/loc_api/libloc_api_50001/LocEngAdapter.h b/loc_api/libloc_api_50001/LocEngAdapter.h
index fe5df3c..e5d1018 100644
--- a/loc_api/libloc_api_50001/LocEngAdapter.h
+++ b/loc_api/libloc_api_50001/LocEngAdapter.h
@@ -85,6 +85,7 @@ class LocEngAdapter : public LocAdapterBase {
 public:
     bool mSupportsAgpsRequests;
     bool mSupportsPositionInjection;
+    bool mSupportsTimeInjection;
 
     LocEngAdapter(LOC_API_ADAPTER_EVENT_MASK_T mask,
                   void* owner, ContextBase* context,
@@ -137,11 +138,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);
@@ -256,14 +252,16 @@ public:
     {
         return mLocApi->getBestAvailableZppFix(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,
diff --git a/loc_api/libloc_api_50001/gps.c b/loc_api/libloc_api_50001/gps.c
index 46596aa..29f20f4 100644
--- a/loc_api/libloc_api_50001/gps.c
+++ b/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
diff --git a/loc_api/libloc_api_50001/loc.cpp b/loc_api/libloc_api_50001/loc.cpp
index eb11f0b..9fc5623 100644
--- a/loc_api/libloc_api_50001/loc.cpp
+++ b/loc_api/libloc_api_50001/loc.cpp
@@ -45,16 +45,27 @@
 #include <LocDualContext.h>
 #include <cutils/properties.h>
 
+#ifdef MODEM_POWER_VOTE
+#include <pm-service.h>
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+#include <mdm_detect.h>
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+#endif /*MODEM_POWER_VOTE*/
+
 using namespace loc_core;
 
+#define LOC_PM_CLIENT_NAME "GPS"
+
 //Globals defns
 static gps_location_callback gps_loc_cb = NULL;
 static gps_sv_status_callback gps_sv_cb = NULL;
-static agps_status_callback agps_status_cb = NULL;
 
 static void local_loc_cb(UlpLocation* location, void* locExt);
 static void local_sv_cb(GpsSvStatus* sv_status, void* svExt);
-static void loc_agps_status_cb(AGpsStatus* status);
 
 static const GpsGeofencingInterface* get_geofence_interface(void);
 
@@ -125,6 +136,22 @@ static const GpsNiInterface sLocEngNiInterface =
    loc_ni_respond,
 };
 
+#ifdef MODEM_POWER_VOTE
+typedef struct {
+    //MAX_NAME_LEN defined in mdm_detect.h
+    char modem_name[MAX_NAME_LEN];
+    //MAX_PATH_LEN defined in mdm_detect.h
+    char powerup_node[MAX_PATH_LEN];
+    //this handle is used by peripheral mgr
+    void *handle;
+    int mdm_fd;
+    MdmType mdm_type;
+    bool peripheral_mgr_supported;
+    bool peripheral_mgr_registered;
+}s_loc_mdm_info;
+static s_loc_mdm_info loc_mdm_info;
+static void loc_pm_event_notifier(void *client_data, enum pm_event event);
+#endif /*MODEM_POWER_VOTE*/
 // For shutting down MDM in fusion devices
 static int mdm_fd = -1;
 static int loc_gps_measurement_init(GpsMeasurementCallbacks* callbacks);
@@ -233,6 +260,7 @@ extern "C" const GpsInterface* get_gps_interface()
     switch (gnssType)
     {
     case GNSS_GSS:
+    case GNSS_AUTO:
         //APQ8064
         gps_conf.CAPABILITIES &= ~(GPS_CAPABILITY_MSA | GPS_CAPABILITY_MSB);
         gss_fd = open("/dev/gss", O_RDONLY);
@@ -277,7 +305,11 @@ SIDE EFFECTS
 static int loc_init(GpsCallbacks* callbacks)
 {
     int retVal = -1;
-    int i = 0;
+#ifdef MODEM_POWER_VOTE
+    enum pm_event mdm_state;
+    static int mdm_index = -1;
+    int peripheral_mgr_ret = PM_RET_FAILED;
+#endif /*MODEM_POWER_VOTE*/
     ENTRY_LOG();
     LOC_API_ADAPTER_EVENT_MASK_T event;
 
@@ -315,8 +347,9 @@ static int loc_init(GpsCallbacks* callbacks)
     retVal = loc_eng_init(loc_afw_data, &clientCallbacks, event, NULL);
     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();
     loc_afw_data.adapter->setGpsLockMsg(0);
-    loc_afw_data.adapter->requestUlp(gps_conf.CAPABILITIES);
+    loc_afw_data.adapter->requestUlp(getCarrierCapabilities());
 
     if(retVal) {
         LOC_LOGE("loc_eng_init() fail!");
@@ -328,43 +361,90 @@ static int loc_init(GpsCallbacks* callbacks)
 
     LOC_LOGD("loc_eng_init() success!");
 
-#ifdef PLATFORM_MSM8084
-    if (mdm_fd < 0) {
-        int (*open_first_external_modem)(void);
-        const char *name = "libdetectmodem.so";
-        const char *func = "open_first_external_modem";
-        const char *error;
-
-        void *lib = ::dlopen(name, RTLD_NOW);
-        error = ::dlerror();
-        if (!lib) {
-            LOC_LOGE("%s: could not find %s: %s", __func__, name, error);
+#ifdef MODEM_POWER_VOTE
+    //if index is 0 or more, then we've looked for mdm already
+    LOC_LOGD("%s:%d]: mdm_index: %d", __func__, __LINE__,
+             mdm_index);
+    if (mdm_index < 0) {
+        struct dev_info modem_info;
+        memset(&modem_info, 0, sizeof(struct dev_info));
+        if(get_system_info(&modem_info) != RET_SUCCESS) {
+            LOC_LOGE("%s:%d]: Error: get_system_info returned error\n",
+                     __func__, __LINE__);
             goto err;
         }
 
-        open_first_external_modem = NULL;
-        *(void **)(&open_first_external_modem) = ::dlsym(lib, func);
-        error = ::dlerror();
+        for(mdm_index = 0;
+            mdm_index < modem_info.num_modems;
+            mdm_index++) {
+            if(modem_info.mdm_list[mdm_index].mdm_name) {
+                //Copy modem name to register with peripheral manager
+                strlcpy(loc_mdm_info.modem_name,
+                        modem_info.mdm_list[mdm_index].mdm_name,
+                        sizeof(loc_mdm_info.modem_name));
+                //copy powerup node name if we need to use mdmdetect method
+                strlcpy(loc_mdm_info.powerup_node,
+                        modem_info.mdm_list[mdm_index].powerup_node,
+                        sizeof(loc_mdm_info.powerup_node));
+                loc_mdm_info.mdm_type = modem_info.mdm_list[mdm_index].type;
+                LOC_LOGD("%s:%d]: Found modem: %s, powerup node:%s at index: %d",
+                         __func__, __LINE__, loc_mdm_info.modem_name, loc_mdm_info.powerup_node,
+                         mdm_index);
+                break;
+            }
+        }
+    }
 
-        if (!open_first_external_modem) {
-            LOC_LOGE("%s: could not find symbol %s in %s: %s",
-                     __func__, func, name, error);
+    if(loc_mdm_info.peripheral_mgr_registered != true) {
+        peripheral_mgr_ret = pm_client_register(loc_pm_event_notifier,
+                                                &loc_mdm_info,
+                                                loc_mdm_info.modem_name,
+                                                LOC_PM_CLIENT_NAME,
+                                                &mdm_state,
+                                                &loc_mdm_info.handle);
+        if(peripheral_mgr_ret == PM_RET_SUCCESS) {
+            loc_mdm_info.peripheral_mgr_supported = true;
+            loc_mdm_info.peripheral_mgr_registered = true;
+            LOC_LOGD("%s:%d]: registered with peripheral mgr for %s",
+                     __func__, __LINE__, loc_mdm_info.modem_name);
+        }
+        else if(peripheral_mgr_ret == PM_RET_UNSUPPORTED) {
+            loc_mdm_info.peripheral_mgr_registered = true;
+            loc_mdm_info.peripheral_mgr_supported = false;
+            LOC_LOGD("%s:%d]: peripheral mgr unsupported for: %s",
+                     __func__, __LINE__, loc_mdm_info.modem_name);
         }
         else {
-            errno = 0;
-            mdm_fd = open_first_external_modem();
-            if (mdm_fd < 0) {
-                LOC_LOGE("%s: %s failed: %s\n", __func__, func, strerror(errno));
-            }
-            else {
-                LOC_LOGD("%s: external power up modem opened successfully\n", __func__);
-            }
+            //Not setting any flags here so that we can try again the next time around
+            LOC_LOGE("%s:%d]: Error: pm_client_register returned: %d",
+                     __func__, __LINE__, peripheral_mgr_ret);
+        }
+    }
+
+    if(loc_mdm_info.peripheral_mgr_supported == false &&
+       loc_mdm_info.peripheral_mgr_registered == true) {
+        //Peripheral mgr is not supported
+        //use legacy method to open the powerup node
+        LOC_LOGD("%s:%d]: powerup_node: %s", __func__, __LINE__,
+                 loc_mdm_info.powerup_node);
+        loc_mdm_info.mdm_fd = open(loc_mdm_info.powerup_node, O_RDONLY);
+
+        if (loc_mdm_info.mdm_fd < 0) {
+            LOC_LOGE("Error: %s open failed: %s\n",
+                     loc_mdm_info.powerup_node, strerror(errno));
+        } else {
+            LOC_LOGD("%s opens success!", loc_mdm_info.powerup_node);
         }
-        dlclose(lib);
-    } else {
-        LOC_LOGD("powerup_node has been opened before");
     }
-#endif //PLATFORM_MSM8084
+    else if(loc_mdm_info.peripheral_mgr_supported == true &&
+            loc_mdm_info.peripheral_mgr_registered == true) {
+        LOC_LOGD("%s:%d]: Voting for modem power up", __func__, __LINE__);
+        pm_client_connect(loc_mdm_info.handle);
+    }
+    else {
+        LOC_LOGD("%s:%d]: Not voted for modem power up due to errors", __func__, __LINE__);
+    }
+#endif /*MODEM_POWER_VOTE*/
 err:
     EXIT_LOG(%d, retVal);
     return retVal;
@@ -374,7 +454,7 @@ err:
 FUNCTION    loc_close_mdm_node
 
 DESCRIPTION
-   closes mdm_fd which is the modem powerup node obtained in loc_init
+   closes loc_mdm_info.mdm_fd which is the modem powerup node obtained in loc_init
 
 DEPENDENCIES
    None
@@ -389,15 +469,21 @@ SIDE EFFECTS
 static void loc_close_mdm_node()
 {
     ENTRY_LOG();
-    if (mdm_fd >= 0) {
+#ifdef MODEM_POWER_VOTE
+    if(loc_mdm_info.peripheral_mgr_supported == true) {
+        LOC_LOGD("%s:%d]: Voting for modem power down", __func__, __LINE__);
+        pm_client_disconnect(loc_mdm_info.handle);
+    }
+    else if (loc_mdm_info.mdm_fd >= 0) {
         LOC_LOGD("closing the powerup node");
-        close(mdm_fd);
-        mdm_fd = -1;
+        close(loc_mdm_info.mdm_fd);
+        loc_mdm_info.mdm_fd = -1;
         LOC_LOGD("finished closing the powerup node");
-    } else {
+    }
+    else {
         LOC_LOGD("powerup node has not been opened yet.");
     }
-
+#endif /*MODEM_POWER_VOTE*/
     EXIT_LOG(%s, VOID_RET);
 }
 
@@ -575,39 +661,11 @@ SIDE EFFECTS
 ===========================================================================*/
 static int loc_inject_location(double latitude, double longitude, float accuracy)
 {
-    static bool initialized = false;
-    static bool enable_cpi = true;
     ENTRY_LOG();
 
-    if (accuracy < 1000)
-    {
-      accuracy = 1000;
-    }
-
     int ret_val = 0;
     ret_val = loc_eng_inject_location(loc_afw_data, latitude, longitude, accuracy);
 
-    if(!initialized)
-    {
-        char value[PROPERTY_VALUE_MAX];
-        memset(value, 0, sizeof(value));
-        (void)property_get("persist.gps.qc_nlp_in_use", value, "0");
-        if(0 == strcmp(value, "1"))
-        {
-            enable_cpi = false;
-            LOC_LOGI("GPS HAL coarse position injection disabled");
-        }
-        else
-        {
-            LOC_LOGI("GPS HAL coarse position injection enabled");
-        }
-        initialized = true;
-    }
-
-    if(enable_cpi)
-    {
-      ret_val = loc_eng_inject_location(loc_afw_data, latitude, longitude, accuracy);
-    }
     EXIT_LOG(%d, ret_val);
     return ret_val;
 }
@@ -663,7 +721,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;
      }
@@ -762,10 +820,6 @@ SIDE EFFECTS
 static void loc_agps_init(AGpsCallbacks* callbacks)
 {
     ENTRY_LOG();
-    if (agps_status_cb == NULL) {
-        agps_status_cb = callbacks->status_cb;
-        callbacks->status_cb = loc_agps_status_cb;
-    }
     loc_eng_agps_init(loc_afw_data, (AGpsExtCallbacks*)callbacks);
     EXIT_LOG(%s, VOID_RET);
 }
@@ -980,8 +1034,12 @@ SIDE EFFECTS
 static int loc_xtra_inject_data(char* data, int length)
 {
     ENTRY_LOG();
-    int ret_val = loc_eng_xtra_inject_data(loc_afw_data, data, length);
-
+    int ret_val = -1;
+    if( (data != NULL) && ((unsigned int)length <= XTRA_DATA_MAX_SIZE))
+        ret_val = loc_eng_xtra_inject_data(loc_afw_data, data, length);
+    else
+        LOC_LOGE("%s, Could not inject XTRA data. Buffer address: %p, length: %d",
+                 __func__, data, length);
     EXIT_LOG(%d, ret_val);
     return ret_val;
 }
@@ -1125,7 +1183,7 @@ static int loc_agps_revoke_certificates(const Sha1CertificateFingerprint* finger
                                         size_t length)
 {
     ENTRY_LOG();
-    LOC_LOGE("agps_revoke_certificates not supported");
+    LOC_LOGE("%s:%d]: agps_revoke_certificates not supported");
     int ret_val = AGPS_CERTIFICATE_ERROR_GENERIC;
     EXIT_LOG(%d, ret_val);
     return ret_val;
@@ -1161,16 +1219,12 @@ static void local_sv_cb(GpsSvStatus* sv_status, void* svExt)
     EXIT_LOG(%s, VOID_RET);
 }
 
-static void loc_agps_status_cb(AGpsStatus* status)
+#ifdef MODEM_POWER_VOTE
+static void loc_pm_event_notifier(void *client_data, enum pm_event event)
 {
     ENTRY_LOG();
-
-    if (NULL != agps_status_cb) {
-        size_t realSize = sizeof(AGpsStatus);
-        LOC_LOGD("agps_status size=%d real-size=%d", status->size, realSize);
-        status->size = realSize;
-        agps_status_cb(status);
-    }
+    LOC_LOGD("%s:%d]: event: %d", __func__, __LINE__, (int)event);
+    pm_client_event_acknowledge(loc_mdm_info.handle, event);
     EXIT_LOG(%s, VOID_RET);
 }
-
+#endif /*MODEM_POWER_VOTE*/
diff --git a/loc_api/libloc_api_50001/loc.h b/loc_api/libloc_api_50001/loc.h
index 7e26827..6352866 100644
--- a/loc_api/libloc_api_50001/loc.h
+++ b/loc_api/libloc_api_50001/loc.h
@@ -1,4 +1,4 @@
-/* Copyright (c) 2011-2013, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2011,2014 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
@@ -39,6 +39,8 @@ extern "C" {
 #include <hardware/gps.h>
 #include <gps_extended.h>
 
+#define XTRA_DATA_MAX_SIZE 100000 /*bytes*/
+
 typedef void (*loc_location_cb_ext) (UlpLocation* location, void* locExt);
 typedef void (*loc_sv_status_cb_ext) (GpsSvStatus* sv_status, void* svExt);
 typedef void* (*loc_ext_parser)(void* data);
diff --git a/loc_api/libloc_api_50001/loc_eng.cpp b/loc_api/libloc_api_50001/loc_eng.cpp
index c527e36..448cc79 100644
--- a/loc_api/libloc_api_50001/loc_eng.cpp
+++ b/loc_api/libloc_api_50001/loc_eng.cpp
@@ -44,7 +44,7 @@
 #include <sys/time.h>
 #include <netdb.h>
 #include <time.h>
-
+#include <new>
 #include <LocEngAdapter.h>
 
 #include <cutils/sched_policy.h>
@@ -84,6 +84,8 @@
 #define SAP_CONF_FILE            "/etc/sap.conf"
 #endif
 
+#define XTRA1_GPSONEXTRA         "xtra1.gpsonextra.net"
+
 using namespace loc_core;
 
 boolean configAlreadyRead = false;
@@ -99,10 +101,16 @@ static loc_param_s_type gps_conf_table[] =
   {"LPP_PROFILE",                    &gps_conf.LPP_PROFILE,                    NULL, 'n'},
   {"A_GLONASS_POS_PROTOCOL_SELECT",  &gps_conf.A_GLONASS_POS_PROTOCOL_SELECT,  NULL, 'n'},
   {"AGPS_CERT_WRITABLE_MASK",        &gps_conf.AGPS_CERT_WRITABLE_MASK,        NULL, 'n'},
+  {"SUPL_MODE",                      &gps_conf.SUPL_MODE,                      NULL, 'n'},
   {"INTERMEDIATE_POS",               &gps_conf.INTERMEDIATE_POS,               NULL, 'n'},
   {"ACCURACY_THRES",                 &gps_conf.ACCURACY_THRES,                 NULL, 'n'},
   {"NMEA_PROVIDER",                  &gps_conf.NMEA_PROVIDER,                  NULL, 'n'},
   {"CAPABILITIES",                   &gps_conf.CAPABILITIES,                   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'},
+  {"USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL",  &gps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL,          NULL, 'n'},
 };
 
 static loc_param_s_type sap_conf_table[] =
@@ -123,19 +131,29 @@ static loc_param_s_type sap_conf_table[] =
   {"SENSOR_CONTROL_MODE",            &sap_conf.SENSOR_CONTROL_MODE,            NULL, 'n'},
   {"SENSOR_USAGE",                   &sap_conf.SENSOR_USAGE,                   NULL, 'n'},
   {"SENSOR_ALGORITHM_CONFIG_MASK",   &sap_conf.SENSOR_ALGORITHM_CONFIG_MASK,   NULL, 'n'},
-  {"SENSOR_PROVIDER",                &sap_conf.SENSOR_PROVIDER,                NULL, 'n'},
+  {"SENSOR_PROVIDER",                &sap_conf.SENSOR_PROVIDER,                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.GPS_LOCK = 0;
    gps_conf.SUPL_VER = 0x10000;
+   gps_conf.SUPL_MODE = 0x3;
    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;
@@ -148,26 +166,17 @@ 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;
 
@@ -506,6 +515,24 @@ struct LocEngSuplVer : public LocMsg {
     }
 };
 
+struct LocEngSuplMode : public LocMsg {
+    UlpProxyBase* mUlp;
+
+    inline LocEngSuplMode(UlpProxyBase* ulp) :
+        LocMsg(), mUlp(ulp)
+    {
+        locallog();
+    }
+    inline virtual void proc() const {
+        mUlp->setCapabilities(getCarrierCapabilities());
+    }
+    inline  void locallog() const {
+    }
+    inline virtual void log() const {
+        locallog();
+    }
+};
+
 //        case LOC_ENG_MSG_LPP_CONFIG:
 struct LocEngLppConfig : public LocMsg {
     LocEngAdapter* mAdapter;
@@ -811,16 +838,7 @@ void LocEngReportPosition::proc() const {
     }
 }
 void LocEngReportPosition::locallog() const {
-    LOC_LOGV("flags: %d\n  source: %d\n  latitude: %f\n  longitude: %f\n  "
-             "altitude: %f\n  speed: %f\n  bearing: %f\n  accuracy: %f\n  "
-             "timestamp: %lld\n  rawDataSize: %d\n  rawData: %p\n  Session"
-             " status: %d\n Technology mask: %u",
-             mLocation.gpsLocation.flags, mLocation.position_source,
-             mLocation.gpsLocation.latitude, mLocation.gpsLocation.longitude,
-             mLocation.gpsLocation.altitude, mLocation.gpsLocation.speed,
-             mLocation.gpsLocation.bearing, mLocation.gpsLocation.accuracy,
-             mLocation.gpsLocation.timestamp, mLocation.rawDataSize,
-             mLocation.rawData, mStatus, mTechMask);
+    LOC_LOGV("LocEngReportPosition");
 }
 void LocEngReportPosition::log() const {
     locallog();
@@ -861,19 +879,7 @@ void LocEngReportSv::proc() const {
     }
 }
 void LocEngReportSv::locallog() const {
-    LOC_LOGV("num sv: %d\n  ephemeris mask: %dxn  almanac mask: %x\n  "
-             "used in fix mask: %x\n      sv: prn         snr       "
-             "elevation      azimuth",
-             mSvStatus.num_svs, mSvStatus.ephemeris_mask,
-             mSvStatus.almanac_mask, mSvStatus.used_in_fix_mask);
-    for (int i = 0; i < mSvStatus.num_svs && i < GPS_MAX_SVS; i++) {
-        LOC_LOGV("   %d:   %d    %f    %f    %f\n  ",
-                 i,
-                 mSvStatus.sv_list[i].prn,
-                 mSvStatus.sv_list[i].snr,
-                 mSvStatus.sv_list[i].elevation,
-                 mSvStatus.sv_list[i].azimuth);
-    }
+    LOC_LOGV("%s:%d] LocEngReportSv",__func__, __LINE__);
 }
 inline void LocEngReportSv::log() const {
     locallog();
@@ -939,12 +945,34 @@ LocEngReportXtraServer::LocEngReportXtraServer(void* locEng,
     LocMsg(), mLocEng(locEng), mMaxLen(maxlength),
     mServers(new char[3*(mMaxLen+1)])
 {
+    char * cptr = mServers;
     memset(mServers, 0, 3*(mMaxLen+1));
-    strlcpy(mServers, url1, mMaxLen);
-    strlcpy(&(mServers[mMaxLen+1]), url2, mMaxLen);
-    strlcpy(&(mServers[(mMaxLen+1)<<1]), url3, mMaxLen);
+
+    // Override modem URLs with uncommented gps.conf urls
+    if( gps_conf.XTRA_SERVER_1[0] != '\0' ) {
+        url1 = &gps_conf.XTRA_SERVER_1[0];
+    }
+    if( gps_conf.XTRA_SERVER_2[0] != '\0' ) {
+        url2 = &gps_conf.XTRA_SERVER_2[0];
+    }
+    if( gps_conf.XTRA_SERVER_3[0] != '\0' ) {
+        url3 = &gps_conf.XTRA_SERVER_3[0];
+    }
+    // copy non xtra1.gpsonextra.net URLs into the forwarding buffer.
+    if( NULL == strcasestr(url1, XTRA1_GPSONEXTRA) ) {
+        strlcpy(cptr, url1, mMaxLen + 1);
+        cptr += mMaxLen + 1;
+    }
+    if( NULL == strcasestr(url2, XTRA1_GPSONEXTRA) ) {
+        strlcpy(cptr, url2, mMaxLen + 1);
+        cptr += mMaxLen + 1;
+    }
+    if( NULL == strcasestr(url3, XTRA1_GPSONEXTRA) ) {
+        strlcpy(cptr, url3, mMaxLen + 1);
+    }
     locallog();
 }
+
 void LocEngReportXtraServer::proc() const {
     loc_eng_xtra_data_s_type* locEngXtra =
         &(((loc_eng_data_s_type*)mLocEng)->xtra_module_data);
@@ -1088,7 +1116,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);
     }
 }
@@ -1656,7 +1694,7 @@ inline void LocEngReportGpsMeasurement::log() const {
 }
 
 /*********************************************************************
-* Initialization checking macros
+ * Initialization checking macros
  *********************************************************************/
 #define STATE_CHECK(ctx, x, ret) \
     if (!(ctx))                  \
@@ -1668,6 +1706,24 @@ inline void LocEngReportGpsMeasurement::log() const {
   }
 #define INIT_CHECK(ctx, ret) STATE_CHECK(ctx, "instance not initialized", ret)
 
+uint32_t getCarrierCapabilities() {
+    #define carrierMSA (uint32_t)0x2
+    #define carrierMSB (uint32_t)0x1
+    #define gpsConfMSA (uint32_t)0x4
+    #define gpsConfMSB (uint32_t)0x2
+    uint32_t capabilities = gps_conf.CAPABILITIES;
+    if ((gps_conf.SUPL_MODE & carrierMSA) != carrierMSA) {
+        capabilities &= ~gpsConfMSA;
+    }
+    if ((gps_conf.SUPL_MODE & carrierMSB) != carrierMSB) {
+        capabilities &= ~gpsConfMSB;
+    }
+
+    LOC_LOGV("getCarrierCapabilities: CAPABILITIES %x, SUPL_MODE %x, carrier capabilities %x",
+             gps_conf.CAPABILITIES, gps_conf.SUPL_MODE, capabilities);
+    return capabilities;
+}
+
 /*===========================================================================
 FUNCTION    loc_eng_init
 
@@ -1750,53 +1806,51 @@ 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 LocEngGnssConstellationConfig(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 LocEngGnssConstellationConfig(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)));
+
+    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;
 }
@@ -1896,7 +1950,9 @@ static int loc_eng_start_handler(loc_eng_data_s_type &loc_eng_data)
        ret_val = loc_eng_data.adapter->startFix();
 
        if (ret_val == LOC_API_ADAPTER_ERR_SUCCESS ||
-           ret_val == LOC_API_ADAPTER_ERR_ENGINE_DOWN)
+           ret_val == LOC_API_ADAPTER_ERR_ENGINE_DOWN ||
+           ret_val == LOC_API_ADAPTER_ERR_PHONE_OFFLINE ||
+           ret_val == LOC_API_ADAPTER_ERR_INTERNAL)
        {
            loc_eng_data.adapter->setInSession(TRUE);
            loc_inform_gps_status(loc_eng_data, GPS_STATUS_SESSION_BEGIN);
@@ -2157,7 +2213,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
@@ -2292,8 +2347,9 @@ void loc_eng_agps_init(loc_eng_data_s_type &loc_eng_data, AGpsExtCallbacks* call
                                                       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);
         }
@@ -2325,7 +2381,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:
@@ -2562,29 +2620,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);
@@ -2703,6 +2761,9 @@ void loc_eng_configuration_update (loc_eng_data_s_type &loc_eng_data,
                 adapter->sendMsg(new LocEngAGlonassProtocol(adapter,
                                                             gps_conf.A_GLONASS_POS_PROTOCOL_SELECT));
             }
+            if (gps_conf_tmp.SUPL_MODE != gps_conf.SUPL_MODE) {
+                adapter->sendMsg(new LocEngSuplMode(adapter->getUlpProxy()));
+            }
         }
 
         gps_conf_tmp.SUPL_VER = gps_conf.SUPL_VER;
diff --git a/loc_api/libloc_api_50001/loc_eng.h b/loc_api/libloc_api_50001/loc_eng.h
index fa3f19b..813da48 100644
--- a/loc_api/libloc_api_50001/loc_eng.h
+++ b/loc_api/libloc_api_50001/loc_eng.h
@@ -1,4 +1,4 @@
-/* Copyright (c) 2009-2013, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2009-2014, 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
@@ -67,6 +67,8 @@ typedef unsigned char boolean;
 #define FAILURE                 FALSE
 #define INVALID_ATL_CONNECTION_HANDLE -1
 
+#define MAX_XTRA_SERVER_URL_LENGTH 256
+
 enum loc_nmea_provider_e_type {
     NMEA_PROVIDER_AP = 0, // Application Processor Provider of NMEA
     NMEA_PROVIDER_MP // Modem Processor Provider of NMEA
@@ -147,8 +149,14 @@ typedef struct loc_gps_cfg_s
     uint32_t       INTERMEDIATE_POS;
     uint32_t       ACCURACY_THRES;
     uint32_t       SUPL_VER;
+    uint32_t       SUPL_MODE;
     uint32_t       CAPABILITIES;
     uint32_t       LPP_PROFILE;
+    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       NMEA_PROVIDER;
     uint32_t       GPS_LOCK;
     uint32_t       A_GLONASS_POS_PROTOCOL_SELECT;
@@ -191,6 +199,10 @@ typedef struct
 extern loc_gps_cfg_s_type gps_conf;
 extern loc_sap_cfg_s_type sap_conf;
 
+
+uint32_t getCarrierCapabilities();
+
+//loc_eng functions
 int  loc_eng_init(loc_eng_data_s_type &loc_eng_data,
                   LocCallbacks* callbacks,
                   LOC_API_ADAPTER_EVENT_MASK_T event,
@@ -210,35 +222,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,
@@ -248,12 +258,6 @@ extern void loc_eng_ni_request_handler(loc_eng_data_s_type &loc_eng_data,
                                    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);
-
-int loc_eng_agps_install_certificates(loc_eng_data_s_type &loc_eng_data,
-                                      const DerEncodedCertificate* certificates,
-                                      size_t length);
-
 void loc_eng_configuration_update (loc_eng_data_s_type &loc_eng_data,
                                    const char* config_data, int32_t length);
 int loc_eng_gps_measurement_init(loc_eng_data_s_type &loc_eng_data,
diff --git a/loc_api/libloc_api_50001/loc_eng_agps.cpp b/loc_api/libloc_api_50001/loc_eng_agps.cpp
index d90d5d3..5016b5c 100644
--- a/loc_api/libloc_api_50001/loc_eng_agps.cpp
+++ b/loc_api/libloc_api_50001/loc_eng_agps.cpp
@@ -763,7 +763,6 @@ int AgpsStateMachine::sendRsrcRequest(AGpsStatusValue action) const
         if (s == NULL) {
             nifRequest.ipv4_addr = INADDR_NONE;
             memset(&nifRequest.addr, 0,  sizeof(nifRequest.addr));
-            nifRequest.addr.ss_family = AF_INET6;
             nifRequest.ssid[0] = '\0';
             nifRequest.password[0] = '\0';
         } else {
diff --git a/loc_api/libloc_api_50001/loc_eng_agps.h b/loc_api/libloc_api_50001/loc_eng_agps.h
index d558644..2d689ce 100644
--- a/loc_api/libloc_api_50001/loc_eng_agps.h
+++ b/loc_api/libloc_api_50001/loc_eng_agps.h
@@ -345,8 +345,7 @@ struct ATLSubscriber : public Subscriber {
     { v4 = INADDR_NONE; v6[0] = 0; }
 
     inline virtual void setIPAddresses(struct sockaddr_storage& addr)
-    { memset(&addr, 0,  sizeof(addr));
-      addr.ss_family = AF_INET6; }
+    { addr.ss_family = AF_INET6; }
 
     inline virtual Subscriber* clone()
     {
diff --git a/loc_api/libloc_api_50001/loc_eng_nmea.cpp b/loc_api/libloc_api_50001/loc_eng_nmea.cpp
index 842eda1..4c6b9a3 100644
--- a/loc_api/libloc_api_50001/loc_eng_nmea.cpp
+++ b/loc_api/libloc_api_50001/loc_eng_nmea.cpp
@@ -119,14 +119,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/loc_api/libloc_api_50001/loc_eng_xtra.cpp b/loc_api/libloc_api_50001/loc_eng_xtra.cpp
index 4582286..7bb8083 100644
--- a/loc_api/libloc_api_50001/loc_eng_xtra.cpp
+++ b/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);
 }