Revert "Merge branch 'KK.04.04.02.010.399' into l-pdk"

This reverts commit 8c61f8c1f1572ab769912264af3f31feb041fe79.

Change-Id: I488b164f36f6f6be55aebb4759c116a3b4a1e448

53 files changed, 3689 insertions, 2464 deletions

diff --git a/core/Android.mk b/core/Android.mk
index 0d1b7c2..c8a5fd4 100644
--- a/core/Android.mk
+++ b/core/Android.mk
@@ -1,7 +1,3 @@
-ifeq (, $(filter aarch64 arm64, $(TARGET_ARCH)))
-ifneq ($(BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE),)
-ifneq ($(BUILD_TINY_ANDROID),true)
-
 LOCAL_PATH := $(call my-dir)
 
 include $(CLEAR_VARS)
@@ -39,17 +35,12 @@ LOCAL_COPY_HEADERS:= \
     LocAdapterBase.h \
     ContextBase.h \
     LocDualContext.h \
-    LBSProxyBase.h \
+    IzatProxyBase.h \
     UlpProxyBase.h \
     gps_extended_c.h \
     gps_extended.h \
-    loc_core_log.h \
-    LocAdapterProxyBase.h
+    loc_core_log.h
 
 LOCAL_PRELINK_MODULE := false
 
 include $(BUILD_SHARED_LIBRARY)
-
-endif # not BUILD_TINY_ANDROID
-endif # BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE
-endif # not aarch64
diff --git a/core/ContextBase.cpp b/core/ContextBase.cpp
index 579daf7..d632a9b 100644
--- a/core/ContextBase.cpp
+++ b/core/ContextBase.cpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2011-2014, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2011-2013, 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
@@ -40,22 +40,21 @@
 
 namespace loc_core {
 
-LBSProxyBase* ContextBase::getLBSProxy(const char* libName)
+
+IzatProxyBase* ContextBase::getIzatProxy(const char* libName)
 {
-    LBSProxyBase* proxy = NULL;
-    LOC_LOGD("%s:%d]: getLBSProxy libname: %s\n", __func__, __LINE__, libName);
+    IzatProxyBase* proxy = NULL;
     void* lib = dlopen(libName, RTLD_NOW);
 
     if ((void*)NULL != lib) {
-        getLBSProxy_t* getter = (getLBSProxy_t*)dlsym(lib, "getLBSProxy");
+        getIzatProxy_t* getter = (getIzatProxy_t*)dlsym(lib, "getIzatProxy");
         if (NULL != getter) {
             proxy = (*getter)();
         }
     }
     if (NULL == proxy) {
-        proxy = new LBSProxyBase();
+        proxy = new IzatProxyBase();
     }
-    LOC_LOGD("%s:%d]: Exiting\n", __func__, __LINE__);
     return proxy;
 }
 
@@ -95,7 +94,7 @@ LocApiBase* ContextBase::createLocApi(LOC_API_ADAPTER_EVENT_MASK_T exMask)
     // locApi could still be NULL at this time
     // we would then create a dummy one
     if (NULL == locApi) {
-        locApi = new LocApiBase(mMsgTask, exMask, this);
+        locApi = new LocApiBase(mMsgTask, exMask);
     }
 
     return locApi;
@@ -104,10 +103,9 @@ LocApiBase* ContextBase::createLocApi(LOC_API_ADAPTER_EVENT_MASK_T exMask)
 ContextBase::ContextBase(const MsgTask* msgTask,
                          LOC_API_ADAPTER_EVENT_MASK_T exMask,
                          const char* libName) :
-    mLBSProxy(getLBSProxy(libName)),
+    mIzatProxy(getIzatProxy(libName)),
     mMsgTask(msgTask),
-    mLocApi(createLocApi(exMask)),
-    mLocApiProxy(mLocApi->getLocApiProxy())
+    mLocApi(createLocApi(exMask))
 {
 }
 
diff --git a/core/ContextBase.h b/core/ContextBase.h
index 2adbedd..fc60db4 100644
--- a/core/ContextBase.h
+++ b/core/ContextBase.h
@@ -1,4 +1,4 @@
-/* Copyright (c) 2011-2014, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2011-2013, 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
@@ -33,36 +33,33 @@
 #include <ctype.h>
 #include <MsgTask.h>
 #include <LocApiBase.h>
-#include <LBSProxyBase.h>
+#include <IzatProxyBase.h>
 
 namespace loc_core {
 
 class LocAdapterBase;
 
 class ContextBase {
-    static LBSProxyBase* getLBSProxy(const char* libName);
+    static IzatProxyBase* getIzatProxy(const char* libName);
     LocApiBase* createLocApi(LOC_API_ADAPTER_EVENT_MASK_T excludedMask);
 protected:
-    const LBSProxyBase* mLBSProxy;
+    const IzatProxyBase* mIzatProxy;
     const MsgTask* mMsgTask;
     LocApiBase* mLocApi;
-    LocApiProxyBase *mLocApiProxy;
+
 public:
     ContextBase(const MsgTask* msgTask,
                 LOC_API_ADAPTER_EVENT_MASK_T exMask,
                 const char* libName);
-    inline virtual ~ContextBase() { delete mLocApi; delete mLBSProxy; }
+    inline virtual ~ContextBase() { delete mLocApi; delete mIzatProxy; }
 
     inline const MsgTask* getMsgTask() { return mMsgTask; }
     inline LocApiBase* getLocApi() { return mLocApi; }
-    inline LocApiProxyBase* getLocApiProxy() { return mLocApiProxy; }
-    inline bool hasAgpsExtendedCapabilities() { return mLBSProxy->hasAgpsExtendedCapabilities(); }
-    inline bool hasCPIExtendedCapabilities() { return mLBSProxy->hasCPIExtendedCapabilities(); }
+    inline bool hasAgpsExt() { return mIzatProxy->hasAgpsExt(); }
     inline void requestUlp(LocAdapterBase* adapter,
                            unsigned long capabilities) {
-        mLBSProxy->requestUlp(adapter, capabilities);
+        mIzatProxy->requestUlp(adapter, capabilities);
     }
-    inline void sendMsg(const LocMsg *msg) { getMsgTask()->sendMsg(msg); }
 };
 
 } // namespace loc_core
diff --git a/core/LocAdapterBase.cpp b/core/LocAdapterBase.cpp
index eea8edd..48d179f 100644
--- a/core/LocAdapterBase.cpp
+++ b/core/LocAdapterBase.cpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2011-2014, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2011-2013, 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
@@ -33,36 +33,44 @@
 #include <LocAdapterBase.h>
 #include <loc_target.h>
 #include <log_util.h>
-#include <LocAdapterProxyBase.h>
 
 namespace loc_core {
 
+struct LocOpenMsg : public LocMsg {
+    LocAdapterBase* mLocAdapter;
+    LocApiBase* mLocApi;
+    inline LocOpenMsg(LocAdapterBase* locAdapter,
+                      LocApiBase* locApi) :
+        LocMsg(), mLocAdapter(locAdapter), mLocApi(locApi)
+    {
+        locallog();
+    }
+    inline virtual void proc() const {
+        mLocApi->addAdapter(mLocAdapter);
+    }
+    inline void locallog() {
+        LOC_LOGV("LocOpen");
+    }
+    inline virtual void log() {
+        locallog();
+    }
+};
+
 // This is the top level class, so the constructor will
 // always gets called. Here we prepare for the default.
 // But if getLocApi(targetEnumType target) is overriden,
 // the right locApi should get created.
 LocAdapterBase::LocAdapterBase(const LOC_API_ADAPTER_EVENT_MASK_T mask,
-                               ContextBase* context, LocAdapterProxyBase *adapterProxyBase) :
+                               ContextBase* context) :
     mEvtMask(mask), mContext(context),
-    mLocApi(context->getLocApi()), mLocAdapterProxyBase(adapterProxyBase),
-    mMsgTask(context->getMsgTask())
+    mLocApi(context->getLocApi()), mMsgTask(context->getMsgTask())
 {
-    mLocApi->addAdapter(this);
-}
-
-void LocAdapterBase::handleEngineUpEvent()
-{
-    if (mLocAdapterProxyBase) {
-        mLocAdapterProxyBase->handleEngineUpEvent();
-    }
+    sendMsg(new LocOpenMsg(this, mLocApi));
 }
 
-void LocAdapterBase::handleEngineDownEvent()
-{
-    if (mLocAdapterProxyBase) {
-        mLocAdapterProxyBase->handleEngineDownEvent();
-    }
-}
+void LocAdapterBase::
+    handleEngineDownEvent()
+DEFAULT_IMPL()
 
 void LocAdapterBase::
     reportPosition(UlpLocation &location,
@@ -128,8 +136,4 @@ DEFAULT_IMPL(false)
 bool LocAdapterBase::
     requestNiNotify(GpsNiNotification &notify, const void* data)
 DEFAULT_IMPL(false)
-
-void LocAdapterBase::
-    shutdown()
-DEFAULT_IMPL()
 } // namespace loc_core
diff --git a/core/LocAdapterBase.h b/core/LocAdapterBase.h
index 9348a89..f279f9f 100644
--- a/core/LocAdapterBase.h
+++ b/core/LocAdapterBase.h
@@ -1,4 +1,4 @@
-/* Copyright (c) 2011-2014, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2011-2013, 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,22 +35,21 @@
 
 namespace loc_core {
 
-class LocAdapterProxyBase;
-
 class LocAdapterBase {
 protected:
     const LOC_API_ADAPTER_EVENT_MASK_T mEvtMask;
     ContextBase* mContext;
     LocApiBase* mLocApi;
-    LocAdapterProxyBase* mLocAdapterProxyBase;
     const MsgTask* mMsgTask;
 
     inline LocAdapterBase(const MsgTask* msgTask) :
-        mEvtMask(0), mContext(NULL), mLocApi(NULL), mLocAdapterProxyBase(NULL), mMsgTask(msgTask) {}
-public:
-    inline virtual ~LocAdapterBase() { mLocApi->removeAdapter(this); }
+        mEvtMask(0), mContext(NULL), mLocApi(NULL), mMsgTask(msgTask) {}
+
     LocAdapterBase(const LOC_API_ADAPTER_EVENT_MASK_T mask,
-                   ContextBase* context, LocAdapterProxyBase *adapterProxyBase = NULL);
+                   ContextBase* context);
+    inline virtual ~LocAdapterBase() { mLocApi->removeAdapter(this); }
+
+public:
     inline LOC_API_ADAPTER_EVENT_MASK_T
         checkMask(LOC_API_ADAPTER_EVENT_MASK_T mask) const {
         return mEvtMask & mask;
@@ -71,12 +70,11 @@ public:
     // This will be overridden by the individual adapters
     // if necessary.
     inline virtual void setUlpProxy(UlpProxyBase* ulp) {}
-    virtual void handleEngineUpEvent();
+    inline virtual void handleEngineUpEvent() {}
     virtual void handleEngineDownEvent();
     inline virtual void setPositionModeInt(LocPosMode& posMode) {}
     virtual void startFixInt() {}
     virtual void stopFixInt() {}
-    virtual void getZppInt() {}
     virtual void reportPosition(UlpLocation &location,
                                 GpsLocationExtended &locationExtended,
                                 void* locationExt,
@@ -100,8 +98,6 @@ public:
     virtual bool requestNiNotify(GpsNiNotification &notify,
                                  const void* data);
     inline virtual bool isInSession() { return false; }
-    virtual void shutdown();
-    ContextBase* getContext() const { return mContext; }
 };
 
 } // namespace loc_core
diff --git a/core/LocApiBase.cpp b/core/LocApiBase.cpp
index 90f3653..f50d3e1 100644
--- a/core/LocApiBase.cpp
+++ b/core/LocApiBase.cpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2011-2014, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2011-2013, 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
@@ -33,7 +33,6 @@
 #include <LocApiBase.h>
 #include <LocAdapterBase.h>
 #include <log_util.h>
-#include <LocDualContext.h>
 
 namespace loc_core {
 
@@ -104,31 +103,9 @@ struct LocSsrMsg : public LocMsg {
     }
 };
 
-struct LocOpenMsg : public LocMsg {
-    LocApiBase* mLocApi;
-    LOC_API_ADAPTER_EVENT_MASK_T mMask;
-    inline LocOpenMsg(LocApiBase* locApi,
-                      LOC_API_ADAPTER_EVENT_MASK_T mask) :
-        LocMsg(), mLocApi(locApi), mMask(mask)
-    {
-        locallog();
-    }
-    inline virtual void proc() const {
-        mLocApi->open(mMask);
-    }
-    inline void locallog() {
-        LOC_LOGV("%s:%d]: LocOpen Mask: %x\n",
-                 __func__, __LINE__, mMask);
-    }
-    inline virtual void log() {
-        locallog();
-    }
-};
-
 LocApiBase::LocApiBase(const MsgTask* msgTask,
-                       LOC_API_ADAPTER_EVENT_MASK_T excludedMask,
-                       ContextBase* context) :
-    mExcludedMask(excludedMask), mMsgTask(msgTask), mMask(0), mContext(context)
+                       LOC_API_ADAPTER_EVENT_MASK_T excludedMask) :
+    mExcludedMask(excludedMask), mMsgTask(msgTask), mMask(0)
 {
     memset(mLocAdapters, 0, sizeof(mLocAdapters));
 }
@@ -146,11 +123,7 @@ bool LocApiBase::isInSession()
 {
     bool inSession = false;
 
-    for (int i = 0;
-         !inSession && i < MAX_ADAPTERS && NULL != mLocAdapters[i];
-         i++) {
-        inSession = mLocAdapters[i]->isInSession();
-    }
+    TO_ALL_LOCADAPTERS(inSession = mLocAdapters[i]->isInSession());
 
     return inSession;
 }
@@ -160,8 +133,7 @@ void LocApiBase::addAdapter(LocAdapterBase* adapter)
     for (int i = 0; i < MAX_ADAPTERS && mLocAdapters[i] != adapter; i++) {
         if (mLocAdapters[i] == NULL) {
             mLocAdapters[i] = adapter;
-            mMsgTask->sendMsg(new LocOpenMsg(this,
-                                             (adapter->getEvtMask())));
+            open(mMask | (adapter->getEvtMask() & ~mExcludedMask));
             break;
         }
     }
@@ -197,7 +169,7 @@ void LocApiBase::removeAdapter(LocAdapterBase* adapter)
                 close();
             } else {
                 // else we need to remove the bit
-                mMsgTask->sendMsg(new LocOpenMsg(this, getEvtMask()));
+                open(getEvtMask() & ~mExcludedMask);
             }
         }
     }
@@ -208,8 +180,6 @@ void LocApiBase::handleEngineUpEvent()
     // This will take care of renegotiating the loc handle
     mMsgTask->sendMsg(new LocSsrMsg(this));
 
-    LocDualContext::injectFeatureConfig(mContext);
-
     // loop through adapters, and deliver to all adapters.
     TO_ALL_LOCADAPTERS(mLocAdapters[i]->handleEngineUpEvent());
 }
@@ -322,12 +292,6 @@ void LocApiBase::requestNiNotify(GpsNiNotification &notify, const void* data)
     TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->requestNiNotify(notify, data));
 }
 
-void* LocApiBase :: getSibling()
-    DEFAULT_IMPL(NULL)
-
-LocApiProxyBase* LocApiBase :: getLocApiProxy()
-    DEFAULT_IMPL(NULL)
-
 enum loc_api_adapter_err LocApiBase::
    open(LOC_API_ADAPTER_EVENT_MASK_T mask)
 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
@@ -408,8 +372,7 @@ enum loc_api_adapter_err LocApiBase::
 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
 
 enum loc_api_adapter_err LocApiBase::
-    setSensorControlConfig(int sensorUsage,
-                           int sensorProvider)
+    setSensorControlConfig(int sensorUsage)
 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
 
 enum loc_api_adapter_err LocApiBase::
@@ -446,18 +409,6 @@ enum loc_api_adapter_err LocApiBase::
     setAGLONASSProtocol(unsigned long aGlonassProtocol)
 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
 
-enum loc_api_adapter_err LocApiBase::
-   getWwanZppFix(GpsLocation & zppLoc)
-DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
-
-enum loc_api_adapter_err LocApiBase::
-   getBestAvailableZppFix(GpsLocation & zppLoc)
-DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
-
-enum loc_api_adapter_err LocApiBase::
-   getBestAvailableZppFix(GpsLocation & zppLoc, LocPosTechMask & tech_mask)
-DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
-
 int LocApiBase::
     initDataServiceClient()
 DEFAULT_IMPL(-1)
@@ -474,11 +425,5 @@ void LocApiBase::
     closeDataCall()
 DEFAULT_IMPL()
 
-int LocApiBase::
-    setGpsLock(unsigned int lock)
-DEFAULT_IMPL(-1)
 
-int LocApiBase::
-    getGpsLock()
-DEFAULT_IMPL(-1)
 } // namespace loc_core
diff --git a/core/LocApiBase.h b/core/LocApiBase.h
index bef0379..87facf1 100644
--- a/core/LocApiBase.h
+++ b/core/LocApiBase.h
@@ -1,4 +1,4 @@
-/* Copyright (c) 2011-2014, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2011-2013, 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
@@ -33,10 +33,8 @@
 #include <ctype.h>
 #include <gps_extended.h>
 #include <MsgTask.h>
-#include <log_util.h>
 
 namespace loc_core {
-class ContextBase;
 
 int hexcode(char *hexstring, int string_size,
             const char *data, int data_size);
@@ -53,25 +51,16 @@ 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++);
 
+
 class LocAdapterBase;
 struct LocSsrMsg;
-struct LocOpenMsg;
-
-class LocApiProxyBase {
-public:
-    inline LocApiProxyBase() {}
-    inline virtual ~LocApiProxyBase() {}
-    inline virtual void* getSibling2() { return NULL; }
-};
 
 class LocApiBase {
     friend struct LocSsrMsg;
-    //LocOpenMsg calls open() which makes it necessary to declare
-    //it as a friend
-    friend struct LocOpenMsg;
     friend class ContextBase;
+    const LOC_API_ADAPTER_EVENT_MASK_T mExcludedMask;
     const MsgTask* mMsgTask;
-    ContextBase *mContext;
+
     LocAdapterBase* mLocAdapters[MAX_ADAPTERS];
 
 protected:
@@ -79,19 +68,16 @@ protected:
         open(LOC_API_ADAPTER_EVENT_MASK_T mask);
     virtual enum loc_api_adapter_err
         close();
+
     LOC_API_ADAPTER_EVENT_MASK_T getEvtMask();
     LOC_API_ADAPTER_EVENT_MASK_T mMask;
     LocApiBase(const MsgTask* msgTask,
-               LOC_API_ADAPTER_EVENT_MASK_T excludedMask,
-               ContextBase* context = NULL);
+               LOC_API_ADAPTER_EVENT_MASK_T excludedMask);
     inline virtual ~LocApiBase() { close(); }
     bool isInSession();
-    const LOC_API_ADAPTER_EVENT_MASK_T mExcludedMask;
 
 public:
-    inline void sendMsg(const LocMsg* msg) const {
-        mMsgTask->sendMsg(msg);
-    }
+    inline virtual void* getSibling() { return NULL; }
 
     void addAdapter(LocAdapterBase* adapter);
     void removeAdapter(LocAdapterBase* adapter);
@@ -125,9 +111,6 @@ public:
     // downward calls
     // All below functions are to be defined by adapter specific modules:
     // RPC, QMI, etc.  The default implementation is empty.
-
-    virtual void* getSibling();
-    virtual LocApiProxyBase* getLocApiProxy();
     virtual enum loc_api_adapter_err
         startFix(const LocPosMode& posMode);
     virtual enum loc_api_adapter_err
@@ -164,7 +147,7 @@ public:
     virtual enum loc_api_adapter_err
         setLPPConfig(uint32_t profile);
     virtual enum loc_api_adapter_err
-        setSensorControlConfig(int sensorUsage, int sensorProvider);
+        setSensorControlConfig(int sensorUsage);
     virtual enum loc_api_adapter_err
         setSensorProperties(bool gyroBiasVarianceRandomWalk_valid,
                             float gyroBiasVarianceRandomWalk,
@@ -191,37 +174,16 @@ public:
         setExtPowerConfig(int isBatteryCharging);
     virtual enum loc_api_adapter_err
         setAGLONASSProtocol(unsigned long aGlonassProtocol);
-    virtual enum loc_api_adapter_err
-        getWwanZppFix(GpsLocation & zppLoc);
-    virtual enum loc_api_adapter_err
-        getBestAvailableZppFix(GpsLocation & zppLoc);
-    virtual enum loc_api_adapter_err
-        getBestAvailableZppFix(GpsLocation & zppLoc, LocPosTechMask & tech_mask);
     virtual int initDataServiceClient();
     virtual int openAndStartDataCall();
     virtual void stopDataCall();
     virtual void closeDataCall();
 
     inline virtual void setInSession(bool inSession) {}
-
-    /*Values for lock
-      1 = Do not lock any position sessions
-      2 = Lock MI position sessions
-      3 = Lock MT position sessions
-      4 = Lock all position sessions
-     */
-    virtual int setGpsLock(unsigned int lock);
-    /*
-      Returns
-      Current value of GPS Lock on success
-      -1 on failure
-     */
-    virtual int getGpsLock(void);
 };
 
 typedef LocApiBase* (getLocApi_t)(const MsgTask* msgTask,
-                                  LOC_API_ADAPTER_EVENT_MASK_T exMask,
-                                  ContextBase *context);
+                                  LOC_API_ADAPTER_EVENT_MASK_T exMask);
 
 } // namespace loc_core
 
diff --git a/core/LocDualContext.cpp b/core/LocDualContext.cpp
index ab15110..381743d 100644
--- a/core/LocDualContext.cpp
+++ b/core/LocDualContext.cpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2011-2014, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2011-2013, 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
@@ -44,8 +44,7 @@ LocDualContext::mFgExclMask = 0;
 // excluded events for background clients
 const LOC_API_ADAPTER_EVENT_MASK_T
 LocDualContext::mBgExclMask =
-    (LOC_API_ADAPTER_BIT_PARSED_POSITION_REPORT |
-     LOC_API_ADAPTER_BIT_SATELLITE_REPORT |
+    (LOC_API_ADAPTER_BIT_SATELLITE_REPORT |
      LOC_API_ADAPTER_BIT_NMEA_1HZ_REPORT |
      LOC_API_ADAPTER_BIT_NMEA_POSITION_REPORT |
      LOC_API_ADAPTER_BIT_IOCTL_REPORT |
@@ -55,10 +54,10 @@ LocDualContext::mBgExclMask =
 const MsgTask* LocDualContext::mMsgTask = NULL;
 ContextBase* LocDualContext::mFgContext = NULL;
 ContextBase* LocDualContext::mBgContext = NULL;
-ContextBase* LocDualContext::mInjectContext = NULL;
+
 // the name must be shorter than 15 chars
 const char* LocDualContext::mLocationHalName = "Loc_hal_worker";
-const char* LocDualContext::mLBSLibName = "liblbs_core.so";
+const char* LocDualContext::mIzatLibName = "libizat_core.so";
 
 const MsgTask* LocDualContext::getMsgTask(MsgTask::tCreate tCreator,
                                           const char* name)
@@ -74,8 +73,6 @@ const MsgTask* LocDualContext::getMsgTask(MsgTask::tAssociate tAssociate,
 {
     if (NULL == mMsgTask) {
         mMsgTask = new MsgTask(tAssociate, name);
-    } else if (tAssociate) {
-        mMsgTask->associate(tAssociate);
     }
     return mMsgTask;
 }
@@ -88,10 +85,6 @@ ContextBase* LocDualContext::getLocFgContext(MsgTask::tCreate tCreator,
         mFgContext = new LocDualContext(msgTask,
                                         mFgExclMask);
     }
-    if(NULL == mInjectContext) {
-        mInjectContext = mFgContext;
-        injectFeatureConfig(mInjectContext);
-    }
     return mFgContext;
 }
 
@@ -103,11 +96,6 @@ ContextBase* LocDualContext::getLocFgContext(MsgTask::tAssociate tAssociate,
         mFgContext = new LocDualContext(msgTask,
                                         mFgExclMask);
     }
-    if(NULL == mInjectContext) {
-        LOC_LOGD("%s:%d]: mInjectContext is FgContext", __func__, __LINE__);
-        mInjectContext = mFgContext;
-        injectFeatureConfig(mInjectContext);
-    }
     return mFgContext;
 
 }
@@ -120,11 +108,6 @@ ContextBase* LocDualContext::getLocBgContext(MsgTask::tCreate tCreator,
         mBgContext = new LocDualContext(msgTask,
                                         mBgExclMask);
     }
-    if(NULL == mInjectContext) {
-        LOC_LOGD("%s:%d]: mInjectContext is BgContext", __func__, __LINE__);
-        mInjectContext = mBgContext;
-        injectFeatureConfig(mInjectContext);
-    }
     return mBgContext;
 }
 
@@ -136,28 +119,12 @@ ContextBase* LocDualContext::getLocBgContext(MsgTask::tAssociate tAssociate,
         mBgContext = new LocDualContext(msgTask,
                                         mBgExclMask);
     }
-    if(NULL == mInjectContext) {
-        LOC_LOGD("%s:%d]: mInjectContext is BgContext", __func__, __LINE__);
-        mInjectContext = mBgContext;
-        injectFeatureConfig(mInjectContext);
-    }
     return mBgContext;
 }
 
-void LocDualContext :: injectFeatureConfig(ContextBase *curContext)
-{
-    LOC_LOGD("%s:%d]: Enter", __func__, __LINE__);
-    if(curContext == mInjectContext) {
-        LOC_LOGD("%s:%d]: Calling LBSProxy (%p) to inject feature config",
-                 __func__, __LINE__, ((LocDualContext *)mInjectContext)->mLBSProxy);
-        ((LocDualContext *)mInjectContext)->mLBSProxy->injectFeatureConfig(curContext);
-    }
-    LOC_LOGD("%s:%d]: Exit", __func__, __LINE__);
-}
-
 LocDualContext::LocDualContext(const MsgTask* msgTask,
                                LOC_API_ADAPTER_EVENT_MASK_T exMask) :
-    ContextBase(msgTask, exMask, mLBSLibName)
+    ContextBase(msgTask, exMask, mIzatLibName)
 {
 }
 
diff --git a/core/LocDualContext.h b/core/LocDualContext.h
index cdc4df3..e761e76 100644
--- a/core/LocDualContext.h
+++ b/core/LocDualContext.h
@@ -1,4 +1,4 @@
-/* Copyright (c) 2011-2014, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2011-2013, 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
@@ -40,7 +40,7 @@ class LocDualContext : public ContextBase {
     static const MsgTask* mMsgTask;
     static ContextBase* mFgContext;
     static ContextBase* mBgContext;
-    static ContextBase* mInjectContext;
+
     static const MsgTask* getMsgTask(MsgTask::tCreate tCreator,
                                      const char* name);
     static const MsgTask* getMsgTask(MsgTask::tAssociate tAssociate,
@@ -52,7 +52,7 @@ protected:
     inline virtual ~LocDualContext() {}
 
 public:
-    static const char* mLBSLibName;
+    static const char* mIzatLibName;
     static const LOC_API_ADAPTER_EVENT_MASK_T mFgExclMask;
     static const LOC_API_ADAPTER_EVENT_MASK_T mBgExclMask;
     static const char* mLocationHalName;
@@ -65,7 +65,6 @@ public:
                                         const char* name);
     static ContextBase* getLocBgContext(MsgTask::tAssociate tAssociate,
                                         const char* name);
-    static void injectFeatureConfig(ContextBase *context);
 };
 
 }
diff --git a/core/MsgTask.cpp b/core/MsgTask.cpp
index 4db992d..e61ce1c 100644
--- a/core/MsgTask.cpp
+++ b/core/MsgTask.cpp
@@ -35,7 +35,6 @@
 #include <msg_q.h>
 #include <log_util.h>
 #include <loc_log.h>
-#include <android_runtime/AndroidRuntime.h>
 
 namespace loc_core {
 
@@ -69,21 +68,6 @@ MsgTask::~MsgTask() {
     msg_q_unblock((void*)mQ);
 }
 
-void MsgTask::associate(tAssociate tAssociator) const {
-    struct LocAssociateMsg : public LocMsg {
-        tAssociate mAssociator;
-        inline LocAssociateMsg(tAssociate associator) :
-            LocMsg(), mAssociator(associator) {}
-        inline virtual void proc() const {
-            if (mAssociator) {
-                LOC_LOGD("MsgTask::associate");
-                mAssociator();
-            }
-        }
-    };
-    sendMsg(new LocAssociateMsg(tAssociator));
-}
-
 void MsgTask::createPThread(const char* threadName) {
     pthread_attr_t attr;
     pthread_attr_init(&attr);
diff --git a/core/MsgTask.h b/core/MsgTask.h
index d50bb31..d09de73 100644
--- a/core/MsgTask.h
+++ b/core/MsgTask.h
@@ -52,7 +52,6 @@ public:
     MsgTask(tAssociate tAssociator, const char* threadName);
     ~MsgTask();
     void sendMsg(const LocMsg* msg) const;
-    void associate(tAssociate tAssociator) const;
 
 private:
     const void* mQ;
diff --git a/core/UlpProxyBase.h b/core/UlpProxyBase.h
index b9a8224..02ba167 100644
--- a/core/UlpProxyBase.h
+++ b/core/UlpProxyBase.h
@@ -1,4 +1,4 @@
-/* Copyright (c) 2013-2014, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2013, 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
@@ -37,20 +37,11 @@ class LocAdapterBase;
 
 class UlpProxyBase {
 public:
-    LocPosMode mPosMode;
-    bool mFixSet;
-    inline UlpProxyBase() {
-        mPosMode.mode = LOC_POSITION_MODE_INVALID;
-        mFixSet = false;
-    }
+    inline UlpProxyBase() {}
     inline virtual ~UlpProxyBase() {}
-    inline virtual bool sendStartFix() { mFixSet = true; return false; }
-    inline virtual bool sendStopFix() { mFixSet = false; return false; }
-    inline virtual bool sendFixMode(LocPosMode &params) {
-        mPosMode = params;
-        return false;
-    }
-
+    inline virtual bool sendStartFix() { return false;}
+    inline virtual bool sendStopFix() { return false;}
+    inline virtual bool sendFixMode(LocPosMode &params) { return false;}
     inline virtual bool reportPosition(UlpLocation &location,
                                        GpsLocationExtended &locationExtended,
                                        void* locationExt,
@@ -63,21 +54,8 @@ public:
                                  void* svExt) {
         return false;
     }
-    inline virtual bool reportStatus(GpsStatusValue status) {
-        return false;
-    }
     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/core/gps_extended_c.h b/core/gps_extended_c.h
index 63fe32a..e5e8546 100644
--- a/core/gps_extended_c.h
+++ b/core/gps_extended_c.h
@@ -1,4 +1,4 @@
-/* Copyright (c) 2013-2014, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2013, 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
@@ -55,18 +55,10 @@ extern "C" {
 /** Position source is ULP */
 #define ULP_LOCATION_IS_FROM_HYBRID   0x0001
 /** Position source is GNSS only */
-#define ULP_LOCATION_IS_FROM_GNSS     0x0002
-/** Position source is ZPP only */
-#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
+#define ULP_LOCATION_IS_FROM_GNSS   0x0002
 
 #define ULP_MIN_INTERVAL_INVALID 0xffffffff
 
-/*Emergency SUPL*/
-#define GPS_NI_TYPE_EMERGENCY_SUPL    4
 
 typedef struct {
     /** set to sizeof(UlpLocation) */
@@ -123,14 +115,6 @@ 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
@@ -187,8 +171,7 @@ typedef enum loc_server_type {
 } LocServerType;
 
 typedef enum loc_position_mode_type {
-    LOC_POSITION_MODE_INVALID = -1,
-    LOC_POSITION_MODE_STANDALONE = 0,
+    LOC_POSITION_MODE_STANDALONE,
     LOC_POSITION_MODE_MS_BASED,
     LOC_POSITION_MODE_MS_ASSISTED,
     LOC_POSITION_MODE_RESERVED_1,
@@ -196,27 +179,10 @@ typedef enum loc_position_mode_type {
     LOC_POSITION_MODE_RESERVED_3,
     LOC_POSITION_MODE_RESERVED_4,
     LOC_POSITION_MODE_RESERVED_5
-
 } LocPositionMode;
 
 #define MIN_POSSIBLE_FIX_INTERVAL 1000 /* msec */
 
-/** GpsLocationExtended has valid latitude and longitude. */
-#define GPS_LOCATION_EXTENDED_HAS_LAT_LONG   (1U<<0)
-/** GpsLocationExtended has valid altitude. */
-#define GPS_LOCATION_EXTENDED_HAS_ALTITUDE   (1U<<1)
-/** GpsLocationExtended has valid speed. */
-#define GPS_LOCATION_EXTENDED_HAS_SPEED      (1U<<2)
-/** GpsLocationExtended has valid bearing. */
-#define GPS_LOCATION_EXTENDED_HAS_BEARING    (1U<<4)
-/** GpsLocationExtended has valid accuracy. */
-#define GPS_LOCATION_EXTENDED_HAS_ACCURACY   (1U<<8)
-
-/** GPS extended supports geofencing */
-#define GPS_EXTENDED_CAPABILITY_GEOFENCE     0x0000001
-/** GPS extended supports batching */
-#define GPS_EXTENDED_CAPABILITY_BATCHING     0x0000002
-
 /** Flags to indicate which values are valid in a GpsLocationExtended. */
 typedef uint16_t GpsLocationExtendedFlags;
 /** GpsLocationExtended has valid pdop, hdop, vdop. */
@@ -254,19 +220,6 @@ 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,
@@ -322,54 +275,46 @@ enum loc_api_adapter_err {
 };
 
 enum loc_api_adapter_event_index {
-    LOC_API_ADAPTER_REPORT_POSITION = 0,               // Position report comes in loc_parsed_position_s_type
-    LOC_API_ADAPTER_REPORT_SATELLITE,                  // Satellite in view report
-    LOC_API_ADAPTER_REPORT_NMEA_1HZ,                   // NMEA report at 1HZ rate
-    LOC_API_ADAPTER_REPORT_NMEA_POSITION,              // NMEA report at position report rate
-    LOC_API_ADAPTER_REQUEST_NI_NOTIFY_VERIFY,          // NI notification/verification request
-    LOC_API_ADAPTER_REQUEST_ASSISTANCE_DATA,           // Assistance data, eg: time, predicted orbits request
-    LOC_API_ADAPTER_REQUEST_LOCATION_SERVER,           // Request for location server
-    LOC_API_ADAPTER_REPORT_IOCTL,                      // Callback report for loc_ioctl
-    LOC_API_ADAPTER_REPORT_STATUS,                     // Misc status report: eg, engine state
-    LOC_API_ADAPTER_REQUEST_WIFI,                      //
-    LOC_API_ADAPTER_SENSOR_STATUS,                     //
-    LOC_API_ADAPTER_REQUEST_TIME_SYNC,                 //
-    LOC_API_ADAPTER_REPORT_SPI,                        //
-    LOC_API_ADAPTER_REPORT_NI_GEOFENCE,                //
-    LOC_API_ADAPTER_GEOFENCE_GEN_ALERT,                //
-    LOC_API_ADAPTER_REPORT_GENFENCE_BREACH,            //
-    LOC_API_ADAPTER_PEDOMETER_CTRL,                    //
-    LOC_API_ADAPTER_MOTION_CTRL,                       //
-    LOC_API_ADAPTER_REQUEST_WIFI_AP_DATA,              // Wifi ap data
-    LOC_API_ADAPTER_BATCH_FULL,                        // Batching on full
-    LOC_API_ADAPTER_BATCHED_POSITION_REPORT,           // Batching on fix
-    LOC_API_ADAPTER_BATCHED_GENFENCE_BREACH_REPORT,    //
+    LOC_API_ADAPTER_REPORT_POSITION = 0,       // Position report comes in loc_parsed_position_s_type
+    LOC_API_ADAPTER_REPORT_SATELLITE,          // Satellite in view report
+    LOC_API_ADAPTER_REPORT_NMEA_1HZ,           // NMEA report at 1HZ rate
+    LOC_API_ADAPTER_REPORT_NMEA_POSITION,      // NMEA report at position report rate
+    LOC_API_ADAPTER_REQUEST_NI_NOTIFY_VERIFY,  // NI notification/verification request
+    LOC_API_ADAPTER_REQUEST_ASSISTANCE_DATA,   // Assistance data, eg: time, predicted orbits request
+    LOC_API_ADAPTER_REQUEST_LOCATION_SERVER,   // Request for location server
+    LOC_API_ADAPTER_REPORT_IOCTL,              // Callback report for loc_ioctl
+    LOC_API_ADAPTER_REPORT_STATUS,             // Misc status report: eg, engine state
+    LOC_API_ADAPTER_REQUEST_WIFI,              //
+    LOC_API_ADAPTER_SENSOR_STATUS,             //
+    LOC_API_ADAPTER_REQUEST_TIME_SYNC,         //
+    LOC_API_ADAPTER_REPORT_SPI,                //
+    LOC_API_ADAPTER_REPORT_NI_GEOFENCE,        //
+    LOC_API_ADAPTER_GEOFENCE_GEN_ALERT,        //
+    LOC_API_ADAPTER_REPORT_GENFENCE_BREACH,    //
+    LOC_API_ADAPTER_PEDOMETER_CTRL,            //
+    LOC_API_ADAPTER_MOTION_CTRL,               //
 
     LOC_API_ADAPTER_EVENT_MAX
 };
 
-#define LOC_API_ADAPTER_BIT_PARSED_POSITION_REPORT           (1<<LOC_API_ADAPTER_REPORT_POSITION)
-#define LOC_API_ADAPTER_BIT_SATELLITE_REPORT                 (1<<LOC_API_ADAPTER_REPORT_SATELLITE)
-#define LOC_API_ADAPTER_BIT_NMEA_1HZ_REPORT                  (1<<LOC_API_ADAPTER_REPORT_NMEA_1HZ)
-#define LOC_API_ADAPTER_BIT_NMEA_POSITION_REPORT             (1<<LOC_API_ADAPTER_REPORT_NMEA_POSITION)
-#define LOC_API_ADAPTER_BIT_NI_NOTIFY_VERIFY_REQUEST         (1<<LOC_API_ADAPTER_REQUEST_NI_NOTIFY_VERIFY)
-#define LOC_API_ADAPTER_BIT_ASSISTANCE_DATA_REQUEST          (1<<LOC_API_ADAPTER_REQUEST_ASSISTANCE_DATA)
-#define LOC_API_ADAPTER_BIT_LOCATION_SERVER_REQUEST          (1<<LOC_API_ADAPTER_REQUEST_LOCATION_SERVER)
-#define LOC_API_ADAPTER_BIT_IOCTL_REPORT                     (1<<LOC_API_ADAPTER_REPORT_IOCTL)
-#define LOC_API_ADAPTER_BIT_STATUS_REPORT                    (1<<LOC_API_ADAPTER_REPORT_STATUS)
-#define LOC_API_ADAPTER_BIT_REQUEST_WIFI                     (1<<LOC_API_ADAPTER_REQUEST_WIFI)
-#define LOC_API_ADAPTER_BIT_SENSOR_STATUS                    (1<<LOC_API_ADAPTER_SENSOR_STATUS)
-#define LOC_API_ADAPTER_BIT_REQUEST_TIME_SYNC                (1<<LOC_API_ADAPTER_REQUEST_TIME_SYNC)
-#define LOC_API_ADAPTER_BIT_REPORT_SPI                       (1<<LOC_API_ADAPTER_REPORT_SPI)
-#define LOC_API_ADAPTER_BIT_REPORT_NI_GEOFENCE               (1<<LOC_API_ADAPTER_REPORT_NI_GEOFENCE)
-#define LOC_API_ADAPTER_BIT_GEOFENCE_GEN_ALERT               (1<<LOC_API_ADAPTER_GEOFENCE_GEN_ALERT)
-#define LOC_API_ADAPTER_BIT_REPORT_GENFENCE_BREACH           (1<<LOC_API_ADAPTER_REPORT_GENFENCE_BREACH)
-#define LOC_API_ADAPTER_BIT_BATCHED_GENFENCE_BREACH_REPORT   (1<<LOC_API_ADAPTER_BATCHED_GENFENCE_BREACH_REPORT)
-#define LOC_API_ADAPTER_BIT_PEDOMETER_CTRL                   (1<<LOC_API_ADAPTER_PEDOMETER_CTRL)
-#define LOC_API_ADAPTER_BIT_MOTION_CTRL                      (1<<LOC_API_ADAPTER_MOTION_CTRL)
-#define LOC_API_ADAPTER_BIT_REQUEST_WIFI_AP_DATA             (1<<LOC_API_ADAPTER_REQUEST_WIFI_AP_DATA)
-#define LOC_API_ADAPTER_BIT_BATCH_FULL                       (1<<LOC_API_ADAPTER_BATCH_FULL)
-#define LOC_API_ADAPTER_BIT_BATCHED_POSITION_REPORT          (1<<LOC_API_ADAPTER_BATCHED_POSITION_REPORT)
+#define LOC_API_ADAPTER_BIT_PARSED_POSITION_REPORT   (1<<LOC_API_ADAPTER_REPORT_POSITION)
+#define LOC_API_ADAPTER_BIT_SATELLITE_REPORT         (1<<LOC_API_ADAPTER_REPORT_SATELLITE)
+#define LOC_API_ADAPTER_BIT_NMEA_1HZ_REPORT          (1<<LOC_API_ADAPTER_REPORT_NMEA_1HZ)
+#define LOC_API_ADAPTER_BIT_NMEA_POSITION_REPORT     (1<<LOC_API_ADAPTER_REPORT_NMEA_POSITION)
+#define LOC_API_ADAPTER_BIT_NI_NOTIFY_VERIFY_REQUEST (1<<LOC_API_ADAPTER_REQUEST_NI_NOTIFY_VERIFY)
+#define LOC_API_ADAPTER_BIT_ASSISTANCE_DATA_REQUEST  (1<<LOC_API_ADAPTER_REQUEST_ASSISTANCE_DATA)
+#define LOC_API_ADAPTER_BIT_LOCATION_SERVER_REQUEST  (1<<LOC_API_ADAPTER_REQUEST_LOCATION_SERVER)
+#define LOC_API_ADAPTER_BIT_IOCTL_REPORT             (1<<LOC_API_ADAPTER_REPORT_IOCTL)
+#define LOC_API_ADAPTER_BIT_STATUS_REPORT            (1<<LOC_API_ADAPTER_REPORT_STATUS)
+#define LOC_API_ADAPTER_BIT_REQUEST_WIFI             (1<<LOC_API_ADAPTER_REQUEST_WIFI)
+#define LOC_API_ADAPTER_BIT_SENSOR_STATUS            (1<<LOC_API_ADAPTER_SENSOR_STATUS)
+#define LOC_API_ADAPTER_BIT_REQUEST_TIME_SYNC        (1<<LOC_API_ADAPTER_REQUEST_TIME_SYNC)
+#define LOC_API_ADAPTER_BIT_REPORT_SPI               (1<<LOC_API_ADAPTER_REPORT_SPI)
+#define LOC_API_ADAPTER_BIT_REPORT_NI_GEOFENCE       (1<<LOC_API_ADAPTER_REPORT_NI_GEOFENCE)
+#define LOC_API_ADAPTER_BIT_GEOFENCE_GEN_ALERT       (1<<LOC_API_ADAPTER_GEOFENCE_GEN_ALERT)
+#define LOC_API_ADAPTER_BIT_REPORT_GENFENCE_BREACH   (1<<LOC_API_ADAPTER_REPORT_GENFENCE_BREACH)
+#define LOC_API_ADAPTER_BIT_PEDOMETER_CTRL           (1<<LOC_API_ADAPTER_PEDOMETER_CTRL)
+#define LOC_API_ADAPTER_BIT_MOTION_CTRL              (1<<LOC_API_ADAPTER_MOTION_CTRL)
 
 typedef unsigned int LOC_API_ADAPTER_EVENT_MASK_T;
 
diff --git a/core/loc_core_log.cpp b/core/loc_core_log.cpp
index 430f4b8..f67dfe0 100644
--- a/core/loc_core_log.cpp
+++ b/core/loc_core_log.cpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2011-2014, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2011-2013, 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
@@ -154,8 +154,7 @@ static loc_name_val_s_type loc_eng_ni_types[] =
 {
     NAME_VAL( GPS_NI_TYPE_VOICE ),
     NAME_VAL( GPS_NI_TYPE_UMTS_SUPL ),
-    NAME_VAL( GPS_NI_TYPE_UMTS_CTRL_PLANE ),
-    NAME_VAL( GPS_NI_TYPE_EMERGENCY_SUPL )
+    NAME_VAL( GPS_NI_TYPE_UMTS_CTRL_PLANE )
 };
 static int loc_eng_ni_type_num = sizeof(loc_eng_ni_types) / sizeof(loc_name_val_s_type);
 
@@ -198,7 +197,7 @@ static loc_name_val_s_type loc_eng_agps_bears[] =
 {
     NAME_VAL( AGPS_APN_BEARER_INVALID ),
     NAME_VAL( AGPS_APN_BEARER_IPV4 ),
-    NAME_VAL( AGPS_APN_BEARER_IPV6 ),
+    NAME_VAL( AGPS_APN_BEARER_IPV4 ),
     NAME_VAL( AGPS_APN_BEARER_IPV4V6 )
 };
 static int loc_eng_agps_bears_num = sizeof(loc_eng_agps_bears) / sizeof(loc_name_val_s_type);
diff --git a/etc/Android.mk b/etc/Android.mk
index 452dcd2..025d3f7 100644
--- a/etc/Android.mk
+++ b/etc/Android.mk
@@ -1,4 +1,4 @@
-ifeq (, $(filter aarch64 arm64, $(TARGET_ARCH)))
+
 LOCAL_PATH := $(call my-dir)
 include $(CLEAR_VARS)
 
@@ -9,4 +9,4 @@ LOCAL_MODULE_PATH  := $(TARGET_OUT_ETC)/
 LOCAL_SRC_FILES := gps.conf
 
 include $(BUILD_PREBUILT)
-endif # not aarch64
+
diff --git a/etc/gps.conf b/etc/gps.conf
index 75d4113..60f3123 100755
--- a/etc/gps.conf
+++ b/etc/gps.conf
@@ -1,8 +1,13 @@
-#Uncommenting these urls would only enable
-#the power up auto injection and force injection(test case).
-#XTRA_SERVER_1=http://xtra1.gpsonextra.net/xtra.bin
-#XTRA_SERVER_2=http://xtra2.gpsonextra.net/xtra.bin
-#XTRA_SERVER_3=http://xtra3.gpsonextra.net/xtra.bin
+# XTRA_SERVER_QUERY (1=on, 0=off)
+# If XTRA_SERVER_QUERY is on, the XTRA_SERVERs listed
+# below will be ignored, and instead the servers will
+# be queried from the modem.
+XTRA_SERVER_QUERY=0
+# XTRA_SERVERs below are used only if XTRA_SERVER_QUERY
+# is off.
+XTRA_SERVER_1=http://xtra1.gpsonextra.net/xtra2.bin
+XTRA_SERVER_2=http://xtra2.gpsonextra.net/xtra2.bin
+XTRA_SERVER_3=http://xtra3.gpsonextra.net/xtra2.bin
 
 # Error Estimate
 # _SET = 1
@@ -21,7 +26,7 @@ NTP_SERVER=time.gpsonextra.net
 # DEBUG LEVELS: 0 - none, 1 - Error, 2 - Warning, 3 - Info
 #               4 - Debug, 5 - Verbose
 # If DEBUG_LEVEL is commented, Android's logging levels will be used
-DEBUG_LEVEL = 3
+DEBUG_LEVEL = 2
 
 # Intermediate position report, 1=enable, 0=disable
 INTERMEDIATE_POS=0
@@ -29,9 +34,6 @@ INTERMEDIATE_POS=0
 # supl version 1.0
 SUPL_VER=0x10000
 
-# Emergency SUPL, 1=enable, 0=disable
-SUPL_ES=1
-
 # GPS Capabilities bit mask
 # SCHEDULING = 0x01
 # MSB = 0x02
@@ -73,8 +75,6 @@ LPP_PROFILE = 0
 ################################
 # NMEA provider (1=Modem Processor, 0=Application Processor)
 NMEA_PROVIDER=0
-# Mark if it is a SGLTE target (1=SGLTE, 0=nonSGLTE)
-SGLTE_TARGET=0
 
 ##################################################
 # Select Positioning Protocol on A-GLONASS system
diff --git a/loc_api/Android.mk b/loc_api/Android.mk
index e58f18e..110e5ae 100644
--- a/loc_api/Android.mk
+++ b/loc_api/Android.mk
@@ -1,5 +1,3 @@
-ifeq (, $(filter aarch64 arm64, $(TARGET_ARCH)))
-ifneq ($(BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE),)
 
 LOCAL_PATH := $(call my-dir)
 
@@ -14,6 +12,3 @@ GPS_DIR_LIST += $(LOCAL_PATH)/libloc_api_50001/
 
 #call the subfolders
 include $(addsuffix Android.mk, $(GPS_DIR_LIST))
-
-endif#BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE
-endif # not aarch64
diff --git a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/LocApiRpc.h b/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/LocApiRpc.h
index aafec63..1b4f3f7 100644
--- a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/LocApiRpc.h
+++ b/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/LocApiRpc.h
@@ -1,4 +1,4 @@
-/* Copyright (c) 2011,2014, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2011,2013, 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
@@ -115,25 +115,11 @@ public:
         atlCloseStatus(int handle, int is_succ);
     virtual enum loc_api_adapter_err
         setSUPLVersion(uint32_t version);
-    virtual void setInSession(bool inSession);
 
-    /*Values for lock
-      1 = Do not lock any position sessions
-      2 = Lock MI position sessions
-      3 = Lock MT position sessions
-      4 = Lock all position sessions
-    */
-    virtual int setGpsLock(unsigned int lock);
-    /*
-     Returns
-     Current value of GPS Lock on success
-     -1 on failure
-     */
-    virtual int getGpsLock(void);
+    virtual void setInSession(bool inSession);
 };
 
 extern "C" LocApiBase* getLocApi(const MsgTask* msgTask,
-                                 LOC_API_ADAPTER_EVENT_MASK_T exMask,
-                                 ContextBase *context);
+                                 LOC_API_ADAPTER_EVENT_MASK_T exMask);
 
 #endif //LOC_API_RPC_H
diff --git a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/LocApiRpc.cpp b/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/LocApiRpc.cpp
index e142292..428d5a2 100644
--- a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/LocApiRpc.cpp
+++ b/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/LocApiRpc.cpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2011-2014, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2011-2013, 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
@@ -134,9 +134,8 @@ const rpc_loc_event_mask_type LocApiRpc::locBits[] =
 
 // constructor
 LocApiRpc::LocApiRpc(const MsgTask* msgTask,
-                     LOC_API_ADAPTER_EVENT_MASK_T exMask,
-                     ContextBase* context) :
-    LocApiBase(msgTask, exMask, context),
+                     LOC_API_ADAPTER_EVENT_MASK_T exMask) :
+    LocApiBase(msgTask, exMask),
     client_handle(RPC_LOC_CLIENT_HANDLE_INVALID),
     dataEnableLastSet(-1)
 {
@@ -1389,59 +1388,6 @@ GpsNiEncodingType LocApiRpc::convertNiEncodingType(int loc_encoding)
 }
 
 LocApiBase* getLocApi(const MsgTask* msgTask,
-                      LOC_API_ADAPTER_EVENT_MASK_T exMask,
-                      ContextBase *context) {
-    return new LocApiRpc(msgTask, exMask, context);
-}
-
-/*Values for lock
-  1 = Do not lock any position sessions
-  2 = Lock MI position sessions
-  3 = Lock MT position sessions
-  4 = Lock all position sessions
-*/
-int LocApiRpc::setGpsLock(unsigned int lock)
-{
-    rpc_loc_ioctl_data_u_type    ioctl_data;
-    boolean ret_val;
-    LOC_LOGD("%s:%d]: lock: %d\n", __func__, __LINE__, lock);
-    ioctl_data.rpc_loc_ioctl_data_u_type_u.engine_lock = (rpc_loc_lock_e_type)lock;
-    ioctl_data.disc = RPC_LOC_IOCTL_SET_ENGINE_LOCK;
-    ret_val = loc_eng_ioctl (loc_eng_data.client_handle,
-                            RPC_LOC_IOCTL_SET_ENGINE_LOCK,
-                            &ioctl_data,
-                            LOC_IOCTL_DEFAULT_TIMEOUT,
-                            NULL /* No output information is expected*/);
-
-    LOC_LOGD("%s:%d]: ret_val: %d\n", __func__, __LINE__, (int)ret_val);
-    return (ret_val == TRUE ? 0 : -1);
-}
-
-/*
-  Returns
-  Current value of GPS lock on success
-  -1 on failure
-*/
-int LocApiRpc :: getGpsLock()
-{
-    rpc_loc_ioctl_data_u_type    ioctl_data;
-    rpc_loc_ioctl_callback_s_type callback_payload;
-    boolean ret_val;
-    int ret=0;
-    LOC_LOGD("%s:%d]: Enter\n", __func__, __LINE__);
-    ret_val = loc_eng_ioctl (loc_eng_data.client_handle,
-                            RPC_LOC_IOCTL_GET_ENGINE_LOCK,
-                            &ioctl_data,
-                            LOC_IOCTL_DEFAULT_TIMEOUT,
-                            &callback_payload);
-    if(ret_val == TRUE) {
-        ret = (int)callback_payload.data.engine_lock;
-        LOC_LOGD("%s:%d]: Lock type: %d\n", __func__, __LINE__, ret);
-    }
-    else {
-        LOC_LOGE("%s:%d]: Ioctl failed", __func__, __LINE__);
-        ret = -1;
-    }
-    LOC_LOGD("%s:%d]: Exit\n", __func__, __LINE__);
-    return ret;
+                      LOC_API_ADAPTER_EVENT_MASK_T exMask) {
+    return new LocApiRpc(msgTask, exMask);
 }
diff --git a/loc_api/libloc_api/Android.mk b/loc_api/libloc_api/Android.mk
new file mode 100644
index 0000000..2922a4a
--- /dev/null
+++ b/loc_api/libloc_api/Android.mk
@@ -0,0 +1,40 @@
+#Compile the old library version from Google push for Passion builds with old modem image
+ifneq ($(BOARD_VENDOR_QCOM_GPS_LOC_API_AMSS_VERSION),50001)
+LOCAL_PATH := $(call my-dir)
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := gps.$(BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE)
+LOCAL_MODULE_OWNER := qcom
+
+LOCAL_MODULE_TAGS := optional
+
+LOCAL_STATIC_LIBRARIES:= \
+    libloc_api-rpc 
+
+LOCAL_SHARED_LIBRARIES := \
+    librpc \
+    libutils \
+    libcutils
+
+LOCAL_SRC_FILES += \
+    loc_eng.cpp \
+    loc_eng_ioctl.cpp \
+    loc_eng_xtra.cpp \
+    loc_eng_ni.cpp \
+    gps.c
+
+LOCAL_CFLAGS += \
+    -fno-short-enums \
+    -DAMSS_VERSION=$(BOARD_VENDOR_QCOM_GPS_LOC_API_AMSS_VERSION)
+
+LOCAL_C_INCLUDES:= \
+	$(TARGET_OUT_HEADERS)/libloc_api-rpc \
+	$(TARGET_OUT_HEADERS)/libloc_api-rpc/inc \
+	$(TARGET_OUT_HEADERS)/libcommondefs-rpc/inc \
+	$(TARGET_OUT_HEADERS)/librpc
+
+
+LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/hw
+
+include $(BUILD_SHARED_LIBRARY)
+endif #BOARD_VENDOR_QCOM_GPS_LOC_API_AMSS_VERSION = 50001
diff --git a/core/LBSProxyBase.h b/loc_api/libloc_api/gps.c
index 0b7dbdf..36bfcb6 100644
--- a/core/LBSProxyBase.h
+++ b/loc_api/libloc_api/gps.c
@@ -1,4 +1,4 @@
-/* Copyright (c) 2013-2014, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2009,2011 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
@@ -9,7 +9,7 @@
  *       copyright notice, this list of conditions and the following
  *       disclaimer in the documentation and/or other materials provided
  *       with the distribution.
- *     * Neither the name of The Linux Foundation, nor the names of its
+ *     * Neither the name of The Linux Foundation nor the names of its
  *       contributors may be used to endorse or promote products derived
  *       from this software without specific prior written permission.
  *
@@ -26,38 +26,43 @@
  * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  */
-#ifndef IZAT_PROXY_BASE_H
-#define IZAT_PROXY_BASE_H
-#include <gps_extended.h>
-#include <MsgTask.h>
-
-namespace loc_core {
-
-class LocApiBase;
-class LocAdapterBase;
-class ContextBase;
-
-class LBSProxyBase {
-    friend class ContextBase;
-    inline virtual LocApiBase*
-        getLocApi(const MsgTask* msgTask,
-                  LOC_API_ADAPTER_EVENT_MASK_T exMask,
-                  ContextBase* context) const {
-        return NULL;
-    }
-protected:
-    inline LBSProxyBase() {}
-public:
-    inline virtual ~LBSProxyBase() {}
-    inline virtual void requestUlp(LocAdapterBase* adapter,
-                                   unsigned long capabilities) const {}
-    inline virtual bool hasAgpsExtendedCapabilities() const { return false; }
-    inline virtual bool hasCPIExtendedCapabilities() const { return false; }
-    virtual void injectFeatureConfig(ContextBase* context) const {}
-};
 
-typedef LBSProxyBase* (getLBSProxy_t)();
+#include <hardware/gps.h>
+
+#include <stdlib.h>
+
+extern const GpsInterface* get_gps_interface();
+
+const GpsInterface* gps__get_gps_interface(struct gps_device_t* dev)
+{
+    return get_gps_interface();
+}
+
+static int open_gps(const struct hw_module_t* module, char const* name,
+        struct hw_device_t** device)
+{
+    struct gps_device_t *dev = malloc(sizeof(struct gps_device_t));
+    memset(dev, 0, sizeof(*dev));
 
-} // namespace loc_core
+    dev->common.tag = HARDWARE_DEVICE_TAG;
+    dev->common.version = 0;
+    dev->common.module = (struct hw_module_t*)module;
+    dev->get_gps_interface = gps__get_gps_interface;
 
-#endif // IZAT_PROXY_BASE_H
+    *device = (struct hw_device_t*)dev;
+    return 0;
+}
+
+static struct hw_module_methods_t gps_module_methods = {
+    .open = open_gps
+};
+
+const struct hw_module_t HAL_MODULE_INFO_SYM = {
+    .tag = HARDWARE_MODULE_TAG,
+    .version_major = 1,
+    .version_minor = 0,
+    .id = GPS_HARDWARE_MODULE_ID,
+    .name = "loc_api GPS Module",
+    .author = "Qualcomm USA, Inc.",
+    .methods = &gps_module_methods,
+};
diff --git a/loc_api/libloc_api/loc_eng.cpp b/loc_api/libloc_api/loc_eng.cpp
new file mode 100644
index 0000000..3b28630
--- /dev/null
+++ b/loc_api/libloc_api/loc_eng.cpp
@@ -0,0 +1,1533 @@
+/* Copyright (c) 2009,2011 The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.
+ *     * Neither the name of The Linux Foundation nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#define LOG_NDDEBUG 0
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <ctype.h>
+#include <math.h>
+#include <pthread.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+
+#include <rpc/rpc.h>
+#include "loc_api_rpc_glue.h"
+#include "loc_apicb_appinit.h"
+
+#include <cutils/properties.h>
+#include <cutils/sched_policy.h>
+#include <utils/SystemClock.h>
+
+#include <loc_eng.h>
+#include <loc_eng_ni.h>
+
+#define LOG_TAG "lib_locapi"
+#include <utils/Log.h>
+
+// comment this out to enable logging
+// #undef LOGD
+// #define LOGD(...) {}
+
+#define DEBUG_MOCK_NI 0
+
+// Function declarations for sLocEngInterface
+static int  loc_eng_init(GpsCallbacks* callbacks);
+static int  loc_eng_start();
+static int  loc_eng_stop();
+static int  loc_eng_set_position_mode(GpsPositionMode mode, GpsPositionRecurrence recurrence,
+            uint32_t min_interval, uint32_t preferred_accuracy, uint32_t preferred_time);
+static void loc_eng_cleanup();
+static int  loc_eng_inject_time(GpsUtcTime time, int64_t timeReference, int uncertainty);
+static int  loc_eng_inject_location(double latitude, double longitude, float accuracy);
+static void loc_eng_delete_aiding_data (GpsAidingData f);
+static const void* loc_eng_get_extension(const char* name);
+
+// Function declarations for sLocEngAGpsInterface
+static void loc_eng_agps_init(AGpsCallbacks* callbacks);
+static int loc_eng_agps_data_conn_open(const char* apn);
+static int loc_eng_agps_data_conn_closed();
+static int loc_eng_agps_data_conn_failed();
+static int loc_eng_agps_set_server(AGpsType type, const char* hostname, int port);
+
+
+static int32 loc_event_cb (rpc_loc_client_handle_type client_handle,
+                           rpc_loc_event_mask_type loc_event,
+                           const rpc_loc_event_payload_u_type* loc_event_payload);
+static void loc_eng_report_position (const rpc_loc_parsed_position_s_type *location_report_ptr);
+static void loc_eng_report_sv (const rpc_loc_gnss_info_s_type *gnss_report_ptr);
+static void loc_eng_report_status (const rpc_loc_status_event_s_type *status_report_ptr);
+static void loc_eng_report_nmea (const rpc_loc_nmea_report_s_type *nmea_report_ptr);
+static void loc_eng_process_conn_request (const rpc_loc_server_request_s_type *server_request_ptr);
+
+static void loc_eng_process_deferred_action (void* arg);
+static void loc_eng_process_atl_deferred_action (int flags);
+static void loc_eng_delete_aiding_data_deferred_action (void);
+
+static int set_agps_server();
+
+// Defines the GpsInterface in gps.h
+static const GpsInterface sLocEngInterface =
+{
+    sizeof(GpsInterface),
+    loc_eng_init,
+    loc_eng_start,
+    loc_eng_stop,
+    loc_eng_cleanup,
+    loc_eng_inject_time,
+    loc_eng_inject_location,
+    loc_eng_delete_aiding_data,
+    loc_eng_set_position_mode,
+    loc_eng_get_extension,
+};
+
+static const AGpsInterface sLocEngAGpsInterface =
+{
+    sizeof(AGpsInterface),
+    loc_eng_agps_init,
+    loc_eng_agps_data_conn_open,
+    loc_eng_agps_data_conn_closed,
+    loc_eng_agps_data_conn_failed,
+    loc_eng_agps_set_server,
+};
+
+// Global data structure for location engine
+loc_eng_data_s_type loc_eng_data;
+
+/*===========================================================================
+FUNCTION    gps_get_hardware_interface
+
+DESCRIPTION
+   Returns the GPS hardware interaface based on LOC API
+   if GPS is enabled.
+
+DEPENDENCIES
+   None
+
+RETURN VALUE
+   0: success
+
+SIDE EFFECTS
+   N/A
+
+===========================================================================*/
+const GpsInterface* gps_get_hardware_interface ()
+{
+    char propBuf[PROPERTY_VALUE_MAX];
+
+    // check to see if GPS should be disabled
+    property_get("gps.disable", propBuf, "");
+    if (propBuf[0] == '1')
+    {
+        LOGD("gps_get_interface returning NULL because gps.disable=1\n");
+        return NULL;
+    }
+
+    return &sLocEngInterface;
+}
+
+/*===========================================================================
+FUNCTION    loc_eng_init
+
+DESCRIPTION
+   Initialize the location engine, this include setting up global datas
+   and registers location engien with loc api service.
+
+DEPENDENCIES
+   None
+
+RETURN VALUE
+   0: success
+
+SIDE EFFECTS
+   N/A
+
+===========================================================================*/
+
+// fully shutting down the GPS is temporarily disabled to avoid intermittent BP crash
+#define DISABLE_CLEANUP 1
+
+static int loc_eng_init(GpsCallbacks* callbacks)
+{
+#if DISABLE_CLEANUP
+    if (loc_eng_data.deferred_action_thread) {
+        // already initialized
+        return 0;
+    }
+#endif
+    // Start the LOC api RPC service
+    loc_api_glue_init ();
+
+    callbacks->set_capabilities_cb(GPS_CAPABILITY_SCHEDULING | GPS_CAPABILITY_MSA | GPS_CAPABILITY_MSB);
+
+    memset (&loc_eng_data, 0, sizeof (loc_eng_data_s_type));
+
+    // LOC ENG module data initialization
+    loc_eng_data.location_cb    = callbacks->location_cb;
+    loc_eng_data.sv_status_cb   = callbacks->sv_status_cb;
+    loc_eng_data.status_cb      = callbacks->status_cb;
+    loc_eng_data.nmea_cb        = callbacks->nmea_cb;
+    loc_eng_data.acquire_wakelock_cb = callbacks->acquire_wakelock_cb;
+    loc_eng_data.release_wakelock_cb = callbacks->release_wakelock_cb;
+
+    rpc_loc_event_mask_type event = RPC_LOC_EVENT_PARSED_POSITION_REPORT |
+                                    RPC_LOC_EVENT_SATELLITE_REPORT |
+                                    RPC_LOC_EVENT_LOCATION_SERVER_REQUEST |
+                                    RPC_LOC_EVENT_ASSISTANCE_DATA_REQUEST |
+                                    RPC_LOC_EVENT_IOCTL_REPORT |
+                                    RPC_LOC_EVENT_STATUS_REPORT |
+                                    RPC_LOC_EVENT_NMEA_POSITION_REPORT |
+                                    RPC_LOC_EVENT_NI_NOTIFY_VERIFY_REQUEST;
+
+    loc_eng_data.client_handle = loc_open (event, loc_event_cb);
+
+    pthread_mutex_init (&(loc_eng_data.deferred_action_mutex), NULL);
+    pthread_cond_init  (&(loc_eng_data.deferred_action_cond) , NULL);
+     pthread_mutex_init (&(loc_eng_data.deferred_stop_mutex), NULL);
+
+    loc_eng_data.loc_event = 0;
+    loc_eng_data.deferred_action_flags = 0;
+    memset (loc_eng_data.apn_name, 0, sizeof (loc_eng_data.apn_name));
+
+    loc_eng_data.aiding_data_for_deletion = 0;
+    loc_eng_data.engine_status = GPS_STATUS_NONE;
+
+    // XTRA module data initialization
+    loc_eng_data.xtra_module_data.download_request_cb = NULL;
+
+    // IOCTL module data initialization
+    loc_eng_data.ioctl_data.cb_is_selected  = FALSE;
+    loc_eng_data.ioctl_data.cb_is_waiting   = FALSE;
+    loc_eng_data.ioctl_data.client_handle   = RPC_LOC_CLIENT_HANDLE_INVALID;
+    memset (&(loc_eng_data.ioctl_data.cb_payload),
+            0,
+            sizeof (rpc_loc_ioctl_callback_s_type));
+
+    pthread_mutex_init (&(loc_eng_data.ioctl_data.cb_data_mutex), NULL);
+    pthread_cond_init(&loc_eng_data.ioctl_data.cb_arrived_cond, NULL);
+
+    loc_eng_data.deferred_action_thread = callbacks->create_thread_cb("loc_api",
+                                            loc_eng_process_deferred_action, NULL);
+
+    LOGD ("loc_eng_init called, client id = %d\n", (int32) loc_eng_data.client_handle);
+    return 0;
+}
+
+/*===========================================================================
+FUNCTION    loc_eng_cleanup
+
+DESCRIPTION
+   Cleans location engine. The location client handle will be released.
+
+DEPENDENCIES
+   None
+
+RETURN VALUE
+   None
+
+SIDE EFFECTS
+   N/A
+
+===========================================================================*/
+static void loc_eng_cleanup()
+{
+#if DISABLE_CLEANUP
+    return;
+#else
+    if (loc_eng_data.deferred_action_thread)
+    {
+        /* Terminate deferred action working thread */
+        pthread_mutex_lock(&loc_eng_data.deferred_action_mutex);
+        /* hold a wake lock while events are pending for deferred_action_thread */
+        loc_eng_data.acquire_wakelock_cb();
+        loc_eng_data.deferred_action_flags |= DEFERRED_ACTION_QUIT;
+        pthread_cond_signal(&loc_eng_data.deferred_action_cond);
+        pthread_mutex_unlock(&loc_eng_data.deferred_action_mutex);
+
+        void* ignoredValue;
+        pthread_join(loc_eng_data.deferred_action_thread, &ignoredValue);
+        loc_eng_data.deferred_action_thread = NULL;
+    }
+
+    // clean up
+    (void) loc_close (loc_eng_data.client_handle);
+
+    pthread_mutex_destroy (&loc_eng_data.deferred_action_mutex);
+    pthread_cond_destroy  (&loc_eng_data.deferred_action_cond);
+
+    pthread_mutex_destroy (&loc_eng_data.ioctl_data.cb_data_mutex);
+    pthread_cond_destroy  (&loc_eng_data.ioctl_data.cb_arrived_cond);
+
+// Do not call this as it can result in the ARM9 crashing if it sends events while we are disabled
+//    loc_apicb_app_deinit();
+#endif
+}
+
+
+/*===========================================================================
+FUNCTION    loc_eng_start
+
+DESCRIPTION
+   Starts the tracking session
+
+DEPENDENCIES
+   None
+
+RETURN VALUE
+   0: success
+
+SIDE EFFECTS
+   N/A
+
+===========================================================================*/
+static int loc_eng_start()
+{
+    int ret_val;
+    LOGD ("loc_eng_start\n");
+
+    if (loc_eng_data.position_mode != GPS_POSITION_MODE_STANDALONE &&
+            loc_eng_data.agps_server_host[0] != 0 &&
+            loc_eng_data.agps_server_port != 0) {
+        int result = set_agps_server();
+        LOGD ("set_agps_server returned = %d\n", result);
+    }
+
+    ret_val = loc_start_fix (loc_eng_data.client_handle);
+
+    if (ret_val != RPC_LOC_API_SUCCESS)
+    {
+        LOGD ("loc_eng_start returned error = %d\n", ret_val);
+    }
+
+    return 0;
+}
+
+
+/*===========================================================================
+FUNCTION    loc_eng_stop
+
+DESCRIPTION
+   Stops the tracking session
+
+DEPENDENCIES
+   None
+
+RETURN VALUE
+   0: success
+
+SIDE EFFECTS
+   N/A
+
+===========================================================================*/
+static int loc_eng_stop()
+{
+    int ret_val;
+
+    LOGD ("loc_eng_stop\n");
+
+    pthread_mutex_lock(&(loc_eng_data.deferred_stop_mutex));
+    // work around problem with loc_eng_stop when AGPS requests are pending
+    // we defer stopping the engine until the AGPS request is done
+    if (loc_eng_data.agps_request_pending)
+    {
+        loc_eng_data.stop_request_pending = true;
+        LOGD ("deferring stop until AGPS data call is finished\n");
+        pthread_mutex_unlock(&(loc_eng_data.deferred_stop_mutex));
+        return 0;
+    }
+    pthread_mutex_unlock(&(loc_eng_data.deferred_stop_mutex));
+
+    ret_val = loc_stop_fix (loc_eng_data.client_handle);
+    if (ret_val != RPC_LOC_API_SUCCESS)
+    {
+        LOGD ("loc_eng_stop returned error = %d\n", ret_val);
+    }
+
+    return 0;
+}
+
+static int loc_eng_set_gps_lock(rpc_loc_lock_e_type lock_type)
+{
+    rpc_loc_ioctl_data_u_type    ioctl_data;
+    boolean                      ret_val;
+
+    LOGD ("loc_eng_set_gps_lock mode, client = %d, lock_type = %d\n",
+            (int32) loc_eng_data.client_handle, lock_type);
+
+    ioctl_data.rpc_loc_ioctl_data_u_type_u.engine_lock = lock_type;
+    ioctl_data.disc = RPC_LOC_IOCTL_SET_ENGINE_LOCK;
+
+    ret_val = loc_eng_ioctl (loc_eng_data.client_handle,
+                            RPC_LOC_IOCTL_SET_ENGINE_LOCK,
+                            &ioctl_data,
+                            LOC_IOCTL_DEFAULT_TIMEOUT,
+                            NULL /* No output information is expected*/);
+
+    if (ret_val != TRUE)
+    {
+        LOGD ("loc_eng_set_gps_lock mode failed\n");
+    }
+
+    return 0;
+}
+
+/*===========================================================================
+FUNCTION    loc_eng_set_position_mode
+
+DESCRIPTION
+   Sets the mode and fix frequency for the tracking session.
+
+DEPENDENCIES
+   None
+
+RETURN VALUE
+   0: success
+
+SIDE EFFECTS
+   N/A
+
+===========================================================================*/
+static int loc_eng_set_position_mode(GpsPositionMode mode, GpsPositionRecurrence recurrence,
+            uint32_t min_interval, uint32_t preferred_accuracy, uint32_t preferred_time)
+{
+    rpc_loc_ioctl_data_u_type    ioctl_data;
+    rpc_loc_fix_criteria_s_type *fix_criteria_ptr;
+    boolean                      ret_val;
+
+    LOGD ("loc_eng_set_position mode, client = %d, interval = %d, mode = %d\n",
+            (int32) loc_eng_data.client_handle, min_interval, mode);
+
+    loc_eng_data.position_mode = mode;
+    ioctl_data.disc = RPC_LOC_IOCTL_SET_FIX_CRITERIA;
+
+    fix_criteria_ptr = &(ioctl_data.rpc_loc_ioctl_data_u_type_u.fix_criteria);
+    fix_criteria_ptr->valid_mask = RPC_LOC_FIX_CRIT_VALID_PREFERRED_OPERATION_MODE |
+                                   RPC_LOC_FIX_CRIT_VALID_RECURRENCE_TYPE;
+
+    switch (mode) {
+        case GPS_POSITION_MODE_MS_BASED:
+            fix_criteria_ptr->preferred_operation_mode = RPC_LOC_OPER_MODE_MSB;
+            break;
+        case GPS_POSITION_MODE_MS_ASSISTED:
+            fix_criteria_ptr->preferred_operation_mode = RPC_LOC_OPER_MODE_MSA;
+            break;
+        case GPS_POSITION_MODE_STANDALONE:
+        default:
+            fix_criteria_ptr->preferred_operation_mode = RPC_LOC_OPER_MODE_STANDALONE;
+            break;
+    }
+    if (min_interval > 0) {
+        fix_criteria_ptr->min_interval = min_interval;
+        fix_criteria_ptr->valid_mask |= RPC_LOC_FIX_CRIT_VALID_MIN_INTERVAL;
+    }
+    if (preferred_accuracy > 0) {
+        fix_criteria_ptr->preferred_accuracy = preferred_accuracy;
+        fix_criteria_ptr->valid_mask |= RPC_LOC_FIX_CRIT_VALID_PREFERRED_ACCURACY;
+    }
+    if (preferred_time > 0) {
+        fix_criteria_ptr->preferred_response_time = preferred_time;
+        fix_criteria_ptr->valid_mask |= RPC_LOC_FIX_CRIT_VALID_PREFERRED_RESPONSE_TIME;
+    }
+
+    switch (recurrence) {
+        case GPS_POSITION_RECURRENCE_SINGLE:
+            fix_criteria_ptr->recurrence_type = RPC_LOC_SINGLE_FIX;
+            break;
+        case GPS_POSITION_RECURRENCE_PERIODIC:
+        default:
+            fix_criteria_ptr->recurrence_type = RPC_LOC_PERIODIC_FIX;
+            break;
+    }
+
+    ret_val = loc_eng_ioctl(loc_eng_data.client_handle,
+                            RPC_LOC_IOCTL_SET_FIX_CRITERIA,
+                            &ioctl_data,
+                            LOC_IOCTL_DEFAULT_TIMEOUT,
+                            NULL /* No output information is expected*/);
+
+    if (ret_val != TRUE)
+    {
+        LOGD ("loc_eng_set_position mode failed\n");
+    }
+
+    return 0;
+}
+
+/*===========================================================================
+FUNCTION    loc_eng_inject_time
+
+DESCRIPTION
+   This is used by Java native function to do time injection.
+
+DEPENDENCIES
+   None
+
+RETURN VALUE
+   RPC_LOC_API_SUCCESS
+
+SIDE EFFECTS
+   N/A
+
+===========================================================================*/
+static int loc_eng_inject_time (GpsUtcTime time, int64_t timeReference, int uncertainty)
+{
+    rpc_loc_ioctl_data_u_type       ioctl_data;
+    rpc_loc_assist_data_time_s_type *time_info_ptr;
+    boolean                          ret_val;
+
+    LOGD ("loc_eng_inject_time, uncertainty = %d\n", uncertainty);
+
+    ioctl_data.disc = RPC_LOC_IOCTL_INJECT_UTC_TIME;
+
+    time_info_ptr = &(ioctl_data.rpc_loc_ioctl_data_u_type_u.assistance_data_time);
+    time_info_ptr->time_utc = time;
+    time_info_ptr->time_utc += (int64_t)(android::elapsedRealtime() - timeReference);
+    time_info_ptr->uncertainty = uncertainty; // Uncertainty in ms
+
+    ret_val = loc_eng_ioctl (loc_eng_data.client_handle,
+                             RPC_LOC_IOCTL_INJECT_UTC_TIME,
+                             &ioctl_data,
+                             LOC_IOCTL_DEFAULT_TIMEOUT,
+                             NULL /* No output information is expected*/);
+
+    if (ret_val != TRUE)
+    {
+        LOGD ("loc_eng_inject_time failed\n");
+    }
+
+    return 0;
+}
+
+static int loc_eng_inject_location (double latitude, double longitude, float accuracy)
+{
+    /* not yet implemented */
+    return 0;
+}
+
+/*===========================================================================
+FUNCTION    loc_eng_delete_aiding_data
+
+DESCRIPTION
+   This is used by Java native function to delete the aiding data. The function
+   updates the global variable for the aiding data to be deleted. If the GPS
+   engine is off, the aiding data will be deleted. Otherwise, the actual action
+   will happen when gps engine is turned off.
+
+DEPENDENCIES
+   Assumes the aiding data type specified in GpsAidingData matches with
+   LOC API specification.
+
+RETURN VALUE
+   RPC_LOC_API_SUCCESS
+
+SIDE EFFECTS
+   N/A
+
+===========================================================================*/
+static void loc_eng_delete_aiding_data (GpsAidingData f)
+{
+    pthread_mutex_lock(&(loc_eng_data.deferred_action_mutex));
+
+    // Currently, LOC API only support deletion of all aiding data,
+    if (f)
+        loc_eng_data.aiding_data_for_deletion = GPS_DELETE_ALL;
+
+    if ((loc_eng_data.engine_status != GPS_STATUS_SESSION_BEGIN) &&
+        (loc_eng_data.aiding_data_for_deletion != 0))
+    {
+        /* hold a wake lock while events are pending for deferred_action_thread */
+        loc_eng_data.acquire_wakelock_cb();
+        loc_eng_data.deferred_action_flags |= DEFERRED_ACTION_DELETE_AIDING;
+        pthread_cond_signal(&(loc_eng_data.deferred_action_cond));
+
+        // In case gps engine is ON, the assistance data will be deleted when the engine is OFF
+    }
+
+    pthread_mutex_unlock(&(loc_eng_data.deferred_action_mutex));
+}
+
+/*===========================================================================
+FUNCTION    loc_eng_get_extension
+
+DESCRIPTION
+   Get the gps extension to support XTRA.
+
+DEPENDENCIES
+   N/A
+
+RETURN VALUE
+   The GPS extension interface.
+
+SIDE EFFECTS
+   N/A
+
+===========================================================================*/
+static const void* loc_eng_get_extension(const char* name)
+{
+    if (strcmp(name, GPS_XTRA_INTERFACE) == 0)
+    {
+        return &sLocEngXTRAInterface;
+    }
+    else if (strcmp(name, AGPS_INTERFACE) == 0)
+    {
+        return &sLocEngAGpsInterface;
+    }
+    else if (strcmp(name, GPS_NI_INTERFACE) == 0)
+    {
+        return &sLocEngNiInterface;
+    }
+
+    return NULL;
+}
+
+#if DEBUG_MOCK_NI == 1
+/*===========================================================================
+FUNCTION    mock_ni
+
+DESCRIPTION
+   DEBUG tool: simulate an NI request
+
+DEPENDENCIES
+   N/A
+
+RETURN VALUE
+   None
+
+SIDE EFFECTS
+   N/A
+
+===========================================================================*/
+static void* mock_ni(void* arg)
+{
+    static int busy = 0;
+
+    if (busy) return NULL;
+
+    busy = 1;
+
+    sleep(5);
+
+    rpc_loc_client_handle_type           client_handle;
+    rpc_loc_event_mask_type              loc_event;
+    rpc_loc_event_payload_u_type         payload;
+    rpc_loc_ni_event_s_type             *ni_req;
+    rpc_loc_ni_supl_notify_verify_req_s_type *supl_req;
+
+    client_handle = (rpc_loc_client_handle_type) arg;
+
+    loc_event = RPC_LOC_EVENT_NI_NOTIFY_VERIFY_REQUEST;
+    payload.disc = loc_event;
+
+    ni_req = &payload.rpc_loc_event_payload_u_type_u.ni_request;
+    ni_req->event = RPC_LOC_NI_EVENT_SUPL_NOTIFY_VERIFY_REQ;
+    supl_req = &ni_req->payload.rpc_loc_ni_event_payload_u_type_u.supl_req;
+
+    // Encodings for Spirent Communications
+    char client_name[80]  = {0x53,0x78,0x5A,0x5E,0x76,0xD3,0x41,0xC3,0x77,
+            0xBB,0x5D,0x77,0xA7,0xC7,0x61,0x7A,0xFA,0xED,0x9E,0x03};
+    char requestor_id[80] = {0x53,0x78,0x5A,0x5E,0x76,0xD3,0x41,0xC3,0x77,
+            0xBB,0x5D,0x77,0xA7,0xC7,0x61,0x7A,0xFA,0xED,0x9E,0x03};
+
+    supl_req->flags = RPC_LOC_NI_CLIENT_NAME_PRESENT |
+                      RPC_LOC_NI_REQUESTOR_ID_PRESENT |
+                      RPC_LOC_NI_ENCODING_TYPE_PRESENT;
+
+    supl_req->datacoding_scheme = RPC_LOC_NI_SUPL_GSM_DEFAULT;
+
+    supl_req->client_name.data_coding_scheme = RPC_LOC_NI_SUPL_GSM_DEFAULT; // no coding
+    supl_req->client_name.client_name_string.client_name_string_len = strlen(client_name);
+    supl_req->client_name.client_name_string.client_name_string_val = client_name;
+    supl_req->client_name.string_len = strlen(client_name);
+
+    supl_req->requestor_id.data_coding_scheme = RPC_LOC_NI_SUPL_GSM_DEFAULT;
+    supl_req->requestor_id.requestor_id_string.requestor_id_string_len = strlen(requestor_id);
+    supl_req->requestor_id.requestor_id_string.requestor_id_string_val = requestor_id;
+    supl_req->requestor_id.string_len = strlen(requestor_id);
+
+    supl_req->notification_priv_type = RPC_LOC_NI_USER_NOTIFY_VERIFY_ALLOW_NO_RESP;
+    supl_req->user_response_timer = 10;
+
+    loc_event_cb(client_handle, loc_event, &payload);
+
+    busy = 0;
+
+    return NULL;
+}
+#endif // DEBUG_MOCK_NI
+
+/*===========================================================================
+FUNCTION    loc_event_cb
+
+DESCRIPTION
+   This is the callback function registered by loc_open.
+
+DEPENDENCIES
+   N/A
+
+RETURN VALUE
+   RPC_LOC_API_SUCCESS
+
+SIDE EFFECTS
+   N/A
+
+===========================================================================*/
+static int32 loc_event_cb(
+    rpc_loc_client_handle_type           client_handle,
+    rpc_loc_event_mask_type              loc_event,
+    const rpc_loc_event_payload_u_type*  loc_event_payload
+    )
+{
+    LOGV ("loc_event_cb, client = %d, loc_event = 0x%x", (int32) client_handle, (uint32) loc_event);
+    if (client_handle == loc_eng_data.client_handle)
+    {
+        pthread_mutex_lock(&loc_eng_data.deferred_action_mutex);
+        loc_eng_data.loc_event = loc_event;
+        memcpy(&loc_eng_data.loc_event_payload, loc_event_payload, sizeof(*loc_event_payload));
+
+        /* hold a wake lock while events are pending for deferred_action_thread */
+        loc_eng_data.acquire_wakelock_cb();
+        loc_eng_data.deferred_action_flags |= DEFERRED_ACTION_EVENT;
+        pthread_cond_signal(&loc_eng_data.deferred_action_cond);
+        pthread_mutex_unlock(&loc_eng_data.deferred_action_mutex);
+    }
+    else
+    {
+        LOGD ("loc client mismatch: received = %d, expected = %d \n", (int32) client_handle, (int32) loc_eng_data.client_handle);
+    }
+
+    return RPC_LOC_API_SUCCESS;
+}
+
+/*===========================================================================
+FUNCTION    loc_eng_report_position
+
+DESCRIPTION
+   Reports position information to the Java layer.
+
+DEPENDENCIES
+   N/A
+
+RETURN VALUE
+   N/A
+
+SIDE EFFECTS
+   N/A
+
+===========================================================================*/
+static void loc_eng_report_position (const rpc_loc_parsed_position_s_type *location_report_ptr)
+{
+    UlpLocation location;
+
+    LOGV ("loc_eng_report_position: location report, valid mask = 0x%x, sess status = %d\n",
+         (uint32) location_report_ptr->valid_mask, location_report_ptr->session_status);
+
+    memset (&location, 0, sizeof(location));
+    location.size = sizeof(location);
+    if (location_report_ptr->valid_mask & RPC_LOC_POS_VALID_SESSION_STATUS)
+    {
+        // Not a position report, return
+        if (location_report_ptr->session_status == RPC_LOC_SESS_STATUS_SUCCESS)
+        {
+            if (location_report_ptr->valid_mask & RPC_LOC_POS_VALID_TIMESTAMP_UTC)
+            {
+                location.timestamp = location_report_ptr->timestamp_utc;
+            }
+
+            if ((location_report_ptr->valid_mask & RPC_LOC_POS_VALID_LATITUDE) &&
+                (location_report_ptr->valid_mask & RPC_LOC_POS_VALID_LONGITUDE))
+            {
+                location.flags    |= GPS_LOCATION_HAS_LAT_LONG;
+                location.latitude  = location_report_ptr->latitude;
+                location.longitude = location_report_ptr->longitude;
+            }
+
+            if (location_report_ptr->valid_mask &  RPC_LOC_POS_VALID_ALTITUDE_WRT_ELLIPSOID )
+            {
+                location.flags    |= GPS_LOCATION_HAS_ALTITUDE;
+                location.altitude = location_report_ptr->altitude_wrt_ellipsoid;
+            }
+
+            if ((location_report_ptr->valid_mask & RPC_LOC_POS_VALID_SPEED_HORIZONTAL) &&
+                (location_report_ptr->valid_mask & RPC_LOC_POS_VALID_SPEED_VERTICAL))
+            {
+                location.flags    |= GPS_LOCATION_HAS_SPEED;
+                location.speed = sqrt(location_report_ptr->speed_horizontal * location_report_ptr->speed_horizontal +
+                                     location_report_ptr->speed_vertical * location_report_ptr->speed_vertical);
+            }
+
+            if (location_report_ptr->valid_mask &  RPC_LOC_POS_VALID_HEADING)
+            {
+                location.flags    |= GPS_LOCATION_HAS_BEARING;
+                location.bearing = location_report_ptr->heading;
+            }
+
+            if (location_report_ptr->valid_mask & RPC_LOC_POS_VALID_HOR_UNC_CIRCULAR)
+            {
+                location.flags    |= GPS_LOCATION_HAS_ACCURACY;
+                location.accuracy = location_report_ptr->hor_unc_circular;
+            }
+
+            if (loc_eng_data.location_cb != NULL)
+            {
+                LOGV ("loc_eng_report_position: fire callback\n");
+                loc_eng_data.location_cb (&location);
+            }
+        }
+        else
+        {
+            LOGV ("loc_eng_report_position: ignore position report when session status = %d\n", location_report_ptr->session_status);
+        }
+    }
+    else
+    {
+        LOGV ("loc_eng_report_position: ignore position report when session status is not set\n");
+    }
+}
+
+/*===========================================================================
+FUNCTION    loc_eng_report_sv
+
+DESCRIPTION
+   Reports GPS satellite information to the Java layer.
+
+DEPENDENCIES
+   N/A
+
+RETURN VALUE
+   N/A
+
+SIDE EFFECTS
+   N/A
+
+===========================================================================*/
+static void loc_eng_report_sv (const rpc_loc_gnss_info_s_type *gnss_report_ptr)
+{
+    GpsSvStatus     SvStatus;
+    int             num_svs_max, i;
+    const rpc_loc_sv_info_s_type *sv_info_ptr;
+
+    LOGV ("loc_eng_report_sv: valid_mask = 0x%x, num of sv = %d\n",
+            (uint32) gnss_report_ptr->valid_mask,
+            gnss_report_ptr->sv_count);
+
+    num_svs_max = 0;
+    memset (&SvStatus, 0, sizeof (GpsSvStatus));
+    if (gnss_report_ptr->valid_mask & RPC_LOC_GNSS_INFO_VALID_SV_COUNT)
+    {
+        num_svs_max = gnss_report_ptr->sv_count;
+        if (num_svs_max > GPS_MAX_SVS)
+        {
+            num_svs_max = GPS_MAX_SVS;
+        }
+    }
+
+    if (gnss_report_ptr->valid_mask & RPC_LOC_GNSS_INFO_VALID_SV_LIST)
+    {
+        SvStatus.num_svs = 0;
+
+        for (i = 0; i < num_svs_max; i++)
+        {
+            sv_info_ptr = &(gnss_report_ptr->sv_list.sv_list_val[i]);
+            if (sv_info_ptr->valid_mask & RPC_LOC_SV_INFO_VALID_SYSTEM)
+            {
+                if (sv_info_ptr->system == RPC_LOC_SV_SYSTEM_GPS)
+                {
+                    SvStatus.sv_list[SvStatus.num_svs].size = sizeof(GpsSvStatus);
+                    SvStatus.sv_list[SvStatus.num_svs].prn = sv_info_ptr->prn;
+
+                    // We only have the data field to report gps eph and alm mask
+                    if ((sv_info_ptr->valid_mask & RPC_LOC_SV_INFO_VALID_HAS_EPH) &&
+                        (sv_info_ptr->has_eph == 1))
+                    {
+                        SvStatus.ephemeris_mask |= (1 << (sv_info_ptr->prn-1));
+                    }
+
+                    if ((sv_info_ptr->valid_mask & RPC_LOC_SV_INFO_VALID_HAS_ALM) &&
+                        (sv_info_ptr->has_alm == 1))
+                    {
+                        SvStatus.almanac_mask |= (1 << (sv_info_ptr->prn-1));
+                    }
+
+                    if ((sv_info_ptr->valid_mask & RPC_LOC_SV_INFO_VALID_PROCESS_STATUS) &&
+                        (sv_info_ptr->process_status == RPC_LOC_SV_STATUS_TRACK))
+                    {
+                        SvStatus.used_in_fix_mask |= (1 << (sv_info_ptr->prn-1));
+                    }
+                }
+                // SBAS: GPS RPN: 120-151,
+                // In exteneded measurement report, we follow nmea standard, which is from 33-64.
+                else if (sv_info_ptr->system == RPC_LOC_SV_SYSTEM_SBAS)
+                {
+                    SvStatus.sv_list[SvStatus.num_svs].prn = sv_info_ptr->prn + 33 - 120;
+                }
+                // Gloness: Slot id: 1-32
+                // In extended measurement report, we follow nmea standard, which is 65-96
+                else if (sv_info_ptr->system == RPC_LOC_SV_SYSTEM_GLONASS)
+                {
+                    SvStatus.sv_list[SvStatus.num_svs].prn = sv_info_ptr->prn + (65-1);
+                }
+                // Unsupported SV system
+                else
+                {
+                    continue;
+                }
+            }
+
+            if (sv_info_ptr->valid_mask & RPC_LOC_SV_INFO_VALID_SNR)
+            {
+                SvStatus.sv_list[SvStatus.num_svs].snr = sv_info_ptr->snr;
+            }
+
+            if (sv_info_ptr->valid_mask & RPC_LOC_SV_INFO_VALID_ELEVATION)
+            {
+                SvStatus.sv_list[SvStatus.num_svs].elevation = sv_info_ptr->elevation;
+            }
+
+            if (sv_info_ptr->valid_mask & RPC_LOC_SV_INFO_VALID_AZIMUTH)
+            {
+                SvStatus.sv_list[SvStatus.num_svs].azimuth = sv_info_ptr->azimuth;
+            }
+
+            SvStatus.num_svs++;
+        }
+    }
+
+    LOGV ("num_svs = %d, eph mask = %d, alm mask = %d\n", SvStatus.num_svs, SvStatus.ephemeris_mask, SvStatus.almanac_mask );
+    if ((SvStatus.num_svs != 0) && (loc_eng_data.sv_status_cb != NULL))
+    {
+        loc_eng_data.sv_status_cb(&SvStatus);
+    }
+}
+
+/*===========================================================================
+FUNCTION    loc_eng_report_status
+
+DESCRIPTION
+   Reports GPS engine state to Java layer.
+
+DEPENDENCIES
+   N/A
+
+RETURN VALUE
+   N/A
+
+SIDE EFFECTS
+   N/A
+
+===========================================================================*/
+static void loc_eng_report_status (const rpc_loc_status_event_s_type *status_report_ptr)
+{
+    GpsStatus status;
+
+    LOGV ("loc_eng_report_status: event = %d\n", status_report_ptr->event);
+
+    memset (&status, 0, sizeof(status));
+    status.size = sizeof(status);
+    status.status = GPS_STATUS_NONE;
+    if (status_report_ptr->event == RPC_LOC_STATUS_EVENT_ENGINE_STATE)
+    {
+        if (status_report_ptr->payload.rpc_loc_status_event_payload_u_type_u.engine_state == RPC_LOC_ENGINE_STATE_ON)
+        {
+            // GPS_STATUS_SESSION_BEGIN implies GPS_STATUS_ENGINE_ON
+            status.status = GPS_STATUS_SESSION_BEGIN;
+            loc_eng_data.status_cb(&status);
+        }
+        else if (status_report_ptr->payload.rpc_loc_status_event_payload_u_type_u.engine_state == RPC_LOC_ENGINE_STATE_OFF)
+        {
+            // GPS_STATUS_SESSION_END implies GPS_STATUS_ENGINE_OFF
+            status.status = GPS_STATUS_ENGINE_OFF;
+            loc_eng_data.status_cb(&status);
+        }
+    }
+
+    pthread_mutex_lock(&loc_eng_data.deferred_action_mutex);
+    loc_eng_data.engine_status = status.status;
+
+    // Wake up the thread for aiding data deletion.
+    if ((loc_eng_data.engine_status != GPS_STATUS_SESSION_BEGIN) &&
+        (loc_eng_data.aiding_data_for_deletion != 0))
+    {
+        /* hold a wake lock while events are pending for deferred_action_thread */
+        loc_eng_data.acquire_wakelock_cb();
+        loc_eng_data.deferred_action_flags |= DEFERRED_ACTION_DELETE_AIDING;
+        pthread_cond_signal(&(loc_eng_data.deferred_action_cond));
+        // In case gps engine is ON, the assistance data will be deleted when the engine is OFF
+    }
+
+    pthread_mutex_unlock(&loc_eng_data.deferred_action_mutex);
+}
+
+static void loc_eng_report_nmea (const rpc_loc_nmea_report_s_type *nmea_report_ptr)
+{
+    if (loc_eng_data.nmea_cb != NULL)
+    {
+        struct timeval tv;
+
+        gettimeofday(&tv, (struct timezone *) NULL);
+        long long now = tv.tv_sec * 1000LL + tv.tv_usec / 1000;
+
+#if (AMSS_VERSION==3200)
+        loc_eng_data.nmea_cb(now, nmea_report_ptr->nmea_sentences.nmea_sentences_val,
+                nmea_report_ptr->nmea_sentences.nmea_sentences_len);
+#else
+        loc_eng_data.nmea_cb(now, nmea_report_ptr->nmea_sentences, nmea_report_ptr->length);
+#endif
+    }
+}
+
+/*===========================================================================
+FUNCTION    loc_eng_process_conn_request
+
+DESCRIPTION
+   Requests data connection to be brought up/tore down with the location server.
+
+DEPENDENCIES
+   N/A
+
+RETURN VALUE
+   N/A
+
+SIDE EFFECTS
+   N/A
+
+===========================================================================*/
+static void loc_eng_process_conn_request (const rpc_loc_server_request_s_type *server_request_ptr)
+{
+    LOGD ("loc_event_cb: get loc event location server request, event = %d\n", server_request_ptr->event);
+
+    // Signal DeferredActionThread to send the APN name
+    pthread_mutex_lock(&loc_eng_data.deferred_action_mutex);
+
+    // This implemenation is based on the fact that modem now at any time has only one data connection for AGPS at any given time
+    if (server_request_ptr->event == RPC_LOC_SERVER_REQUEST_OPEN)
+    {
+        loc_eng_data.conn_handle = server_request_ptr->payload.rpc_loc_server_request_u_type_u.open_req.conn_handle;
+        loc_eng_data.agps_status = GPS_REQUEST_AGPS_DATA_CONN;
+        loc_eng_data.agps_request_pending = true;
+    }
+    else
+    {
+        loc_eng_data.conn_handle = server_request_ptr->payload.rpc_loc_server_request_u_type_u.close_req.conn_handle;
+        loc_eng_data.agps_status = GPS_RELEASE_AGPS_DATA_CONN;
+        loc_eng_data.agps_request_pending = false;
+    }
+
+    /* hold a wake lock while events are pending for deferred_action_thread */
+    loc_eng_data.acquire_wakelock_cb();
+    loc_eng_data.deferred_action_flags |= DEFERRED_ACTION_AGPS_STATUS;
+    pthread_cond_signal(&loc_eng_data.deferred_action_cond);
+    pthread_mutex_unlock(&loc_eng_data.deferred_action_mutex);
+}
+
+/*===========================================================================
+FUNCTION    loc_eng_agps_init
+
+DESCRIPTION
+
+
+DEPENDENCIES
+   NONE
+
+RETURN VALUE
+   0
+
+SIDE EFFECTS
+   N/A
+
+===========================================================================*/
+static void loc_eng_agps_init(AGpsCallbacks* callbacks)
+{
+    LOGV("loc_eng_agps_init\n");
+    loc_eng_data.agps_status_cb = callbacks->status_cb;
+}
+
+static int loc_eng_agps_data_conn_open(const char* apn)
+{
+    int apn_len;
+    LOGD("loc_eng_agps_data_conn_open: %s\n", apn);
+
+    pthread_mutex_lock(&(loc_eng_data.deferred_action_mutex));
+
+    if (apn != NULL)
+    {
+        apn_len = strlen (apn);
+
+        if (apn_len >= sizeof(loc_eng_data.apn_name))
+        {
+            LOGD ("loc_eng_set_apn: error, apn name exceeds maximum lenght of 100 chars\n");
+            apn_len = sizeof(loc_eng_data.apn_name) - 1;
+        }
+
+        memcpy (loc_eng_data.apn_name, apn, apn_len);
+        loc_eng_data.apn_name[apn_len] = '\0';
+    }
+
+    /* hold a wake lock while events are pending for deferred_action_thread */
+    loc_eng_data.acquire_wakelock_cb();
+    loc_eng_data.deferred_action_flags |= DEFERRED_ACTION_AGPS_DATA_SUCCESS;
+    pthread_cond_signal(&(loc_eng_data.deferred_action_cond));
+    pthread_mutex_unlock(&(loc_eng_data.deferred_action_mutex));
+    return 0;
+}
+
+static int loc_eng_agps_data_conn_closed()
+{
+    LOGD("loc_eng_agps_data_conn_closed\n");
+    pthread_mutex_lock(&(loc_eng_data.deferred_action_mutex));
+    /* hold a wake lock while events are pending for deferred_action_thread */
+    loc_eng_data.acquire_wakelock_cb();
+    loc_eng_data.deferred_action_flags |= DEFERRED_ACTION_AGPS_DATA_CLOSED;
+    pthread_cond_signal(&(loc_eng_data.deferred_action_cond));
+    pthread_mutex_unlock(&(loc_eng_data.deferred_action_mutex));
+    return 0;
+}
+
+static int loc_eng_agps_data_conn_failed()
+{
+    LOGD("loc_eng_agps_data_conn_failed\n");
+
+    pthread_mutex_lock(&(loc_eng_data.deferred_action_mutex));
+    /* hold a wake lock while events are pending for deferred_action_thread */
+    loc_eng_data.acquire_wakelock_cb();
+    loc_eng_data.deferred_action_flags |= DEFERRED_ACTION_AGPS_DATA_FAILED;
+    pthread_cond_signal(&(loc_eng_data.deferred_action_cond));
+    pthread_mutex_unlock(&(loc_eng_data.deferred_action_mutex));
+    return 0;
+}
+
+static int set_agps_server()
+{
+    rpc_loc_ioctl_data_u_type       ioctl_data;
+    rpc_loc_server_info_s_type      *server_info_ptr;
+    boolean                         ret_val;
+    uint16                          port_temp;
+    unsigned char                   *b_ptr;
+
+    if (loc_eng_data.agps_server_host[0] == 0 || loc_eng_data.agps_server_port == 0)
+        return -1;
+
+    if (loc_eng_data.agps_server_address == 0) {
+        struct hostent* he = gethostbyname(loc_eng_data.agps_server_host);
+        if (he)
+            loc_eng_data.agps_server_address = *(uint32_t *)he->h_addr_list[0];
+    }
+    if (loc_eng_data.agps_server_address == 0)
+        return -1;
+
+    b_ptr = (unsigned char*) (&loc_eng_data.agps_server_address);
+
+
+    server_info_ptr = &(ioctl_data.rpc_loc_ioctl_data_u_type_u.server_addr);
+    ioctl_data.disc = RPC_LOC_IOCTL_SET_UMTS_SLP_SERVER_ADDR;
+    server_info_ptr->addr_type = RPC_LOC_SERVER_ADDR_URL;
+    server_info_ptr->addr_info.disc =  RPC_LOC_SERVER_ADDR_URL;
+
+#if (AMSS_VERSION==3200)
+    char   url[24];
+    memset(url, 0, sizeof(url));
+    snprintf(url, sizeof(url) - 1, "%d.%d.%d.%d:%d",
+            (*(b_ptr + 0)  & 0x000000ff), (*(b_ptr+1) & 0x000000ff),
+            (*(b_ptr + 2)  & 0x000000ff), (*(b_ptr+3) & 0x000000ff),
+            (loc_eng_data.agps_server_port & (0x0000ffff)));
+
+    server_info_ptr->addr_info.rpc_loc_server_addr_u_type_u.url.addr.addr_val = url;
+    server_info_ptr->addr_info.rpc_loc_server_addr_u_type_u.url.addr.addr_len = strlen(url);
+    LOGD ("set_agps_server, addr = %s\n", server_info_ptr->addr_info.rpc_loc_server_addr_u_type_u.url.addr.addr_val);
+#else
+    char* buf = server_info_ptr->addr_info.rpc_loc_server_addr_u_type_u.url.addr;
+    int buf_len = sizeof(server_info_ptr->addr_info.rpc_loc_server_addr_u_type_u.url.addr);
+    memset(buf, 0, buf_len);
+    snprintf(buf, buf_len - 1, "%d.%d.%d.%d:%d",
+            (*(b_ptr + 0)  & 0x000000ff), (*(b_ptr+1) & 0x000000ff),
+            (*(b_ptr + 2)  & 0x000000ff), (*(b_ptr+3) & 0x000000ff),
+            (loc_eng_data.agps_server_port & (0x0000ffff)));
+
+    server_info_ptr->addr_info.rpc_loc_server_addr_u_type_u.url.length = buf_len;
+    LOGD ("set_agps_server, addr = %s\n", buf);
+#endif
+
+    ret_val = loc_eng_ioctl (loc_eng_data.client_handle,
+                            RPC_LOC_IOCTL_SET_UMTS_SLP_SERVER_ADDR,
+                            &ioctl_data,
+                            LOC_IOCTL_DEFAULT_TIMEOUT,
+                            NULL /* No output information is expected*/);
+
+    if (ret_val != TRUE)
+    {
+        LOGD ("set_agps_server failed\n");
+        return -1;
+    }
+    else
+    {
+        LOGV ("set_agps_server successful\n");
+        return 0;
+    }
+}
+
+static int loc_eng_agps_set_server(AGpsType type, const char* hostname, int port)
+{
+    LOGD ("loc_eng_set_default_agps_server, type = %d, hostname = %s, port = %d\n", type, hostname, port);
+
+    if (type != AGPS_TYPE_SUPL)
+        return -1;
+
+    strncpy(loc_eng_data.agps_server_host, hostname, sizeof(loc_eng_data.agps_server_host) - 1);
+    loc_eng_data.agps_server_port = port;
+    return 0;
+}
+
+/*===========================================================================
+FUNCTION    loc_eng_delete_aiding_data_deferred_action
+
+DESCRIPTION
+   This is used to remove the aiding data when GPS engine is off.
+
+DEPENDENCIES
+   Assumes the aiding data type specified in GpsAidingData matches with
+   LOC API specification.
+
+RETURN VALUE
+   RPC_LOC_API_SUCCESS
+
+SIDE EFFECTS
+   N/A
+
+===========================================================================*/
+static void loc_eng_delete_aiding_data_deferred_action (void)
+{
+    // Currently, we only support deletion of all aiding data,
+    // since the Android defined aiding data mask matches with modem,
+    // so just pass them down without any translation
+    rpc_loc_ioctl_data_u_type          ioctl_data;
+    rpc_loc_assist_data_delete_s_type  *assist_data_ptr;
+    boolean                             ret_val;
+
+    ioctl_data.disc = RPC_LOC_IOCTL_DELETE_ASSIST_DATA;
+    assist_data_ptr = &(ioctl_data.rpc_loc_ioctl_data_u_type_u.assist_data_delete);
+    assist_data_ptr->type = loc_eng_data.aiding_data_for_deletion;
+    loc_eng_data.aiding_data_for_deletion = 0;
+
+    memset (&(assist_data_ptr->reserved), 0, sizeof (assist_data_ptr->reserved));
+
+    ret_val = loc_eng_ioctl (loc_eng_data.client_handle,
+                             RPC_LOC_IOCTL_DELETE_ASSIST_DATA ,
+                             &ioctl_data,
+                             LOC_IOCTL_DEFAULT_TIMEOUT,
+                             NULL);
+
+    LOGD("loc_eng_ioctl for aiding data deletion returned %d, 1 for success\n", ret_val);
+}
+
+/*===========================================================================
+FUNCTION    loc_eng_process_atl_deferred_action
+
+DESCRIPTION
+   This is used to inform the location engine of the processing status for
+   data connection open/close request.
+
+DEPENDENCIES
+   None
+
+RETURN VALUE
+   RPC_LOC_API_SUCCESS
+
+SIDE EFFECTS
+   N/A
+
+===========================================================================*/
+static void loc_eng_process_atl_deferred_action (int flags)
+{
+    rpc_loc_server_open_status_s_type  *conn_open_status_ptr;
+    rpc_loc_server_close_status_s_type *conn_close_status_ptr;
+    rpc_loc_ioctl_data_u_type           ioctl_data;
+    boolean                             ret_val;
+    int                                 agps_status = -1;
+
+    LOGV("loc_eng_process_atl_deferred_action, agps_status = %d\n", loc_eng_data.agps_status);
+
+    memset (&ioctl_data, 0, sizeof (rpc_loc_ioctl_data_u_type));
+
+    if (flags & DEFERRED_ACTION_AGPS_DATA_CLOSED)
+    {
+        ioctl_data.disc = RPC_LOC_IOCTL_INFORM_SERVER_CLOSE_STATUS;
+        conn_close_status_ptr = &(ioctl_data.rpc_loc_ioctl_data_u_type_u.conn_close_status);
+        conn_close_status_ptr->conn_handle = loc_eng_data.conn_handle;
+        conn_close_status_ptr->close_status = RPC_LOC_SERVER_CLOSE_SUCCESS;
+    }
+    else
+    {
+        ioctl_data.disc = RPC_LOC_IOCTL_INFORM_SERVER_OPEN_STATUS;
+        conn_open_status_ptr = &ioctl_data.rpc_loc_ioctl_data_u_type_u.conn_open_status;
+        conn_open_status_ptr->conn_handle = loc_eng_data.conn_handle;
+        if (flags & DEFERRED_ACTION_AGPS_DATA_SUCCESS)
+        {
+            conn_open_status_ptr->open_status = RPC_LOC_SERVER_OPEN_SUCCESS;
+            // Both buffer are of the same maximum size, and the source is null terminated
+            // strcpy (&(ioctl_data.rpc_loc_ioctl_data_u_type_u.conn_open_status.apn_name), &(loc_eng_data.apn_name));
+#if (AMSS_VERSION==3200)
+            conn_open_status_ptr->apn_name = loc_eng_data.apn_name;
+#else
+            memset(conn_open_status_ptr->apn_name, 0, sizeof(conn_open_status_ptr->apn_name));
+            strncpy(conn_open_status_ptr->apn_name, loc_eng_data.apn_name,
+                    sizeof(conn_open_status_ptr->apn_name) - 1);
+#endif
+            // Delay this so that PDSM ATL module will behave properly
+            sleep (1);
+            LOGD("loc_eng_ioctl for ATL with apn_name = %s\n", conn_open_status_ptr->apn_name);
+        }
+        else // data_connection_failed
+        {
+            conn_open_status_ptr->open_status = RPC_LOC_SERVER_OPEN_FAIL;
+        }
+        // Delay this so that PDSM ATL module will behave properly
+        sleep (1);
+    }
+
+    ret_val = loc_eng_ioctl (loc_eng_data.client_handle,
+                             ioctl_data.disc,
+                             &ioctl_data,
+                             LOC_IOCTL_DEFAULT_TIMEOUT,
+                             NULL);
+
+    LOGD("loc_eng_ioctl for ATL returned %d (1 for success)\n", ret_val);
+}
+
+/*===========================================================================
+FUNCTION    loc_eng_process_loc_event
+
+DESCRIPTION
+   This is used to process events received from the location engine.
+
+DEPENDENCIES
+   None
+
+RETURN VALUE
+   N/A
+
+SIDE EFFECTS
+   N/A
+
+===========================================================================*/
+static void loc_eng_process_loc_event (rpc_loc_event_mask_type loc_event,
+        rpc_loc_event_payload_u_type* loc_event_payload)
+{
+    if (loc_event & RPC_LOC_EVENT_PARSED_POSITION_REPORT)
+    {
+        loc_eng_report_position (&(loc_event_payload->rpc_loc_event_payload_u_type_u.parsed_location_report));
+    }
+
+    if (loc_event & RPC_LOC_EVENT_SATELLITE_REPORT)
+    {
+        loc_eng_report_sv (&(loc_event_payload->rpc_loc_event_payload_u_type_u.gnss_report));
+    }
+
+    if (loc_event & RPC_LOC_EVENT_STATUS_REPORT)
+    {
+        loc_eng_report_status (&(loc_event_payload->rpc_loc_event_payload_u_type_u.status_report));
+    }
+
+    if (loc_event & RPC_LOC_EVENT_NMEA_POSITION_REPORT)
+    {
+        loc_eng_report_nmea (&(loc_event_payload->rpc_loc_event_payload_u_type_u.nmea_report));
+    }
+
+    // Android XTRA interface supports only XTRA download
+    if (loc_event & RPC_LOC_EVENT_ASSISTANCE_DATA_REQUEST)
+    {
+        if (loc_event_payload->rpc_loc_event_payload_u_type_u.assist_data_request.event ==
+                RPC_LOC_ASSIST_DATA_PREDICTED_ORBITS_REQ)
+        {
+            LOGD ("loc_event_cb: xtra download requst");
+
+            // Call Registered callback
+            if (loc_eng_data.xtra_module_data.download_request_cb != NULL)
+            {
+                loc_eng_data.xtra_module_data.download_request_cb ();
+            }
+        }
+    }
+
+    if (loc_event & RPC_LOC_EVENT_IOCTL_REPORT)
+    {
+        // Process the received RPC_LOC_EVENT_IOCTL_REPORT
+        (void) loc_eng_ioctl_process_cb (loc_eng_data.client_handle,
+                                &(loc_event_payload->rpc_loc_event_payload_u_type_u.ioctl_report));
+    }
+
+    if (loc_event & RPC_LOC_EVENT_LOCATION_SERVER_REQUEST)
+    {
+        loc_eng_process_conn_request (&(loc_event_payload->rpc_loc_event_payload_u_type_u.loc_server_request));
+    }
+
+    loc_eng_ni_callback(loc_event, loc_event_payload);
+
+#if DEBUG_MOCK_NI == 1
+    // DEBUG only
+    if ((loc_event & RPC_LOC_EVENT_STATUS_REPORT) &&
+        loc_event_payload->rpc_loc_event_payload_u_type_u.status_report.
+        payload.rpc_loc_status_event_payload_u_type_u.engine_state
+        == RPC_LOC_ENGINE_STATE_OFF)
+    {
+        // Mock an NI request
+        pthread_t th;
+        pthread_create (&th, NULL, mock_ni, (void*) client_handle);
+    }
+#endif /* DEBUG_MOCK_NI == 1 */
+}
+
+/*===========================================================================
+FUNCTION loc_eng_process_deferred_action
+
+DESCRIPTION
+   Main routine for the thread to execute certain commands
+   that are not safe to be done from within an RPC callback.
+
+DEPENDENCIES
+   None
+
+RETURN VALUE
+   None
+
+SIDE EFFECTS
+   N/A
+
+===========================================================================*/
+static void loc_eng_process_deferred_action (void* arg)
+{
+    AGpsExtStatus      status;
+    status.size = sizeof(status);
+    status.type = AGPS_TYPE_SUPL;
+
+    LOGD("loc_eng_process_deferred_action started\n");
+
+    // make sure we do not run in background scheduling group
+    set_sched_policy(gettid(), SP_FOREGROUND);
+
+    // disable the GPS lock
+    LOGD("Setting GPS privacy lock to RPC_LOC_LOCK_NONE\n");
+    loc_eng_set_gps_lock(RPC_LOC_LOCK_NONE);
+
+    while (1)
+    {
+        GpsAidingData   aiding_data_for_deletion;
+        GpsStatusValue  engine_status;
+
+        rpc_loc_event_mask_type         loc_event;
+        rpc_loc_event_payload_u_type    loc_event_payload;
+
+        // Wait until we are signalled to do a deferred action, or exit
+        pthread_mutex_lock(&loc_eng_data.deferred_action_mutex);
+
+        // If we have an event we should process it immediately,
+        // otherwise wait until we are signalled
+        if (loc_eng_data.deferred_action_flags == 0) {
+            // do not hold a wake lock while waiting for an event...
+            loc_eng_data.release_wakelock_cb();
+            pthread_cond_wait(&loc_eng_data.deferred_action_cond,
+                                &loc_eng_data.deferred_action_mutex);
+            // but after we are signalled reacquire the wake lock
+            // until we are done processing the event.
+            loc_eng_data.acquire_wakelock_cb();
+        }
+
+        if (loc_eng_data.deferred_action_flags & DEFERRED_ACTION_QUIT)
+        {
+            pthread_mutex_unlock(&loc_eng_data.deferred_action_mutex);
+            break;
+        }
+
+        // copy anything we need before releasing the mutex
+        loc_event = loc_eng_data.loc_event;
+        if (loc_event != 0) {
+            memcpy(&loc_event_payload, &loc_eng_data.loc_event_payload, sizeof(loc_event_payload));
+            loc_eng_data.loc_event = 0;
+        }
+
+        int flags = loc_eng_data.deferred_action_flags;
+        loc_eng_data.deferred_action_flags = 0;
+        engine_status = loc_eng_data.agps_status;
+        aiding_data_for_deletion = loc_eng_data.aiding_data_for_deletion;
+        status.status = loc_eng_data.agps_status;
+        loc_eng_data.agps_status = 0;
+
+        // perform all actions after releasing the mutex to avoid blocking RPCs from the ARM9
+        pthread_mutex_unlock(&(loc_eng_data.deferred_action_mutex));
+
+        if (loc_event != 0) {
+            loc_eng_process_loc_event(loc_event, &loc_event_payload);
+        }
+
+        // send_delete_aiding_data must be done when GPS engine is off
+        if ((engine_status != GPS_STATUS_SESSION_BEGIN) && (aiding_data_for_deletion != 0))
+        {
+            loc_eng_delete_aiding_data_deferred_action ();
+        }
+
+        if (flags & (DEFERRED_ACTION_AGPS_DATA_SUCCESS |
+                     DEFERRED_ACTION_AGPS_DATA_CLOSED |
+                     DEFERRED_ACTION_AGPS_DATA_FAILED))
+        {
+            loc_eng_process_atl_deferred_action(flags);
+
+            pthread_mutex_lock(&(loc_eng_data.deferred_stop_mutex));
+            // work around problem with loc_eng_stop when AGPS requests are pending
+            // we defer stopping the engine until the AGPS request is done
+            loc_eng_data.agps_request_pending = false;
+            if (loc_eng_data.stop_request_pending)
+            {
+                LOGD ("handling deferred stop\n");
+                if (loc_stop_fix(loc_eng_data.client_handle) != RPC_LOC_API_SUCCESS)
+                {
+                    LOGD ("loc_stop_fix failed!\n");
+                }
+            }
+            pthread_mutex_unlock(&(loc_eng_data.deferred_stop_mutex));
+        }
+
+        if (status.status != 0 && loc_eng_data.agps_status_cb) {
+            loc_eng_data.agps_status_cb(&status);
+        }
+    }
+
+    // reenable the GPS lock
+    LOGD("Setting GPS privacy lock to RPC_LOC_LOCK_ALL\n");
+    loc_eng_set_gps_lock(RPC_LOC_LOCK_ALL);
+
+    LOGD("loc_eng_process_deferred_action thread exiting\n");
+    loc_eng_data.release_wakelock_cb();
+
+    loc_eng_data.deferred_action_thread = 0;
+}
+
+// for gps.c
+extern "C" const GpsInterface* get_gps_interface()
+{
+    return &sLocEngInterface;
+}
diff --git a/loc_api/libloc_api/loc_eng.h b/loc_api/libloc_api/loc_eng.h
new file mode 100644
index 0000000..b855331
--- /dev/null
+++ b/loc_api/libloc_api/loc_eng.h
@@ -0,0 +1,115 @@
+/* Copyright (c) 2009,2011 The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.
+ *     * Neither the name of The Linux Foundation nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef LOC_ENG_H
+#define LOC_ENG_H
+
+// Define boolean type to be used by libgps on loc api module
+typedef unsigned char boolean;
+
+#ifndef TRUE
+#define TRUE 1
+#endif
+
+#ifndef FALSE
+#define FALSE 0
+#endif
+
+#include <loc_eng_ioctl.h>
+#include <loc_eng_xtra.h>
+#include <hardware/gps.h>
+
+#define LOC_IOCTL_DEFAULT_TIMEOUT 1000 // 1000 milli-seconds
+
+enum {
+    DEFERRED_ACTION_EVENT               = 0x01,
+    DEFERRED_ACTION_DELETE_AIDING       = 0x02,
+    DEFERRED_ACTION_AGPS_STATUS         = 0x04,
+    DEFERRED_ACTION_AGPS_DATA_SUCCESS   = 0x08,
+    DEFERRED_ACTION_AGPS_DATA_CLOSED    = 0x10,
+    DEFERRED_ACTION_AGPS_DATA_FAILED    = 0x20,
+    DEFERRED_ACTION_QUIT                = 0x40,
+};
+
+// Module data
+typedef struct
+{
+    rpc_loc_client_handle_type  client_handle;
+
+    gps_location_callback           location_cb;
+    gps_status_callback             status_cb;
+    gps_sv_status_callback          sv_status_cb;
+    agps_status_callback            agps_status_cb;
+    gps_nmea_callback               nmea_cb;
+    gps_ni_notify_callback          ni_notify_cb;
+    gps_acquire_wakelock            acquire_wakelock_cb;
+    gps_release_wakelock            release_wakelock_cb;
+    int                             agps_status;
+
+    // used to defer stopping the GPS engine until AGPS data calls are done
+    boolean                         agps_request_pending;
+    boolean                         stop_request_pending;
+    pthread_mutex_t                 deferred_stop_mutex;
+
+    loc_eng_xtra_data_s_type        xtra_module_data;
+
+    loc_eng_ioctl_data_s_type       ioctl_data;
+
+    // data from loc_event_cb
+    rpc_loc_event_mask_type         loc_event;
+    rpc_loc_event_payload_u_type    loc_event_payload;
+
+    // TBD:
+    char                            agps_server_host[256];
+    int                             agps_server_port;
+    uint32                          agps_server_address;
+    char                            apn_name[100];
+    int                             position_mode;
+    rpc_loc_server_connection_handle  conn_handle;
+
+    // GPS engine status
+    GpsStatusValue                  engine_status;
+
+    // Aiding data information to be deleted, aiding data can only be deleted when GPS engine is off
+    GpsAidingData                   aiding_data_for_deletion;
+
+    // Data variables used by deferred action thread
+    pthread_t                       deferred_action_thread;
+    // Mutex used by deferred action thread
+    pthread_mutex_t                 deferred_action_mutex;
+    // Condition variable used by deferred action thread
+    pthread_cond_t                  deferred_action_cond;
+
+    // flags for pending events for deferred action thread
+    int                             deferred_action_flags;
+} loc_eng_data_s_type;
+   
+extern loc_eng_data_s_type loc_eng_data;
+
+#endif // LOC_ENG_H
diff --git a/loc_api/libloc_api/loc_eng_ioctl.cpp b/loc_api/libloc_api/loc_eng_ioctl.cpp
new file mode 100644
index 0000000..dc7b2c1
--- /dev/null
+++ b/loc_api/libloc_api/loc_eng_ioctl.cpp
@@ -0,0 +1,354 @@
+/* Copyright (c) 2009,2011 The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.
+ *     * Neither the name of The Linux Foundation nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#define LOG_NDDEBUG 0
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <unistd.h>
+#include <ctype.h>
+#include <math.h>
+#include <pthread.h>
+
+#include <rpc/rpc.h>
+#include <loc_api_rpc_glue.h>
+
+#include <hardware/gps.h>
+
+#include <loc_eng.h>
+
+#define LOG_TAG "lib_locapi"
+#include <utils/Log.h>
+
+// comment this out to enable logging
+// #undef LOGD
+// #define LOGD(...) {}
+
+// Function declarations
+static boolean loc_eng_ioctl_setup_cb(
+    rpc_loc_client_handle_type    handle,
+    rpc_loc_ioctl_e_type          ioctl_type
+);
+
+static boolean loc_eng_ioctl_wait_cb(
+    int                            timeout_msec,  // Timeout in this number of msec
+    rpc_loc_ioctl_callback_s_type *cb_data_ptr    // Output parameter for IOCTL calls
+);
+
+/*===========================================================================
+
+FUNCTION    loc_eng_ioctl
+
+DESCRIPTION
+   This function calls loc_ioctl and waits for the callback result before
+   returning back to the user.
+
+DEPENDENCIES
+   N/A
+
+RETURN VALUE
+   TRUE                 if successful
+   FALSE                if failed
+
+SIDE EFFECTS
+   N/A
+
+===========================================================================*/
+boolean loc_eng_ioctl(
+    rpc_loc_client_handle_type           handle,
+    rpc_loc_ioctl_e_type                 ioctl_type,
+    rpc_loc_ioctl_data_u_type*           ioctl_data_ptr,
+    uint32                               timeout_msec,
+    rpc_loc_ioctl_callback_s_type       *cb_data_ptr
+    )
+{
+    boolean                    ret_val;
+    int                        rpc_ret_val;
+    loc_eng_ioctl_data_s_type *ioctl_cb_data_ptr;
+
+    LOGV ("loc_eng_ioctl: client = %d, ioctl_type = %d, cb_data =0x%x\n", (int32) handle, ioctl_type, (uint32) cb_data_ptr);
+
+    ioctl_cb_data_ptr = &(loc_eng_data.ioctl_data);
+    // Select the callback we are waiting for
+    ret_val = loc_eng_ioctl_setup_cb (handle, ioctl_type);
+
+    if (ret_val == TRUE) 
+    {
+        rpc_ret_val =  loc_ioctl (handle,
+                                    ioctl_type,
+                                    ioctl_data_ptr);
+
+        LOGV ("loc_eng_ioctl: loc_ioctl returned %d \n", rpc_ret_val);
+
+        if (rpc_ret_val == RPC_LOC_API_SUCCESS)
+        {
+            // Wait for the callback of loc_ioctl
+            ret_val = loc_eng_ioctl_wait_cb (timeout_msec, cb_data_ptr);
+        }
+        else
+        {
+            ret_val = FALSE;
+        }
+    }
+
+    // Reset the state when we are done
+    pthread_mutex_lock(&ioctl_cb_data_ptr->cb_data_mutex);
+    ioctl_cb_data_ptr->cb_is_selected = FALSE;
+    ioctl_cb_data_ptr->cb_is_waiting  = FALSE;
+    ioctl_cb_data_ptr->cb_has_arrived = FALSE;
+    pthread_mutex_unlock(&ioctl_cb_data_ptr->cb_data_mutex);
+
+    return ret_val;
+}
+
+
+/*===========================================================================
+
+FUNCTION    loc_eng_ioctl_setup_cb
+
+DESCRIPTION
+   Selects which callback is going to be waited for
+
+DEPENDENCIES
+   N/A
+
+RETURN VALUE
+   TRUE                 if successful
+   FALSE                if failed
+
+SIDE EFFECTS
+   N/A
+
+===========================================================================*/
+static boolean loc_eng_ioctl_setup_cb(
+    rpc_loc_client_handle_type    handle,
+    rpc_loc_ioctl_e_type          ioctl_type
+    )
+{
+    boolean ret_val;
+    loc_eng_ioctl_data_s_type *ioctl_cb_data_ptr;
+
+    ioctl_cb_data_ptr = &(loc_eng_data.ioctl_data);
+
+    pthread_mutex_lock(&ioctl_cb_data_ptr->cb_data_mutex);
+    if (ioctl_cb_data_ptr->cb_is_selected == TRUE)
+    {
+        LOGD ("loc_eng_ioctl_setup_cb: ERROR, another ioctl in progress \n");
+        ret_val = FALSE;
+    }
+    else
+    {
+        ioctl_cb_data_ptr->cb_is_selected = TRUE;
+        ioctl_cb_data_ptr->cb_is_waiting  = FALSE;
+        ioctl_cb_data_ptr->cb_has_arrived = FALSE;
+        ioctl_cb_data_ptr->client_handle  = handle;
+        ioctl_cb_data_ptr->ioctl_type     = ioctl_type;
+        memset (&(ioctl_cb_data_ptr->cb_payload), 0, sizeof (rpc_loc_ioctl_callback_s_type));
+        ret_val = TRUE;
+    }
+    pthread_mutex_unlock(&ioctl_cb_data_ptr->cb_data_mutex);
+
+    return ret_val;
+}
+
+/*===========================================================================
+
+FUNCTION    loc_eng_ioctl_wait_cb
+
+DESCRIPTION
+   Waits for a selected callback. The wait expires in timeout_msec.
+
+   If the function is called before an existing wait has finished, it will
+   immediately return EBUSY.
+
+DEPENDENCIES
+   N/A
+
+RETURN VALUE
+   TRUE                 if successful
+   FALSE                if failed
+
+SIDE EFFECTS
+   N/A
+
+===========================================================================*/
+boolean loc_eng_ioctl_wait_cb(
+    int                            timeout_msec,  // Timeout in this number of msec
+    rpc_loc_ioctl_callback_s_type *cb_data_ptr
+    )
+{
+    boolean ret_val = FALSE; // the return value of this function
+    int rc;                  // return code from pthread calls
+
+    struct timeval present_time;
+    struct timespec expire_time;
+    loc_eng_ioctl_data_s_type *ioctl_cb_data_ptr;
+
+    ioctl_cb_data_ptr = &(loc_eng_data.ioctl_data);
+
+    pthread_mutex_lock(&ioctl_cb_data_ptr->cb_data_mutex);
+
+    do {
+        if (ioctl_cb_data_ptr->cb_is_selected == FALSE)
+        {
+            LOGD ("loc_eng_ioctl_wait_cb: ERROR called when cb_is_waiting is set to FALSE \n");
+            ret_val = FALSE;
+            break;
+        }
+
+        // Calculate absolute expire time
+        gettimeofday(&present_time, NULL);
+        expire_time.tv_sec  = present_time.tv_sec;
+        expire_time.tv_sec  +=  timeout_msec / 1000;
+        if ((present_time.tv_usec + timeout_msec) >= 1000)
+        {
+            expire_time.tv_sec += 1;
+        }
+        expire_time.tv_nsec = (present_time.tv_usec + timeout_msec) % 1000 * 1000;
+
+        // Special case where callback is issued before loc_ioctl ever returns
+        if (ioctl_cb_data_ptr->cb_has_arrived == TRUE)
+        {
+            LOGD ("loc_eng_ioctl_wait_cb: cb has arrived without waiting \n");
+            ret_val = TRUE;
+            break;
+        }
+   
+        ioctl_cb_data_ptr->cb_is_waiting = TRUE;
+        // Wait for the callback until timeout expires
+        rc = pthread_cond_timedwait(&ioctl_cb_data_ptr->cb_arrived_cond,
+                                    &ioctl_cb_data_ptr->cb_data_mutex,
+                                    &expire_time);
+
+        if (rc == 0)
+        {
+            ret_val = TRUE;
+        }
+        else
+        {
+            ret_val = FALSE;
+        }
+
+        LOGV ("loc_eng_ioctl_wait_cb: pthread_cond_timedwait returned %d\n", rc);
+
+    } while (0);
+
+    // Process the ioctl callback data when IOCTL is successful
+    if (ret_val == TRUE)
+    {
+        ioctl_cb_data_ptr = &(loc_eng_data.ioctl_data);
+        if (ioctl_cb_data_ptr->cb_payload.status == RPC_LOC_API_SUCCESS)
+        {
+            ret_val = TRUE;
+            if (cb_data_ptr != NULL)
+            {
+                memcpy (cb_data_ptr,
+                        &(ioctl_cb_data_ptr->cb_payload),
+                        sizeof (rpc_loc_ioctl_callback_s_type));
+            }
+        }
+        else
+        {
+            ret_val = FALSE;
+        }
+    }
+
+    pthread_mutex_unlock(&ioctl_cb_data_ptr->cb_data_mutex);
+
+    LOGV ("loc_eng_ioctl_wait_cb: returned %d\n", ret_val);
+    return ret_val;
+}
+
+/*===========================================================================
+
+FUNCTION    loc_eng_ioctl_process_cb
+
+DESCRIPTION
+   This function process the IOCTL callback, parameter specifies the client 
+   that receives the IOCTL callback.
+
+DEPENDENCIES
+   N/A
+
+RETURN VALUE
+   TRUE                 if successful
+   FALSE                if failed
+
+SIDE EFFECTS
+   N/A
+
+===========================================================================*/
+boolean loc_eng_ioctl_process_cb (
+    rpc_loc_client_handle_type           client_handle,
+    const rpc_loc_ioctl_callback_s_type *cb_data_ptr
+    )
+{
+    boolean ret_val = FALSE; // the return value of this function
+    loc_eng_ioctl_data_s_type *ioctl_cb_data_ptr;
+    ioctl_cb_data_ptr = &(loc_eng_data.ioctl_data);
+
+    pthread_mutex_lock(&ioctl_cb_data_ptr->cb_data_mutex);
+    if (client_handle != ioctl_cb_data_ptr->client_handle)
+    {
+        LOGD ("loc_eng_ioctl_process_cb: client handle mismatch, received = %d, expected = %d \n",
+                (int32) client_handle, (int32) ioctl_cb_data_ptr->client_handle);
+        ret_val = FALSE;
+    }
+    else if (cb_data_ptr->type != ioctl_cb_data_ptr->ioctl_type)
+    {
+        LOGD ("loc_eng_ioctl_process_cb: ioctl type mismatch, received = %d, expected = %d \n",
+                 cb_data_ptr->type, ioctl_cb_data_ptr->ioctl_type);
+        ret_val = FALSE;
+    }
+    else // both matches
+    {
+        memcpy (&(ioctl_cb_data_ptr->cb_payload),
+                cb_data_ptr,
+                sizeof (rpc_loc_ioctl_callback_s_type));
+
+        ioctl_cb_data_ptr->cb_has_arrived = TRUE;
+
+        LOGV ("loc_eng_ioctl_process_cb: callback arrived for client = %d, ioctl = %d, status = %d\n",
+                (int32) ioctl_cb_data_ptr->client_handle, ioctl_cb_data_ptr->ioctl_type,
+                (int32) ioctl_cb_data_ptr->cb_payload.status);
+
+        ret_val = TRUE;
+    }
+
+    pthread_mutex_unlock(&ioctl_cb_data_ptr->cb_data_mutex);
+
+    // Signal the waiting thread that callback has arrived
+    if (ret_val == TRUE)
+    {
+        pthread_cond_signal (&ioctl_cb_data_ptr->cb_arrived_cond);
+    }
+
+    return ret_val;
+}
diff --git a/loc_api/libloc_api/loc_eng_ioctl.h b/loc_api/libloc_api/loc_eng_ioctl.h
new file mode 100644
index 0000000..b819125
--- /dev/null
+++ b/loc_api/libloc_api/loc_eng_ioctl.h
@@ -0,0 +1,69 @@
+/* Copyright (c) 2009,2011 The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.
+ *     * Neither the name of The Linux Foundation nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef LOC_ENG_IOCTL_H
+#define LOC_ENG_IOCTL_H
+
+// Module data
+typedef struct loc_eng_ioctl_data_s_type
+{
+    // We are waiting for an ioctl callback
+    boolean                       cb_is_selected;
+    // The thread has been put in a wait state for an ioctl callback
+    boolean                       cb_is_waiting;
+    // Loc client handle that is waiting for the callback
+    rpc_loc_client_handle_type    client_handle;
+    // IOCTL type that the loc client is waiting for
+    rpc_loc_ioctl_e_type          ioctl_type;
+    // The IOCLT report has arrived for the waiting client
+    boolean                       cb_has_arrived;
+    // The payload for the RPC_LOC_EVENT_IOCTL_REPORT
+    rpc_loc_ioctl_callback_s_type cb_payload;
+    // Mutex to access this data structure
+    pthread_mutex_t               cb_data_mutex;
+    // LOC ioctl callback arrived mutex
+    pthread_cond_t                cb_arrived_cond;
+} loc_eng_ioctl_data_s_type;
+
+
+extern boolean loc_eng_ioctl
+(
+    rpc_loc_client_handle_type           handle,
+    rpc_loc_ioctl_e_type                 ioctl_type,
+    rpc_loc_ioctl_data_u_type*           ioctl_data_ptr,
+    uint32                               timeout_msec,
+    rpc_loc_ioctl_callback_s_type       *cb_data_ptr
+);
+
+extern boolean loc_eng_ioctl_process_cb 
+(
+    rpc_loc_client_handle_type           client_handle,
+    const rpc_loc_ioctl_callback_s_type *cb_data_ptr
+);
+#endif // LOC_ENG_IOCTL_H
diff --git a/loc_api/libloc_api/loc_eng_ni.cpp b/loc_api/libloc_api/loc_eng_ni.cpp
new file mode 100644
index 0000000..11d7aba
--- /dev/null
+++ b/loc_api/libloc_api/loc_eng_ni.cpp
@@ -0,0 +1,609 @@
+/* Copyright (c) 2009,2011 The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.
+ *     * Neither the name of The Linux Foundation nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#define LOG_NDDEBUG 0
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <pthread.h>
+#include <string.h>
+#include <ctype.h>
+#include <unistd.h>
+#include <time.h>
+
+#include <rpc/rpc.h>
+#include <loc_api_rpc_glue.h>
+#include <loc_eng.h>
+#include <loc_eng_ni.h>
+
+#define LOG_TAG "lib_locapi"
+#include <utils/Log.h>
+
+// comment this out to enable logging
+// #undef LOGD
+// #define LOGD(...) {}
+
+/*=============================================================================
+ *
+ *                             DATA DECLARATION
+ *
+ *============================================================================*/
+
+const GpsNiInterface sLocEngNiInterface =
+{
+    sizeof(GpsNiInterface),
+    loc_eng_ni_init,
+    loc_eng_ni_respond,
+};
+
+boolean loc_eng_ni_data_init = FALSE;
+loc_eng_ni_data_s_type loc_eng_ni_data;
+
+extern loc_eng_data_s_type loc_eng_data;
+
+/*=============================================================================
+ *
+ *                             FUNCTION DECLARATIONS
+ *
+ *============================================================================*/
+
+/*===========================================================================
+
+FUNCTION respond_from_enum
+
+DESCRIPTION
+   Returns the name of the response
+
+RETURN VALUE
+   response name string
+
+===========================================================================*/
+static const char* respond_from_enum(rpc_loc_ni_user_resp_e_type resp)
+{
+    switch (resp)
+    {
+    case RPC_LOC_NI_LCS_NOTIFY_VERIFY_ACCEPT:
+        return "accept";
+    case RPC_LOC_NI_LCS_NOTIFY_VERIFY_DENY:
+        return "deny";
+    case RPC_LOC_NI_LCS_NOTIFY_VERIFY_NORESP:
+        return "no response";
+    default:
+        return NULL;
+    }
+}
+
+/*===========================================================================
+
+FUNCTION loc_ni_respond
+
+DESCRIPTION
+   Displays the NI request and awaits user input. If a previous request is
+   in session, the new one is handled using sys.ni_default_response (if exists);
+   otherwise, it is denied.
+
+DEPENDENCY
+   Do not lock the data by mutex loc_ni_lock
+
+RETURN VALUE
+   none
+
+===========================================================================*/
+static void loc_ni_respond(rpc_loc_ni_user_resp_e_type resp,
+                    const rpc_loc_ni_event_s_type *request_pass_back
+)
+{
+    LOGD("Sending NI response: %s\n", respond_from_enum(resp));
+
+    rpc_loc_ioctl_data_u_type data;
+    rpc_loc_ioctl_callback_s_type callback_payload;
+
+    memcpy(&data.rpc_loc_ioctl_data_u_type_u.user_verify_resp.ni_event_pass_back,
+            request_pass_back, sizeof (rpc_loc_ni_event_s_type));
+    data.rpc_loc_ioctl_data_u_type_u.user_verify_resp.user_resp = resp;
+
+    loc_eng_ioctl(
+            loc_eng_data.client_handle,
+            RPC_LOC_IOCTL_INFORM_NI_USER_RESPONSE,
+            &data,
+            LOC_IOCTL_DEFAULT_TIMEOUT,
+            &callback_payload
+    );
+}
+
+/*===========================================================================
+
+FUNCTION loc_ni_fill_notif_verify_type
+
+DESCRIPTION
+   Fills need_notify, need_verify, etc.
+
+RETURN VALUE
+   none
+
+===========================================================================*/
+static boolean loc_ni_fill_notif_verify_type(GpsNiNotification *notif,
+      rpc_loc_ni_notify_verify_e_type notif_priv)
+{
+    notif->notify_flags       = 0;
+    notif->default_response   = GPS_NI_RESPONSE_NORESP;
+
+    switch (notif_priv)
+    {
+    case RPC_LOC_NI_USER_NO_NOTIFY_NO_VERIFY:
+        notif->notify_flags = 0;
+        break;
+
+    case RPC_LOC_NI_USER_NOTIFY_ONLY:
+        notif->notify_flags = GPS_NI_NEED_NOTIFY;
+        break;
+
+    case RPC_LOC_NI_USER_NOTIFY_VERIFY_ALLOW_NO_RESP:
+        notif->notify_flags = GPS_NI_NEED_NOTIFY | GPS_NI_NEED_VERIFY;
+        notif->default_response = GPS_NI_RESPONSE_ACCEPT;
+        break;
+
+    case RPC_LOC_NI_USER_NOTIFY_VERIFY_NOT_ALLOW_NO_RESP:
+        notif->notify_flags = GPS_NI_NEED_NOTIFY | GPS_NI_NEED_VERIFY;
+        notif->default_response = GPS_NI_RESPONSE_DENY;
+        break;
+
+    case RPC_LOC_NI_USER_PRIVACY_OVERRIDE:
+        notif->notify_flags = GPS_NI_PRIVACY_OVERRIDE;
+        break;
+
+    default:
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+/*===========================================================================
+
+FUNCTION hexcode
+
+DESCRIPTION
+   Converts a binary array into a Hex string. E.g., 1F 00 3F --> "1F003F"
+
+RETURN VALUE
+   bytes encoded
+
+===========================================================================*/
+static int hexcode(char *hexstring, int string_size, const char *data, int data_size)
+{
+    int i;
+    for (i = 0; i < data_size; i++)
+    {
+        char ch = data[i];
+        if (i*2 + 3 <= string_size)
+        {
+            snprintf(&hexstring[i*2], 3, "%02X", ch);
+        }
+        else {
+            break;
+        }
+    }
+    return i;
+}
+
+static GpsNiEncodingType convert_encoding_type(int loc_encoding)
+{
+    GpsNiEncodingType enc = GPS_ENC_UNKNOWN;
+
+    switch (loc_encoding)
+    {
+    case RPC_LOC_NI_SUPL_UTF8:
+        enc = GPS_ENC_SUPL_UTF8;
+        break;
+    case RPC_LOC_NI_SUPL_UCS2:
+        enc = GPS_ENC_SUPL_UCS2;
+        break;
+    case RPC_LOC_NI_SUPL_GSM_DEFAULT:
+        enc = GPS_ENC_SUPL_GSM_DEFAULT;
+        break;
+    default:
+        break;
+    }
+
+    return enc;
+}
+
+/*===========================================================================
+
+FUNCTION loc_ni_request_handler
+
+DESCRIPTION
+   Displays the NI request and awaits user input. If a previous request is
+   in session, it is ignored.
+
+RETURN VALUE
+   none
+
+===========================================================================*/
+static void loc_ni_request_handler(const char *msg, const rpc_loc_ni_event_s_type *ni_req)
+{
+    GpsNiNotification notif;
+    notif.size = sizeof(notif);
+    strlcpy(notif.text, "[text]", sizeof notif.text);    // defaults
+    strlcpy(notif.requestor_id, "[requestor id]", sizeof notif.requestor_id);
+
+    /* If busy, use default or deny */
+    if (loc_eng_ni_data.notif_in_progress)
+    {
+#if 0
+        /* Cannot be here because the current thread is in RPC client */
+        /* XXX Consider adding an event queue to process overlapped NI requests */
+        loc_ni_user_resp_e_type response =
+            sys.ni_default_resp == 1 /* accept */ ?
+                    LOC_NI_LCS_NOTIFY_VERIFY_ACCEPT :
+                    LOC_NI_LCS_NOTIFY_VERIFY_DENY;
+
+        loc_ni_respond(response, ni_req); */
+#endif
+        LOGW("loc_ni_request_handler, notification in progress, new NI request ignored, type: %d",
+                ni_req->event);
+    }
+    else {
+        /* Print notification */
+        LOGD("NI Notification: %s, event: %d", msg, ni_req->event);
+
+        pthread_mutex_lock(&loc_eng_ni_data.loc_ni_lock);
+
+        /* Save request */
+        memcpy(&loc_eng_ni_data.loc_ni_request, ni_req, sizeof loc_eng_ni_data.loc_ni_request);
+
+        /* Set up NI response waiting */
+        loc_eng_ni_data.notif_in_progress = TRUE;
+        loc_eng_ni_data.current_notif_id = abs(rand());
+
+        /* Fill in notification */
+        notif.notification_id = loc_eng_ni_data.current_notif_id;
+
+        const rpc_loc_ni_vx_notify_verify_req_s_type *vx_req;
+        const rpc_loc_ni_supl_notify_verify_req_s_type *supl_req;
+        const rpc_loc_ni_umts_cp_notify_verify_req_s_type *umts_cp_req;
+
+        switch (ni_req->event)
+        {
+            case RPC_LOC_NI_EVENT_VX_NOTIFY_VERIFY_REQ:
+                vx_req = &ni_req->payload.rpc_loc_ni_event_payload_u_type_u.vx_req;
+                notif.ni_type     = GPS_NI_TYPE_VOICE;
+                notif.timeout     = LOC_NI_NO_RESPONSE_TIME; // vx_req->user_resp_timer_val;
+                memset(notif.extras, 0, sizeof notif.extras);
+                memset(notif.text, 0, sizeof notif.text);
+                memset(notif.requestor_id, 0, sizeof notif.requestor_id);
+
+                // Requestor ID
+                hexcode(notif.requestor_id, sizeof notif.requestor_id,
+                        vx_req->requester_id.requester_id,
+                        vx_req->requester_id.requester_id_length);
+
+                notif.text_encoding = 0; // No text and no encoding
+                notif.requestor_id_encoding = convert_encoding_type(vx_req->encoding_scheme);
+
+                // Set default_response & notify_flags
+                loc_ni_fill_notif_verify_type(&notif, vx_req->notification_priv_type);
+
+                break;
+
+            case RPC_LOC_NI_EVENT_UMTS_CP_NOTIFY_VERIFY_REQ:
+                umts_cp_req = &ni_req->payload.rpc_loc_ni_event_payload_u_type_u.umts_cp_req;
+                notif.ni_type     = GPS_NI_TYPE_UMTS_CTRL_PLANE;
+                notif.timeout     = LOC_NI_NO_RESPONSE_TIME; // umts_cp_req->user_response_timer;
+                memset(notif.extras, 0, sizeof notif.extras);
+                memset(notif.text, 0, sizeof notif.text);
+                memset(notif.requestor_id, 0, sizeof notif.requestor_id);
+
+                // Stores notification text
+                hexcode(notif.text, sizeof notif.text,
+#if (AMSS_VERSION==3200)
+                        umts_cp_req->notification_text.notification_text_val,
+#else
+                        umts_cp_req->notification_text,
+#endif
+                        umts_cp_req->notification_length);
+
+                // Stores requestor ID
+                hexcode(notif.requestor_id, sizeof notif.requestor_id,
+#if (AMSS_VERSION==3200)
+                        umts_cp_req->requestor_id.requestor_id_string.requestor_id_string_val,
+#else
+                        umts_cp_req->requestor_id.requestor_id_string,
+#endif
+                        umts_cp_req->requestor_id.string_len);
+
+                notif.text_encoding = convert_encoding_type(umts_cp_req->datacoding_scheme);
+                notif.requestor_id_encoding = convert_encoding_type(umts_cp_req->datacoding_scheme);
+
+                // Set default_response & notify_flags
+                loc_ni_fill_notif_verify_type(&notif, umts_cp_req->notification_priv_type);
+
+                break;
+
+            case RPC_LOC_NI_EVENT_SUPL_NOTIFY_VERIFY_REQ:
+                supl_req = &ni_req->payload.rpc_loc_ni_event_payload_u_type_u.supl_req;
+                notif.ni_type     = GPS_NI_TYPE_UMTS_SUPL;
+                notif.timeout     = LOC_NI_NO_RESPONSE_TIME; // supl_req->user_response_timer;
+                memset(notif.extras, 0, sizeof notif.extras);
+                memset(notif.text, 0, sizeof notif.text);
+                memset(notif.requestor_id, 0, sizeof notif.requestor_id);
+
+                // Client name
+                if (supl_req->flags & RPC_LOC_NI_CLIENT_NAME_PRESENT)
+                {
+                    hexcode(notif.text, sizeof notif.text,
+#if (AMSS_VERSION==3200)
+                            supl_req->client_name.client_name_string.client_name_string_val,   /* buffer */
+#else
+                            supl_req->client_name.client_name_string,                          /* buffer */
+#endif
+                            supl_req->client_name.string_len                                   /* length */
+                    );
+                    LOGD("SUPL NI: client_name: %s len=%d", notif.text, supl_req->client_name.string_len);
+                } else {
+                    LOGD("SUPL NI: client_name not present.");
+                }
+
+                // Requestor ID
+                if (supl_req->flags & RPC_LOC_NI_REQUESTOR_ID_PRESENT)
+                {
+                    hexcode(notif.requestor_id, sizeof notif.requestor_id,
+#if (AMSS_VERSION==3200)
+                            supl_req->requestor_id.requestor_id_string.requestor_id_string_val,  /* buffer */
+#else
+                            supl_req->requestor_id.requestor_id_string,                          /* buffer */
+#endif
+                            supl_req->requestor_id.string_len                                    /* length */
+                    );
+                    LOGD("SUPL NI: requestor_id: %s len=%d", notif.requestor_id, supl_req->requestor_id.string_len);
+                } else {
+                    LOGD("SUPL NI: requestor_id not present.");
+                }
+
+                // Encoding type
+                if (supl_req->flags & RPC_LOC_NI_ENCODING_TYPE_PRESENT)
+                {
+                    notif.text_encoding = convert_encoding_type(supl_req->datacoding_scheme);
+                    notif.requestor_id_encoding = convert_encoding_type(supl_req->datacoding_scheme);
+                } else {
+                    notif.text_encoding = notif.requestor_id_encoding = GPS_ENC_UNKNOWN;
+                }
+
+                // Set default_response & notify_flags
+                loc_ni_fill_notif_verify_type(&notif, ni_req->payload.rpc_loc_ni_event_payload_u_type_u.supl_req.notification_priv_type);
+
+                break;
+
+            default:
+                LOGE("loc_ni_request_handler, unknown request event: %d", ni_req->event);
+                return;
+        }
+
+        /* Log requestor ID and text for debugging */
+        LOGI("Notification: notif_type: %d, timeout: %d, default_resp: %d", notif.ni_type, notif.timeout, notif.default_response);
+        LOGI("              requestor_id: %s (encoding: %d)", notif.requestor_id, notif.requestor_id_encoding);
+        LOGI("              text: %s text (encoding: %d)", notif.text, notif.text_encoding);
+
+        /* For robustness, always sets a timeout to clear up the notification status, even though
+        * the OEM layer in java does not do so.
+        **/
+        loc_eng_ni_data.response_time_left = 5 + (notif.timeout != 0 ? notif.timeout : LOC_NI_NO_RESPONSE_TIME);
+        LOGI("Automatically sends 'no response' in %d seconds (to clear status)\n", loc_eng_ni_data.response_time_left);
+
+        pthread_mutex_unlock(&loc_eng_ni_data.loc_ni_lock);
+
+        /* Notify callback */
+        if (loc_eng_data.ni_notify_cb != NULL)
+        {
+            loc_eng_data.ni_notify_cb(&notif);
+        }
+    }
+}
+
+/*===========================================================================
+
+FUNCTION loc_ni_process_user_response
+
+DESCRIPTION
+   Handles user input from the UI
+
+RETURN VALUE
+   error code (0 for successful, -1 for error)
+
+===========================================================================*/
+int loc_ni_process_user_response(GpsUserResponseType userResponse)
+{
+    LOGD("NI response from UI: %d", userResponse);
+
+    rpc_loc_ni_user_resp_e_type resp;
+    switch (userResponse)
+    {
+        case GPS_NI_RESPONSE_ACCEPT:
+            resp = RPC_LOC_NI_LCS_NOTIFY_VERIFY_ACCEPT;
+            break;
+        case GPS_NI_RESPONSE_DENY:
+            resp = RPC_LOC_NI_LCS_NOTIFY_VERIFY_DENY;
+            break;
+        case GPS_NI_RESPONSE_NORESP:
+            resp = RPC_LOC_NI_LCS_NOTIFY_VERIFY_NORESP;
+            break;
+        default:
+            return -1;
+    }
+
+    loc_ni_respond(resp, &loc_eng_ni_data.loc_ni_request);
+
+    /* Make the NI respond */
+    pthread_mutex_lock(&loc_eng_ni_data.loc_ni_lock);
+    loc_eng_ni_data.notif_in_progress = FALSE;
+    loc_eng_ni_data.response_time_left = 0;
+    loc_eng_ni_data.current_notif_id = -1;
+    pthread_mutex_unlock(&loc_eng_ni_data.loc_ni_lock);
+
+    return 0;
+}
+
+/*===========================================================================
+
+FUNCTION loc_eng_ni_callback
+
+DESCRIPTION
+   Loc API callback handler
+
+RETURN VALUE
+   error code (0 for success)
+
+===========================================================================*/
+int loc_eng_ni_callback (
+      rpc_loc_event_mask_type               loc_event,              /* event mask           */
+      const rpc_loc_event_payload_u_type*   loc_event_payload       /* payload              */
+)
+{
+    int rc = 0;
+    const rpc_loc_ni_event_s_type *ni_req = &loc_event_payload->rpc_loc_event_payload_u_type_u.ni_request;
+    if (loc_event == RPC_LOC_EVENT_NI_NOTIFY_VERIFY_REQUEST)
+    {
+        switch (ni_req->event)
+        {
+            case RPC_LOC_NI_EVENT_VX_NOTIFY_VERIFY_REQ:
+                LOGI("VX Notification");
+                loc_ni_request_handler("VX Notify", ni_req);
+                break;
+
+            case RPC_LOC_NI_EVENT_UMTS_CP_NOTIFY_VERIFY_REQ:
+                LOGI("UMTS CP Notification\n");
+                loc_ni_request_handler("UMTS CP Notify", ni_req);
+                break;
+
+            case RPC_LOC_NI_EVENT_SUPL_NOTIFY_VERIFY_REQ:
+                LOGI("SUPL Notification\n");
+                loc_ni_request_handler("SUPL Notify", ni_req);
+                break;
+
+            default:
+                LOGE("Unknown NI event: %x\n", (int) ni_req->event);
+                break;
+        }
+    }
+    return rc;
+}
+
+/*===========================================================================
+
+FUNCTION loc_ni_thread_proc
+
+===========================================================================*/
+static void loc_ni_thread_proc(void *unused)
+{
+    LOGI("Starting Loc NI thread...\n");
+
+    while (1)
+    {
+        /* wakes up every second to check timed out requests */
+        sleep(1);
+
+        pthread_mutex_lock(&loc_eng_ni_data.loc_ni_lock);
+
+        if (loc_eng_ni_data.notif_in_progress && loc_eng_ni_data.response_time_left > 0)
+        {
+            loc_eng_ni_data.response_time_left--;
+            if (loc_eng_ni_data.response_time_left <= 0)
+            {
+                loc_ni_respond(RPC_LOC_NI_LCS_NOTIFY_VERIFY_NORESP, &loc_eng_ni_data.loc_ni_request);
+                loc_eng_ni_data.notif_in_progress = FALSE;
+            }
+        }
+
+        pthread_mutex_unlock(&loc_eng_ni_data.loc_ni_lock);
+    } /* while (1) */
+}
+
+/*===========================================================================
+FUNCTION    loc_eng_ni_init
+
+DESCRIPTION
+   This function initializes the NI interface
+
+DEPENDENCIES
+   NONE
+
+RETURN VALUE
+   None
+
+SIDE EFFECTS
+   N/A
+
+===========================================================================*/
+void loc_eng_ni_init(GpsNiCallbacks *callbacks)
+{
+    LOGD("loc_eng_ni_init: entered.");
+
+    if (!loc_eng_ni_data_init)
+    {
+        pthread_mutex_init(&loc_eng_ni_data.loc_ni_lock, NULL);
+        callbacks->create_thread_cb("loc_api_ni", loc_ni_thread_proc, NULL);
+        loc_eng_ni_data_init = TRUE;
+    }
+
+    loc_eng_ni_data.notif_in_progress = FALSE;
+    loc_eng_ni_data.current_notif_id = -1;
+    loc_eng_ni_data.response_time_left = 0;
+
+    srand(time(NULL));
+    loc_eng_data.ni_notify_cb = callbacks->notify_cb;
+}
+
+/*===========================================================================
+FUNCTION    loc_eng_ni_respond
+
+DESCRIPTION
+   This function sends an NI respond to the modem processor
+
+DEPENDENCIES
+   NONE
+
+RETURN VALUE
+   None
+
+SIDE EFFECTS
+   N/A
+
+===========================================================================*/
+void loc_eng_ni_respond(int notif_id, GpsUserResponseType user_response)
+{
+    if (notif_id == loc_eng_ni_data.current_notif_id && loc_eng_ni_data.notif_in_progress)
+    {
+        LOGI("loc_eng_ni_respond: send user response %d for notif %d", user_response, notif_id);
+        loc_ni_process_user_response(user_response);
+    } else {
+        LOGE("loc_eng_ni_respond: notif_id %d mismatch or notification not in progress, response: %d",
+            notif_id, user_response);
+    }
+}
diff --git a/loc_api/libloc_api/loc_eng_ni.h b/loc_api/libloc_api/loc_eng_ni.h
new file mode 100644
index 0000000..cfd2ab1
--- /dev/null
+++ b/loc_api/libloc_api/loc_eng_ni.h
@@ -0,0 +1,56 @@
+/* Copyright (c) 2009,2011 The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.
+ *     * Neither the name of The Linux Foundation nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef LOC_ENG_NI_H
+#define LOC_ENG_NI_H
+
+#include <hardware/gps.h>
+
+#define LOC_NI_NO_RESPONSE_TIME            20                      /* secs */
+
+extern const GpsNiInterface sLocEngNiInterface;
+
+typedef struct {
+    pthread_mutex_t         loc_ni_lock;
+    int                     response_time_left;       /* examine time for NI response */
+    boolean                 notif_in_progress;        /* NI notification/verification in progress */
+    rpc_loc_ni_event_s_type loc_ni_request;
+    int                     current_notif_id;         /* ID to check against response */
+} loc_eng_ni_data_s_type;
+
+// Functions for sLocEngNiInterface
+extern void loc_eng_ni_init(GpsNiCallbacks *callbacks);
+extern void loc_eng_ni_respond(int notif_id, GpsUserResponseType user_response);
+
+extern int loc_eng_ni_callback (
+        rpc_loc_event_mask_type               loc_event,              /* event mask           */
+        const rpc_loc_event_payload_u_type*   loc_event_payload       /* payload              */
+);
+
+#endif /* LOC_ENG_NI_H */
diff --git a/loc_api/libloc_api/loc_eng_xtra.cpp b/loc_api/libloc_api/loc_eng_xtra.cpp
new file mode 100644
index 0000000..0c3e476
--- /dev/null
+++ b/loc_api/libloc_api/loc_eng_xtra.cpp
@@ -0,0 +1,180 @@
+/* Copyright (c) 2009,2011 The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.
+ *     * Neither the name of The Linux Foundation nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#define LOG_NDDEBUG 0
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <ctype.h>
+#include <errno.h>
+#include <math.h>
+#include <pthread.h>
+
+#include <rpc/rpc.h>
+#include <loc_api_rpc_glue.h>
+
+#include <loc_eng.h>
+
+#define LOG_TAG "lib_locapi"
+#include <utils/Log.h>
+
+// comment this out to enable logging
+// #undef LOGD
+// #define LOGD(...) {}
+
+#define LOC_XTRA_INJECT_DEFAULT_TIMEOUT (3100)
+#define XTRA_BLOCK_SIZE                 (400)
+
+static int qct_loc_eng_xtra_init (GpsXtraCallbacks* callbacks);
+static int qct_loc_eng_inject_xtra_data(char* data, int length);
+
+const GpsXtraInterface sLocEngXTRAInterface =
+{
+    sizeof(GpsXtraInterface),
+    qct_loc_eng_xtra_init,
+    qct_loc_eng_inject_xtra_data,
+};
+
+/*===========================================================================
+FUNCTION    qct_loc_eng_xtra_init
+
+DESCRIPTION
+   Initialize XTRA module.
+
+DEPENDENCIES
+   N/A
+
+RETURN VALUE
+   0: success
+
+SIDE EFFECTS
+   N/A
+
+===========================================================================*/
+static int qct_loc_eng_xtra_init (GpsXtraCallbacks* callbacks)
+{
+    rpc_loc_event_mask_type event;
+    loc_eng_xtra_data_s_type *xtra_module_data_ptr;
+
+    xtra_module_data_ptr = &(loc_eng_data.xtra_module_data);
+    xtra_module_data_ptr->download_request_cb = callbacks->download_request_cb;
+
+    return 0;
+}
+
+/*===========================================================================
+FUNCTION    qct_loc_eng_inject_xtra_data
+
+DESCRIPTION
+   Injects XTRA file into the engine. 
+
+DEPENDENCIES
+   N/A
+
+RETURN VALUE
+   0: success
+   >0: failure
+
+SIDE EFFECTS
+   N/A
+
+===========================================================================*/
+static int qct_loc_eng_inject_xtra_data(char* data, int length)
+{
+    int     rpc_ret_val = RPC_LOC_API_GENERAL_FAILURE;
+    boolean ret_val = 0;
+    int     total_parts;
+    uint8   part;
+    uint16  part_len;
+    uint16  len_injected;
+    rpc_loc_ioctl_data_u_type            ioctl_data;
+    rpc_loc_predicted_orbits_data_s_type *predicted_orbits_data_ptr;
+
+    LOGV ("qct_loc_eng_inject_xtra_data, xtra size = %d, data ptr = 0x%x\n", length, (int) data);
+
+    ioctl_data.disc = RPC_LOC_IOCTL_INJECT_PREDICTED_ORBITS_DATA;
+
+    predicted_orbits_data_ptr = &(ioctl_data.rpc_loc_ioctl_data_u_type_u.predicted_orbits_data);
+    predicted_orbits_data_ptr->format_type = RPC_LOC_PREDICTED_ORBITS_XTRA;
+    predicted_orbits_data_ptr->total_size = length;
+    total_parts = (length / XTRA_BLOCK_SIZE);
+    if ((total_parts % XTRA_BLOCK_SIZE) != 0)
+    {
+        total_parts += 1;
+    }
+    predicted_orbits_data_ptr->total_parts = total_parts;
+
+    len_injected = 0; // O bytes injected
+    // XTRA injection starts with part 1
+    for (part = 1; part <= total_parts; part++)
+    {
+        predicted_orbits_data_ptr->part = part;
+        predicted_orbits_data_ptr->part_len = XTRA_BLOCK_SIZE;
+        if (XTRA_BLOCK_SIZE > (length - len_injected))
+        {
+            predicted_orbits_data_ptr->part_len = length - len_injected;
+        }
+        predicted_orbits_data_ptr->data_ptr.data_ptr_len = predicted_orbits_data_ptr->part_len;
+        predicted_orbits_data_ptr->data_ptr.data_ptr_val = data + len_injected;
+
+        LOGV ("qct_loc_eng_inject_xtra_data, inject part = %d, len = %d, len = %d\n", predicted_orbits_data_ptr->part, predicted_orbits_data_ptr->part_len, predicted_orbits_data_ptr->data_ptr.data_ptr_len);
+        LOGV ("qct_loc_eng_inject_xtra_data, total part = %d, len = %d \n", predicted_orbits_data_ptr->part, predicted_orbits_data_ptr->part_len);
+
+        if (part < total_parts)
+        {
+            // No callback in this case
+            rpc_ret_val = loc_ioctl (loc_eng_data.client_handle,
+                                  RPC_LOC_IOCTL_INJECT_PREDICTED_ORBITS_DATA,
+                                  &ioctl_data);
+
+            if (rpc_ret_val != RPC_LOC_API_SUCCESS)
+            {
+                LOGE ("loc_ioctl for xtra returned %d \n", rpc_ret_val);
+                ret_val = EINVAL; // return error
+                break;
+            }
+        }
+        else // part == total_parts
+        {
+            // Last part injection, will need to wait for callback
+            ret_val = loc_eng_ioctl (loc_eng_data.client_handle,
+                                  RPC_LOC_IOCTL_INJECT_PREDICTED_ORBITS_DATA,
+                                  &ioctl_data,
+                                  LOC_XTRA_INJECT_DEFAULT_TIMEOUT,
+                                  NULL /* No output information is expected*/);
+            break; // done with injection
+        }
+
+        len_injected += predicted_orbits_data_ptr->part_len;
+        LOGV ("loc_ioctl for xtra len injected %d \n", len_injected);
+    }
+
+    return ret_val;
+}
diff --git a/core/LocAdapterProxyBase.h b/loc_api/libloc_api/loc_eng_xtra.h
index 25af10b..a72b152 100644
--- a/core/LocAdapterProxyBase.h
+++ b/loc_api/libloc_api/loc_eng_xtra.h
@@ -1,4 +1,4 @@
-/* Copyright (c) 2014 The Linux Foundation. All rights reserved.
+/* Copyright (c) 2009,2011 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
@@ -9,7 +9,7 @@
  *       copyright notice, this list of conditions and the following
  *       disclaimer in the documentation and/or other materials provided
  *       with the distribution.
- *     * Neither the name of The Linux Foundation, nor the names of its
+ *     * Neither the name of The Linux Foundation nor the names of its
  *       contributors may be used to endorse or promote products derived
  *       from this software without specific prior written permission.
  *
@@ -27,33 +27,19 @@
  *
  */
 
-#ifndef LOC_ADAPTER_PROXY_BASE_H
-#define LOC_ADAPTER_PROXY_BASE_H
+#ifndef LOC_ENG_XTRA_H
+#define LOC_ENG_XTRA_H
 
-#include <ContextBase.h>
-#include <gps_extended.h>
+#include <hardware/gps.h>
 
-namespace loc_core {
+extern const GpsXtraInterface sLocEngXTRAInterface;
 
-class LocAdapterProxyBase {
-private:
-    const LocAdapterBase *mLocAdapterBase;
-protected:
-    inline LocAdapterProxyBase(const LOC_API_ADAPTER_EVENT_MASK_T mask,
-                   ContextBase* context):
-                   mLocAdapterBase(new LocAdapterBase(mask, context, this)) {
-    }
-    inline virtual ~LocAdapterProxyBase() {
-        delete mLocAdapterBase;
-    }
-    ContextBase* getContext() const {
-        return mLocAdapterBase->getContext();
-    }
-public:
-    inline virtual void handleEngineUpEvent() {};
-    inline virtual void handleEngineDownEvent() {};
-};
+// Module data
+typedef struct
+{
+    // loc_eng_ioctl_cb_data_s_type   ioctl_cb_data;
+    gps_xtra_download_request      download_request_cb;
 
-} // namespace loc_core
+} loc_eng_xtra_data_s_type;
 
-#endif //LOC_ADAPTER_PROXY_BASE_H
+#endif // LOC_ENG_XTRA_H
diff --git a/loc_api/libloc_api_50001/Android.mk b/loc_api/libloc_api_50001/Android.mk
index 8f5d389..a1488a0 100644
--- a/loc_api/libloc_api_50001/Android.mk
+++ b/loc_api/libloc_api_50001/Android.mk
@@ -74,8 +74,7 @@ LOCAL_SHARED_LIBRARIES := \
     libloc_eng \
     libloc_core \
     libgps.utils \
-    libdl \
-    libmdmdetect
+    libdl
 
 LOCAL_SRC_FILES += \
     loc.cpp \
@@ -92,8 +91,7 @@ endif
 ## Includes
 LOCAL_C_INCLUDES:= \
     $(TARGET_OUT_HEADERS)/gps.utils \
-    $(TARGET_OUT_HEADERS)/libloc_core \
-    $(TARGET_OUT_HEADERS)/libmdmdetect/inc
+    $(TARGET_OUT_HEADERS)/libloc_core
 
 LOCAL_PRELINK_MODULE := false
 LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/hw
diff --git a/loc_api/libloc_api_50001/LocEngAdapter.cpp b/loc_api/libloc_api_50001/LocEngAdapter.cpp
index 1e6e4e1..116a8ae 100644
--- a/loc_api/libloc_api_50001/LocEngAdapter.cpp
+++ b/loc_api/libloc_api_50001/LocEngAdapter.cpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2011-2014, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2011-2013, 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
@@ -49,31 +49,35 @@ void LocInternalAdapter::startFixInt() {
 void LocInternalAdapter::stopFixInt() {
     sendMsg(new LocEngStopFix(mLocEngAdapter));
 }
-void LocInternalAdapter::getZppInt() {
-    sendMsg(new LocEngGetZpp(mLocEngAdapter));
-}
+void LocInternalAdapter::setUlpProxy(UlpProxyBase* ulp) {
+    struct LocSetUlpProxy : public LocMsg {
+        LocAdapterBase* mAdapter;
+        UlpProxyBase* mUlp;
+        inline LocSetUlpProxy(LocAdapterBase* adapter, UlpProxyBase* ulp) :
+            LocMsg(), mAdapter(adapter), mUlp(ulp) {
+        }
+        virtual void proc() const {
+            LOC_LOGV("%s] ulp %p adapter %p", __func__,
+                     mUlp, mAdapter);
+            mAdapter->setUlpProxy(mUlp);
+        }
+    };
 
-void LocInternalAdapter::shutdown() {
-    sendMsg(new LocEngShutdown(mLocEngAdapter));
+    sendMsg(new LocSetUlpProxy(mLocEngAdapter, ulp));
 }
 
 LocEngAdapter::LocEngAdapter(LOC_API_ADAPTER_EVENT_MASK_T mask,
-                             void* owner, ContextBase* context,
+                             void* owner,
                              MsgTask::tCreate tCreator) :
     LocAdapterBase(mask,
-                   //Get the AFW context if VzW context has not already been intialized in
-                   //loc_ext
-                   context == NULL?
-                   LocDualContext::getLocFgContext(tCreator,
-                                                   LocDualContext::mLocationHalName)
-                   :context),
+                   LocDualContext::getLocFgContext(
+                         tCreator,
+                         LocDualContext::mLocationHalName)),
     mOwner(owner), mInternalAdapter(new LocInternalAdapter(this)),
     mUlp(new UlpProxyBase()), mNavigating(false),
-    mSupportsAgpsRequests(false),
-    mSupportsPositionInjection(false), mPowerVote(0)
+    mAgpsEnabled(false)
 {
     memset(&mFixCriteria, 0, sizeof(mFixCriteria));
-    mFixCriteria.mode = LOC_POSITION_MODE_INVALID;
     LOC_LOGD("LocEngAdapter created");
 }
 
@@ -84,84 +88,16 @@ LocEngAdapter::~LocEngAdapter()
     LOC_LOGV("LocEngAdapter deleted");
 }
 
-void LocInternalAdapter::setUlpProxy(UlpProxyBase* ulp) {
-    struct LocSetUlpProxy : public LocMsg {
-        LocAdapterBase* mAdapter;
-        UlpProxyBase* mUlp;
-        inline LocSetUlpProxy(LocAdapterBase* adapter, UlpProxyBase* ulp) :
-            LocMsg(), mAdapter(adapter), mUlp(ulp) {
-        }
-        virtual void proc() const {
-            LOC_LOGV("%s] ulp %p adapter %p", __func__,
-                     mUlp, mAdapter);
-            mAdapter->setUlpProxy(mUlp);
-        }
-    };
-
-    sendMsg(new LocSetUlpProxy(mLocEngAdapter, ulp));
-}
-
 void LocEngAdapter::setUlpProxy(UlpProxyBase* ulp)
 {
-    if (ulp == mUlp) {
-        //This takes care of the case when double initalization happens
-        //and we get the same object back for UlpProxyBase . Do nothing
-        return;
-    }
-
+    delete mUlp;
     LOC_LOGV("%s] %p", __func__, ulp);
     if (NULL == ulp) {
-        LOC_LOGE("%s:%d]: ulp pointer is NULL", __func__, __LINE__);
         ulp = new UlpProxyBase();
     }
-
-    if (LOC_POSITION_MODE_INVALID != mUlp->mPosMode.mode) {
-        // need to send this mode and start msg to ULP
-        ulp->sendFixMode(mUlp->mPosMode);
-    }
-
-    if(mUlp->mFixSet) {
-        ulp->sendStartFix();
-    }
-
-    delete mUlp;
     mUlp = ulp;
 }
 
-void LocEngAdapter::requestPowerVote()
-{
-    struct LocEngAdapterVotePower : public LocMsg {
-        LocEngAdapter* mAdapter;
-        const bool mPowerUp;
-        inline LocEngAdapterVotePower(LocEngAdapter* adapter, bool powerUp) :
-            LocMsg(), mAdapter(adapter), mPowerUp(powerUp)
-        {
-            locallog();
-        }
-        inline virtual void proc() const {
-            /* Power voting without engine lock:
-             * 101: vote down, 102-104 - vote up
-             * These codes are used not to confuse with actual engine lock
-             * functionality, that can't be used in SSR scenario, as it
-             * conflicts with initialization sequence.
-             */
-            int mode = mPowerUp ? 103 : 101;
-            mAdapter->setGpsLock(mode);
-        }
-        inline  void locallog() const {
-            LOC_LOGV("LocEngAdapterVotePower - Vote Power: %d",
-                     (int)mPowerUp);
-        }
-        inline virtual void log() const {
-            locallog();
-        }
-    };
-
-    if (getPowerVoteRight()) {
-        sendMsg(new LocEngAdapterVotePower(this, getPowerVote()));
-    }
-}
-
 void LocInternalAdapter::reportPosition(UlpLocation &location,
                                         GpsLocationExtended &locationExtended,
                                         void* locationExt,
@@ -216,25 +152,10 @@ void LocEngAdapter::reportSv(GpsSvStatus &svStatus,
     }
 }
 
-void LocEngAdapter::setInSession(bool inSession)
-{
-    mNavigating = inSession;
-    mLocApi->setInSession(inSession);
-    if (!mNavigating) {
-        mFixCriteria.mode = LOC_POSITION_MODE_INVALID;
-    }
-}
-
-void LocInternalAdapter::reportStatus(GpsStatusValue status)
-{
-    sendMsg(new LocEngReportStatus(mLocEngAdapter, status));
-}
-
+inline
 void LocEngAdapter::reportStatus(GpsStatusValue status)
 {
-    if (!mUlp->reportStatus(status)) {
-        mInternalAdapter->reportStatus(status);
-    }
+    sendMsg(new LocEngReportStatus(mOwner, status));
 }
 
 inline
@@ -249,84 +170,81 @@ bool LocEngAdapter::reportXtraServer(const char* url1,
                                         const char* url3,
                                         const int maxlength)
 {
-    if (mSupportsAgpsRequests) {
+    if (mAgpsEnabled) {
         sendMsg(new LocEngReportXtraServer(mOwner, url1,
                                            url2, url3, maxlength));
     }
-    return mSupportsAgpsRequests;
+    return mAgpsEnabled;
 }
 
 inline
 bool LocEngAdapter::requestATL(int connHandle, AGpsType agps_type)
 {
-    if (mSupportsAgpsRequests) {
+    if (mAgpsEnabled) {
         sendMsg(new LocEngRequestATL(mOwner,
                                      connHandle, agps_type));
     }
-    return mSupportsAgpsRequests;
+    return mAgpsEnabled;
 }
 
 inline
 bool LocEngAdapter::releaseATL(int connHandle)
 {
-    if (mSupportsAgpsRequests) {
+    if (mAgpsEnabled) {
         sendMsg(new LocEngReleaseATL(mOwner, connHandle));
     }
-    return mSupportsAgpsRequests;
+    return mAgpsEnabled;
 }
 
 inline
 bool LocEngAdapter::requestXtraData()
 {
-    if (mSupportsAgpsRequests) {
+    if (mAgpsEnabled) {
         sendMsg(new LocEngRequestXtra(mOwner));
     }
-    return mSupportsAgpsRequests;
+    return mAgpsEnabled;
 }
 
 inline
 bool LocEngAdapter::requestTime()
 {
-    if (mSupportsAgpsRequests) {
+    if (mAgpsEnabled) {
         sendMsg(new LocEngRequestTime(mOwner));
     }
-    return mSupportsAgpsRequests;
+    return mAgpsEnabled;
 }
 
 inline
 bool LocEngAdapter::requestNiNotify(GpsNiNotification &notif, const void* data)
 {
-    if (mSupportsAgpsRequests) {
+    if (mAgpsEnabled) {
         notif.size = sizeof(notif);
         notif.timeout = LOC_NI_NO_RESPONSE_TIME;
 
         sendMsg(new LocEngRequestNi(mOwner, notif, data));
     }
-    return mSupportsAgpsRequests;
+    return mAgpsEnabled;
 }
 
 inline
 bool LocEngAdapter::requestSuplES(int connHandle)
 {
-    if (mSupportsAgpsRequests)
-        sendMsg(new LocEngRequestSuplEs(mOwner, connHandle));
-    return mSupportsAgpsRequests;
+    sendMsg(new LocEngRequestSuplEs(mOwner, connHandle));
+    return true;
 }
 
 inline
 bool LocEngAdapter::reportDataCallOpened()
 {
-    if(mSupportsAgpsRequests)
-        sendMsg(new LocEngSuplEsOpened(mOwner));
-    return mSupportsAgpsRequests;
+    sendMsg(new LocEngSuplEsOpened(mOwner));
+    return true;
 }
 
 inline
 bool LocEngAdapter::reportDataCallClosed()
 {
-    if(mSupportsAgpsRequests)
-        sendMsg(new LocEngSuplEsClosed(mOwner));
-    return mSupportsAgpsRequests;
+    sendMsg(new LocEngSuplEsClosed(mOwner));
+    return true;
 }
 
 inline
diff --git a/loc_api/libloc_api_50001/LocEngAdapter.h b/loc_api/libloc_api_50001/LocEngAdapter.h
index 93f3dc2..6ad3ba9 100644
--- a/loc_api/libloc_api_50001/LocEngAdapter.h
+++ b/loc_api/libloc_api_50001/LocEngAdapter.h
@@ -1,4 +1,4 @@
-/* Copyright (c) 2011-2014, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2011-2013, 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
@@ -58,13 +58,10 @@ public:
     virtual void reportSv(GpsSvStatus &svStatus,
                           GpsLocationExtended &locationExtended,
                           void* svExt);
-    virtual void reportStatus(GpsStatusValue status);
     virtual void setPositionModeInt(LocPosMode& posMode);
     virtual void startFixInt();
     virtual void stopFixInt();
-    virtual void getZppInt();
     virtual void setUlpProxy(UlpProxyBase* ulp);
-    virtual void shutdown();
 };
 
 typedef void (*loc_msg_sender)(void* loc_eng_data_p, void* msgp);
@@ -75,19 +72,12 @@ class LocEngAdapter : public LocAdapterBase {
     UlpProxyBase* mUlp;
     LocPosMode mFixCriteria;
     bool mNavigating;
-    // mPowerVote is encoded as
-    // mPowerVote & 0x20 -- powerVoteRight
-    // mPowerVote & 0x10 -- power On / Off
-    unsigned int mPowerVote;
-    static const unsigned int POWER_VOTE_RIGHT = 0x20;
-    static const unsigned int POWER_VOTE_VALUE = 0x10;
 
 public:
-    bool mSupportsAgpsRequests;
-    bool mSupportsPositionInjection;
+    bool mAgpsEnabled;
 
     LocEngAdapter(LOC_API_ADAPTER_EVENT_MASK_T mask,
-                  void* owner, ContextBase* context,
+                  void* owner,
                   MsgTask::tCreate tCreator);
     virtual ~LocEngAdapter();
 
@@ -98,12 +88,7 @@ public:
     inline LocInternalAdapter* getInternalAdapter() { return mInternalAdapter; }
     inline UlpProxyBase* getUlpProxy() { return mUlp; }
     inline void* getOwner() { return mOwner; }
-    inline bool hasAgpsExtendedCapabilities() {
-        return mContext->hasAgpsExtendedCapabilities();
-    }
-    inline bool hasCPIExtendedCapabilities() {
-        return mContext->hasCPIExtendedCapabilities();
-    }
+    inline bool hasAgpsExt() { return mContext->hasAgpsExt(); }
     inline const MsgTask* getMsgTask() { return mMsgTask; }
 
     inline enum loc_api_adapter_err
@@ -196,9 +181,9 @@ public:
         return mLocApi->setLPPConfig(profile);
     }
     inline enum loc_api_adapter_err
-        setSensorControlConfig(int sensorUsage, int sensorProvider)
+        setSensorControlConfig(int sensorUsage)
     {
-        return mLocApi->setSensorControlConfig(sensorUsage, sensorProvider);
+        return mLocApi->setSensorControlConfig(sensorUsage);
     }
     inline enum loc_api_adapter_err
         setSensorProperties(bool gyroBiasVarianceRandomWalk_valid, float gyroBiasVarianceRandomWalk,
@@ -251,11 +236,6 @@ public:
     {
         mLocApi->closeDataCall();
     }
-    inline enum loc_api_adapter_err
-        getZpp(GpsLocation &zppLoc, LocPosTechMask &tech_mask)
-    {
-        return mLocApi->getBestAvailableZppFix(zppLoc, tech_mask);
-    }
 
     virtual void handleEngineDownEvent();
     virtual void handleEngineUpEvent();
@@ -284,47 +264,8 @@ public:
     {return mFixCriteria;}
     inline virtual bool isInSession()
     { return mNavigating; }
-    void setInSession(bool inSession);
-
-    // Permit/prohibit power voting
-    inline void setPowerVoteRight(bool powerVoteRight) {
-        mPowerVote = powerVoteRight ? (mPowerVote | POWER_VOTE_RIGHT) :
-                                      (mPowerVote & ~POWER_VOTE_RIGHT);
-    }
-    inline bool getPowerVoteRight() const {
-        return (mPowerVote & POWER_VOTE_RIGHT) != 0 ;
-    }
-    // Set the power voting up/down and do actual operation if permitted
-    inline void setPowerVote(bool powerOn) {
-        mPowerVote = powerOn ? (mPowerVote | POWER_VOTE_VALUE) :
-                               (mPowerVote & ~POWER_VOTE_VALUE);
-        requestPowerVote();
-    }
-    inline bool getPowerVote() const {
-        return (mPowerVote & POWER_VOTE_VALUE) != 0 ;
-    }
-    // Do power voting according to last settings if permitted
-    void requestPowerVote();
-
-    /*Values for lock
-      1 = Do not lock any position sessions
-      2 = Lock MI position sessions
-      3 = Lock MT position sessions
-      4 = Lock all position sessions
-    */
-    inline int setGpsLock(unsigned int lock)
-    {
-        return mLocApi->setGpsLock(lock);
-    }
-    /*
-      Returns
-      Current value of GPS lock on success
-      -1 on failure
-     */
-    inline int getGpsLock()
-    {
-        return mLocApi->getGpsLock();
-    }
+    inline void setInSession(bool inSession)
+    { mNavigating = inSession; mLocApi->setInSession(inSession); }
 };
 
 #endif //LOC_API_ENG_ADAPTER_H
diff --git a/loc_api/libloc_api_50001/gps.c b/loc_api/libloc_api_50001/gps.c
index b0669af..82bc742 100644
--- a/loc_api/libloc_api_50001/gps.c
+++ b/loc_api/libloc_api_50001/gps.c
@@ -42,10 +42,6 @@ static int open_gps(const struct hw_module_t* module, char const* name,
         struct hw_device_t** device)
 {
     struct gps_device_t *dev = (struct gps_device_t *) malloc(sizeof(struct gps_device_t));
-
-    if(dev == NULL)
-        return -1;
-
     memset(dev, 0, sizeof(*dev));
 
     dev->common.tag = HARDWARE_DEVICE_TAG;
diff --git a/loc_api/libloc_api_50001/loc.cpp b/loc_api/libloc_api_50001/loc.cpp
index ac65d25..f765966 100644
--- a/loc_api/libloc_api_50001/loc.cpp
+++ b/loc_api/libloc_api_50001/loc.cpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2011-2014, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2011-2013, 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
@@ -44,13 +44,7 @@
 #include <errno.h>
 #include <LocDualContext.h>
 #include <cutils/properties.h>
-#ifdef __cplusplus
-extern "C" {
-#endif /* __cplusplus */
-#include <mdm_detect.h>
-#ifdef __cplusplus
-}
-#endif /* __cplusplus */
+
 using namespace loc_core;
 
 //Globals defns
@@ -74,7 +68,7 @@ static int  loc_set_position_mode(GpsPositionMode mode, GpsPositionRecurrence re
                                   uint32_t min_interval, uint32_t preferred_accuracy,
                                   uint32_t preferred_time);
 static const void* loc_get_extension(const char* name);
-static void loc_close_mdm_node();
+
 // Defines the GpsInterface in gps.h
 static const GpsInterface sLocEngInterface =
 {
@@ -127,9 +121,6 @@ const GpsNiInterface sLocEngNiInterface =
    loc_ni_respond,
 };
 
-// For shutting down MDM in fusion devices
-static int mdm_fd = -1;
-
 static void loc_agps_ril_init( AGpsRilCallbacks* callbacks );
 static void loc_agps_ril_set_ref_location(const AGpsRefLocation *agps_reflocation, size_t sz_struct);
 static void loc_agps_ril_set_set_id(AGpsSetIDType type, const char* setid);
@@ -149,7 +140,7 @@ static const AGpsRilInterface sLocEngAGpsRilInterface =
 };
 
 static loc_eng_data_s_type loc_afw_data;
-static int gss_fd = -1;
+static int gss_fd = 0;
 
 /*===========================================================================
 FUNCTION    gps_get_hardware_interface
@@ -199,14 +190,10 @@ extern "C" const GpsInterface* get_gps_interface()
     unsigned int target = TARGET_DEFAULT;
     loc_eng_read_config();
 
-    target = loc_get_target();
+    target = get_target();
     LOC_LOGD("Target name check returned %s", loc_get_target_name(target));
-
-    int gnssType = getTargetGnssType(target);
-    switch (gnssType)
-    {
-    case GNSS_GSS:
         //APQ8064
+        if( getTargetGnssType(target) == GNSS_GSS ) {
         gps_conf.CAPABILITIES &= ~(GPS_CAPABILITY_MSA | GPS_CAPABILITY_MSB);
         gss_fd = open("/dev/gss", O_RDONLY);
         if (gss_fd < 0) {
@@ -216,16 +203,11 @@ extern "C" const GpsInterface* get_gps_interface()
             LOC_LOGD("GSS open success! CAPABILITIES %0lx\n",
                      gps_conf.CAPABILITIES);
         }
-        break;
-    case GNSS_NONE:
-        //MPQ8064
-        LOC_LOGE("No GPS HW on this target. Not returning interface.");
+    }
+    //MPQ8064
+        else if( getTargetGnssType(target) == GNSS_NONE) {
+        LOC_LOGE("No GPS HW on this target (MPQ8064). Not returning interface");
         return NULL;
-    case GNSS_QCA1530:
-        // qca1530 chip is present
-        gps_conf.CAPABILITIES &= ~(GPS_CAPABILITY_MSA | GPS_CAPABILITY_MSB);
-        LOC_LOGD("qca1530 present: CAPABILITIES %0lx\n", gps_conf.CAPABILITIES);
-        break;
     }
     return &sLocEngInterface;
 }
@@ -250,7 +232,6 @@ SIDE EFFECTS
 static int loc_init(GpsCallbacks* callbacks)
 {
     int retVal = -1;
-    int i = 0;
     ENTRY_LOG();
     LOC_API_ADAPTER_EVENT_MASK_T event;
 
@@ -279,93 +260,21 @@ static int loc_init(GpsCallbacks* callbacks)
                                     callbacks->create_thread_cb, /* create_thread_cb */
                                     NULL, /* location_ext_parser */
                                     NULL, /* sv_ext_parser */
-                                    callbacks->request_utc_time_cb, /* request_utc_time_cb */
-                                    loc_close_mdm_node  /*loc_shutdown_cb*/};
+                                    callbacks->request_utc_time_cb /* request_utc_time_cb */};
 
     gps_loc_cb = callbacks->location_cb;
     gps_sv_cb = callbacks->sv_status_cb;
 
-    retVal = loc_eng_init(loc_afw_data, &clientCallbacks, event, NULL);
+    retVal = loc_eng_init(loc_afw_data, &clientCallbacks, event);
     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();
-
-    if(retVal) {
-        LOC_LOGE("loc_eng_init() fail!");
-        goto err;
-    }
+    loc_afw_data.adapter->mAgpsEnabled = !loc_afw_data.adapter->hasAgpsExt();
 
-    loc_afw_data.adapter->setPowerVoteRight(loc_get_target() == TARGET_QCA1530);
-    loc_afw_data.adapter->setPowerVote(true);
-
-    LOC_LOGD("loc_eng_init() success!");
-    if (mdm_fd < 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;
-        }
-        for(i=0; i<modem_info.num_modems; i++) {
-            if((modem_info.mdm_list[i].type == MDM_TYPE_EXTERNAL) &&
-               (modem_info.mdm_list[i].powerup_node)) {
-                LOC_LOGD("%s:%d]: powerup_node: %s", __func__, __LINE__,
-                         modem_info.mdm_list[i].powerup_node);
-                mdm_fd = open(modem_info.mdm_list[i].powerup_node, O_RDONLY);
-                if (mdm_fd < 0) {
-                    LOC_LOGE("Error: %s open failed: %s\n",
-                             modem_info.mdm_list[i].powerup_node, strerror(errno));
-                } else {
-                    LOC_LOGD("%s opens success!", modem_info.mdm_list[i].powerup_node);
-                }
-            }
-            else {
-                LOC_LOGD("%s:%d]: powerup_node not present in mdm %d",
-                         __func__, __LINE__, i);
-            }
-        }
-    } else {
-        LOC_LOGD("powerup_node has been opened before");
-    }
 
-err:
     EXIT_LOG(%d, retVal);
     return retVal;
 }
 
 /*===========================================================================
-FUNCTION    loc_close_mdm_node
-
-DESCRIPTION
-   closes mdm_fd which is the modem powerup node obtained in loc_init
-
-DEPENDENCIES
-   None
-
-RETURN VALUE
-   None
-
-SIDE EFFECTS
-   N/A
-
-===========================================================================*/
-static void loc_close_mdm_node()
-{
-    ENTRY_LOG();
-    if (mdm_fd >= 0) {
-        LOC_LOGD("closing the powerup node");
-        close(mdm_fd);
-        mdm_fd = -1;
-        LOC_LOGD("finished closing the powerup node");
-    } else {
-        LOC_LOGD("powerup node has not been opened yet.");
-    }
-
-    EXIT_LOG(%s, VOID_RET);
-}
-
-/*===========================================================================
 FUNCTION    loc_cleanup
 
 DESCRIPTION
@@ -384,14 +293,18 @@ SIDE EFFECTS
 static void loc_cleanup()
 {
     ENTRY_LOG();
-
-    loc_afw_data.adapter->setPowerVote(false);
-
     loc_eng_cleanup(loc_afw_data);
-    loc_close_mdm_node();
     gps_loc_cb = NULL;
     gps_sv_cb = NULL;
 
+    /*
+     * if (get_target() == TARGET_NAME_APQ8064_STANDALONE)
+     * {
+     *     close(gss_fd);
+     *     LOC_LOGD("GSS shutdown.\n");
+     * }
+     */
+
     EXIT_LOG(%s, VOID_RET);
 }
 
@@ -542,14 +455,6 @@ static int loc_inject_location(double latitude, double longitude, float accuracy
     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];
@@ -666,7 +571,19 @@ const void* loc_get_extension(const char* name)
    }
    else if (strcmp(name, AGPS_INTERFACE) == 0)
    {
-       ret_val = &sLocEngAGpsInterface;
+       //Return an interface to AGPS only if MSA or MSB capabilities
+       //are present. If the target is an APQ, these masks are
+       //cleared in get_gps_interface() and the below logic will
+       //return NULL as the interface for AGPS
+       if((gps_conf.CAPABILITIES & GPS_CAPABILITY_MSA) ||
+          (gps_conf.CAPABILITIES & GPS_CAPABILITY_MSB) ) {
+           LOC_LOGD("%s:%d]: AGPS capabilities found\n", __func__, __LINE__);
+           ret_val = &sLocEngAGpsInterface;
+       }
+       else {
+           LOC_LOGD("%s:%d]: Returning NULL AgpsInterface\n", __func__, __LINE__);
+           ret_val = NULL;
+       }
    }
    else if (strcmp(name, GPS_NI_INTERFACE) == 0)
    {
diff --git a/loc_api/libloc_api_50001/loc.h b/loc_api/libloc_api_50001/loc.h
index 7e26827..c959323 100644
--- a/loc_api/libloc_api_50001/loc.h
+++ b/loc_api/libloc_api_50001/loc.h
@@ -42,7 +42,6 @@ extern "C" {
 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);
-typedef void (*loc_shutdown_cb) (void);
 
 typedef struct {
     loc_location_cb_ext location_cb;
@@ -56,7 +55,6 @@ typedef struct {
     loc_ext_parser location_ext_parser;
     loc_ext_parser sv_ext_parser;
     gps_request_utc_time request_utc_time_cb;
-    loc_shutdown_cb shutdown_cb;
 } LocCallbacks;
 
 #ifdef __cplusplus
diff --git a/loc_api/libloc_api_50001/loc_eng.cpp b/loc_api/libloc_api_50001/loc_eng.cpp
index c336dd1..357cf63 100644
--- a/loc_api/libloc_api_50001/loc_eng.cpp
+++ b/loc_api/libloc_api_50001/loc_eng.cpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2009-2014, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2009-2013, 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
@@ -96,6 +96,7 @@ static loc_param_s_type loc_parameter_table[] =
 {
   {"INTERMEDIATE_POS",               &gps_conf.INTERMEDIATE_POS,               NULL, 'n'},
   {"ACCURACY_THRES",                 &gps_conf.ACCURACY_THRES,                 NULL, 'n'},
+  {"ENABLE_WIPER",                   &gps_conf.ENABLE_WIPER,                   NULL, 'n'},
   {"NMEA_PROVIDER",                  &gps_conf.NMEA_PROVIDER,                  NULL, 'n'},
   {"SUPL_VER",                       &gps_conf.SUPL_VER,                       NULL, 'n'},
   {"CAPABILITIES",                   &gps_conf.CAPABILITIES,                   NULL, 'n'},
@@ -115,9 +116,9 @@ static loc_param_s_type loc_parameter_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'},
+  {"QUIPC_ENABLED",                  &gps_conf.QUIPC_ENABLED,                  NULL, 'n'},
   {"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'},
 };
 
 static void loc_default_parameters(void)
@@ -125,6 +126,7 @@ static void loc_default_parameters(void)
    /* defaults */
    gps_conf.INTERMEDIATE_POS = 0;
    gps_conf.ACCURACY_THRES = 0;
+   gps_conf.ENABLE_WIPER = 0;
    gps_conf.NMEA_PROVIDER = 0;
    gps_conf.SUPL_VER = 0x10000;
    gps_conf.CAPABILITIES = 0x7;
@@ -160,9 +162,6 @@ static void loc_default_parameters(void)
 
    /*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;
 }
 
 // 2nd half of init(), singled out for
@@ -185,12 +184,11 @@ static void loc_eng_handle_engine_up(loc_eng_data_s_type &loc_eng_data) ;
 
 static int loc_eng_start_handler(loc_eng_data_s_type &loc_eng_data);
 static int loc_eng_stop_handler(loc_eng_data_s_type &loc_eng_data);
-static int loc_eng_get_zpp_handler(loc_eng_data_s_type &loc_eng_data);
-static void loc_eng_handle_shutdown(loc_eng_data_s_type &loc_eng_data);
+
 static void deleteAidingData(loc_eng_data_s_type &logEng);
 static AgpsStateMachine*
 getAgpsStateMachine(loc_eng_data_s_type& logEng, AGpsExtType agpsType);
-static int dataCallCb(void *cb_data);
+
 static void update_aiding_data_for_deletion(loc_eng_data_s_type& loc_eng_data) {
     if (loc_eng_data.engine_status != GPS_STATUS_ENGINE_ON &&
         loc_eng_data.aiding_data_for_deletion != 0)
@@ -304,49 +302,6 @@ void LocEngPositionMode::send() const {
     mAdapter->sendMsg(this);
 }
 
-LocEngGetZpp::LocEngGetZpp(LocEngAdapter* adapter) :
-    LocMsg(), mAdapter(adapter)
-{
-    locallog();
-}
-inline void LocEngGetZpp::proc() const
-{
-    loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mAdapter->getOwner();
-    loc_eng_get_zpp_handler(*locEng);
-}
-inline void LocEngGetZpp::locallog() const
-{
-    LOC_LOGV("LocEngGetZpp");
-}
-inline void LocEngGetZpp::log() const
-{
-    locallog();
-}
-void LocEngGetZpp::send() const {
-    mAdapter->sendMsg(this);
-}
-
-
-LocEngShutdown::LocEngShutdown(LocEngAdapter* adapter) :
-    LocMsg(), mAdapter(adapter)
-{
-    locallog();
-}
-inline void LocEngShutdown::proc() const
-{
-    loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mAdapter->getOwner();
-    LOC_LOGD("%s:%d]: Calling loc_eng_handle_shutdown", __func__, __LINE__);
-    loc_eng_handle_shutdown(*locEng);
-}
-inline void LocEngShutdown::locallog() const
-{
-    LOC_LOGV("LocEngShutdown");
-}
-inline void LocEngShutdown::log() const
-{
-    locallog();
-}
-
 //        case LOC_ENG_MSG_SET_TIME:
 struct LocEngSetTime : public LocMsg {
     LocEngAdapter* mAdapter;
@@ -521,20 +476,18 @@ struct LocEngLppConfig : public LocMsg {
 struct LocEngSensorControlConfig : public LocMsg {
     LocEngAdapter* mAdapter;
     const int mSensorsDisabled;
-    const int mSensorProvider;
     inline LocEngSensorControlConfig(LocEngAdapter* adapter,
-                                     int sensorsDisabled, int sensorProvider) :
-        LocMsg(), mAdapter(adapter), mSensorsDisabled(sensorsDisabled),
-        mSensorProvider(sensorProvider)
+                                     int sensorsDisabled) :
+        LocMsg(), mAdapter(adapter), mSensorsDisabled(sensorsDisabled)
     {
         locallog();
     }
     inline virtual void proc() const {
-        mAdapter->setSensorControlConfig(mSensorsDisabled, mSensorProvider);
+        mAdapter->setSensorControlConfig(mSensorsDisabled);
     }
     inline  void locallog() const {
-        LOC_LOGV("LocEngSensorControlConfig - Sensors Disabled: %d, Sensor Provider: %d",
-                 mSensorsDisabled, mSensorProvider);
+        LOC_LOGV("LocEngSensorControlConfig - Sensors Disabled: %d",
+                 mSensorsDisabled);
     }
     inline virtual void log() const {
         locallog();
@@ -749,8 +702,7 @@ void LocEngReportPosition::proc() const {
             //   2.2.3 the inaccuracy exceeds our tolerance
             else if ((LOC_SESS_SUCCESS == mStatus &&
                       ((LOC_POS_TECH_MASK_SATELLITE |
-                        LOC_POS_TECH_MASK_SENSORS   |
-                        LOC_POS_TECH_MASK_HYBRID) &
+                        LOC_POS_TECH_MASK_SENSORS) &
                        mTechMask)) ||
                      (LOC_SESS_INTERMEDIATE == locEng->intermediateFix &&
                       !((mLocation.gpsLocation.flags &
@@ -779,10 +731,7 @@ void LocEngReportPosition::proc() const {
         }
 
         if (locEng->generateNmea &&
-            mLocation.position_source == ULP_LOCATION_IS_FROM_GNSS &&
-            mTechMask & (LOC_POS_TECH_MASK_SATELLITE |
-                         LOC_POS_TECH_MASK_SENSORS |
-                         LOC_POS_TECH_MASK_HYBRID))
+            mLocation.position_source == ULP_LOCATION_IS_FROM_GNSS)
         {
             unsigned char generate_nmea = reported &&
                                           (mStatus != LOC_SESS_FAILURE);
@@ -873,16 +822,15 @@ void LocEngReportSv::send() const {
 }
 
 //        case LOC_ENG_MSG_REPORT_STATUS:
-LocEngReportStatus::LocEngReportStatus(LocAdapterBase* adapter,
+LocEngReportStatus::LocEngReportStatus(void* locEng,
                                        GpsStatusValue engineStatus) :
-    LocMsg(),  mAdapter(adapter), mStatus(engineStatus)
+    LocMsg(),  mLocEng(locEng), mStatus(engineStatus)
 {
     locallog();
 }
 inline void LocEngReportStatus::proc() const
 {
-    LocEngAdapter* adapter = (LocEngAdapter*)mAdapter;
-    loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)adapter->getOwner();
+    loc_eng_data_s_type* locEng = (loc_eng_data_s_type*) mLocEng;
 
     loc_eng_report_status(*locEng, mStatus);
     update_aiding_data_for_deletion(*locEng);
@@ -909,9 +857,7 @@ void LocEngReportNmea::proc() const {
     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);
+    locEng->nmea_cb(now, mNmea, mLen);
 }
 inline void LocEngReportNmea::locallog() const {
     LOC_LOGV("LocEngReportNmea");
@@ -929,7 +875,6 @@ LocEngReportXtraServer::LocEngReportXtraServer(void* locEng,
     LocMsg(), mLocEng(locEng), mMaxLen(maxlength),
     mServers(new char[3*(mMaxLen+1)])
 {
-    memset(mServers, 0, 3*(mMaxLen+1));
     strlcpy(mServers, url1, mMaxLen);
     strlcpy(&(mServers[mMaxLen+1]), url2, mMaxLen);
     strlcpy(&(mServers[(mMaxLen+1)<<1]), url3, mMaxLen);
@@ -951,7 +896,7 @@ void LocEngReportXtraServer::proc() const {
 inline void LocEngReportXtraServer::locallog() const {
     LOC_LOGV("LocEngReportXtraServers: server1: %s\n  server2: %s\n"
              "  server3: %s\n",
-             mServers, &mServers[mMaxLen+1], &mServers[(mMaxLen+1)<<1]);
+             mServers, &mServers[mMaxLen], &mServers[mMaxLen<<1]);
 }
 inline void LocEngReportXtraServer::log() const {
     locallog();
@@ -986,10 +931,10 @@ void LocEngReqRelBIT::proc() const {
 }
 inline void LocEngReqRelBIT::locallog() const {
     LOC_LOGV("LocEngRequestBIT - ipv4: %d.%d.%d.%d, ipv6: %s",
-             (unsigned char)mIPv4Addr,
-             (unsigned char)(mIPv4Addr>>8),
-             (unsigned char)(mIPv4Addr>>16),
              (unsigned char)(mIPv4Addr>>24),
+             (unsigned char)(mIPv4Addr>>16),
+             (unsigned char)(mIPv4Addr>>8),
+             (unsigned char)mIPv4Addr,
              NULL != mIPv6Addr ? mIPv6Addr : "");
 }
 inline void LocEngReqRelBIT::log() const {
@@ -1035,10 +980,8 @@ LocEngSuplEsOpened::LocEngSuplEsOpened(void* locEng) :
 }
 void LocEngSuplEsOpened::proc() const {
     loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
-    if (locEng->ds_nif) {
-        AgpsStateMachine* sm = locEng->ds_nif;
-        sm->onRsrcEvent(RSRC_GRANTED);
-    }
+    AgpsStateMachine* sm = locEng->ds_nif;
+    sm->onRsrcEvent(RSRC_GRANTED);
 }
 void LocEngSuplEsOpened::locallog() const {
     LOC_LOGV("LocEngSuplEsOpened");
@@ -1054,450 +997,6 @@ LocEngSuplEsClosed::LocEngSuplEsClosed(void* locEng) :
 }
 void LocEngSuplEsClosed::proc() const {
     loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
-    if (locEng->ds_nif) {
-        AgpsStateMachine* sm = locEng->ds_nif;
-        sm->onRsrcEvent(RSRC_RELEASED);
-    }
-}
-void LocEngSuplEsClosed::locallog() const {
-    LOC_LOGV("LocEngSuplEsClosed");
-}
-void LocEngSuplEsClosed::log() const {
-    locallog();
-}
-
-
-//        case LOC_ENG_MSG_REQUEST_SUPL_ES:
-LocEngRequestSuplEs::LocEngRequestSuplEs(void* locEng, int id) :
-    LocMsg(), mLocEng(locEng), mID(id) {
-    locallog();
-}
-void LocEngRequestSuplEs::proc() const {
-    loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
-    if (locEng->ds_nif) {
-        AgpsStateMachine* sm = locEng->ds_nif;
-        DSSubscriber s(sm, mID);
-        sm->subscribeRsrc((Subscriber*)&s);
-    } else {
-        locEng->adapter->atlOpenStatus(mID, 0, NULL, -1, -1);
-    }
-}
-inline void LocEngRequestSuplEs::locallog() const {
-    LOC_LOGV("LocEngRequestSuplEs");
-}
-inline void LocEngRequestSuplEs::log() const {
-    locallog();
-}
-
-//        case LOC_ENG_MSG_REQUEST_ATL:
-LocEngRequestATL::LocEngRequestATL(void* locEng, int id,
-                                   AGpsExtType agps_type) :
-    LocMsg(), mLocEng(locEng), mID(id), mType(agps_type) {
-    locallog();
-}
-void LocEngRequestATL::proc() const {
-    loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
-    AgpsStateMachine* sm = (AgpsStateMachine*)
-                           getAgpsStateMachine(*locEng, mType);
-    if (sm) {
-        ATLSubscriber s(mID,
-                        sm,
-                        locEng->adapter,
-                        AGPS_TYPE_INVALID == mType);
-        sm->subscribeRsrc((Subscriber*)&s);
-    } else {
-        locEng->adapter->atlOpenStatus(mID, 0, NULL, -1, mType);
-    }
-}
-inline void LocEngRequestATL::locallog() const {
-    LOC_LOGV("LocEngRequestATL");
-}
-inline void LocEngRequestATL::log() const {
-    locallog();
-}
-
-//        case LOC_ENG_MSG_RELEASE_ATL:
-LocEngReleaseATL::LocEngReleaseATL(void* locEng, int id) :
-    LocMsg(), mLocEng(locEng), mID(id) {
-    locallog();
-}
-void LocEngReleaseATL::proc() const {
-    loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
-
-   if (locEng->agnss_nif) {
-        ATLSubscriber s1(mID, locEng->agnss_nif, locEng->adapter, false);
-        if (locEng->agnss_nif->unsubscribeRsrc((Subscriber*)&s1)) {
-            LOC_LOGD("%s:%d]: Unsubscribed from agnss_nif",
-                     __func__, __LINE__);
-            return;
-        }
-    }
-
-    if (locEng->internet_nif) {
-        ATLSubscriber s2(mID, locEng->internet_nif, locEng->adapter, false);
-        if (locEng->internet_nif->unsubscribeRsrc((Subscriber*)&s2)) {
-            LOC_LOGD("%s:%d]: Unsubscribed from internet_nif",
-                     __func__, __LINE__);
-            return;
-        }
-    }
-
-    if (locEng->ds_nif) {
-        DSSubscriber s3(locEng->ds_nif, mID);
-        if (locEng->ds_nif->unsubscribeRsrc((Subscriber*)&s3)) {
-            LOC_LOGD("%s:%d]: Unsubscribed from ds_nif",
-                     __func__, __LINE__);
-            return;
-        }
-    }
-
-    LOC_LOGW("%s:%d]: Could not release ATL. "
-             "No subscribers found\n",
-             __func__, __LINE__);
-    locEng->adapter->atlCloseStatus(mID, 0);
-}
-inline void LocEngReleaseATL::locallog() const {
-    LOC_LOGV("LocEngReleaseATL");
-}
-inline void LocEngReleaseATL::log() const {
-    locallog();
-}
-
-//        case LOC_ENG_MSG_REQUEST_WIFI:
-//        case LOC_ENG_MSG_RELEASE_WIFI:
-LocEngReqRelWifi::LocEngReqRelWifi(void* locEng, AGpsExtType type,
-                                   loc_if_req_sender_id_e_type sender_id,
-                                   char* s, char* p, bool isReq) :
-    LocMsg(), mLocEng(locEng), mType(type), mSenderId(sender_id),
-    mSSID(NULL == s ? NULL : new char[SSID_BUF_SIZE]),
-    mPassword(NULL == p ? NULL : new char[SSID_BUF_SIZE]),
-    mIsReq(isReq) {
-    if (NULL != s)
-        strlcpy(mSSID, s, SSID_BUF_SIZE);
-    if (NULL != p)
-        strlcpy(mPassword, p, SSID_BUF_SIZE);
-    locallog();
-}
-LocEngReqRelWifi::~LocEngReqRelWifi() {
-    if (NULL != mSSID) {
-        delete[] mSSID;
-    }
-    if (NULL != mPassword) {
-        delete[] mPassword;
-    }
-}
-void LocEngReqRelWifi::proc() const {
-    loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
-    if (locEng->wifi_nif) {
-        WIFISubscriber s(locEng->wifi_nif, mSSID, mPassword, mSenderId);
-        if (mIsReq) {
-            locEng->wifi_nif->subscribeRsrc((Subscriber*)&s);
-        } else {
-            locEng->wifi_nif->unsubscribeRsrc((Subscriber*)&s);
-        }
-    } else {
-        locEng->adapter->atlOpenStatus(mSenderId, 0, NULL, -1, mType);
-    }
-}
-inline void LocEngReqRelWifi::locallog() const {
-    LOC_LOGV("%s - senderId: %d, ssid: %s, password: %s",
-             mIsReq ? "LocEngRequestWifi" : "LocEngReleaseWifi",
-             mSenderId,
-             NULL != mSSID ? mSSID : "",
-             NULL != mPassword ? mPassword : "");
-}
-inline void LocEngReqRelWifi::log() const {
-    locallog();
-}
-void LocEngReqRelWifi::send() const {
-    loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
-    locEng->adapter->sendMsg(this);
-}
-
-//        case LOC_ENG_MSG_REQUEST_XTRA_DATA:
-LocEngRequestXtra::LocEngRequestXtra(void* locEng) :
-    mLocEng(locEng) {
-    locallog();
-}
-void LocEngRequestXtra::proc() const
-{
-    loc_eng_xtra_data_s_type* locEngXtra =
-        &(((loc_eng_data_s_type*)mLocEng)->xtra_module_data);
-
-    if (locEngXtra->download_request_cb != NULL) {
-        CALLBACK_LOG_CALLFLOW("download_request_cb", %p, mLocEng);
-        locEngXtra->download_request_cb();
-    } else {
-        LOC_LOGE("Callback function for request xtra is NULL");
-    }
-}
-inline void LocEngRequestXtra::locallog() const {
-    LOC_LOGV("LocEngReqXtra");
-}
-inline void LocEngRequestXtra::log() const {
-    locallog();
-}
-
-//        case LOC_ENG_MSG_REQUEST_TIME:
-LocEngRequestTime::LocEngRequestTime(void* locEng) :
-    LocMsg(), mLocEng(locEng)
-{
-    locallog();
-}
-void LocEngRequestTime::proc() const {
-    loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
-    if (gps_conf.CAPABILITIES & GPS_CAPABILITY_ON_DEMAND_TIME) {
-        if (locEng->request_utc_time_cb != NULL) {
-            locEng->request_utc_time_cb();
-        } else {
-            LOC_LOGE("Callback function for request time is NULL");
-        }
-    }
-}
-inline void LocEngRequestTime::locallog() const {
-    LOC_LOGV("LocEngReqTime");
-}
-inline void LocEngRequestTime::log() const {
-    locallog();
-}
-
-//        case LOC_ENG_MSG_DELETE_AIDING_DATA:
-struct LocEngDelAidData : public LocMsg {
-    loc_eng_data_s_type* mLocEng;
-    const GpsAidingData mType;
-    inline LocEngDelAidData(loc_eng_data_s_type* locEng,
-                            GpsAidingData f) :
-        LocMsg(), mLocEng(locEng), mType(f)
-    {
-        locallog();
-    }
-    inline virtual void proc() const {
-        mLocEng->aiding_data_for_deletion = mType;
-        update_aiding_data_for_deletion(*mLocEng);
-    }
-    inline void locallog() const {
-        LOC_LOGV("aiding data msak %d", mType);
-    }
-    virtual void log() const {
-        locallog();
-    }
-};
-
-//        case LOC_ENG_MSG_ENABLE_DATA:
-struct LocEngEnableData : public LocMsg {
-    LocEngAdapter* mAdapter;
-    const int mEnable;
-    char* mAPN;
-    const int mLen;
-    inline LocEngEnableData(LocEngAdapter* adapter,
-                            const char* name, int len, int enable) :
-        LocMsg(), mAdapter(adapter),
-        mEnable(enable), mAPN(NULL), mLen(len)
-    {
-        if (NULL != name) {
-            mAPN = new char[len+1];
-            memcpy((void*)mAPN, (void*)name, len);
-            mAPN[len] = 0;
-        }
-        locallog();
-    }
-    inline ~LocEngEnableData() {
-        if (NULL != mAPN) {
-            delete[] mAPN;
-        }
-    }
-    inline virtual void proc() const {
-        mAdapter->enableData(mEnable);
-        if (NULL != mAPN) {
-            mAdapter->setAPN(mAPN, mLen);
-        }
-    }
-    inline void locallog() const {
-        LOC_LOGV("apn: %s\n  enable: %d",
-                 (NULL == mAPN) ? "NULL" : mAPN, mEnable);
-    }
-    inline virtual void log() const {
-        locallog();
-    }
-};
-
-//        case LOC_ENG_MSG_INJECT_XTRA_DATA:
-// loc_eng_xtra.cpp
-
-//        case LOC_ENG_MSG_LOC_INIT:
-struct LocEngInit : public LocMsg {
-    loc_eng_data_s_type* mLocEng;
-    inline LocEngInit(loc_eng_data_s_type* locEng) :
-        LocMsg(), mLocEng(locEng)
-    {
-        locallog();
-    }
-    inline virtual void proc() const {
-        loc_eng_reinit(*mLocEng);
-    }
-    inline void locallog() const
-    {
-        LOC_LOGV("LocEngInit");
-    }
-    inline virtual void log() const
-    {
-        locallog();
-    }
-};
-
-//        case LOC_ENG_MSG_REQUEST_XTRA_SERVER:
-// loc_eng_xtra.cpp
-
-//        case LOC_ENG_MSG_ATL_OPEN_SUCCESS:
-struct LocEngAtlOpenSuccess : public LocMsg {
-    AgpsStateMachine* mStateMachine;
-    const int mLen;
-    char* mAPN;
-    const AGpsBearerType mBearerType;
-    inline LocEngAtlOpenSuccess(AgpsStateMachine* statemachine,
-                                const char* name,
-                                int len,
-                                AGpsBearerType btype) :
-        LocMsg(),
-        mStateMachine(statemachine), mLen(len),
-        mAPN(new char[len+1]), mBearerType(btype)
-    {
-        memcpy((void*)mAPN, (void*)name, len);
-        mAPN[len] = 0;
-        locallog();
-    }
-    inline ~LocEngAtlOpenSuccess()
-    {
-        delete[] mAPN;
-    }
-    inline virtual void proc() const {
-        mStateMachine->setBearer(mBearerType);
-        mStateMachine->setAPN(mAPN, mLen);
-        mStateMachine->onRsrcEvent(RSRC_GRANTED);
-    }
-    inline void locallog() const {
-        LOC_LOGV("LocEngAtlOpenSuccess agps type: %s\n  apn: %s\n"
-                 "  bearer type: %s",
-                 loc_get_agps_type_name(mStateMachine->getType()),
-                 mAPN,
-                 loc_get_agps_bear_name(mBearerType));
-    }
-    inline virtual void log() const {
-        locallog();
-    }
-};
-
-//        case LOC_ENG_MSG_ATL_CLOSED:
-struct LocEngAtlClosed : public LocMsg {
-    AgpsStateMachine* mStateMachine;
-    inline LocEngAtlClosed(AgpsStateMachine* statemachine) :
-        LocMsg(), mStateMachine(statemachine) {
-        locallog();
-    }
-    inline virtual void proc() const {
-        mStateMachine->onRsrcEvent(RSRC_RELEASED);
-    }
-    inline void locallog() const {
-        LOC_LOGV("LocEngAtlClosed");
-    }
-    inline virtual void log() const {
-        locallog();
-    }
-};
-
-//        case LOC_ENG_MSG_ATL_OPEN_FAILED:
-struct LocEngAtlOpenFailed : public LocMsg {
-    AgpsStateMachine* mStateMachine;
-    inline LocEngAtlOpenFailed(AgpsStateMachine* statemachine) :
-        LocMsg(), mStateMachine(statemachine) {
-        locallog();
-    }
-    inline virtual void proc() const {
-        mStateMachine->onRsrcEvent(RSRC_DENIED);
-    }
-    inline void locallog() const {
-        LOC_LOGV("LocEngAtlOpenFailed");
-    }
-    inline virtual void log() const {
-        locallog();
-    }
-};
-
-//        case LOC_ENG_MSG_ENGINE_DOWN:
-LocEngDown::LocEngDown(void* locEng) :
-    LocMsg(), mLocEng(locEng) {
-    locallog();
-}
-inline void LocEngDown::proc() const {
-    loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
-    loc_eng_handle_engine_down(*locEng);
-}
-inline void LocEngDown::locallog() const {
-    LOC_LOGV("LocEngDown");
-}
-inline void LocEngDown::log() const {
-    locallog();
-}
-
-//        case LOC_ENG_MSG_ENGINE_UP:
-LocEngUp::LocEngUp(void* locEng) :
-    LocMsg(), mLocEng(locEng) {
-    locallog();
-}
-inline void LocEngUp::proc() const {
-    loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
-    loc_eng_handle_engine_up(*locEng);
-}
-inline void LocEngUp::locallog() const {
-    LOC_LOGV("LocEngUp");
-}
-inline void LocEngUp::log() const {
-    locallog();
-}
-
-struct LocEngDataClientInit : public LocMsg {
-    loc_eng_data_s_type* mLocEng;
-    inline LocEngDataClientInit(loc_eng_data_s_type* locEng) :
-        LocMsg(), mLocEng(locEng) {
-        locallog();
-    }
-    virtual void proc() const {
-        loc_eng_data_s_type *locEng = (loc_eng_data_s_type *)mLocEng;
-        if(!locEng->adapter->initDataServiceClient()) {
-            locEng->ds_nif = new DSStateMachine(servicerTypeExt,
-                                               (void *)dataCallCb,
-                                               locEng->adapter);
-        }
-    }
-    void locallog() const {
-        LOC_LOGV("LocEngDataClientInit\n");
-    }
-    virtual void log() const {
-        locallog();
-    }
-};
-
-
-/*********************************************************************
- * Initialization checking macros
- *********************************************************************/
-#define STATE_CHECK(ctx, x, ret) \
-    if (!(ctx))                  \
-  {                              \
-      /* Not intialized, abort */\
-      LOC_LOGE("%s: log_eng state error: %s", __func__, x); \
-      EXIT_LOG(%s, x);                                            \
-      ret;                                                        \
-  }
-#define INIT_CHECK(ctx, ret) STATE_CHECK(ctx, "instance not initialized", ret)
-
-//        LocEngSuplEsClosed
-LocEngSuplEsClosed::LocEngSuplEsClosed(void* locEng) :
-    LocMsg(), mLocEng(locEng) {
-    locallog();
-}
-void LocEngSuplEsClosed::proc() const {
-    loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
     AgpsStateMachine* sm = locEng->ds_nif;
     sm->onRsrcEvent(RSRC_RELEASED);
 }
@@ -1904,7 +1403,7 @@ SIDE EFFECTS
 
 ===========================================================================*/
 int loc_eng_init(loc_eng_data_s_type &loc_eng_data, LocCallbacks* callbacks,
-                 LOC_API_ADAPTER_EVENT_MASK_T event, ContextBase* context)
+                 LOC_API_ADAPTER_EVENT_MASK_T event)
 
 {
     int ret_val = 0;
@@ -1939,7 +1438,7 @@ int loc_eng_init(loc_eng_data_s_type &loc_eng_data, LocCallbacks* callbacks,
     loc_eng_data.sv_ext_parser = callbacks->sv_ext_parser ?
         callbacks->sv_ext_parser : noProc;
     loc_eng_data.intermediateFix = gps_conf.INTERMEDIATE_POS;
-    loc_eng_data.shutdown_cb = callbacks->shutdown_cb;
+
     // initial states taken care of by the memset above
     // loc_eng_data.engine_status -- GPS_STATUS_NONE;
     // loc_eng_data.fix_session_status -- GPS_STATUS_NONE;
@@ -1955,13 +1454,12 @@ int loc_eng_init(loc_eng_data_s_type &loc_eng_data, LocCallbacks* callbacks,
         loc_eng_data.generateNmea = false;
     }
 
-    loc_eng_data.adapter =
-        new LocEngAdapter(event, &loc_eng_data, context,
-                          (MsgTask::tCreate)callbacks->create_thread_cb);
-
-    LOC_LOGD("loc_eng_init created client, id = %p\n",
-             loc_eng_data.adapter);
-    loc_eng_data.adapter->sendMsg(new LocEngInit(&loc_eng_data));
+    //Disable AGPS if capabilities are not present
+    if(!(gps_conf.CAPABILITIES & GPS_CAPABILITY_MSA) &&
+       !(gps_conf.CAPABILITIES & GPS_CAPABILITY_MSB)) {
+        event &= ~(LOC_API_ADAPTER_BIT_LOCATION_SERVER_REQUEST |
+                   LOC_API_ADAPTER_BIT_NI_NOTIFY_VERIFY_REQUEST);
+    }
 
     loc_eng_data.adapter =
         new LocEngAdapter(event, &loc_eng_data,
@@ -1987,8 +1485,7 @@ static int loc_eng_reinit(loc_eng_data_s_type &loc_eng_data)
         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 LocEngSensorControlConfig(adapter, sap_conf.SENSOR_USAGE));
         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. */
@@ -2231,16 +1728,6 @@ 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) {
-        params.mode = LOC_POSITION_MODE_STANDALONE;
-        LOC_LOGD("Position mode changed to standalone for target with GSS/qca1530.");
-    }
-
     if(! loc_eng_data.adapter->getUlpProxy()->sendFixMode(params))
     {
         LocEngAdapter* adapter = loc_eng_data.adapter;
@@ -2273,10 +1760,10 @@ int loc_eng_inject_time(loc_eng_data_s_type &loc_eng_data, GpsUtcTime time,
     ENTRY_LOG_CALLFLOW();
     INIT_CHECK(loc_eng_data.adapter, return -1);
     LocEngAdapter* adapter = loc_eng_data.adapter;
-
-    adapter->sendMsg(new LocEngSetTime(adapter, time, timeReference,
-                                       uncertainty));
-
+    if (adapter->mAgpsEnabled) {
+        adapter->sendMsg(new LocEngSetTime(adapter, time, timeReference,
+                                           uncertainty));
+    }
     EXIT_LOG(%d, 0);
     return 0;
 }
@@ -2304,11 +1791,8 @@ int loc_eng_inject_location(loc_eng_data_s_type &loc_eng_data, double latitude,
     ENTRY_LOG_CALLFLOW();
     INIT_CHECK(loc_eng_data.adapter, return -1);
     LocEngAdapter* adapter = loc_eng_data.adapter;
-    if(adapter->mSupportsPositionInjection)
-    {
-        adapter->sendMsg(new LocEngInjectLocation(adapter, latitude, longitude,
-                                                  accuracy));
-    }
+    adapter->sendMsg(new LocEngInjectLocation(adapter, latitude, longitude,
+                                              accuracy));
 
     EXIT_LOG(%d, 0);
     return 0;
@@ -2377,32 +1861,6 @@ static void loc_inform_gps_status(loc_eng_data_s_type &loc_eng_data, GpsStatusVa
     EXIT_LOG(%s, VOID_RET);
 }
 
-static int loc_eng_get_zpp_handler(loc_eng_data_s_type &loc_eng_data)
-{
-   ENTRY_LOG();
-   int ret_val = LOC_API_ADAPTER_ERR_SUCCESS;
-   UlpLocation location;
-   LocPosTechMask tech_mask = LOC_POS_TECH_MASK_DEFAULT;
-   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
-  location.gpsLocation.flags |= LOCATION_HAS_SOURCE_INFO;
-  location.position_source = ULP_LOCATION_IS_FROM_ZPP;
-
-  loc_eng_data.adapter->getUlpProxy()->reportPosition(location,
-                                     locationExtended,
-                                     NULL,
-                                     LOC_SESS_SUCCESS,
-                                     tech_mask);
-
-  EXIT_LOG(%d, ret_val);
-  return ret_val;
-}
-
 /*
   Callback function passed to Data Services State Machine
   This becomes part of the state machine's servicer and
@@ -2494,14 +1952,28 @@ void loc_eng_agps_init(loc_eng_data_s_type &loc_eng_data, AGpsExtCallbacks* call
     STATE_CHECK((NULL == loc_eng_data.agps_status_cb),
                 "agps instance already initialized",
                 return);
-    if (callbacks == NULL) {
+    if(callbacks == NULL) {
         LOC_LOGE("loc_eng_agps_init: bad parameters cb %p", callbacks);
         EXIT_LOG(%s, VOID_RET);
         return;
     }
-    LocEngAdapter* adapter = loc_eng_data.adapter;
+
+    //Proceed to create AGPS framework only if MSA or MSB capabilities
+    //are present. If the target is an APQ, these masks are
+    //cleared in get_gps_interface()
+    if(!(gps_conf.CAPABILITIES & GPS_CAPABILITY_MSA) &&
+       !(gps_conf.CAPABILITIES & GPS_CAPABILITY_MSB) ) {
+        LOC_LOGD("%s:%d]: No AGPS capabilities found. Returning\n",
+                 __func__, __LINE__);
+        return;
+    }
+
     loc_eng_data.agps_status_cb = callbacks->status_cb;
 
+    loc_eng_data.agnss_nif = new AgpsStateMachine(servicerTypeAgps,
+                                                  (void *)loc_eng_data.agps_status_cb,
+                                                  AGPS_TYPE_SUPL,
+                                                  false);
     loc_eng_data.internet_nif = new AgpsStateMachine(servicerTypeAgps,
                                                      (void *)loc_eng_data.agps_status_cb,
                                                      AGPS_TYPE_WWAN_ANY,
@@ -2510,25 +1982,18 @@ void loc_eng_agps_init(loc_eng_data_s_type &loc_eng_data, AGpsExtCallbacks* call
                                                  (void *)loc_eng_data.agps_status_cb,
                                                  AGPS_TYPE_WIFI,
                                                  true);
-
-    int gnssType = getTargetGnssType(loc_get_target());
-    bool isAPQ = (gnssType == GNSS_GSS);
-    bool is1530 = (gnssType == GNSS_QCA1530);
-    if (!isAPQ && !is1530) {
-        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));
-
-            loc_eng_dmn_conn_loc_api_server_launch(callbacks->create_thread_cb,
-                                                   NULL, NULL, &loc_eng_data);
-        }
-        loc_eng_agps_reinit(loc_eng_data);
+    if(!loc_eng_data.adapter->initDataServiceClient()) {
+        LOC_LOGD("%s:%d]: Creating new ds state machine\n", __func__, __LINE__);
+        loc_eng_data.ds_nif = new DSStateMachine(servicerTypeExt,
+                                                 (void *)dataCallCb,
+                                                 loc_eng_data.adapter);
+        LOC_LOGD("%s:%d]: Created new ds state machine\n", __func__, __LINE__);
     }
 
+    //loc_eng_dmn_conn_loc_api_server_launch(callbacks->create_thread_cb,
+    //                                               NULL, NULL, &loc_eng_data);
+
+    loc_eng_agps_reinit(loc_eng_data);
     EXIT_LOG(%s, VOID_RET);
 }
 
@@ -2952,13 +2417,9 @@ void loc_eng_handle_engine_up(loc_eng_data_s_type &loc_eng_data)
     ENTRY_LOG();
     loc_eng_reinit(loc_eng_data);
 
-    loc_eng_data.adapter->requestPowerVote();
-
     if (loc_eng_data.agps_status_cb != NULL) {
-        if (loc_eng_data.agnss_nif)
-            loc_eng_data.agnss_nif->dropAllSubscribers();
-        if (loc_eng_data.internet_nif)
-            loc_eng_data.internet_nif->dropAllSubscribers();
+        loc_eng_data.agnss_nif->dropAllSubscribers();
+        loc_eng_data.internet_nif->dropAllSubscribers();
 
         loc_eng_agps_reinit(loc_eng_data);
     }
@@ -3033,27 +2494,3 @@ int loc_eng_read_config(void)
     EXIT_LOG(%d, 0);
     return 0;
 }
-
-/*===========================================================================
-FUNCTION    loc_eng_handle_shutdown
-
-DESCRIPTION
-   Calls the shutdown callback function in the loc interface to close
-   the modem node
-
-DEPENDENCIES
-   None
-
-RETURN VALUE
-   0: success
-
-SIDE EFFECTS
-   N/A
-
-===========================================================================*/
-void loc_eng_handle_shutdown(loc_eng_data_s_type &locEng)
-{
-    ENTRY_LOG();
-    locEng.shutdown_cb();
-    EXIT_LOG(%d, 0);
-}
diff --git a/loc_api/libloc_api_50001/loc_eng.h b/loc_api/libloc_api_50001/loc_eng.h
index ff787da..d5f1855 100644
--- a/loc_api/libloc_api_50001/loc_eng.h
+++ b/loc_api/libloc_api_50001/loc_eng.h
@@ -133,7 +133,6 @@ typedef struct loc_eng_data_s
 
     loc_ext_parser location_ext_parser;
     loc_ext_parser sv_ext_parser;
-    loc_shutdown_cb shutdown_cb;
 } loc_eng_data_s_type;
 
 /* GPS.conf support */
@@ -141,8 +140,10 @@ typedef struct loc_gps_cfg_s
 {
     unsigned long  INTERMEDIATE_POS;
     unsigned long  ACCURACY_THRES;
+    unsigned long  ENABLE_WIPER;
     unsigned long  SUPL_VER;
     unsigned long  CAPABILITIES;
+    unsigned long  QUIPC_ENABLED;
     unsigned long  LPP_PROFILE;
     uint8_t        NMEA_PROVIDER;
     unsigned long  A_GLONASS_POS_PROTOCOL_SELECT;
@@ -171,7 +172,6 @@ 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;
 } loc_sap_cfg_s_type;
 
 extern loc_gps_cfg_s_type gps_conf;
@@ -179,8 +179,7 @@ extern loc_sap_cfg_s_type sap_conf;
 
 int  loc_eng_init(loc_eng_data_s_type &loc_eng_data,
                   LocCallbacks* callbacks,
-                  LOC_API_ADAPTER_EVENT_MASK_T event,
-                  ContextBase* context);
+                  LOC_API_ADAPTER_EVENT_MASK_T event);
 int  loc_eng_start(loc_eng_data_s_type &loc_eng_data);
 int  loc_eng_stop(loc_eng_data_s_type &loc_eng_data);
 void loc_eng_cleanup(loc_eng_data_s_type &loc_eng_data);
diff --git a/loc_api/libloc_api_50001/loc_eng_dmn_conn.h b/loc_api/libloc_api_50001/loc_eng_dmn_conn.h
index 1d8c142..c7c100b 100644
--- a/loc_api/libloc_api_50001/loc_eng_dmn_conn.h
+++ b/loc_api/libloc_api_50001/loc_eng_dmn_conn.h
@@ -1,4 +1,4 @@
-/* Copyright (c) 2011-2012,2014 The Linux Foundation. All rights reserved.
+/* Copyright (c) 2011-2012, 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
@@ -33,11 +33,11 @@
 
 #ifdef _ANDROID_
 
-#define GPSONE_LOC_API_Q_PATH "/data/misc/location/gpsone_d/gpsone_loc_api_q"
-#define GPSONE_LOC_API_RESP_Q_PATH "/data/misc/location/gpsone_d/gpsone_loc_api_resp_q"
-#define QUIPC_CTRL_Q_PATH "/data/misc/location/gpsone_d/quipc_ctrl_q"
-#define MSAPM_CTRL_Q_PATH "/data/misc/location/gpsone_d/msapm_ctrl_q"
-#define MSAPU_CTRL_Q_PATH "/data/misc/location/gpsone_d/msapu_ctrl_q"
+#define GPSONE_LOC_API_Q_PATH "/data/misc/gpsone_d/gpsone_loc_api_q"
+#define GPSONE_LOC_API_RESP_Q_PATH "/data/misc/gpsone_d/gpsone_loc_api_resp_q"
+#define QUIPC_CTRL_Q_PATH "/data/misc/gpsone_d/quipc_ctrl_q"
+#define MSAPM_CTRL_Q_PATH "/data/misc/gpsone_d/msapm_ctrl_q"
+#define MSAPU_CTRL_Q_PATH "/data/misc/gpsone_d/msapu_ctrl_q"
 
 #else
 
diff --git a/loc_api/libloc_api_50001/loc_eng_msg.h b/loc_api/libloc_api_50001/loc_eng_msg.h
index b767dc5..1a31894 100644
--- a/loc_api/libloc_api_50001/loc_eng_msg.h
+++ b/loc_api/libloc_api_50001/loc_eng_msg.h
@@ -119,9 +119,9 @@ struct LocEngReportSv : public LocMsg {
 };
 
 struct LocEngReportStatus : public LocMsg {
-    LocAdapterBase* mAdapter;
+    void* mLocEng;
     const GpsStatusValue mStatus;
-    LocEngReportStatus(LocAdapterBase* adapter,
+    LocEngReportStatus(void* locEng,
                        GpsStatusValue engineStatus);
     virtual void proc() const;
     void locallog() const;
@@ -280,22 +280,7 @@ struct LocEngUp : public LocMsg {
     virtual void log() const;
 };
 
-struct LocEngGetZpp : public LocMsg {
-    LocEngAdapter* mAdapter;
-    LocEngGetZpp(LocEngAdapter* adapter);
-    virtual void proc() const;
-    void locallog() const;
-    virtual void log() const;
-    void send() const;
-};
 
-struct LocEngShutdown : public LocMsg {
-    LocEngAdapter* mAdapter;
-    LocEngShutdown(LocEngAdapter* adapter);
-    virtual void proc() const;
-    void locallog() const;
-    virtual void log() const;
-};
 #ifdef __cplusplus
 }
 #endif /* __cplusplus */
diff --git a/loc_api/libloc_api_50001/loc_eng_ni.cpp b/loc_api/libloc_api_50001/loc_eng_ni.cpp
index 4597b98..f017cab 100644
--- a/loc_api/libloc_api_50001/loc_eng_ni.cpp
+++ b/loc_api/libloc_api_50001/loc_eng_ni.cpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2009-2014, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2009-2013, 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
@@ -116,45 +116,28 @@ void loc_eng_ni_request_handler(loc_eng_data_s_type &loc_eng_data,
     ENTRY_LOG();
     char lcs_addr[32]; // Decoded LCS address for UMTS CP NI
     loc_eng_ni_data_s_type* loc_eng_ni_data_p = &loc_eng_data.loc_eng_ni_data;
-    loc_eng_ni_session_s_type* pSession = NULL;
 
     if (NULL == loc_eng_data.ni_notify_cb) {
         EXIT_LOG(%s, "loc_eng_ni_init hasn't happened yet.");
         return;
     }
 
-    if (notif->ni_type == GPS_NI_TYPE_EMERGENCY_SUPL) {
-        if (NULL != loc_eng_ni_data_p->sessionEs.rawRequest) {
-            LOC_LOGW("loc_eng_ni_request_handler, supl es NI in progress, new supl es NI ignored, type: %d",
-                     notif->ni_type);
-            if (NULL != passThrough) {
-                free((void*)passThrough);
-            }
-        } else {
-            pSession = &loc_eng_ni_data_p->sessionEs;
-        }
-    } else {
-        if (NULL != loc_eng_ni_data_p->session.rawRequest ||
-            NULL != loc_eng_ni_data_p->sessionEs.rawRequest) {
-            LOC_LOGW("loc_eng_ni_request_handler, supl NI in progress, new supl NI ignored, type: %d",
-                     notif->ni_type);
-            if (NULL != passThrough) {
-                free((void*)passThrough);
-            }
-        } else {
-            pSession = &loc_eng_ni_data_p->session;
+    /* If busy, use default or deny */
+    if (NULL != loc_eng_ni_data_p->rawRequest)
+    {
+        /* XXX Consider sending a NO RESPONSE reply or queue the request */
+        LOC_LOGW("loc_eng_ni_request_handler, notification in progress, new NI request ignored, type: %d",
+                 notif->ni_type);
+        if (NULL != passThrough) {
+            free((void*)passThrough);
         }
     }
-
-
-    if (pSession) {
+    else {
         /* Save request */
-        pSession->rawRequest = (void*)passThrough;
-        pSession->reqID = ++loc_eng_ni_data_p->reqIDCounter;
-        pSession->adapter = loc_eng_data.adapter;
+        loc_eng_ni_data_p->rawRequest = (void*)passThrough;
 
         /* Fill in notification */
-        ((GpsNiNotification*)notif)->notification_id = pSession->reqID;
+        ((GpsNiNotification*)notif)->notification_id = loc_eng_ni_data_p->reqID;
 
         if (notif->notify_flags == GPS_NI_PRIVACY_OVERRIDE)
         {
@@ -173,16 +156,16 @@ void loc_eng_ni_request_handler(loc_eng_data_s_type &loc_eng_data,
         /* For robustness, spawn a thread at this point to timeout to clear up the notification status, even though
          * the OEM layer in java does not do so.
          **/
-        pSession->respTimeLeft = 5 + (notif->timeout != 0 ? notif->timeout : LOC_NI_NO_RESPONSE_TIME);
-        LOC_LOGI("Automatically sends 'no response' in %d seconds (to clear status)\n", pSession->respTimeLeft);
+        loc_eng_ni_data_p->respTimeLeft = 5 + (notif->timeout != 0 ? notif->timeout : LOC_NI_NO_RESPONSE_TIME);
+        LOC_LOGI("Automatically sends 'no response' in %d seconds (to clear status)\n", loc_eng_ni_data_p->respTimeLeft);
 
         int rc = 0;
-        rc = pthread_create(&pSession->thread, NULL, ni_thread_proc, pSession);
+        rc = pthread_create(&loc_eng_ni_data_p->thread, NULL, ni_thread_proc, &loc_eng_data);
         if (rc)
         {
             LOC_LOGE("Loc NI thread is not created.\n");
         }
-        rc = pthread_detach(pSession->thread);
+        rc = pthread_detach(loc_eng_ni_data_p->thread);
         if (rc)
         {
             LOC_LOGE("Loc NI thread is not detached.\n");
@@ -203,64 +186,56 @@ static void* ni_thread_proc(void *args)
 {
     ENTRY_LOG();
 
-    loc_eng_ni_session_s_type* pSession = (loc_eng_ni_session_s_type*)args;
+    loc_eng_data_s_type* loc_eng_data_p = (loc_eng_data_s_type*)args;
+    loc_eng_ni_data_s_type* loc_eng_ni_data_p = &loc_eng_data_p->loc_eng_ni_data;
     int rc = 0;          /* return code from pthread calls */
 
     struct timeval present_time;
     struct timespec expire_time;
 
     LOC_LOGD("Starting Loc NI thread...\n");
-    pthread_mutex_lock(&pSession->tLock);
+    pthread_mutex_lock(&loc_eng_ni_data_p->tLock);
     /* Calculate absolute expire time */
     gettimeofday(&present_time, NULL);
-    expire_time.tv_sec  = present_time.tv_sec + pSession->respTimeLeft;
+    expire_time.tv_sec  = present_time.tv_sec + loc_eng_ni_data_p->respTimeLeft;
     expire_time.tv_nsec = present_time.tv_usec * 1000;
     LOC_LOGD("ni_thread_proc-Time out set for abs time %ld with delay %d sec\n",
-             (long) expire_time.tv_sec, pSession->respTimeLeft );
+             (long) expire_time.tv_sec, loc_eng_ni_data_p->respTimeLeft );
 
-    while (!pSession->respRecvd)
+    while (!loc_eng_ni_data_p->respRecvd)
     {
-        rc = pthread_cond_timedwait(&pSession->tCond,
-                                    &pSession->tLock,
+        rc = pthread_cond_timedwait(&loc_eng_ni_data_p->tCond,
+                                    &loc_eng_ni_data_p->tLock,
                                     &expire_time);
         if (rc == ETIMEDOUT)
         {
-            pSession->resp = GPS_NI_RESPONSE_NORESP;
+            loc_eng_ni_data_p->resp = GPS_NI_RESPONSE_NORESP;
             LOC_LOGD("ni_thread_proc-Thread time out after valting for specified time. Ret Val %d\n",rc );
             break;
         }
     }
     LOC_LOGD("ni_thread_proc-Java layer has sent us a user response and return value from "
              "pthread_cond_timedwait = %d\n",rc );
-    pSession->respRecvd = FALSE; /* Reset the user response flag for the next session*/
-
-    LOC_LOGD("pSession->resp is %d\n",pSession->resp);
+    loc_eng_ni_data_p->respRecvd = FALSE; /* Reset the user response flag for the next session*/
 
     // adding this check to support modem restart, in which case, we need the thread
     // to exit without calling sending data. We made sure that rawRequest is NULL in
     // loc_eng_ni_reset_on_engine_restart()
-    LocEngAdapter* adapter = pSession->adapter;
+    LocEngAdapter* adapter = loc_eng_data_p->adapter;
     LocEngInformNiResponse *msg = NULL;
 
-    if (NULL != pSession->rawRequest) {
-        if (pSession->resp != GPS_NI_RESPONSE_IGNORE) {
-            LOC_LOGD("pSession->resp != GPS_NI_RESPONSE_IGNORE \n");
-            msg = new LocEngInformNiResponse(adapter,
-                                             pSession->resp,
-                                             pSession->rawRequest);
-        } else {
-            LOC_LOGD("this is the ignore reply for SUPL ES\n");
-            free(pSession->rawRequest);
-        }
-        pSession->rawRequest = NULL;
+    if (NULL != loc_eng_ni_data_p->rawRequest) {
+        msg = new LocEngInformNiResponse(adapter,
+                                         loc_eng_ni_data_p->resp,
+                                         loc_eng_ni_data_p->rawRequest);
+        loc_eng_ni_data_p->rawRequest = NULL;
     }
-    pthread_mutex_unlock(&pSession->tLock);
+    pthread_mutex_unlock(&loc_eng_ni_data_p->tLock);
 
-    pSession->respTimeLeft = 0;
-    pSession->reqID = 0;
+    loc_eng_ni_data_p->respTimeLeft = 0;
+    loc_eng_ni_data_p->reqID++;
 
     if (NULL != msg) {
-        LOC_LOGD("ni_thread_proc: adapter->sendMsg(msg)\n");
         adapter->sendMsg(msg);
     }
 
@@ -279,28 +254,16 @@ void loc_eng_ni_reset_on_engine_restart(loc_eng_data_s_type &loc_eng_data)
     }
 
     // only if modem has requested but then died.
-    if (NULL != loc_eng_ni_data_p->sessionEs.rawRequest) {
-        free(loc_eng_ni_data_p->sessionEs.rawRequest);
-        loc_eng_ni_data_p->sessionEs.rawRequest = NULL;
+    if (NULL != loc_eng_ni_data_p->rawRequest) {
+        free(loc_eng_ni_data_p->rawRequest);
+        loc_eng_ni_data_p->rawRequest = NULL;
 
-        pthread_mutex_lock(&loc_eng_ni_data_p->sessionEs.tLock);
+        pthread_mutex_lock(&loc_eng_ni_data_p->tLock);
         // the goal is to wake up ni_thread_proc
         // and let it exit.
-        loc_eng_ni_data_p->sessionEs.respRecvd = TRUE;
-        pthread_cond_signal(&loc_eng_ni_data_p->sessionEs.tCond);
-        pthread_mutex_unlock(&loc_eng_ni_data_p->sessionEs.tLock);
-    }
-
-    if (NULL != loc_eng_ni_data_p->session.rawRequest) {
-        free(loc_eng_ni_data_p->session.rawRequest);
-        loc_eng_ni_data_p->session.rawRequest = NULL;
-
-        pthread_mutex_lock(&loc_eng_ni_data_p->session.tLock);
-        // the goal is to wake up ni_thread_proc
-        // and let it exit.
-        loc_eng_ni_data_p->session.respRecvd = TRUE;
-        pthread_cond_signal(&loc_eng_ni_data_p->session.tCond);
-        pthread_mutex_unlock(&loc_eng_ni_data_p->session.tLock);
+        loc_eng_ni_data_p->respRecvd = TRUE;
+        pthread_cond_signal(&loc_eng_ni_data_p->tCond);
+        pthread_mutex_unlock(&loc_eng_ni_data_p->tLock);
     }
 
     EXIT_LOG(%s, VOID_RET);
@@ -334,19 +297,12 @@ void loc_eng_ni_init(loc_eng_data_s_type &loc_eng_data, GpsNiExtCallbacks *callb
         EXIT_LOG(%s, "loc_eng_ni_init: already inited.");
     } else {
         loc_eng_ni_data_s_type* loc_eng_ni_data_p = &loc_eng_data.loc_eng_ni_data;
-        loc_eng_ni_data_p->sessionEs.respTimeLeft = 0;
-        loc_eng_ni_data_p->sessionEs.respRecvd = FALSE;
-        loc_eng_ni_data_p->sessionEs.rawRequest = NULL;
-        loc_eng_ni_data_p->sessionEs.reqID = 0;
-        pthread_cond_init(&loc_eng_ni_data_p->sessionEs.tCond, NULL);
-        pthread_mutex_init(&loc_eng_ni_data_p->sessionEs.tLock, NULL);
-
-        loc_eng_ni_data_p->session.respTimeLeft = 0;
-        loc_eng_ni_data_p->session.respRecvd = FALSE;
-        loc_eng_ni_data_p->session.rawRequest = NULL;
-        loc_eng_ni_data_p->session.reqID = 0;
-        pthread_cond_init(&loc_eng_ni_data_p->session.tCond, NULL);
-        pthread_mutex_init(&loc_eng_ni_data_p->session.tLock, NULL);
+        loc_eng_ni_data_p->respTimeLeft = 0;
+        loc_eng_ni_data_p->respRecvd = FALSE;
+        loc_eng_ni_data_p->rawRequest = NULL;
+        loc_eng_ni_data_p->reqID = 0;
+        pthread_cond_init(&loc_eng_ni_data_p->tCond, NULL);
+        pthread_mutex_init(&loc_eng_ni_data_p->tLock, NULL);
 
         loc_eng_data.ni_notify_cb = callbacks->notify_cb;
         EXIT_LOG(%s, VOID_RET);
@@ -374,40 +330,25 @@ void loc_eng_ni_respond(loc_eng_data_s_type &loc_eng_data,
 {
     ENTRY_LOG_CALLFLOW();
     loc_eng_ni_data_s_type* loc_eng_ni_data_p = &loc_eng_data.loc_eng_ni_data;
-    loc_eng_ni_session_s_type* pSession = NULL;
 
     if (NULL == loc_eng_data.ni_notify_cb) {
         EXIT_LOG(%s, "loc_eng_ni_init hasn't happened yet.");
         return;
     }
 
-    if (notif_id == loc_eng_ni_data_p->sessionEs.reqID &&
-        NULL != loc_eng_ni_data_p->sessionEs.rawRequest) {
-        pSession = &loc_eng_ni_data_p->sessionEs;
-        // ignore any SUPL NI non-Es session if a SUPL NI ES is accepted
-        if (user_response == GPS_NI_RESPONSE_ACCEPT &&
-            NULL != loc_eng_ni_data_p->session.rawRequest) {
-                pthread_mutex_lock(&loc_eng_ni_data_p->session.tLock);
-                loc_eng_ni_data_p->session.resp = GPS_NI_RESPONSE_IGNORE;
-                loc_eng_ni_data_p->session.respRecvd = TRUE;
-                pthread_cond_signal(&loc_eng_ni_data_p->session.tCond);
-                pthread_mutex_unlock(&loc_eng_ni_data_p->session.tLock);
-        }
-    } else if (notif_id == loc_eng_ni_data_p->session.reqID &&
-        NULL != loc_eng_ni_data_p->session.rawRequest) {
-        pSession = &loc_eng_ni_data_p->session;
-    }
-
-    if (pSession) {
+    if (notif_id == loc_eng_ni_data_p->reqID &&
+        NULL != loc_eng_ni_data_p->rawRequest)
+    {
         LOC_LOGI("loc_eng_ni_respond: send user response %d for notif %d", user_response, notif_id);
-        pthread_mutex_lock(&pSession->tLock);
-        pSession->resp = user_response;
-        pSession->respRecvd = TRUE;
-        pthread_cond_signal(&pSession->tCond);
-        pthread_mutex_unlock(&pSession->tLock);
+        pthread_mutex_lock(&loc_eng_ni_data_p->tLock);
+        loc_eng_ni_data_p->resp = user_response;
+        loc_eng_ni_data_p->respRecvd = TRUE;
+        pthread_cond_signal(&loc_eng_ni_data_p->tCond);
+        pthread_mutex_unlock(&loc_eng_ni_data_p->tLock);
     }
     else {
-        LOC_LOGE("loc_eng_ni_respond: notif_id %d not an active session", notif_id);
+        LOC_LOGE("loc_eng_ni_respond: reqID %d and notif_id %d mismatch or rawRequest %p, response: %d",
+                 loc_eng_ni_data_p->reqID, notif_id, loc_eng_ni_data_p->rawRequest, user_response);
     }
 
     EXIT_LOG(%s, VOID_RET);
diff --git a/loc_api/libloc_api_50001/loc_eng_ni.h b/loc_api/libloc_api_50001/loc_eng_ni.h
index 068f5cd..9cbc57d 100644
--- a/loc_api/libloc_api_50001/loc_eng_ni.h
+++ b/loc_api/libloc_api_50001/loc_eng_ni.h
@@ -1,4 +1,4 @@
-/* Copyright (c) 2009,2011,2014 The Linux Foundation. All rights reserved.
+/* Copyright (c) 2009,2011 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
@@ -31,11 +31,9 @@
 #define LOC_ENG_NI_H
 
 #include <stdbool.h>
-#include <LocEngAdapter.h>
 
 #define LOC_NI_NO_RESPONSE_TIME            20                      /* secs */
 #define LOC_NI_NOTIF_KEY_ADDRESS           "Address"
-#define GPS_NI_RESPONSE_IGNORE             4
 
 typedef struct {
     pthread_t               thread;            /* NI thread */
@@ -46,13 +44,6 @@ typedef struct {
     GpsUserResponseType     resp;
     pthread_cond_t          tCond;
     pthread_mutex_t         tLock;
-    LocEngAdapter*          adapter;
-} loc_eng_ni_session_s_type;
-
-typedef struct {
-    loc_eng_ni_session_s_type session;    /* SUPL NI Session */
-    loc_eng_ni_session_s_type sessionEs;  /* Emergency SUPL NI Session */
-    int reqIDCounter;
 } loc_eng_ni_data_s_type;
 
 
diff --git a/loc_api/libloc_api_50001/loc_eng_nmea.cpp b/loc_api/libloc_api_50001/loc_eng_nmea.cpp
index 842eda1..f5f746b 100644
--- a/loc_api/libloc_api_50001/loc_eng_nmea.cpp
+++ b/loc_api/libloc_api_50001/loc_eng_nmea.cpp
@@ -29,10 +29,7 @@
 
 #define LOG_NDDEBUG 0
 #define LOG_TAG "LocSvc_eng_nmea"
-#define GPS_PRN_START 1
-#define GPS_PRN_END   32
-#define GLONASS_PRN_START 65
-#define GLONASS_PRN_END   96
+
 #include <loc_eng.h>
 #include <loc_eng_nmea.h>
 #include <math.h>
@@ -60,8 +57,7 @@ void loc_eng_nmea_send(char *pNmea, int length, loc_eng_data_s_type *loc_eng_dat
     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_eng_data_p->nmea_cb(now, pNmea, length);
     LOC_LOGD("NMEA <%s", pNmea);
 }
 
@@ -609,33 +605,12 @@ void loc_eng_nmea_generate_sv(loc_eng_data_s_type *loc_eng_data_p,
     char* pMarker = sentence;
     int lengthRemaining = sizeof(sentence);
     int length = 0;
-    int svCount = svStatus.num_svs;
-    int sentenceCount = 0;
-    int sentenceNumber = 1;
-    int svNumber = 1;
-    int gpsCount = 0;
-    int glnCount = 0;
-
-    //Count GPS SVs for saparating GPS from GLONASS and throw others
-
-    for(svNumber=1; svNumber <= svCount; svNumber++) {
-        if( (svStatus.sv_list[svNumber-1].prn >= GPS_PRN_START)&&
-            (svStatus.sv_list[svNumber-1].prn <= GPS_PRN_END) )
-        {
-            gpsCount++;
-        }
-        else if( (svStatus.sv_list[svNumber-1].prn >= GLONASS_PRN_START) &&
-                 (svStatus.sv_list[svNumber-1].prn <= GLONASS_PRN_END) )
-        {
-            glnCount++;
-        }
-    }
 
     // ------------------
     // ------$GPGSV------
     // ------------------
 
-    if (gpsCount <= 0)
+    if (svStatus.num_svs <= 0)
     {
         // no svs in view, so just send a blank $GPGSV sentence
         strlcpy(sentence, "$GPGSV,1,1,0,", sizeof(sentence));
@@ -644,9 +619,12 @@ void loc_eng_nmea_generate_sv(loc_eng_data_s_type *loc_eng_data_p,
     }
     else
     {
-        svNumber = 1;
-        sentenceNumber = 1;
-        sentenceCount = gpsCount/4 + (gpsCount % 4 != 0);
+        int svCount = svStatus.num_svs;
+        int sentenceCount = svCount / 4;
+        if (svStatus.num_svs % 4)
+            sentenceCount++;
+        int sentenceNumber = 1;
+        int svNumber = 1;
 
         while (sentenceNumber <= sentenceCount)
         {
@@ -654,7 +632,7 @@ void loc_eng_nmea_generate_sv(loc_eng_data_s_type *loc_eng_data_p,
             lengthRemaining = sizeof(sentence);
 
             length = snprintf(pMarker, lengthRemaining, "$GPGSV,%d,%d,%02d",
-                          sentenceCount, sentenceNumber, gpsCount);
+                          sentenceCount, sentenceNumber, svCount);
 
             if (length < 0 || length >= lengthRemaining)
             {
@@ -664,93 +642,25 @@ void loc_eng_nmea_generate_sv(loc_eng_data_s_type *loc_eng_data_p,
             pMarker += length;
             lengthRemaining -= length;
 
-            for (int i=0; (svNumber <= svCount) && (i < 4);  svNumber++)
+            for (int i=0; (svNumber <= svCount) && (i < 4); i++, svNumber++)
             {
-                if( (svStatus.sv_list[svNumber-1].prn >= GPS_PRN_START) &&
-                    (svStatus.sv_list[svNumber-1].prn <= GPS_PRN_END) )
-                {
-                    length = snprintf(pMarker, lengthRemaining,",%02d,%02d,%03d,",
+                length = snprintf(pMarker, lengthRemaining,",%02d,%02d,%03d,",
                                   svStatus.sv_list[svNumber-1].prn,
                                   (int)(0.5 + svStatus.sv_list[svNumber-1].elevation), //float to int
                                   (int)(0.5 + svStatus.sv_list[svNumber-1].azimuth)); //float to int
 
-                    if (length < 0 || length >= lengthRemaining)
-                    {
-                        LOC_LOGE("NMEA Error in string formatting");
-                        return;
-                    }
-                    pMarker += length;
-                    lengthRemaining -= length;
-
-                    if (svStatus.sv_list[svNumber-1].snr > 0)
-                    {
-                        length = snprintf(pMarker, lengthRemaining,"%02d",
-                                         (int)(0.5 + svStatus.sv_list[svNumber-1].snr)); //float to int
-
-                        if (length < 0 || length >= lengthRemaining)
-                        {
-                            LOC_LOGE("NMEA Error in string formatting");
-                            return;
-                        }
-                        pMarker += length;
-                        lengthRemaining -= length;
-                    }
-
-                    i++;
-               }
-
-            }
-
-            length = loc_eng_nmea_put_checksum(sentence, sizeof(sentence));
-            loc_eng_nmea_send(sentence, length, loc_eng_data_p);
-            sentenceNumber++;
-
-        }  //while
-
-    } //if
-
-    // ------------------
-    // ------$GLGSV------
-    // ------------------
-
-    if (glnCount <= 0)
-    {
-        // no svs in view, so just send a blank $GLGSV sentence
-        strlcpy(sentence, "$GLGSV,1,1,0,", sizeof(sentence));
-        length = loc_eng_nmea_put_checksum(sentence, sizeof(sentence));
-        loc_eng_nmea_send(sentence, length, loc_eng_data_p);
-    }
-    else
-    {
-        svNumber = 1;
-        sentenceNumber = 1;
-        sentenceCount = glnCount/4 + (glnCount % 4 != 0);
-
-        while (sentenceNumber <= sentenceCount)
-        {
-            pMarker = sentence;
-            lengthRemaining = sizeof(sentence);
-
-            length = snprintf(pMarker, lengthRemaining, "$GLGSV,%d,%d,%02d",
-                          sentenceCount, sentenceNumber, glnCount);
-
-            if (length < 0 || length >= lengthRemaining)
-            {
-                LOC_LOGE("NMEA Error in string formatting");
-                return;
-            }
-            pMarker += length;
-            lengthRemaining -= length;
-
-            for (int i=0; (svNumber <= svCount) && (i < 4);  svNumber++)
-            {
-                if( (svStatus.sv_list[svNumber-1].prn >= GLONASS_PRN_START) &&
-                    (svStatus.sv_list[svNumber-1].prn <= GLONASS_PRN_END) )      {
+                if (length < 0 || length >= lengthRemaining)
+                {
+                    LOC_LOGE("NMEA Error in string formatting");
+                    return;
+                }
+                pMarker += length;
+                lengthRemaining -= length;
 
-                    length = snprintf(pMarker, lengthRemaining,",%02d,%02d,%03d,",
-                                  svStatus.sv_list[svNumber-1].prn,
-                                  (int)(0.5 + svStatus.sv_list[svNumber-1].elevation), //float to int
-                                  (int)(0.5 + svStatus.sv_list[svNumber-1].azimuth)); //float to int
+                if (svStatus.sv_list[svNumber-1].snr > 0)
+                {
+                    length = snprintf(pMarker, lengthRemaining,"%02d",
+                                     (int)(0.5 + svStatus.sv_list[svNumber-1].snr)); //float to int
 
                     if (length < 0 || length >= lengthRemaining)
                     {
@@ -759,33 +669,15 @@ void loc_eng_nmea_generate_sv(loc_eng_data_s_type *loc_eng_data_p,
                     }
                     pMarker += length;
                     lengthRemaining -= length;
-
-                    if (svStatus.sv_list[svNumber-1].snr > 0)
-                    {
-                        length = snprintf(pMarker, lengthRemaining,"%02d",
-                                         (int)(0.5 + svStatus.sv_list[svNumber-1].snr)); //float to int
-
-                        if (length < 0 || length >= lengthRemaining)
-                        {
-                            LOC_LOGE("NMEA Error in string formatting");
-                            return;
-                        }
-                        pMarker += length;
-                        lengthRemaining -= length;
-                    }
-
-                    i++;
-               }
-
+                }
             }
 
             length = loc_eng_nmea_put_checksum(sentence, sizeof(sentence));
             loc_eng_nmea_send(sentence, length, loc_eng_data_p);
             sentenceNumber++;
 
-        }  //while
-
-    }//if
+        }
+    }
 
     if (svStatus.used_in_fix_mask == 0)
     {   // No sv used, so there will be no position report, so send
diff --git a/utils/Android.mk b/utils/Android.mk
index 82c56f6..18c7ccc 100644
--- a/utils/Android.mk
+++ b/utils/Android.mk
@@ -1,6 +1,3 @@
-ifeq (, $(filter aarch64 arm64, $(TARGET_ARCH)))
-ifneq ($(BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE),)
-ifneq ($(BUILD_TINY_ANDROID),true)
 #Compile this library only for builds with the latest modem image
 
 LOCAL_PATH := $(call my-dir)
@@ -20,17 +17,13 @@ LOCAL_SRC_FILES += \
     linked_list.c \
     loc_target.cpp \
     loc_timer.c \
-    ../platform_lib_abstractions/elapsed_millis_since_boot.cpp \
-    loc_misc_utils.cpp
+    ../platform_lib_abstractions/elapsed_millis_since_boot.cpp
+
 
 LOCAL_CFLAGS += \
      -fno-short-enums \
      -D_ANDROID_
 
-ifeq ($(TARGET_BUILD_VARIANT),user)
-   LOCAL_CFLAGS += -DTARGET_BUILD_VARIANT_USER
-endif
-
 LOCAL_LDFLAGS += -Wl,--export-dynamic
 
 ## Includes
@@ -48,8 +41,8 @@ LOCAL_COPY_HEADERS:= \
    loc_timer.h \
    ../platform_lib_abstractions/platform_lib_includes.h \
    ../platform_lib_abstractions/platform_lib_time.h \
-   ../platform_lib_abstractions/platform_lib_macros.h \
-   loc_misc_utils.h
+   ../platform_lib_abstractions/platform_lib_macros.h
+
 
 LOCAL_MODULE := libgps.utils
 
@@ -59,6 +52,3 @@ LOCAL_PRELINK_MODULE := false
 
 LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)
 include $(BUILD_SHARED_LIBRARY)
-endif # not BUILD_TINY_ANDROID
-endif # BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE
-endif # not aarch64
diff --git a/utils/loc_cfg.cpp b/utils/loc_cfg.cpp
index b8315ee..73d1ca4 100644
--- a/utils/loc_cfg.cpp
+++ b/utils/loc_cfg.cpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2011-2014, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2011-2013, 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,7 +39,6 @@
 #include <time.h>
 #include <loc_cfg.h>
 #include <log_util.h>
-#include <loc_misc_utils.h>
 #ifdef USE_GLIB
 #include <glib.h>
 #endif
@@ -58,30 +57,16 @@ static uint8_t TIMESTAMP = 0;
 /* Parameter spec table */
 static loc_param_s_type loc_parameter_table[] =
 {
-    {"DEBUG_LEVEL",    &DEBUG_LEVEL, NULL,    'n'},
-    {"TIMESTAMP",      &TIMESTAMP,   NULL,    'n'},
+  {"DEBUG_LEVEL",                    &DEBUG_LEVEL, NULL,                   'n'},
+  {"TIMESTAMP",                      &TIMESTAMP,   NULL,                   'n'},
 };
 int loc_param_num = sizeof(loc_parameter_table) / sizeof(loc_param_s_type);
 
-typedef struct loc_param_v_type
-{
-    char* param_name;
-    char* param_str_value;
-    int param_int_value;
-    double param_double_value;
-}loc_param_v_type;
-
 /*===========================================================================
-FUNCTION loc_set_config_entry
+FUNCTION trim_space
 
 DESCRIPTION
-   Potentially sets a given configuration table entry based on the passed in
-   configuration value. This is done by using a string comparison of the
-   parameter names and those found in the configuration file.
-
-PARAMETERS:
-   config_entry: configuration entry in the table to possibly set
-   config_value: value to store in the entry if the parameter names match
+   Removes leading and trailing spaces of the string
 
 DEPENDENCIES
    N/A
@@ -92,177 +77,122 @@ RETURN VALUE
 SIDE EFFECTS
    N/A
 ===========================================================================*/
-int loc_set_config_entry(loc_param_s_type* config_entry, loc_param_v_type* config_value)
+void trim_space(char *org_string)
 {
-    int ret=-1;
-    if(NULL == config_entry || NULL == config_value)
-    {
-        LOC_LOGE("%s: INVALID config entry or parameter", __FUNCTION__);
-        return ret;
-    }
-
-    if (strcmp(config_entry->param_name, config_value->param_name) == 0 &&
-        config_entry->param_ptr)
-    {
-        switch (config_entry->param_type)
-        {
-        case 's':
-            if (strcmp(config_value->param_str_value, "NULL") == 0)
-            {
-                *((char*)config_entry->param_ptr) = '\0';
-            }
-            else {
-                strlcpy((char*) config_entry->param_ptr,
-                        config_value->param_str_value,
-                        LOC_MAX_PARAM_STRING + 1);
-            }
-            /* Log INI values */
-            LOC_LOGD("%s: PARAM %s = %s", __FUNCTION__, config_entry->param_name, (char*)config_entry->param_ptr);
-
-            if(NULL != config_entry->param_set)
-            {
-                *(config_entry->param_set) = 1;
-            }
-            ret = 0;
-            break;
-        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);
-
-            if(NULL != config_entry->param_set)
-            {
-                *(config_entry->param_set) = 1;
-            }
-            ret = 0;
-            break;
-        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);
-
-            if(NULL != config_entry->param_set)
-            {
-                *(config_entry->param_set) = 1;
-            }
-            ret = 0;
-            break;
-        default:
-            LOC_LOGE("%s: PARAM %s parameter type must be n, f, or s", __FUNCTION__, config_entry->param_name);
-        }
-    }
-    return ret;
+   char *scan_ptr, *write_ptr;
+   char *first_nonspace = NULL, *last_nonspace = NULL;
+
+   scan_ptr = write_ptr = org_string;
+
+   while (*scan_ptr)
+   {
+      if ( !isspace(*scan_ptr) && first_nonspace == NULL)
+      {
+         first_nonspace = scan_ptr;
+      }
+
+      if (first_nonspace != NULL)
+      {
+         *(write_ptr++) = *scan_ptr;
+         if ( !isspace(*scan_ptr))
+         {
+            last_nonspace = write_ptr;
+         }
+      }
+
+      scan_ptr++;
+   }
+
+   if (last_nonspace) { *last_nonspace = '\0'; }
 }
 
+typedef struct loc_param_v_type
+{
+   char* param_name;
+
+   char* param_str_value;
+   int param_int_value;
+   double param_double_value;
+}loc_param_v_type;
+
 /*===========================================================================
-FUNCTION loc_read_conf_r (repetitive)
+FUNCTION loc_set_config_entry
 
 DESCRIPTION
-   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.
-   The difference between this and loc_read_conf is that this function returns
-   the file pointer position at the end of filling a config table. Also, it
-   reads a fixed number of parameters at a time which is equal to the length
-   of the configuration table. This functionality enables the caller to
-   repeatedly call the function to read data from the same file.
+   Potentially sets a given configuration table entry based on the passed in
+   configuration value. This is done by using a string comparison of the
+   parameter names and those found in the configuration file.
 
 PARAMETERS:
-   conf_fp : file pointer
-   config_table: table definition of strings to places to store information
-   table_length: length of the configuration table
+   config_entry: configuration entry in the table to possibly set
+   config_value: value to store in the entry if the parameter names match
 
 DEPENDENCIES
    N/A
 
 RETURN VALUE
-   0: Table filled successfully
-   1: No more parameters to read
-  -1: Error filling table
+   None
 
 SIDE EFFECTS
    N/A
 ===========================================================================*/
-int loc_read_conf_r(FILE *conf_fp, loc_param_s_type* config_table, uint32_t table_length)
+void loc_set_config_entry(loc_param_s_type* config_entry, loc_param_v_type* config_value)
 {
-    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;
-    if(conf_fp == NULL) {
-        LOC_LOGE("%s:%d]: ERROR: File pointer is NULL\n", __func__, __LINE__);
-        ret = -1;
-        goto err;
-    }
-
-    /* Clear all validity bits */
-    for(i = 0; NULL != config_table && i < table_length; i++)
-    {
-        if(NULL != config_table[i].param_set)
-        {
-            *(config_table[i].param_set) = 0;
-        }
-    }
-    LOC_LOGD("%s:%d]: num_params: %d\n", __func__, __LINE__, num_params);
-    while(num_params)
-    {
-        if(!fgets(input_buf, LOC_MAX_PARAM_LINE, conf_fp)) {
-            LOC_LOGD("%s:%d]: fgets returned NULL\n", __func__, __LINE__);
-            break;
-        }
-
-        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 == 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 */
-        }
-
-        for(i = 0; NULL != config_table && i < table_length; i++)
-        {
-            if(!loc_set_config_entry(&config_table[i], &config_value)) {
-                num_params--;
-            }
-        }
-    }
-
-err:
-    return ret;
+   if(NULL == config_entry || NULL == config_value)
+   {
+      LOC_LOGE("%s: INVALID config entry or parameter", __FUNCTION__);
+      return;
+   }
+
+   if (strcmp(config_entry->param_name, config_value->param_name) == 0 &&
+               config_entry->param_ptr)
+   {
+      switch (config_entry->param_type)
+      {
+      case 's':
+         if (strcmp(config_value->param_str_value, "NULL") == 0)
+         {
+            *((char*)config_entry->param_ptr) = '\0';
+         }
+         else {
+            strlcpy((char*) config_entry->param_ptr,
+                  config_value->param_str_value,
+                  LOC_MAX_PARAM_STRING + 1);
+         }
+         /* Log INI values */
+         LOC_LOGD("%s: PARAM %s = %s", __FUNCTION__, config_entry->param_name, (char*)config_entry->param_ptr);
+
+         if(NULL != config_entry->param_set)
+         {
+            *(config_entry->param_set) = 1;
+         }
+         break;
+      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);
+
+         if(NULL != config_entry->param_set)
+         {
+            *(config_entry->param_set) = 1;
+         }
+         break;
+      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);
+
+         if(NULL != config_entry->param_set)
+         {
+            *(config_entry->param_set) = 1;
+         }
+         break;
+      default:
+         LOC_LOGE("%s: PARAM %s parameter type must be n, f, or s", __FUNCTION__, config_entry->param_name);
+      }
+   }
 }
 
-typedef struct loc_param_v_type
-{
-   char* param_name;
-
-   char* param_str_value;
-   int param_int_value;
-   double param_double_value;
-}loc_param_v_type;
-
 /*===========================================================================
 FUNCTION loc_read_conf
 
@@ -285,25 +215,72 @@ RETURN VALUE
 SIDE EFFECTS
    N/A
 ===========================================================================*/
-void loc_read_conf(const char* conf_file_name, 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)
 {
-    FILE *gps_conf_fp = NULL;
-    char input_buf[LOC_MAX_PARAM_LINE];  /* declare a char array */
-    char *lasts;
-    loc_param_v_type config_value;
-    uint32_t i;
-
-    if((gps_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(gps_conf_fp, loc_parameter_table, loc_param_num);
-        fclose(gps_conf_fp);
-    }
-    /* Initialize logging mechanism with parsed data */
-    loc_logger_init(DEBUG_LEVEL, TIMESTAMP);
+   FILE *gps_conf_fp = NULL;
+   char input_buf[LOC_MAX_PARAM_LINE];  /* declare a char array */
+   char *lasts;
+   loc_param_v_type config_value;
+   uint32_t i;
+
+   if((gps_conf_fp = fopen(conf_file_name, "r")) != NULL)
+   {
+      LOC_LOGD("%s: using %s", __FUNCTION__, conf_file_name);
+   }
+   else
+   {
+      LOC_LOGW("%s: no %s file found", __FUNCTION__, conf_file_name);
+      loc_logger_init(DEBUG_LEVEL, TIMESTAMP);
+      return; /* no parameter file */
+   }
+
+   /* Clear all validity bits */
+   for(i = 0; NULL != config_table && i < table_length; i++)
+   {
+      if(NULL != config_table[i].param_set)
+      {
+         *(config_table[i].param_set) = 0;
+      }
+   }
+
+   while(fgets(input_buf, LOC_MAX_PARAM_LINE, gps_conf_fp) != NULL)
+   {
+      memset(&config_value, 0, sizeof(config_value));
+
+      /* Separate variable and value */
+      config_value.param_name = strtok_r(input_buf, "=", &lasts);
+      if (config_value.param_name == NULL) continue;       /* skip lines that do not contain "=" */
+      config_value.param_str_value = strtok_r(NULL, "=", &lasts);
+      if (config_value.param_str_value == NULL) continue;  /* skip lines that do not contain two operands */
+
+      /* Trim leading and trailing spaces */
+      trim_space(config_value.param_name);
+      trim_space(config_value.param_str_value);
+
+      /* Parse numerical value */
+      if (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(i = 0; NULL != config_table && i < table_length; i++)
+      {
+         loc_set_config_entry(&config_table[i], &config_value);
+      }
+
+      for(i = 0; i < loc_param_num; i++)
+      {
+         loc_set_config_entry(&loc_parameter_table[i], &config_value);
+      }
+   }
+
+   fclose(gps_conf_fp);
+
+   /* Initialize logging mechanism with parsed data */
+   loc_logger_init(DEBUG_LEVEL, TIMESTAMP);
 }
diff --git a/utils/loc_cfg.h b/utils/loc_cfg.h
index 268f4c2..df83338 100644
--- a/utils/loc_cfg.h
+++ b/utils/loc_cfg.h
@@ -1,4 +1,4 @@
-/* Copyright (c) 2011-2014, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2011-2013, 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,7 +30,6 @@
 #ifndef LOC_CFG_H
 #define LOC_CFG_H
 
-#include <stdio.h>
 #include <stdint.h>
 
 #define LOC_MAX_PARAM_NAME                 48
@@ -76,7 +75,7 @@ extern "C" {
 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);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/utils/loc_log.cpp b/utils/loc_log.cpp
index 392966e..f755d70 100644
--- a/utils/loc_log.cpp
+++ b/utils/loc_log.cpp
@@ -112,7 +112,7 @@ loc_name_val_s_type target_name[] =
     NAME_VAL(GNSS_MSM),
     NAME_VAL(GNSS_GSS),
     NAME_VAL(GNSS_MDM),
-    NAME_VAL(GNSS_QCA1530),
+    NAME_VAL(GNSS_GRIFFON),
     NAME_VAL(GNSS_UNKNOWN)
 };
 
@@ -134,18 +134,18 @@ RETURN VALUE
 const char *loc_get_target_name(unsigned int target)
 {
     int index = 0;
-    static char ret[BUFFER_SIZE];
+    char ret[BUFFER_SIZE];
 
     index =  getTargetGnssType(target);
     if( index >= target_name_num || index < 0)
         index = target_name_num - 1;
 
     if( (target & HAS_SSC) == HAS_SSC ) {
-        snprintf(ret, sizeof(ret), " %s with SSC",
+        sprintf(ret, " %s with SSC",
            loc_get_name_from_val(target_name, target_name_num, (long)index) );
     }
     else {
-       snprintf(ret, sizeof(ret), " %s  without SSC",
+       sprintf(ret, " %s  without SSC",
            loc_get_name_from_val(target_name, target_name_num, (long)index) );
     }
     return ret;
@@ -200,12 +200,6 @@ 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/utils/loc_misc_utils.cpp b/utils/loc_misc_utils.cpp
deleted file mode 100644
index 7e96313..0000000
--- a/utils/loc_misc_utils.cpp
+++ /dev/null
@@ -1,114 +0,0 @@
-/* Copyright (c) 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
- * met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above
- *       copyright notice, this list of conditions and the following
- *       disclaimer in the documentation and/or other materials provided
- *       with the distribution.
- *     * Neither the name of The Linux Foundation, nor the names of its
- *       contributors may be used to endorse or promote products derived
- *       from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-#include <stdio.h>
-#include <string.h>
-#include <log_util.h>
-#include <loc_misc_utils.h>
-#include <ctype.h>
-
-#define LOG_NDDEBUG 0
-#define LOG_TAG "LocSvc_misc_utils"
-
-int loc_util_split_string(char *raw_string, char **split_strings_ptr,
-                          int max_num_substrings, char delimiter)
-{
-    int raw_string_index=0;
-    int num_split_strings=0;
-    unsigned char end_string=0;
-    int raw_string_length=0;
-
-    if(!raw_string || !split_strings_ptr) {
-        LOC_LOGE("%s:%d]: NULL parameters", __func__, __LINE__);
-        num_split_strings = -1;
-        goto err;
-    }
-    LOC_LOGD("%s:%d]: raw string: %s\n", __func__, __LINE__, raw_string);
-    raw_string_length = strlen(raw_string) + 1;
-    split_strings_ptr[num_split_strings] = &raw_string[raw_string_index];
-    for(raw_string_index=0; raw_string_index < raw_string_length; raw_string_index++) {
-        if(raw_string[raw_string_index] == '\0')
-            end_string=1;
-        if((raw_string[raw_string_index] == delimiter) || end_string) {
-            raw_string[raw_string_index] = '\0';
-            LOC_LOGD("%s:%d]: split string: %s\n",
-                     __func__, __LINE__, split_strings_ptr[num_split_strings]);
-            num_split_strings++;
-            if(((raw_string_index + 1) < raw_string_length) &&
-               (num_split_strings < max_num_substrings)) {
-                split_strings_ptr[num_split_strings] = &raw_string[raw_string_index+1];
-            }
-            else {
-                break;
-            }
-        }
-        if(end_string)
-            break;
-    }
-err:
-    LOC_LOGD("%s:%d]: num_split_strings: %d\n", __func__, __LINE__, num_split_strings);
-    return num_split_strings;
-}
-
-void loc_util_trim_space(char *org_string)
-{
-    char *scan_ptr, *write_ptr;
-    char *first_nonspace = NULL, *last_nonspace = NULL;
-
-    if(org_string == NULL) {
-        LOC_LOGE("%s:%d]: NULL parameter", __func__, __LINE__);
-        goto err;
-    }
-
-    scan_ptr = write_ptr = org_string;
-
-    while (*scan_ptr) {
-        //Find the first non-space character
-        if ( !isspace(*scan_ptr) && first_nonspace == NULL) {
-            first_nonspace = scan_ptr;
-        }
-        //Once the first non-space character is found in the
-        //above check, keep shifting the characters to the left
-        //to replace the spaces
-        if (first_nonspace != NULL) {
-            *(write_ptr++) = *scan_ptr;
-            //Keep track of which was the last non-space character
-            //encountered
-            //last_nonspace will not be updated in the case where
-            //the string ends with spaces
-            if ( !isspace(*scan_ptr)) {
-                last_nonspace = write_ptr;
-            }
-        }
-        scan_ptr++;
-    }
-    //Add NULL terminator after the last non-space character
-    if (last_nonspace) { *last_nonspace = '\0'; }
-err:
-    return;
-}
diff --git a/utils/loc_misc_utils.h b/utils/loc_misc_utils.h
deleted file mode 100644
index 7d66d84..0000000
--- a/utils/loc_misc_utils.h
+++ /dev/null
@@ -1,99 +0,0 @@
-/* Copyright (c) 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
- * met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above
- *       copyright notice, this list of conditions and the following
- *       disclaimer in the documentation and/or other materials provided
- *       with the distribution.
- *     * Neither the name of The Linux Foundation, nor the names of its
- *       contributors may be used to endorse or promote products derived
- *       from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-#ifndef _LOC_MISC_UTILS_H_
-#define _LOC_MISC_UTILS_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*===========================================================================
-FUNCTION loc_split_string
-
-DESCRIPTION:
-    This function is used to split a delimiter separated string into
-    sub-strings. This function does not allocate new memory to store the split
-    strings. Instead, it places '\0' in places of delimiters and assings the
-    starting address of the substring within the raw string as the string address
-    The input raw_string no longer remains to be a collection of sub-strings
-    after this function is executed.
-    Please make a copy of the input string before calling this function if
-    necessary
-
-PARAMETERS:
-    char *raw_string: is the original string with delimiter separated substrings
-    char **split_strings_ptr: is the arraw of pointers which will hold the addresses
-                              of individual substrings
-    int max_num_substrings: is the maximum number of substrings that are expected
-                            by the caller. The array of pointers in the above parameter
-                            is usually this long
-    char delimiter: is the delimiter that separates the substrings. Examples: ' ', ';'
-
-DEPENDENCIES
-    N/A
-
-RETURN VALUE
-    int Number of split strings
-
-SIDE EFFECTS
-    The input raw_string no longer remains a delimiter separated single string.
-
-EXAMPLE
-    delimiter = ' ' //space
-    raw_string = "hello new user" //delimiter is space ' '
-    addresses  =  0123456789abcd
-    split_strings_ptr[0] = &raw_string[0]; //split_strings_ptr[0] contains "hello"
-    split_strings_ptr[1] = &raw_string[6]; //split_strings_ptr[1] contains "new"
-    split_strings_ptr[2] = &raw_string[a]; //split_strings_ptr[2] contains "user"
-
-===========================================================================*/
-int loc_util_split_string(char *raw_string, char **split_strings_ptr, int max_num_substrings,
-                     char delimiter);
-
-/*===========================================================================
-FUNCTION trim_space
-
-DESCRIPTION
-   Removes leading and trailing spaces of the string
-
-DEPENDENCIES
-   N/A
-
-RETURN VALUE
-   None
-
-SIDE EFFECTS
-   N/A
-===========================================================================*/
-void loc_util_trim_space(char *org_string);
-#ifdef __cplusplus
-}
-#endif
-
-#endif //_LOC_MISC_UTILS_H_
diff --git a/utils/loc_target.cpp b/utils/loc_target.cpp
index d46747a..26df4cb 100644
--- a/utils/loc_target.cpp
+++ b/utils/loc_target.cpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2012-2014, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2012, 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
@@ -56,14 +56,8 @@
 #define LENGTH(s) (sizeof(s) - 1)
 #define GPS_CHECK_NO_ERROR 0
 #define GPS_CHECK_NO_GPS_HW 1
-/* 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"
 
-static unsigned int gTarget = (unsigned int)-1;
+static int gss_fd = 0;
 
 static int read_a_line(const char * file_path, char * line, int line_size)
 {
@@ -87,132 +81,29 @@ static int read_a_line(const char * file_path, char * line, int line_size)
     return result;
 }
 
-/*!
- * \brief Checks if QCA1530 is avalable.
- *
- * Function verifies if qca1530 SoC is configured on the device. The test is
- * based on property value. For 1530 scenario, the value shall be one of the
- * following: "yes", "no", "detect". All other values are treated equally to
- * "no". When the value is "detect" the system waits for SoC detection to
- * finish before returning result.
- *
- * \retval true - QCA1530 is available.
- * \retval false - QCA1530 is not available.
- */
-static bool is_qca1530(void)
-{
-    static const char qca1530_property_name[] = "sys.qca1530";
-    bool res = false;
-    int ret, i;
-    char buf[PROPERTY_VALUE_MAX];
-
-    memset(buf, 0, sizeof(buf));
-
-    for (i = 0; i < QCA1530_DETECT_TIMEOUT; ++i)
-    {
-        ret = property_get(qca1530_property_name, buf, NULL);
-        if (ret < 0)
-        {
-            LOC_LOGV( "qca1530: property %s is not accessible, ret=%d",
-                  qca1530_property_name,
-                  ret);
-
-            break;
-        }
-
-        LOC_LOGV( "qca1530: property %s is set to %s",
-                  qca1530_property_name,
-                  buf);
-
-        if (!memcmp(buf, QCA1530_DETECT_PRESENT,
-                    sizeof(QCA1530_DETECT_PRESENT)))
-        {
-            res = true;
-            break;
-        }
-        if (!memcmp(buf, QCA1530_DETECT_PROGRESS,
-                    sizeof(QCA1530_DETECT_PROGRESS)))
-        {
-            LOC_LOGV("qca1530: SoC detection is in progress.");
-            sleep(1);
-            continue;
-        }
-        break;
-    }
-
-    LOC_LOGD("qca1530: detected=%s", res ? "true" : "false");
-    return res;
-}
-
-/*The character array passed to this function should have length
-  of atleast PROPERTY_VALUE_MAX*/
-void loc_get_target_baseband(char *baseband, int array_length)
-{
-    if(baseband && (array_length >= PROPERTY_VALUE_MAX)) {
-        property_get("ro.baseband", baseband, "");
-        LOC_LOGD("%s:%d]: Baseband: %s\n", __func__, __LINE__, baseband);
-    }
-    else {
-        LOC_LOGE("%s:%d]: NULL parameter or array length less than PROPERTY_VALUE_MAX\n",
-                 __func__, __LINE__);
-    }
-}
-
-/*The character array passed to this function should have length
-  of atleast PROPERTY_VALUE_MAX*/
-void loc_get_platform_name(char *platform_name, int array_length)
-{
-    if(platform_name && (array_length >= PROPERTY_VALUE_MAX)) {
-        property_get("ro.board.platform", platform_name, "");
-        LOC_LOGD("%s:%d]: Target name: %s\n", __func__, __LINE__, platform_name);
-    }
-    else {
-        LOC_LOGE("%s:%d]: Null parameter or array length less than PROPERTY_VALUE_MAX\n",
-                 __func__, __LINE__);
-    }
-}
-
-unsigned int loc_get_target(void)
+unsigned int get_target(void)
 {
-    if (gTarget != (unsigned int)-1)
-        return gTarget;
+    unsigned int target = TARGET_DEFAULT;
 
-    static const char hw_platform[]      = "/sys/devices/soc0/hw_platform";
-    static const char id[]               = "/sys/devices/soc0/soc_id";
-    static const char hw_platform_dep[]  =
-        "/sys/devices/system/soc/soc0/hw_platform";
-    static const char id_dep[]           = "/sys/devices/system/soc/soc0/id";
-    static const char mdm[]              = "/dev/mdm"; // No such file or directory
+    char hw_platform[]      = "/sys/devices/system/soc/soc0/hw_platform";
+    char id[]               = "/sys/devices/system/soc/soc0/id";
+    char mdm[]              = "/dev/mdm"; // No such file or directory
 
     char rd_hw_platform[LINE_LEN];
     char rd_id[LINE_LEN];
     char rd_mdm[LINE_LEN];
     char baseband[LINE_LEN];
 
-    if (is_qca1530()) {
-        gTarget = TARGET_QCA1530;
-        goto detected;
-    }
-
-    loc_get_target_baseband(baseband, sizeof(baseband));
-
-    if (!access(hw_platform, F_OK)) {
-        read_a_line(hw_platform, rd_hw_platform, LINE_LEN);
-    } else {
-        read_a_line(hw_platform_dep, rd_hw_platform, LINE_LEN);
-    }
-    if (!access(id, F_OK)) {
-        read_a_line(id, rd_id, LINE_LEN);
-    } else {
-        read_a_line(id_dep, rd_id, LINE_LEN);
-    }
+    property_get("ro.baseband", baseband, "");
+    read_a_line(hw_platform, rd_hw_platform, LINE_LEN);
+    read_a_line( id, rd_id, LINE_LEN);
 
     if( !memcmp(baseband, STR_APQ, LENGTH(STR_APQ)) ){
         if( !memcmp(rd_id, MPQ8064_ID_1, LENGTH(MPQ8064_ID_1))
             && IS_STR_END(rd_id[LENGTH(MPQ8064_ID_1)]) )
-            gTarget = TARGET_MPQ;
+            target = TARGET_MPQ;
         else
-            gTarget = TARGET_APQ_SA;
+            target = TARGET_APQ_SA;
     }
     else {
         if( (!memcmp(rd_hw_platform, STR_LIQUID, LENGTH(STR_LIQUID))
@@ -223,18 +114,13 @@ unsigned int loc_get_target(void)
              && IS_STR_END(rd_hw_platform[LENGTH(STR_MTP)]))) {
 
             if (!read_a_line( mdm, rd_mdm, LINE_LEN))
-                gTarget = TARGET_MDM;
+                target = TARGET_MDM;
         }
         else if( (!memcmp(rd_id, MSM8930_ID_1, LENGTH(MSM8930_ID_1))
                    && IS_STR_END(rd_id[LENGTH(MSM8930_ID_1)])) ||
                   (!memcmp(rd_id, MSM8930_ID_2, LENGTH(MSM8930_ID_2))
                    && IS_STR_END(rd_id[LENGTH(MSM8930_ID_2)])) )
-             gTarget = TARGET_MSM_NO_SSC;
-        else
-             gTarget = TARGET_UNKNOWN;
+             target = TARGET_MSM_NO_SSC;
     }
-
-detected:
-    LOC_LOGD("HAL: %s returned %d", __FUNCTION__, gTarget);
-    return gTarget;
+    return target;
 }
diff --git a/utils/loc_target.h b/utils/loc_target.h
index 9aa525f..12cff1d 100644
--- a/utils/loc_target.h
+++ b/utils/loc_target.h
@@ -1,4 +1,4 @@
-/* Copyright (c) 2012-2014, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2012, 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
@@ -34,8 +34,6 @@
 #define TARGET_APQ_SA        TARGET_SET(GNSS_GSS, NO_SSC)
 #define TARGET_MPQ           TARGET_SET(GNSS_NONE,NO_SSC)
 #define TARGET_MSM_NO_SSC    TARGET_SET(GNSS_MSM, NO_SSC)
-#define TARGET_QCA1530       TARGET_SET(GNSS_QCA1530, NO_SSC)
-#define TARGET_UNKNOWN       TARGET_SET(GNSS_UNKNOWN, NO_SSC)
 #define getTargetGnssType(target)  (target>>1)
 
 #ifdef __cplusplus
@@ -43,23 +41,14 @@ extern "C"
 {
 #endif
 
-unsigned int loc_get_target(void);
+unsigned int get_target(void);
 
-/*The character array passed to this function should have length
-  of atleast PROPERTY_VALUE_MAX*/
-void loc_get_target_baseband(char *baseband, int array_length);
-/*The character array passed to this function should have length
-  of atleast PROPERTY_VALUE_MAX*/
-void loc_get_platform_name(char *platform_name, int array_length);
-
-/* Please remember to update 'target_name' in loc_log.cpp,
-   if do any changes to this enum. */
 typedef enum {
     GNSS_NONE = 0,
     GNSS_MSM,
     GNSS_GSS,
     GNSS_MDM,
-    GNSS_QCA1530,
+    GNSS_GRIFFON,
     GNSS_UNKNOWN
 }GNSS_TARGET;
 
diff --git a/utils/loc_timer.c b/utils/loc_timer.c
index 1e4008e..13f7786 100644
--- a/utils/loc_timer.c
+++ b/utils/loc_timer.c
@@ -34,153 +34,124 @@
 #include<time.h>
 #include<errno.h>
 
-enum timer_state {
-    READY = 100,
-    WAITING,
-    DONE,
-    ABORT
-};
+#define MAX_DELAY_RETRIES 3
 
 typedef struct {
     loc_timer_callback callback_func;
     void *user_data;
     unsigned int time_msec;
-    pthread_cond_t timer_cond;
-    pthread_mutex_t timer_mutex;
-    enum timer_state state;
 }timer_data;
 
 static void *timer_thread(void *thread_data)
 {
-    int ret = -ETIMEDOUT;
+    int ret;
+    unsigned char retries=0;
     struct timespec ts;
     struct timeval tv;
-    timer_data* t = (timer_data*)thread_data;
+    timer_data t;
+    t.callback_func = ((timer_data *)thread_data)->callback_func;
+    t.user_data = ((timer_data *)thread_data)->user_data;
+    t.time_msec = ((timer_data *)thread_data)->time_msec;
+    pthread_cond_t timer_cond;
+    pthread_mutex_t timer_mutex;
 
-    LOC_LOGD("%s:%d]: Enter. Delay = %d\n", __func__, __LINE__, t->time_msec);
+    LOC_LOGD("%s:%d]: Enter. Delay = %d\n", __func__, __LINE__, t.time_msec);
+    //Copied over all info into local variable. Do not need allocated struct
+    free(thread_data);
 
-    gettimeofday(&tv, NULL);
-    clock_gettime(CLOCK_REALTIME, &ts);
-    if(t->time_msec >= 1000) {
-        ts.tv_sec += t->time_msec/1000;
-        t->time_msec = t->time_msec % 1000;
-    }
-    if(t->time_msec)
-        ts.tv_nsec += t->time_msec * 1000000;
-    if(ts.tv_nsec > 999999999) {
-        LOC_LOGD("%s:%d]: Large nanosecs\n", __func__, __LINE__);
-        ts.tv_sec += 1;
-        ts.tv_nsec -= 1000000000;
+    if(pthread_cond_init(&timer_cond, NULL)) {
+        LOC_LOGE("%s:%d]: Pthread cond init failed\n", __func__, __LINE__);
+        ret = -1;
+        goto err;
     }
-    LOC_LOGD("%s:%d]: ts.tv_sec:%d; ts.tv_nsec:%d\n"
-             "\t Current time: %d sec; %d nsec",
-             __func__, __LINE__, (int)ts.tv_sec, (int)ts.tv_nsec,
-             (int)tv.tv_sec, (int)tv.tv_usec*1000);
-
-    pthread_mutex_lock(&(t->timer_mutex));
-    if (READY == t->state) {
-        t->state = WAITING;
-        ret = pthread_cond_timedwait(&t->timer_cond, &t->timer_mutex, &ts);
-        t->state = DONE;
+    if(pthread_mutex_init(&timer_mutex, NULL)) {
+        LOC_LOGE("%s:%d]: Pthread mutex init failed\n", __func__, __LINE__);
+        ret = -1;
+        goto mutex_err;
     }
-    pthread_mutex_unlock(&(t->timer_mutex));
-
-    switch (ret) {
-    case ETIMEDOUT:
-        LOC_LOGV("%s:%d]: loc_timer timed out",  __func__, __LINE__);
-        break;
-    case 0:
-        LOC_LOGV("%s:%d]: loc_timer stopped",  __func__, __LINE__);
-        break;
-    case -ETIMEDOUT:
-        LOC_LOGV("%s:%d]: loc_timer cancelled",  __func__, __LINE__);
-        break;
-    default:
-        LOC_LOGE("%s:%d]: Call to pthread timedwait failed; ret=%d\n",
-                 __func__, __LINE__, ret);
-        break;
+    while(retries < MAX_DELAY_RETRIES) {
+        gettimeofday(&tv, NULL);
+        clock_gettime(CLOCK_REALTIME, &ts);
+        if(t.time_msec >= 1000) {
+            ts.tv_sec += t.time_msec/1000;
+            t.time_msec = t.time_msec % 1000;
+        }
+        if(t.time_msec)
+            ts.tv_nsec += t.time_msec * 1000000;
+        if(ts.tv_nsec > 999999999) {
+            LOC_LOGD("%s:%d]: Large nanosecs\n", __func__, __LINE__);
+            ts.tv_sec += 1;
+            ts.tv_nsec -= 1000000000;
+        }
+        LOC_LOGD("%s:%d]: ts.tv_sec:%d; ts.tv_nsec:%d\n",
+                 __func__, __LINE__, (int)ts.tv_sec, (int)ts.tv_nsec);
+        LOC_LOGD("%s:%d]: Current time: %d sec; %d nsec\n",
+                 __func__, __LINE__, (int)tv.tv_sec, (int)tv.tv_usec*1000);
+        pthread_mutex_lock(&(timer_mutex));
+        ret = pthread_cond_timedwait(&timer_cond, &timer_mutex, &ts);
+        pthread_mutex_unlock(&(timer_mutex));
+        if(ret != ETIMEDOUT) {
+            LOC_LOGE("%s:%d]: Call to pthread timedwait failed; ret=%d\n",
+                     __func__, __LINE__,ret);
+            ret = -1;
+            retries++;
+        }
+        else {
+            ret = 0;
+            break;
+        }
     }
 
-    pthread_mutex_destroy(&t->timer_mutex);
-    pthread_cond_destroy(&t->timer_cond);
-
-    if(ETIMEDOUT == ret)
-        t->callback_func(t->user_data, ret);
-
-    free(t);
+    pthread_mutex_destroy(&timer_mutex);
+mutex_err:
+    pthread_cond_destroy(&timer_cond);
+err:
+    if(!ret)
+        t.callback_func(t.user_data, ret);
     LOC_LOGD("%s:%d]: Exit\n", __func__, __LINE__);
     return NULL;
 }
 
-void* loc_timer_start(unsigned int msec, loc_timer_callback cb_func,
-                      void* caller_data)
+int loc_timer_start(unsigned int msec, loc_timer_callback cb_func,
+                    void* caller_data)
 {
+    int ret=0;
     timer_data *t=NULL;
     pthread_attr_t tattr;
     pthread_t id;
     LOC_LOGD("%s:%d]: Enter\n", __func__, __LINE__);
     if(cb_func == NULL || msec == 0) {
         LOC_LOGE("%s:%d]: Error: Wrong parameters\n", __func__, __LINE__);
-        goto _err;
+        ret = -1;
+        goto err;
     }
     t = (timer_data *)calloc(1, sizeof(timer_data));
     if(t == NULL) {
         LOC_LOGE("%s:%d]: Could not allocate memory. Failing.\n",
                  __func__, __LINE__);
-        goto _err;
-    }
-
-    if(pthread_cond_init(&(t->timer_cond), NULL)) {
-        LOC_LOGE("%s:%d]: Pthread cond init failed\n", __func__, __LINE__);
-        goto t_err;
-    }
-    if(pthread_mutex_init(&(t->timer_mutex), NULL)) {
-        LOC_LOGE("%s:%d]: Pthread mutex init failed\n", __func__, __LINE__);
-        goto cond_err;
+        ret = -1;
+        goto err;
     }
 
     t->callback_func = cb_func;
     t->user_data = caller_data;
     t->time_msec = msec;
-    t->state = READY;
 
-    if (pthread_attr_init(&tattr)) {
-        LOC_LOGE("%s:%d]: Pthread mutex init failed\n", __func__, __LINE__);
-        goto mutex_err;
-    }
+    pthread_attr_init(&tattr);
     pthread_attr_setdetachstate(&tattr, PTHREAD_CREATE_DETACHED);
-
     if(pthread_create(&(id), &tattr, timer_thread, (void *)t)) {
         LOC_LOGE("%s:%d]: Could not create thread\n", __func__, __LINE__);
+        ret = -1;
         goto attr_err;
     }
-
-    LOC_LOGD("%s:%d]: Created thread with id: %d\n",
-             __func__, __LINE__, (int)id);
-    goto _err;
+    else {
+        LOC_LOGD("%s:%d]: Created thread with id: %d\n",
+                 __func__, __LINE__, (int)id);
+    }
 
 attr_err:
     pthread_attr_destroy(&tattr);
-mutex_err:
-    pthread_mutex_destroy(&t->timer_mutex);
-cond_err:
-    pthread_cond_destroy(&t->timer_cond);
-t_err:
-    free(t);
-_err:
+err:
     LOC_LOGD("%s:%d]: Exit\n", __func__, __LINE__);
-    return t;
-}
-
-void loc_timer_stop(void* handle) {
-    timer_data* t = (timer_data*)handle;
-
-    if (NULL != t && (READY == t->state || WAITING == t->state)) {
-        pthread_mutex_lock(&(t->timer_mutex));
-        if (READY == t->state || WAITING == t->state) {
-            pthread_cond_signal(&t->timer_cond);
-            t->state = ABORT;
-        }
-        pthread_mutex_unlock(&(t->timer_mutex));
-    }
+    return ret;
 }
diff --git a/utils/loc_timer.h b/utils/loc_timer.h
index 0034d27..213da20 100644
--- a/utils/loc_timer.h
+++ b/utils/loc_timer.h
@@ -43,19 +43,10 @@ extern "C" {
 */
 typedef void(*loc_timer_callback)(void *user_data, int result);
 
-
-/*
-  Returns the handle, which can be used to stop the timer
-*/
-void* loc_timer_start(unsigned int delay_msec,
-                      loc_timer_callback,
-                      void* user_data);
-
-/*
-  handle becomes invalid upon the return of the callback
-*/
-void loc_timer_stop(void* handle);
-
+//int loc_timer_start(loc_timer_client_data *p_thread);
+int loc_timer_start(unsigned int delay_msec,
+                    loc_timer_callback,
+                    void* user_data);
 #ifdef __cplusplus
 }
 #endif /* __cplusplus */
diff --git a/utils/log_util.h b/utils/log_util.h
index 8ff6b5a..7fb0c78 100644
--- a/utils/log_util.h
+++ b/utils/log_util.h
@@ -1,4 +1,4 @@
-/* Copyright (c) 2011-2014 The Linux Foundation. All rights reserved.
+/* Copyright (c) 2011 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
@@ -96,47 +96,37 @@ extern char* get_timestamp(char* str, unsigned long buf_size);
   if that value remains unchanged, it means gps.conf did not
   provide a value and we default to the initial value to use
   Android's logging levels*/
-#define IF_LOC_LOGE if((loc_logger.DEBUG_LEVEL >= 1) && (loc_logger.DEBUG_LEVEL <= 5))
-
-#define IF_LOC_LOGW if((loc_logger.DEBUG_LEVEL >= 2) && (loc_logger.DEBUG_LEVEL <= 5))
-
-#define IF_LOC_LOGI if((loc_logger.DEBUG_LEVEL >= 3) && (loc_logger.DEBUG_LEVEL <= 5))
-
-#define IF_LOC_LOGD if((loc_logger.DEBUG_LEVEL >= 4) && (loc_logger.DEBUG_LEVEL <= 5))
-
-#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__); }
+if ((loc_logger.DEBUG_LEVEL >= 1) && (loc_logger.DEBUG_LEVEL <= 5)) { ALOGE("W/"__VA_ARGS__); } \
+else if (loc_logger.DEBUG_LEVEL == 0xff) { ALOGE("W/"__VA_ARGS__); }
 
 #define LOC_LOGW(...) \
-IF_LOC_LOGW { ALOGE("W/" __VA_ARGS__); }  \
-else if (loc_logger.DEBUG_LEVEL == 0xff) { ALOGW("W/" __VA_ARGS__); }
+if ((loc_logger.DEBUG_LEVEL >= 2) && (loc_logger.DEBUG_LEVEL <= 5)) { 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__); }
+if ((loc_logger.DEBUG_LEVEL >= 3) && (loc_logger.DEBUG_LEVEL <= 5)) { 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__); }
+if ((loc_logger.DEBUG_LEVEL >= 4) && (loc_logger.DEBUG_LEVEL <= 5)) { 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__); }
+if ((loc_logger.DEBUG_LEVEL >= 5) && (loc_logger.DEBUG_LEVEL <= 5)) { ALOGE("V/"__VA_ARGS__); }   \
+else if (loc_logger.DEBUG_LEVEL == 0xff) { ALOGV("V/"__VA_ARGS__); }
 
 #else /* DEBUG_DMN_LOC_API */
 
-#define LOC_LOGE(...) ALOGE("E/" __VA_ARGS__)
+#define LOC_LOGE(...) ALOGE("E/"__VA_ARGS__)
 
-#define LOC_LOGW(...) ALOGW("W/" __VA_ARGS__)
+#define LOC_LOGW(...) ALOGW("W/"__VA_ARGS__)
 
-#define LOC_LOGI(...) ALOGI("I/" __VA_ARGS__)
+#define LOC_LOGI(...) ALOGI("I/"__VA_ARGS__)
 
-#define LOC_LOGD(...) ALOGD("D/" __VA_ARGS__)
+#define LOC_LOGD(...) ALOGD("D/"__VA_ARGS__)
 
-#define LOC_LOGV(...) ALOGV("V/" __VA_ARGS__)
+#define LOC_LOGV(...) ALOGV("V/"__VA_ARGS__)
 
 #endif /* DEBUG_DMN_LOC_API */