gps: msm8909w caf release LW.BR.1.0-00410-8x09w.0
MSM8909w GPS HAL code copied from CAF release
LW.BR.1.0-00410-8x09w.0
b61731a Move some debug logs to verbose.
78bb132 Location: reduce memory footprint
0b4a33b missing util header file
56a5a75 set LPP CP as default
9336256 Add support for new sockaddr_storage struct
9b3aa46 another potential race condition
Fixed makefiles to be compatible with PDK without kernel source
Change-Id: I6e73cc7db9d7bdc6a478a3c6b14922578e315dce
diff --git a/Android.mk b/Android.mk
index 7b7c8d5..1535d65 100644
--- a/Android.mk
+++ b/Android.mk
@@ -18,7 +18,10 @@
include $(call all-named-subdir-makefiles,$(GPS_DIRS))
endif #TARGET_BOARD_PLATFORM
-else ifeq ($(filter msm8916,$(TARGET_BOARD_PLATFORM)),)
+else ifneq ($(filter msm8909 ,$(TARGET_BOARD_PLATFORM)),)
+ #For msm8909 target
+ include $(call all-named-subdir-makefiles,msm8909)
+else ifeq ($(filter msm8916 ,$(TARGET_BOARD_PLATFORM)),)
GPS_DIRS=core utils loc_api platform_lib_abstractions etc
include $(call all-named-subdir-makefiles,$(GPS_DIRS))
endif #BOARD_VENDOR_QCOM_LOC_PDK_FEATURE_SET
diff --git a/msm8909/CleanSpec.mk b/msm8909/CleanSpec.mk
new file mode 100644
index 0000000..dd1849d
--- /dev/null
+++ b/msm8909/CleanSpec.mk
@@ -0,0 +1,50 @@
+# Copyright (C) 2007 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+# If you don't need to do a full clean build but would like to touch
+# a file or delete some intermediate files, add a clean step to the end
+# of the list. These steps will only be run once, if they haven't been
+# run before.
+#
+# E.g.:
+# $(call add-clean-step, touch -c external/sqlite/sqlite3.h)
+# $(call add-clean-step, rm -rf $(PRODUCT_OUT)/obj/STATIC_LIBRARIES/libz_intermediates)
+#
+# Always use "touch -c" and "rm -f" or "rm -rf" to gracefully deal with
+# files that are missing or have been moved.
+#
+# Use $(PRODUCT_OUT) to get to the "out/target/product/blah/" directory.
+# Use $(OUT_DIR) to refer to the "out" directory.
+#
+# If you need to re-do something that's already mentioned, just copy
+# the command and add it to the bottom of the list. E.g., if a change
+# that you made last week required touching a file and a change you
+# made today requires touching the same file, just copy the old
+# touch step and add it to the end of the list.
+#
+# ************************************************
+# NEWER CLEAN STEPS MUST BE AT THE END OF THE LIST
+# ************************************************
+
+# For example:
+#$(call add-clean-step, rm -rf $(OUT_DIR)/target/common/obj/APPS/AndroidTests_intermediates)
+#$(call add-clean-step, rm -rf $(OUT_DIR)/target/common/obj/JAVA_LIBRARIES/core_intermediates)
+#$(call add-clean-step, find $(OUT_DIR) -type f -name "IGTalkSession*" -print0 | xargs -0 rm -f)
+#$(call add-clean-step, rm -rf $(PRODUCT_OUT)/data/*)
+
+# ************************************************
+# NEWER CLEAN STEPS MUST BE AT THE END OF THE LIST
+# ************************************************
+$(call add-clean-step, rm -rf $(PRODUCT_OUT)/obj/SHARED_LIBRARIES/libloc_api*)
diff --git a/msm8909/Makefile.am b/msm8909/Makefile.am
new file mode 100644
index 0000000..f374a5c
--- /dev/null
+++ b/msm8909/Makefile.am
@@ -0,0 +1,10 @@
+# Makefile.am - Automake script for gps loc_api
+#
+
+ACLOCAL_AMFLAGS = -I m4
+
+SUBDIRS = utils loc_api/libloc_api_50001 loc_api/loc_api_v02
+
+pkgconfigdir = $(libdir)/pkgconfig
+pkgconfig_DATA = loc-api.pc
+EXTRA_DIST = $(pkgconfig_DATA)
diff --git a/msm8909/configure.ac b/msm8909/configure.ac
new file mode 100644
index 0000000..dca18a1
--- /dev/null
+++ b/msm8909/configure.ac
@@ -0,0 +1,85 @@
+# configure.ac -- Autoconf script for gps loc_api
+#
+# Process this file with autoconf to produce a configure script
+
+# Requires autoconf tool later than 2.61
+AC_PREREQ(2.61)
+# Initialize the gps loc_api package version 1.0.0
+AC_INIT([loc-api],1.0.0)
+# Does not strictly follow GNU Coding standards
+AM_INIT_AUTOMAKE([foreign])
+# Disables auto rebuilding of configure, Makefile.ins
+AM_MAINTAINER_MODE
+# Verifies the --srcdir is correct by checking for the path
+AC_CONFIG_SRCDIR([utils/loc_cfg.cpp])
+# defines some macros variable to be included by source
+AC_CONFIG_HEADERS([config.h])
+AC_CONFIG_MACRO_DIR([m4])
+
+# Checks for programs.
+AC_PROG_LIBTOOL
+AC_PROG_CXX
+AC_PROG_CC
+AM_PROG_CC_C_O
+AC_PROG_AWK
+AC_PROG_CPP
+AC_PROG_INSTALL
+AC_PROG_LN_S
+AC_PROG_MAKE_SET
+PKG_PROG_PKG_CONFIG
+
+# Checks for libraries.
+PKG_CHECK_MODULES([QMIF], [qmi-framework])
+AC_SUBST([QMIF_CFLAGS])
+AC_SUBST([QMIF_LIBS])
+
+AC_ARG_WITH([libhardware_includes],
+ AC_HELP_STRING([--with-libhardware-includes=@<:@dir@:>@],
+ [Specify the location of the libhardware headers]),
+ [libhardware_incdir=$withval],
+ with_libhardware_includes=no)
+
+if test "x$with_libhardware_includes" != "xno"; then
+ CPPFLAGS="${CPPFLAGS} -I${libhardware_incdir}"
+fi
+
+AC_ARG_WITH([core_includes],
+ AC_HELP_STRING([--with-core-includes=@<:@dir@:>@],
+ [Specify the location of the core headers]),
+ [core_incdir=$withval],
+ with_core_includes=no)
+
+if test "x$with_core_includes" != "xno"; then
+ CPPFLAGS="${CPPFLAGS} -I${core_incdir}"
+fi
+
+AC_SUBST([CPPFLAGS])
+
+AC_ARG_WITH([glib],
+ AC_HELP_STRING([--with-glib],
+ [enable glib, building HLOS systems which use glib]))
+
+if (test "x${with_glib}" = "xyes"); then
+ AC_DEFINE(ENABLE_USEGLIB, 1, [Define if HLOS systems uses glib])
+ PKG_CHECK_MODULES(GTHREAD, gthread-2.0 >= 2.16, dummy=yes,
+ AC_MSG_ERROR(GThread >= 2.16 is required))
+ PKG_CHECK_MODULES(GLIB, glib-2.0 >= 2.16, dummy=yes,
+ AC_MSG_ERROR(GLib >= 2.16 is required))
+ GLIB_CFLAGS="$GLIB_CFLAGS $GTHREAD_CFLAGS"
+ GLIB_LIBS="$GLIB_LIBS $GTHREAD_LIBS"
+
+ AC_SUBST(GLIB_CFLAGS)
+ AC_SUBST(GLIB_LIBS)
+fi
+
+AM_CONDITIONAL(USE_GLIB, test "x${with_glib}" = "xyes")
+
+AC_CONFIG_FILES([ \
+ Makefile \
+ utils/Makefile \
+ loc_api/libloc_api_50001/Makefile \
+ loc_api/loc_api_v02/Makefile \
+ loc-api.pc \
+ ])
+
+AC_OUTPUT
diff --git a/msm8909/core/Android.mk b/msm8909/core/Android.mk
new file mode 100644
index 0000000..c6d3128
--- /dev/null
+++ b/msm8909/core/Android.mk
@@ -0,0 +1,58 @@
+ifneq ($(BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE),)
+ifneq ($(BUILD_TINY_ANDROID),true)
+
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := libloc_core
+LOCAL_MODULE_OWNER := qcom
+
+LOCAL_MODULE_TAGS := optional
+
+ifeq ($(TARGET_DEVICE),apq8026_lw)
+LOCAL_CFLAGS += -DPDK_FEATURE_SET
+else ifeq ($(BOARD_VENDOR_QCOM_LOC_PDK_FEATURE_SET),true)
+LOCAL_CFLAGS += -DPDK_FEATURE_SET
+endif
+
+LOCAL_SHARED_LIBRARIES := \
+ libutils \
+ libcutils \
+ libgps.utils \
+ libdl
+
+LOCAL_SRC_FILES += \
+ LocApiBase.cpp \
+ LocAdapterBase.cpp \
+ ContextBase.cpp \
+ LocDualContext.cpp \
+ loc_core_log.cpp
+
+LOCAL_CFLAGS += \
+ -fno-short-enums \
+ -D_ANDROID_
+
+LOCAL_C_INCLUDES:= \
+ $(TARGET_OUT_HEADERS)/gps.utils \
+ $(TARGET_OUT_HEADERS)/libflp
+
+LOCAL_COPY_HEADERS_TO:= libloc_core/
+LOCAL_COPY_HEADERS:= \
+ LocApiBase.h \
+ LocAdapterBase.h \
+ ContextBase.h \
+ LocDualContext.h \
+ LBSProxyBase.h \
+ UlpProxyBase.h \
+ gps_extended_c.h \
+ gps_extended.h \
+ loc_core_log.h \
+ LocAdapterProxyBase.h
+
+LOCAL_PRELINK_MODULE := false
+
+include $(BUILD_SHARED_LIBRARY)
+
+endif # not BUILD_TINY_ANDROID
+endif # BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE
diff --git a/msm8909/core/ContextBase.cpp b/msm8909/core/ContextBase.cpp
new file mode 100644
index 0000000..9f6c4aa
--- /dev/null
+++ b/msm8909/core/ContextBase.cpp
@@ -0,0 +1,114 @@
+/* Copyright (c) 2011-2014, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * 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
+#define LOG_TAG "LocSvc_CtxBase"
+
+#include <dlfcn.h>
+#include <cutils/sched_policy.h>
+#include <unistd.h>
+#include <ContextBase.h>
+#include <msg_q.h>
+#include <loc_target.h>
+#include <log_util.h>
+#include <loc_log.h>
+
+namespace loc_core {
+
+LBSProxyBase* ContextBase::getLBSProxy(const char* libName)
+{
+ LBSProxyBase* proxy = NULL;
+ LOC_LOGD("%s:%d]: getLBSProxy libname: %s\n", __func__, __LINE__, libName);
+ void* lib = dlopen(libName, RTLD_NOW);
+
+ if ((void*)NULL != lib) {
+ getLBSProxy_t* getter = (getLBSProxy_t*)dlsym(lib, "getLBSProxy");
+ if (NULL != getter) {
+ proxy = (*getter)();
+ }
+ }
+ if (NULL == proxy) {
+ proxy = new LBSProxyBase();
+ }
+ LOC_LOGD("%s:%d]: Exiting\n", __func__, __LINE__);
+ return proxy;
+}
+
+LocApiBase* ContextBase::createLocApi(LOC_API_ADAPTER_EVENT_MASK_T exMask)
+{
+ LocApiBase* locApi = NULL;
+
+ // first if can not be MPQ
+ if (TARGET_MPQ != loc_get_target()) {
+ if (NULL == (locApi = mLBSProxy->getLocApi(mMsgTask, exMask, this))) {
+ void *handle = NULL;
+ //try to see if LocApiV02 is present
+ if((handle = dlopen("libloc_api_v02.so", RTLD_NOW)) != NULL) {
+ LOC_LOGD("%s:%d]: libloc_api_v02.so is present", __func__, __LINE__);
+ getLocApi_t* getter = (getLocApi_t*)dlsym(handle, "getLocApi");
+ if(getter != NULL) {
+ LOC_LOGD("%s:%d]: getter is not NULL for LocApiV02", __func__, __LINE__);
+ locApi = (*getter)(mMsgTask, exMask, this);
+ }
+ }
+ // only RPC is the option now
+ else {
+ LOC_LOGD("%s:%d]: libloc_api_v02.so is NOT present. Trying RPC",
+ __func__, __LINE__);
+ handle = dlopen("libloc_api-rpc-qc.so", RTLD_NOW);
+ if (NULL != handle) {
+ getLocApi_t* getter = (getLocApi_t*)dlsym(handle, "getLocApi");
+ if (NULL != getter) {
+ LOC_LOGD("%s:%d]: getter is not NULL in RPC", __func__, __LINE__);
+ locApi = (*getter)(mMsgTask, exMask, this);
+ }
+ }
+ }
+ }
+ }
+
+ // locApi could still be NULL at this time
+ // we would then create a dummy one
+ if (NULL == locApi) {
+ locApi = new LocApiBase(mMsgTask, exMask, this);
+ }
+
+ return locApi;
+}
+
+ContextBase::ContextBase(const MsgTask* msgTask,
+ LOC_API_ADAPTER_EVENT_MASK_T exMask,
+ const char* libName) :
+ mLBSProxy(getLBSProxy(libName)),
+ mMsgTask(msgTask),
+ mLocApi(createLocApi(exMask)),
+ mLocApiProxy(mLocApi->getLocApiProxy())
+{
+}
+
+}
diff --git a/msm8909/core/ContextBase.h b/msm8909/core/ContextBase.h
new file mode 100644
index 0000000..fe0b860
--- /dev/null
+++ b/msm8909/core/ContextBase.h
@@ -0,0 +1,74 @@
+/* Copyright (c) 2011-2015, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * 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_CONTEXT_BASE__
+#define __LOC_CONTEXT_BASE__
+
+#include <stdbool.h>
+#include <ctype.h>
+#include <MsgTask.h>
+#include <LocApiBase.h>
+#include <LBSProxyBase.h>
+
+namespace loc_core {
+
+class LocAdapterBase;
+
+class ContextBase {
+ static LBSProxyBase* getLBSProxy(const char* libName);
+ LocApiBase* createLocApi(LOC_API_ADAPTER_EVENT_MASK_T excludedMask);
+protected:
+ const LBSProxyBase* mLBSProxy;
+ 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 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 void modemPowerVote(bool power) const { return mLBSProxy->modemPowerVote(power); }
+ inline void requestUlp(LocAdapterBase* adapter,
+ unsigned long capabilities) {
+ mLBSProxy->requestUlp(adapter, capabilities);
+ }
+ inline IzatDevId_t getIzatDevId() const {
+ return mLBSProxy->getIzatDevId();
+ }
+ inline void sendMsg(const LocMsg *msg) { getMsgTask()->sendMsg(msg); }
+};
+
+} // namespace loc_core
+
+#endif //__LOC_CONTEXT_BASE__
diff --git a/msm8909/core/LBSProxyBase.h b/msm8909/core/LBSProxyBase.h
new file mode 100644
index 0000000..0faf801
--- /dev/null
+++ b/msm8909/core/LBSProxyBase.h
@@ -0,0 +1,65 @@
+/* Copyright (c) 2013-2015, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * 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 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; }
+ inline virtual void modemPowerVote(bool power) const {}
+ virtual void injectFeatureConfig(ContextBase* context) const {}
+ inline virtual IzatDevId_t getIzatDevId() const { return 0; }
+};
+
+typedef LBSProxyBase* (getLBSProxy_t)();
+
+} // namespace loc_core
+
+#endif // IZAT_PROXY_BASE_H
diff --git a/msm8909/core/LocAdapterBase.cpp b/msm8909/core/LocAdapterBase.cpp
new file mode 100644
index 0000000..8fdb8cb
--- /dev/null
+++ b/msm8909/core/LocAdapterBase.cpp
@@ -0,0 +1,142 @@
+/* Copyright (c) 2011-2014, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * 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
+#define LOG_TAG "LocSvc_LocAdapterBase"
+
+#include <dlfcn.h>
+#include <LocAdapterBase.h>
+#include <loc_target.h>
+#include <log_util.h>
+#include <LocAdapterProxyBase.h>
+
+namespace loc_core {
+
+// 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) :
+ mEvtMask(mask), mContext(context),
+ mLocApi(context->getLocApi()), mLocAdapterProxyBase(adapterProxyBase),
+ mMsgTask(context->getMsgTask())
+{
+ mLocApi->addAdapter(this);
+}
+
+void LocAdapterBase::handleEngineUpEvent()
+{
+ if (mLocAdapterProxyBase) {
+ mLocAdapterProxyBase->handleEngineUpEvent();
+ }
+}
+
+void LocAdapterBase::handleEngineDownEvent()
+{
+ if (mLocAdapterProxyBase) {
+ mLocAdapterProxyBase->handleEngineDownEvent();
+ }
+}
+
+void LocAdapterBase::
+ reportPosition(UlpLocation &location,
+ GpsLocationExtended &locationExtended,
+ void* locationExt,
+ enum loc_sess_status status,
+ LocPosTechMask loc_technology_mask) {
+ if (mLocAdapterProxyBase == NULL ||
+ !mLocAdapterProxyBase->reportPosition(location,
+ locationExtended,
+ status,
+ loc_technology_mask)) {
+ DEFAULT_IMPL()
+ }
+}
+
+void LocAdapterBase::
+ reportSv(GnssSvStatus &svStatus,
+ GpsLocationExtended &locationExtended,
+ void* svExt)
+DEFAULT_IMPL()
+
+
+void LocAdapterBase::
+ reportStatus(GpsStatusValue status)
+DEFAULT_IMPL()
+
+
+void LocAdapterBase::
+ reportNmea(const char* nmea, int length)
+DEFAULT_IMPL()
+
+bool LocAdapterBase::
+ reportXtraServer(const char* url1, const char* url2,
+ const char* url3, const int maxlength)
+DEFAULT_IMPL(false)
+
+bool LocAdapterBase::
+ requestXtraData()
+DEFAULT_IMPL(false)
+
+bool LocAdapterBase::
+ requestTime()
+DEFAULT_IMPL(false)
+
+bool LocAdapterBase::
+ requestLocation()
+DEFAULT_IMPL(false)
+
+bool LocAdapterBase::
+ requestATL(int connHandle, AGpsType agps_type)
+DEFAULT_IMPL(false)
+
+bool LocAdapterBase::
+ releaseATL(int connHandle)
+DEFAULT_IMPL(false)
+
+bool LocAdapterBase::
+ requestSuplES(int connHandle)
+DEFAULT_IMPL(false)
+
+bool LocAdapterBase::
+ reportDataCallOpened()
+DEFAULT_IMPL(false)
+
+bool LocAdapterBase::
+ reportDataCallClosed()
+DEFAULT_IMPL(false)
+
+bool LocAdapterBase::
+ requestNiNotify(GpsNiNotification ¬ify, const void* data)
+DEFAULT_IMPL(false)
+
+void LocAdapterBase::
+ reportGpsMeasurementData(GpsData &gpsMeasurementData)
+DEFAULT_IMPL()
+} // namespace loc_core
diff --git a/msm8909/core/LocAdapterBase.h b/msm8909/core/LocAdapterBase.h
new file mode 100644
index 0000000..5f4660b
--- /dev/null
+++ b/msm8909/core/LocAdapterBase.h
@@ -0,0 +1,119 @@
+/* Copyright (c) 2011-2014, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * 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_API_ADAPTER_BASE_H
+#define LOC_API_ADAPTER_BASE_H
+
+#include <gps_extended.h>
+#include <UlpProxyBase.h>
+#include <ContextBase.h>
+
+namespace loc_core {
+
+class LocAdapterProxyBase;
+
+class LocAdapterBase {
+protected:
+ 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); }
+ LocAdapterBase(const LOC_API_ADAPTER_EVENT_MASK_T mask,
+ ContextBase* context, LocAdapterProxyBase *adapterProxyBase = NULL);
+ inline LOC_API_ADAPTER_EVENT_MASK_T
+ checkMask(LOC_API_ADAPTER_EVENT_MASK_T mask) const {
+ return mEvtMask & mask;
+ }
+
+ inline LOC_API_ADAPTER_EVENT_MASK_T getEvtMask() const {
+ return mEvtMask;
+ }
+
+ inline void sendMsg(const LocMsg* msg) const {
+ mMsgTask->sendMsg(msg);
+ }
+
+ inline void sendMsg(const LocMsg* msg) {
+ mMsgTask->sendMsg(msg);
+ }
+
+ inline void updateEvtMask(LOC_API_ADAPTER_EVENT_MASK_T event,
+ loc_registration_mask_status isEnabled)
+ {
+ mEvtMask =
+ isEnabled == LOC_REGISTRATION_MASK_ENABLED ? (mEvtMask|event):(mEvtMask&~event);
+
+ mLocApi->updateEvtMask();
+ }
+
+ // This will be overridden by the individual adapters
+ // if necessary.
+ inline virtual void setUlpProxy(UlpProxyBase* ulp) {}
+ 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,
+ enum loc_sess_status status,
+ LocPosTechMask loc_technology_mask);
+ virtual void reportSv(GnssSvStatus &svStatus,
+ GpsLocationExtended &locationExtended,
+ void* svExt);
+ virtual void reportStatus(GpsStatusValue status);
+ virtual void reportNmea(const char* nmea, int length);
+ virtual bool reportXtraServer(const char* url1, const char* url2,
+ const char* url3, const int maxlength);
+ virtual bool requestXtraData();
+ virtual bool requestTime();
+ virtual bool requestLocation();
+ virtual bool requestATL(int connHandle, AGpsType agps_type);
+ virtual bool releaseATL(int connHandle);
+ virtual bool requestSuplES(int connHandle);
+ virtual bool reportDataCallOpened();
+ virtual bool reportDataCallClosed();
+ virtual bool requestNiNotify(GpsNiNotification ¬ify,
+ const void* data);
+ inline virtual bool isInSession() { return false; }
+ ContextBase* getContext() const { return mContext; }
+ virtual void reportGpsMeasurementData(GpsData &gpsMeasurementData);
+};
+
+} // namespace loc_core
+
+#endif //LOC_API_ADAPTER_BASE_H
diff --git a/msm8909/core/LocAdapterProxyBase.h b/msm8909/core/LocAdapterProxyBase.h
new file mode 100644
index 0000000..1ddcca4
--- /dev/null
+++ b/msm8909/core/LocAdapterProxyBase.h
@@ -0,0 +1,70 @@
+/* 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_ADAPTER_PROXY_BASE_H
+#define LOC_ADAPTER_PROXY_BASE_H
+
+#include <ContextBase.h>
+#include <gps_extended.h>
+
+namespace loc_core {
+
+class LocAdapterProxyBase {
+private:
+ 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();
+ }
+ inline void updateEvtMask(LOC_API_ADAPTER_EVENT_MASK_T event,
+ loc_registration_mask_status isEnabled) {
+ mLocAdapterBase->updateEvtMask(event,isEnabled);
+ }
+
+public:
+ inline virtual void handleEngineUpEvent() {};
+ inline virtual void handleEngineDownEvent() {};
+ inline virtual bool reportPosition(UlpLocation &location,
+ GpsLocationExtended &locationExtended,
+ enum loc_sess_status status,
+ LocPosTechMask loc_technology_mask) {
+ return false;
+ }
+};
+
+} // namespace loc_core
+
+#endif //LOC_ADAPTER_PROXY_BASE_H
diff --git a/msm8909/core/LocApiBase.cpp b/msm8909/core/LocApiBase.cpp
new file mode 100644
index 0000000..dcd35fe
--- /dev/null
+++ b/msm8909/core/LocApiBase.cpp
@@ -0,0 +1,553 @@
+/* Copyright (c) 2011-2014, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * 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
+#define LOG_TAG "LocSvc_LocApiBase"
+
+#include <dlfcn.h>
+#include <LocApiBase.h>
+#include <LocAdapterBase.h>
+#include <log_util.h>
+#include <LocDualContext.h>
+
+namespace loc_core {
+
+#define TO_ALL_LOCADAPTERS(call) TO_ALL_ADAPTERS(mLocAdapters, (call))
+#define TO_1ST_HANDLING_LOCADAPTERS(call) TO_1ST_HANDLING_ADAPTER(mLocAdapters, (call))
+
+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;
+}
+
+int decodeAddress(char *addr_string, int string_size,
+ const char *data, int data_size)
+{
+ const char addr_prefix = 0x91;
+ int i, idxOutput = 0;
+
+ if (!data || !addr_string) { return 0; }
+
+ if (data[0] != addr_prefix)
+ {
+ LOC_LOGW("decodeAddress: address prefix is not 0x%x but 0x%x", addr_prefix, data[0]);
+ addr_string[0] = '\0';
+ return 0; // prefix not correct
+ }
+
+ for (i = 1; i < data_size; i++)
+ {
+ unsigned char ch = data[i], low = ch & 0x0F, hi = ch >> 4;
+ if (low <= 9 && idxOutput < string_size - 1) { addr_string[idxOutput++] = low + '0'; }
+ if (hi <= 9 && idxOutput < string_size - 1) { addr_string[idxOutput++] = hi + '0'; }
+ }
+
+ addr_string[idxOutput] = '\0'; // Terminates the string
+
+ return idxOutput;
+}
+
+struct LocSsrMsg : public LocMsg {
+ LocApiBase* mLocApi;
+ inline LocSsrMsg(LocApiBase* locApi) :
+ LocMsg(), mLocApi(locApi)
+ {
+ locallog();
+ }
+ inline virtual void proc() const {
+ mLocApi->close();
+ mLocApi->open(mLocApi->getEvtMask());
+ }
+ inline void locallog() {
+ LOC_LOGV("LocSsrMsg");
+ }
+ inline virtual void log() {
+ locallog();
+ }
+};
+
+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), mSupportedMsg(0), mContext(context)
+{
+ memset(mLocAdapters, 0, sizeof(mLocAdapters));
+}
+
+LOC_API_ADAPTER_EVENT_MASK_T LocApiBase::getEvtMask()
+{
+ LOC_API_ADAPTER_EVENT_MASK_T mask = 0;
+
+ TO_ALL_LOCADAPTERS(mask |= mLocAdapters[i]->getEvtMask());
+
+ return mask & ~mExcludedMask;
+}
+
+bool LocApiBase::isInSession()
+{
+ bool inSession = false;
+
+ for (int i = 0;
+ !inSession && i < MAX_ADAPTERS && NULL != mLocAdapters[i];
+ i++) {
+ inSession = mLocAdapters[i]->isInSession();
+ }
+
+ return inSession;
+}
+
+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())));
+ break;
+ }
+ }
+}
+
+void LocApiBase::removeAdapter(LocAdapterBase* adapter)
+{
+ for (int i = 0;
+ i < MAX_ADAPTERS && NULL != mLocAdapters[i];
+ i++) {
+ if (mLocAdapters[i] == adapter) {
+ mLocAdapters[i] = NULL;
+
+ // shift the rest of the adapters up so that the pointers
+ // in the array do not have holes. This should be more
+ // performant, because the array maintenance is much much
+ // less frequent than event handlings, which need to linear
+ // search all the adapters
+ int j = i;
+ while (++i < MAX_ADAPTERS && mLocAdapters[i] != NULL);
+
+ // i would be MAX_ADAPTERS or point to a NULL
+ i--;
+ // i now should point to a none NULL adapter within valid
+ // range although i could be equal to j, but it won't hurt.
+ // No need to check it, as it gains nothing.
+ mLocAdapters[j] = mLocAdapters[i];
+ // this makes sure that we exit the for loop
+ mLocAdapters[i] = NULL;
+
+ // if we have an empty list of adapters
+ if (0 == i) {
+ close();
+ } else {
+ // else we need to remove the bit
+ mMsgTask->sendMsg(new LocOpenMsg(this, getEvtMask()));
+ }
+ }
+ }
+}
+
+void LocApiBase::updateEvtMask()
+{
+ mMsgTask->sendMsg(new LocOpenMsg(this, getEvtMask()));
+}
+
+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());
+}
+
+void LocApiBase::handleEngineDownEvent()
+{
+ // loop through adapters, and deliver to all adapters.
+ TO_ALL_LOCADAPTERS(mLocAdapters[i]->handleEngineDownEvent());
+}
+
+void LocApiBase::reportPosition(UlpLocation &location,
+ GpsLocationExtended &locationExtended,
+ void* locationExt,
+ enum loc_sess_status status,
+ LocPosTechMask loc_technology_mask)
+{
+ // print the location info before delivering
+ LOC_LOGV("flags: %d\n source: %d\n latitude: %f\n longitude: %f\n "
+ "altitude: %f\n speed: %f\n bearing: %f\n accuracy: %f\n "
+ "timestamp: %lld\n rawDataSize: %d\n rawData: %p\n "
+ "Session status: %d\n Technology mask: %u",
+ location.gpsLocation.flags, location.position_source,
+ location.gpsLocation.latitude, location.gpsLocation.longitude,
+ location.gpsLocation.altitude, location.gpsLocation.speed,
+ location.gpsLocation.bearing, location.gpsLocation.accuracy,
+ location.gpsLocation.timestamp, location.rawDataSize,
+ location.rawData, status, loc_technology_mask);
+ // loop through adapters, and deliver to all adapters.
+ TO_ALL_LOCADAPTERS(
+ mLocAdapters[i]->reportPosition(location,
+ locationExtended,
+ locationExt,
+ status,
+ loc_technology_mask)
+ );
+}
+
+void LocApiBase::reportSv(GnssSvStatus &svStatus,
+ GpsLocationExtended &locationExtended,
+ void* svExt)
+{
+ // print the SV info before delivering
+ LOC_LOGV("num sv: %d\n ephemeris mask: %dxn almanac mask: %x\n gps/glo/bds in use"
+ " mask: %x/%x/%x\n sv: prn snr elevation azimuth",
+ svStatus.num_svs, svStatus.ephemeris_mask,
+ svStatus.almanac_mask, svStatus.gps_used_in_fix_mask,
+ svStatus.glo_used_in_fix_mask, svStatus.bds_used_in_fix_mask);
+ for (int i = 0; i < svStatus.num_svs && i < GPS_MAX_SVS; i++) {
+ LOC_LOGV(" %d: %d %f %f %f",
+ i,
+ svStatus.sv_list[i].prn,
+ svStatus.sv_list[i].snr,
+ svStatus.sv_list[i].elevation,
+ svStatus.sv_list[i].azimuth);
+ }
+ // loop through adapters, and deliver to all adapters.
+ TO_ALL_LOCADAPTERS(
+ mLocAdapters[i]->reportSv(svStatus,
+ locationExtended,
+ svExt)
+ );
+}
+
+void LocApiBase::reportStatus(GpsStatusValue status)
+{
+ // loop through adapters, and deliver to all adapters.
+ TO_ALL_LOCADAPTERS(mLocAdapters[i]->reportStatus(status));
+}
+
+void LocApiBase::reportNmea(const char* nmea, int length)
+{
+ // loop through adapters, and deliver to all adapters.
+ TO_ALL_LOCADAPTERS(mLocAdapters[i]->reportNmea(nmea, length));
+}
+
+void LocApiBase::reportXtraServer(const char* url1, const char* url2,
+ const char* url3, const int maxlength)
+{
+ // loop through adapters, and deliver to the first handling adapter.
+ TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->reportXtraServer(url1, url2, url3, maxlength));
+
+}
+
+void LocApiBase::requestXtraData()
+{
+ // loop through adapters, and deliver to the first handling adapter.
+ TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->requestXtraData());
+}
+
+void LocApiBase::requestTime()
+{
+ // loop through adapters, and deliver to the first handling adapter.
+ TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->requestTime());
+}
+
+void LocApiBase::requestLocation()
+{
+ // loop through adapters, and deliver to the first handling adapter.
+ TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->requestLocation());
+}
+
+void LocApiBase::requestATL(int connHandle, AGpsType agps_type)
+{
+ // loop through adapters, and deliver to the first handling adapter.
+ TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->requestATL(connHandle, agps_type));
+}
+
+void LocApiBase::releaseATL(int connHandle)
+{
+ // loop through adapters, and deliver to the first handling adapter.
+ TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->releaseATL(connHandle));
+}
+
+void LocApiBase::requestSuplES(int connHandle)
+{
+ // loop through adapters, and deliver to the first handling adapter.
+ TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->requestSuplES(connHandle));
+}
+
+void LocApiBase::reportDataCallOpened()
+{
+ // loop through adapters, and deliver to the first handling adapter.
+ TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->reportDataCallOpened());
+}
+
+void LocApiBase::reportDataCallClosed()
+{
+ // loop through adapters, and deliver to the first handling adapter.
+ TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->reportDataCallClosed());
+}
+
+void LocApiBase::requestNiNotify(GpsNiNotification ¬ify, const void* data)
+{
+ // loop through adapters, and deliver to the first handling adapter.
+ TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->requestNiNotify(notify, data));
+}
+
+void LocApiBase::saveSupportedMsgList(uint64_t supportedMsgList)
+{
+ mSupportedMsg = supportedMsgList;
+}
+
+void* LocApiBase :: getSibling()
+ DEFAULT_IMPL(NULL)
+
+LocApiProxyBase* LocApiBase :: getLocApiProxy()
+ DEFAULT_IMPL(NULL)
+
+void LocApiBase::reportGpsMeasurementData(GpsData &gpsMeasurementData)
+{
+ // loop through adapters, and deliver to all adapters.
+ TO_ALL_LOCADAPTERS(mLocAdapters[i]->reportGpsMeasurementData(gpsMeasurementData));
+}
+
+enum loc_api_adapter_err LocApiBase::
+ open(LOC_API_ADAPTER_EVENT_MASK_T mask)
+DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
+
+enum loc_api_adapter_err LocApiBase::
+ close()
+DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
+
+enum loc_api_adapter_err LocApiBase::
+ startFix(const LocPosMode& posMode)
+DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
+
+enum loc_api_adapter_err LocApiBase::
+ stopFix()
+DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
+
+enum loc_api_adapter_err LocApiBase::
+ deleteAidingData(GpsAidingData f)
+DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
+
+enum loc_api_adapter_err LocApiBase::
+ enableData(int enable)
+DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
+
+enum loc_api_adapter_err LocApiBase::
+ setAPN(char* apn, int len)
+DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
+
+enum loc_api_adapter_err LocApiBase::
+ injectPosition(double latitude, double longitude, float accuracy)
+DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
+
+enum loc_api_adapter_err LocApiBase::
+ setTime(GpsUtcTime time, int64_t timeReference, int uncertainty)
+DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
+
+enum loc_api_adapter_err LocApiBase::
+ setXtraData(char* data, int length)
+DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
+
+enum loc_api_adapter_err LocApiBase::
+ requestXtraServer()
+DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
+
+enum loc_api_adapter_err LocApiBase::
+ atlOpenStatus(int handle, int is_succ, char* apn,
+ AGpsBearerType bear, AGpsType agpsType)
+DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
+
+enum loc_api_adapter_err LocApiBase::
+ atlCloseStatus(int handle, int is_succ)
+DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
+
+enum loc_api_adapter_err LocApiBase::
+ setPositionMode(const LocPosMode& posMode)
+DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
+
+enum loc_api_adapter_err LocApiBase::
+ setServer(const char* url, int len)
+DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
+
+enum loc_api_adapter_err LocApiBase::
+ setServer(unsigned int ip, int port,
+ LocServerType type)
+DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
+
+enum loc_api_adapter_err LocApiBase::
+ informNiResponse(GpsUserResponseType userResponse,
+ const void* passThroughData)
+DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
+
+enum loc_api_adapter_err LocApiBase::
+ setSUPLVersion(uint32_t version)
+DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
+
+enum loc_api_adapter_err LocApiBase::
+ setLPPConfig(uint32_t profile)
+DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
+
+enum loc_api_adapter_err LocApiBase::
+ setSensorControlConfig(int sensorUsage,
+ int sensorProvider)
+DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
+
+enum loc_api_adapter_err LocApiBase::
+ setSensorProperties(bool gyroBiasVarianceRandomWalk_valid,
+ float gyroBiasVarianceRandomWalk,
+ bool accelBiasVarianceRandomWalk_valid,
+ float accelBiasVarianceRandomWalk,
+ bool angleBiasVarianceRandomWalk_valid,
+ float angleBiasVarianceRandomWalk,
+ bool rateBiasVarianceRandomWalk_valid,
+ float rateBiasVarianceRandomWalk,
+ bool velocityBiasVarianceRandomWalk_valid,
+ float velocityBiasVarianceRandomWalk)
+DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
+
+enum loc_api_adapter_err LocApiBase::
+ setSensorPerfControlConfig(int controlMode,
+ int accelSamplesPerBatch,
+ int accelBatchesPerSec,
+ int gyroSamplesPerBatch,
+ int gyroBatchesPerSec,
+ int accelSamplesPerBatchHigh,
+ int accelBatchesPerSecHigh,
+ int gyroSamplesPerBatchHigh,
+ int gyroBatchesPerSecHigh,
+ int algorithmConfig)
+DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
+
+enum loc_api_adapter_err LocApiBase::
+ setExtPowerConfig(int isBatteryCharging)
+DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
+
+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)
+{
+ memset(&zppLoc, 0, sizeof(zppLoc));
+ DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
+}
+
+enum loc_api_adapter_err LocApiBase::
+ getBestAvailableZppFix(GpsLocation & zppLoc, LocPosTechMask & tech_mask)
+{
+ memset(&zppLoc, 0, sizeof(zppLoc));
+ memset(&tech_mask, 0, sizeof(tech_mask));
+ DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
+}
+
+int LocApiBase::
+ initDataServiceClient()
+DEFAULT_IMPL(-1)
+
+int LocApiBase::
+ openAndStartDataCall()
+DEFAULT_IMPL(-1)
+
+void LocApiBase::
+ stopDataCall()
+DEFAULT_IMPL()
+
+void LocApiBase::
+ closeDataCall()
+DEFAULT_IMPL()
+
+int LocApiBase::
+ setGpsLock(LOC_GPS_LOCK_MASK lock)
+DEFAULT_IMPL(-1)
+
+void LocApiBase::
+ installAGpsCert(const DerEncodedCertificate* pData,
+ size_t length,
+ uint32_t slotBitMask)
+DEFAULT_IMPL()
+
+int LocApiBase::
+ getGpsLock()
+DEFAULT_IMPL(-1)
+
+enum loc_api_adapter_err LocApiBase::
+ setXtraVersionCheck(enum xtra_version_check check)
+DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
+
+int LocApiBase::
+ updateRegistrationMask(LOC_API_ADAPTER_EVENT_MASK_T event,
+ loc_registration_mask_status isEnabled)
+DEFAULT_IMPL(-1)
+
+bool LocApiBase::
+ gnssConstellationConfig()
+DEFAULT_IMPL(false)
+
+} // namespace loc_core
diff --git a/msm8909/core/LocApiBase.h b/msm8909/core/LocApiBase.h
new file mode 100644
index 0000000..b1c3d30
--- /dev/null
+++ b/msm8909/core/LocApiBase.h
@@ -0,0 +1,261 @@
+/* Copyright (c) 2011-2014, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * 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_API_BASE_H
+#define LOC_API_BASE_H
+
+#include <stddef.h>
+#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);
+int decodeAddress(char *addr_string, int string_size,
+ const char *data, int data_size);
+
+#define MAX_ADAPTERS 10
+
+#define TO_ALL_ADAPTERS(adapters, call) \
+ for (int i = 0; i < MAX_ADAPTERS && NULL != (adapters)[i]; i++) { \
+ call; \
+ }
+
+#define TO_1ST_HANDLING_ADAPTER(adapters, call) \
+ for (int i = 0; i <MAX_ADAPTERS && NULL != (adapters)[i] && !(call); i++);
+
+enum xtra_version_check {
+ DISABLED,
+ AUTO,
+ XTRA2,
+ XTRA3
+};
+
+class LocAdapterBase;
+struct LocSsrMsg;
+struct LocOpenMsg;
+
+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 MsgTask* mMsgTask;
+ ContextBase *mContext;
+ LocAdapterBase* mLocAdapters[MAX_ADAPTERS];
+ uint64_t mSupportedMsg;
+
+protected:
+ virtual enum loc_api_adapter_err
+ 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);
+ 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);
+ }
+
+ void addAdapter(LocAdapterBase* adapter);
+ void removeAdapter(LocAdapterBase* adapter);
+
+ // upward calls
+ void handleEngineUpEvent();
+ void handleEngineDownEvent();
+ void reportPosition(UlpLocation &location,
+ GpsLocationExtended &locationExtended,
+ void* locationExt,
+ enum loc_sess_status status,
+ LocPosTechMask loc_technology_mask =
+ LOC_POS_TECH_MASK_DEFAULT);
+ void reportSv(GnssSvStatus &svStatus,
+ GpsLocationExtended &locationExtended,
+ void* svExt);
+ void reportStatus(GpsStatusValue status);
+ void reportNmea(const char* nmea, int length);
+ void reportXtraServer(const char* url1, const char* url2,
+ const char* url3, const int maxlength);
+ void requestXtraData();
+ void requestTime();
+ void requestLocation();
+ void requestATL(int connHandle, AGpsType agps_type);
+ void releaseATL(int connHandle);
+ void requestSuplES(int connHandle);
+ void reportDataCallOpened();
+ void reportDataCallClosed();
+ void requestNiNotify(GpsNiNotification ¬ify, const void* data);
+ void saveSupportedMsgList(uint64_t supportedMsgList);
+ void reportGpsMeasurementData(GpsData &gpsMeasurementData);
+
+ // 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
+ stopFix();
+ virtual enum loc_api_adapter_err
+ deleteAidingData(GpsAidingData f);
+ virtual enum loc_api_adapter_err
+ enableData(int enable);
+ virtual enum loc_api_adapter_err
+ setAPN(char* apn, int len);
+ virtual enum loc_api_adapter_err
+ injectPosition(double latitude, double longitude, float accuracy);
+ virtual enum loc_api_adapter_err
+ setTime(GpsUtcTime time, int64_t timeReference, int uncertainty);
+ virtual enum loc_api_adapter_err
+ setXtraData(char* data, int length);
+ virtual enum loc_api_adapter_err
+ requestXtraServer();
+ virtual enum loc_api_adapter_err
+ atlOpenStatus(int handle, int is_succ, char* apn, AGpsBearerType bear, AGpsType agpsType);
+ virtual enum loc_api_adapter_err
+ atlCloseStatus(int handle, int is_succ);
+ virtual enum loc_api_adapter_err
+ setPositionMode(const LocPosMode& posMode);
+ virtual enum loc_api_adapter_err
+ setServer(const char* url, int len);
+ virtual enum loc_api_adapter_err
+ setServer(unsigned int ip, int port,
+ LocServerType type);
+ virtual enum loc_api_adapter_err
+ informNiResponse(GpsUserResponseType userResponse, const void* passThroughData);
+ virtual enum loc_api_adapter_err
+ setSUPLVersion(uint32_t version);
+ virtual enum loc_api_adapter_err
+ setLPPConfig(uint32_t profile);
+ virtual enum loc_api_adapter_err
+ setSensorControlConfig(int sensorUsage, int sensorProvider);
+ virtual enum loc_api_adapter_err
+ setSensorProperties(bool gyroBiasVarianceRandomWalk_valid,
+ float gyroBiasVarianceRandomWalk,
+ bool accelBiasVarianceRandomWalk_valid,
+ float accelBiasVarianceRandomWalk,
+ bool angleBiasVarianceRandomWalk_valid,
+ float angleBiasVarianceRandomWalk,
+ bool rateBiasVarianceRandomWalk_valid,
+ float rateBiasVarianceRandomWalk,
+ bool velocityBiasVarianceRandomWalk_valid,
+ float velocityBiasVarianceRandomWalk);
+ virtual enum loc_api_adapter_err
+ setSensorPerfControlConfig(int controlMode,
+ int accelSamplesPerBatch,
+ int accelBatchesPerSec,
+ int gyroSamplesPerBatch,
+ int gyroBatchesPerSec,
+ int accelSamplesPerBatchHigh,
+ int accelBatchesPerSecHigh,
+ int gyroSamplesPerBatchHigh,
+ int gyroBatchesPerSecHigh,
+ int algorithmConfig);
+ virtual enum loc_api_adapter_err
+ 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();
+ virtual void installAGpsCert(const DerEncodedCertificate* pData,
+ size_t length,
+ uint32_t slotBitMask);
+ inline virtual void setInSession(bool inSession) {}
+ inline bool isMessageSupported (LocCheckingMessagesID msgID) const {
+ if (msgID > (sizeof(mSupportedMsg) << 3)) {
+ return false;
+ } else {
+ uint32_t messageChecker = 1 << msgID;
+ return (messageChecker & mSupportedMsg) == messageChecker;
+ }
+ }
+ void updateEvtMask();
+
+ /*Values for lock
+ 1 = Do not lock any position sessions
+ 2 = Lock MI position sessions
+ 3 = Lock MT position sessions
+ 4 = Lock all position sessions
+ */
+ virtual int setGpsLock(LOC_GPS_LOCK_MASK lock);
+ /*
+ Returns
+ Current value of GPS Lock on success
+ -1 on failure
+ */
+ virtual int getGpsLock(void);
+
+ virtual enum loc_api_adapter_err setXtraVersionCheck(enum xtra_version_check check);
+
+ /*
+ Update gps reporting events
+ */
+ virtual int updateRegistrationMask(LOC_API_ADAPTER_EVENT_MASK_T event,
+ loc_registration_mask_status isEnabled);
+ /*
+ Check if the modem support the service
+ */
+ virtual bool gnssConstellationConfig();
+};
+
+typedef LocApiBase* (getLocApi_t)(const MsgTask* msgTask,
+ LOC_API_ADAPTER_EVENT_MASK_T exMask,
+ ContextBase *context);
+
+} // namespace loc_core
+
+#endif //LOC_API_BASE_H
diff --git a/msm8909/core/LocDualContext.cpp b/msm8909/core/LocDualContext.cpp
new file mode 100644
index 0000000..578421c
--- /dev/null
+++ b/msm8909/core/LocDualContext.cpp
@@ -0,0 +1,147 @@
+/* Copyright (c) 2011-2014, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * 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
+#define LOG_TAG "LocSvc_DualCtx"
+
+#include <cutils/sched_policy.h>
+#include <unistd.h>
+#include <LocDualContext.h>
+#include <msg_q.h>
+#include <log_util.h>
+#include <loc_log.h>
+
+namespace loc_core {
+
+// nothing exclude for foreground
+const LOC_API_ADAPTER_EVENT_MASK_T
+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_NMEA_1HZ_REPORT |
+ LOC_API_ADAPTER_BIT_NMEA_POSITION_REPORT |
+ LOC_API_ADAPTER_BIT_IOCTL_REPORT |
+ LOC_API_ADAPTER_BIT_STATUS_REPORT |
+ LOC_API_ADAPTER_BIT_GEOFENCE_GEN_ALERT |
+ LOC_API_ADAPTER_BIT_GNSS_MEASUREMENT);
+
+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";
+
+pthread_mutex_t LocDualContext::mGetLocContextMutex = PTHREAD_MUTEX_INITIALIZER;
+
+const MsgTask* LocDualContext::getMsgTask(LocThread::tCreate tCreator,
+ const char* name, bool joinable)
+{
+ if (NULL == mMsgTask) {
+ mMsgTask = new MsgTask(tCreator, name, joinable);
+ }
+ return mMsgTask;
+}
+
+inline
+const MsgTask* LocDualContext::getMsgTask(const char* name, bool joinable) {
+ return getMsgTask((LocThread::tCreate)NULL, name, joinable);
+}
+
+ContextBase* LocDualContext::getLocFgContext(LocThread::tCreate tCreator,
+ LocMsg* firstMsg, const char* name, bool joinable)
+{
+ pthread_mutex_lock(&LocDualContext::mGetLocContextMutex);
+ LOC_LOGD("%s:%d]: querying ContextBase with tCreator", __func__, __LINE__);
+ if (NULL == mFgContext) {
+ LOC_LOGD("%s:%d]: creating msgTask with tCreator", __func__, __LINE__);
+ const MsgTask* msgTask = getMsgTask(tCreator, name, joinable);
+ mFgContext = new LocDualContext(msgTask,
+ mFgExclMask);
+ }
+ if(NULL == mInjectContext) {
+ LOC_LOGD("%s:%d]: mInjectContext is FgContext", __func__, __LINE__);
+ mInjectContext = mFgContext;
+ injectFeatureConfig(mInjectContext);
+ }
+ pthread_mutex_unlock(&LocDualContext::mGetLocContextMutex);
+
+ if (firstMsg) {
+ mFgContext->sendMsg(firstMsg);
+ }
+
+ return mFgContext;
+}
+
+ContextBase* LocDualContext::getLocBgContext(LocThread::tCreate tCreator,
+ LocMsg* firstMsg, const char* name, bool joinable)
+{
+ pthread_mutex_lock(&LocDualContext::mGetLocContextMutex);
+ LOC_LOGD("%s:%d]: querying ContextBase with tCreator", __func__, __LINE__);
+ if (NULL == mBgContext) {
+ LOC_LOGD("%s:%d]: creating msgTask with tCreator", __func__, __LINE__);
+ const MsgTask* msgTask = getMsgTask(tCreator, name, joinable);
+ mBgContext = new LocDualContext(msgTask,
+ mBgExclMask);
+ }
+ if(NULL == mInjectContext) {
+ LOC_LOGD("%s:%d]: mInjectContext is BgContext", __func__, __LINE__);
+ mInjectContext = mBgContext;
+ injectFeatureConfig(mInjectContext);
+ }
+ pthread_mutex_unlock(&LocDualContext::mGetLocContextMutex);
+
+ if (firstMsg) {
+ mBgContext->sendMsg(firstMsg);
+ }
+
+ 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)
+{
+}
+
+}
diff --git a/msm8909/core/LocDualContext.h b/msm8909/core/LocDualContext.h
new file mode 100644
index 0000000..ce77a1a
--- /dev/null
+++ b/msm8909/core/LocDualContext.h
@@ -0,0 +1,76 @@
+/* Copyright (c) 2011-2014, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * 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_CONTEXT__
+#define __LOC_ENG_CONTEXT__
+
+#include <stdbool.h>
+#include <ctype.h>
+#include <dlfcn.h>
+#include <ContextBase.h>
+
+namespace loc_core {
+
+class LocDualContext : public ContextBase {
+ static const MsgTask* mMsgTask;
+ static ContextBase* mFgContext;
+ static ContextBase* mBgContext;
+ static ContextBase* mInjectContext;
+ static const MsgTask* getMsgTask(LocThread::tCreate tCreator,
+ const char* name, bool joinable = true);
+ static const MsgTask* getMsgTask(const char* name, bool joinable = true);
+ static pthread_mutex_t mGetLocContextMutex;
+
+protected:
+ LocDualContext(const MsgTask* msgTask,
+ LOC_API_ADAPTER_EVENT_MASK_T exMask);
+ inline virtual ~LocDualContext() {}
+
+public:
+ static const char* mLBSLibName;
+ static const LOC_API_ADAPTER_EVENT_MASK_T mFgExclMask;
+ static const LOC_API_ADAPTER_EVENT_MASK_T mBgExclMask;
+ static const char* mLocationHalName;
+
+ static ContextBase* getLocFgContext(LocThread::tCreate tCreator, LocMsg* firstMsg,
+ const char* name, bool joinable = true);
+ inline static ContextBase* getLocFgContext(const char* name, bool joinable = true) {
+ return getLocFgContext(NULL, NULL, name, joinable);
+ }
+ static ContextBase* getLocBgContext(LocThread::tCreate tCreator, LocMsg* firstMsg,
+ const char* name, bool joinable = true);
+ inline static ContextBase* getLocBgContext(const char* name, bool joinable = true) {
+ return getLocBgContext(NULL, NULL, name, joinable);
+ }
+
+ static void injectFeatureConfig(ContextBase *context);
+};
+
+}
+
+#endif //__LOC_ENG_CONTEXT__
diff --git a/msm8909/core/UlpProxyBase.h b/msm8909/core/UlpProxyBase.h
new file mode 100644
index 0000000..59e265e
--- /dev/null
+++ b/msm8909/core/UlpProxyBase.h
@@ -0,0 +1,84 @@
+/* Copyright (c) 2013-2015, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * 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 ULP_PROXY_BASE_H
+#define ULP_PROXY_BASE_H
+
+#include <gps_extended.h>
+#include "fused_location_extended.h"
+
+namespace loc_core {
+
+class LocAdapterBase;
+
+class UlpProxyBase {
+public:
+ LocPosMode mPosMode;
+ bool mFixSet;
+ inline UlpProxyBase() {
+ mPosMode.mode = LOC_POSITION_MODE_INVALID;
+ mFixSet = false;
+ }
+ inline virtual ~UlpProxyBase() {}
+ inline virtual bool sendStartFix() { mFixSet = true; return false; }
+ inline virtual bool sendStopFix() { mFixSet = false; return false; }
+ inline virtual bool sendFixMode(LocPosMode ¶ms) {
+ mPosMode = params;
+ return false;
+ }
+
+ inline virtual bool reportPosition(UlpLocation &location,
+ GpsLocationExtended &locationExtended,
+ void* locationExt,
+ enum loc_sess_status status,
+ LocPosTechMask loc_technology_mask) {
+ return false;
+ }
+ inline virtual bool reportSv(GnssSvStatus &svStatus,
+ GpsLocationExtended &locationExtended,
+ 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(FlpExtBatchOptions &options,
+ bool active) {
+ return false;
+ }
+ inline virtual bool reportPositions(const FlpExtLocation* locations,
+ int32_t number_of_locations) {
+ return false;
+ }
+};
+
+} // namespace loc_core
+
+#endif // ULP_PROXY_BASE_H
diff --git a/msm8909/core/gps_extended.h b/msm8909/core/gps_extended.h
new file mode 100644
index 0000000..88b0415
--- /dev/null
+++ b/msm8909/core/gps_extended.h
@@ -0,0 +1,92 @@
+/* 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
+ * 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 GPS_EXTENDED_H
+#define GPS_EXTENDED_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+#include <gps_extended_c.h>
+
+struct LocPosMode
+{
+ LocPositionMode mode;
+ GpsPositionRecurrence recurrence;
+ uint32_t min_interval;
+ uint32_t preferred_accuracy;
+ uint32_t preferred_time;
+ char credentials[14];
+ char provider[8];
+ LocPosMode(LocPositionMode m, GpsPositionRecurrence recr,
+ uint32_t gap, uint32_t accu, uint32_t time,
+ const char* cred, const char* prov) :
+ mode(m), recurrence(recr),
+ min_interval(gap < MIN_POSSIBLE_FIX_INTERVAL ? MIN_POSSIBLE_FIX_INTERVAL : gap),
+ preferred_accuracy(accu), preferred_time(time) {
+ memset(credentials, 0, sizeof(credentials));
+ memset(provider, 0, sizeof(provider));
+ if (NULL != cred) {
+ memcpy(credentials, cred, sizeof(credentials)-1);
+ }
+ if (NULL != prov) {
+ memcpy(provider, prov, sizeof(provider)-1);
+ }
+ }
+
+ inline LocPosMode() :
+ mode(LOC_POSITION_MODE_MS_BASED),
+ recurrence(GPS_POSITION_RECURRENCE_PERIODIC),
+ min_interval(MIN_POSSIBLE_FIX_INTERVAL),
+ preferred_accuracy(50), preferred_time(120000) {
+ memset(credentials, 0, sizeof(credentials));
+ memset(provider, 0, sizeof(provider));
+ }
+
+ inline bool equals(const LocPosMode &anotherMode) const
+ {
+ return anotherMode.mode == mode &&
+ anotherMode.recurrence == recurrence &&
+ anotherMode.min_interval == min_interval &&
+ anotherMode.preferred_accuracy == preferred_accuracy &&
+ anotherMode.preferred_time == preferred_time &&
+ !strncmp(anotherMode.credentials, credentials, sizeof(credentials)-1) &&
+ !strncmp(anotherMode.provider, provider, sizeof(provider)-1);
+ }
+
+ void logv() const;
+};
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* GPS_EXTENDED_H */
+
diff --git a/msm8909/core/gps_extended_c.h b/msm8909/core/gps_extended_c.h
new file mode 100644
index 0000000..27deb44
--- /dev/null
+++ b/msm8909/core/gps_extended_c.h
@@ -0,0 +1,435 @@
+/* Copyright (c) 2013-2015, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * 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 GPS_EXTENDED_C_H
+#define GPS_EXTENDED_C_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+#include <ctype.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+#include <hardware/gps.h>
+
+/** Location has valid source information. */
+#define LOCATION_HAS_SOURCE_INFO 0x0020
+/** GpsLocation has valid "is indoor?" flag */
+#define GPS_LOCATION_HAS_IS_INDOOR 0x0040
+/** GpsLocation has valid floor number */
+#define GPS_LOCATION_HAS_FLOOR_NUMBER 0x0080
+/** GpsLocation has valid map URL*/
+#define GPS_LOCATION_HAS_MAP_URL 0x0100
+/** GpsLocation has valid map index */
+#define GPS_LOCATION_HAS_MAP_INDEX 0x0200
+
+/** Sizes for indoor fields */
+#define GPS_LOCATION_MAP_URL_SIZE 400
+#define GPS_LOCATION_MAP_INDEX_SIZE 16
+
+/** 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
+/** Position is from Hardware FLP */
+#define ULP_LOCATION_IS_FROM_HW_FLP 0x0010
+/** Position is from NLP */
+#define ULP_LOCATION_IS_FROM_NLP 0x0020
+/** Position is from PIP */
+#define ULP_LOCATION_IS_FROM_PIP 0x0040
+
+#define ULP_MIN_INTERVAL_INVALID 0xffffffff
+
+/*Emergency SUPL*/
+#define GPS_NI_TYPE_EMERGENCY_SUPL 4
+
+#define AGPS_CERTIFICATE_MAX_LENGTH 2000
+#define AGPS_CERTIFICATE_MAX_SLOTS 10
+
+enum loc_registration_mask_status {
+ LOC_REGISTRATION_MASK_ENABLED,
+ LOC_REGISTRATION_MASK_DISABLED
+};
+
+typedef struct {
+ /** set to sizeof(UlpLocation) */
+ size_t size;
+ GpsLocation gpsLocation;
+ /* Provider indicator for HYBRID or GPS */
+ uint16_t position_source;
+ /*allows HAL to pass additional information related to the location */
+ int rawDataSize; /* in # of bytes */
+ void * rawData;
+ bool is_indoor;
+ float floor_number;
+ char map_url[GPS_LOCATION_MAP_URL_SIZE];
+ unsigned char map_index[GPS_LOCATION_MAP_INDEX_SIZE];
+} UlpLocation;
+
+/** AGPS type */
+typedef int16_t AGpsExtType;
+#define AGPS_TYPE_INVALID -1
+#define AGPS_TYPE_ANY 0
+#define AGPS_TYPE_SUPL 1
+#define AGPS_TYPE_C2K 2
+#define AGPS_TYPE_WWAN_ANY 3
+#define AGPS_TYPE_WIFI 4
+#define AGPS_TYPE_SUPL_ES 5
+
+/** SSID length */
+#define SSID_BUF_SIZE (32+1)
+
+typedef int16_t AGpsBearerType;
+#define AGPS_APN_BEARER_INVALID -1
+#define AGPS_APN_BEARER_IPV4 0
+#define AGPS_APN_BEARER_IPV6 1
+#define AGPS_APN_BEARER_IPV4V6 2
+
+/** GPS extended callback structure. */
+typedef struct {
+ /** set to sizeof(GpsCallbacks) */
+ size_t size;
+ gps_set_capabilities set_capabilities_cb;
+ gps_acquire_wakelock acquire_wakelock_cb;
+ gps_release_wakelock release_wakelock_cb;
+ gps_create_thread create_thread_cb;
+ gps_request_utc_time request_utc_time_cb;
+} GpsExtCallbacks;
+
+/** 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
+ */
+typedef void (* report_xtra_server)(const char*, const char*, const char*);
+
+/** Callback structure for the XTRA interface. */
+typedef struct {
+ gps_xtra_download_request download_request_cb;
+ gps_create_thread create_thread_cb;
+ report_xtra_server report_xtra_server_cb;
+} GpsXtraExtCallbacks;
+
+/** Represents the status of AGPS. */
+typedef struct {
+ /** set to sizeof(AGpsExtStatus) */
+ size_t size;
+
+ AGpsExtType type;
+ AGpsStatusValue status;
+ uint32_t ipv4_addr;
+ struct sockaddr_storage addr;
+ char ssid[SSID_BUF_SIZE];
+ char password[SSID_BUF_SIZE];
+} AGpsExtStatus;
+
+/** Callback with AGPS status information.
+ * Can only be called from a thread created by create_thread_cb.
+ */
+typedef void (* agps_status_extended)(AGpsExtStatus* status);
+
+/** Callback structure for the AGPS interface. */
+typedef struct {
+ agps_status_extended status_cb;
+ gps_create_thread create_thread_cb;
+} AGpsExtCallbacks;
+
+
+/** GPS NI callback structure. */
+typedef struct
+{
+ /**
+ * Sends the notification request from HAL to GPSLocationProvider.
+ */
+ gps_ni_notify_callback notify_cb;
+ gps_create_thread create_thread_cb;
+} GpsNiExtCallbacks;
+
+typedef enum loc_server_type {
+ LOC_AGPS_CDMA_PDE_SERVER,
+ LOC_AGPS_CUSTOM_PDE_SERVER,
+ LOC_AGPS_MPC_SERVER,
+ LOC_AGPS_SUPL_SERVER
+} LocServerType;
+
+typedef enum loc_position_mode_type {
+ LOC_POSITION_MODE_INVALID = -1,
+ LOC_POSITION_MODE_STANDALONE = 0,
+ LOC_POSITION_MODE_MS_BASED,
+ LOC_POSITION_MODE_MS_ASSISTED,
+ LOC_POSITION_MODE_RESERVED_1,
+ LOC_POSITION_MODE_RESERVED_2,
+ LOC_POSITION_MODE_RESERVED_3,
+ LOC_POSITION_MODE_RESERVED_4,
+ LOC_POSITION_MODE_RESERVED_5
+
+} LocPositionMode;
+
+#define MIN_POSSIBLE_FIX_INTERVAL 1000 /* msec */
+
+/** Flags to indicate which values are valid in a GpsLocationExtended. */
+typedef uint16_t GpsLocationExtendedFlags;
+/** GpsLocationExtended has valid pdop, hdop, vdop. */
+#define GPS_LOCATION_EXTENDED_HAS_DOP 0x0001
+/** GpsLocationExtended has valid altitude mean sea level. */
+#define GPS_LOCATION_EXTENDED_HAS_ALTITUDE_MEAN_SEA_LEVEL 0x0002
+/** UlpLocation has valid magnetic deviation. */
+#define GPS_LOCATION_EXTENDED_HAS_MAG_DEV 0x0004
+/** UlpLocation has valid mode indicator. */
+#define GPS_LOCATION_EXTENDED_HAS_MODE_IND 0x0008
+/** GpsLocationExtended has valid vertical uncertainty */
+#define GPS_LOCATION_EXTENDED_HAS_VERT_UNC 0x0010
+/** GpsLocationExtended has valid speed uncertainty */
+#define GPS_LOCATION_EXTENDED_HAS_SPEED_UNC 0x0020
+/** GpsLocationExtended has valid heading uncertainty */
+#define GPS_LOCATION_EXTENDED_HAS_BEARING_UNC 0x0040
+/** GpsLocationExtended has valid horizontal reliability */
+#define GPS_LOCATION_EXTENDED_HAS_HOR_RELIABILITY 0x0080
+/** GpsLocationExtended has valid vertical reliability */
+#define GPS_LOCATION_EXTENDED_HAS_VERT_RELIABILITY 0x0100
+
+typedef enum {
+ LOC_RELIABILITY_NOT_SET = 0,
+ LOC_RELIABILITY_VERY_LOW = 1,
+ LOC_RELIABILITY_LOW = 2,
+ LOC_RELIABILITY_MEDIUM = 3,
+ LOC_RELIABILITY_HIGH = 4
+}LocReliability;
+
+/** Represents gps location extended. */
+typedef struct {
+ /** set to sizeof(GpsLocationExtended) */
+ size_t size;
+ /** Contains GpsLocationExtendedFlags bits. */
+ uint16_t flags;
+ /** Contains the Altitude wrt mean sea level */
+ float altitudeMeanSeaLevel;
+ /** Contains Position Dilusion of Precision. */
+ float pdop;
+ /** Contains Horizontal Dilusion of Precision. */
+ float hdop;
+ /** Contains Vertical Dilusion of Precision. */
+ float vdop;
+ /** Contains Magnetic Deviation. */
+ float magneticDeviation;
+ /** vertical uncertainty in meters */
+ float vert_unc;
+ /** speed uncertainty in m/s */
+ float speed_unc;
+ /** heading uncertainty in degrees (0 to 359.999) */
+ float bearing_unc;
+ /** horizontal reliability. */
+ LocReliability horizontal_reliability;
+ /** vertical reliability. */
+ LocReliability vertical_reliability;
+} GpsLocationExtended;
+
+/** Represents SV status. */
+typedef struct {
+ /** set to sizeof(GnssSvStatus) */
+ size_t size;
+
+ /** Number of SVs currently visible. */
+ int num_svs;
+
+ /** Contains an array of SV information. */
+ GpsSvInfo sv_list[GPS_MAX_SVS];
+
+ /** Represents a bit mask indicating which SVs
+ * have ephemeris data.
+ */
+ uint32_t ephemeris_mask;
+
+ /** Represents a bit mask indicating which SVs
+ * have almanac data.
+ */
+ uint32_t almanac_mask;
+
+ /**
+ * Represents a bit mask indicating which GPS SVs
+ * were used for computing the most recent position fix.
+ */
+ uint32_t gps_used_in_fix_mask;
+
+ /**
+ * Represents a bit mask indicating which GLONASS SVs
+ * were used for computing the most recent position fix.
+ */
+ uint32_t glo_used_in_fix_mask;
+
+ /**
+ * Represents a bit mask indicating which BDS SVs
+ * were used for computing the most recent position fix.
+ */
+ uint64_t bds_used_in_fix_mask;
+
+} GnssSvStatus;
+
+enum loc_sess_status {
+ LOC_SESS_SUCCESS,
+ LOC_SESS_INTERMEDIATE,
+ LOC_SESS_FAILURE
+};
+
+typedef uint32_t LocPosTechMask;
+#define LOC_POS_TECH_MASK_DEFAULT ((LocPosTechMask)0x00000000)
+#define LOC_POS_TECH_MASK_SATELLITE ((LocPosTechMask)0x00000001)
+#define LOC_POS_TECH_MASK_CELLID ((LocPosTechMask)0x00000002)
+#define LOC_POS_TECH_MASK_WIFI ((LocPosTechMask)0x00000004)
+#define LOC_POS_TECH_MASK_SENSORS ((LocPosTechMask)0x00000008)
+#define LOC_POS_TECH_MASK_REFERENCE_LOCATION ((LocPosTechMask)0x00000010)
+#define LOC_POS_TECH_MASK_INJECTED_COARSE_POSITION ((LocPosTechMask)0x00000020)
+#define LOC_POS_TECH_MASK_AFLT ((LocPosTechMask)0x00000040)
+#define LOC_POS_TECH_MASK_HYBRID ((LocPosTechMask)0x00000080)
+
+typedef enum {
+ LOC_ENG_IF_REQUEST_SENDER_ID_QUIPC = 0,
+ LOC_ENG_IF_REQUEST_SENDER_ID_MSAPM,
+ LOC_ENG_IF_REQUEST_SENDER_ID_MSAPU,
+ LOC_ENG_IF_REQUEST_SENDER_ID_GPSONE_DAEMON,
+ LOC_ENG_IF_REQUEST_SENDER_ID_MODEM,
+ LOC_ENG_IF_REQUEST_SENDER_ID_UNKNOWN
+} loc_if_req_sender_id_e_type;
+
+
+#define smaller_of(a, b) (((a) > (b)) ? (b) : (a))
+#define MAX_APN_LEN 100
+
+// This will be overridden by the individual adapters
+// if necessary.
+#define DEFAULT_IMPL(rtv) \
+{ \
+ LOC_LOGD("%s: default implementation invoked", __func__); \
+ return rtv; \
+}
+
+enum loc_api_adapter_err {
+ LOC_API_ADAPTER_ERR_SUCCESS = 0,
+ LOC_API_ADAPTER_ERR_GENERAL_FAILURE = 1,
+ LOC_API_ADAPTER_ERR_UNSUPPORTED = 2,
+ LOC_API_ADAPTER_ERR_INVALID_HANDLE = 4,
+ LOC_API_ADAPTER_ERR_INVALID_PARAMETER = 5,
+ LOC_API_ADAPTER_ERR_ENGINE_BUSY = 6,
+ LOC_API_ADAPTER_ERR_PHONE_OFFLINE = 7,
+ LOC_API_ADAPTER_ERR_TIMEOUT = 8,
+ LOC_API_ADAPTER_ERR_SERVICE_NOT_PRESENT = 9,
+ LOC_API_ADAPTER_ERR_INTERNAL = 10,
+
+ /* equating engine down to phone offline, as they are the same errror */
+ LOC_API_ADAPTER_ERR_ENGINE_DOWN = LOC_API_ADAPTER_ERR_PHONE_OFFLINE,
+ LOC_API_ADAPTER_ERR_FAILURE = 101,
+ LOC_API_ADAPTER_ERR_UNKNOWN
+};
+
+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_GDT_UPLOAD_BEGIN_REQ, // GDT upload start request
+ LOC_API_ADAPTER_GDT_UPLOAD_END_REQ, // GDT upload end request
+ LOC_API_ADAPTER_GNSS_MEASUREMENT, // GNSS Measurement report
+ LOC_API_ADAPTER_REQUEST_TIMEZONE, // Timezone injection request
+ 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_GDT_UPLOAD_BEGIN_REQ (1<<LOC_API_ADAPTER_GDT_UPLOAD_BEGIN_REQ)
+#define LOC_API_ADAPTER_BIT_GDT_UPLOAD_END_REQ (1<<LOC_API_ADAPTER_GDT_UPLOAD_END_REQ)
+#define LOC_API_ADAPTER_BIT_GNSS_MEASUREMENT (1<<LOC_API_ADAPTER_GNSS_MEASUREMENT)
+#define LOC_API_ADAPTER_BIT_REQUEST_TIMEZONE (1<<LOC_API_ADAPTER_REQUEST_TIMEZONE)
+
+typedef unsigned int LOC_API_ADAPTER_EVENT_MASK_T;
+
+typedef enum loc_api_adapter_msg_to_check_supported {
+ LOC_API_ADAPTER_MESSAGE_LOCATION_BATCHING, // Batching 1.0
+ LOC_API_ADAPTER_MESSAGE_BATCHED_GENFENCE_BREACH, // Geofence Batched Breach
+ LOC_API_ADAPTER_MESSAGE_DISTANCE_BASE_TRACKING, // DBT 2.0
+ LOC_API_ADAPTER_MESSAGE_ADAPTIVE_LOCATION_BATCHING, // Batching 1.5
+ LOC_API_ADAPTER_MESSAGE_DISTANCE_BASE_LOCATION_BATCHING, // Batching 2.0
+
+ LOC_API_ADAPTER_MESSAGE_MAX
+} LocCheckingMessagesID;
+
+typedef int IzatDevId_t;
+
+typedef uint32_t LOC_GPS_LOCK_MASK;
+#define isGpsLockNone(lock) ((lock) == 0)
+#define isGpsLockMO(lock) ((lock) & ((LOC_GPS_LOCK_MASK)1))
+#define isGpsLockMT(lock) ((lock) & ((LOC_GPS_LOCK_MASK)2))
+#define isGpsLockAll(lock) (((lock) & ((LOC_GPS_LOCK_MASK)3)) == 3)
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* GPS_EXTENDED_C_H */
diff --git a/msm8909/core/loc_core_log.cpp b/msm8909/core/loc_core_log.cpp
new file mode 100644
index 0000000..3ca6c0a
--- /dev/null
+++ b/msm8909/core/loc_core_log.cpp
@@ -0,0 +1,243 @@
+/* Copyright (c) 2011-2015, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * 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
+#define LOG_TAG "LocSvc_core_log"
+
+#include <loc_log.h>
+#include <log_util.h>
+#include <loc_core_log.h>
+
+void LocPosMode::logv() const
+{
+ LOC_LOGV ("Position mode: %s\n Position recurrence: %s\n "
+ "min interval: %d\n preferred accuracy: %d\n "
+ "preferred time: %d\n credentials: %s provider: %s",
+ loc_get_position_mode_name(mode),
+ loc_get_position_recurrence_name(recurrence),
+ min_interval,
+ preferred_accuracy,
+ preferred_time,
+ credentials,
+ provider);
+}
+
+/* GPS status names */
+static const loc_name_val_s_type gps_status_name[] =
+{
+ NAME_VAL( GPS_STATUS_NONE ),
+ NAME_VAL( GPS_STATUS_SESSION_BEGIN ),
+ NAME_VAL( GPS_STATUS_SESSION_END ),
+ NAME_VAL( GPS_STATUS_ENGINE_ON ),
+ NAME_VAL( GPS_STATUS_ENGINE_OFF ),
+};
+static const int gps_status_num = sizeof(gps_status_name) / sizeof(loc_name_val_s_type);
+
+/* Find Android GPS status name */
+const char* loc_get_gps_status_name(GpsStatusValue gps_status)
+{
+ return loc_get_name_from_val(gps_status_name, gps_status_num,
+ (long) gps_status);
+}
+
+
+
+static const loc_name_val_s_type loc_eng_position_modes[] =
+{
+ NAME_VAL( LOC_POSITION_MODE_STANDALONE ),
+ NAME_VAL( LOC_POSITION_MODE_MS_BASED ),
+ NAME_VAL( LOC_POSITION_MODE_MS_ASSISTED ),
+ NAME_VAL( LOC_POSITION_MODE_RESERVED_1 ),
+ NAME_VAL( LOC_POSITION_MODE_RESERVED_2 ),
+ NAME_VAL( LOC_POSITION_MODE_RESERVED_3 ),
+ NAME_VAL( LOC_POSITION_MODE_RESERVED_4 ),
+ NAME_VAL( LOC_POSITION_MODE_RESERVED_5 )
+};
+static const int loc_eng_position_mode_num = sizeof(loc_eng_position_modes) / sizeof(loc_name_val_s_type);
+
+const char* loc_get_position_mode_name(GpsPositionMode mode)
+{
+ return loc_get_name_from_val(loc_eng_position_modes, loc_eng_position_mode_num, (long) mode);
+}
+
+
+
+static const loc_name_val_s_type loc_eng_position_recurrences[] =
+{
+ NAME_VAL( GPS_POSITION_RECURRENCE_PERIODIC ),
+ NAME_VAL( GPS_POSITION_RECURRENCE_SINGLE )
+};
+static const int loc_eng_position_recurrence_num = sizeof(loc_eng_position_recurrences) / sizeof(loc_name_val_s_type);
+
+const char* loc_get_position_recurrence_name(GpsPositionRecurrence recur)
+{
+ return loc_get_name_from_val(loc_eng_position_recurrences, loc_eng_position_recurrence_num, (long) recur);
+}
+
+
+
+static const loc_name_val_s_type loc_eng_aiding_data_bits[] =
+{
+ NAME_VAL( GPS_DELETE_EPHEMERIS ),
+ NAME_VAL( GPS_DELETE_ALMANAC ),
+ NAME_VAL( GPS_DELETE_POSITION ),
+ NAME_VAL( GPS_DELETE_TIME ),
+ NAME_VAL( GPS_DELETE_IONO ),
+ NAME_VAL( GPS_DELETE_UTC ),
+ NAME_VAL( GPS_DELETE_HEALTH ),
+ NAME_VAL( GPS_DELETE_SVDIR ),
+ NAME_VAL( GPS_DELETE_SVSTEER ),
+ NAME_VAL( GPS_DELETE_SADATA ),
+ NAME_VAL( GPS_DELETE_RTI ),
+ NAME_VAL( GPS_DELETE_CELLDB_INFO ),
+ NAME_VAL( GPS_DELETE_ALL)
+};
+static const int loc_eng_aiding_data_bit_num = sizeof(loc_eng_aiding_data_bits) / sizeof(loc_name_val_s_type);
+
+const char* loc_get_aiding_data_mask_names(GpsAidingData data)
+{
+ return NULL;
+}
+
+
+static const loc_name_val_s_type loc_eng_agps_types[] =
+{
+ NAME_VAL( AGPS_TYPE_INVALID ),
+ NAME_VAL( AGPS_TYPE_ANY ),
+ NAME_VAL( AGPS_TYPE_SUPL ),
+ NAME_VAL( AGPS_TYPE_C2K ),
+ NAME_VAL( AGPS_TYPE_WWAN_ANY )
+};
+static const int loc_eng_agps_type_num = sizeof(loc_eng_agps_types) / sizeof(loc_name_val_s_type);
+
+const char* loc_get_agps_type_name(AGpsType type)
+{
+ return loc_get_name_from_val(loc_eng_agps_types, loc_eng_agps_type_num, (long) type);
+}
+
+
+static const 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 )
+};
+static const int loc_eng_ni_type_num = sizeof(loc_eng_ni_types) / sizeof(loc_name_val_s_type);
+
+const char* loc_get_ni_type_name(GpsNiType type)
+{
+ return loc_get_name_from_val(loc_eng_ni_types, loc_eng_ni_type_num, (long) type);
+}
+
+
+static const loc_name_val_s_type loc_eng_ni_responses[] =
+{
+ NAME_VAL( GPS_NI_RESPONSE_ACCEPT ),
+ NAME_VAL( GPS_NI_RESPONSE_DENY ),
+ NAME_VAL( GPS_NI_RESPONSE_DENY )
+};
+static const int loc_eng_ni_reponse_num = sizeof(loc_eng_ni_responses) / sizeof(loc_name_val_s_type);
+
+const char* loc_get_ni_response_name(GpsUserResponseType response)
+{
+ return loc_get_name_from_val(loc_eng_ni_responses, loc_eng_ni_reponse_num, (long) response);
+}
+
+
+static const loc_name_val_s_type loc_eng_ni_encodings[] =
+{
+ NAME_VAL( GPS_ENC_NONE ),
+ NAME_VAL( GPS_ENC_SUPL_GSM_DEFAULT ),
+ NAME_VAL( GPS_ENC_SUPL_UTF8 ),
+ NAME_VAL( GPS_ENC_SUPL_UCS2 ),
+ NAME_VAL( GPS_ENC_UNKNOWN )
+};
+static const int loc_eng_ni_encoding_num = sizeof(loc_eng_ni_encodings) / sizeof(loc_name_val_s_type);
+
+const char* loc_get_ni_encoding_name(GpsNiEncodingType encoding)
+{
+ return loc_get_name_from_val(loc_eng_ni_encodings, loc_eng_ni_encoding_num, (long) encoding);
+}
+
+static const 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_IPV4V6 )
+};
+static const int loc_eng_agps_bears_num = sizeof(loc_eng_agps_bears) / sizeof(loc_name_val_s_type);
+
+const char* loc_get_agps_bear_name(AGpsBearerType bearer)
+{
+ return loc_get_name_from_val(loc_eng_agps_bears, loc_eng_agps_bears_num, (long) bearer);
+}
+
+static const loc_name_val_s_type loc_eng_server_types[] =
+{
+ NAME_VAL( LOC_AGPS_CDMA_PDE_SERVER ),
+ NAME_VAL( LOC_AGPS_CUSTOM_PDE_SERVER ),
+ NAME_VAL( LOC_AGPS_MPC_SERVER ),
+ NAME_VAL( LOC_AGPS_SUPL_SERVER )
+};
+static const int loc_eng_server_types_num = sizeof(loc_eng_server_types) / sizeof(loc_name_val_s_type);
+
+const char* loc_get_server_type_name(LocServerType type)
+{
+ return loc_get_name_from_val(loc_eng_server_types, loc_eng_server_types_num, (long) type);
+}
+
+static const loc_name_val_s_type loc_eng_position_sess_status_types[] =
+{
+ NAME_VAL( LOC_SESS_SUCCESS ),
+ NAME_VAL( LOC_SESS_INTERMEDIATE ),
+ NAME_VAL( LOC_SESS_FAILURE )
+};
+static const int loc_eng_position_sess_status_num = sizeof(loc_eng_position_sess_status_types) / sizeof(loc_name_val_s_type);
+
+const char* loc_get_position_sess_status_name(enum loc_sess_status status)
+{
+ return loc_get_name_from_val(loc_eng_position_sess_status_types, loc_eng_position_sess_status_num, (long) status);
+}
+
+static const loc_name_val_s_type loc_eng_agps_status_names[] =
+{
+ NAME_VAL( GPS_REQUEST_AGPS_DATA_CONN ),
+ NAME_VAL( GPS_RELEASE_AGPS_DATA_CONN ),
+ NAME_VAL( GPS_AGPS_DATA_CONNECTED ),
+ NAME_VAL( GPS_AGPS_DATA_CONN_DONE ),
+ NAME_VAL( GPS_AGPS_DATA_CONN_FAILED )
+};
+static const int loc_eng_agps_status_num = sizeof(loc_eng_agps_status_names) / sizeof(loc_name_val_s_type);
+
+const char* loc_get_agps_status_name(AGpsStatusValue status)
+{
+ return loc_get_name_from_val(loc_eng_agps_status_names, loc_eng_agps_status_num, (long) status);
+}
diff --git a/msm8909/core/loc_core_log.h b/msm8909/core/loc_core_log.h
new file mode 100644
index 0000000..8a1825a
--- /dev/null
+++ b/msm8909/core/loc_core_log.h
@@ -0,0 +1,58 @@
+/* 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
+ * 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_CORE_LOG_H
+#define LOC_CORE_LOG_H
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#include <ctype.h>
+#include <gps_extended.h>
+
+const char* loc_get_gps_status_name(GpsStatusValue gps_status);
+const char* loc_get_position_mode_name(GpsPositionMode mode);
+const char* loc_get_position_recurrence_name(GpsPositionRecurrence recur);
+const char* loc_get_aiding_data_mask_names(GpsAidingData data);
+const char* loc_get_agps_type_name(AGpsType type);
+const char* loc_get_ni_type_name(GpsNiType type);
+const char* loc_get_ni_response_name(GpsUserResponseType response);
+const char* loc_get_ni_encoding_name(GpsNiEncodingType encoding);
+const char* loc_get_agps_bear_name(AGpsBearerType bear);
+const char* loc_get_server_type_name(LocServerType type);
+const char* loc_get_position_sess_status_name(enum loc_sess_status status);
+const char* loc_get_agps_status_name(AGpsStatusValue status);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* LOC_CORE_LOG_H */
diff --git a/msm8909/etc/Android.mk b/msm8909/etc/Android.mk
new file mode 100644
index 0000000..025d3f7
--- /dev/null
+++ b/msm8909/etc/Android.mk
@@ -0,0 +1,12 @@
+
+LOCAL_PATH := $(call my-dir)
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := gps.conf
+LOCAL_MODULE_TAGS := optional
+LOCAL_MODULE_CLASS := ETC
+LOCAL_MODULE_PATH := $(TARGET_OUT_ETC)/
+LOCAL_SRC_FILES := gps.conf
+
+include $(BUILD_PREBUILT)
+
diff --git a/msm8909/etc/gps.conf b/msm8909/etc/gps.conf
new file mode 100644
index 0000000..4e6b436
--- /dev/null
+++ b/msm8909/etc/gps.conf
@@ -0,0 +1,117 @@
+#Uncommenting these urls would only enable
+#the power up auto injection and force injection(test case).
+#XTRA_SERVER_1=http://xtrapath1.izatcloud.net/xtra2.bin
+#XTRA_SERVER_2=http://xtrapath2.izatcloud.net/xtra2.bin
+#XTRA_SERVER_3=http://xtrapath3.izatcloud.net/xtra2.bin
+
+#Version check for XTRA
+#DISABLE = 0
+#AUTO = 1
+#XTRA2 = 2
+#XTRA3 = 3
+XTRA_VERSION_CHECK=0
+
+# Error Estimate
+# _SET = 1
+# _CLEAR = 0
+ERR_ESTIMATE=0
+
+#Test
+NTP_SERVER=time.gpsonextra.net
+#Asia
+# NTP_SERVER=asia.pool.ntp.org
+#Europe
+# NTP_SERVER=europe.pool.ntp.org
+#North America
+# NTP_SERVER=north-america.pool.ntp.org
+
+# 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
+
+# Intermediate position report, 1=enable, 0=disable
+INTERMEDIATE_POS=0
+
+# Below bit mask configures how GPS functionalities
+# should be locked when user turns off GPS on Settings
+# Set bit 0x1 if MO GPS functionalities are to be locked
+# Set bit 0x2 if NI GPS functionalities are to be locked
+# default - non is locked for backward compatibility
+#GPS_LOCK = 0
+
+# supl version 1.0
+SUPL_VER=0x10000
+
+# Emergency SUPL, 1=enable, 0=disable
+SUPL_ES=0
+
+#Choose PDN for Emergency SUPL
+#1 - Use emergency PDN
+#0 - Use regular SUPL PDN for Emergency SUPL
+USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL=1
+
+#SUPL_MODE is a bit mask set in config.xml per carrier by default.
+#If it is uncommented here, this value will overwrite the value from
+#config.xml.
+#MSA=0X2
+#MSB=0X1
+#SUPL_MODE=
+
+# GPS Capabilities bit mask
+# SCHEDULING = 0x01
+# MSB = 0x02
+# MSA = 0x04
+# ON_DEMAND_TIME = 0x10
+# GEOFENCE = 0x20
+# default = ON_DEMAND_TIME | MSA | MSB | SCHEDULING | GEOFENCE
+CAPABILITIES=0x37
+
+# Accuracy threshold for intermediate positions
+# less accurate positions are ignored, 0 for passing all positions
+# ACCURACY_THRES=5000
+
+################################
+##### AGPS server settings #####
+################################
+
+# FOR SUPL SUPPORT, set the following
+# SUPL_HOST=supl.host.com or IP
+# SUPL_PORT=1234
+
+# FOR C2K PDE SUPPORT, set the following
+# C2K_HOST=c2k.pde.com or IP
+# C2K_PORT=1234
+
+# Bitmask of slots that are available
+# for write/install to, where 1s indicate writable,
+# and the default value is 0 where no slots
+# are writable. For example, AGPS_CERT_WRITABLE_MASK
+# of b1000001010 makes 3 slots available
+# and the remaining 7 slots unwritable.
+#AGPS_CERT_WRITABLE_MASK=0
+
+####################################
+# LTE Positioning Profile Settings
+####################################
+# 0: Enable RRLP on LTE(Default)
+# 1: Enable LPP_User_Plane on LTE
+# 2: Enable LPP_Control_Plane
+# 3: Enable both LPP_User_Plane and LPP_Control_Plane
+LPP_PROFILE = 2
+
+################################
+# EXTRA SETTINGS
+################################
+# 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
+##################################################
+# 0x1: RRC CPlane
+# 0x2: RRLP UPlane
+# 0x4: LLP Uplane
+A_GLONASS_POS_PROTOCOL_SELECT = 0
diff --git a/msm8909/loc-api.pc.in b/msm8909/loc-api.pc.in
new file mode 100644
index 0000000..3b4f81b
--- /dev/null
+++ b/msm8909/loc-api.pc.in
@@ -0,0 +1,10 @@
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+includedir=@includedir@
+
+Name: loc-api
+Description: Qualcomm GPS Location API
+Version: @VERSION@
+Libs: -L${libdir} -lgps_utils_so -lloc_adapter_so -lloc_eng_so -lgps_default_so -lloc_api
+Cflags: -I${includedir}/loc-api/libloc_api_50001 -I${includedir}/loc-api/utils -I${includedir}/ -I${includedir}/loc-api
diff --git a/msm8909/loc_api/Android.mk b/msm8909/loc_api/Android.mk
new file mode 100644
index 0000000..743b386
--- /dev/null
+++ b/msm8909/loc_api/Android.mk
@@ -0,0 +1,17 @@
+ifneq ($(BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE),)
+
+LOCAL_PATH := $(call my-dir)
+
+# add RPC dirs if RPC is available
+ifneq ($(TARGET_NO_RPC),true)
+
+GPS_DIR_LIST += $(LOCAL_PATH)/libloc_api-rpc-50001/
+
+endif #TARGET_NO_RPC
+
+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
diff --git a/msm8909/loc_api/libloc_api-rpc-50001/Android.mk b/msm8909/loc_api/libloc_api-rpc-50001/Android.mk
new file mode 100644
index 0000000..6c5d533
--- /dev/null
+++ b/msm8909/loc_api/libloc_api-rpc-50001/Android.mk
@@ -0,0 +1,3 @@
+ifeq ($(BOARD_VENDOR_QCOM_GPS_LOC_API_AMSS_VERSION),50001)
+include $(call all-subdir-makefiles)
+endif
diff --git a/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/Android.mk b/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/Android.mk
new file mode 100644
index 0000000..bb3d924
--- /dev/null
+++ b/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/Android.mk
@@ -0,0 +1,60 @@
+LOCAL_PATH:= $(call my-dir)
+include $(CLEAR_VARS)
+
+RPC_INC:=rpc_inc
+
+source_files:= \
+ src/loc_api_rpc_glue.c \
+ src/loc_api_sync_call.c \
+ src/loc_apicb_appinit.c \
+ src/loc_api_fixup.c \
+ src/loc_api_log.c \
+ src/LocApiRpc.cpp
+
+LOCAL_SRC_FILES:= $(source_files)
+
+LOCAL_CFLAGS:=-fno-short-enums
+LOCAL_CFLAGS+=-DDEBUG -DUSE_QCOM_AUTO_RPC -DUSE_QCOM_AUTO_RPC
+LOCAL_CFLAGS+=$(GPS_FEATURES)
+
+# for loc_api_fixup.c
+LOCAL_CFLAGS+=-DADD_XDR_FLOAT -DADD_XDR_BOOL
+
+LOCAL_SHARED_LIBRARIES:= \
+ librpc \
+ libutils \
+ libcutils \
+ libcommondefs \
+ libgps.utils \
+ libloc_core
+
+LOCAL_STATIC_LIBRARIES := \
+ libloc_api_rpcgen
+
+LOCAL_PRELINK_MODULE:= false
+
+LOCAL_C_INCLUDES:= \
+ $(LOCAL_PATH) \
+ $(LOCAL_PATH)/rpc_inc \
+ $(TARGET_OUT_HEADERS)/gps.utils \
+ $(TARGET_OUT_HEADERS)/libloc_core \
+ $(TARGET_OUT_HEADERS)/loc_api/rpcgen/inc \
+ $(TARGET_OUT_HEADERS)/libcommondefs/rpcgen/inc \
+ $(TARGET_OUT_HEADERS)/librpc \
+ $(TARGET_OUT_HEADERS)/libloc-rpc/rpc_inc \
+ $(TOP)/hardware/msm7k/librpc
+
+LOCAL_COPY_HEADERS_TO:= libloc_api-rpc-qc/$(RPC_INC)
+LOCAL_COPY_HEADERS:= \
+ $(RPC_INC)/loc_api_rpc_glue.h \
+ $(RPC_INC)/loc_api_fixup.h \
+ $(RPC_INC)/loc_api_sync_call.h \
+ $(RPC_INC)/loc_apicb_appinit.h \
+ $(RPC_INC)/LocApiRpc.h
+
+LOCAL_MODULE:= libloc_api-rpc-qc
+LOCAL_MODULE_OWNER := qcom
+
+LOCAL_MODULE_TAGS := optional
+
+include $(BUILD_SHARED_LIBRARY)
diff --git a/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/Makefile.am b/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/Makefile.am
new file mode 100644
index 0000000..f5c5136
--- /dev/null
+++ b/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/Makefile.am
@@ -0,0 +1,46 @@
+AM_CFLAGS = \
+ -I../../../utils \
+ -I../../../platform_lib_abstractions \
+ -I./rpc_inc \
+ -I../libloc_api-rpc-stub/inc \
+ -I../../libloc_api_50001 \
+ $(MSM7K_CFLAGS) \
+ -DUSE_QCOM_AUTO_RPC
+
+requiredlibs = \
+ ../../../utils/libgps_utils_so.la \
+ $(MSM7K_LIBS)
+
+h_sources = \
+ rpc_inc/loc_api_rpc_glue.h \
+ rpc_inc/loc_api_fixup.h \
+ rpc_inc/loc_api_sync_call.h \
+ rpc_inc/loc_apicb_appinit.h \
+
+c_sources = \
+ src/loc_api_rpc_glue.c \
+ src/loc_api_sync_call.c \
+ src/loc_apicb_appinit.c \
+ src/loc_api_fixup.c \
+ src/loc_api_log.c \
+ src/LocApiRpcAdapter.cpp \
+
+
+library_includedir = $(pkgincludedir)/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc
+library_include_HEADERS = $(h_sources)
+libloc_api_rpc_qc_la_SOURCES = $(c_sources) $(h_sources)
+
+if USE_GLIB
+libloc_api_rpc_qc_la_CFLAGS = -DUSE_GLIB $(AM_CFLAGS) @GLIB_CFLAGS@
+libloc_api_rpc_qc_la_LDFLAGS = -lstdc++ -lpthread @GLIB_LIBS@ -shared -version-info 1:0:0
+libloc_api_rpc_qc_la_CPPFLAGS = -DUSE_GLIB $(AM_CFLAGS) $(AM_CPPFLAGS) @GLIB_CFLAGS@
+else
+libloc_api_rpc_qc_la_CFLAGS = $(AM_CFLAGS)
+libloc_api_rpc_qc_la_LDFLAGS = -lpthread -shared -version-info 1:0:0
+libloc_api_rpc_qc_la_CPPFLAGS = $(AM_CFLAGS) $(AM_CPPFLAGS)
+endif
+
+libloc_api_rpc_qc_la_LIBADD = $(requiredlibs) -lstdc++
+
+#Create and Install Libraries
+lib_LTLIBRARIES = libloc_api_rpc_qc.la
diff --git a/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/LocApiRpc.h b/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/LocApiRpc.h
new file mode 100644
index 0000000..01d67f4
--- /dev/null
+++ b/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/LocApiRpc.h
@@ -0,0 +1,140 @@
+/* Copyright (c) 2011,2014, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * 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_API_RPC_H
+#define LOC_API_RPC_H
+
+#include <rpc/rpc.h>
+#include <loc_api_rpcgen_common_rpc.h>
+#include <loc_api_rpc_glue.h>
+#include <LocApiBase.h>
+#include <loc_log.h>
+
+using namespace loc_core;
+
+class LocApiRpc : public LocApiBase {
+protected:
+ // RPC communication establishment
+ rpc_loc_client_handle_type client_handle;
+
+private:
+ int dataEnableLastSet;
+ char apnLastSet[MAX_APN_LEN];
+
+ static const LOC_API_ADAPTER_EVENT_MASK_T maskAll;
+ static const rpc_loc_event_mask_type locBits[];
+ static rpc_loc_event_mask_type convertMask(LOC_API_ADAPTER_EVENT_MASK_T mask);
+ static rpc_loc_lock_e_type convertGpsLockMask(LOC_GPS_LOCK_MASK lockMask);
+ static enum loc_api_adapter_err convertErr(int rpcErr);
+ static GpsNiEncodingType convertNiEncodingType(int loc_encoding);
+ static int NIEventFillVerfiyType(GpsNiNotification ¬if,
+ rpc_loc_ni_notify_verify_e_type notif_priv);
+
+ void reportPosition(const rpc_loc_parsed_position_s_type *location_report_ptr);
+ void reportSv(const rpc_loc_gnss_info_s_type *gnss_report_ptr);
+ void reportStatus(const rpc_loc_status_event_s_type *status_report_ptr);
+ void reportNmea(const rpc_loc_nmea_report_s_type *nmea_report_ptr);
+ void ATLEvent(const rpc_loc_server_request_s_type *server_request_ptr);
+ void NIEvent(const rpc_loc_ni_event_s_type *ni_req_ptr);
+
+protected:
+ virtual enum loc_api_adapter_err
+ open(LOC_API_ADAPTER_EVENT_MASK_T mask);
+ virtual enum loc_api_adapter_err
+ close();
+
+public:
+ LocApiRpc(const MsgTask* msgTask,
+ LOC_API_ADAPTER_EVENT_MASK_T exMask);
+ ~LocApiRpc();
+
+ virtual int locEventCB(rpc_loc_client_handle_type client_handle,
+ rpc_loc_event_mask_type loc_event,
+ const rpc_loc_event_payload_u_type* loc_event_payload);
+
+ void locRpcGlobalCB(CLIENT* clnt, enum rpc_reset_event event);
+
+ // RPC adapter interface implementations
+ virtual enum loc_api_adapter_err
+ startFix(const LocPosMode& posMode);
+ virtual enum loc_api_adapter_err
+ stopFix();
+ virtual enum loc_api_adapter_err
+ setPositionMode(const LocPosMode& mode);
+ inline virtual enum loc_api_adapter_err
+ enableData(int enable) { return enableData(enable, false); }
+ virtual enum loc_api_adapter_err
+ enableData(int enable, boolean force);
+ virtual enum loc_api_adapter_err
+ setTime(GpsUtcTime time, int64_t timeReference, int uncertainty);
+ virtual enum loc_api_adapter_err
+ injectPosition(double latitude, double longitude, float accuracy);
+ virtual enum loc_api_adapter_err
+ deleteAidingData(GpsAidingData f);
+ virtual enum loc_api_adapter_err
+ informNiResponse(GpsUserResponseType userResponse, const void* passThroughData);
+ inline virtual enum loc_api_adapter_err
+ setAPN(char* apn, int len) { return setAPN(apn, len, false); }
+ virtual enum loc_api_adapter_err
+ setAPN(char* apn, int len, boolean force);
+ virtual enum loc_api_adapter_err
+ setServer(const char* url, int len);
+ virtual enum loc_api_adapter_err
+ setServer(unsigned int ip, int port, LocServerType type);
+ virtual enum loc_api_adapter_err
+ setXtraData(char* data, int length);
+ virtual enum loc_api_adapter_err
+ requestXtraServer();
+ virtual enum loc_api_adapter_err
+ atlOpenStatus(int handle, int is_succ, char* apn, AGpsBearerType bear, AGpsType agpsType);
+ virtual enum loc_api_adapter_err
+ 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(LOC_GPS_LOCK_MASK lock);
+ /*
+ Returns
+ Current value of GPS Lock on success
+ -1 on failure
+ */
+ virtual int getGpsLock(void);
+};
+
+extern "C" LocApiBase* getLocApi(const MsgTask* msgTask,
+ LOC_API_ADAPTER_EVENT_MASK_T exMask,
+ ContextBase *context);
+
+#endif //LOC_API_RPC_H
diff --git a/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/debug.h b/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/debug.h
new file mode 100644
index 0000000..49a6d0b
--- /dev/null
+++ b/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/debug.h
@@ -0,0 +1,69 @@
+/* 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
+ * 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 DEBUG_H
+#define DEBUG_H
+
+#include <stdio.h>
+
+#define LOG_TAG "LocSvc_rpc"
+#include <utils/Log.h>
+
+#define PRINT(x...) do { \
+ fprintf(stdout, "%s(%d) ", __FUNCTION__, __LINE__); \
+ fprintf(stdout, ##x); \
+ ALOGD(x); \
+ } while(0)
+
+#ifdef DEBUG
+#define D PRINT
+#else
+#define D(x...) do { } while(0)
+#endif
+
+#ifdef VERBOSE
+#define V PRINT
+#else
+#define V(x...) do { } while(0)
+#endif
+
+#define E(x...) do { \
+ fprintf(stderr, "%s(%d) ", __FUNCTION__, __LINE__); \
+ fprintf(stderr, ##x); \
+ ALOGE(x); \
+ } while(0)
+
+#define FAILIF(cond, msg...) do { \
+ if (__builtin_expect (cond, 0)) { \
+ fprintf(stderr, "%s:%s:(%d): ", __FILE__, __FUNCTION__, __LINE__); \
+ fprintf(stderr, ##msg); \
+ ALOGE(##msg); \
+ } \
+ } while(0)
+
+#endif/*DEBUG_H*/
diff --git a/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/loc_api_fixup.h b/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/loc_api_fixup.h
new file mode 100644
index 0000000..c483b4a
--- /dev/null
+++ b/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/loc_api_fixup.h
@@ -0,0 +1,226 @@
+/* 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
+ * 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_API_FIXUP_H
+#define LOC_API_FIXUP_H
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#ifndef NULLPROC
+#define NULLPROC 0
+#endif /* NULLPROC */
+
+#ifdef ADD_XDR_FLOAT
+
+extern bool_t xdr_float (XDR *__xdrs, float *__fp);
+extern bool_t xdr_double (XDR *__xdrs, double *__dp);
+
+#endif /* ADD_XDR_FLOAT */
+
+#ifdef ADD_XDR_BOOL
+extern bool_t xdr_bool(XDR *__xdrs, int *__bp);
+#endif /* ADD_XDR_BOOL */
+
+#define RPC_LOC_API_MAJOR_VERSION_NUMBER 1
+#define RPC_LOC_API_MINOR_VERSION_NUMBER 0
+
+// Return value for loc_open in case of failure.
+#define RPC_LOC_CLIENT_HANDLE_INVALID -1
+
+// Return value of loc api calls for loc_close, loc_start_fix, loc_stop_fix and loc_ioctl
+// These are also the status for the ioctl callback
+#define RPC_LOC_API_SUCCESS 0
+#define RPC_LOC_API_GENERAL_FAILURE 1
+#define RPC_LOC_API_UNSUPPORTED 2
+#define RPC_LOC_API_INVALID_HANDLE 4
+#define RPC_LOC_API_INVALID_PARAMETER 5
+#define RPC_LOC_API_ENGINE_BUSY 6
+#define RPC_LOC_API_PHONE_OFFLINE 7
+#define RPC_LOC_API_TIMEOUT 8
+
+// Special return value for loc api calls in case of RPC failure
+#define RPC_LOC_API_RPC_FAILURE (-1234)
+// Special return value for modem restart incurred RPC failure
+#define RPC_LOC_API_RPC_MODEM_RESTART (-1235)
+
+#define RPC_LOC_API_MAX_SV_COUNT 80
+#define RPC_LOC_API_MAX_NMEA_STRING_LENGTH 1200
+
+// Maximum server address that will be used in location API
+#define RPC_LOC_API_MAX_SERVER_ADDR_LENGTH 256
+#define RPC_LOC_API_MAX_NUM_PREDICTED_ORBITS_SERVERS 3
+#define RPC_LOC_API_MAX_NUM_NTP_SERVERS 3
+
+#define RPC_LOC_EVENT_PARSED_POSITION_REPORT 0x00000001 // Position report comes in loc_parsed_position_s_type
+#define RPC_LOC_EVENT_SATELLITE_REPORT 0x00000002 // Satellite in view report
+#define RPC_LOC_EVENT_NMEA_1HZ_REPORT 0x00000004 // NMEA report at 1HZ rate
+#define RPC_LOC_EVENT_NMEA_POSITION_REPORT 0x00000008 // NMEA report at position report rate
+#define RPC_LOC_EVENT_NI_NOTIFY_VERIFY_REQUEST 0x00000010 // NI notification/verification request
+#define RPC_LOC_EVENT_ASSISTANCE_DATA_REQUEST 0x00000020 // Assistance data, eg: time, predicted orbits request
+#define RPC_LOC_EVENT_LOCATION_SERVER_REQUEST 0x00000040 // Request for location server
+#define RPC_LOC_EVENT_IOCTL_REPORT 0x00000080 // Callback report for loc_ioctl
+#define RPC_LOC_EVENT_STATUS_REPORT 0x00000100 // Misc status report: eg, engine state
+
+#define RPC_LOC_POS_VALID_SESSION_STATUS 0x00000001
+#define RPC_LOC_POS_VALID_TIMESTAMP_CALENDAR 0x00000002
+#define RPC_LOC_POS_VALID_TIMESTAMP_UTC 0x00000004
+#define RPC_LOC_POS_VALID_LEAP_SECONDS 0x00000008
+#define RPC_LOC_POS_VALID_TIME_UNC 0x00000010
+#define RPC_LOC_POS_VALID_LATITUDE 0x00000020
+#define RPC_LOC_POS_VALID_LONGITUDE 0x00000040
+#define RPC_LOC_POS_VALID_ALTITUDE_WRT_ELLIPSOID 0x00000080
+#define RPC_LOC_POS_VALID_ALTITUDE_WRT_MEAN_SEA_LEVEL 0x00000100
+#define RPC_LOC_POS_VALID_SPEED_HORIZONTAL 0x00000200
+#define RPC_LOC_POS_VALID_SPEED_VERTICAL 0x00000400
+#define RPC_LOC_POS_VALID_HEADING 0x00000800
+#define RPC_LOC_POS_VALID_HOR_UNC_CIRCULAR 0x00001000
+#define RPC_LOC_POS_VALID_HOR_UNC_ELLI_SEMI_MAJ 0x00002000
+#define RPC_LOC_POS_VALID_HOR_UNC_ELLI_SEMI_MIN 0x00004000
+#define RPC_LOC_POS_VALID_HOR_UNC_ELLI_ORIENT_AZIMUTH 0x00008000
+#define RPC_LOC_POS_VALID_VERTICAL_UNC 0x00010000
+#define RPC_LOC_POS_VALID_SPEED_UNC 0x00020000
+#define RPC_LOC_POS_VALID_HEADING_UNC 0x00040000
+#define RPC_LOC_POS_VALID_CONFIDENCE_HORIZONTAL 0x00080000
+#define RPC_LOC_POS_VALID_CONFIDENCE_VERTICAL 0x00100000
+#define RPC_LOC_POS_VALID_MAGNETIC_VARIATION 0x00200000
+#define RPC_LOC_POS_VALID_TECHNOLOGY_MASK 0x00400000
+
+#define RPC_LOC_POS_TECH_SATELLITE 0x00000001
+#define RPC_LOC_POS_TECH_CELLID 0x00000002
+#define RPC_LOC_POS_TECH_WIFI 0x00000004
+
+#define RPC_LOC_SV_INFO_VALID_SYSTEM 0x00000001
+#define RPC_LOC_SV_INFO_VALID_PRN 0x00000002
+#define RPC_LOC_SV_INFO_VALID_HEALTH_STATUS 0x00000004
+#define RPC_LOC_SV_INFO_VALID_PROCESS_STATUS 0x00000008
+#define RPC_LOC_SV_INFO_VALID_HAS_EPH 0x00000010
+#define RPC_LOC_SV_INFO_VALID_HAS_ALM 0x00000020
+#define RPC_LOC_SV_INFO_VALID_ELEVATION 0x00000040
+#define RPC_LOC_SV_INFO_VALID_AZIMUTH 0x00000080
+#define RPC_LOC_SV_INFO_VALID_SNR 0x00000100
+
+#define RPC_LOC_GNSS_INFO_VALID_POS_DOP 0x00000001
+#define RPC_LOC_GNSS_INFO_VALID_HOR_DOP 0x00000002
+#define RPC_LOC_GNSS_INFO_VALID_VERT_DOP 0x00000004
+#define RPC_LOC_GNSS_INFO_VALID_ALTITUDE_ASSUMED 0x00000008
+#define RPC_LOC_GNSS_INFO_VALID_SV_COUNT 0x00000010
+#define RPC_LOC_GNSS_INFO_VALID_SV_LIST 0x00000020
+
+#define RPC_LOC_NI_MAX_REQUESTOR_ID_LENGTH 200
+#define RPC_LOC_NI_SUPL_HASH_LENGTH 8
+#define RPC_LOC_NI_SUPL_SLP_SESSION_ID_BYTE_LENGTH 4
+#define RPC_LOC_NI_MAX_CLIENT_NAME_LENGTH 64
+#define RPC_LOC_NI_MAX_EXT_CLIENT_ADDRESS 20
+#define RPC_LOC_NI_CODEWORD_LENGTH 20
+
+#define RPC_LOC_NI_SUPL_QOP_VALID 0x01
+#define RPC_LOC_NI_SUPL_QOP_VERACC_VALID 0x02
+#define RPC_LOC_NI_SUPL_QOP_MAXAGE_VALID 0x04
+#define RPC_LOC_NI_SUPL_QOP_DELAY_VALID 0x08
+
+#define RPC_LOC_FIX_CRIT_VALID_RECURRENCE_TYPE 0x00000001
+#define RPC_LOC_FIX_CRIT_VALID_PREFERRED_OPERATION_MODE 0x00000002
+#define RPC_LOC_FIX_CRIT_VALID_PREFERRED_ACCURACY 0x00000004
+#define RPC_LOC_FIX_CRIT_VALID_PREFERRED_RESPONSE_TIME 0x00000008
+#define RPC_LOC_FIX_CRIT_VALID_INTERMEDIATE_POS_REPORT_ENABLED 0x00000010
+#define RPC_LOC_FIX_CRIT_VALID_NOTIFY_TYPE 0x00000020
+#define RPC_LOC_FIX_CRIT_VALID_MIN_INTERVAL 0x00000040
+#define RPC_LOC_FIX_CRIT_VALID_MIN_DISTANCE 0x00000080
+#define RPC_LOC_FIX_CRIT_VALID_MIN_DIST_SAMPLE_INTERVAL 0x00000100
+
+#define RPC_LOC_ASSIST_POS_VALID_TIMESTAMP_UTC 0x00000001
+#define RPC_LOC_ASSIST_POS_VALID_LATITUDE 0x00000002
+#define RPC_LOC_ASSIST_POS_VALID_LONGITUDE 0x00000004
+#define RPC_LOC_ASSIST_POS_VALID_ALTITUDE_WRT_ELLIPSOID 0x00000008
+#define RPC_LOC_ASSIST_POS_VALID_ALTITUDE_WRT_MEAN_SEA_LEVEL 0x00000010
+#define RPC_LOC_ASSIST_POS_VALID_HOR_UNC_CIRCULAR 0x00000020
+#define RPC_LOC_ASSIST_POS_VALID_VERT_UNC 0x00000040
+#define RPC_LOC_ASSIST_POS_VALID_CONFIDENCE_HORIZONTAL 0x00000080
+#define RPC_LOC_ASSIST_POS_VALID_CONFIDENCE_VERTICAL 0x00000100
+#define RPC_LOC_ASSIST_POS_VALID_TIMESTAMP_AGE 0x00000200
+
+#define RPC_LOC_ASSIST_DATA_ALL 0xFFFFFFFF
+
+#define RPC_LOC_NMEA_MASK_ALL 0xffff
+#define RPC_LOC_NMEA_MASK_GGA 0x0001
+#define RPC_LOC_NMEA_MASK_RMC 0x0002
+#define RPC_LOC_NMEA_MASK_GSV 0x0004
+#define RPC_LOC_NMEA_MASK_GSA 0x0008
+#define RPC_LOC_NMEA_MASK_VTG 0x0010
+
+/* EFS data access */
+#define RPC_LOC_EFS_MAX_PATH_LEN_BYTES 64 /* Max file name length in bytes that can be written*/
+#define RPC_LOC_EFS_MAX_FILE_LEN_BYTES 2000 /* Max file size in bytes that can be written */
+
+/* WIPER valid information flag in log report */
+#define RPC_LOC_WIPER_LOG_TIME_VALID 0x01
+#define RPC_LOC_WIPER_LOG_POS_VALID 0x02
+#define RPC_LOC_WIPER_LOG_AP_SET_VALID 0x04
+
+/* General WIPER defines */
+#define RPC_LOC_WIPER_MAC_ADDR_LENGTH 6 // Do not change this number since it affects RPC and log packet sizes
+#define RPC_LOC_WIPER_MAX_REPORTED_APS_PER_LOG_MSG 50 // Do not change this number since it affects RPC and log packet sizes
+
+/* WIPER AP Qualifier */
+#define RPC_LOC_WIPER_AP_QUALIFIER_BEING_USED 0x1 /* AP is being used by WPS */
+#define RPC_LOC_WIPER_AP_QUALIFIER_HIDDEN_SSID 0x2 /* AP does not broadcast SSID */
+#define RPC_LOC_WIPER_AP_QUALIFIER_PRIVATE 0x4 /* AP has encryption turned on */
+#define RPC_LOC_WIPER_AP_QUALIFIER_INFRASTRUCTURE_MODE 0x8 /* AP is in infrastructure mode and not in ad-hoc/unknown mode */
+
+/* flags for notification */
+#define RPC_LOC_NI_CLIENT_NAME_PRESENT 0x0001
+#define RPC_LOC_NI_CLIENT_EXTADDR_PRESENT 0x0002
+#define RPC_LOC_NI_DEF_LOCATION_TYPE_PRESENT 0x0010
+#define RPC_LOC_NI_REQUESTOR_ID_PRESENT 0x0020
+#define RPC_LOC_NI_CODEWORD_PRESENT 0x0040
+#define RPC_LOC_NI_SERVICE_TYPE_ID_PRESENT 0x0080
+#define RPC_LOC_NI_ENCODING_TYPE_PRESENT 0x0100
+
+/* below are for RPC_LOC_IOCTL_SET_LBS_APN_PROFILE data */
+/* values for apn_profiles[0].srv_system_type */
+#define LOC_APN_PROFILE_SRV_SYS_CDMA 0x01
+#define LOC_APN_PROFILE_SRV_SYS_HDR 0x02
+#define LOC_APN_PROFILE_SRV_SYS_GSM 0x04
+#define LOC_APN_PROFILE_SRV_SYS_WCDMA 0x08
+#define LOC_APN_PROFILE_SRV_SYS_LTE 0x10
+#define LOC_APN_PROFILE_SRV_SYS_MAX 0x1F
+/* values for apn_profiles[0].pdp_type */
+#define LOC_APN_PROFILE_PDN_TYPE_IPV4 0x01
+#define LOC_APN_PROFILE_PDN_TYPE_IPV6 0x02
+#define LOC_APN_PROFILE_PDN_TYPE_IPV4V6 0x03
+#define LOC_APN_PROFILE_PDN_TYPE_PPP 0x04
+#define LOC_APN_PROFILE_PDN_TYPE_MAX 0x04
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* LOC_API_FIXUP_H */
diff --git a/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/loc_api_log.h b/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/loc_api_log.h
new file mode 100644
index 0000000..f037428
--- /dev/null
+++ b/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/loc_api_log.h
@@ -0,0 +1,59 @@
+/* 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
+ * 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_API_LOG_H
+#define LOC_API_LOG_H
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#include <ctype.h>
+#include "loc_api_rpcgen_common_rpc.h"
+
+extern int loc_callback_log(
+ rpc_loc_event_mask_type loc_event, /* event mask */
+ const rpc_loc_event_payload_u_type* loc_event_payload /* payload */
+);
+
+extern const char* loc_get_event_atl_open_name(rpc_loc_server_request_e_type loc_event_atl_open);
+extern const char* loc_get_event_name(rpc_loc_event_mask_type loc_event_mask);
+extern const char* loc_get_ioctl_type_name(rpc_loc_ioctl_e_type ioctl_type);
+extern const char* loc_get_ioctl_status_name(uint32 status);
+extern const char* loc_get_sess_status_name(rpc_loc_session_status_e_type status);
+extern const char* loc_get_engine_state_name(rpc_loc_engine_state_e_type state);
+extern const char* loc_get_fix_session_state_name(rpc_loc_fix_session_state_e_type state);
+extern const char* loc_get_rpc_reset_event_name(enum rpc_reset_event event);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* LOC_API_LOG_H */
diff --git a/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/loc_api_rpc_glue.h b/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/loc_api_rpc_glue.h
new file mode 100644
index 0000000..6df33ae
--- /dev/null
+++ b/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/loc_api_rpc_glue.h
@@ -0,0 +1,123 @@
+/* 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
+ * 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_API_RPC_GLUE_H
+#define LOC_API_RPC_GLUE_H
+
+/* Include RPC headers */
+#ifdef USE_LOCAL_RPC
+#include "rpc_inc/loc_api_common.h"
+#include "rpc_inc/loc_api.h"
+#include "rpc_inc/loc_api_cb.h"
+#endif
+
+#ifdef USE_QCOM_AUTO_RPC
+#include "loc_api_rpcgen_rpc.h"
+#include "loc_api_rpcgen_common_rpc.h"
+#include "loc_api_rpcgen_cb_rpc.h"
+#endif
+
+/* Boolean */
+/* Other data types in comdef.h are defined in rpc stubs, so fix it here */
+typedef unsigned char boolean;
+#define TRUE 1
+#define FALSE 0
+
+#include "loc_api_fixup.h"
+#include "loc_api_sync_call.h"
+#include <rpc/clnt.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+extern int loc_api_glue_init(void);
+extern int loc_api_null(void);
+
+typedef int32 (loc_event_cb_f_type)(
+ void* userData,
+ rpc_loc_client_handle_type loc_handle, /* handle of the client */
+ rpc_loc_event_mask_type loc_event, /* event mask */
+ const rpc_loc_event_payload_u_type* loc_event_payload /* payload */
+);
+
+typedef void (loc_reset_notif_cb_f_type)(
+ void* userData,
+ CLIENT* clnt,
+ enum rpc_reset_event event
+);
+
+extern rpc_loc_client_handle_type loc_open(
+ rpc_loc_event_mask_type event_reg_mask,
+ loc_event_cb_f_type *event_callback,
+ loc_reset_notif_cb_f_type *rpc_global_cb,
+ void* userData
+);
+
+extern int32 loc_close
+(
+ rpc_loc_client_handle_type handle
+);
+
+extern void loc_clear
+(
+ rpc_loc_client_handle_type handle
+);
+
+extern int32 loc_start_fix
+(
+ rpc_loc_client_handle_type handle
+);
+
+extern int32 loc_stop_fix
+(
+ rpc_loc_client_handle_type handle
+);
+
+extern int32 loc_ioctl
+(
+ rpc_loc_client_handle_type handle,
+ rpc_loc_ioctl_e_type ioctl_type,
+ rpc_loc_ioctl_data_u_type* ioctl_data
+);
+
+extern int 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
+);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* LOC_API_RPC_GLUE_H */
diff --git a/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/loc_api_sync_call.h b/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/loc_api_sync_call.h
new file mode 100644
index 0000000..43208bd
--- /dev/null
+++ b/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/loc_api_sync_call.h
@@ -0,0 +1,90 @@
+/* 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
+ * 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_API_CB_SYNC_H
+#define LOC_API_CB_SYNC_H
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+#include "loc_api_rpc_glue.h"
+#define LOC_SYNC_CALL_SLOTS_MAX 8
+
+typedef struct {
+ pthread_mutex_t lock;
+
+ /* Client ID */
+ rpc_loc_client_handle_type loc_handle;
+
+ /* Callback waiting conditional variable */
+ pthread_cond_t loc_cb_arrived_cond;
+
+ /* Callback waiting data block, protected by loc_cb_data_mutex */
+ boolean in_use;
+ boolean signal_sent;
+ boolean not_available;
+ rpc_loc_event_mask_type loc_cb_wait_event_mask; /* event to wait for */
+ rpc_loc_ioctl_e_type ioctl_type; /* ioctl to wait for */
+ rpc_loc_event_payload_u_type loc_cb_received_payload; /* received payload */
+ rpc_loc_event_mask_type loc_cb_received_event_mask; /* received event */
+} loc_sync_call_slot_s_type;
+
+typedef struct {
+ int num_of_slots;
+ loc_sync_call_slot_s_type slots[LOC_SYNC_CALL_SLOTS_MAX];
+} loc_sync_call_slot_array_s_type;
+
+/* Init function */
+void loc_api_sync_call_init();
+
+/* Destroy function */
+void loc_api_sync_call_destroy();
+
+/* Process Loc API callbacks to wake up blocked user threads */
+void loc_api_callback_process_sync_call(
+ rpc_loc_client_handle_type loc_handle, /* handle of the client */
+ rpc_loc_event_mask_type loc_event, /* event mask */
+ const rpc_loc_event_payload_u_type* loc_event_payload /* payload */
+);
+
+/* Reentrant synchronous IOCTL call, using Loc API return code */
+int loc_api_sync_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
+);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* LOC_API_CB_SYNC_H */
diff --git a/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/loc_apicb_appinit.h b/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/loc_apicb_appinit.h
new file mode 100644
index 0000000..ba41d08
--- /dev/null
+++ b/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/loc_apicb_appinit.h
@@ -0,0 +1,45 @@
+/* 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
+ * 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_APICB_APPINIT_H
+#define LOC_APICB_APPINIT_H
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+ /* Initialization function for callbacks */
+extern int loc_apicb_app_init();
+extern void loc_apicb_app_deinit();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* LOC_APICB_APPINIT_H */
diff --git a/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/LocApiRpc.cpp b/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/LocApiRpc.cpp
new file mode 100644
index 0000000..c744754
--- /dev/null
+++ b/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/LocApiRpc.cpp
@@ -0,0 +1,1465 @@
+/* Copyright (c) 2011-2014, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * 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
+#define LOG_TAG "LocSvc_api_rpc"
+
+#include <unistd.h>
+#include <math.h>
+#ifndef USE_GLIB
+#include <utils/SystemClock.h>
+#endif /* USE_GLIB */
+#include <LocApiRpc.h>
+#include <LocAdapterBase.h>
+#include <loc_api_fixup.h>
+#include <loc_api_rpc_glue.h>
+#include <log_util.h>
+#include <loc_log.h>
+#include <loc_api_log.h>
+#ifdef USE_GLIB
+#include <glib.h>
+#endif
+#include <librpc.h>
+#include <platform_lib_includes.h>
+
+using namespace loc_core;
+
+#define LOC_XTRA_INJECT_DEFAULT_TIMEOUT (3100)
+#define XTRA_BLOCK_SIZE (3072)
+#define LOC_IOCTL_DEFAULT_TIMEOUT 1000 // 1000 milli-seconds
+#define LOC_NI_NOTIF_KEY_ADDRESS "Address"
+
+/*===========================================================================
+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
+(
+ void* user,
+ rpc_loc_client_handle_type client_handle,
+ rpc_loc_event_mask_type loc_event,
+ const rpc_loc_event_payload_u_type* loc_event_payload
+)
+{
+ MODEM_LOG_CALLFLOW(%s, loc_get_event_name(loc_event));
+ loc_callback_log(loc_event, loc_event_payload);
+ int32 ret_val = ((LocApiRpc*)user)->locEventCB(client_handle, loc_event, loc_event_payload);
+ EXIT_LOG(%d, ret_val);
+ return ret_val;
+}
+
+/*===========================================================================
+FUNCTION loc_eng_rpc_global_cb
+
+DESCRIPTION
+ This is the callback function registered by loc_open for RPC global events
+
+DEPENDENCIES
+ N/A
+
+RETURN VALUE
+ RPC_LOC_API_SUCCESS
+
+SIDE EFFECTS
+ N/A
+
+===========================================================================*/
+static void loc_rpc_global_cb(void* user, CLIENT* clnt, enum rpc_reset_event event)
+{
+ MODEM_LOG_CALLFLOW(%s, loc_get_rpc_reset_event_name(event));
+ ((LocApiRpc*)user)->locRpcGlobalCB(clnt, event);
+ EXIT_LOG(%p, VOID_RET);
+}
+
+const LOC_API_ADAPTER_EVENT_MASK_T LocApiRpc::maskAll =
+ LOC_API_ADAPTER_BIT_PARSED_POSITION_REPORT |
+ LOC_API_ADAPTER_BIT_SATELLITE_REPORT |
+ LOC_API_ADAPTER_BIT_LOCATION_SERVER_REQUEST |
+ LOC_API_ADAPTER_BIT_ASSISTANCE_DATA_REQUEST |
+ LOC_API_ADAPTER_BIT_IOCTL_REPORT |
+ LOC_API_ADAPTER_BIT_STATUS_REPORT |
+ LOC_API_ADAPTER_BIT_NMEA_1HZ_REPORT |
+ LOC_API_ADAPTER_BIT_NI_NOTIFY_VERIFY_REQUEST;
+
+const rpc_loc_event_mask_type LocApiRpc::locBits[] =
+{
+ RPC_LOC_EVENT_PARSED_POSITION_REPORT,
+ RPC_LOC_EVENT_SATELLITE_REPORT,
+ RPC_LOC_EVENT_NMEA_1HZ_REPORT,
+ RPC_LOC_EVENT_NMEA_POSITION_REPORT,
+ RPC_LOC_EVENT_NI_NOTIFY_VERIFY_REQUEST,
+ RPC_LOC_EVENT_ASSISTANCE_DATA_REQUEST,
+ RPC_LOC_EVENT_LOCATION_SERVER_REQUEST,
+ RPC_LOC_EVENT_IOCTL_REPORT,
+ RPC_LOC_EVENT_STATUS_REPORT,
+ RPC_LOC_EVENT_WPS_NEEDED_REQUEST
+};
+
+// constructor
+LocApiRpc::LocApiRpc(const MsgTask* msgTask,
+ LOC_API_ADAPTER_EVENT_MASK_T exMask,
+ ContextBase* context) :
+ LocApiBase(msgTask, exMask, context),
+ client_handle(RPC_LOC_CLIENT_HANDLE_INVALID),
+ dataEnableLastSet(-1)
+{
+ memset(apnLastSet, 0, sizeof(apnLastSet));
+ loc_api_glue_init();
+}
+
+LocApiRpc::~LocApiRpc()
+{
+ close();
+}
+
+rpc_loc_event_mask_type
+LocApiRpc::convertMask(LOC_API_ADAPTER_EVENT_MASK_T mask)
+{
+ rpc_loc_event_mask_type newMask = 0;
+
+ for (unsigned int i = 0, bit=1; 0 != mask; i++, bit<<=1) {
+ if (mask & bit) {
+ newMask |= locBits[i];
+ mask ^= bit;
+ }
+ }
+
+ return newMask;
+}
+
+rpc_loc_lock_e_type
+LocApiRpc::convertGpsLockMask(LOC_GPS_LOCK_MASK lockMask)
+{
+ if (isGpsLockAll(lockMask))
+ return RPC_LOC_LOCK_ALL;
+ if (isGpsLockMO(lockMask))
+ return RPC_LOC_LOCK_MI;
+ if (isGpsLockMT(lockMask))
+ return RPC_LOC_LOCK_MT;
+ if (isGpsLockNone(lockMask))
+ return RPC_LOC_LOCK_NONE;
+ return (rpc_loc_lock_e_type)lockMask;
+}
+
+enum loc_api_adapter_err
+LocApiRpc::convertErr(int rpcErr)
+{
+ switch(rpcErr)
+ {
+ case RPC_LOC_API_SUCCESS:
+ return LOC_API_ADAPTER_ERR_SUCCESS;
+ case RPC_LOC_API_GENERAL_FAILURE:
+ return LOC_API_ADAPTER_ERR_GENERAL_FAILURE;
+ case RPC_LOC_API_UNSUPPORTED:
+ return LOC_API_ADAPTER_ERR_UNSUPPORTED;
+ case RPC_LOC_API_INVALID_HANDLE:
+ return LOC_API_ADAPTER_ERR_INVALID_HANDLE;
+ case RPC_LOC_API_INVALID_PARAMETER:
+ return LOC_API_ADAPTER_ERR_INVALID_PARAMETER;
+ case RPC_LOC_API_ENGINE_BUSY:
+ return LOC_API_ADAPTER_ERR_ENGINE_BUSY;
+ case RPC_LOC_API_PHONE_OFFLINE:
+ return LOC_API_ADAPTER_ERR_PHONE_OFFLINE;
+ case RPC_LOC_API_TIMEOUT:
+ return LOC_API_ADAPTER_ERR_TIMEOUT;
+ case RPC_LOC_API_RPC_MODEM_RESTART:
+ return LOC_API_ADAPTER_ERR_ENGINE_DOWN;
+ case RPC_LOC_API_RPC_FAILURE:
+ return LOC_API_ADAPTER_ERR_FAILURE;
+ default:
+ return LOC_API_ADAPTER_ERR_UNKNOWN;
+ }
+}
+
+void LocApiRpc::locRpcGlobalCB(CLIENT* clnt, enum rpc_reset_event event)
+{
+ static rpc_loc_engine_state_e_type last_state = RPC_LOC_ENGINE_STATE_MAX;
+
+ switch (event) {
+ case RPC_SUBSYSTEM_RESTART_BEGIN:
+ if (RPC_LOC_ENGINE_STATE_OFF != last_state) {
+ last_state = RPC_LOC_ENGINE_STATE_OFF;
+ handleEngineDownEvent();
+ }
+ break;
+ case RPC_SUBSYSTEM_RESTART_END:
+ if (RPC_LOC_ENGINE_STATE_ON != last_state) {
+ last_state = RPC_LOC_ENGINE_STATE_ON;
+ handleEngineUpEvent();
+ }
+ break;
+ }
+}
+
+int32 LocApiRpc::locEventCB(rpc_loc_client_handle_type client_handle,
+ rpc_loc_event_mask_type loc_event,
+ const rpc_loc_event_payload_u_type* loc_event_payload)
+{
+ // Parsed report
+ if (loc_event & RPC_LOC_EVENT_PARSED_POSITION_REPORT)
+ {
+ reportPosition(&loc_event_payload->rpc_loc_event_payload_u_type_u.
+ parsed_location_report);
+ }
+
+ // Satellite report
+ if (loc_event & RPC_LOC_EVENT_SATELLITE_REPORT)
+ {
+ reportSv(&loc_event_payload->rpc_loc_event_payload_u_type_u.gnss_report);
+ }
+
+ // Status report
+ if (loc_event & RPC_LOC_EVENT_STATUS_REPORT)
+ {
+ reportStatus(&loc_event_payload->rpc_loc_event_payload_u_type_u.status_report);
+ }
+
+ // NMEA
+ if (loc_event & RPC_LOC_EVENT_NMEA_1HZ_REPORT)
+ {
+ reportNmea(&(loc_event_payload->rpc_loc_event_payload_u_type_u.nmea_report));
+ }
+ // XTRA support: 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)
+ {
+ requestXtraData();
+ } else if (loc_event_payload->rpc_loc_event_payload_u_type_u.assist_data_request.event ==
+ RPC_LOC_ASSIST_DATA_TIME_REQ)
+ {
+ requestTime();
+ } else if (loc_event_payload->rpc_loc_event_payload_u_type_u.assist_data_request.event ==
+ RPC_LOC_ASSIST_DATA_POSITION_INJECTION_REQ)
+ {
+ requestLocation();
+ }
+ }
+
+ // AGPS data request
+ if (loc_event & RPC_LOC_EVENT_LOCATION_SERVER_REQUEST)
+ {
+ ATLEvent(&loc_event_payload->rpc_loc_event_payload_u_type_u.
+ loc_server_request);
+ }
+
+ // NI notify request
+ if (loc_event & RPC_LOC_EVENT_NI_NOTIFY_VERIFY_REQUEST)
+ {
+ NIEvent(&loc_event_payload->rpc_loc_event_payload_u_type_u.ni_request);
+ }
+
+ return RPC_LOC_API_SUCCESS;//We simply want to return sucess here as we do not want to
+ // cause any issues in RPC thread context
+}
+
+enum loc_api_adapter_err
+LocApiRpc::open(LOC_API_ADAPTER_EVENT_MASK_T mask)
+{
+ enum loc_api_adapter_err ret_val = LOC_API_ADAPTER_ERR_SUCCESS;
+
+ // RPC does not dynamically update the event mask. And in the
+ // case of RPC, all we support are positioning (gps + agps)
+ // masks anyways, so we simply mask all of them on always.
+ // After doing so the first time in a power cycle, we know there
+ // will the following if condition will never be true any more.
+ mask = maskAll;
+
+ if (mask != mMask) {
+ if (RPC_LOC_CLIENT_HANDLE_INVALID != client_handle) {
+ close();
+ }
+
+ mMask = mask;
+ // it is important to cap the mask here, because not all LocApi's
+ // can enable the same bits, e.g. foreground and bckground.
+ client_handle = loc_open(convertMask(mask),
+ loc_event_cb,
+ loc_rpc_global_cb, this);
+
+ if (client_handle < 0) {
+ mMask = 0;
+ client_handle = RPC_LOC_CLIENT_HANDLE_INVALID;
+ ret_val = LOC_API_ADAPTER_ERR_INVALID_HANDLE;
+ }
+ }
+
+ return ret_val;
+}
+
+enum loc_api_adapter_err
+LocApiRpc::close()
+{
+ if (RPC_LOC_CLIENT_HANDLE_INVALID != client_handle) {
+ loc_clear(client_handle);
+ }
+
+ loc_close(client_handle);
+ mMask = 0;
+ client_handle = RPC_LOC_CLIENT_HANDLE_INVALID;
+
+ return LOC_API_ADAPTER_ERR_SUCCESS;
+}
+
+enum loc_api_adapter_err
+LocApiRpc::startFix(const LocPosMode& posMode) {
+ LOC_LOGD("LocApiRpc::startFix() called");
+ return convertErr(
+ loc_start_fix(client_handle)
+ );
+}
+
+enum loc_api_adapter_err
+LocApiRpc::stopFix() {
+ LOC_LOGD("LocApiRpc::stopFix() called");
+ return convertErr(
+ loc_stop_fix(client_handle)
+ );
+}
+
+enum loc_api_adapter_err
+LocApiRpc::setPositionMode(const LocPosMode& posMode)
+{
+ rpc_loc_ioctl_data_u_type ioctl_data;
+ rpc_loc_fix_criteria_s_type *fix_criteria_ptr =
+ &ioctl_data.rpc_loc_ioctl_data_u_type_u.fix_criteria;
+ rpc_loc_ioctl_e_type ioctl_type = RPC_LOC_IOCTL_SET_FIX_CRITERIA;
+ rpc_loc_operation_mode_e_type op_mode;
+ int ret_val;
+ const LocPosMode* fixCriteria = &posMode;
+
+ ALOGD ("loc_eng_set_position mode, client = %d, interval = %d, mode = %d\n",
+ (int32) client_handle, fixCriteria->min_interval, fixCriteria->mode);
+
+ switch (fixCriteria->mode)
+ {
+ case LOC_POSITION_MODE_MS_BASED:
+ op_mode = RPC_LOC_OPER_MODE_MSB;
+ break;
+ case LOC_POSITION_MODE_MS_ASSISTED:
+ op_mode = RPC_LOC_OPER_MODE_MSA;
+ break;
+ case LOC_POSITION_MODE_RESERVED_1:
+ op_mode = RPC_LOC_OPER_MODE_SPEED_OPTIMAL;
+ break;
+ case LOC_POSITION_MODE_RESERVED_2:
+ op_mode = RPC_LOC_OPER_MODE_ACCURACY_OPTIMAL;
+ break;
+ case LOC_POSITION_MODE_RESERVED_3:
+ op_mode = RPC_LOC_OPER_MODE_DATA_OPTIMAL;
+ break;
+ case LOC_POSITION_MODE_RESERVED_4:
+ case LOC_POSITION_MODE_RESERVED_5:
+ op_mode = RPC_LOC_OPER_MODE_MSA;
+ fix_criteria_ptr->preferred_response_time = 0;
+ break;
+ default:
+ op_mode = RPC_LOC_OPER_MODE_STANDALONE;
+ }
+
+ fix_criteria_ptr->valid_mask = RPC_LOC_FIX_CRIT_VALID_PREFERRED_OPERATION_MODE |
+ RPC_LOC_FIX_CRIT_VALID_RECURRENCE_TYPE;
+ fix_criteria_ptr->min_interval = fixCriteria->min_interval;
+ fix_criteria_ptr->preferred_operation_mode = op_mode;
+
+ fix_criteria_ptr->min_interval = fixCriteria->min_interval;
+ fix_criteria_ptr->valid_mask |= RPC_LOC_FIX_CRIT_VALID_MIN_INTERVAL;
+
+ if (fixCriteria->preferred_accuracy > 0) {
+ fix_criteria_ptr->preferred_accuracy = fixCriteria->preferred_accuracy;
+ fix_criteria_ptr->valid_mask |= RPC_LOC_FIX_CRIT_VALID_PREFERRED_ACCURACY;
+ }
+ if (fixCriteria->preferred_time > 0) {
+ fix_criteria_ptr->preferred_response_time = fixCriteria->preferred_time;
+ fix_criteria_ptr->valid_mask |= RPC_LOC_FIX_CRIT_VALID_PREFERRED_RESPONSE_TIME;
+ }
+
+ switch (fixCriteria->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;
+ }
+ ioctl_data.disc = ioctl_type;
+
+ ret_val = loc_eng_ioctl (client_handle,
+ ioctl_type,
+ &ioctl_data,
+ LOC_IOCTL_DEFAULT_TIMEOUT,
+ NULL /* No output information is expected*/);
+
+ return convertErr(ret_val);
+}
+
+enum loc_api_adapter_err
+LocApiRpc::setTime(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;
+ rpc_loc_ioctl_e_type ioctl_type = RPC_LOC_IOCTL_INJECT_UTC_TIME;
+ int ret_val;
+
+ LOC_LOGD ("loc_eng_inject_time, uncertainty = %d\n", uncertainty);
+
+ 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)(ELAPSED_MILLIS_SINCE_BOOT_PLATFORM_LIB_ABSTRACTION - timeReference);
+ time_info_ptr->uncertainty = uncertainty; // Uncertainty in ms
+
+ ioctl_data.disc = ioctl_type;
+
+ ret_val = loc_eng_ioctl (client_handle,
+ ioctl_type,
+ &ioctl_data,
+ LOC_IOCTL_DEFAULT_TIMEOUT,
+ NULL /* No output information is expected*/);
+
+ return convertErr(ret_val);
+}
+
+enum loc_api_adapter_err
+LocApiRpc::injectPosition(double latitude, double longitude, float accuracy)
+{
+ /* IOCTL data */
+ rpc_loc_ioctl_data_u_type ioctl_data;
+ rpc_loc_assist_data_pos_s_type *assistance_data_position =
+ &ioctl_data.rpc_loc_ioctl_data_u_type_u.assistance_data_position;
+ int ret_val;
+
+ /************************************************
+ * Fill in latitude, longitude & accuracy
+ ************************************************/
+
+ /* This combo is required */
+ assistance_data_position->valid_mask =
+ RPC_LOC_ASSIST_POS_VALID_LATITUDE |
+ RPC_LOC_ASSIST_POS_VALID_LONGITUDE |
+ RPC_LOC_ASSIST_POS_VALID_HOR_UNC_CIRCULAR |
+ RPC_LOC_ASSIST_POS_VALID_CONFIDENCE_HORIZONTAL;
+
+ assistance_data_position->latitude = latitude;
+ assistance_data_position->longitude = longitude;
+ assistance_data_position->hor_unc_circular = accuracy; /* Meters assumed */
+ assistance_data_position->confidence_horizontal = 63; /* 63% (1 std dev) assumed */
+
+ /* Log */
+ LOC_LOGD("Inject coarse position Lat=%lf, Lon=%lf, Acc=%.2lf\n",
+ (double) assistance_data_position->latitude,
+ (double) assistance_data_position->longitude,
+ (double) assistance_data_position->hor_unc_circular);
+
+ ret_val = loc_eng_ioctl( client_handle,
+ RPC_LOC_IOCTL_INJECT_POSITION,
+ &ioctl_data,
+ LOC_IOCTL_DEFAULT_TIMEOUT,
+ NULL /* No output information is expected*/);
+ return convertErr(ret_val);
+}
+
+enum loc_api_adapter_err
+LocApiRpc::informNiResponse(GpsUserResponseType userResponse,
+ const void* passThroughData)
+{
+ 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,
+ passThroughData, sizeof (rpc_loc_ni_event_s_type));
+
+ rpc_loc_ni_user_resp_e_type resp;
+ switch (userResponse)
+ {
+ case GPS_NI_RESPONSE_ACCEPT:
+ data.rpc_loc_ioctl_data_u_type_u.user_verify_resp.user_resp =
+ RPC_LOC_NI_LCS_NOTIFY_VERIFY_ACCEPT;
+ break;
+ case GPS_NI_RESPONSE_DENY:
+ data.rpc_loc_ioctl_data_u_type_u.user_verify_resp.user_resp =
+ RPC_LOC_NI_LCS_NOTIFY_VERIFY_DENY;
+ break;
+ case GPS_NI_RESPONSE_NORESP:
+ default:
+ data.rpc_loc_ioctl_data_u_type_u.user_verify_resp.user_resp =
+ RPC_LOC_NI_LCS_NOTIFY_VERIFY_NORESP;
+ break;
+ }
+
+ return convertErr(
+ loc_eng_ioctl(client_handle,
+ RPC_LOC_IOCTL_INFORM_NI_USER_RESPONSE,
+ &data,
+ LOC_IOCTL_DEFAULT_TIMEOUT,
+ &callback_payload)
+ );
+}
+
+enum loc_api_adapter_err
+LocApiRpc::setAPN(char* apn, int len, boolean force)
+{
+ enum loc_api_adapter_err rtv = LOC_API_ADAPTER_ERR_SUCCESS;
+ int size = sizeof(apnLastSet);
+ if (force || memcmp(apnLastSet, apn, size)) {
+ if (len < size) {
+ // size will be not larger than its original value
+ size = len + 1;
+ }
+ memcpy(apnLastSet, apn, size);
+
+ if (!isInSession()) {
+ rpc_loc_ioctl_data_u_type ioctl_data = {RPC_LOC_IOCTL_SET_LBS_APN_PROFILE, {0}};
+ ioctl_data.rpc_loc_ioctl_data_u_type_u.apn_profiles[0].srv_system_type = LOC_APN_PROFILE_SRV_SYS_MAX;
+ ioctl_data.rpc_loc_ioctl_data_u_type_u.apn_profiles[0].pdp_type = LOC_APN_PROFILE_PDN_TYPE_IPV4;
+ memcpy(&(ioctl_data.rpc_loc_ioctl_data_u_type_u.apn_profiles[0].apn_name), apn, size);
+
+ rtv = convertErr(
+ loc_eng_ioctl (client_handle,
+ RPC_LOC_IOCTL_SET_LBS_APN_PROFILE,
+ &ioctl_data,
+ LOC_IOCTL_DEFAULT_TIMEOUT,
+ NULL)
+ );
+ }
+ }
+ return rtv;
+}
+
+void LocApiRpc::setInSession(bool inSession)
+{
+ if (!inSession) {
+ enableData(dataEnableLastSet, true);
+ setAPN(apnLastSet, sizeof(apnLastSet)-1, true);
+ }
+}
+
+enum loc_api_adapter_err
+LocApiRpc::setServer(const char* url, int len)
+{
+ rpc_loc_ioctl_data_u_type ioctl_data;
+ rpc_loc_server_info_s_type *server_info_ptr;
+ rpc_loc_ioctl_e_type ioctl_cmd;
+
+ ioctl_cmd = RPC_LOC_IOCTL_SET_UMTS_SLP_SERVER_ADDR;
+ ioctl_data.disc = ioctl_cmd;
+ server_info_ptr = &ioctl_data.rpc_loc_ioctl_data_u_type_u.server_addr;
+ server_info_ptr->addr_type = RPC_LOC_SERVER_ADDR_URL;
+ server_info_ptr->addr_info.disc = server_info_ptr->addr_type;
+ server_info_ptr->addr_info.rpc_loc_server_addr_u_type_u.url.length = len;
+#if (AMSS_VERSION==3200)
+ server_info_ptr->addr_info.rpc_loc_server_addr_u_type_u.url.addr.addr_val = (char*) url;
+ server_info_ptr->addr_info.rpc_loc_server_addr_u_type_u.url.addr.addr_len= len;
+#else
+ strlcpy(server_info_ptr->addr_info.rpc_loc_server_addr_u_type_u.url.addr, url,
+ sizeof server_info_ptr->addr_info.rpc_loc_server_addr_u_type_u.url.addr);
+#endif /* #if (AMSS_VERSION==3200) */
+ LOC_LOGD ("loc_eng_set_server, addr = %s\n", url);
+
+ return convertErr(
+ loc_eng_ioctl (client_handle,
+ ioctl_cmd,
+ &ioctl_data,
+ LOC_IOCTL_DEFAULT_TIMEOUT,
+ NULL /* No output information is expected*/)
+ );
+}
+
+enum loc_api_adapter_err
+LocApiRpc::setServer(unsigned int ip, int port, LocServerType type)
+{
+ rpc_loc_ioctl_data_u_type ioctl_data;
+ rpc_loc_server_info_s_type *server_info_ptr;
+ rpc_loc_ioctl_e_type ioctl_cmd;
+
+ switch (type) {
+ case LOC_AGPS_MPC_SERVER:
+ ioctl_cmd = RPC_LOC_IOCTL_SET_CDMA_MPC_SERVER_ADDR;
+ break;
+ case LOC_AGPS_CUSTOM_PDE_SERVER:
+ ioctl_cmd = RPC_LOC_IOCTL_SET_CUSTOM_PDE_SERVER_ADDR;
+ break;
+ default:
+ ioctl_cmd = RPC_LOC_IOCTL_SET_CDMA_PDE_SERVER_ADDR;
+ break;
+ }
+ ioctl_data.disc = ioctl_cmd;
+ server_info_ptr = &ioctl_data.rpc_loc_ioctl_data_u_type_u.server_addr;
+ server_info_ptr->addr_type = RPC_LOC_SERVER_ADDR_IPV4;
+ server_info_ptr->addr_info.disc = server_info_ptr->addr_type;
+ server_info_ptr->addr_info.rpc_loc_server_addr_u_type_u.ipv4.addr = ip;
+ server_info_ptr->addr_info.rpc_loc_server_addr_u_type_u.ipv4.port = port;
+ LOC_LOGD ("setServer, addr = %X:%d\n", (unsigned int) ip, (unsigned int) port);
+
+ return convertErr(
+ loc_eng_ioctl (client_handle,
+ ioctl_cmd,
+ &ioctl_data,
+ LOC_IOCTL_DEFAULT_TIMEOUT,
+ NULL /* No output information is expected*/)
+ );
+}
+
+enum loc_api_adapter_err
+LocApiRpc::enableData(int enable, boolean force)
+{
+ enum loc_api_adapter_err rtv = LOC_API_ADAPTER_ERR_SUCCESS;
+ if (force || dataEnableLastSet != enable) {
+ dataEnableLastSet = enable;
+
+ if (!isInSession()) {
+ rpc_loc_ioctl_data_u_type ioctl_data = {RPC_LOC_IOCTL_SET_DATA_ENABLE, {0}};
+
+ ioctl_data.rpc_loc_ioctl_data_u_type_u.data_enable = enable;
+ rtv = convertErr(
+ loc_eng_ioctl (client_handle,
+ RPC_LOC_IOCTL_SET_DATA_ENABLE,
+ &ioctl_data,
+ LOC_IOCTL_DEFAULT_TIMEOUT,
+ NULL)
+ );
+ }
+ }
+ return rtv;
+}
+
+enum loc_api_adapter_err
+LocApiRpc::deleteAidingData(GpsAidingData bits)
+{
+ rpc_loc_ioctl_data_u_type ioctl_data = {RPC_LOC_IOCTL_DELETE_ASSIST_DATA, {0}};
+ ioctl_data.rpc_loc_ioctl_data_u_type_u.assist_data_delete.type = bits;
+
+ return convertErr(
+ loc_eng_ioctl (client_handle,
+ RPC_LOC_IOCTL_DELETE_ASSIST_DATA,
+ &ioctl_data,
+ LOC_IOCTL_DEFAULT_TIMEOUT,
+ NULL)
+ );
+}
+
+void LocApiRpc::reportPosition(const rpc_loc_parsed_position_s_type *location_report_ptr)
+{
+ LocPosTechMask tech_Mask = LOC_POS_TECH_MASK_DEFAULT;
+
+ UlpLocation location = {0};
+ GpsLocationExtended locationExtended = {0};
+
+ location.size = sizeof(location);
+ locationExtended.size = sizeof(locationExtended);
+ if (location_report_ptr->valid_mask & RPC_LOC_POS_VALID_SESSION_STATUS)
+ {
+ // Process the position from final and intermediate reports
+ if (location_report_ptr->session_status == RPC_LOC_SESS_STATUS_SUCCESS ||
+ location_report_ptr->session_status == RPC_LOC_SESS_STATUS_IN_PROGESS)
+ {
+ // Latitude & Longitude
+ if ((location_report_ptr->valid_mask & RPC_LOC_POS_VALID_LATITUDE) &&
+ (location_report_ptr->valid_mask & RPC_LOC_POS_VALID_LONGITUDE) &&
+ (location_report_ptr->latitude != 0 ||
+ location_report_ptr->longitude != 0))
+ {
+ location.gpsLocation.flags |= GPS_LOCATION_HAS_LAT_LONG;
+ location.gpsLocation.latitude = location_report_ptr->latitude;
+ location.gpsLocation.longitude = location_report_ptr->longitude;
+
+ // Time stamp (UTC)
+ if (location_report_ptr->valid_mask & RPC_LOC_POS_VALID_TIMESTAMP_UTC)
+ {
+ location.gpsLocation.timestamp = location_report_ptr->timestamp_utc;
+ }
+
+ // Altitude
+ if (location_report_ptr->valid_mask & RPC_LOC_POS_VALID_ALTITUDE_WRT_ELLIPSOID )
+ {
+ location.gpsLocation.flags |= GPS_LOCATION_HAS_ALTITUDE;
+ location.gpsLocation.altitude = location_report_ptr->altitude_wrt_ellipsoid;
+ }
+
+ // Speed
+ if (location_report_ptr->valid_mask & RPC_LOC_POS_VALID_SPEED_HORIZONTAL)
+ {
+ location.gpsLocation.flags |= GPS_LOCATION_HAS_SPEED;
+ location.gpsLocation.speed = location_report_ptr->speed_horizontal;
+ }
+
+ // Heading
+ if (location_report_ptr->valid_mask & RPC_LOC_POS_VALID_HEADING)
+ {
+ location.gpsLocation.flags |= GPS_LOCATION_HAS_BEARING;
+ location.gpsLocation.bearing = location_report_ptr->heading;
+ }
+
+ // Uncertainty (circular)
+ if ( (location_report_ptr->valid_mask & RPC_LOC_POS_VALID_HOR_UNC_CIRCULAR) )
+ {
+ location.gpsLocation.flags |= GPS_LOCATION_HAS_ACCURACY;
+ location.gpsLocation.accuracy = location_report_ptr->hor_unc_circular;
+ }
+
+ // Technology Mask
+
+ tech_Mask |= location_report_ptr->technology_mask;
+ //Mark the location source as from GNSS
+ location.gpsLocation.flags |= LOCATION_HAS_SOURCE_INFO;
+ location.position_source = ULP_LOCATION_IS_FROM_GNSS;
+ if (location_report_ptr->valid_mask & RPC_LOC_POS_VALID_ALTITUDE_WRT_MEAN_SEA_LEVEL)
+ {
+ locationExtended.flags |= GPS_LOCATION_EXTENDED_HAS_ALTITUDE_MEAN_SEA_LEVEL;
+ locationExtended.altitudeMeanSeaLevel = location_report_ptr->altitude_wrt_mean_sea_level;
+ }
+
+ if (location_report_ptr->valid_mask & RPC_LOC_POS_VALID_MAGNETIC_VARIATION )
+ {
+ locationExtended.flags |= GPS_LOCATION_EXTENDED_HAS_MAG_DEV;
+ locationExtended.magneticDeviation = location_report_ptr->magnetic_deviation;
+ }
+
+ if (location_report_ptr->valid_mask & RPC_LOC_POS_VALID_VERTICAL_UNC)
+ {
+ locationExtended.flags |= GPS_LOCATION_EXTENDED_HAS_VERT_UNC;
+ locationExtended.vert_unc = location_report_ptr->vert_unc;
+ }
+
+ if (location_report_ptr->valid_mask & RPC_LOC_POS_VALID_SPEED_UNC)
+ {
+ locationExtended.flags |= GPS_LOCATION_EXTENDED_HAS_SPEED_UNC;
+ locationExtended.speed_unc = location_report_ptr->speed_unc;
+ }
+
+ LOC_LOGV("reportPosition: fire callback\n");
+ enum loc_sess_status fixStatus =
+ (location_report_ptr->session_status
+ == RPC_LOC_SESS_STATUS_IN_PROGESS ?
+ LOC_SESS_INTERMEDIATE : LOC_SESS_SUCCESS);
+ LocApiBase::reportPosition(location,
+ locationExtended,
+ (void*)location_report_ptr,
+ fixStatus,
+ tech_Mask);
+ }
+ }
+ else
+ {
+ LocApiBase::reportPosition(location,
+ locationExtended,
+ NULL,
+ LOC_SESS_FAILURE);
+ LOC_LOGV("loc_eng_report_position: ignore position report "
+ "when session status = %d\n",
+ location_report_ptr->session_status);
+ }
+ }
+ else
+ {
+ LOC_LOGV("loc_eng_report_position: ignore position report "
+ "when session status is not set\n");
+ }
+}
+
+void LocApiRpc::reportSv(const rpc_loc_gnss_info_s_type *gnss_report_ptr)
+{
+ GnssSvStatus SvStatus = {0};
+ GpsLocationExtended locationExtended = {0};
+ locationExtended.size = sizeof(locationExtended);
+ int num_svs_max = 0;
+ const rpc_loc_sv_info_s_type *sv_info_ptr;
+
+ 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 (int 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(GpsSvInfo);
+ 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.gps_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)
+ {
+ if ((sv_info_ptr->valid_mask & RPC_LOC_SV_INFO_VALID_PROCESS_STATUS) &&
+ (sv_info_ptr->process_status == RPC_LOC_SV_STATUS_TRACK))
+ {
+ SvStatus.glo_used_in_fix_mask |= (1 << (sv_info_ptr->prn-1));
+ }
+
+ 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++;
+ }
+ }
+
+ if ((gnss_report_ptr->valid_mask & RPC_LOC_GNSS_INFO_VALID_POS_DOP) &&
+ (gnss_report_ptr->valid_mask & RPC_LOC_GNSS_INFO_VALID_HOR_DOP) &&
+ (gnss_report_ptr->valid_mask & RPC_LOC_GNSS_INFO_VALID_VERT_DOP))
+ {
+ locationExtended.flags |= GPS_LOCATION_EXTENDED_HAS_DOP;
+ locationExtended.pdop = gnss_report_ptr->position_dop;
+ locationExtended.hdop = gnss_report_ptr->horizontal_dop;
+ locationExtended.vdop = gnss_report_ptr->vertical_dop;
+ }
+
+ if (SvStatus.num_svs >= 0)
+ {
+ LocApiBase::reportSv(SvStatus,
+ locationExtended,
+ (void*)gnss_report_ptr);
+ }
+}
+
+void LocApiRpc::reportStatus(const rpc_loc_status_event_s_type *status_report_ptr)
+{
+
+ 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)
+ {
+ LocApiBase::reportStatus(GPS_STATUS_ENGINE_ON);
+ LocApiBase::reportStatus(GPS_STATUS_SESSION_BEGIN);
+ }
+ else if (status_report_ptr->payload.rpc_loc_status_event_payload_u_type_u.engine_state == RPC_LOC_ENGINE_STATE_OFF)
+ {
+ LocApiBase::reportStatus(GPS_STATUS_SESSION_END);
+ LocApiBase::reportStatus(GPS_STATUS_ENGINE_OFF);
+ }
+ else
+ {
+ LocApiBase::reportStatus(GPS_STATUS_NONE);
+ }
+ }
+
+}
+
+void LocApiRpc::reportNmea(const rpc_loc_nmea_report_s_type *nmea_report_ptr)
+{
+
+#if (AMSS_VERSION==3200)
+ LocApiBase::reportNmea(nmea_report_ptr->nmea_sentences.nmea_sentences_val,
+ nmea_report_ptr->nmea_sentences.nmea_sentences_len);
+#else
+ LocApiBase::reportNmea(nmea_report_ptr->nmea_sentences,
+ nmea_report_ptr->length);
+ LOC_LOGD("loc_eng_report_nmea: $%c%c%c\n",
+ nmea_report_ptr->nmea_sentences[3],
+ nmea_report_ptr->nmea_sentences[4],
+ nmea_report_ptr->nmea_sentences[5]);
+#endif /* #if (AMSS_VERSION==3200) */
+}
+
+enum loc_api_adapter_err
+LocApiRpc::setXtraData(char* data, int length)
+{
+ int rpc_ret_val = RPC_LOC_API_GENERAL_FAILURE;
+ int total_parts;
+ uint8 part;
+ uint16 part_len;
+ uint16 len_injected;
+ rpc_loc_ioctl_data_u_type ioctl_data;
+ rpc_loc_ioctl_e_type ioctl_type = RPC_LOC_IOCTL_INJECT_PREDICTED_ORBITS_DATA;
+ rpc_loc_predicted_orbits_data_s_type *predicted_orbits_data_ptr;
+
+ LOC_LOGD("qct_loc_eng_inject_xtra_data, xtra size = %d, data ptr = 0x%lx\n", length, (long) 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 - 1) / XTRA_BLOCK_SIZE + 1;
+ predicted_orbits_data_ptr->total_parts = total_parts;
+
+ len_injected = 0; // O bytes injected
+ ioctl_data.disc = ioctl_type;
+
+ // 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;
+
+ LOC_LOGD("qct_loc_eng_inject_xtra_data, part %d/%d, len = %d, total = %d\n",
+ predicted_orbits_data_ptr->part,
+ total_parts,
+ predicted_orbits_data_ptr->part_len,
+ len_injected);
+
+ if (part < total_parts)
+ {
+ // No callback in this case
+ rpc_ret_val = loc_ioctl (client_handle,
+ ioctl_type,
+ &ioctl_data);
+
+ if (rpc_ret_val != RPC_LOC_API_SUCCESS)
+ {
+ LOC_LOGE("loc_ioctl for xtra error: %s\n", loc_get_ioctl_status_name(rpc_ret_val));
+ break;
+ }
+ //Add a delay of 10 ms so that repeated RPC calls dont starve the modem processor
+ usleep(10 * 1000);
+ }
+ else // part == total_parts
+ {
+ // Last part injection, will need to wait for callback
+ if (!loc_eng_ioctl(client_handle,
+ ioctl_type,
+ &ioctl_data,
+ LOC_XTRA_INJECT_DEFAULT_TIMEOUT,
+ NULL))
+ {
+ rpc_ret_val = RPC_LOC_API_GENERAL_FAILURE;
+ }
+ break; // done with injection
+ }
+
+ len_injected += predicted_orbits_data_ptr->part_len;
+ LOC_LOGD("loc_ioctl XTRA injected length: %d\n", len_injected);
+ }
+
+ return convertErr(rpc_ret_val);
+}
+
+/* Request the Xtra Server Url from the modem */
+enum loc_api_adapter_err
+LocApiRpc::requestXtraServer()
+{
+ loc_api_adapter_err err;
+ rpc_loc_ioctl_data_u_type data;
+ rpc_loc_ioctl_callback_s_type callback_data;
+
+ err = convertErr(loc_eng_ioctl(client_handle,
+ RPC_LOC_IOCTL_QUERY_PREDICTED_ORBITS_DATA_SOURCE,
+ &data,
+ LOC_IOCTL_DEFAULT_TIMEOUT,
+ &callback_data));
+
+ if (LOC_API_ADAPTER_ERR_SUCCESS != err)
+ {
+ LOC_LOGE("RPC_LOC_IOCTL_QUERY_PREDICTED_ORBITS_DATA_SOURCE failed!: err=%d\n", err);
+ return err;
+ }
+ else if (RPC_LOC_SESS_STATUS_SUCCESS != callback_data.status)
+ {
+ LOC_LOGE("RPC_LOC_IOCTL_QUERY_PREDICTED_ORBITS_DATA_SOURCE failed!: status=%ld\n", callback_data.status);
+ return LOC_API_ADAPTER_ERR_GENERAL_FAILURE;
+ }
+ else if (RPC_LOC_IOCTL_QUERY_PREDICTED_ORBITS_DATA_SOURCE != callback_data.type)
+ {
+ LOC_LOGE("RPC_LOC_IOCTL_QUERY_PREDICTED_ORBITS_DATA_SOURCE is not the type expected! type=%d\n", callback_data.type);
+ return LOC_API_ADAPTER_ERR_GENERAL_FAILURE;
+ }
+ else if (RPC_LOC_IOCTL_QUERY_PREDICTED_ORBITS_DATA_SOURCE != callback_data.data.disc)
+ {
+ LOC_LOGE("RPC_LOC_IOCTL_QUERY_PREDICTED_ORBITS_DATA_SOURCE is not the disc expected! disc=%d\n", callback_data.data.disc);
+ return LOC_API_ADAPTER_ERR_GENERAL_FAILURE;
+ }
+
+ reportXtraServer(callback_data.data.rpc_loc_ioctl_callback_data_u_type_u.
+ predicted_orbits_data_source.servers[0],
+ callback_data.data.rpc_loc_ioctl_callback_data_u_type_u.
+ predicted_orbits_data_source.servers[1],
+ callback_data.data.rpc_loc_ioctl_callback_data_u_type_u.
+ predicted_orbits_data_source.servers[2],
+ 255);
+
+ return LOC_API_ADAPTER_ERR_SUCCESS;
+}
+
+enum loc_api_adapter_err
+LocApiRpc::atlOpenStatus(int handle, int is_succ, char* apn, AGpsBearerType bearer, AGpsType agpsType)
+{
+ rpc_loc_server_open_status_e_type open_status = is_succ ? RPC_LOC_SERVER_OPEN_SUCCESS : RPC_LOC_SERVER_OPEN_FAIL;
+ rpc_loc_ioctl_data_u_type ioctl_data;
+
+ if (AGPS_TYPE_INVALID == agpsType) {
+ rpc_loc_server_open_status_s_type *conn_open_status_ptr =
+ &ioctl_data.rpc_loc_ioctl_data_u_type_u.conn_open_status;
+
+ // Fill in data
+ ioctl_data.disc = RPC_LOC_IOCTL_INFORM_SERVER_OPEN_STATUS;
+ conn_open_status_ptr->conn_handle = handle;
+ conn_open_status_ptr->open_status = open_status;
+#if (AMSS_VERSION==3200)
+ conn_open_status_ptr->apn_name = apn; /* requires APN */
+#else
+ if (is_succ) {
+ strlcpy(conn_open_status_ptr->apn_name, apn,
+ sizeof conn_open_status_ptr->apn_name);
+ } else {
+ conn_open_status_ptr->apn_name[0] = 0;
+ }
+#endif /* #if (AMSS_VERSION==3200) */
+
+ LOC_LOGD("ATL RPC_LOC_IOCTL_INFORM_SERVER_OPEN_STATUS open %s, APN name = [%s]\n",
+ log_succ_fail_string(is_succ),
+ apn);
+ } else {
+ rpc_loc_server_multi_open_status_s_type *conn_multi_open_status_ptr =
+ &ioctl_data.rpc_loc_ioctl_data_u_type_u.multi_conn_open_status;
+
+ // Fill in data
+ ioctl_data.disc = RPC_LOC_IOCTL_INFORM_SERVER_MULTI_OPEN_STATUS;
+ conn_multi_open_status_ptr->conn_handle = handle;
+ conn_multi_open_status_ptr->open_status = open_status;
+ if (is_succ) {
+ strlcpy(conn_multi_open_status_ptr->apn_name, apn,
+ sizeof conn_multi_open_status_ptr->apn_name);
+ } else {
+ conn_multi_open_status_ptr->apn_name[0] = 0;
+ }
+
+ switch(bearer)
+ {
+ case AGPS_APN_BEARER_IPV4:
+ conn_multi_open_status_ptr->pdp_type = RPC_LOC_SERVER_PDP_IP;
+ break;
+ case AGPS_APN_BEARER_IPV6:
+ conn_multi_open_status_ptr->pdp_type = RPC_LOC_SERVER_PDP_IPV6;
+ break;
+ case AGPS_APN_BEARER_IPV4V6:
+ conn_multi_open_status_ptr->pdp_type = RPC_LOC_SERVER_PDP_IPV4V6;
+ break;
+ default:
+ conn_multi_open_status_ptr->pdp_type = RPC_LOC_SERVER_PDP_PPP;
+ }
+
+ LOC_LOGD("ATL RPC_LOC_IOCTL_INFORM_SERVER_MULTI_OPEN_STATUS open %s, APN name = [%s], pdp_type = %d\n",
+ log_succ_fail_string(is_succ),
+ apn,
+ conn_multi_open_status_ptr->pdp_type);
+ }
+
+ // Make the IOCTL call
+ return convertErr(
+ loc_eng_ioctl(client_handle,
+ ioctl_data.disc,
+ &ioctl_data,
+ LOC_IOCTL_DEFAULT_TIMEOUT,
+ NULL)
+ );
+}
+
+enum loc_api_adapter_err
+LocApiRpc::atlCloseStatus(int handle, int is_succ)
+{
+ rpc_loc_ioctl_data_u_type ioctl_data;
+ ioctl_data.disc = RPC_LOC_IOCTL_INFORM_SERVER_CLOSE_STATUS;
+
+ rpc_loc_server_close_status_s_type *conn_close_status_ptr =
+ &ioctl_data.rpc_loc_ioctl_data_u_type_u.conn_close_status;
+ conn_close_status_ptr->conn_handle = handle;
+ conn_close_status_ptr->close_status = is_succ ? RPC_LOC_SERVER_CLOSE_SUCCESS : RPC_LOC_SERVER_CLOSE_FAIL;
+
+ // Make the IOCTL call
+ return convertErr(
+ loc_eng_ioctl(client_handle,
+ ioctl_data.disc,
+ &ioctl_data,
+ LOC_IOCTL_DEFAULT_TIMEOUT,
+ NULL)
+ );
+}
+
+void LocApiRpc::ATLEvent(const rpc_loc_server_request_s_type *server_request_ptr)
+{
+ int connHandle;
+ AGpsType agps_type;
+
+ LOC_LOGV("RPC_LOC_EVENT_ASSISTANCE_DATA_REQUEST event %s)",
+ loc_get_event_atl_open_name(server_request_ptr->event));
+ switch (server_request_ptr->event)
+ {
+ case RPC_LOC_SERVER_REQUEST_MULTI_OPEN:
+ connHandle = server_request_ptr->payload.rpc_loc_server_request_u_type_u.multi_open_req.conn_handle;
+ if (server_request_ptr->payload.rpc_loc_server_request_u_type_u.multi_open_req.connection_type
+ == RPC_LOC_SERVER_CONNECTION_LBS) {
+ agps_type = AGPS_TYPE_SUPL;
+ LOC_LOGV("ATLEvent: event - RPC_LOC_SERVER_REQUEST_MULTI_OPEN\n type - AGPS_TYPE_SUPL\n handle - %d", connHandle);
+ } else {
+ agps_type = AGPS_TYPE_WWAN_ANY;
+ LOC_LOGV("ATLEvent: event - RPC_LOC_SERVER_REQUEST_MULTI_OPEN\n type - AGPS_TYPE_WWAN_ANY\n handle - %d", connHandle);
+ }
+ requestATL(connHandle, agps_type);
+ break;
+ case RPC_LOC_SERVER_REQUEST_OPEN:
+ connHandle = server_request_ptr->payload.rpc_loc_server_request_u_type_u.open_req.conn_handle;
+ LOC_LOGV("ATLEvent: event - RPC_LOC_SERVER_REQUEST_OPEN\n handle - %d", connHandle);
+ requestATL(connHandle, AGPS_TYPE_INVALID);
+ break;
+ case RPC_LOC_SERVER_REQUEST_CLOSE:
+ connHandle = server_request_ptr->payload.rpc_loc_server_request_u_type_u.close_req.conn_handle;
+ LOC_LOGV("ATLEvent: event - RPC_LOC_SERVER_REQUEST_CLOSE\n handle - %d", connHandle);
+ releaseATL(connHandle);
+ break;
+ default:
+ LOC_LOGE("ATLEvent: event type %d invalid", server_request_ptr->event);
+ }
+}
+
+void LocApiRpc::NIEvent(const rpc_loc_ni_event_s_type *ni_req)
+{
+ GpsNiNotification notif = {0};
+
+ switch (ni_req->event)
+ {
+ case RPC_LOC_NI_EVENT_VX_NOTIFY_VERIFY_REQ:
+ {
+ const rpc_loc_ni_vx_notify_verify_req_s_type *vx_req =
+ &ni_req->payload.rpc_loc_ni_event_payload_u_type_u.vx_req;
+ LOC_LOGI("VX Notification");
+ notif.ni_type = GPS_NI_TYPE_VOICE;
+ // 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 = convertNiEncodingType(vx_req->encoding_scheme);
+ NIEventFillVerfiyType(notif, vx_req->notification_priv_type);
+ }
+ break;
+
+ case RPC_LOC_NI_EVENT_UMTS_CP_NOTIFY_VERIFY_REQ:
+ {
+ const rpc_loc_ni_umts_cp_notify_verify_req_s_type *umts_cp_req =
+ &ni_req->payload.rpc_loc_ni_event_payload_u_type_u.umts_cp_req;
+ LOC_LOGI("UMTS CP Notification\n");
+ notif.ni_type= GPS_NI_TYPE_UMTS_CTRL_PLANE; // Stores notification text
+#if (AMSS_VERSION==3200)
+ hexcode(notif.text, sizeof notif.text,
+ umts_cp_req->notification_text.notification_text_val,
+ umts_cp_req->notification_length);
+ hexcode(notif.requestor_id, sizeof notif.requestor_id,
+ umts_cp_req->requestor_id.requestor_id_string.requestor_id_string_val,
+ umts_cp_req->requestor_id.string_len);
+#else
+ hexcode(notif.text, sizeof notif.text,
+ umts_cp_req->notification_text,
+ umts_cp_req->notification_length);
+ hexcode(notif.requestor_id, sizeof notif.requestor_id,
+ umts_cp_req->requestor_id.requestor_id_string,
+ umts_cp_req->requestor_id.string_len);
+#endif
+ notif.text_encoding = convertNiEncodingType(umts_cp_req->datacoding_scheme);
+ notif.requestor_id_encoding = notif.text_encoding;
+ NIEventFillVerfiyType(notif, umts_cp_req->notification_priv_type);
+
+ // LCS address (using extras field)
+ if (umts_cp_req->ext_client_address_data.ext_client_address_len != 0)
+ {
+ // Copy LCS Address into notif.extras in the format: Address = 012345
+ strlcat(notif.extras, LOC_NI_NOTIF_KEY_ADDRESS, sizeof notif.extras);
+ strlcat(notif.extras, " = ", sizeof notif.extras);
+ int addr_len = 0;
+ const char *address_source = NULL;
+
+#if (AMSS_VERSION==3200)
+ address_source = umts_cp_req->ext_client_address_data.ext_client_address.ext_client_address_val;
+#else
+ address_source = umts_cp_req->ext_client_address_data.ext_client_address;
+#endif /* #if (AMSS_VERSION==3200) */
+
+ char lcs_addr[32]; // Decoded LCS address for UMTS CP NI
+ addr_len = decodeAddress(lcs_addr, sizeof lcs_addr, address_source,
+ umts_cp_req->ext_client_address_data.ext_client_address_len);
+
+ // The address is ASCII string
+ if (addr_len)
+ {
+ strlcat(notif.extras, lcs_addr, sizeof notif.extras);
+ }
+ }
+ }
+ break;
+
+ case RPC_LOC_NI_EVENT_SUPL_NOTIFY_VERIFY_REQ:
+ {
+ const rpc_loc_ni_supl_notify_verify_req_s_type *supl_req =
+ &ni_req->payload.rpc_loc_ni_event_payload_u_type_u.supl_req;
+ LOC_LOGI("SUPL Notification\n");
+ notif.ni_type = GPS_NI_TYPE_UMTS_SUPL;
+
+ if (supl_req->flags & RPC_LOC_NI_CLIENT_NAME_PRESENT)
+ {
+#if (AMSS_VERSION==3200)
+ hexcode(notif.text, sizeof notif.text,
+ supl_req->client_name.client_name_string.client_name_string_val, /* buffer */
+ supl_req->client_name.string_len /* length */
+ );
+#else
+ hexcode(notif.text, sizeof notif.text,
+ supl_req->client_name.client_name_string, /* buffer */
+ supl_req->client_name.string_len /* length */
+ );
+#endif /* #if (AMSS_VERSION==3200) */
+ LOC_LOGV("SUPL NI: client_name: %s len=%d", notif.text, supl_req->client_name.string_len);
+ }
+ else {
+ LOC_LOGV("SUPL NI: client_name not present.");
+ }
+
+ // Requestor ID
+ if (supl_req->flags & RPC_LOC_NI_REQUESTOR_ID_PRESENT)
+ {
+#if (AMSS_VERSION==3200)
+ hexcode(notif.requestor_id, sizeof notif.requestor_id,
+ supl_req->requestor_id.requestor_id_string.requestor_id_string_val, /* buffer */
+ supl_req->requestor_id.string_len /* length */
+ );
+#else
+ hexcode(notif.requestor_id, sizeof notif.requestor_id,
+ supl_req->requestor_id.requestor_id_string, /* buffer */
+ supl_req->requestor_id.string_len /* length */
+ );
+#endif /* #if (AMSS_VERSION==3200) */
+ LOC_LOGV("SUPL NI: requestor_id: %s len=%d", notif.requestor_id, supl_req->requestor_id.string_len);
+ }
+ else {
+ LOC_LOGV("SUPL NI: requestor_id not present.");
+ }
+
+ // Encoding type
+ if (supl_req->flags & RPC_LOC_NI_ENCODING_TYPE_PRESENT)
+ {
+ notif.text_encoding = convertNiEncodingType(supl_req->datacoding_scheme);
+ notif.requestor_id_encoding = notif.text_encoding;
+ }
+ else {
+ notif.text_encoding = notif.requestor_id_encoding = GPS_ENC_UNKNOWN;
+ }
+
+ NIEventFillVerfiyType(notif, ni_req->payload.rpc_loc_ni_event_payload_u_type_u.supl_req.notification_priv_type);
+ }
+ break;
+
+ default:
+ LOC_LOGE("Unknown NI event: %x\n", (int) ni_req->event);
+ return;
+ }
+
+ // this copy will get freed in loc_eng_ni when loc_ni_respond() is called
+ rpc_loc_ni_event_s_type *copy = (rpc_loc_ni_event_s_type *)malloc(sizeof(*copy));
+ memcpy(copy, ni_req, sizeof(*copy));
+ requestNiNotify(notif, (const void*)copy);
+}
+
+int LocApiRpc::NIEventFillVerfiyType(GpsNiNotification ¬if,
+ rpc_loc_ni_notify_verify_e_type notif_priv)
+{
+ switch (notif_priv)
+ {
+ case RPC_LOC_NI_USER_NO_NOTIFY_NO_VERIFY:
+ notif.notify_flags = 0;
+ notif.default_response = GPS_NI_RESPONSE_NORESP;
+ return 1;
+ case RPC_LOC_NI_USER_NOTIFY_ONLY:
+ notif.notify_flags = GPS_NI_NEED_NOTIFY;
+ notif.default_response = GPS_NI_RESPONSE_NORESP;
+ return 1;
+ 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;
+ return 1;
+ 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;
+ return 1;
+ case RPC_LOC_NI_USER_PRIVACY_OVERRIDE:
+ notif.notify_flags = GPS_NI_PRIVACY_OVERRIDE;
+ notif.default_response = GPS_NI_RESPONSE_NORESP;
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+enum loc_api_adapter_err
+LocApiRpc::setSUPLVersion(uint32_t version)
+{
+ rpc_loc_ioctl_data_u_type ioctl_data = {RPC_LOC_IOCTL_SET_SUPL_VERSION, {0}};
+ ioctl_data.rpc_loc_ioctl_data_u_type_u.supl_version = (int)version;
+ return convertErr(
+ loc_eng_ioctl (client_handle,
+ RPC_LOC_IOCTL_SET_SUPL_VERSION,
+ &ioctl_data,
+ LOC_IOCTL_DEFAULT_TIMEOUT,
+ NULL)
+ );
+}
+
+GpsNiEncodingType LocApiRpc::convertNiEncodingType(int loc_encoding)
+{
+ switch (loc_encoding)
+ {
+ case RPC_LOC_NI_SUPL_UTF8:
+ return GPS_ENC_SUPL_UTF8;
+ case RPC_LOC_NI_SUPL_UCS2:
+ return GPS_ENC_SUPL_UCS2;
+ case RPC_LOC_NI_SUPL_GSM_DEFAULT:
+ return GPS_ENC_SUPL_GSM_DEFAULT;
+ case RPC_LOC_NI_SS_LANGUAGE_UNSPEC:
+ return GPS_ENC_SUPL_GSM_DEFAULT; // SS_LANGUAGE_UNSPEC = GSM
+ default:
+ return GPS_ENC_UNKNOWN;
+ }
+}
+
+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(LOC_GPS_LOCK_MASK lockMask)
+{
+ rpc_loc_ioctl_data_u_type ioctl_data;
+ boolean ret_val;
+ LOC_LOGD("%s:%d]: lock: %x\n", __func__, __LINE__, lockMask);
+ ioctl_data.rpc_loc_ioctl_data_u_type_u.engine_lock = convertGpsLockMask(lockMask);
+ 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;
+}
diff --git a/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/loc_api_fixup.c b/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/loc_api_fixup.c
new file mode 100644
index 0000000..837ef11
--- /dev/null
+++ b/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/loc_api_fixup.c
@@ -0,0 +1,52 @@
+/* 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
+ * 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 <rpc/rpc.h>
+
+#include "loc_api_fixup.h"
+
+#ifdef ADD_XDR_FLOAT
+
+int
+xdr_float(xdrp, fp)
+ XDR *xdrp;
+ float *fp;
+{
+ return xdr_long(xdrp, (long*)fp);
+}
+
+int
+xdr_double(xdrp, dp)
+ XDR *xdrp;
+ double *dp;
+{
+ return xdr_long(xdrp, (long*)dp + 1)
+ && xdr_long(xdrp, (long*)dp);
+}
+
+#endif /* ADD_XDR_FLOAT */
diff --git a/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/loc_api_log.c b/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/loc_api_log.c
new file mode 100644
index 0000000..1c48232
--- /dev/null
+++ b/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/loc_api_log.c
@@ -0,0 +1,345 @@
+/* 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
+ * 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
+#define LOG_TAG "LocSvc_api_rpc_glue"
+
+#include "loc_api_log.h"
+#include "loc_log.h"
+#include "log_util.h"
+#include "platform_lib_includes.h"
+#include "rpc/rpc.h"
+#include "loc_api_fixup.h"
+
+/* Event names */
+loc_name_val_s_type loc_event_name[] =
+ {
+ NAME_VAL( RPC_LOC_EVENT_PARSED_POSITION_REPORT ),
+ NAME_VAL( RPC_LOC_EVENT_SATELLITE_REPORT ),
+ NAME_VAL( RPC_LOC_EVENT_NMEA_1HZ_REPORT ),
+ NAME_VAL( RPC_LOC_EVENT_NMEA_POSITION_REPORT ),
+ NAME_VAL( RPC_LOC_EVENT_NI_NOTIFY_VERIFY_REQUEST ),
+ NAME_VAL( RPC_LOC_EVENT_ASSISTANCE_DATA_REQUEST ),
+ NAME_VAL( RPC_LOC_EVENT_LOCATION_SERVER_REQUEST ),
+ NAME_VAL( RPC_LOC_EVENT_IOCTL_REPORT ),
+ NAME_VAL( RPC_LOC_EVENT_STATUS_REPORT ),
+ NAME_VAL( RPC_LOC_EVENT_WPS_NEEDED_REQUEST ),
+ };
+int loc_event_num = sizeof loc_event_name / sizeof(loc_name_val_s_type);
+
+/* Event names */
+loc_name_val_s_type loc_event_atl_open_name[] =
+ {
+ NAME_VAL( RPC_LOC_SERVER_REQUEST_OPEN ),
+ NAME_VAL( RPC_LOC_SERVER_REQUEST_CLOSE ),
+ NAME_VAL( RPC_LOC_SERVER_REQUEST_MULTI_OPEN )
+ };
+int loc_event_atl_open_num = sizeof loc_event_atl_open_name / sizeof(loc_name_val_s_type);
+
+/* Finds the first event found in the mask */
+const char* loc_get_event_atl_open_name(rpc_loc_server_request_e_type loc_event_atl_open)
+{
+ return loc_get_name_from_val(loc_event_atl_open_name, loc_event_atl_open_num,
+ (long) loc_event_atl_open);
+}
+
+/* IOCTL Type names */
+loc_name_val_s_type loc_ioctl_type_name[] =
+ {
+ NAME_VAL( RPC_LOC_IOCTL_GET_API_VERSION ),
+ NAME_VAL( RPC_LOC_IOCTL_SET_FIX_CRITERIA ),
+ NAME_VAL( RPC_LOC_IOCTL_GET_FIX_CRITERIA ),
+ NAME_VAL( RPC_LOC_IOCTL_INFORM_NI_USER_RESPONSE ),
+ NAME_VAL( RPC_LOC_IOCTL_INJECT_PREDICTED_ORBITS_DATA ),
+ NAME_VAL( RPC_LOC_IOCTL_QUERY_PREDICTED_ORBITS_DATA_VALIDITY ),
+ NAME_VAL( RPC_LOC_IOCTL_QUERY_PREDICTED_ORBITS_DATA_SOURCE ),
+ NAME_VAL( RPC_LOC_IOCTL_SET_PREDICTED_ORBITS_DATA_AUTO_DOWNLOAD ),
+ NAME_VAL( RPC_LOC_IOCTL_INJECT_UTC_TIME ),
+ NAME_VAL( RPC_LOC_IOCTL_INJECT_RTC_VALUE ),
+ NAME_VAL( RPC_LOC_IOCTL_INJECT_POSITION ),
+ NAME_VAL( RPC_LOC_IOCTL_QUERY_ENGINE_STATE ),
+ NAME_VAL( RPC_LOC_IOCTL_ERROR_ESTIMATE_CONFIG),
+ NAME_VAL( RPC_LOC_IOCTL_INFORM_SERVER_MULTI_OPEN_STATUS ),
+ NAME_VAL( RPC_LOC_IOCTL_INFORM_SERVER_OPEN_STATUS ),
+ NAME_VAL( RPC_LOC_IOCTL_INFORM_SERVER_CLOSE_STATUS ),
+ NAME_VAL( RPC_LOC_IOCTL_SEND_WIPER_POSITION_REPORT ),
+ NAME_VAL( RPC_LOC_IOCTL_NOTIFY_WIPER_STATUS ),
+ NAME_VAL( RPC_LOC_IOCTL_SET_ENGINE_LOCK ),
+ NAME_VAL( RPC_LOC_IOCTL_GET_ENGINE_LOCK ),
+ NAME_VAL( RPC_LOC_IOCTL_SET_SBAS_CONFIG ),
+ NAME_VAL( RPC_LOC_IOCTL_GET_SBAS_CONFIG ),
+ NAME_VAL( RPC_LOC_IOCTL_SET_NMEA_TYPES ),
+ NAME_VAL( RPC_LOC_IOCTL_GET_NMEA_TYPES ),
+ NAME_VAL( RPC_LOC_IOCTL_SET_CDMA_PDE_SERVER_ADDR ),
+ NAME_VAL( RPC_LOC_IOCTL_GET_CDMA_PDE_SERVER_ADDR ),
+ NAME_VAL( RPC_LOC_IOCTL_SET_CDMA_MPC_SERVER_ADDR ),
+ NAME_VAL( RPC_LOC_IOCTL_GET_CDMA_MPC_SERVER_ADDR ),
+ NAME_VAL( RPC_LOC_IOCTL_SET_UMTS_SLP_SERVER_ADDR ),
+ NAME_VAL( RPC_LOC_IOCTL_GET_UMTS_SLP_SERVER_ADDR ),
+ NAME_VAL( RPC_LOC_IOCTL_SET_ON_DEMAND_LPM ),
+ NAME_VAL( RPC_LOC_IOCTL_GET_ON_DEMAND_LPM ),
+ NAME_VAL( RPC_LOC_IOCTL_SET_XTRA_T_SESSION_CONTROL ),
+ NAME_VAL( RPC_LOC_IOCTL_GET_XTRA_T_SESSION_CONTROL ),
+ NAME_VAL( RPC_LOC_IOCTL_SET_LBS_APN_PROFILE ),
+ NAME_VAL( RPC_LOC_IOCTL_GET_LBS_APN_PROFILE ),
+ NAME_VAL( RPC_LOC_IOCTL_SET_XTRA_APN_PROFILE ),
+ NAME_VAL( RPC_LOC_IOCTL_GET_XTRA_APN_PROFILE ),
+ NAME_VAL( RPC_LOC_IOCTL_SET_DATA_ENABLE ),
+ NAME_VAL( RPC_LOC_IOCTL_SET_SUPL_VERSION ),
+ NAME_VAL( RPC_LOC_IOCTL_GET_SUPL_VERSION ),
+ NAME_VAL( RPC_LOC_IOCTL_DELETE_ASSIST_DATA ),
+ NAME_VAL( RPC_LOC_IOCTL_SET_CUSTOM_PDE_SERVER_ADDR ),
+ NAME_VAL( RPC_LOC_IOCTL_GET_CUSTOM_PDE_SERVER_ADDR ),
+ };
+int loc_ioctl_type_num = sizeof loc_ioctl_type_name / sizeof(loc_name_val_s_type);
+
+/* IOCTL Status names */
+loc_name_val_s_type loc_ioctl_status_name[] =
+ {
+ NAME_VAL( RPC_LOC_API_SUCCESS ),
+ NAME_VAL( RPC_LOC_API_GENERAL_FAILURE ),
+ NAME_VAL( RPC_LOC_API_UNSUPPORTED ),
+ NAME_VAL( RPC_LOC_API_INVALID_HANDLE ),
+ NAME_VAL( RPC_LOC_API_INVALID_PARAMETER ),
+ NAME_VAL( RPC_LOC_API_ENGINE_BUSY ),
+ NAME_VAL( RPC_LOC_API_PHONE_OFFLINE ),
+ NAME_VAL( RPC_LOC_API_TIMEOUT ),
+ NAME_VAL( RPC_LOC_API_RPC_FAILURE ),
+ NAME_VAL( RPC_LOC_API_RPC_MODEM_RESTART )
+ };
+int loc_ioctl_status_num = sizeof loc_ioctl_status_name / sizeof(loc_name_val_s_type);
+
+/* Fix session status names */
+loc_name_val_s_type loc_sess_status_name[] =
+ {
+ NAME_VAL( RPC_LOC_SESS_STATUS_SUCCESS ),
+ NAME_VAL( RPC_LOC_SESS_STATUS_IN_PROGESS ),
+ NAME_VAL( RPC_LOC_SESS_STATUS_GENERAL_FAILURE ),
+ NAME_VAL( RPC_LOC_SESS_STATUS_TIMEOUT ),
+ NAME_VAL( RPC_LOC_SESS_STATUS_USER_END ),
+ NAME_VAL( RPC_LOC_SESS_STATUS_BAD_PARAMETER ),
+ NAME_VAL( RPC_LOC_SESS_STATUS_PHONE_OFFLINE ),
+ NAME_VAL( RPC_LOC_SESS_STATUS_USER_END ),
+ NAME_VAL( RPC_LOC_SESS_STATUS_ENGINE_LOCKED )
+ };
+int loc_sess_status_num = sizeof loc_sess_status_name / sizeof(loc_name_val_s_type);
+
+/* Engine state names */
+loc_name_val_s_type loc_engine_state_name[] =
+ {
+ NAME_VAL( RPC_LOC_ENGINE_STATE_ON ),
+ NAME_VAL( RPC_LOC_ENGINE_STATE_OFF )
+ };
+int loc_engine_state_num = sizeof loc_engine_state_name / sizeof(loc_name_val_s_type);
+
+/* Fix session state names */
+loc_name_val_s_type loc_fix_session_state_name[] =
+ {
+ NAME_VAL( RPC_LOC_FIX_SESSION_STATE_BEGIN ),
+ NAME_VAL( RPC_LOC_FIX_SESSION_STATE_END )
+ };
+int loc_fix_session_state_num = sizeof loc_fix_session_state_name / sizeof(loc_name_val_s_type);
+
+
+static const char* log_final_interm_string(int is_final)
+{
+ return is_final ? "final" : "intermediate";
+}
+
+/* Logs parsed report */
+static void log_parsed_report(const rpc_loc_parsed_position_s_type *parsed_report)
+{
+ rpc_loc_session_status_e_type status = parsed_report->session_status;
+ LOC_LOGD("Session status: %s Valid mask: 0x%X\n",
+ loc_get_sess_status_name(status),
+ (uint) parsed_report->valid_mask);
+ LOC_LOGD("Latitude: %.7f (%s)\n", parsed_report->latitude,
+ log_final_interm_string(
+ (parsed_report->valid_mask & RPC_LOC_POS_VALID_LATITUDE) &&
+ parsed_report->session_status == RPC_LOC_SESS_STATUS_SUCCESS));
+ LOC_LOGD("Longitude: %.7f\n", parsed_report->longitude);
+ LOC_LOGD("Accuracy: %.7f\n", parsed_report->hor_unc_circular);
+}
+
+/* Logs status report */
+static void log_status_report(const rpc_loc_status_event_s_type *status_event)
+{
+ rpc_loc_status_event_e_type event = status_event->event;
+ switch (event) {
+ case RPC_LOC_STATUS_EVENT_ENGINE_STATE:
+ LOC_LOGD("Engine state: %s\n",
+ loc_get_engine_state_name(
+ status_event->payload.rpc_loc_status_event_payload_u_type_u.engine_state));
+ break;
+ case RPC_LOC_STATUS_EVENT_FIX_SESSION_STATE:
+ LOC_LOGD("Fix session state: %s\n",
+ loc_get_fix_session_state_name(
+ status_event->payload.rpc_loc_status_event_payload_u_type_u.fix_session_state));
+ break;
+ default:
+ break;
+ }
+}
+
+/* Logs valid fields in the GNSS SV constellation report */
+static void log_satellite_report(const rpc_loc_gnss_info_s_type *gnss)
+{
+ if (gnss->valid_mask & RPC_LOC_GNSS_INFO_VALID_POS_DOP)
+ {
+ LOC_LOGV("position dop: %.3f\n", (float) gnss->position_dop);
+ }
+ if (gnss->valid_mask & RPC_LOC_GNSS_INFO_VALID_HOR_DOP)
+ {
+ LOC_LOGV("horizontal dop: %.3f\n", (float) gnss->horizontal_dop);
+ }
+ if (gnss->valid_mask & RPC_LOC_GNSS_INFO_VALID_VERT_DOP)
+ {
+ LOC_LOGV("vertical dop: %.3f\n", (float) gnss->vertical_dop);
+ }
+ if (gnss->valid_mask & RPC_LOC_GNSS_INFO_VALID_ALTITUDE_ASSUMED)
+ {
+ LOC_LOGV("altitude assumed: %d\n", (int) gnss->altitude_assumed);
+ }
+ if (gnss->valid_mask & RPC_LOC_GNSS_INFO_VALID_SV_COUNT)
+ {
+ LOC_LOGD("sv count: %d\n", (int) gnss->sv_count);
+ }
+ if (gnss->valid_mask & RPC_LOC_GNSS_INFO_VALID_SV_LIST)
+ {
+ LOC_LOGV("sv list: ");
+
+ if (gnss->sv_count)
+ {
+ LOC_LOGV("\n\tsys\tprn\thlth\tproc\teph\talm\telev\tazi\tsnr\n");
+ }
+ else {
+ LOC_LOGV("empty\n");
+ }
+
+ int i;
+ for (i = 0; i < gnss->sv_count; i++)
+ {
+ const rpc_loc_sv_info_s_type *sv = &gnss->sv_list.sv_list_val[i];
+ rpc_loc_sv_info_valid_mask_type mask = sv->valid_mask;
+ LOC_LOGV(" %d: \t%d\t%d\t%d\t%d\t%d\t%d\t%.3f\t%.3f\t%.3f\n", i,
+ CHECK_MASK(int, sv->system, mask, RPC_LOC_SV_INFO_VALID_SYSTEM),
+ CHECK_MASK(int, sv->prn, mask, RPC_LOC_SV_INFO_VALID_PRN),
+ CHECK_MASK(int, sv->health_status, mask, RPC_LOC_SV_INFO_VALID_HEALTH_STATUS),
+ CHECK_MASK(int, sv->process_status, mask, RPC_LOC_SV_INFO_VALID_PROCESS_STATUS),
+ CHECK_MASK(int, sv->has_eph, mask, RPC_LOC_SV_INFO_VALID_HAS_EPH),
+ CHECK_MASK(int, sv->has_alm, mask, RPC_LOC_SV_INFO_VALID_HAS_ALM),
+ CHECK_MASK(float, sv->elevation, mask, RPC_LOC_SV_INFO_VALID_ELEVATION),
+ CHECK_MASK(float, sv->azimuth, mask, RPC_LOC_SV_INFO_VALID_AZIMUTH),
+ CHECK_MASK(float, sv->snr, mask, RPC_LOC_SV_INFO_VALID_SNR)
+ );
+ }
+ }
+}
+
+/* Logs a callback event */
+int loc_callback_log(
+ rpc_loc_event_mask_type loc_event, /* event mask */
+ const rpc_loc_event_payload_u_type* loc_event_payload /* payload */
+)
+{
+ switch (loc_event)
+ {
+ case RPC_LOC_EVENT_SATELLITE_REPORT:
+ log_satellite_report(&loc_event_payload->
+ rpc_loc_event_payload_u_type_u.gnss_report);
+ break;
+ case RPC_LOC_EVENT_STATUS_REPORT:
+ log_status_report(&loc_event_payload->
+ rpc_loc_event_payload_u_type_u.status_report);
+ break;
+ case RPC_LOC_EVENT_PARSED_POSITION_REPORT:
+ log_parsed_report(&loc_event_payload->
+ rpc_loc_event_payload_u_type_u.parsed_location_report);
+ break;
+ default:
+ break;
+ }
+
+ return 0;
+}
+
+/* Finds the first event found in the mask */
+const char* loc_get_event_name(rpc_loc_event_mask_type loc_event_mask)
+{
+ return loc_get_name_from_mask(loc_event_name, loc_event_num,
+ (long) loc_event_mask);
+}
+
+/* Finds IOCTL type name */
+const char* loc_get_ioctl_type_name(rpc_loc_ioctl_e_type ioctl_type)
+{
+ return loc_get_name_from_val(loc_ioctl_type_name, loc_ioctl_type_num,
+ (long) ioctl_type);
+}
+
+/* Finds IOCTL status name */
+const char* loc_get_ioctl_status_name(uint32 status)
+{
+ return loc_get_name_from_val(loc_ioctl_status_name, loc_ioctl_status_num,
+ (long) status);
+}
+
+/* Finds session status name */
+const char* loc_get_sess_status_name(rpc_loc_session_status_e_type status)
+{
+ return loc_get_name_from_val(loc_sess_status_name, loc_sess_status_num,
+ (long) status);
+}
+
+/* Find engine state name */
+const char* loc_get_engine_state_name(rpc_loc_engine_state_e_type state)
+{
+ return loc_get_name_from_val(loc_engine_state_name, loc_engine_state_num,
+ (long) state);
+}
+
+/* Find engine state name */
+const char* loc_get_fix_session_state_name(rpc_loc_fix_session_state_e_type state)
+{
+ return loc_get_name_from_val(loc_fix_session_state_name, loc_fix_session_state_num,
+ (long) state);
+}
+
+/* Event names */
+loc_name_val_s_type rpc_reset_event_name[] =
+{
+ NAME_VAL( RPC_SUBSYSTEM_RESTART_BEGIN ),
+ NAME_VAL( RPC_SUBSYSTEM_RESTART_END )
+};
+int rpc_reset_event_num = sizeof rpc_reset_event_name / sizeof(loc_name_val_s_type);
+
+const char* loc_get_rpc_reset_event_name(enum rpc_reset_event event)
+{
+ return loc_get_name_from_val(rpc_reset_event_name, rpc_reset_event_num, event);
+}
diff --git a/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/loc_api_rpc_glue.c b/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/loc_api_rpc_glue.c
new file mode 100644
index 0000000..e0f400c
--- /dev/null
+++ b/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/loc_api_rpc_glue.c
@@ -0,0 +1,636 @@
+/* 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
+ * 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 FILES FOR MODULE
+
+======================================================================*/
+#include <stdio.h>
+#include <pthread.h>
+#include <errno.h>
+#include <string.h>
+#include <sys/select.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <sys/mman.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <loc_api_log.h>
+
+#include <rpc/rpc.h>
+
+/* Include RPC headers */
+#include "rpc_inc/loc_api_rpc_glue.h"
+
+/* Callback init */
+#include "rpc_inc/loc_apicb_appinit.h"
+
+/* Logging */
+#define LOG_TAG "LocSvc_api_rpc_glue"
+#define LOG_NDDEBUG 0
+#ifndef USE_GLIB
+#include <utils/Log.h>
+#endif /* USE_GLIB */
+
+/* Logging Improvement */
+#include "log_util.h"
+#include "platform_lib_includes.h"
+/*Maximum number of Modem init*/
+#define RPC_TRY_NUM 10
+
+/*Maximum number of Modem init*/
+#define RPC_TRY_NUM 10
+
+/* Uncomment to force ALOGD messages */
+// #define ALOGD ALOGI
+
+/*=====================================================================
+ External declarations
+======================================================================*/
+
+CLIENT* loc_api_clnt = NULL;
+
+/* Callback ID and pointer */
+#define LOC_API_CB_MAX_CLIENTS 16
+typedef struct
+{
+ uint32 cb_id; /* same as rpc/types.h */
+ loc_event_cb_f_type *cb_func; /* callback func */
+ loc_reset_notif_cb_f_type *rpc_cb; /* callback from RPC */
+ rpc_loc_client_handle_type handle; /* stores handle for client closing */
+ void* user; /* user's own data handle */
+} loc_glue_cb_entry_s_type;
+
+loc_glue_cb_entry_s_type loc_glue_callback_table[LOC_API_CB_MAX_CLIENTS];
+
+#define RPC_FUNC_VERSION_BASE(a,b) a ## b
+#define RPC_FUNC_VERSION(a,b) RPC_FUNC_VERSION_BASE(a,b)
+
+#define RPC_CALLBACK_FUNC_VERSION_BASE(a,v,b) a ## v ## b
+#define RPC_CALLBACK_FUNC_VERSION(a,v,b) RPC_CALLBACK_FUNC_VERSION_BASE(a,v,b)
+
+#define LOC_GLUE_CHECK_INIT(ret_type) \
+ if (loc_api_clnt == NULL) { EXIT_LOG_CALLFLOW(%d, RPC_LOC_API_RPC_FAILURE); return (ret_type) RPC_LOC_API_RPC_FAILURE; }
+
+#define LOC_GLUE_CHECK_RESULT(stat, ret_type) \
+ if (stat != RPC_SUCCESS) { \
+ LOC_LOGE("%s:%d] failure code %d", __func__, __LINE__, stat); \
+ return (ret_type)((stat == RPC_SUBSYSTEM_RESTART) ? \
+ RPC_LOC_API_RPC_MODEM_RESTART : RPC_LOC_API_RPC_FAILURE); \
+ }
+
+/* Callback functions */
+/* Returns 1 if successful */
+bool_t rpc_loc_event_cb_f_type_svc(
+ rpc_loc_event_cb_f_type_args *argp,
+ rpc_loc_event_cb_f_type_rets *ret,
+ struct svc_req *req)
+{
+ // The lower word of cd_id is the index
+ int index = argp->cb_id & 0xFFFF;
+
+ /* Callback not registered, or unexpected ID (shouldn't happen) */
+ if (index >= LOC_API_CB_MAX_CLIENTS || loc_glue_callback_table[index].cb_func == NULL)
+ {
+ LOC_LOGE("Warning: No callback handler %d.\n", index);
+ ret->loc_event_cb_f_type_result = 0;
+ return 1; /* simply return */
+ }
+
+ LOC_LOGV("proc: %x prog: %x vers: %x\n",
+ (int) req->rq_proc,
+ (int) req->rq_prog,
+ (int) req->rq_vers);
+
+ LOC_LOGV("Callback received: %x (cb_id=%p handle=%d ret_ptr=%d)\n",
+ (int) argp->loc_event,
+ argp->cb_id,
+ (int) argp->loc_handle,
+ (int) ret);
+
+ /* Forward callback to real callback procedure */
+ rpc_loc_client_handle_type loc_handle = argp->loc_handle;
+ rpc_loc_event_mask_type loc_event = argp->loc_event;
+ const rpc_loc_event_payload_u_type* loc_event_payload =
+ (const rpc_loc_event_payload_u_type*) argp->loc_event_payload;
+
+ /* Gives control to synchronous call handler */
+ loc_api_callback_process_sync_call(loc_handle, loc_event, loc_event_payload);
+
+ int32 rc = (loc_glue_callback_table[index].cb_func)(loc_glue_callback_table[index].user,
+ loc_handle, loc_event, loc_event_payload);
+
+ LOC_LOGV("cb_func=%p", loc_glue_callback_table[index].cb_func);
+
+ ret->loc_event_cb_f_type_result = rc;
+
+ return 1; /* ok */
+}
+
+int loc_apicbprog_freeresult (SVCXPRT *transp, xdrproc_t xdr_result, caddr_t result)
+{
+ xdr_free (xdr_result, result);
+
+ /*
+ * Insert additional freeing code here, if needed
+ */
+ // LOC_LOGD("***** loc_apicbprog_freeresult\n");
+
+ return 1;
+}
+
+/*===========================================================================
+
+FUNCTION rpc_loc_event_cb_f_type_<version>_svc (MACRO)
+
+DESCRIPTION
+ Callback function for Loc API
+
+RETURN VALUE
+ 1 for success
+ 0 for failure
+
+===========================================================================*/
+bool_t RPC_CALLBACK_FUNC_VERSION(rpc_loc_event_cb_f_type_, RPC_LOC_EVENT_CB_F_TYPE_VERSION, _svc) (
+ rpc_loc_event_cb_f_type_args *argp,
+ rpc_loc_event_cb_f_type_rets *ret,
+ struct svc_req *req)
+{
+ return rpc_loc_event_cb_f_type_svc(argp, ret, req);
+}
+
+/*===========================================================================
+
+FUNCTION loc_apicbprog_<version>_freeresult (MACRO)
+
+DESCRIPTION
+ Free up RPC data structure
+
+RETURN VALUE
+ 1 for success
+ 0 for failure
+
+===========================================================================*/
+#define VERSION_CONCAT(MAJOR,MINOR) MAJOR##MINOR
+#define loc_apicb_prog_VER_freeresult(M,N) \
+int RPC_CALLBACK_FUNC_VERSION(loc_apicbprog_, VERSION_CONCAT(M,N), _freeresult) \
+(SVCXPRT *transp, xdrproc_t xdr_result, caddr_t result) \
+{ \
+ return loc_apicbprog_freeresult(transp, xdr_result, result); \
+}
+
+/* Define all of the possible minors */
+loc_apicb_prog_VER_freeresult(RPC_LOC_API_API_MAJOR_NUM, 0001);
+loc_apicb_prog_VER_freeresult(RPC_LOC_API_API_MAJOR_NUM, 0002);
+loc_apicb_prog_VER_freeresult(RPC_LOC_API_API_MAJOR_NUM, 0003);
+loc_apicb_prog_VER_freeresult(RPC_LOC_API_API_MAJOR_NUM, 0004);
+loc_apicb_prog_VER_freeresult(RPC_LOC_API_API_MAJOR_NUM, 0005);
+loc_apicb_prog_VER_freeresult(RPC_LOC_API_API_MAJOR_NUM, 0006);
+
+/*===========================================================================
+
+FUNCTION rpc_loc_api_cb_null_<version>_svc (MACRO) [Patch for wrong RPCGEN stubs]
+
+DESCRIPTION
+ Null callback function for Loc API
+
+RETURN VALUE
+ 1 for success
+
+===========================================================================*/
+#define rpc_loc_api_cb_null_VER_svc(M,N) \
+bool_t RPC_CALLBACK_FUNC_VERSION(rpc_loc_api_cb_null_, VERSION_CONCAT(M,N), _svc) ( \
+ void *a, int *b, struct svc_req *req) \
+{ \
+ return 1; \
+}
+
+/* Define all of the possible minors */
+rpc_loc_api_cb_null_VER_svc(RPC_LOC_API_API_MAJOR_NUM, 0001);
+rpc_loc_api_cb_null_VER_svc(RPC_LOC_API_API_MAJOR_NUM, 0002);
+rpc_loc_api_cb_null_VER_svc(RPC_LOC_API_API_MAJOR_NUM, 0003);
+rpc_loc_api_cb_null_VER_svc(RPC_LOC_API_API_MAJOR_NUM, 0004);
+rpc_loc_api_cb_null_VER_svc(RPC_LOC_API_API_MAJOR_NUM, 0005);
+rpc_loc_api_cb_null_VER_svc(RPC_LOC_API_API_MAJOR_NUM, 0006);
+
+static void loc_api_glue_rpc_cb(CLIENT* client, enum rpc_reset_event event)
+{
+ int i;
+ for (i = 0; i < LOC_API_CB_MAX_CLIENTS; i++) {
+ if (NULL != loc_glue_callback_table[i].rpc_cb) {
+ loc_glue_callback_table[i].rpc_cb(loc_glue_callback_table[i].user, client, event);
+ }
+ }
+}
+
+/*===========================================================================
+
+FUNCTION loc_api_glue_init
+
+DESCRIPTION
+ Initiates the RPC client
+
+RETURN VALUE
+ 1 for success
+ 0 for failure
+
+===========================================================================*/
+int loc_api_glue_init(void)
+{
+ if (loc_api_clnt == NULL)
+ {
+ /* Initialize data */
+ int i;
+ int pid = getpid();
+ for (i = 0; i < LOC_API_CB_MAX_CLIENTS; i++)
+ {
+ loc_glue_callback_table[i].cb_id = i | (pid << 16);
+ loc_glue_callback_table[i].cb_func = NULL;
+ loc_glue_callback_table[i].handle = -1;
+ loc_glue_callback_table[i].rpc_cb = NULL;
+ loc_glue_callback_table[i].user = NULL;
+ }
+
+ /* Print msg */
+ LOC_LOGV("Trying to create RPC client...\n");
+ loc_api_clnt = clnt_create(NULL, LOC_APIPROG, LOC_APIVERS, NULL);
+ LOC_LOGV("Created loc_api_clnt ---- %x\n", (unsigned int)loc_api_clnt);
+
+ if (loc_api_clnt == NULL)
+ {
+ LOC_LOGE("Error: cannot create RPC client.\n");
+ return 0;
+ }
+
+ /* Init RPC callbacks */
+ loc_api_sync_call_init();
+
+ int rc = loc_apicb_app_init();
+ if (rc >= 0)
+ {
+ LOC_LOGD("Loc API RPC client initialized.\n");
+ clnt_register_reset_notification_cb(loc_api_clnt, loc_api_glue_rpc_cb);
+ }
+ else {
+ LOC_LOGE("Loc API callback initialization failed.\n");
+ return 0;
+ }
+ }
+
+ return 1;
+}
+
+rpc_loc_client_handle_type loc_open (
+ rpc_loc_event_mask_type event_reg_mask,
+ loc_event_cb_f_type *event_callback,
+ loc_reset_notif_cb_f_type *rpc_cb,
+ void* userData
+)
+{
+ int try_num = RPC_TRY_NUM;
+ ENTRY_LOG();
+ LOC_GLUE_CHECK_INIT(rpc_loc_client_handle_type);
+
+ rpc_loc_client_handle_type ret_val;
+
+ rpc_loc_open_args args;
+ args.event_reg_mask = event_reg_mask;
+
+ int i, j = LOC_API_CB_MAX_CLIENTS;
+ for (i = 0; i < LOC_API_CB_MAX_CLIENTS; i++)
+ {
+ if (loc_glue_callback_table[i].user == userData)
+ {
+ LOC_LOGW("Client already opened service (callback=%p)...\n",
+ event_callback);
+ break;
+ } else if (j == LOC_API_CB_MAX_CLIENTS &&
+ loc_glue_callback_table[i].user == NULL) {
+ j = i;
+ }
+ }
+
+ if (i == LOC_API_CB_MAX_CLIENTS)
+ {
+ i = j;
+ }
+
+ if (i == LOC_API_CB_MAX_CLIENTS)
+ {
+ LOC_LOGE("Too many clients opened at once...\n");
+ return RPC_LOC_CLIENT_HANDLE_INVALID;
+ }
+
+ loc_glue_callback_table[i].cb_func = event_callback;
+ loc_glue_callback_table[i].rpc_cb = rpc_cb;
+ loc_glue_callback_table[i].user = userData;
+
+ args.event_callback = loc_glue_callback_table[i].cb_id;
+ LOC_LOGV("cb_id=%d, func=0x%x", i, (unsigned int) event_callback);
+
+ rpc_loc_open_rets rets;
+ enum clnt_stat stat = RPC_SUCCESS;
+
+ EXIT_LOG_CALLFLOW(%s, "loc client open");
+
+ /*try more for rpc_loc_open_xx()*/
+
+ do
+ {
+ stat = RPC_FUNC_VERSION(rpc_loc_open_, RPC_LOC_OPEN_VERSION)(&args, &rets, loc_api_clnt);
+ ret_val = (rpc_loc_client_handle_type) rets.loc_open_result;
+ try_num--;
+
+ }while( (RPC_SUCCESS != stat||0 > ret_val) && 0 != try_num );
+
+ LOC_GLUE_CHECK_RESULT(stat, int32);
+
+ /* save the handle in the table */
+ loc_glue_callback_table[i].handle = (rpc_loc_client_handle_type) rets.loc_open_result;
+
+ return ret_val;
+
+}
+
+int32 loc_close
+(
+ rpc_loc_client_handle_type handle
+)
+{
+ ENTRY_LOG();
+ LOC_GLUE_CHECK_INIT(int32);
+
+ int32 ret_val;
+
+ rpc_loc_close_args args;
+ args.handle = handle;
+
+ rpc_loc_close_rets rets;
+ enum clnt_stat stat = RPC_SUCCESS;
+
+ EXIT_LOG_CALLFLOW(%s, "loc client close");
+ stat = RPC_FUNC_VERSION(rpc_loc_close_, RPC_LOC_CLOSE_VERSION)(&args, &rets, loc_api_clnt);
+
+ loc_clear(handle);
+
+ LOC_GLUE_CHECK_RESULT(stat, int32);
+ ret_val = (int32) rets.loc_close_result;
+
+ return ret_val;
+}
+
+void loc_clear(rpc_loc_client_handle_type handle) {
+ /* Clean the client's callback function in callback table */
+ int i;
+ for (i = 0; i < LOC_API_CB_MAX_CLIENTS; i++)
+ {
+ if (loc_glue_callback_table[i].handle == handle)
+ {
+ /* Found the client */
+ loc_glue_callback_table[i].cb_func = NULL;
+ loc_glue_callback_table[i].rpc_cb = NULL;
+ loc_glue_callback_table[i].handle = -1;
+ loc_glue_callback_table[i].user = NULL;
+ break;
+ }
+ }
+
+ if (i == LOC_API_CB_MAX_CLIENTS)
+ {
+ LOC_LOGW("Handle not found (handle=%d)...\n", (int) handle);
+ }
+}
+
+int32 loc_start_fix
+(
+ rpc_loc_client_handle_type handle
+)
+{
+ ENTRY_LOG();
+ LOC_GLUE_CHECK_INIT(int32);
+
+ int32 ret_val;
+
+ rpc_loc_start_fix_args args;
+ args.handle = handle;
+
+ rpc_loc_start_fix_rets rets;
+ enum clnt_stat stat = RPC_SUCCESS;
+
+ EXIT_LOG_CALLFLOW(%s, "loc start fix");
+ stat = RPC_FUNC_VERSION(rpc_loc_start_fix_, RPC_LOC_START_FIX_VERSION)(&args, &rets, loc_api_clnt);
+ LOC_GLUE_CHECK_RESULT(stat, int32);
+
+ ret_val = (int32) rets.loc_start_fix_result;
+
+ return ret_val;
+}
+
+int32 loc_stop_fix
+(
+ rpc_loc_client_handle_type handle
+)
+{
+ ENTRY_LOG();
+ LOC_GLUE_CHECK_INIT(int32);
+
+ int32 ret_val;
+
+ rpc_loc_stop_fix_args args;
+ args.handle = handle;
+
+ rpc_loc_stop_fix_rets rets;
+ enum clnt_stat stat = RPC_SUCCESS;
+
+ EXIT_LOG_CALLFLOW(%s, "loc stop fix");
+ stat = RPC_FUNC_VERSION(rpc_loc_stop_fix_, RPC_LOC_STOP_FIX_VERSION)(&args, &rets, loc_api_clnt);
+ LOC_GLUE_CHECK_RESULT(stat, int32);
+
+ ret_val = (int32) rets.loc_stop_fix_result;
+
+ return ret_val;
+}
+
+int32 loc_ioctl
+(
+ rpc_loc_client_handle_type handle,
+ rpc_loc_ioctl_e_type ioctl_type,
+ rpc_loc_ioctl_data_u_type* ioctl_data
+)
+{
+ ENTRY_LOG();
+ LOC_GLUE_CHECK_INIT(int32);
+
+ int32 ret_val;
+
+ rpc_loc_ioctl_args args;
+ args.handle = handle;
+ args.ioctl_data = ioctl_data;
+ args.ioctl_type = ioctl_type;
+ if (ioctl_data != NULL)
+ {
+ /* Assign ioctl union discriminator */
+ ioctl_data->disc = ioctl_type;
+
+ /* In case the user hasn't filled in other disc fields,
+ automatically fill them in here */
+ switch (ioctl_type)
+ {
+ case RPC_LOC_IOCTL_GET_API_VERSION:
+ break;
+ case RPC_LOC_IOCTL_SET_FIX_CRITERIA:
+ break;
+ case RPC_LOC_IOCTL_GET_FIX_CRITERIA:
+ break;
+ case RPC_LOC_IOCTL_INFORM_NI_USER_RESPONSE:
+ break;
+ case RPC_LOC_IOCTL_INJECT_PREDICTED_ORBITS_DATA:
+ break;
+ case RPC_LOC_IOCTL_QUERY_PREDICTED_ORBITS_DATA_VALIDITY:
+ break;
+ case RPC_LOC_IOCTL_QUERY_PREDICTED_ORBITS_DATA_SOURCE:
+ break;
+ case RPC_LOC_IOCTL_SET_PREDICTED_ORBITS_DATA_AUTO_DOWNLOAD:
+ break;
+ case RPC_LOC_IOCTL_INJECT_UTC_TIME:
+ break;
+ case RPC_LOC_IOCTL_INJECT_RTC_VALUE:
+ break;
+ case RPC_LOC_IOCTL_INJECT_POSITION:
+ break;
+ case RPC_LOC_IOCTL_QUERY_ENGINE_STATE:
+ break;
+ case RPC_LOC_IOCTL_INFORM_SERVER_OPEN_STATUS:
+ break;
+ case RPC_LOC_IOCTL_INFORM_SERVER_CLOSE_STATUS:
+ break;
+ case RPC_LOC_IOCTL_SET_ENGINE_LOCK:
+ break;
+ case RPC_LOC_IOCTL_GET_ENGINE_LOCK:
+ break;
+ case RPC_LOC_IOCTL_SET_SBAS_CONFIG:
+ break;
+ case RPC_LOC_IOCTL_GET_SBAS_CONFIG:
+ break;
+ case RPC_LOC_IOCTL_SET_NMEA_TYPES:
+ break;
+ case RPC_LOC_IOCTL_GET_NMEA_TYPES:
+ break;
+ case RPC_LOC_IOCTL_SET_CDMA_PDE_SERVER_ADDR:
+ case RPC_LOC_IOCTL_SET_CDMA_MPC_SERVER_ADDR:
+ case RPC_LOC_IOCTL_SET_UMTS_SLP_SERVER_ADDR:
+ case RPC_LOC_IOCTL_SET_CUSTOM_PDE_SERVER_ADDR:
+ args.ioctl_data->rpc_loc_ioctl_data_u_type_u.server_addr.addr_info.disc =
+ args.ioctl_data->rpc_loc_ioctl_data_u_type_u.server_addr.addr_type;
+ break;
+ case RPC_LOC_IOCTL_GET_CDMA_PDE_SERVER_ADDR:
+ case RPC_LOC_IOCTL_GET_CDMA_MPC_SERVER_ADDR:
+ case RPC_LOC_IOCTL_GET_UMTS_SLP_SERVER_ADDR:
+ case RPC_LOC_IOCTL_GET_CUSTOM_PDE_SERVER_ADDR:
+ break;
+ case RPC_LOC_IOCTL_SET_ON_DEMAND_LPM:
+ break;
+ case RPC_LOC_IOCTL_GET_ON_DEMAND_LPM:
+ break;
+ case RPC_LOC_IOCTL_DELETE_ASSIST_DATA:
+ break;
+ default:
+ break;
+ } /* switch */
+ } /* ioctl_data != NULL */
+
+ rpc_loc_ioctl_rets rets;
+ enum clnt_stat stat = RPC_SUCCESS;
+
+ EXIT_LOG_CALLFLOW(%s, loc_get_ioctl_type_name(ioctl_type));
+ stat = RPC_FUNC_VERSION(rpc_loc_ioctl_, RPC_LOC_IOCTL_VERSION)(&args, &rets, loc_api_clnt);
+ LOC_GLUE_CHECK_RESULT(stat, int32);
+
+ ret_val = (int32) rets.loc_ioctl_result;
+
+ return ret_val;
+}
+
+/* Returns 0 if error */
+int32 loc_api_null(void)
+{
+ LOC_GLUE_CHECK_INIT(int32);
+
+ int32 rets;
+ enum clnt_stat stat = RPC_SUCCESS;
+
+ clnt_unregister_reset_notification_cb(loc_api_clnt);
+ stat = RPC_FUNC_VERSION(rpc_loc_api_null_, RPC_LOC_API_NULL_VERSION)(NULL, &rets, loc_api_clnt);
+ LOC_GLUE_CHECK_RESULT(stat, int32);
+
+ return (int32) rets;
+}
+
+/*===========================================================================
+
+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
+
+===========================================================================*/
+int 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
+)
+{
+ int ret_val = RPC_LOC_API_SUCCESS;
+
+ ret_val = loc_api_sync_ioctl(handle, ioctl_type, ioctl_data_ptr, timeout_msec, cb_data_ptr);
+
+ LOC_LOGD("loc_eng_ioctl result: client = %d, ioctl_type = %s, returt %s\n",
+ (int32) handle,
+ loc_get_ioctl_type_name(ioctl_type),
+ loc_get_ioctl_status_name(ret_val) );
+
+ return ret_val;
+}
diff --git a/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/loc_api_sync_call.c b/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/loc_api_sync_call.c
new file mode 100644
index 0000000..ae629d7
--- /dev/null
+++ b/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/loc_api_sync_call.c
@@ -0,0 +1,565 @@
+/* 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
+ * 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 <assert.h>
+#include <errno.h>
+#include <sys/time.h>
+#include <string.h>
+#include <pthread.h>
+
+#include <rpc/rpc.h>
+#include <loc_api_rpc_glue.h>
+#include "loc_api_sync_call.h"
+
+/* Logging */
+#define LOG_TAG "LocSvc_api_rpc_glue"
+// #define LOG_NDDEBUG 0
+#ifndef USE_GLIB
+#include <utils/Log.h>
+#endif /* USE_GLIB */
+
+/***************************************************************************
+ * DATA FOR ASYNCHRONOUS RPC PROCESSING
+ **************************************************************************/
+loc_sync_call_slot_array_s_type loc_sync_data;
+
+pthread_mutex_t loc_sync_call_mutex = PTHREAD_MUTEX_INITIALIZER;
+boolean loc_sync_call_inited = 0;
+
+/*===========================================================================
+
+FUNCTION loc_api_sync_call_init
+
+DESCRIPTION
+ Initialize this module
+
+DEPENDENCIES
+ N/A
+
+RETURN VALUE
+ none
+
+SIDE EFFECTS
+ N/A
+
+===========================================================================*/
+void loc_api_sync_call_init()
+{
+ pthread_mutex_lock(&loc_sync_call_mutex);
+ if (loc_sync_call_inited == 1) {
+ pthread_mutex_unlock(&loc_sync_call_mutex);
+ return;
+ }
+ loc_sync_call_inited = 1;
+
+ loc_sync_data.num_of_slots = LOC_SYNC_CALL_SLOTS_MAX;
+
+ int i;
+ for (i = 0; i < loc_sync_data.num_of_slots; i++)
+ {
+ loc_sync_call_slot_s_type *slot = &loc_sync_data.slots[i];
+
+ pthread_mutex_init(&slot->lock, NULL);
+ pthread_cond_init(&slot->loc_cb_arrived_cond, NULL);
+
+ slot->not_available = 0;
+ slot->in_use = 0;
+ slot->loc_handle = -1;
+ slot->loc_cb_wait_event_mask = 0; /* event to wait */
+ slot->loc_cb_received_event_mask = 0; /* received event */
+ }
+
+ pthread_mutex_unlock(&loc_sync_call_mutex);
+}
+
+/*===========================================================================
+
+FUNCTION loc_api_sync_call_destroy
+
+DESCRIPTION
+ Initialize this module
+
+DEPENDENCIES
+ N/A
+
+RETURN VALUE
+ none
+
+SIDE EFFECTS
+ N/A
+
+===========================================================================*/
+void loc_api_sync_call_destroy()
+{
+ int i;
+
+ pthread_mutex_lock(&loc_sync_call_mutex);
+ if (loc_sync_call_inited == 0) {
+ pthread_mutex_unlock(&loc_sync_call_mutex);
+ return;
+ }
+ loc_sync_call_inited = 0;
+
+ for (i = 0; i < loc_sync_data.num_of_slots; i++)
+ {
+ loc_sync_call_slot_s_type *slot = &loc_sync_data.slots[i];
+
+ pthread_mutex_lock(&slot->lock);
+
+ slot->not_available = 1;
+
+ pthread_mutex_unlock(&slot->lock);
+
+ pthread_cond_destroy(&slot->loc_cb_arrived_cond);
+ pthread_mutex_destroy(&slot->lock);
+ }
+
+ pthread_mutex_unlock(&loc_sync_call_mutex);
+}
+
+/*===========================================================================
+
+FUNCTION loc_match_callback
+
+DESCRIPTION
+ Checks if an awaited event has arrived
+
+RETURN VALUE
+ TRUE arrived
+ FALSE not matching
+
+===========================================================================*/
+static boolean loc_match_callback(
+ rpc_loc_event_mask_type wait_mask,
+ rpc_loc_ioctl_e_type wait_ioctl,
+ rpc_loc_event_mask_type event_mask,
+ const rpc_loc_event_payload_u_type *callback_payload
+)
+{
+ if ((event_mask & wait_mask) == 0) return FALSE;
+
+ if (event_mask != RPC_LOC_EVENT_IOCTL_REPORT || wait_ioctl == 0 ||
+ ( (callback_payload != NULL) &&
+ callback_payload->rpc_loc_event_payload_u_type_u.ioctl_report.type == wait_ioctl) )
+ return TRUE;
+
+ return FALSE;
+}
+
+/*===========================================================================
+
+FUNCTION loc_api_callback_process_sync_call
+
+DESCRIPTION
+ Wakes up blocked API calls to check if the needed callback has arrived
+
+DEPENDENCIES
+ N/A
+
+RETURN VALUE
+ none
+
+SIDE EFFECTS
+ N/A
+
+===========================================================================*/
+void loc_api_callback_process_sync_call(
+ rpc_loc_client_handle_type loc_handle, /* handle of the client */
+ rpc_loc_event_mask_type loc_event, /* event mask */
+ const rpc_loc_event_payload_u_type* loc_event_payload /* payload */
+)
+{
+ int i;
+
+ ALOGV("loc_handle = 0x%lx, loc_event = 0x%lx", loc_handle, loc_event);
+ for (i = 0; i < loc_sync_data.num_of_slots; i++)
+ {
+ loc_sync_call_slot_s_type *slot = &loc_sync_data.slots[i];
+
+ pthread_mutex_lock(&slot->lock);
+
+ if (slot->in_use &&
+ slot->signal_sent == 0 &&
+ slot->loc_handle == loc_handle &&
+ loc_match_callback(slot->loc_cb_wait_event_mask, slot->ioctl_type, loc_event, loc_event_payload))
+ {
+ memcpy(&slot->loc_cb_received_payload, loc_event_payload, sizeof (rpc_loc_event_payload_u_type));
+
+ slot->loc_cb_received_event_mask = loc_event;
+
+ ALOGV("signal slot %d in_use %d, loc_handle 0x%lx, event_mask 0x%1x, ioctl_type %d", i, slot->in_use, slot->loc_handle, (int) slot->loc_cb_wait_event_mask, (int) slot->ioctl_type);
+ pthread_cond_signal(&slot->loc_cb_arrived_cond);
+ slot->signal_sent = 1;
+
+ pthread_mutex_unlock(&slot->lock);
+ break;
+ } else {
+ /* do nothing */
+ }
+
+ pthread_mutex_unlock(&slot->lock);
+ }
+}
+
+/*===========================================================================
+
+FUNCTION loc_lock_a_slot
+
+DESCRIPTION
+ Allocates a buffer slot for the synchronous API call
+
+DEPENDENCIES
+ N/A
+
+RETURN VALUE
+ Select ID (>=0) : successful
+ -1 : buffer full
+
+SIDE EFFECTS
+ N/A
+
+===========================================================================*/
+static int loc_lock_a_slot()
+{
+ int i, select_id = -1; /* no free buffer */
+
+ for (i = 0; i < loc_sync_data.num_of_slots; i++)
+ {
+ loc_sync_call_slot_s_type *slot = &loc_sync_data.slots[i];
+ if (pthread_mutex_trylock(&slot->lock) == EBUSY)
+ {
+ ALOGV("trylock EBUSY : %d", i);
+ continue;
+ }
+
+ if (!slot->in_use && !slot->not_available)
+ {
+ select_id = i;
+ /* Return from here and leave the mutex locked.
+ * will unlock it in loc_unlock_slot()
+ */
+ break;
+ }
+ /* ALOGV("slot %d in_use = %d, not_available = %d : %d", i, slot->in_use, slot->not_available, i); */
+ pthread_mutex_unlock(&slot->lock);
+ }
+
+ return select_id;
+}
+
+/*===========================================================================
+
+FUNCTION loc_unlock_slot
+
+DESCRIPTION
+ Unlocks a buffer slot
+
+DEPENDENCIES
+ N/A
+
+RETURN VALUE
+ None
+
+SIDE EFFECTS
+ N/A
+
+===========================================================================*/
+static void loc_unlock_slot(int select_id)
+{
+ pthread_mutex_unlock(&loc_sync_data.slots[select_id].lock);
+}
+
+/*===========================================================================
+
+FUNCTION loc_lock_slot
+
+DESCRIPTION
+ Locks a specific slot that was previously locked from loc_lock_a_slot
+
+DEPENDENCIES
+ N/A
+
+RETURN VALUE
+ None
+
+SIDE EFFECTS
+ N/A
+
+===========================================================================*/
+static void loc_lock_slot(int select_id)
+{
+ pthread_mutex_lock(&loc_sync_data.slots[select_id].lock);
+}
+
+/*===========================================================================
+
+FUNCTION loc_set_slot_in_use
+
+DESCRIPTION
+ Sets the in_use flag of slot to true or false.
+ Should be called only after the slot is locked
+
+DEPENDENCIES
+ N/A
+
+RETURN VALUE
+ None
+
+SIDE EFFECTS
+ N/A
+
+===========================================================================*/
+static void loc_set_slot_in_use(int select_id, boolean in_use)
+{
+ loc_sync_data.slots[select_id].in_use = in_use;
+ if (in_use == 1)
+ loc_sync_data.slots[select_id].signal_sent = 0;
+}
+
+/*===========================================================================
+
+FUNCTION loc_api_save_callback
+
+DESCRIPTION
+ Selects which callback or IOCTL event to wait for.
+
+ The event_mask specifies the event(s). If it is RPC_LOC_EVENT_IOCTL_REPORT,
+ then ioctl_type specifies the IOCTL event.
+
+ If ioctl_type is non-zero, RPC_LOC_EVENT_IOCTL_REPORT is automatically added.
+
+DEPENDENCIES
+ N/A
+
+RETURN VALUE
+ Select ID (>=0) : successful
+ -1 : out of buffer
+
+SIDE EFFECTS
+ N/A
+
+===========================================================================*/
+static void loc_api_save_callback(
+ int select_id, /* Selected slot */
+ rpc_loc_client_handle_type loc_handle, /* Client handle */
+ rpc_loc_event_mask_type event_mask, /* Event mask to wait for */
+ rpc_loc_ioctl_e_type ioctl_type /* IOCTL type to wait for */
+)
+{
+ loc_sync_call_slot_s_type *slot = &loc_sync_data.slots[select_id];
+
+ slot->loc_handle = loc_handle;
+
+ slot->loc_cb_wait_event_mask = event_mask;
+ slot->ioctl_type = ioctl_type;
+ if (ioctl_type) slot->loc_cb_wait_event_mask |= RPC_LOC_EVENT_IOCTL_REPORT;
+
+ return;
+}
+
+/*===========================================================================
+
+FUNCTION loc_save_user_payload
+
+DESCRIPTION
+ Saves received payload into user data structures
+
+RETURN VALUE
+ None
+
+===========================================================================*/
+static void loc_save_user_payload(
+ rpc_loc_event_payload_u_type *user_cb_payload,
+ rpc_loc_ioctl_callback_s_type *user_ioctl_buffer,
+ const rpc_loc_event_payload_u_type *received_cb_payload
+)
+{
+ if (user_cb_payload)
+ {
+ memcpy(user_cb_payload, received_cb_payload,
+ sizeof (rpc_loc_event_payload_u_type));
+ }
+ if (user_ioctl_buffer)
+ {
+ memcpy(user_ioctl_buffer,
+ &received_cb_payload->rpc_loc_event_payload_u_type_u.ioctl_report,
+ sizeof *user_ioctl_buffer);
+ }
+}
+
+/*===========================================================================
+
+FUNCTION loc_api_wait_callback
+
+DESCRIPTION
+ Waits for a selected callback. The wait expires in timeout_seconds seconds.
+
+ If the function is called before an existing wait has finished, it will
+ immediately return EBUSY.
+
+DEPENDENCIES
+ N/A
+
+RETURN VALUE
+ RPC_LOC_API_SUCCESS if successful (0)
+ RPC_LOC_API_TIMEOUT if timed out
+ RPC_LOC_API_ENGINE_BUSY if already in a wait
+ RPC_LOC_API_INVALID_PARAMETER if callback is not yet selected
+
+SIDE EFFECTS
+ N/A
+
+===========================================================================*/
+static int loc_api_wait_callback(
+ int select_id, /* ID from loc_select_callback() */
+ int timeout_seconds, /* Timeout in this number of seconds */
+ rpc_loc_event_payload_u_type *callback_payload, /* Pointer to callback payload buffer, can be NULL */
+ rpc_loc_ioctl_callback_s_type *ioctl_payload /* Pointer to IOCTL payload, can be NULL */
+)
+{
+ int ret_val = RPC_LOC_API_SUCCESS; /* the return value of this function: 0 = no error */
+ int rc = 0; /* return code from pthread calls */
+
+ struct timespec expire_time;
+
+ loc_sync_call_slot_s_type *slot = &loc_sync_data.slots[select_id];
+
+ clock_gettime(CLOCK_REALTIME, &expire_time);
+ expire_time.tv_sec += timeout_seconds;
+
+ /* Waiting */
+ while (slot->signal_sent == 0 && rc != ETIMEDOUT) {
+ rc = pthread_cond_timedwait(&slot->loc_cb_arrived_cond,
+ &slot->lock, &expire_time);
+ }
+
+ if (rc == ETIMEDOUT)
+ {
+ ret_val = RPC_LOC_API_TIMEOUT; /* Timed out */
+ ALOGE("TIMEOUT: %d", select_id);
+ }
+ else {
+ /* Obtained the first awaited callback */
+ ret_val = RPC_LOC_API_SUCCESS; /* Successful */
+ loc_save_user_payload(callback_payload, ioctl_payload, &slot->loc_cb_received_payload);
+ }
+
+ return ret_val;
+}
+
+/*===========================================================================
+
+FUNCTION loc_api_sync_ioctl
+
+DESCRIPTION
+ Synchronous IOCTL call (reentrant version)
+
+DEPENDENCIES
+ N/A
+
+RETURN VALUE
+ Loc API error code (0 = success)
+
+SIDE EFFECTS
+ N/A
+
+===========================================================================*/
+int loc_api_sync_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
+)
+{
+ int rc = -1;
+ int select_id;
+ rpc_loc_ioctl_callback_s_type callback_data;
+
+ select_id = loc_lock_a_slot();
+
+ if (select_id < 0 || select_id >= loc_sync_data.num_of_slots)
+ {
+ ALOGE("slot not available ioctl_type = %s",
+ loc_get_ioctl_type_name(ioctl_type));
+ return rc;
+ }
+
+ loc_set_slot_in_use(select_id, 1); // set slot in use to true
+
+ // Select the callback we are waiting for
+ loc_api_save_callback(select_id, handle, 0, ioctl_type);
+
+ loc_unlock_slot(select_id); // slot is unlocked, but in_use is still true
+
+ // we want to avoid keeping the slot locked during the loc_ioctl because the rpc
+ // framework will also lock a different mutex during this call, and typically
+ // locking two different mutexes at the same time can lead to deadlock.
+ rc = loc_ioctl(handle, ioctl_type, ioctl_data_ptr);
+
+ loc_lock_slot(select_id);
+
+ if (rc != RPC_LOC_API_SUCCESS)
+ {
+ ALOGE("loc_ioctl failed select_id = %d, ioctl_type %s, returned %s",
+ select_id, loc_get_ioctl_type_name(ioctl_type), loc_get_ioctl_status_name(rc));
+ }
+ else {
+ ALOGV("select_id = %d, ioctl_type %d, returned RPC_LOC_API_SUCCESS",
+ select_id, ioctl_type);
+ // Wait for the callback of loc_ioctl
+ if ((rc = loc_api_wait_callback(select_id, timeout_msec / 1000, NULL, &callback_data)) != 0)
+ {
+ // Callback waiting failed
+ ALOGE("callback wait failed select_id = %d, ioctl_type %s, returned %s",
+ select_id, loc_get_ioctl_type_name(ioctl_type), loc_get_ioctl_status_name(rc));
+ }
+ else
+ {
+ if (cb_data_ptr) memcpy(cb_data_ptr, &callback_data, sizeof *cb_data_ptr);
+ if (callback_data.status != RPC_LOC_API_SUCCESS)
+ {
+ rc = callback_data.status;
+ ALOGE("callback status failed select_id = %d, ioctl_type %s, returned %s",
+ select_id, loc_get_ioctl_type_name(ioctl_type), loc_get_ioctl_status_name(rc));
+ } else {
+ ALOGV("callback status success select_id = %d, ioctl_type %d, returned %d",
+ select_id, ioctl_type, rc);
+ }
+ } /* wait callback */
+ } /* loc_ioctl */
+
+ loc_set_slot_in_use(select_id, 0); // set slot in use to false
+ loc_unlock_slot(select_id);
+
+ return rc;
+}
+
+
diff --git a/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/loc_apicb_appinit.c b/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/loc_apicb_appinit.c
new file mode 100644
index 0000000..db5b291
--- /dev/null
+++ b/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/loc_apicb_appinit.c
@@ -0,0 +1,86 @@
+/* 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
+ * 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 "rpc/rpc.h"
+
+/* Include RPC headers */
+#ifdef USE_LOCAL_RPC
+#include "rpc_inc/loc_api_common.h"
+#include "rpc_inc/loc_api.h"
+#include "rpc_inc/loc_api_cb.h"
+#endif
+
+#ifdef USE_QCOM_AUTO_RPC
+#include "loc_api_rpcgen_rpc.h"
+#include "loc_api_rpcgen_common_rpc.h"
+#include "loc_api_rpcgen_cb_rpc.h"
+#endif
+
+#include "rpc_inc/loc_api_fixup.h"
+#include "loc_apicb_appinit.h"
+
+#define RPC_FUNC_VERSION_BASE(a,b) a ## b
+#define RPC_CB_FUNC_VERS(a,b) RPC_FUNC_VERSION_BASE(a,b)
+
+static SVCXPRT* svrPort = NULL;
+
+extern void RPC_CB_FUNC_VERS(loc_apicbprog_,LOC_APICBVERS_0001)(struct svc_req *rqstp, register SVCXPRT *transp);
+
+int loc_apicb_app_init(void)
+{
+
+ /* Register a callback server to use the loc_apicbprog_* function */
+ if (svrPort == NULL) {
+ svrPort = svcrtr_create();
+ }
+ if (!svrPort) return -1;
+
+ xprt_register(svrPort);
+ if(svc_register(svrPort, LOC_APICBPROG, LOC_APICBVERS_0001, RPC_CB_FUNC_VERS(loc_apicbprog_,LOC_APICBVERS_0001),0))
+ {
+ return 0;
+ }
+ else
+ {
+ return -1;
+ }
+}
+
+void loc_apicb_app_deinit(void)
+{
+ if (svrPort == NULL)
+ {
+ return;
+ }
+
+ svc_unregister(svrPort, LOC_APICBPROG, LOC_APICBVERS_0001);
+ xprt_unregister(svrPort);
+ svc_destroy(svrPort);
+ svrPort = NULL;
+}
+
diff --git a/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/Android.mk b/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/Android.mk
new file mode 100644
index 0000000..c0987e6
--- /dev/null
+++ b/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/Android.mk
@@ -0,0 +1,36 @@
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+
+# functions
+LOC_RPCGEN_APIS_PATH := $(TARGET_OUT_INTERMEDIATES)/loc_api/libloc_api_rpcgen_intermediates
+LOC_RPCGEN_APIS_PATH_FL := ../../../../../$(TARGET_OUT_INTERMEDIATES)/loc_api/libloc_api_rpcgen_intermediates
+
+LOCAL_MODULE := libloc_api_rpcgen
+LOCAL_MODULE_OWNER := qcom
+
+LOCAL_SHARED_LIBRARIES := \
+ librpc \
+ libcommondefs
+
+LOCAL_SRC_FILES += \
+ src/loc_api_rpcgen_cb_xdr.c \
+ src/loc_api_rpcgen_common_xdr.c \
+ src/loc_api_rpcgen_cb_svc.c \
+ src/loc_api_rpcgen_clnt.c \
+ src/loc_api_rpcgen_xdr.c
+
+LOCAL_C_INCLUDES += hardware/msm7k/librpc
+LOCAL_C_INCLUDES += $(LOC_RPCGEN_APIS_PATH)/../../SHARED_LIBRARIES/libcommondefs_intermediates/inc
+LOCAL_C_INCLUDES += $(LOCAL_PATH)/inc
+LOCAL_C_INCLUDES += $(TARGET_OUT_HEADERS)/libcommondefs/rpcgen/inc
+
+LOCAL_COPY_HEADERS_TO := loc_api/rpcgen/inc
+LOCAL_COPY_HEADERS := inc/loc_api_rpcgen_rpc.h
+LOCAL_COPY_HEADERS += inc/loc_api_rpcgen_common_rpc.h
+LOCAL_COPY_HEADERS += inc/loc_api_rpcgen_cb_rpc.h
+LOCAL_COPY_HEADERS += inc/loc_apicb_appinit.h
+
+LOCAL_LDLIBS += -lpthread
+LOCAL_PRELINK_MODULE := false
+include $(BUILD_STATIC_LIBRARY)
diff --git a/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/Makefile.am b/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/Makefile.am
new file mode 100644
index 0000000..4ac8c8a
--- /dev/null
+++ b/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/Makefile.am
@@ -0,0 +1,42 @@
+AM_CFLAGS = \
+ -I../../../utils \
+ -I./inc \
+ $(MSM7K_CFLAGS)
+
+requiredlibs = \
+ ../../../utils/libgps_utils_so.la \
+ $(MSM7K_LIBS)
+
+h_sources = \
+ inc/loc_api_rpcgen_rpc.h \
+ inc/loc_api_rpcgen_common_rpc.h \
+ inc/loc_api_rpcgen_cb_rpc.h \
+ inc/loc_apicb_appinit.h
+
+c_sources = \
+ src/loc_api_rpcgen_cb_xdr.c \
+ src/loc_api_rpcgen_common_xdr.c \
+ src/loc_api_rpcgen_cb_svc.c \
+ src/loc_api_rpcgen_clnt.c \
+ src/loc_api_rpcgen_xdr.c
+
+
+
+library_includedir = $(pkgincludedir)/libloc_api-rpc-50001/libloc_api-rpc-stub/inc
+library_include_HEADERS = $(h_sources)
+libloc_api_rpcgen_la_SOURCES = $(c_sources) $(h_sources)
+
+if USE_GLIB
+libloc_api_rpcgen_la_CFLAGS = -DUSE_GLIB $(AM_CFLAGS) @GLIB_CFLAGS@
+libloc_api_rpcgen_la_LDFLAGS = -lstdc++ -lpthread @GLIB_LIBS@ -shared -version-info 1:0:0
+libloc_api_rpcgen_la_CPPFLAGS = -DUSE_GLIB $(AM_CFLAGS) $(AM_CPPFLAGS) @GLIB_CFLAGS@
+else
+libloc_api_rpcgen_la_CFLAGS = $(AM_CFLAGS)
+libloc_api_rpcgen_la_LDFLAGS = -lpthread -shared -version-info 1:0:0
+libloc_api_rpcgen_la_CPPFLAGS = $(AM_CFLAGS) $(AM_CPPFLAGS)
+endif
+
+libloc_api_rpcgen_la_LIBADD = $(requiredlibs) -lstdc++
+
+#Create and Install Libraries
+lib_LTLIBRARIES = libloc_api_rpcgen.la
diff --git a/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/inc/loc_api_rpcgen_cb_rpc.h b/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/inc/loc_api_rpcgen_cb_rpc.h
new file mode 100644
index 0000000..87f2c37
--- /dev/null
+++ b/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/inc/loc_api_rpcgen_cb_rpc.h
@@ -0,0 +1,156 @@
+/* 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
+ * 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.
+ *
+ */
+/*
+ * Please do not edit this file.
+ * It was generated using rpcgen.
+ */
+
+#ifndef _LOC_API_CB_RPC_H_RPCGEN
+#define _LOC_API_CB_RPC_H_RPCGEN
+
+#include "librpc.h"
+#include "commondefs_rpcgen_rpc.h"
+#include "loc_api_rpcgen_common_rpc.h"
+
+#include <pthread.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+struct rpc_loc_event_cb_f_type_args {
+ rpc_uint32 cb_id;
+ rpc_loc_client_handle_type loc_handle;
+ rpc_loc_event_mask_type loc_event;
+ rpc_loc_event_payload_u_type *loc_event_payload;
+};
+typedef struct rpc_loc_event_cb_f_type_args rpc_loc_event_cb_f_type_args;
+
+struct rpc_loc_event_cb_f_type_rets {
+ rpc_int32 loc_event_cb_f_type_result;
+};
+typedef struct rpc_loc_event_cb_f_type_rets rpc_loc_event_cb_f_type_rets;
+#define LOC_APICBVERS 0x00050006
+
+#define LOC_APICBPROG 0x3100008C
+#define LOC_APICBVERS_0001 0x00050001
+
+#if defined(__STDC__) || defined(__cplusplus)
+#define rpc_loc_event_cb_f_type 1
+extern enum clnt_stat rpc_loc_event_cb_f_type_0x00050001(rpc_loc_event_cb_f_type_args *, rpc_loc_event_cb_f_type_rets *, CLIENT *);
+extern bool_t rpc_loc_event_cb_f_type_0x00050001_svc(rpc_loc_event_cb_f_type_args *, rpc_loc_event_cb_f_type_rets *, struct svc_req *);
+extern int loc_apicbprog_0x00050001_freeresult (SVCXPRT *, xdrproc_t, caddr_t);
+
+#else /* K&R C */
+#define rpc_loc_event_cb_f_type 1
+extern enum clnt_stat rpc_loc_event_cb_f_type_0x00050001();
+extern bool_t rpc_loc_event_cb_f_type_0x00050001_svc();
+extern int loc_apicbprog_0x00050001_freeresult ();
+#endif /* K&R C */
+#define LOC_APICBVERS_0002 0x00050002
+
+#if defined(__STDC__) || defined(__cplusplus)
+#define rpc_loc_api_cb_null 0xffffff00
+extern enum clnt_stat rpc_loc_api_cb_null_0x00050002(void *, int *, CLIENT *);
+extern bool_t rpc_loc_api_cb_null_0x00050002_svc(void *, int *, struct svc_req *);
+extern int loc_apicbprog_0x00050002_freeresult (SVCXPRT *, xdrproc_t, caddr_t);
+
+#else /* K&R C */
+#define rpc_loc_api_cb_null 0xffffff00
+extern enum clnt_stat rpc_loc_api_cb_null_0x00050002();
+extern bool_t rpc_loc_api_cb_null_0x00050002_svc();
+extern int loc_apicbprog_0x00050002_freeresult ();
+#endif /* K&R C */
+#define LOC_APICBVERS_0003 0x00050003
+
+#if defined(__STDC__) || defined(__cplusplus)
+extern enum clnt_stat rpc_loc_api_cb_null_0x00050003(void *, int *, CLIENT *);
+extern bool_t rpc_loc_api_cb_null_0x00050003_svc(void *, int *, struct svc_req *);
+extern int loc_apicbprog_0x00050003_freeresult (SVCXPRT *, xdrproc_t, caddr_t);
+
+#else /* K&R C */
+extern enum clnt_stat rpc_loc_api_cb_null_0x00050003();
+extern bool_t rpc_loc_api_cb_null_0x00050003_svc();
+extern int loc_apicbprog_0x00050003_freeresult ();
+#endif /* K&R C */
+#define LOC_APICBVERS_0004 0x00050004
+
+#if defined(__STDC__) || defined(__cplusplus)
+extern enum clnt_stat rpc_loc_api_cb_null_0x00050004(void *, int *, CLIENT *);
+extern bool_t rpc_loc_api_cb_null_0x00050004_svc(void *, int *, struct svc_req *);
+extern int loc_apicbprog_0x00050004_freeresult (SVCXPRT *, xdrproc_t, caddr_t);
+
+#else /* K&R C */
+extern enum clnt_stat rpc_loc_api_cb_null_0x00050004();
+extern bool_t rpc_loc_api_cb_null_0x00050004_svc();
+extern int loc_apicbprog_0x00050004_freeresult ();
+#endif /* K&R C */
+#define LOC_APICBVERS_0005 0x00050005
+
+#if defined(__STDC__) || defined(__cplusplus)
+extern enum clnt_stat rpc_loc_api_cb_null_0x00050005(void *, int *, CLIENT *);
+extern bool_t rpc_loc_api_cb_null_0x00050005_svc(void *, int *, struct svc_req *);
+extern int loc_apicbprog_0x00050005_freeresult (SVCXPRT *, xdrproc_t, caddr_t);
+
+#else /* K&R C */
+extern enum clnt_stat rpc_loc_api_cb_null_0x00050005();
+extern bool_t rpc_loc_api_cb_null_0x00050005_svc();
+extern int loc_apicbprog_0x00050005_freeresult ();
+#endif /* K&R C */
+#define LOC_APICBVERS_0006 0x00050006
+
+#if defined(__STDC__) || defined(__cplusplus)
+extern enum clnt_stat rpc_loc_api_cb_null_0x00050006(void *, int *, CLIENT *);
+extern bool_t rpc_loc_api_cb_null_0x00050006_svc(void *, int *, struct svc_req *);
+extern int loc_apicbprog_0x00050006_freeresult (SVCXPRT *, xdrproc_t, caddr_t);
+
+#else /* K&R C */
+extern enum clnt_stat rpc_loc_api_cb_null_0x00050006();
+extern bool_t rpc_loc_api_cb_null_0x00050006_svc();
+extern int loc_apicbprog_0x00050006_freeresult ();
+#endif /* K&R C */
+
+/* the xdr functions */
+
+#if defined(__STDC__) || defined(__cplusplus)
+extern bool_t xdr_rpc_loc_event_cb_f_type_args (XDR *, rpc_loc_event_cb_f_type_args*);
+extern bool_t xdr_rpc_loc_event_cb_f_type_rets (XDR *, rpc_loc_event_cb_f_type_rets*);
+
+#else /* K&R C */
+extern bool_t xdr_rpc_loc_event_cb_f_type_args ();
+extern bool_t xdr_rpc_loc_event_cb_f_type_rets ();
+
+#endif /* K&R C */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* !_LOC_API_CB_RPC_H_RPCGEN */
diff --git a/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/inc/loc_api_rpcgen_common_rpc.h b/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/inc/loc_api_rpcgen_common_rpc.h
new file mode 100644
index 0000000..8107de2
--- /dev/null
+++ b/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/inc/loc_api_rpcgen_common_rpc.h
@@ -0,0 +1,1261 @@
+/* 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
+ * 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.
+ *
+ */
+/*
+ * Please do not edit this file.
+ * It was generated using rpcgen.
+ */
+
+#ifndef _LOC_API_COMMON_RPC_H_RPCGEN
+#define _LOC_API_COMMON_RPC_H_RPCGEN
+
+#include "librpc.h"
+#include "commondefs_rpcgen_rpc.h"
+
+#include <pthread.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define LOC_API_TOOLVERS 0x00040030
+#define LOC_API_FEATURES 0x00000001
+#define RPC_LOC_EVENT_STATUS_REPORT 0x00000100
+#define RPC_LOC_EVENT_ASSISTANCE_DATA_REQUEST 0x00000020
+#define RPC_LOC_EVENT_WPS_NEEDED_REQUEST 0x00000200
+#define RPC_LOC_EVENT_SATELLITE_REPORT 0x00000002
+#define RPC_LOC_EVENT_PARSED_POSITION_REPORT 0x00000001
+#define RPC_LOC_EVENT_RESERVED 0x8000000000000000
+#define RPC_LOC_EVENT_LOCATION_SERVER_REQUEST 0x00000040
+#define RPC_LOC_EVENT_NMEA_POSITION_REPORT 0x00000008
+#define RPC_LOC_EVENT_IOCTL_REPORT 0x00000080
+#define RPC_LOC_EVENT_NMEA_1HZ_REPORT 0x00000004
+#define RPC_LOC_EVENT_NI_NOTIFY_VERIFY_REQUEST 0x00000010
+#define RPC_LOC_API_CB_NULL_VERSION 0x00050002
+#define RPC_LOC_EVENT_CB_F_TYPE_VERSION 0x00050001
+#define RPC_LOC_API_API_VERSIONS_VERSION 0x00050001
+#define RPC_LOC_STOP_FIX_VERSION 0x00050001
+#define RPC_LOC_START_FIX_VERSION 0x00050001
+#define RPC_LOC_IOCTL_VERSION 0x00050001
+#define RPC_LOC_CLOSE_VERSION 0x00050001
+#define RPC_LOC_API_RPC_GLUE_CODE_INFO_REMOTE_VERSION 0x00050001
+#define RPC_LOC_OPEN_VERSION 0x00050001
+#define RPC_LOC_API_NULL_VERSION 0x00050001
+#define RPC_LOC_API_API_MAJOR_NUM 0x0005
+#define RPC_LOC_APIAPI_VERSION_IS_HASHKEY 0
+
+typedef rpc_int32 rpc_loc_client_handle_type;
+
+typedef rpc_uint64 rpc_loc_event_mask_type;
+
+typedef rpc_uint64 rpc_loc_position_valid_mask_type;
+
+typedef rpc_uint32 rpc_loc_pos_technology_mask_type;
+
+enum rpc_loc_session_status_e_type {
+ RPC_LOC_SESS_STATUS_SUCCESS = 0,
+ RPC_LOC_SESS_STATUS_IN_PROGESS = 1,
+ RPC_LOC_SESS_STATUS_GENERAL_FAILURE = 2,
+ RPC_LOC_SESS_STATUS_TIMEOUT = 3,
+ RPC_LOC_SESS_STATUS_USER_END = 4,
+ RPC_LOC_SESS_STATUS_BAD_PARAMETER = 5,
+ RPC_LOC_SESS_STATUS_PHONE_OFFLINE = 6,
+ RPC_LOC_SESS_STATUS_ENGINE_LOCKED = 7,
+ RPC_LOC_SESS_STATUS_MAX = 268435456,
+};
+typedef enum rpc_loc_session_status_e_type rpc_loc_session_status_e_type;
+
+struct rpc_loc_calendar_time_s_type {
+ rpc_uint16 year;
+ u_char month;
+ u_char day_of_week;
+ u_char day;
+ u_char hour;
+ u_char minute;
+ u_char second;
+ rpc_uint16 millisecond;
+};
+typedef struct rpc_loc_calendar_time_s_type rpc_loc_calendar_time_s_type;
+
+struct rpc_loc_parsed_position_s_type {
+ rpc_loc_position_valid_mask_type valid_mask;
+ rpc_loc_session_status_e_type session_status;
+ rpc_loc_calendar_time_s_type timestamp_calendar;
+ rpc_uint64 timestamp_utc;
+ rpc_uint8 leap_seconds;
+ float time_unc;
+ double latitude;
+ double longitude;
+ float altitude_wrt_ellipsoid;
+ float altitude_wrt_mean_sea_level;
+ float speed_horizontal;
+ float speed_vertical;
+ float heading;
+ float hor_unc_circular;
+ float hor_unc_ellipse_semi_major;
+ float hor_unc_ellipse_semi_minor;
+ float hor_unc_ellipse_orient_azimuth;
+ float vert_unc;
+ float speed_unc;
+ float heading_unc;
+ u_char confidence_horizontal;
+ u_char confidence_vertical;
+ float magnetic_deviation;
+ rpc_loc_pos_technology_mask_type technology_mask;
+};
+typedef struct rpc_loc_parsed_position_s_type rpc_loc_parsed_position_s_type;
+
+enum rpc_loc_sv_system_e_type {
+ RPC_LOC_SV_SYSTEM_GPS = 1,
+ RPC_LOC_SV_SYSTEM_GALILEO = 2,
+ RPC_LOC_SV_SYSTEM_SBAS = 3,
+ RPC_LOC_SV_SYSTEM_COMPASS = 4,
+ RPC_LOC_SV_SYSTEM_GLONASS = 5,
+ RPC_LOC_SV_SYSTEM_MAX = 268435456,
+};
+typedef enum rpc_loc_sv_system_e_type rpc_loc_sv_system_e_type;
+
+enum rpc_loc_sv_status_e_type {
+ RPC_LOC_SV_STATUS_IDLE = 1,
+ RPC_LOC_SV_STATUS_SEARCH = 2,
+ RPC_LOC_SV_STATUS_TRACK = 3,
+ RPC_LOC_SV_STATUS_MAX = 268435456,
+};
+typedef enum rpc_loc_sv_status_e_type rpc_loc_sv_status_e_type;
+
+typedef rpc_uint32 rpc_loc_sv_info_valid_mask_type;
+
+struct rpc_loc_sv_info_s_type {
+ rpc_loc_sv_info_valid_mask_type valid_mask;
+ rpc_loc_sv_system_e_type system;
+ rpc_uint8 prn;
+ rpc_uint8 health_status;
+ rpc_loc_sv_status_e_type process_status;
+ rpc_boolean has_eph;
+ rpc_boolean has_alm;
+ float elevation;
+ float azimuth;
+ float snr;
+};
+typedef struct rpc_loc_sv_info_s_type rpc_loc_sv_info_s_type;
+
+typedef rpc_uint32 rpc_loc_gnss_info_valid_mask_type;
+
+struct rpc_loc_gnss_info_s_type {
+ rpc_loc_gnss_info_valid_mask_type valid_mask;
+ float position_dop;
+ float horizontal_dop;
+ float vertical_dop;
+ rpc_boolean altitude_assumed;
+ rpc_uint16 sv_count;
+ struct {
+ u_int sv_list_len;
+ rpc_loc_sv_info_s_type *sv_list_val;
+ } sv_list;
+};
+typedef struct rpc_loc_gnss_info_s_type rpc_loc_gnss_info_s_type;
+
+struct rpc_loc_nmea_report_s_type {
+ rpc_uint16 length;
+ char nmea_sentences[200];
+};
+typedef struct rpc_loc_nmea_report_s_type rpc_loc_nmea_report_s_type;
+
+enum rpc_loc_status_event_e_type {
+ RPC_LOC_STATUS_EVENT_ENGINE_STATE = 1,
+ RPC_LOC_STATUS_EVENT_FIX_SESSION_STATE = 2,
+ RPC_LOC_STATUS_EVENT_MAX = 268435456,
+};
+typedef enum rpc_loc_status_event_e_type rpc_loc_status_event_e_type;
+
+enum rpc_loc_engine_state_e_type {
+ RPC_LOC_ENGINE_STATE_ON = 1,
+ RPC_LOC_ENGINE_STATE_OFF = 2,
+ RPC_LOC_ENGINE_STATE_MAX = 268435456,
+};
+typedef enum rpc_loc_engine_state_e_type rpc_loc_engine_state_e_type;
+
+enum rpc_loc_fix_session_state_e_type {
+ RPC_LOC_FIX_SESSION_STATE_BEGIN = 1,
+ RPC_LOC_FIX_SESSION_STATE_END = 2,
+ RPC_LOC_FIX_SESSION_STATE_MAX = 268435456,
+};
+typedef enum rpc_loc_fix_session_state_e_type rpc_loc_fix_session_state_e_type;
+
+struct rpc_loc_status_event_payload_u_type {
+ rpc_loc_status_event_e_type disc;
+ union {
+ rpc_loc_engine_state_e_type engine_state;
+ rpc_loc_fix_session_state_e_type fix_session_state;
+ } rpc_loc_status_event_payload_u_type_u;
+};
+typedef struct rpc_loc_status_event_payload_u_type rpc_loc_status_event_payload_u_type;
+
+struct rpc_loc_status_event_s_type {
+ rpc_loc_status_event_e_type event;
+ rpc_loc_status_event_payload_u_type payload;
+};
+typedef struct rpc_loc_status_event_s_type rpc_loc_status_event_s_type;
+
+enum rpc_loc_server_addr_e_type {
+ RPC_LOC_SERVER_ADDR_IPV4 = 1,
+ RPC_LOC_SERVER_ADDR_URL = 2,
+ RPC_LOC_SERVER_ADDR_IPV6 = 3,
+ RPC_LOC_SERVER_ADDR_MAX = 268435456,
+};
+typedef enum rpc_loc_server_addr_e_type rpc_loc_server_addr_e_type;
+
+struct rpc_loc_server_addr_ipv4_type {
+ rpc_uint32 addr;
+ rpc_uint16 port;
+};
+typedef struct rpc_loc_server_addr_ipv4_type rpc_loc_server_addr_ipv4_type;
+
+struct rpc_loc_server_addr_url_type {
+ rpc_uint16 length;
+ char addr[256];
+};
+typedef struct rpc_loc_server_addr_url_type rpc_loc_server_addr_url_type;
+
+struct rpc_loc_server_addr_ipv6_type {
+ rpc_uint16 addr[8];
+ rpc_uint32 port;
+};
+typedef struct rpc_loc_server_addr_ipv6_type rpc_loc_server_addr_ipv6_type;
+
+struct rpc_loc_server_addr_u_type {
+ rpc_loc_server_addr_e_type disc;
+ union {
+ rpc_loc_server_addr_ipv4_type ipv4;
+ rpc_loc_server_addr_url_type url;
+ rpc_loc_server_addr_ipv6_type ipv6;
+ } rpc_loc_server_addr_u_type_u;
+};
+typedef struct rpc_loc_server_addr_u_type rpc_loc_server_addr_u_type;
+
+struct rpc_loc_server_info_s_type {
+ rpc_loc_server_addr_e_type addr_type;
+ rpc_loc_server_addr_u_type addr_info;
+};
+typedef struct rpc_loc_server_info_s_type rpc_loc_server_info_s_type;
+
+enum rpc_loc_ni_notify_verify_e_type {
+ RPC_LOC_NI_USER_NO_NOTIFY_NO_VERIFY = 1,
+ RPC_LOC_NI_USER_NOTIFY_ONLY = 2,
+ RPC_LOC_NI_USER_NOTIFY_VERIFY_ALLOW_NO_RESP = 3,
+ RPC_LOC_NI_USER_NOTIFY_VERIFY_NOT_ALLOW_NO_RESP = 4,
+ RPC_LOC_NI_USER_PRIVACY_OVERRIDE = 5,
+ RPC_LOC_NI_USER_NOTIFY_VERITY_TYPE_MAX = 268435456,
+};
+typedef enum rpc_loc_ni_notify_verify_e_type rpc_loc_ni_notify_verify_e_type;
+
+enum rpc_loc_ni_event_e_type {
+ RPC_LOC_NI_EVENT_VX_NOTIFY_VERIFY_REQ = 1,
+ RPC_LOC_NI_EVENT_SUPL_NOTIFY_VERIFY_REQ = 2,
+ RPC_LOC_NI_EVENT_UMTS_CP_NOTIFY_VERIFY_REQ = 3,
+ RPC_LOC_NI_EVENT_VX_SERVICE_INTERACTION_REQ = 4,
+ RPC_LOC_NI_EVENT_MAX = 268435456,
+};
+typedef enum rpc_loc_ni_event_e_type rpc_loc_ni_event_e_type;
+
+enum rpc_loc_ni_datacoding_scheme_e_type {
+ RPC_LOC_NI_PRESUPL_ISO646IRV = 0,
+ RPC_LOC_NI_PRESUPL_ISO8859 = 1,
+ RPC_LOC_NI_PRESUPL_UTF8 = 2,
+ RPC_LOC_NI_PRESUPL_UTF16 = 3,
+ RPC_LOC_NI_PRESUPL_UCS2 = 4,
+ RPC_LOC_NI_PRESUPL_GSM_DEFAULT = 5,
+ RPC_LOC_NI_PRESUPL_SHIFT_JIS = 6,
+ RPC_LOC_NI_PRESUPL_JIS = 7,
+ RPC_LOC_NI_PRESUPL_EUC = 8,
+ RPC_LOC_NI_PRESUPL_GB2312 = 9,
+ RPC_LOC_NI_PRESUPL_CNS11643 = 10,
+ RPC_LOC_NI_PRESUPL_KSC1001 = 11,
+ RPC_LOC_NI_PRESUPL_ENCODING_UNKNOWN = 2147483647,
+ RPC_LOC_NI_SS_GERMAN = 12,
+ RPC_LOC_NI_SS_ENGLISH = 13,
+ RPC_LOC_NI_SS_ITALIAN = 14,
+ RPC_LOC_NI_SS_FRENCH = 15,
+ RPC_LOC_NI_SS_SPANISH = 16,
+ RPC_LOC_NI_SS_DUTCH = 17,
+ RPC_LOC_NI_SS_SWEDISH = 18,
+ RPC_LOC_NI_SS_DANISH = 19,
+ RPC_LOC_NI_SS_PORTUGUESE = 20,
+ RPC_LOC_NI_SS_FINNISH = 21,
+ RPC_LOC_NI_SS_NORWEGIAN = 22,
+ RPC_LOC_NI_SS_GREEK = 23,
+ RPC_LOC_NI_SS_TURKISH = 24,
+ RPC_LOC_NI_SS_HUNGARIAN = 25,
+ RPC_LOC_NI_SS_POLISH = 26,
+ RPC_LOC_NI_SS_LANGUAGE_UNSPEC = 27,
+ RPC_LOC_NI_SUPL_UTF8 = 28,
+ RPC_LOC_NI_SUPL_UCS2 = 29,
+ RPC_LOC_NI_SUPL_GSM_DEFAULT = 30,
+ RPC_LOC_NI_SUPL_ENCODING_UNKNOWN = 2147483647,
+};
+typedef enum rpc_loc_ni_datacoding_scheme_e_type rpc_loc_ni_datacoding_scheme_e_type;
+
+enum rpc_loc_ni_vx_requester_id_encoding_scheme_e_type {
+ RPC_LOC_NI_VX_OCTET = 0,
+ RPC_LOC_NI_VX_EXN_PROTOCOL_MSG = 1,
+ RPC_LOC_NI_VX_ASCII = 2,
+ RPC_LOC_NI_VX_IA5 = 3,
+ RPC_LOC_NI_VX_UNICODE = 4,
+ RPC_LOC_NI_VX_SHIFT_JIS = 5,
+ RPC_LOC_NI_VX_KOREAN = 6,
+ RPC_LOC_NI_VX_LATIN_HEBREW = 7,
+ RPC_LOC_NI_VX_LATIN = 8,
+ RPC_LOC_NI_VX_GSM = 9,
+ RPC_LOC_NI_VX_ENCODING_TYPE_MAX = 268435456,
+};
+typedef enum rpc_loc_ni_vx_requester_id_encoding_scheme_e_type rpc_loc_ni_vx_requester_id_encoding_scheme_e_type;
+
+enum rpc_loc_ni_vx_pos_mode_e_type {
+ RPC_LOC_VX_MS_ASSISTED_ONLY = 1,
+ RPC_LOC_VX_MS_BASED_ONLY = 2,
+ RPC_LOC_VX_MS_ASSISTED_PREF_MSBASED_ALLWD = 3,
+ RPC_LOC_VX_MS_BASED_PREF_ASSISTED_ALLWD = 4,
+ RPC_LOC_VX_POS_MODE_MAX = 268435456,
+};
+typedef enum rpc_loc_ni_vx_pos_mode_e_type rpc_loc_ni_vx_pos_mode_e_type;
+
+struct rpc_loc_ni_vx_requester_id_s_type {
+ u_char requester_id_length;
+ char requester_id[200];
+};
+typedef struct rpc_loc_ni_vx_requester_id_s_type rpc_loc_ni_vx_requester_id_s_type;
+
+struct rpc_loc_ni_vx_notify_verify_req_s_type {
+ rpc_loc_ni_notify_verify_e_type notification_priv_type;
+ u_char pos_qos_incl;
+ u_char pos_qos;
+ rpc_uint32 num_fixes;
+ rpc_uint32 tbf;
+ rpc_loc_ni_vx_pos_mode_e_type pos_mode;
+ rpc_loc_ni_vx_requester_id_encoding_scheme_e_type encoding_scheme;
+ rpc_loc_ni_vx_requester_id_s_type requester_id;
+ rpc_uint16 user_resp_timer_val;
+};
+typedef struct rpc_loc_ni_vx_notify_verify_req_s_type rpc_loc_ni_vx_notify_verify_req_s_type;
+
+enum rpc_loc_ni_supl_pos_method_e_type {
+ RPC_LOC_NI_POSMETHOD_AGPS_SETASSISTED = 1,
+ RPC_LOC_NI_POSMETHOD_AGPS_SETBASED = 2,
+ RPC_LOC_NI_POSMETHOD_AGPS_SETASSISTED_PREF = 3,
+ RPC_LOC_NI_POSMETHOD_AGPS_SETBASED_PREF = 4,
+ RPC_LOC_NI_POSMETHOD_AUTONOMOUS_GPS = 5,
+ RPC_LOC_NI_POSMETHOD_AFLT = 6,
+ RPC_LOC_NI_POSMETHOD_ECID = 7,
+ RPC_LOC_NI_POSMETHOD_EOTD = 8,
+ RPC_LOC_NI_POSMETHOD_OTDOA = 9,
+ RPC_LOC_NI_POSMETHOD_NO_POSITION = 10,
+ RPC_LOC_NI_POSMETHOD_MAX = 268435456,
+};
+typedef enum rpc_loc_ni_supl_pos_method_e_type rpc_loc_ni_supl_pos_method_e_type;
+
+struct rpc_loc_ni_supl_slp_session_id_s_type {
+ u_char presence;
+ char session_id[4];
+ rpc_loc_server_info_s_type slp_address;
+};
+typedef struct rpc_loc_ni_supl_slp_session_id_s_type rpc_loc_ni_supl_slp_session_id_s_type;
+
+struct rpc_loc_ni_requestor_id_s_type {
+ u_char data_coding_scheme;
+ char requestor_id_string[200];
+ u_char string_len;
+};
+typedef struct rpc_loc_ni_requestor_id_s_type rpc_loc_ni_requestor_id_s_type;
+
+struct rpc_loc_ni_supl_client_name_s_type {
+ u_char data_coding_scheme;
+ char client_name_string[64];
+ u_char string_len;
+};
+typedef struct rpc_loc_ni_supl_client_name_s_type rpc_loc_ni_supl_client_name_s_type;
+
+struct rpc_loc_ni_supl_qop_s_type {
+ u_char bit_mask;
+ u_char horacc;
+ u_char veracc;
+ rpc_uint16 maxLocAge;
+ u_char delay;
+};
+typedef struct rpc_loc_ni_supl_qop_s_type rpc_loc_ni_supl_qop_s_type;
+
+struct rpc_loc_ni_supl_notify_verify_req_s_type {
+ rpc_loc_ni_notify_verify_e_type notification_priv_type;
+ rpc_uint16 flags;
+ rpc_loc_ni_supl_slp_session_id_s_type supl_slp_session_id;
+ char supl_hash[8];
+ rpc_loc_ni_datacoding_scheme_e_type datacoding_scheme;
+ rpc_loc_ni_supl_pos_method_e_type pos_method;
+ rpc_loc_ni_requestor_id_s_type requestor_id;
+ rpc_loc_ni_supl_client_name_s_type client_name;
+ rpc_loc_ni_supl_qop_s_type supl_qop;
+ rpc_uint16 user_response_timer;
+};
+typedef struct rpc_loc_ni_supl_notify_verify_req_s_type rpc_loc_ni_supl_notify_verify_req_s_type;
+
+struct rpc_loc_ni_ext_client_address_s_type {
+ u_char ext_client_address_len;
+ char ext_client_address[20];
+};
+typedef struct rpc_loc_ni_ext_client_address_s_type rpc_loc_ni_ext_client_address_s_type;
+
+enum rpc_loc_ni_location_type_e_type {
+ RPC_LOC_NI_LOCATIONTYPE_CURRENT_LOCATION = 1,
+ RPC_LOC_NI_LOCATIONTYPE_CURRENT_OR_LAST_KNOWN_LOCATION = 2,
+ RPC_LOC_NI_LOCATIONTYPE_INITIAL_LOCATION = 3,
+ RPC_LOC_NI_LOCATIONTYPE_MAX = 268435456,
+};
+typedef enum rpc_loc_ni_location_type_e_type rpc_loc_ni_location_type_e_type;
+
+struct rpc_loc_ni_deferred_location_s_type {
+ u_char unused_bits;
+ u_char ms_available;
+};
+typedef struct rpc_loc_ni_deferred_location_s_type rpc_loc_ni_deferred_location_s_type;
+
+struct rpc_loc_ni_codeword_string_s_type {
+ u_char data_coding_scheme;
+ char lcs_codeword_string[20];
+ u_char string_len;
+};
+typedef struct rpc_loc_ni_codeword_string_s_type rpc_loc_ni_codeword_string_s_type;
+
+struct rpc_loc_ni_service_type_id_s_type {
+ u_char lcs_service_type_id;
+};
+typedef struct rpc_loc_ni_service_type_id_s_type rpc_loc_ni_service_type_id_s_type;
+
+struct rpc_loc_ni_umts_cp_notify_verify_req_s_type {
+ rpc_loc_ni_notify_verify_e_type notification_priv_type;
+ u_char invoke_id;
+ rpc_uint16 flags;
+ u_char notification_length;
+ char notification_text[64];
+ rpc_loc_ni_datacoding_scheme_e_type datacoding_scheme;
+ rpc_loc_ni_ext_client_address_s_type ext_client_address_data;
+ rpc_loc_ni_location_type_e_type location_type;
+ rpc_loc_ni_deferred_location_s_type deferred_location;
+ rpc_loc_ni_requestor_id_s_type requestor_id;
+ rpc_loc_ni_codeword_string_s_type codeword_string;
+ rpc_loc_ni_service_type_id_s_type service_type_id;
+ rpc_uint16 user_response_timer;
+};
+typedef struct rpc_loc_ni_umts_cp_notify_verify_req_s_type rpc_loc_ni_umts_cp_notify_verify_req_s_type;
+
+enum rpc_loc_ni_service_interaction_e_type {
+ RPC_LOC_NI_SERVICE_INTERACTION_ONGOING_NI_INCOMING_MO = 1,
+ RPC_LOC_NI_SERVICE_INTERACTION_MAX = 268435456,
+};
+typedef enum rpc_loc_ni_service_interaction_e_type rpc_loc_ni_service_interaction_e_type;
+
+struct rpc_loc_ni_vx_service_interaction_req_s_type {
+ rpc_loc_ni_vx_notify_verify_req_s_type ni_vx_req;
+ rpc_loc_ni_service_interaction_e_type service_interation_type;
+};
+typedef struct rpc_loc_ni_vx_service_interaction_req_s_type rpc_loc_ni_vx_service_interaction_req_s_type;
+
+struct rpc_loc_ni_event_payload_u_type {
+ rpc_loc_ni_event_e_type disc;
+ union {
+ rpc_loc_ni_vx_notify_verify_req_s_type vx_req;
+ rpc_loc_ni_supl_notify_verify_req_s_type supl_req;
+ rpc_loc_ni_umts_cp_notify_verify_req_s_type umts_cp_req;
+ rpc_loc_ni_vx_service_interaction_req_s_type service_interaction_req;
+ } rpc_loc_ni_event_payload_u_type_u;
+};
+typedef struct rpc_loc_ni_event_payload_u_type rpc_loc_ni_event_payload_u_type;
+
+struct rpc_loc_ni_event_s_type {
+ rpc_loc_ni_event_e_type event;
+ rpc_loc_ni_event_payload_u_type payload;
+};
+typedef struct rpc_loc_ni_event_s_type rpc_loc_ni_event_s_type;
+
+enum rpc_loc_assist_data_request_e_type {
+ RPC_LOC_ASSIST_DATA_TIME_REQ = 1,
+ RPC_LOC_ASSIST_DATA_PREDICTED_ORBITS_REQ = 2,
+ RPC_LOC_ASSIST_DATA_POSITION_INJECTION_REQ = 3,
+ RPC_LOC_ASSIST_DATA_MAX = 268435456,
+};
+typedef enum rpc_loc_assist_data_request_e_type rpc_loc_assist_data_request_e_type;
+
+typedef char *rpc_struct_loc_time_download_source_s_type_servers_ptr;
+
+typedef rpc_struct_loc_time_download_source_s_type_servers_ptr rpc_struct_loc_time_download_source_s_type_servers[3];
+
+struct rpc_loc_time_download_source_s_type {
+ rpc_uint32 delay_threshold;
+ rpc_struct_loc_time_download_source_s_type_servers servers;
+};
+typedef struct rpc_loc_time_download_source_s_type rpc_loc_time_download_source_s_type;
+
+typedef char *rpc_struct_loc_predicted_orbits_data_source_s_type_servers_ptr;
+
+typedef rpc_struct_loc_predicted_orbits_data_source_s_type_servers_ptr rpc_struct_loc_predicted_orbits_data_source_s_type_servers[3];
+
+struct rpc_loc_predicted_orbits_data_source_s_type {
+ rpc_uint32 max_file_size;
+ rpc_uint32 max_part_size;
+ rpc_struct_loc_predicted_orbits_data_source_s_type_servers servers;
+};
+typedef struct rpc_loc_predicted_orbits_data_source_s_type rpc_loc_predicted_orbits_data_source_s_type;
+
+struct rpc_loc_pos_inj_request_s_type {
+ rpc_uint32 flags;
+ double latitude;
+ double longitude;
+ rpc_uint32 position_uncertainty;
+ rpc_uint64 timestamp;
+};
+typedef struct rpc_loc_pos_inj_request_s_type rpc_loc_pos_inj_request_s_type;
+
+struct rpc_loc_assist_data_request_payload_u_type {
+ rpc_loc_assist_data_request_e_type disc;
+ union {
+ rpc_loc_time_download_source_s_type time_download;
+ rpc_loc_predicted_orbits_data_source_s_type data_download;
+ rpc_loc_pos_inj_request_s_type pos_injection;
+ } rpc_loc_assist_data_request_payload_u_type_u;
+};
+typedef struct rpc_loc_assist_data_request_payload_u_type rpc_loc_assist_data_request_payload_u_type;
+
+struct rpc_loc_assist_data_request_s_type {
+ rpc_loc_assist_data_request_e_type event;
+ rpc_loc_assist_data_request_payload_u_type payload;
+};
+typedef struct rpc_loc_assist_data_request_s_type rpc_loc_assist_data_request_s_type;
+
+typedef rpc_uint32 rpc_loc_server_connection_handle;
+
+enum rpc_loc_server_protocol_e_type {
+ RPC_LOC_SERVER_PROTOCOL_DEFAULT = 0,
+ RPC_LOC_SERVER_PROTOCOL_SUPL = 1,
+ RPC_LOC_SERVER_PROTOCOL_VX_MPC = 2,
+ RPC_LOC_SERVER_PROTOCOL_VX_PDE = 3,
+ RPC_LOC_SERVER_PROTOCOL_MAX = 16777216,
+};
+typedef enum rpc_loc_server_protocol_e_type rpc_loc_server_protocol_e_type;
+
+enum rpc_loc_server_connection_e_type {
+ RPC_LOC_SERVER_CONNECTION_LBS = 0,
+ RPC_LOC_SERVER_CONNECTION_WWAN_INTERNET = 0 + 1,
+ RPC_LOC_SERVER_CONNECTION_MAX = 16777216,
+};
+typedef enum rpc_loc_server_connection_e_type rpc_loc_server_connection_e_type;
+
+enum rpc_loc_server_request_e_type {
+ RPC_LOC_SERVER_REQUEST_OPEN = 1,
+ RPC_LOC_SERVER_REQUEST_CLOSE = 2,
+ RPC_LOC_SERVER_REQUEST_MULTI_OPEN = 3,
+ RPC_LOC_SERVER_REQUEST_MAX = 268435456,
+};
+typedef enum rpc_loc_server_request_e_type rpc_loc_server_request_e_type;
+
+struct rpc_loc_server_open_req_s_type {
+ rpc_loc_server_connection_handle conn_handle;
+ rpc_loc_server_protocol_e_type protocol;
+};
+typedef struct rpc_loc_server_open_req_s_type rpc_loc_server_open_req_s_type;
+
+struct rpc_loc_server_multi_open_req_s_type {
+ rpc_loc_server_connection_handle conn_handle;
+ rpc_loc_server_protocol_e_type protocol;
+ rpc_loc_server_connection_e_type connection_type;
+};
+typedef struct rpc_loc_server_multi_open_req_s_type rpc_loc_server_multi_open_req_s_type;
+
+struct rpc_loc_server_close_req_s_type {
+ rpc_loc_server_connection_handle conn_handle;
+};
+typedef struct rpc_loc_server_close_req_s_type rpc_loc_server_close_req_s_type;
+
+struct rpc_loc_server_request_u_type {
+ rpc_loc_server_request_e_type disc;
+ union {
+ rpc_loc_server_open_req_s_type open_req;
+ rpc_loc_server_close_req_s_type close_req;
+ rpc_loc_server_multi_open_req_s_type multi_open_req;
+ } rpc_loc_server_request_u_type_u;
+};
+typedef struct rpc_loc_server_request_u_type rpc_loc_server_request_u_type;
+
+struct rpc_loc_server_request_s_type {
+ rpc_loc_server_request_e_type event;
+ rpc_loc_server_request_u_type payload;
+};
+typedef struct rpc_loc_server_request_s_type rpc_loc_server_request_s_type;
+
+enum rpc_loc_qwip_request_e_type {
+ RPC_LOC_QWIP_START_PERIODIC_HI_FREQ_FIXES = 0,
+ RPC_LOC_QWIP_START_PERIODIC_KEEP_WARM = 0 + 1,
+ RPC_LOC_QWIP_STOP_PERIODIC_FIXES = 0 + 2,
+ RPC_LOC_QWIP_SUSPEND = 0 + 3,
+ RPC_LOC_QWIP_REQUEST_MAX = 268435456,
+};
+typedef enum rpc_loc_qwip_request_e_type rpc_loc_qwip_request_e_type;
+
+struct rpc_loc_qwip_request_s_type {
+ rpc_loc_qwip_request_e_type request_type;
+ rpc_uint16 tbf_ms;
+};
+typedef struct rpc_loc_qwip_request_s_type rpc_loc_qwip_request_s_type;
+
+struct rpc_loc_reserved_payload_s_type {
+ rpc_uint16 data_size;
+ struct {
+ u_int data_len;
+ char *data_val;
+ } data;
+};
+typedef struct rpc_loc_reserved_payload_s_type rpc_loc_reserved_payload_s_type;
+
+enum rpc_loc_ioctl_e_type {
+ RPC_LOC_IOCTL_GET_API_VERSION = 1,
+ RPC_LOC_IOCTL_SET_FIX_CRITERIA = 2,
+ RPC_LOC_IOCTL_GET_FIX_CRITERIA = 3,
+ RPC_LOC_IOCTL_SERVICE_START_INDEX = 400,
+ RPC_LOC_IOCTL_INFORM_NI_USER_RESPONSE = 400,
+ RPC_LOC_IOCTL_INJECT_PREDICTED_ORBITS_DATA = 401,
+ RPC_LOC_IOCTL_QUERY_PREDICTED_ORBITS_DATA_VALIDITY = 402,
+ RPC_LOC_IOCTL_QUERY_PREDICTED_ORBITS_DATA_SOURCE = 403,
+ RPC_LOC_IOCTL_SET_PREDICTED_ORBITS_DATA_AUTO_DOWNLOAD = 404,
+ RPC_LOC_IOCTL_INJECT_UTC_TIME = 405,
+ RPC_LOC_IOCTL_INJECT_RTC_VALUE = 406,
+ RPC_LOC_IOCTL_INJECT_POSITION = 407,
+ RPC_LOC_IOCTL_QUERY_ENGINE_STATE = 408,
+ RPC_LOC_IOCTL_INFORM_SERVER_OPEN_STATUS = 409,
+ RPC_LOC_IOCTL_INFORM_SERVER_CLOSE_STATUS = 410,
+ RPC_LOC_IOCTL_SEND_WIPER_POSITION_REPORT = 411,
+ RPC_LOC_IOCTL_NOTIFY_WIPER_STATUS = 412,
+ RPC_LOC_IOCTL_ACCESS_EFS_DATA = 413,
+ RPC_LOC_IOCTL_ERROR_ESTIMATE_CONFIG = 414,
+ RPC_LOC_IOCTL_INFORM_SERVER_MULTI_OPEN_STATUS = 415,
+ RPC_LOC_IOCTL_NV_SETTINGS_START_INDEX = 800,
+ RPC_LOC_IOCTL_SET_ENGINE_LOCK = 800,
+ RPC_LOC_IOCTL_GET_ENGINE_LOCK = 801,
+ RPC_LOC_IOCTL_SET_SBAS_CONFIG = 802,
+ RPC_LOC_IOCTL_GET_SBAS_CONFIG = 803,
+ RPC_LOC_IOCTL_SET_NMEA_TYPES = 804,
+ RPC_LOC_IOCTL_GET_NMEA_TYPES = 805,
+ RPC_LOC_IOCTL_SET_CDMA_PDE_SERVER_ADDR = 806,
+ RPC_LOC_IOCTL_GET_CDMA_PDE_SERVER_ADDR = 807,
+ RPC_LOC_IOCTL_SET_CDMA_MPC_SERVER_ADDR = 808,
+ RPC_LOC_IOCTL_GET_CDMA_MPC_SERVER_ADDR = 809,
+ RPC_LOC_IOCTL_SET_UMTS_SLP_SERVER_ADDR = 810,
+ RPC_LOC_IOCTL_GET_UMTS_SLP_SERVER_ADDR = 811,
+ RPC_LOC_IOCTL_SET_ON_DEMAND_LPM = 812,
+ RPC_LOC_IOCTL_GET_ON_DEMAND_LPM = 813,
+ RPC_LOC_IOCTL_SET_XTRA_T_SESSION_CONTROL = 814,
+ RPC_LOC_IOCTL_GET_XTRA_T_SESSION_CONTROL = 815,
+ RPC_LOC_IOCTL_SET_LBS_APN_PROFILE = 816,
+ RPC_LOC_IOCTL_GET_LBS_APN_PROFILE = 817,
+ RPC_LOC_IOCTL_SET_XTRA_APN_PROFILE = 818,
+ RPC_LOC_IOCTL_GET_XTRA_APN_PROFILE = 819,
+ RPC_LOC_IOCTL_SET_DATA_ENABLE = 820,
+ RPC_LOC_IOCTL_SET_SUPL_VERSION = 821,
+ RPC_LOC_IOCTL_GET_SUPL_VERSION = 822,
+ RPC_LOC_IOCTL_PROPRIETARY_START_INDEX = 1000,
+ RPC_LOC_IOCTL_DELETE_ASSIST_DATA = 1000,
+ RPC_LOC_IOCTL_SET_CUSTOM_PDE_SERVER_ADDR = 1001,
+ RPC_LOC_IOCTL_GET_CUSTOM_PDE_SERVER_ADDR = 1002,
+ RPC_LOC_IOCTL_RESERVED_CMD = 8000,
+ RPC_LOC_IOCTL_THIRD_PARTY_START_INDEX = 1073741824,
+};
+typedef enum rpc_loc_ioctl_e_type rpc_loc_ioctl_e_type;
+
+struct rpc_loc_api_version_s_type {
+ u_char major;
+ u_char minor;
+};
+typedef struct rpc_loc_api_version_s_type rpc_loc_api_version_s_type;
+
+enum rpc_loc_fix_recurrence_e_type {
+ RPC_LOC_PERIODIC_FIX = 1,
+ RPC_LOC_SINGLE_FIX = 2,
+ RPC_LOC_FIX_SESSION_TYPE_MAX = 268435456,
+};
+typedef enum rpc_loc_fix_recurrence_e_type rpc_loc_fix_recurrence_e_type;
+
+enum rpc_loc_operation_mode_e_type {
+ RPC_LOC_OPER_MODE_DEFAULT = 1,
+ RPC_LOC_OPER_MODE_MSB = 2,
+ RPC_LOC_OPER_MODE_MSA = 3,
+ RPC_LOC_OPER_MODE_STANDALONE = 4,
+ RPC_LOC_OPER_MODE_SPEED_OPTIMAL = 5,
+ RPC_LOC_OPER_MODE_ACCURACY_OPTIMAL = 6,
+ RPC_LOC_OPER_MODE_DATA_OPTIMAL = 7,
+ RPC_LOC_OPER_MODE_CELL_ID = 8,
+ RPC_LOC_OPER_MODE_MAX = 268435456,
+};
+typedef enum rpc_loc_operation_mode_e_type rpc_loc_operation_mode_e_type;
+
+enum rpc_loc_notify_e_type {
+ RPC_LOC_NOTIFY_ON_INTERVAL = 1,
+ RPC_LOC_NOTIFY_ON_DISTANCE = 2,
+ RPC_LOC_NOTIFY_ON_ANY = 3,
+ RPC_LOC_NOTIFY_ON_ALL = 4,
+ RPC_LOC_NOTIFY_TYPE_MAX = 268435456,
+};
+typedef enum rpc_loc_notify_e_type rpc_loc_notify_e_type;
+
+struct rpc_loc_fix_criteria_s_type {
+ rpc_uint32 valid_mask;
+ rpc_loc_fix_recurrence_e_type recurrence_type;
+ rpc_loc_operation_mode_e_type preferred_operation_mode;
+ rpc_uint32 preferred_accuracy;
+ rpc_uint32 preferred_response_time;
+ rpc_boolean intermediate_pos_report_enabled;
+ rpc_loc_notify_e_type notify_type;
+ rpc_uint32 min_interval;
+ float min_distance;
+ rpc_uint32 min_dist_sample_interval;
+};
+typedef struct rpc_loc_fix_criteria_s_type rpc_loc_fix_criteria_s_type;
+
+enum rpc_loc_ni_user_resp_e_type {
+ RPC_LOC_NI_LCS_NOTIFY_VERIFY_ACCEPT = 1,
+ RPC_LOC_NI_LCS_NOTIFY_VERIFY_DENY = 2,
+ RPC_LOC_NI_LCS_NOTIFY_VERIFY_NORESP = 3,
+ RPC_LOC_NI_LCS_NOTIFY_VERIFY_MAX = 268435456,
+};
+typedef enum rpc_loc_ni_user_resp_e_type rpc_loc_ni_user_resp_e_type;
+
+struct rpc_loc_user_verify_s_type {
+ rpc_loc_ni_user_resp_e_type user_resp;
+ rpc_loc_ni_event_s_type ni_event_pass_back;
+};
+typedef struct rpc_loc_user_verify_s_type rpc_loc_user_verify_s_type;
+
+enum rpc_loc_predicted_orbits_data_format_e_type {
+ RPC_LOC_PREDICTED_ORBITS_XTRA = 0,
+ RPC_LOC_PREDICTED_ORBITS_FORMAT_MAX = 268435456,
+};
+typedef enum rpc_loc_predicted_orbits_data_format_e_type rpc_loc_predicted_orbits_data_format_e_type;
+
+struct rpc_loc_predicted_orbits_data_s_type {
+ rpc_loc_predicted_orbits_data_format_e_type format_type;
+ rpc_uint32 total_size;
+ rpc_uint8 total_parts;
+ rpc_uint8 part;
+ rpc_uint16 part_len;
+ struct {
+ u_int data_ptr_len;
+ char *data_ptr_val;
+ } data_ptr;
+};
+typedef struct rpc_loc_predicted_orbits_data_s_type rpc_loc_predicted_orbits_data_s_type;
+
+struct rpc_loc_predicted_orbits_data_validity_report_s_type {
+ rpc_uint64 start_time_utc;
+ rpc_uint16 valid_duration_hrs;
+};
+typedef struct rpc_loc_predicted_orbits_data_validity_report_s_type rpc_loc_predicted_orbits_data_validity_report_s_type;
+
+struct rpc_loc_predicted_orbits_auto_download_config_s_type {
+ rpc_boolean enable;
+ u_char auto_check_every_hrs;
+};
+typedef struct rpc_loc_predicted_orbits_auto_download_config_s_type rpc_loc_predicted_orbits_auto_download_config_s_type;
+
+struct rpc_loc_assist_data_time_s_type {
+ rpc_uint64 time_utc;
+ rpc_uint32 uncertainty;
+};
+typedef struct rpc_loc_assist_data_time_s_type rpc_loc_assist_data_time_s_type;
+
+typedef rpc_uint64 rpc_loc_assist_pos_valid_mask_type;
+
+struct rpc_loc_assist_data_pos_s_type {
+ rpc_loc_assist_pos_valid_mask_type valid_mask;
+ rpc_uint64 timestamp_utc;
+ double latitude;
+ double longitude;
+ float altitude_wrt_ellipsoid;
+ float altitude_wrt_mean_sea_level;
+ float hor_unc_circular;
+ float vert_unc;
+ u_char confidence_horizontal;
+ u_char confidence_vertical;
+ rpc_int32 timestamp_age;
+};
+typedef struct rpc_loc_assist_data_pos_s_type rpc_loc_assist_data_pos_s_type;
+
+enum rpc_loc_server_open_status_e_type {
+ RPC_LOC_SERVER_OPEN_SUCCESS = 1,
+ RPC_LOC_SERVER_OPEN_FAIL = 2,
+ RPC_LOC_SERVER_OPEN_STATUS_MAX = 268435456,
+};
+typedef enum rpc_loc_server_open_status_e_type rpc_loc_server_open_status_e_type;
+
+enum rpc_loc_server_pdp_type_e_type {
+ RPC_LOC_SERVER_PDP_IP = 0,
+ RPC_LOC_SERVER_PDP_PPP = 0 + 1,
+ RPC_LOC_SERVER_PDP_IPV6 = 0 + 2,
+ RPC_LOC_SERVER_PDP_IPV4V6 = 0 + 3,
+ RPC_LOC_SERVER_PDP_MAX = 268435456,
+};
+typedef enum rpc_loc_server_pdp_type_e_type rpc_loc_server_pdp_type_e_type;
+
+struct rpc_loc_server_open_status_s_type {
+ rpc_loc_server_connection_handle conn_handle;
+ rpc_loc_server_open_status_e_type open_status;
+ char apn_name[100];
+};
+typedef struct rpc_loc_server_open_status_s_type rpc_loc_server_open_status_s_type;
+
+struct rpc_loc_server_multi_open_status_s_type {
+ rpc_loc_server_connection_handle conn_handle;
+ rpc_loc_server_open_status_e_type open_status;
+ rpc_loc_server_pdp_type_e_type pdp_type;
+ char apn_name[100];
+};
+typedef struct rpc_loc_server_multi_open_status_s_type rpc_loc_server_multi_open_status_s_type;
+
+enum rpc_loc_server_close_status_e_type {
+ RPC_LOC_SERVER_CLOSE_SUCCESS = 1,
+ RPC_LOC_SERVER_CLOSE_FAIL = 2,
+ RPC_LOC_SERVER_CLOSE_STATUS_MAX = 268435456,
+};
+typedef enum rpc_loc_server_close_status_e_type rpc_loc_server_close_status_e_type;
+
+struct rpc_loc_server_close_status_s_type {
+ rpc_loc_server_connection_handle conn_handle;
+ rpc_loc_server_close_status_e_type close_status;
+};
+typedef struct rpc_loc_server_close_status_s_type rpc_loc_server_close_status_s_type;
+
+struct rpc_loc_wiper_fix_time_s_type {
+ rpc_uint32 slow_clock_count;
+};
+typedef struct rpc_loc_wiper_fix_time_s_type rpc_loc_wiper_fix_time_s_type;
+
+struct rpc_loc_wiper_fix_pos_s_type {
+ rpc_int32 lat;
+ rpc_int32 lon;
+ rpc_uint16 HEPE;
+ rpc_uint8 num_of_aps_used;
+ rpc_uint8 fix_error_code;
+};
+typedef struct rpc_loc_wiper_fix_pos_s_type rpc_loc_wiper_fix_pos_s_type;
+
+struct rpc_loc_wiper_ap_info_s_type {
+ char mac_addr[6];
+ rpc_int32 rssi;
+ rpc_uint16 channel;
+ rpc_uint8 ap_qualifier;
+};
+typedef struct rpc_loc_wiper_ap_info_s_type rpc_loc_wiper_ap_info_s_type;
+
+struct rpc_loc_wiper_ap_set_s_type {
+ rpc_uint8 num_of_aps;
+ rpc_loc_wiper_ap_info_s_type ap_info[50];
+};
+typedef struct rpc_loc_wiper_ap_set_s_type rpc_loc_wiper_ap_set_s_type;
+
+struct rpc_loc_wiper_position_report_s_type {
+ rpc_uint8 wiper_valid_info_flag;
+ rpc_loc_wiper_fix_time_s_type wiper_fix_time;
+ rpc_loc_wiper_fix_pos_s_type wiper_fix_position;
+ rpc_loc_wiper_ap_set_s_type wiper_ap_set;
+};
+typedef struct rpc_loc_wiper_position_report_s_type rpc_loc_wiper_position_report_s_type;
+
+enum rpc_loc_wiper_status_e_type {
+ RPC_LOC_WIPER_STATUS_AVAILABLE = 1,
+ RPC_LOC_WIPER_STATUS_UNAVAILABLE = 2,
+ RPC_LOC_WIPER_STATUS_E_SIZE = 268435456,
+};
+typedef enum rpc_loc_wiper_status_e_type rpc_loc_wiper_status_e_type;
+
+enum rpc_loc_fs_operation_e_type {
+ RPC_LOC_FS_CREATE_WRITE_FILE = 1,
+ RPC_LOC_FS_APPEND_FILE = 2,
+ RPC_LOC_FS_DELETE_FILE = 3,
+ RPC_LOC_FS_READ_FILE = 4,
+ RPC_LOC_FS_MAX = 268435456,
+};
+typedef enum rpc_loc_fs_operation_e_type rpc_loc_fs_operation_e_type;
+
+struct rpc_loc_efs_data_s_type {
+ char filename[64];
+ rpc_loc_fs_operation_e_type operation;
+ rpc_uint32 total_size;
+ struct {
+ u_int data_ptr_len;
+ char *data_ptr_val;
+ } data_ptr;
+ rpc_uint32 part_len;
+ rpc_uint8 part;
+ rpc_uint8 total_parts;
+ rpc_uint32 reserved;
+};
+typedef struct rpc_loc_efs_data_s_type rpc_loc_efs_data_s_type;
+
+enum rpc_loc_error_estimate_config_e_type {
+ RPC_LOC_ERROR_ESTIMATE_CONFIG_SET = 1,
+ RPC_LOC_ERROR_ESTIMATE_CONFIG_CLEAR = 2,
+ RPC_LOC_ERROR_ESTIMATE_MAX = 268435456,
+};
+typedef enum rpc_loc_error_estimate_config_e_type rpc_loc_error_estimate_config_e_type;
+
+struct rpc_loc_apn_profiles_type {
+ rpc_uint32 srv_system_type;
+ rpc_uint32 pdp_type;
+ rpc_uint32 reserved;
+ char apn_name[100];
+};
+typedef struct rpc_loc_apn_profiles_type rpc_loc_apn_profiles_type;
+
+enum rpc_loc_lock_e_type {
+ RPC_LOC_LOCK_NONE = 1,
+ RPC_LOC_LOCK_MI = 2,
+ RPC_LOC_LOCK_MT = 3,
+ RPC_LOC_LOCK_ALL = 4,
+ RPC_LOC_LOCK_MAX = 268435456,
+};
+typedef enum rpc_loc_lock_e_type rpc_loc_lock_e_type;
+
+typedef rpc_uint32 rpc_loc_nmea_sentence_type;
+
+typedef rpc_uint32 rpc_loc_assist_data_type;
+
+struct rpc_loc_assist_data_delete_s_type {
+ rpc_loc_assist_data_type type;
+ rpc_uint32 reserved[8];
+};
+typedef struct rpc_loc_assist_data_delete_s_type rpc_loc_assist_data_delete_s_type;
+
+struct rpc_loc_ioctl_data_u_type {
+ rpc_loc_ioctl_e_type disc;
+ union {
+ rpc_loc_fix_criteria_s_type fix_criteria;
+ rpc_loc_user_verify_s_type user_verify_resp;
+ rpc_loc_predicted_orbits_data_s_type predicted_orbits_data;
+ rpc_loc_predicted_orbits_auto_download_config_s_type predicted_orbits_auto_download;
+ rpc_loc_assist_data_time_s_type assistance_data_time;
+ rpc_loc_assist_data_pos_s_type assistance_data_position;
+ rpc_loc_server_open_status_s_type conn_open_status;
+ rpc_loc_server_close_status_s_type conn_close_status;
+ rpc_loc_wiper_position_report_s_type wiper_pos;
+ rpc_loc_wiper_status_e_type wiper_status;
+ rpc_loc_lock_e_type engine_lock;
+ rpc_boolean sbas_mode;
+ rpc_loc_nmea_sentence_type nmea_types;
+ rpc_boolean on_demand_lpm;
+ rpc_loc_server_info_s_type server_addr;
+ rpc_loc_assist_data_delete_s_type assist_data_delete;
+ rpc_loc_efs_data_s_type efs_data;
+ rpc_loc_error_estimate_config_e_type error_estimate_config;
+ rpc_uint8 xtra_t_session_control;
+ rpc_loc_apn_profiles_type apn_profiles[6];
+ rpc_boolean data_enable;
+ rpc_uint32 supl_version;
+ rpc_loc_server_multi_open_status_s_type multi_conn_open_status;
+ rpc_loc_reserved_payload_s_type reserved;
+ } rpc_loc_ioctl_data_u_type_u;
+};
+typedef struct rpc_loc_ioctl_data_u_type rpc_loc_ioctl_data_u_type;
+
+struct rpc_loc_ioctl_callback_data_u_type {
+ rpc_loc_ioctl_e_type disc;
+ union {
+ rpc_loc_api_version_s_type api_version;
+ rpc_loc_fix_criteria_s_type fix_criteria;
+ rpc_loc_lock_e_type engine_lock;
+ rpc_boolean sbas_mode;
+ rpc_loc_nmea_sentence_type nmea_types;
+ rpc_boolean on_demand_lpm;
+ rpc_loc_server_info_s_type server_addr;
+ rpc_loc_predicted_orbits_data_source_s_type predicted_orbits_data_source;
+ rpc_loc_predicted_orbits_data_validity_report_s_type predicted_orbits_data_validity;
+ rpc_uint8 xtra_t_session_control;
+ rpc_loc_apn_profiles_type apn_profiles[6];
+ rpc_uint32 supl_version;
+ } rpc_loc_ioctl_callback_data_u_type_u;
+};
+typedef struct rpc_loc_ioctl_callback_data_u_type rpc_loc_ioctl_callback_data_u_type;
+
+struct rpc_loc_ioctl_callback_s_type {
+ rpc_loc_ioctl_e_type type;
+ rpc_int32 status;
+ rpc_loc_ioctl_callback_data_u_type data;
+};
+typedef struct rpc_loc_ioctl_callback_s_type rpc_loc_ioctl_callback_s_type;
+
+struct rpc_loc_event_payload_u_type {
+ u_quad_t disc;
+ union {
+ rpc_loc_parsed_position_s_type parsed_location_report;
+ rpc_loc_gnss_info_s_type gnss_report;
+ rpc_loc_nmea_report_s_type nmea_report;
+ rpc_loc_ni_event_s_type ni_request;
+ rpc_loc_assist_data_request_s_type assist_data_request;
+ rpc_loc_server_request_s_type loc_server_request;
+ rpc_loc_ioctl_callback_s_type ioctl_report;
+ rpc_loc_status_event_s_type status_report;
+ rpc_loc_qwip_request_s_type qwip_request;
+ rpc_loc_reserved_payload_s_type reserved;
+ } rpc_loc_event_payload_u_type_u;
+};
+typedef struct rpc_loc_event_payload_u_type rpc_loc_event_payload_u_type;
+
+/* the xdr functions */
+
+#if defined(__STDC__) || defined(__cplusplus)
+extern bool_t xdr_rpc_loc_client_handle_type (XDR *, rpc_loc_client_handle_type*);
+extern bool_t xdr_rpc_loc_event_mask_type (XDR *, rpc_loc_event_mask_type*);
+extern bool_t xdr_rpc_loc_position_valid_mask_type (XDR *, rpc_loc_position_valid_mask_type*);
+extern bool_t xdr_rpc_loc_pos_technology_mask_type (XDR *, rpc_loc_pos_technology_mask_type*);
+extern bool_t xdr_rpc_loc_session_status_e_type (XDR *, rpc_loc_session_status_e_type*);
+extern bool_t xdr_rpc_loc_calendar_time_s_type (XDR *, rpc_loc_calendar_time_s_type*);
+extern bool_t xdr_rpc_loc_parsed_position_s_type (XDR *, rpc_loc_parsed_position_s_type*);
+extern bool_t xdr_rpc_loc_sv_system_e_type (XDR *, rpc_loc_sv_system_e_type*);
+extern bool_t xdr_rpc_loc_sv_status_e_type (XDR *, rpc_loc_sv_status_e_type*);
+extern bool_t xdr_rpc_loc_sv_info_valid_mask_type (XDR *, rpc_loc_sv_info_valid_mask_type*);
+extern bool_t xdr_rpc_loc_sv_info_s_type (XDR *, rpc_loc_sv_info_s_type*);
+extern bool_t xdr_rpc_loc_gnss_info_valid_mask_type (XDR *, rpc_loc_gnss_info_valid_mask_type*);
+extern bool_t xdr_rpc_loc_gnss_info_s_type (XDR *, rpc_loc_gnss_info_s_type*);
+extern bool_t xdr_rpc_loc_nmea_report_s_type (XDR *, rpc_loc_nmea_report_s_type*);
+extern bool_t xdr_rpc_loc_status_event_e_type (XDR *, rpc_loc_status_event_e_type*);
+extern bool_t xdr_rpc_loc_engine_state_e_type (XDR *, rpc_loc_engine_state_e_type*);
+extern bool_t xdr_rpc_loc_fix_session_state_e_type (XDR *, rpc_loc_fix_session_state_e_type*);
+extern bool_t xdr_rpc_loc_status_event_payload_u_type (XDR *, rpc_loc_status_event_payload_u_type*);
+extern bool_t xdr_rpc_loc_status_event_s_type (XDR *, rpc_loc_status_event_s_type*);
+extern bool_t xdr_rpc_loc_server_addr_e_type (XDR *, rpc_loc_server_addr_e_type*);
+extern bool_t xdr_rpc_loc_server_addr_ipv4_type (XDR *, rpc_loc_server_addr_ipv4_type*);
+extern bool_t xdr_rpc_loc_server_addr_url_type (XDR *, rpc_loc_server_addr_url_type*);
+extern bool_t xdr_rpc_loc_server_addr_ipv6_type (XDR *, rpc_loc_server_addr_ipv6_type*);
+extern bool_t xdr_rpc_loc_server_addr_u_type (XDR *, rpc_loc_server_addr_u_type*);
+extern bool_t xdr_rpc_loc_server_info_s_type (XDR *, rpc_loc_server_info_s_type*);
+extern bool_t xdr_rpc_loc_ni_notify_verify_e_type (XDR *, rpc_loc_ni_notify_verify_e_type*);
+extern bool_t xdr_rpc_loc_ni_event_e_type (XDR *, rpc_loc_ni_event_e_type*);
+extern bool_t xdr_rpc_loc_ni_datacoding_scheme_e_type (XDR *, rpc_loc_ni_datacoding_scheme_e_type*);
+extern bool_t xdr_rpc_loc_ni_vx_requester_id_encoding_scheme_e_type (XDR *, rpc_loc_ni_vx_requester_id_encoding_scheme_e_type*);
+extern bool_t xdr_rpc_loc_ni_vx_pos_mode_e_type (XDR *, rpc_loc_ni_vx_pos_mode_e_type*);
+extern bool_t xdr_rpc_loc_ni_vx_requester_id_s_type (XDR *, rpc_loc_ni_vx_requester_id_s_type*);
+extern bool_t xdr_rpc_loc_ni_vx_notify_verify_req_s_type (XDR *, rpc_loc_ni_vx_notify_verify_req_s_type*);
+extern bool_t xdr_rpc_loc_ni_supl_pos_method_e_type (XDR *, rpc_loc_ni_supl_pos_method_e_type*);
+extern bool_t xdr_rpc_loc_ni_supl_slp_session_id_s_type (XDR *, rpc_loc_ni_supl_slp_session_id_s_type*);
+extern bool_t xdr_rpc_loc_ni_requestor_id_s_type (XDR *, rpc_loc_ni_requestor_id_s_type*);
+extern bool_t xdr_rpc_loc_ni_supl_client_name_s_type (XDR *, rpc_loc_ni_supl_client_name_s_type*);
+extern bool_t xdr_rpc_loc_ni_supl_qop_s_type (XDR *, rpc_loc_ni_supl_qop_s_type*);
+extern bool_t xdr_rpc_loc_ni_supl_notify_verify_req_s_type (XDR *, rpc_loc_ni_supl_notify_verify_req_s_type*);
+extern bool_t xdr_rpc_loc_ni_ext_client_address_s_type (XDR *, rpc_loc_ni_ext_client_address_s_type*);
+extern bool_t xdr_rpc_loc_ni_location_type_e_type (XDR *, rpc_loc_ni_location_type_e_type*);
+extern bool_t xdr_rpc_loc_ni_deferred_location_s_type (XDR *, rpc_loc_ni_deferred_location_s_type*);
+extern bool_t xdr_rpc_loc_ni_codeword_string_s_type (XDR *, rpc_loc_ni_codeword_string_s_type*);
+extern bool_t xdr_rpc_loc_ni_service_type_id_s_type (XDR *, rpc_loc_ni_service_type_id_s_type*);
+extern bool_t xdr_rpc_loc_ni_umts_cp_notify_verify_req_s_type (XDR *, rpc_loc_ni_umts_cp_notify_verify_req_s_type*);
+extern bool_t xdr_rpc_loc_ni_service_interaction_e_type (XDR *, rpc_loc_ni_service_interaction_e_type*);
+extern bool_t xdr_rpc_loc_ni_vx_service_interaction_req_s_type (XDR *, rpc_loc_ni_vx_service_interaction_req_s_type*);
+extern bool_t xdr_rpc_loc_ni_event_payload_u_type (XDR *, rpc_loc_ni_event_payload_u_type*);
+extern bool_t xdr_rpc_loc_ni_event_s_type (XDR *, rpc_loc_ni_event_s_type*);
+extern bool_t xdr_rpc_loc_assist_data_request_e_type (XDR *, rpc_loc_assist_data_request_e_type*);
+extern bool_t xdr_rpc_struct_loc_time_download_source_s_type_servers_ptr (XDR *, rpc_struct_loc_time_download_source_s_type_servers_ptr*);
+extern bool_t xdr_rpc_struct_loc_time_download_source_s_type_servers (XDR *, rpc_struct_loc_time_download_source_s_type_servers);
+extern bool_t xdr_rpc_loc_time_download_source_s_type (XDR *, rpc_loc_time_download_source_s_type*);
+extern bool_t xdr_rpc_struct_loc_predicted_orbits_data_source_s_type_servers_ptr (XDR *, rpc_struct_loc_predicted_orbits_data_source_s_type_servers_ptr*);
+extern bool_t xdr_rpc_struct_loc_predicted_orbits_data_source_s_type_servers (XDR *, rpc_struct_loc_predicted_orbits_data_source_s_type_servers);
+extern bool_t xdr_rpc_loc_predicted_orbits_data_source_s_type (XDR *, rpc_loc_predicted_orbits_data_source_s_type*);
+extern bool_t xdr_rpc_loc_pos_inj_request_s_type (XDR *, rpc_loc_pos_inj_request_s_type*);
+extern bool_t xdr_rpc_loc_assist_data_request_payload_u_type (XDR *, rpc_loc_assist_data_request_payload_u_type*);
+extern bool_t xdr_rpc_loc_assist_data_request_s_type (XDR *, rpc_loc_assist_data_request_s_type*);
+extern bool_t xdr_rpc_loc_server_connection_handle (XDR *, rpc_loc_server_connection_handle*);
+extern bool_t xdr_rpc_loc_server_protocol_e_type (XDR *, rpc_loc_server_protocol_e_type*);
+extern bool_t xdr_rpc_loc_server_connection_e_type (XDR *, rpc_loc_server_connection_e_type*);
+extern bool_t xdr_rpc_loc_server_request_e_type (XDR *, rpc_loc_server_request_e_type*);
+extern bool_t xdr_rpc_loc_server_open_req_s_type (XDR *, rpc_loc_server_open_req_s_type*);
+extern bool_t xdr_rpc_loc_server_multi_open_req_s_type (XDR *, rpc_loc_server_multi_open_req_s_type*);
+extern bool_t xdr_rpc_loc_server_close_req_s_type (XDR *, rpc_loc_server_close_req_s_type*);
+extern bool_t xdr_rpc_loc_server_request_u_type (XDR *, rpc_loc_server_request_u_type*);
+extern bool_t xdr_rpc_loc_server_request_s_type (XDR *, rpc_loc_server_request_s_type*);
+extern bool_t xdr_rpc_loc_qwip_request_e_type (XDR *, rpc_loc_qwip_request_e_type*);
+extern bool_t xdr_rpc_loc_qwip_request_s_type (XDR *, rpc_loc_qwip_request_s_type*);
+extern bool_t xdr_rpc_loc_reserved_payload_s_type (XDR *, rpc_loc_reserved_payload_s_type*);
+extern bool_t xdr_rpc_loc_ioctl_e_type (XDR *, rpc_loc_ioctl_e_type*);
+extern bool_t xdr_rpc_loc_api_version_s_type (XDR *, rpc_loc_api_version_s_type*);
+extern bool_t xdr_rpc_loc_fix_recurrence_e_type (XDR *, rpc_loc_fix_recurrence_e_type*);
+extern bool_t xdr_rpc_loc_operation_mode_e_type (XDR *, rpc_loc_operation_mode_e_type*);
+extern bool_t xdr_rpc_loc_notify_e_type (XDR *, rpc_loc_notify_e_type*);
+extern bool_t xdr_rpc_loc_fix_criteria_s_type (XDR *, rpc_loc_fix_criteria_s_type*);
+extern bool_t xdr_rpc_loc_ni_user_resp_e_type (XDR *, rpc_loc_ni_user_resp_e_type*);
+extern bool_t xdr_rpc_loc_user_verify_s_type (XDR *, rpc_loc_user_verify_s_type*);
+extern bool_t xdr_rpc_loc_predicted_orbits_data_format_e_type (XDR *, rpc_loc_predicted_orbits_data_format_e_type*);
+extern bool_t xdr_rpc_loc_predicted_orbits_data_s_type (XDR *, rpc_loc_predicted_orbits_data_s_type*);
+extern bool_t xdr_rpc_loc_predicted_orbits_data_validity_report_s_type (XDR *, rpc_loc_predicted_orbits_data_validity_report_s_type*);
+extern bool_t xdr_rpc_loc_predicted_orbits_auto_download_config_s_type (XDR *, rpc_loc_predicted_orbits_auto_download_config_s_type*);
+extern bool_t xdr_rpc_loc_assist_data_time_s_type (XDR *, rpc_loc_assist_data_time_s_type*);
+extern bool_t xdr_rpc_loc_assist_pos_valid_mask_type (XDR *, rpc_loc_assist_pos_valid_mask_type*);
+extern bool_t xdr_rpc_loc_assist_data_pos_s_type (XDR *, rpc_loc_assist_data_pos_s_type*);
+extern bool_t xdr_rpc_loc_server_open_status_e_type (XDR *, rpc_loc_server_open_status_e_type*);
+extern bool_t xdr_rpc_loc_server_pdp_type_e_type (XDR *, rpc_loc_server_pdp_type_e_type*);
+extern bool_t xdr_rpc_loc_server_open_status_s_type (XDR *, rpc_loc_server_open_status_s_type*);
+extern bool_t xdr_rpc_loc_server_multi_open_status_s_type (XDR *, rpc_loc_server_multi_open_status_s_type*);
+extern bool_t xdr_rpc_loc_server_close_status_e_type (XDR *, rpc_loc_server_close_status_e_type*);
+extern bool_t xdr_rpc_loc_server_close_status_s_type (XDR *, rpc_loc_server_close_status_s_type*);
+extern bool_t xdr_rpc_loc_wiper_fix_time_s_type (XDR *, rpc_loc_wiper_fix_time_s_type*);
+extern bool_t xdr_rpc_loc_wiper_fix_pos_s_type (XDR *, rpc_loc_wiper_fix_pos_s_type*);
+extern bool_t xdr_rpc_loc_wiper_ap_info_s_type (XDR *, rpc_loc_wiper_ap_info_s_type*);
+extern bool_t xdr_rpc_loc_wiper_ap_set_s_type (XDR *, rpc_loc_wiper_ap_set_s_type*);
+extern bool_t xdr_rpc_loc_wiper_position_report_s_type (XDR *, rpc_loc_wiper_position_report_s_type*);
+extern bool_t xdr_rpc_loc_wiper_status_e_type (XDR *, rpc_loc_wiper_status_e_type*);
+extern bool_t xdr_rpc_loc_fs_operation_e_type (XDR *, rpc_loc_fs_operation_e_type*);
+extern bool_t xdr_rpc_loc_efs_data_s_type (XDR *, rpc_loc_efs_data_s_type*);
+extern bool_t xdr_rpc_loc_error_estimate_config_e_type (XDR *, rpc_loc_error_estimate_config_e_type*);
+extern bool_t xdr_rpc_loc_apn_profiles_type (XDR *, rpc_loc_apn_profiles_type*);
+extern bool_t xdr_rpc_loc_lock_e_type (XDR *, rpc_loc_lock_e_type*);
+extern bool_t xdr_rpc_loc_nmea_sentence_type (XDR *, rpc_loc_nmea_sentence_type*);
+extern bool_t xdr_rpc_loc_assist_data_type (XDR *, rpc_loc_assist_data_type*);
+extern bool_t xdr_rpc_loc_assist_data_delete_s_type (XDR *, rpc_loc_assist_data_delete_s_type*);
+extern bool_t xdr_rpc_loc_ioctl_data_u_type (XDR *, rpc_loc_ioctl_data_u_type*);
+extern bool_t xdr_rpc_loc_ioctl_callback_data_u_type (XDR *, rpc_loc_ioctl_callback_data_u_type*);
+extern bool_t xdr_rpc_loc_ioctl_callback_s_type (XDR *, rpc_loc_ioctl_callback_s_type*);
+extern bool_t xdr_rpc_loc_event_payload_u_type (XDR *, rpc_loc_event_payload_u_type*);
+
+#else /* K&R C */
+extern bool_t xdr_rpc_loc_client_handle_type ();
+extern bool_t xdr_rpc_loc_event_mask_type ();
+extern bool_t xdr_rpc_loc_position_valid_mask_type ();
+extern bool_t xdr_rpc_loc_pos_technology_mask_type ();
+extern bool_t xdr_rpc_loc_session_status_e_type ();
+extern bool_t xdr_rpc_loc_calendar_time_s_type ();
+extern bool_t xdr_rpc_loc_parsed_position_s_type ();
+extern bool_t xdr_rpc_loc_sv_system_e_type ();
+extern bool_t xdr_rpc_loc_sv_status_e_type ();
+extern bool_t xdr_rpc_loc_sv_info_valid_mask_type ();
+extern bool_t xdr_rpc_loc_sv_info_s_type ();
+extern bool_t xdr_rpc_loc_gnss_info_valid_mask_type ();
+extern bool_t xdr_rpc_loc_gnss_info_s_type ();
+extern bool_t xdr_rpc_loc_nmea_report_s_type ();
+extern bool_t xdr_rpc_loc_status_event_e_type ();
+extern bool_t xdr_rpc_loc_engine_state_e_type ();
+extern bool_t xdr_rpc_loc_fix_session_state_e_type ();
+extern bool_t xdr_rpc_loc_status_event_payload_u_type ();
+extern bool_t xdr_rpc_loc_status_event_s_type ();
+extern bool_t xdr_rpc_loc_server_addr_e_type ();
+extern bool_t xdr_rpc_loc_server_addr_ipv4_type ();
+extern bool_t xdr_rpc_loc_server_addr_url_type ();
+extern bool_t xdr_rpc_loc_server_addr_ipv6_type ();
+extern bool_t xdr_rpc_loc_server_addr_u_type ();
+extern bool_t xdr_rpc_loc_server_info_s_type ();
+extern bool_t xdr_rpc_loc_ni_notify_verify_e_type ();
+extern bool_t xdr_rpc_loc_ni_event_e_type ();
+extern bool_t xdr_rpc_loc_ni_datacoding_scheme_e_type ();
+extern bool_t xdr_rpc_loc_ni_vx_requester_id_encoding_scheme_e_type ();
+extern bool_t xdr_rpc_loc_ni_vx_pos_mode_e_type ();
+extern bool_t xdr_rpc_loc_ni_vx_requester_id_s_type ();
+extern bool_t xdr_rpc_loc_ni_vx_notify_verify_req_s_type ();
+extern bool_t xdr_rpc_loc_ni_supl_pos_method_e_type ();
+extern bool_t xdr_rpc_loc_ni_supl_slp_session_id_s_type ();
+extern bool_t xdr_rpc_loc_ni_requestor_id_s_type ();
+extern bool_t xdr_rpc_loc_ni_supl_client_name_s_type ();
+extern bool_t xdr_rpc_loc_ni_supl_qop_s_type ();
+extern bool_t xdr_rpc_loc_ni_supl_notify_verify_req_s_type ();
+extern bool_t xdr_rpc_loc_ni_ext_client_address_s_type ();
+extern bool_t xdr_rpc_loc_ni_location_type_e_type ();
+extern bool_t xdr_rpc_loc_ni_deferred_location_s_type ();
+extern bool_t xdr_rpc_loc_ni_codeword_string_s_type ();
+extern bool_t xdr_rpc_loc_ni_service_type_id_s_type ();
+extern bool_t xdr_rpc_loc_ni_umts_cp_notify_verify_req_s_type ();
+extern bool_t xdr_rpc_loc_ni_service_interaction_e_type ();
+extern bool_t xdr_rpc_loc_ni_vx_service_interaction_req_s_type ();
+extern bool_t xdr_rpc_loc_ni_event_payload_u_type ();
+extern bool_t xdr_rpc_loc_ni_event_s_type ();
+extern bool_t xdr_rpc_loc_assist_data_request_e_type ();
+extern bool_t xdr_rpc_struct_loc_time_download_source_s_type_servers_ptr ();
+extern bool_t xdr_rpc_struct_loc_time_download_source_s_type_servers ();
+extern bool_t xdr_rpc_loc_time_download_source_s_type ();
+extern bool_t xdr_rpc_struct_loc_predicted_orbits_data_source_s_type_servers_ptr ();
+extern bool_t xdr_rpc_struct_loc_predicted_orbits_data_source_s_type_servers ();
+extern bool_t xdr_rpc_loc_predicted_orbits_data_source_s_type ();
+extern bool_t xdr_rpc_loc_pos_inj_request_s_type ();
+extern bool_t xdr_rpc_loc_assist_data_request_payload_u_type ();
+extern bool_t xdr_rpc_loc_assist_data_request_s_type ();
+extern bool_t xdr_rpc_loc_server_connection_handle ();
+extern bool_t xdr_rpc_loc_server_protocol_e_type ();
+extern bool_t xdr_rpc_loc_server_connection_e_type ();
+extern bool_t xdr_rpc_loc_server_request_e_type ();
+extern bool_t xdr_rpc_loc_server_open_req_s_type ();
+extern bool_t xdr_rpc_loc_server_multi_open_req_s_type ();
+extern bool_t xdr_rpc_loc_server_close_req_s_type ();
+extern bool_t xdr_rpc_loc_server_request_u_type ();
+extern bool_t xdr_rpc_loc_server_request_s_type ();
+extern bool_t xdr_rpc_loc_qwip_request_e_type ();
+extern bool_t xdr_rpc_loc_qwip_request_s_type ();
+extern bool_t xdr_rpc_loc_reserved_payload_s_type ();
+extern bool_t xdr_rpc_loc_ioctl_e_type ();
+extern bool_t xdr_rpc_loc_api_version_s_type ();
+extern bool_t xdr_rpc_loc_fix_recurrence_e_type ();
+extern bool_t xdr_rpc_loc_operation_mode_e_type ();
+extern bool_t xdr_rpc_loc_notify_e_type ();
+extern bool_t xdr_rpc_loc_fix_criteria_s_type ();
+extern bool_t xdr_rpc_loc_ni_user_resp_e_type ();
+extern bool_t xdr_rpc_loc_user_verify_s_type ();
+extern bool_t xdr_rpc_loc_predicted_orbits_data_format_e_type ();
+extern bool_t xdr_rpc_loc_predicted_orbits_data_s_type ();
+extern bool_t xdr_rpc_loc_predicted_orbits_data_validity_report_s_type ();
+extern bool_t xdr_rpc_loc_predicted_orbits_auto_download_config_s_type ();
+extern bool_t xdr_rpc_loc_assist_data_time_s_type ();
+extern bool_t xdr_rpc_loc_assist_pos_valid_mask_type ();
+extern bool_t xdr_rpc_loc_assist_data_pos_s_type ();
+extern bool_t xdr_rpc_loc_server_open_status_e_type ();
+extern bool_t xdr_rpc_loc_server_pdp_type_e_type ();
+extern bool_t xdr_rpc_loc_server_open_status_s_type ();
+extern bool_t xdr_rpc_loc_server_multi_open_status_s_type ();
+extern bool_t xdr_rpc_loc_server_close_status_e_type ();
+extern bool_t xdr_rpc_loc_server_close_status_s_type ();
+extern bool_t xdr_rpc_loc_wiper_fix_time_s_type ();
+extern bool_t xdr_rpc_loc_wiper_fix_pos_s_type ();
+extern bool_t xdr_rpc_loc_wiper_ap_info_s_type ();
+extern bool_t xdr_rpc_loc_wiper_ap_set_s_type ();
+extern bool_t xdr_rpc_loc_wiper_position_report_s_type ();
+extern bool_t xdr_rpc_loc_wiper_status_e_type ();
+extern bool_t xdr_rpc_loc_fs_operation_e_type ();
+extern bool_t xdr_rpc_loc_efs_data_s_type ();
+extern bool_t xdr_rpc_loc_error_estimate_config_e_type ();
+extern bool_t xdr_rpc_loc_apn_profiles_type ();
+extern bool_t xdr_rpc_loc_lock_e_type ();
+extern bool_t xdr_rpc_loc_nmea_sentence_type ();
+extern bool_t xdr_rpc_loc_assist_data_type ();
+extern bool_t xdr_rpc_loc_assist_data_delete_s_type ();
+extern bool_t xdr_rpc_loc_ioctl_data_u_type ();
+extern bool_t xdr_rpc_loc_ioctl_callback_data_u_type ();
+extern bool_t xdr_rpc_loc_ioctl_callback_s_type ();
+extern bool_t xdr_rpc_loc_event_payload_u_type ();
+
+#endif /* K&R C */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* !_LOC_API_COMMON_RPC_H_RPCGEN */
diff --git a/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/inc/loc_api_rpcgen_rpc.h b/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/inc/loc_api_rpcgen_rpc.h
new file mode 100644
index 0000000..6138432
--- /dev/null
+++ b/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/inc/loc_api_rpcgen_rpc.h
@@ -0,0 +1,288 @@
+/* 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
+ * 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.
+ *
+ */
+/*
+ * Please do not edit this file.
+ * It was generated using rpcgen.
+ */
+
+#ifndef _LOC_API_RPC_H_RPCGEN
+#define _LOC_API_RPC_H_RPCGEN
+
+#include "librpc.h"
+#include "commondefs_rpcgen_rpc.h"
+#include "loc_api_rpcgen_common_rpc.h"
+
+#include <pthread.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+typedef struct {
+ u_int rpc_loc_api_api_versions_return_type_len;
+ rpc_uint32 *rpc_loc_api_api_versions_return_type_val;
+} rpc_loc_api_api_versions_return_type;
+
+typedef rpc_uint32 rpc_loc_event_cb_f_type;
+
+struct rpc_loc_open_args {
+ rpc_loc_event_mask_type event_reg_mask;
+ rpc_loc_event_cb_f_type event_callback;
+};
+typedef struct rpc_loc_open_args rpc_loc_open_args;
+
+struct rpc_loc_close_args {
+ rpc_loc_client_handle_type handle;
+};
+typedef struct rpc_loc_close_args rpc_loc_close_args;
+
+struct rpc_loc_start_fix_args {
+ rpc_loc_client_handle_type handle;
+};
+typedef struct rpc_loc_start_fix_args rpc_loc_start_fix_args;
+
+struct rpc_loc_stop_fix_args {
+ rpc_loc_client_handle_type handle;
+};
+typedef struct rpc_loc_stop_fix_args rpc_loc_stop_fix_args;
+
+struct rpc_loc_ioctl_args {
+ rpc_loc_client_handle_type handle;
+ rpc_loc_ioctl_e_type ioctl_type;
+ rpc_loc_ioctl_data_u_type *ioctl_data;
+};
+typedef struct rpc_loc_ioctl_args rpc_loc_ioctl_args;
+
+struct rpc_loc_api_api_version_s_args {
+ rpc_boolean len_not_null;
+};
+typedef struct rpc_loc_api_api_version_s_args rpc_loc_api_api_version_s_args;
+
+struct rpc_loc_api_rpc_glue_code_info_remote_rets {
+ rpc_uint32 toolvers;
+ rpc_uint32 features;
+ rpc_uint32 proghash;
+ rpc_uint32 cbproghash;
+};
+typedef struct rpc_loc_api_rpc_glue_code_info_remote_rets rpc_loc_api_rpc_glue_code_info_remote_rets;
+
+struct rpc_loc_open_rets {
+ rpc_loc_client_handle_type loc_open_result;
+};
+typedef struct rpc_loc_open_rets rpc_loc_open_rets;
+
+struct rpc_loc_close_rets {
+ rpc_int32 loc_close_result;
+};
+typedef struct rpc_loc_close_rets rpc_loc_close_rets;
+
+struct rpc_loc_start_fix_rets {
+ rpc_int32 loc_start_fix_result;
+};
+typedef struct rpc_loc_start_fix_rets rpc_loc_start_fix_rets;
+
+struct rpc_loc_stop_fix_rets {
+ rpc_int32 loc_stop_fix_result;
+};
+typedef struct rpc_loc_stop_fix_rets rpc_loc_stop_fix_rets;
+
+struct rpc_loc_ioctl_rets {
+ rpc_int32 loc_ioctl_result;
+};
+typedef struct rpc_loc_ioctl_rets rpc_loc_ioctl_rets;
+
+struct rpc_loc_api_api_versions_rets {
+ rpc_loc_api_api_versions_return_type loc_api_api_versions_result;
+ rpc_uint32 *len;
+};
+typedef struct rpc_loc_api_api_versions_rets rpc_loc_api_api_versions_rets;
+#define LOC_APIVERS 0x00050006
+
+#define LOC_APIPROG 0x3000008C
+#define LOC_APIVERS_0001 0x00050001
+
+#if defined(__STDC__) || defined(__cplusplus)
+#define rpc_loc_api_null 0
+extern enum clnt_stat rpc_loc_api_null_0x00050001(void *, void *, CLIENT *);
+extern bool_t rpc_loc_api_null_0x00050001_svc(void *, void *, struct svc_req *);
+#define rpc_loc_api_rpc_glue_code_info_remote 1
+extern enum clnt_stat rpc_loc_api_rpc_glue_code_info_remote_0x00050001(void *, rpc_loc_api_rpc_glue_code_info_remote_rets *, CLIENT *);
+extern bool_t rpc_loc_api_rpc_glue_code_info_remote_0x00050001_svc(void *, rpc_loc_api_rpc_glue_code_info_remote_rets *, struct svc_req *);
+#define rpc_loc_open 2
+extern enum clnt_stat rpc_loc_open_0x00050001(rpc_loc_open_args *, rpc_loc_open_rets *, CLIENT *);
+extern bool_t rpc_loc_open_0x00050001_svc(rpc_loc_open_args *, rpc_loc_open_rets *, struct svc_req *);
+#define rpc_loc_close 3
+extern enum clnt_stat rpc_loc_close_0x00050001(rpc_loc_close_args *, rpc_loc_close_rets *, CLIENT *);
+extern bool_t rpc_loc_close_0x00050001_svc(rpc_loc_close_args *, rpc_loc_close_rets *, struct svc_req *);
+#define rpc_loc_start_fix 4
+extern enum clnt_stat rpc_loc_start_fix_0x00050001(rpc_loc_start_fix_args *, rpc_loc_start_fix_rets *, CLIENT *);
+extern bool_t rpc_loc_start_fix_0x00050001_svc(rpc_loc_start_fix_args *, rpc_loc_start_fix_rets *, struct svc_req *);
+#define rpc_loc_stop_fix 5
+extern enum clnt_stat rpc_loc_stop_fix_0x00050001(rpc_loc_stop_fix_args *, rpc_loc_stop_fix_rets *, CLIENT *);
+extern bool_t rpc_loc_stop_fix_0x00050001_svc(rpc_loc_stop_fix_args *, rpc_loc_stop_fix_rets *, struct svc_req *);
+#define rpc_loc_ioctl 6
+extern enum clnt_stat rpc_loc_ioctl_0x00050001(rpc_loc_ioctl_args *, rpc_loc_ioctl_rets *, CLIENT *);
+extern bool_t rpc_loc_ioctl_0x00050001_svc(rpc_loc_ioctl_args *, rpc_loc_ioctl_rets *, struct svc_req *);
+#define rpc_loc_api_api_versions 0xFFFFFFFF
+extern enum clnt_stat rpc_loc_api_api_versions_0x00050001(void *, rpc_loc_api_api_versions_rets *, CLIENT *);
+extern bool_t rpc_loc_api_api_versions_0x00050001_svc(void *, rpc_loc_api_api_versions_rets *, struct svc_req *);
+extern int loc_apiprog_0x00050001_freeresult (SVCXPRT *, xdrproc_t, caddr_t);
+
+#else /* K&R C */
+#define rpc_loc_api_null 0
+extern enum clnt_stat rpc_loc_api_null_0x00050001();
+extern bool_t rpc_loc_api_null_0x00050001_svc();
+#define rpc_loc_api_rpc_glue_code_info_remote 1
+extern enum clnt_stat rpc_loc_api_rpc_glue_code_info_remote_0x00050001();
+extern bool_t rpc_loc_api_rpc_glue_code_info_remote_0x00050001_svc();
+#define rpc_loc_open 2
+extern enum clnt_stat rpc_loc_open_0x00050001();
+extern bool_t rpc_loc_open_0x00050001_svc();
+#define rpc_loc_close 3
+extern enum clnt_stat rpc_loc_close_0x00050001();
+extern bool_t rpc_loc_close_0x00050001_svc();
+#define rpc_loc_start_fix 4
+extern enum clnt_stat rpc_loc_start_fix_0x00050001();
+extern bool_t rpc_loc_start_fix_0x00050001_svc();
+#define rpc_loc_stop_fix 5
+extern enum clnt_stat rpc_loc_stop_fix_0x00050001();
+extern bool_t rpc_loc_stop_fix_0x00050001_svc();
+#define rpc_loc_ioctl 6
+extern enum clnt_stat rpc_loc_ioctl_0x00050001();
+extern bool_t rpc_loc_ioctl_0x00050001_svc();
+#define rpc_loc_api_api_versions 0xFFFFFFFF
+extern enum clnt_stat rpc_loc_api_api_versions_0x00050001();
+extern bool_t rpc_loc_api_api_versions_0x00050001_svc();
+extern int loc_apiprog_0x00050001_freeresult ();
+#endif /* K&R C */
+#define LOC_APIVERS_0002 0x00050002
+
+#if defined(__STDC__) || defined(__cplusplus)
+extern enum clnt_stat rpc_loc_api_null_0x00050002(void *, void *, CLIENT *);
+extern bool_t rpc_loc_api_null_0x00050002_svc(void *, void *, struct svc_req *);
+extern int loc_apiprog_0x00050002_freeresult (SVCXPRT *, xdrproc_t, caddr_t);
+
+#else /* K&R C */
+extern enum clnt_stat rpc_loc_api_null_0x00050002();
+extern bool_t rpc_loc_api_null_0x00050002_svc();
+extern int loc_apiprog_0x00050002_freeresult ();
+#endif /* K&R C */
+#define LOC_APIVERS_0003 0x00050003
+
+#if defined(__STDC__) || defined(__cplusplus)
+extern enum clnt_stat rpc_loc_api_null_0x00050003(void *, void *, CLIENT *);
+extern bool_t rpc_loc_api_null_0x00050003_svc(void *, void *, struct svc_req *);
+extern int loc_apiprog_0x00050003_freeresult (SVCXPRT *, xdrproc_t, caddr_t);
+
+#else /* K&R C */
+extern enum clnt_stat rpc_loc_api_null_0x00050003();
+extern bool_t rpc_loc_api_null_0x00050003_svc();
+extern int loc_apiprog_0x00050003_freeresult ();
+#endif /* K&R C */
+#define LOC_APIVERS_0004 0x00050004
+
+#if defined(__STDC__) || defined(__cplusplus)
+extern enum clnt_stat rpc_loc_api_null_0x00050004(void *, void *, CLIENT *);
+extern bool_t rpc_loc_api_null_0x00050004_svc(void *, void *, struct svc_req *);
+extern int loc_apiprog_0x00050004_freeresult (SVCXPRT *, xdrproc_t, caddr_t);
+
+#else /* K&R C */
+extern enum clnt_stat rpc_loc_api_null_0x00050004();
+extern bool_t rpc_loc_api_null_0x00050004_svc();
+extern int loc_apiprog_0x00050004_freeresult ();
+#endif /* K&R C */
+#define LOC_APIVERS_0005 0x00050005
+
+#if defined(__STDC__) || defined(__cplusplus)
+extern enum clnt_stat rpc_loc_api_null_0x00050005(void *, void *, CLIENT *);
+extern bool_t rpc_loc_api_null_0x00050005_svc(void *, void *, struct svc_req *);
+extern int loc_apiprog_0x00050005_freeresult (SVCXPRT *, xdrproc_t, caddr_t);
+
+#else /* K&R C */
+extern enum clnt_stat rpc_loc_api_null_0x00050005();
+extern bool_t rpc_loc_api_null_0x00050005_svc();
+extern int loc_apiprog_0x00050005_freeresult ();
+#endif /* K&R C */
+#define LOC_APIVERS_0006 0x00050006
+
+#if defined(__STDC__) || defined(__cplusplus)
+extern enum clnt_stat rpc_loc_api_null_0x00050006(void *, void *, CLIENT *);
+extern bool_t rpc_loc_api_null_0x00050006_svc(void *, void *, struct svc_req *);
+extern int loc_apiprog_0x00050006_freeresult (SVCXPRT *, xdrproc_t, caddr_t);
+
+#else /* K&R C */
+extern enum clnt_stat rpc_loc_api_null_0x00050006();
+extern bool_t rpc_loc_api_null_0x00050006_svc();
+extern int loc_apiprog_0x00050006_freeresult ();
+#endif /* K&R C */
+
+/* the xdr functions */
+
+#if defined(__STDC__) || defined(__cplusplus)
+extern bool_t xdr_rpc_loc_api_api_versions_return_type (XDR *, rpc_loc_api_api_versions_return_type*);
+extern bool_t xdr_rpc_loc_event_cb_f_type (XDR *, rpc_loc_event_cb_f_type*);
+extern bool_t xdr_rpc_loc_open_args (XDR *, rpc_loc_open_args*);
+extern bool_t xdr_rpc_loc_close_args (XDR *, rpc_loc_close_args*);
+extern bool_t xdr_rpc_loc_start_fix_args (XDR *, rpc_loc_start_fix_args*);
+extern bool_t xdr_rpc_loc_stop_fix_args (XDR *, rpc_loc_stop_fix_args*);
+extern bool_t xdr_rpc_loc_ioctl_args (XDR *, rpc_loc_ioctl_args*);
+extern bool_t xdr_rpc_loc_api_api_version_s_args (XDR *, rpc_loc_api_api_version_s_args*);
+extern bool_t xdr_rpc_loc_api_rpc_glue_code_info_remote_rets (XDR *, rpc_loc_api_rpc_glue_code_info_remote_rets*);
+extern bool_t xdr_rpc_loc_open_rets (XDR *, rpc_loc_open_rets*);
+extern bool_t xdr_rpc_loc_close_rets (XDR *, rpc_loc_close_rets*);
+extern bool_t xdr_rpc_loc_start_fix_rets (XDR *, rpc_loc_start_fix_rets*);
+extern bool_t xdr_rpc_loc_stop_fix_rets (XDR *, rpc_loc_stop_fix_rets*);
+extern bool_t xdr_rpc_loc_ioctl_rets (XDR *, rpc_loc_ioctl_rets*);
+extern bool_t xdr_rpc_loc_api_api_versions_rets (XDR *, rpc_loc_api_api_versions_rets*);
+
+#else /* K&R C */
+extern bool_t xdr_rpc_loc_api_api_versions_return_type ();
+extern bool_t xdr_rpc_loc_event_cb_f_type ();
+extern bool_t xdr_rpc_loc_open_args ();
+extern bool_t xdr_rpc_loc_close_args ();
+extern bool_t xdr_rpc_loc_start_fix_args ();
+extern bool_t xdr_rpc_loc_stop_fix_args ();
+extern bool_t xdr_rpc_loc_ioctl_args ();
+extern bool_t xdr_rpc_loc_api_api_version_s_args ();
+extern bool_t xdr_rpc_loc_api_rpc_glue_code_info_remote_rets ();
+extern bool_t xdr_rpc_loc_open_rets ();
+extern bool_t xdr_rpc_loc_close_rets ();
+extern bool_t xdr_rpc_loc_start_fix_rets ();
+extern bool_t xdr_rpc_loc_stop_fix_rets ();
+extern bool_t xdr_rpc_loc_ioctl_rets ();
+extern bool_t xdr_rpc_loc_api_api_versions_rets ();
+
+#endif /* K&R C */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* !_LOC_API_RPC_H_RPCGEN */
diff --git a/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/inc/loc_apicb_appinit.h b/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/inc/loc_apicb_appinit.h
new file mode 100644
index 0000000..875c4f0
--- /dev/null
+++ b/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/inc/loc_apicb_appinit.h
@@ -0,0 +1,34 @@
+/* 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
+ * 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.
+ *
+ */
+
+/* Initialization function for callbacks */
+int loc_apicb_app_init();
+
+void loc_apicb_app_deinit();
+
diff --git a/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/src/loc_api_rpcgen_cb_svc.c b/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/src/loc_api_rpcgen_cb_svc.c
new file mode 100644
index 0000000..2ef5852
--- /dev/null
+++ b/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/src/loc_api_rpcgen_cb_svc.c
@@ -0,0 +1,327 @@
+/* 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
+ * 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.
+ *
+ */
+/*
+ * Please do not edit this file.
+ * It was generated using rpcgen.
+ */
+
+#include "loc_api_rpcgen_cb_rpc.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <rpc/pmap_clnt.h>
+#include <string.h>
+#include <memory.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+
+#ifndef SIG_PF
+#define SIG_PF void(*)(int)
+#endif
+
+void
+loc_apicbprog_0x00050001(struct svc_req *rqstp, register SVCXPRT *transp)
+{
+ union {
+ rpc_loc_event_cb_f_type_args rpc_loc_event_cb_f_type_0x00050001_arg;
+ } argument;
+ union {
+ rpc_loc_event_cb_f_type_rets rpc_loc_event_cb_f_type_0x00050001_res;
+ } result;
+ bool_t retval;
+ xdrproc_t _xdr_argument, _xdr_result;
+ bool_t (*local)(char *, void *, struct svc_req *);
+
+ switch (rqstp->rq_proc) {
+ case NULLPROC:
+ (void) svc_sendreply (transp, (xdrproc_t) xdr_void, (char *)NULL);
+ return;
+
+ case rpc_loc_event_cb_f_type:
+ _xdr_argument = (xdrproc_t) xdr_rpc_loc_event_cb_f_type_args;
+ _xdr_result = (xdrproc_t) xdr_rpc_loc_event_cb_f_type_rets;
+ local = (bool_t (*) (char *, void *, struct svc_req *))rpc_loc_event_cb_f_type_0x00050001_svc;
+ break;
+
+ default:
+ svcerr_noproc (transp);
+ return;
+ }
+ memset ((char *)&argument, 0, sizeof (argument));
+ if (!svc_getargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {
+ svcerr_decode (transp);
+ return;
+ }
+ retval = (bool_t) (*local)((char *)&argument, (void *)&result, rqstp);
+ if (retval > 0 && !svc_sendreply(transp, (xdrproc_t) _xdr_result, (char *)&result)) {
+ svcerr_systemerr (transp);
+ }
+ if (!svc_freeargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {
+ fprintf (stderr, "%s", "unable to free arguments");
+ exit (1);
+ }
+ if (!loc_apicbprog_0x00050001_freeresult (transp, _xdr_result, (caddr_t) &result))
+ fprintf (stderr, "%s", "unable to free results");
+
+ return;
+}
+
+void
+loc_apicbprog_0x00050002(struct svc_req *rqstp, register SVCXPRT *transp)
+{
+ union {
+ int fill;
+ } argument;
+ union {
+ int rpc_loc_api_cb_null_0x00050002_res;
+ } result;
+ bool_t retval;
+ xdrproc_t _xdr_argument, _xdr_result;
+ bool_t (*local)(char *, void *, struct svc_req *);
+
+ switch (rqstp->rq_proc) {
+ case NULLPROC:
+ (void) svc_sendreply (transp, (xdrproc_t) xdr_void, (char *)NULL);
+ return;
+
+ case rpc_loc_api_cb_null:
+ _xdr_argument = (xdrproc_t) xdr_void;
+ _xdr_result = (xdrproc_t) xdr_int;
+ local = (bool_t (*) (char *, void *, struct svc_req *))rpc_loc_api_cb_null_0x00050002_svc;
+ break;
+
+ default:
+ svcerr_noproc (transp);
+ return;
+ }
+ memset ((char *)&argument, 0, sizeof (argument));
+ if (!svc_getargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {
+ svcerr_decode (transp);
+ return;
+ }
+ retval = (bool_t) (*local)((char *)&argument, (void *)&result, rqstp);
+ if (retval > 0 && !svc_sendreply(transp, (xdrproc_t) _xdr_result, (char *)&result)) {
+ svcerr_systemerr (transp);
+ }
+ if (!svc_freeargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {
+ fprintf (stderr, "%s", "unable to free arguments");
+ exit (1);
+ }
+ if (!loc_apicbprog_0x00050002_freeresult (transp, _xdr_result, (caddr_t) &result))
+ fprintf (stderr, "%s", "unable to free results");
+
+ return;
+}
+
+void
+loc_apicbprog_0x00050003(struct svc_req *rqstp, register SVCXPRT *transp)
+{
+ union {
+ int fill;
+ } argument;
+ union {
+ int rpc_loc_api_cb_null_0x00050003_res;
+ } result;
+ bool_t retval;
+ xdrproc_t _xdr_argument, _xdr_result;
+ bool_t (*local)(char *, void *, struct svc_req *);
+
+ switch (rqstp->rq_proc) {
+ case NULLPROC:
+ (void) svc_sendreply (transp, (xdrproc_t) xdr_void, (char *)NULL);
+ return;
+
+ case rpc_loc_api_cb_null:
+ _xdr_argument = (xdrproc_t) xdr_void;
+ _xdr_result = (xdrproc_t) xdr_int;
+ local = (bool_t (*) (char *, void *, struct svc_req *))rpc_loc_api_cb_null_0x00050003_svc;
+ break;
+
+ default:
+ svcerr_noproc (transp);
+ return;
+ }
+ memset ((char *)&argument, 0, sizeof (argument));
+ if (!svc_getargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {
+ svcerr_decode (transp);
+ return;
+ }
+ retval = (bool_t) (*local)((char *)&argument, (void *)&result, rqstp);
+ if (retval > 0 && !svc_sendreply(transp, (xdrproc_t) _xdr_result, (char *)&result)) {
+ svcerr_systemerr (transp);
+ }
+ if (!svc_freeargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {
+ fprintf (stderr, "%s", "unable to free arguments");
+ exit (1);
+ }
+ if (!loc_apicbprog_0x00050003_freeresult (transp, _xdr_result, (caddr_t) &result))
+ fprintf (stderr, "%s", "unable to free results");
+
+ return;
+}
+
+void
+loc_apicbprog_0x00050004(struct svc_req *rqstp, register SVCXPRT *transp)
+{
+ union {
+ int fill;
+ } argument;
+ union {
+ int rpc_loc_api_cb_null_0x00050004_res;
+ } result;
+ bool_t retval;
+ xdrproc_t _xdr_argument, _xdr_result;
+ bool_t (*local)(char *, void *, struct svc_req *);
+
+ switch (rqstp->rq_proc) {
+ case NULLPROC:
+ (void) svc_sendreply (transp, (xdrproc_t) xdr_void, (char *)NULL);
+ return;
+
+ case rpc_loc_api_cb_null:
+ _xdr_argument = (xdrproc_t) xdr_void;
+ _xdr_result = (xdrproc_t) xdr_int;
+ local = (bool_t (*) (char *, void *, struct svc_req *))rpc_loc_api_cb_null_0x00050004_svc;
+ break;
+
+ default:
+ svcerr_noproc (transp);
+ return;
+ }
+ memset ((char *)&argument, 0, sizeof (argument));
+ if (!svc_getargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {
+ svcerr_decode (transp);
+ return;
+ }
+ retval = (bool_t) (*local)((char *)&argument, (void *)&result, rqstp);
+ if (retval > 0 && !svc_sendreply(transp, (xdrproc_t) _xdr_result, (char *)&result)) {
+ svcerr_systemerr (transp);
+ }
+ if (!svc_freeargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {
+ fprintf (stderr, "%s", "unable to free arguments");
+ exit (1);
+ }
+ if (!loc_apicbprog_0x00050004_freeresult (transp, _xdr_result, (caddr_t) &result))
+ fprintf (stderr, "%s", "unable to free results");
+
+ return;
+}
+
+void
+loc_apicbprog_0x00050005(struct svc_req *rqstp, register SVCXPRT *transp)
+{
+ union {
+ int fill;
+ } argument;
+ union {
+ int rpc_loc_api_cb_null_0x00050005_res;
+ } result;
+ bool_t retval;
+ xdrproc_t _xdr_argument, _xdr_result;
+ bool_t (*local)(char *, void *, struct svc_req *);
+
+ switch (rqstp->rq_proc) {
+ case NULLPROC:
+ (void) svc_sendreply (transp, (xdrproc_t) xdr_void, (char *)NULL);
+ return;
+
+ case rpc_loc_api_cb_null:
+ _xdr_argument = (xdrproc_t) xdr_void;
+ _xdr_result = (xdrproc_t) xdr_int;
+ local = (bool_t (*) (char *, void *, struct svc_req *))rpc_loc_api_cb_null_0x00050005_svc;
+ break;
+
+ default:
+ svcerr_noproc (transp);
+ return;
+ }
+ memset ((char *)&argument, 0, sizeof (argument));
+ if (!svc_getargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {
+ svcerr_decode (transp);
+ return;
+ }
+ retval = (bool_t) (*local)((char *)&argument, (void *)&result, rqstp);
+ if (retval > 0 && !svc_sendreply(transp, (xdrproc_t) _xdr_result, (char *)&result)) {
+ svcerr_systemerr (transp);
+ }
+ if (!svc_freeargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {
+ fprintf (stderr, "%s", "unable to free arguments");
+ exit (1);
+ }
+ if (!loc_apicbprog_0x00050005_freeresult (transp, _xdr_result, (caddr_t) &result))
+ fprintf (stderr, "%s", "unable to free results");
+
+ return;
+}
+
+void
+loc_apicbprog_0x00050006(struct svc_req *rqstp, register SVCXPRT *transp)
+{
+ union {
+ int fill;
+ } argument;
+ union {
+ int rpc_loc_api_cb_null_0x00050006_res;
+ } result;
+ bool_t retval;
+ xdrproc_t _xdr_argument, _xdr_result;
+ bool_t (*local)(char *, void *, struct svc_req *);
+
+ switch (rqstp->rq_proc) {
+ case NULLPROC:
+ (void) svc_sendreply (transp, (xdrproc_t) xdr_void, (char *)NULL);
+ return;
+
+ case rpc_loc_api_cb_null:
+ _xdr_argument = (xdrproc_t) xdr_void;
+ _xdr_result = (xdrproc_t) xdr_int;
+ local = (bool_t (*) (char *, void *, struct svc_req *))rpc_loc_api_cb_null_0x00050006_svc;
+ break;
+
+ default:
+ svcerr_noproc (transp);
+ return;
+ }
+ memset ((char *)&argument, 0, sizeof (argument));
+ if (!svc_getargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {
+ svcerr_decode (transp);
+ return;
+ }
+ retval = (bool_t) (*local)((char *)&argument, (void *)&result, rqstp);
+ if (retval > 0 && !svc_sendreply(transp, (xdrproc_t) _xdr_result, (char *)&result)) {
+ svcerr_systemerr (transp);
+ }
+ if (!svc_freeargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {
+ fprintf (stderr, "%s", "unable to free arguments");
+ exit (1);
+ }
+ if (!loc_apicbprog_0x00050006_freeresult (transp, _xdr_result, (caddr_t) &result))
+ fprintf (stderr, "%s", "unable to free results");
+
+ return;
+}
diff --git a/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/src/loc_api_rpcgen_cb_xdr.c b/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/src/loc_api_rpcgen_cb_xdr.c
new file mode 100644
index 0000000..ad171dc
--- /dev/null
+++ b/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/src/loc_api_rpcgen_cb_xdr.c
@@ -0,0 +1,60 @@
+/* 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
+ * 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.
+ *
+ */
+/*
+ * Please do not edit this file.
+ * It was generated using rpcgen.
+ */
+
+#include "loc_api_rpcgen_cb_rpc.h"
+
+bool_t
+xdr_rpc_loc_event_cb_f_type_args (XDR *xdrs, rpc_loc_event_cb_f_type_args *objp)
+{
+;
+
+ if (!xdr_rpc_uint32 (xdrs, &objp->cb_id))
+ return FALSE;
+ if (!xdr_rpc_loc_client_handle_type (xdrs, &objp->loc_handle))
+ return FALSE;
+ if (!xdr_rpc_loc_event_mask_type (xdrs, &objp->loc_event))
+ return FALSE;
+ if (!xdr_pointer (xdrs, (char **)&objp->loc_event_payload, sizeof (rpc_loc_event_payload_u_type), (xdrproc_t) xdr_rpc_loc_event_payload_u_type))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_event_cb_f_type_rets (XDR *xdrs, rpc_loc_event_cb_f_type_rets *objp)
+{
+;
+
+ if (!xdr_rpc_int32 (xdrs, &objp->loc_event_cb_f_type_result))
+ return FALSE;
+ return TRUE;
+}
diff --git a/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/src/loc_api_rpcgen_clnt.c b/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/src/loc_api_rpcgen_clnt.c
new file mode 100644
index 0000000..3e39576
--- /dev/null
+++ b/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/src/loc_api_rpcgen_clnt.c
@@ -0,0 +1,155 @@
+/* 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
+ * 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.
+ *
+ */
+/*
+ * Please do not edit this file.
+ * It was generated using rpcgen.
+ */
+
+#include <memory.h> /* for memset */
+#include "loc_api_rpcgen_rpc.h"
+
+/* Default timeout can be changed using clnt_control() */
+static struct timeval TIMEOUT = { 25, 0 };
+
+enum clnt_stat
+rpc_loc_api_null_0x00050001(void *argp, void *clnt_res, CLIENT *clnt)
+{
+ return (clnt_call(clnt, rpc_loc_api_null,
+ (xdrproc_t) xdr_void, (caddr_t) argp,
+ (xdrproc_t) xdr_void, (caddr_t) clnt_res,
+ TIMEOUT));
+}
+
+enum clnt_stat
+rpc_loc_api_rpc_glue_code_info_remote_0x00050001(void *argp, rpc_loc_api_rpc_glue_code_info_remote_rets *clnt_res, CLIENT *clnt)
+{
+ return (clnt_call(clnt, rpc_loc_api_rpc_glue_code_info_remote,
+ (xdrproc_t) xdr_void, (caddr_t) argp,
+ (xdrproc_t) xdr_rpc_loc_api_rpc_glue_code_info_remote_rets, (caddr_t) clnt_res,
+ TIMEOUT));
+}
+
+enum clnt_stat
+rpc_loc_open_0x00050001(rpc_loc_open_args *argp, rpc_loc_open_rets *clnt_res, CLIENT *clnt)
+{
+ return (clnt_call(clnt, rpc_loc_open,
+ (xdrproc_t) xdr_rpc_loc_open_args, (caddr_t) argp,
+ (xdrproc_t) xdr_rpc_loc_open_rets, (caddr_t) clnt_res,
+ TIMEOUT));
+}
+
+enum clnt_stat
+rpc_loc_close_0x00050001(rpc_loc_close_args *argp, rpc_loc_close_rets *clnt_res, CLIENT *clnt)
+{
+ return (clnt_call(clnt, rpc_loc_close,
+ (xdrproc_t) xdr_rpc_loc_close_args, (caddr_t) argp,
+ (xdrproc_t) xdr_rpc_loc_close_rets, (caddr_t) clnt_res,
+ TIMEOUT));
+}
+
+enum clnt_stat
+rpc_loc_start_fix_0x00050001(rpc_loc_start_fix_args *argp, rpc_loc_start_fix_rets *clnt_res, CLIENT *clnt)
+{
+ return (clnt_call(clnt, rpc_loc_start_fix,
+ (xdrproc_t) xdr_rpc_loc_start_fix_args, (caddr_t) argp,
+ (xdrproc_t) xdr_rpc_loc_start_fix_rets, (caddr_t) clnt_res,
+ TIMEOUT));
+}
+
+enum clnt_stat
+rpc_loc_stop_fix_0x00050001(rpc_loc_stop_fix_args *argp, rpc_loc_stop_fix_rets *clnt_res, CLIENT *clnt)
+{
+ return (clnt_call(clnt, rpc_loc_stop_fix,
+ (xdrproc_t) xdr_rpc_loc_stop_fix_args, (caddr_t) argp,
+ (xdrproc_t) xdr_rpc_loc_stop_fix_rets, (caddr_t) clnt_res,
+ TIMEOUT));
+}
+
+enum clnt_stat
+rpc_loc_ioctl_0x00050001(rpc_loc_ioctl_args *argp, rpc_loc_ioctl_rets *clnt_res, CLIENT *clnt)
+{
+ return (clnt_call(clnt, rpc_loc_ioctl,
+ (xdrproc_t) xdr_rpc_loc_ioctl_args, (caddr_t) argp,
+ (xdrproc_t) xdr_rpc_loc_ioctl_rets, (caddr_t) clnt_res,
+ TIMEOUT));
+}
+
+enum clnt_stat
+rpc_loc_api_api_versions_0x00050001(void *argp, rpc_loc_api_api_versions_rets *clnt_res, CLIENT *clnt)
+{
+ return (clnt_call(clnt, rpc_loc_api_api_versions,
+ (xdrproc_t) xdr_void, (caddr_t) argp,
+ (xdrproc_t) xdr_rpc_loc_api_api_versions_rets, (caddr_t) clnt_res,
+ TIMEOUT));
+}
+
+enum clnt_stat
+rpc_loc_api_null_0x00050002(void *argp, void *clnt_res, CLIENT *clnt)
+{
+ return (clnt_call(clnt, rpc_loc_api_null,
+ (xdrproc_t) xdr_void, (caddr_t) argp,
+ (xdrproc_t) xdr_void, (caddr_t) clnt_res,
+ TIMEOUT));
+}
+
+enum clnt_stat
+rpc_loc_api_null_0x00050003(void *argp, void *clnt_res, CLIENT *clnt)
+{
+ return (clnt_call(clnt, rpc_loc_api_null,
+ (xdrproc_t) xdr_void, (caddr_t) argp,
+ (xdrproc_t) xdr_void, (caddr_t) clnt_res,
+ TIMEOUT));
+}
+
+enum clnt_stat
+rpc_loc_api_null_0x00050004(void *argp, void *clnt_res, CLIENT *clnt)
+{
+ return (clnt_call(clnt, rpc_loc_api_null,
+ (xdrproc_t) xdr_void, (caddr_t) argp,
+ (xdrproc_t) xdr_void, (caddr_t) clnt_res,
+ TIMEOUT));
+}
+
+enum clnt_stat
+rpc_loc_api_null_0x00050005(void *argp, void *clnt_res, CLIENT *clnt)
+{
+ return (clnt_call(clnt, rpc_loc_api_null,
+ (xdrproc_t) xdr_void, (caddr_t) argp,
+ (xdrproc_t) xdr_void, (caddr_t) clnt_res,
+ TIMEOUT));
+}
+
+enum clnt_stat
+rpc_loc_api_null_0x00050006(void *argp, void *clnt_res, CLIENT *clnt)
+{
+ return (clnt_call(clnt, rpc_loc_api_null,
+ (xdrproc_t) xdr_void, (caddr_t) argp,
+ (xdrproc_t) xdr_void, (caddr_t) clnt_res,
+ TIMEOUT));
+}
diff --git a/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/src/loc_api_rpcgen_common_xdr.c b/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/src/loc_api_rpcgen_common_xdr.c
new file mode 100644
index 0000000..21be8f4
--- /dev/null
+++ b/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/src/loc_api_rpcgen_common_xdr.c
@@ -0,0 +1,1775 @@
+/* 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
+ * 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.
+ *
+ */
+/*
+ * Please do not edit this file.
+ * It was generated using rpcgen.
+ */
+
+#include "loc_api_rpcgen_common_rpc.h"
+
+bool_t
+xdr_rpc_loc_client_handle_type (XDR *xdrs, rpc_loc_client_handle_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_rpc_int32 (xdrs, objp))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_event_mask_type (XDR *xdrs, rpc_loc_event_mask_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_rpc_uint64 (xdrs, objp))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_position_valid_mask_type (XDR *xdrs, rpc_loc_position_valid_mask_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_rpc_uint64 (xdrs, objp))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_pos_technology_mask_type (XDR *xdrs, rpc_loc_pos_technology_mask_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_rpc_uint32 (xdrs, objp))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_session_status_e_type (XDR *xdrs, rpc_loc_session_status_e_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_enum (xdrs, (enum_t *) objp))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_calendar_time_s_type (XDR *xdrs, rpc_loc_calendar_time_s_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_rpc_uint16 (xdrs, &objp->year))
+ return FALSE;
+ if (!xdr_u_char (xdrs, &objp->month))
+ return FALSE;
+ if (!xdr_u_char (xdrs, &objp->day_of_week))
+ return FALSE;
+ if (!xdr_u_char (xdrs, &objp->day))
+ return FALSE;
+ if (!xdr_u_char (xdrs, &objp->hour))
+ return FALSE;
+ if (!xdr_u_char (xdrs, &objp->minute))
+ return FALSE;
+ if (!xdr_u_char (xdrs, &objp->second))
+ return FALSE;
+ if (!xdr_rpc_uint16 (xdrs, &objp->millisecond))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_parsed_position_s_type (XDR *xdrs, rpc_loc_parsed_position_s_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_rpc_loc_position_valid_mask_type (xdrs, &objp->valid_mask))
+ return FALSE;
+ if (!xdr_rpc_loc_session_status_e_type (xdrs, &objp->session_status))
+ return FALSE;
+ if (!xdr_rpc_loc_calendar_time_s_type (xdrs, &objp->timestamp_calendar))
+ return FALSE;
+ if (!xdr_rpc_uint64 (xdrs, &objp->timestamp_utc))
+ return FALSE;
+ if (!xdr_rpc_uint8 (xdrs, &objp->leap_seconds))
+ return FALSE;
+ if (!xdr_float (xdrs, &objp->time_unc))
+ return FALSE;
+ if (!xdr_double (xdrs, &objp->latitude))
+ return FALSE;
+ if (!xdr_double (xdrs, &objp->longitude))
+ return FALSE;
+ if (!xdr_float (xdrs, &objp->altitude_wrt_ellipsoid))
+ return FALSE;
+ if (!xdr_float (xdrs, &objp->altitude_wrt_mean_sea_level))
+ return FALSE;
+ if (!xdr_float (xdrs, &objp->speed_horizontal))
+ return FALSE;
+ if (!xdr_float (xdrs, &objp->speed_vertical))
+ return FALSE;
+ if (!xdr_float (xdrs, &objp->heading))
+ return FALSE;
+ if (!xdr_float (xdrs, &objp->hor_unc_circular))
+ return FALSE;
+ if (!xdr_float (xdrs, &objp->hor_unc_ellipse_semi_major))
+ return FALSE;
+ if (!xdr_float (xdrs, &objp->hor_unc_ellipse_semi_minor))
+ return FALSE;
+ if (!xdr_float (xdrs, &objp->hor_unc_ellipse_orient_azimuth))
+ return FALSE;
+ if (!xdr_float (xdrs, &objp->vert_unc))
+ return FALSE;
+ if (!xdr_float (xdrs, &objp->speed_unc))
+ return FALSE;
+ if (!xdr_float (xdrs, &objp->heading_unc))
+ return FALSE;
+ if (!xdr_u_char (xdrs, &objp->confidence_horizontal))
+ return FALSE;
+ if (!xdr_u_char (xdrs, &objp->confidence_vertical))
+ return FALSE;
+ if (!xdr_float (xdrs, &objp->magnetic_deviation))
+ return FALSE;
+ if (!xdr_rpc_loc_pos_technology_mask_type (xdrs, &objp->technology_mask))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_sv_system_e_type (XDR *xdrs, rpc_loc_sv_system_e_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_enum (xdrs, (enum_t *) objp))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_sv_status_e_type (XDR *xdrs, rpc_loc_sv_status_e_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_enum (xdrs, (enum_t *) objp))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_sv_info_valid_mask_type (XDR *xdrs, rpc_loc_sv_info_valid_mask_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_rpc_uint32 (xdrs, objp))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_sv_info_s_type (XDR *xdrs, rpc_loc_sv_info_s_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_rpc_loc_sv_info_valid_mask_type (xdrs, &objp->valid_mask))
+ return FALSE;
+ if (!xdr_rpc_loc_sv_system_e_type (xdrs, &objp->system))
+ return FALSE;
+ if (!xdr_rpc_uint8 (xdrs, &objp->prn))
+ return FALSE;
+ if (!xdr_rpc_uint8 (xdrs, &objp->health_status))
+ return FALSE;
+ if (!xdr_rpc_loc_sv_status_e_type (xdrs, &objp->process_status))
+ return FALSE;
+ if (!xdr_rpc_boolean (xdrs, &objp->has_eph))
+ return FALSE;
+ if (!xdr_rpc_boolean (xdrs, &objp->has_alm))
+ return FALSE;
+ if (!xdr_float (xdrs, &objp->elevation))
+ return FALSE;
+ if (!xdr_float (xdrs, &objp->azimuth))
+ return FALSE;
+ if (!xdr_float (xdrs, &objp->snr))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_gnss_info_valid_mask_type (XDR *xdrs, rpc_loc_gnss_info_valid_mask_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_rpc_uint32 (xdrs, objp))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_gnss_info_s_type (XDR *xdrs, rpc_loc_gnss_info_s_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_rpc_loc_gnss_info_valid_mask_type (xdrs, &objp->valid_mask))
+ return FALSE;
+ if (!xdr_float (xdrs, &objp->position_dop))
+ return FALSE;
+ if (!xdr_float (xdrs, &objp->horizontal_dop))
+ return FALSE;
+ if (!xdr_float (xdrs, &objp->vertical_dop))
+ return FALSE;
+ if (!xdr_rpc_boolean (xdrs, &objp->altitude_assumed))
+ return FALSE;
+ if (!xdr_rpc_uint16 (xdrs, &objp->sv_count))
+ return FALSE;
+ if (!xdr_array (xdrs, (char **)&objp->sv_list.sv_list_val, (u_int *) &objp->sv_list.sv_list_len, 80,
+ sizeof (rpc_loc_sv_info_s_type), (xdrproc_t) xdr_rpc_loc_sv_info_s_type))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_nmea_report_s_type (XDR *xdrs, rpc_loc_nmea_report_s_type *objp)
+{
+ register int32_t *buf;
+
+ int i;
+ if (!xdr_rpc_uint16 (xdrs, &objp->length))
+ return FALSE;
+ if (!xdr_opaque (xdrs, objp->nmea_sentences, 200))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_status_event_e_type (XDR *xdrs, rpc_loc_status_event_e_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_enum (xdrs, (enum_t *) objp))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_engine_state_e_type (XDR *xdrs, rpc_loc_engine_state_e_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_enum (xdrs, (enum_t *) objp))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_fix_session_state_e_type (XDR *xdrs, rpc_loc_fix_session_state_e_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_enum (xdrs, (enum_t *) objp))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_status_event_payload_u_type (XDR *xdrs, rpc_loc_status_event_payload_u_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_rpc_loc_status_event_e_type (xdrs, &objp->disc))
+ return FALSE;
+ switch (objp->disc) {
+ case RPC_LOC_STATUS_EVENT_ENGINE_STATE:
+ if (!xdr_rpc_loc_engine_state_e_type (xdrs, &objp->rpc_loc_status_event_payload_u_type_u.engine_state))
+ return FALSE;
+ break;
+ case RPC_LOC_STATUS_EVENT_FIX_SESSION_STATE:
+ if (!xdr_rpc_loc_fix_session_state_e_type (xdrs, &objp->rpc_loc_status_event_payload_u_type_u.fix_session_state))
+ return FALSE;
+ break;
+ default:
+ break;
+ }
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_status_event_s_type (XDR *xdrs, rpc_loc_status_event_s_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_rpc_loc_status_event_e_type (xdrs, &objp->event))
+ return FALSE;
+ if (!xdr_rpc_loc_status_event_payload_u_type (xdrs, &objp->payload))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_server_addr_e_type (XDR *xdrs, rpc_loc_server_addr_e_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_enum (xdrs, (enum_t *) objp))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_server_addr_ipv4_type (XDR *xdrs, rpc_loc_server_addr_ipv4_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_rpc_uint32 (xdrs, &objp->addr))
+ return FALSE;
+ if (!xdr_rpc_uint16 (xdrs, &objp->port))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_server_addr_url_type (XDR *xdrs, rpc_loc_server_addr_url_type *objp)
+{
+ register int32_t *buf;
+
+ int i;
+ if (!xdr_rpc_uint16 (xdrs, &objp->length))
+ return FALSE;
+ if (!xdr_opaque (xdrs, objp->addr, 256))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_server_addr_ipv6_type (XDR *xdrs, rpc_loc_server_addr_ipv6_type *objp)
+{
+ register int32_t *buf;
+
+ int i;
+ if (!xdr_vector (xdrs, (char *)objp->addr, 8,
+ sizeof (rpc_uint16), (xdrproc_t) xdr_rpc_uint16))
+ return FALSE;
+ if (!xdr_rpc_uint32 (xdrs, &objp->port))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_server_addr_u_type (XDR *xdrs, rpc_loc_server_addr_u_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_rpc_loc_server_addr_e_type (xdrs, &objp->disc))
+ return FALSE;
+ switch (objp->disc) {
+ case RPC_LOC_SERVER_ADDR_IPV4:
+ if (!xdr_rpc_loc_server_addr_ipv4_type (xdrs, &objp->rpc_loc_server_addr_u_type_u.ipv4))
+ return FALSE;
+ break;
+ case RPC_LOC_SERVER_ADDR_URL:
+ if (!xdr_rpc_loc_server_addr_url_type (xdrs, &objp->rpc_loc_server_addr_u_type_u.url))
+ return FALSE;
+ break;
+ case RPC_LOC_SERVER_ADDR_IPV6:
+ if (!xdr_rpc_loc_server_addr_ipv6_type (xdrs, &objp->rpc_loc_server_addr_u_type_u.ipv6))
+ return FALSE;
+ break;
+ default:
+ break;
+ }
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_server_info_s_type (XDR *xdrs, rpc_loc_server_info_s_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_rpc_loc_server_addr_e_type (xdrs, &objp->addr_type))
+ return FALSE;
+ if (!xdr_rpc_loc_server_addr_u_type (xdrs, &objp->addr_info))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_ni_notify_verify_e_type (XDR *xdrs, rpc_loc_ni_notify_verify_e_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_enum (xdrs, (enum_t *) objp))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_ni_event_e_type (XDR *xdrs, rpc_loc_ni_event_e_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_enum (xdrs, (enum_t *) objp))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_ni_datacoding_scheme_e_type (XDR *xdrs, rpc_loc_ni_datacoding_scheme_e_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_enum (xdrs, (enum_t *) objp))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_ni_vx_requester_id_encoding_scheme_e_type (XDR *xdrs, rpc_loc_ni_vx_requester_id_encoding_scheme_e_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_enum (xdrs, (enum_t *) objp))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_ni_vx_pos_mode_e_type (XDR *xdrs, rpc_loc_ni_vx_pos_mode_e_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_enum (xdrs, (enum_t *) objp))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_ni_vx_requester_id_s_type (XDR *xdrs, rpc_loc_ni_vx_requester_id_s_type *objp)
+{
+ register int32_t *buf;
+
+ int i;
+ if (!xdr_u_char (xdrs, &objp->requester_id_length))
+ return FALSE;
+ if (!xdr_opaque (xdrs, objp->requester_id, 200))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_ni_vx_notify_verify_req_s_type (XDR *xdrs, rpc_loc_ni_vx_notify_verify_req_s_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_rpc_loc_ni_notify_verify_e_type (xdrs, &objp->notification_priv_type))
+ return FALSE;
+ if (!xdr_u_char (xdrs, &objp->pos_qos_incl))
+ return FALSE;
+ if (!xdr_u_char (xdrs, &objp->pos_qos))
+ return FALSE;
+ if (!xdr_rpc_uint32 (xdrs, &objp->num_fixes))
+ return FALSE;
+ if (!xdr_rpc_uint32 (xdrs, &objp->tbf))
+ return FALSE;
+ if (!xdr_rpc_loc_ni_vx_pos_mode_e_type (xdrs, &objp->pos_mode))
+ return FALSE;
+ if (!xdr_rpc_loc_ni_vx_requester_id_encoding_scheme_e_type (xdrs, &objp->encoding_scheme))
+ return FALSE;
+ if (!xdr_rpc_loc_ni_vx_requester_id_s_type (xdrs, &objp->requester_id))
+ return FALSE;
+ if (!xdr_rpc_uint16 (xdrs, &objp->user_resp_timer_val))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_ni_supl_pos_method_e_type (XDR *xdrs, rpc_loc_ni_supl_pos_method_e_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_enum (xdrs, (enum_t *) objp))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_ni_supl_slp_session_id_s_type (XDR *xdrs, rpc_loc_ni_supl_slp_session_id_s_type *objp)
+{
+ register int32_t *buf;
+
+ int i;
+ if (!xdr_u_char (xdrs, &objp->presence))
+ return FALSE;
+ if (!xdr_opaque (xdrs, objp->session_id, 4))
+ return FALSE;
+ if (!xdr_rpc_loc_server_info_s_type (xdrs, &objp->slp_address))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_ni_requestor_id_s_type (XDR *xdrs, rpc_loc_ni_requestor_id_s_type *objp)
+{
+ register int32_t *buf;
+
+ int i;
+ if (!xdr_u_char (xdrs, &objp->data_coding_scheme))
+ return FALSE;
+ if (!xdr_opaque (xdrs, objp->requestor_id_string, 200))
+ return FALSE;
+ if (!xdr_u_char (xdrs, &objp->string_len))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_ni_supl_client_name_s_type (XDR *xdrs, rpc_loc_ni_supl_client_name_s_type *objp)
+{
+ register int32_t *buf;
+
+ int i;
+ if (!xdr_u_char (xdrs, &objp->data_coding_scheme))
+ return FALSE;
+ if (!xdr_opaque (xdrs, objp->client_name_string, 64))
+ return FALSE;
+ if (!xdr_u_char (xdrs, &objp->string_len))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_ni_supl_qop_s_type (XDR *xdrs, rpc_loc_ni_supl_qop_s_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_u_char (xdrs, &objp->bit_mask))
+ return FALSE;
+ if (!xdr_u_char (xdrs, &objp->horacc))
+ return FALSE;
+ if (!xdr_u_char (xdrs, &objp->veracc))
+ return FALSE;
+ if (!xdr_rpc_uint16 (xdrs, &objp->maxLocAge))
+ return FALSE;
+ if (!xdr_u_char (xdrs, &objp->delay))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_ni_supl_notify_verify_req_s_type (XDR *xdrs, rpc_loc_ni_supl_notify_verify_req_s_type *objp)
+{
+ register int32_t *buf;
+
+ int i;
+ if (!xdr_rpc_loc_ni_notify_verify_e_type (xdrs, &objp->notification_priv_type))
+ return FALSE;
+ if (!xdr_rpc_uint16 (xdrs, &objp->flags))
+ return FALSE;
+ if (!xdr_rpc_loc_ni_supl_slp_session_id_s_type (xdrs, &objp->supl_slp_session_id))
+ return FALSE;
+ if (!xdr_opaque (xdrs, objp->supl_hash, 8))
+ return FALSE;
+ if (!xdr_rpc_loc_ni_datacoding_scheme_e_type (xdrs, &objp->datacoding_scheme))
+ return FALSE;
+ if (!xdr_rpc_loc_ni_supl_pos_method_e_type (xdrs, &objp->pos_method))
+ return FALSE;
+ if (!xdr_rpc_loc_ni_requestor_id_s_type (xdrs, &objp->requestor_id))
+ return FALSE;
+ if (!xdr_rpc_loc_ni_supl_client_name_s_type (xdrs, &objp->client_name))
+ return FALSE;
+ if (!xdr_rpc_loc_ni_supl_qop_s_type (xdrs, &objp->supl_qop))
+ return FALSE;
+ if (!xdr_rpc_uint16 (xdrs, &objp->user_response_timer))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_ni_ext_client_address_s_type (XDR *xdrs, rpc_loc_ni_ext_client_address_s_type *objp)
+{
+ register int32_t *buf;
+
+ int i;
+ if (!xdr_u_char (xdrs, &objp->ext_client_address_len))
+ return FALSE;
+ if (!xdr_opaque (xdrs, objp->ext_client_address, 20))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_ni_location_type_e_type (XDR *xdrs, rpc_loc_ni_location_type_e_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_enum (xdrs, (enum_t *) objp))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_ni_deferred_location_s_type (XDR *xdrs, rpc_loc_ni_deferred_location_s_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_u_char (xdrs, &objp->unused_bits))
+ return FALSE;
+ if (!xdr_u_char (xdrs, &objp->ms_available))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_ni_codeword_string_s_type (XDR *xdrs, rpc_loc_ni_codeword_string_s_type *objp)
+{
+ register int32_t *buf;
+
+ int i;
+ if (!xdr_u_char (xdrs, &objp->data_coding_scheme))
+ return FALSE;
+ if (!xdr_opaque (xdrs, objp->lcs_codeword_string, 20))
+ return FALSE;
+ if (!xdr_u_char (xdrs, &objp->string_len))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_ni_service_type_id_s_type (XDR *xdrs, rpc_loc_ni_service_type_id_s_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_u_char (xdrs, &objp->lcs_service_type_id))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_ni_umts_cp_notify_verify_req_s_type (XDR *xdrs, rpc_loc_ni_umts_cp_notify_verify_req_s_type *objp)
+{
+ register int32_t *buf;
+
+ int i;
+ if (!xdr_rpc_loc_ni_notify_verify_e_type (xdrs, &objp->notification_priv_type))
+ return FALSE;
+ if (!xdr_u_char (xdrs, &objp->invoke_id))
+ return FALSE;
+ if (!xdr_rpc_uint16 (xdrs, &objp->flags))
+ return FALSE;
+ if (!xdr_u_char (xdrs, &objp->notification_length))
+ return FALSE;
+ if (!xdr_opaque (xdrs, objp->notification_text, 64))
+ return FALSE;
+ if (!xdr_rpc_loc_ni_datacoding_scheme_e_type (xdrs, &objp->datacoding_scheme))
+ return FALSE;
+ if (!xdr_rpc_loc_ni_ext_client_address_s_type (xdrs, &objp->ext_client_address_data))
+ return FALSE;
+ if (!xdr_rpc_loc_ni_location_type_e_type (xdrs, &objp->location_type))
+ return FALSE;
+ if (!xdr_rpc_loc_ni_deferred_location_s_type (xdrs, &objp->deferred_location))
+ return FALSE;
+ if (!xdr_rpc_loc_ni_requestor_id_s_type (xdrs, &objp->requestor_id))
+ return FALSE;
+ if (!xdr_rpc_loc_ni_codeword_string_s_type (xdrs, &objp->codeword_string))
+ return FALSE;
+ if (!xdr_rpc_loc_ni_service_type_id_s_type (xdrs, &objp->service_type_id))
+ return FALSE;
+ if (!xdr_rpc_uint16 (xdrs, &objp->user_response_timer))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_ni_service_interaction_e_type (XDR *xdrs, rpc_loc_ni_service_interaction_e_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_enum (xdrs, (enum_t *) objp))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_ni_vx_service_interaction_req_s_type (XDR *xdrs, rpc_loc_ni_vx_service_interaction_req_s_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_rpc_loc_ni_vx_notify_verify_req_s_type (xdrs, &objp->ni_vx_req))
+ return FALSE;
+ if (!xdr_rpc_loc_ni_service_interaction_e_type (xdrs, &objp->service_interation_type))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_ni_event_payload_u_type (XDR *xdrs, rpc_loc_ni_event_payload_u_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_rpc_loc_ni_event_e_type (xdrs, &objp->disc))
+ return FALSE;
+ switch (objp->disc) {
+ case RPC_LOC_NI_EVENT_VX_NOTIFY_VERIFY_REQ:
+ if (!xdr_rpc_loc_ni_vx_notify_verify_req_s_type (xdrs, &objp->rpc_loc_ni_event_payload_u_type_u.vx_req))
+ return FALSE;
+ break;
+ case RPC_LOC_NI_EVENT_SUPL_NOTIFY_VERIFY_REQ:
+ if (!xdr_rpc_loc_ni_supl_notify_verify_req_s_type (xdrs, &objp->rpc_loc_ni_event_payload_u_type_u.supl_req))
+ return FALSE;
+ break;
+ case RPC_LOC_NI_EVENT_UMTS_CP_NOTIFY_VERIFY_REQ:
+ if (!xdr_rpc_loc_ni_umts_cp_notify_verify_req_s_type (xdrs, &objp->rpc_loc_ni_event_payload_u_type_u.umts_cp_req))
+ return FALSE;
+ break;
+ case RPC_LOC_NI_EVENT_VX_SERVICE_INTERACTION_REQ:
+ if (!xdr_rpc_loc_ni_vx_service_interaction_req_s_type (xdrs, &objp->rpc_loc_ni_event_payload_u_type_u.service_interaction_req))
+ return FALSE;
+ break;
+ default:
+ break;
+ }
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_ni_event_s_type (XDR *xdrs, rpc_loc_ni_event_s_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_rpc_loc_ni_event_e_type (xdrs, &objp->event))
+ return FALSE;
+ if (!xdr_rpc_loc_ni_event_payload_u_type (xdrs, &objp->payload))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_assist_data_request_e_type (XDR *xdrs, rpc_loc_assist_data_request_e_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_enum (xdrs, (enum_t *) objp))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_struct_loc_time_download_source_s_type_servers_ptr (XDR *xdrs, rpc_struct_loc_time_download_source_s_type_servers_ptr *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_string (xdrs, objp, 256))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_struct_loc_time_download_source_s_type_servers (XDR *xdrs, rpc_struct_loc_time_download_source_s_type_servers objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_vector (xdrs, (char *)objp, 3,
+ sizeof (rpc_struct_loc_time_download_source_s_type_servers_ptr), (xdrproc_t) xdr_rpc_struct_loc_time_download_source_s_type_servers_ptr))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_time_download_source_s_type (XDR *xdrs, rpc_loc_time_download_source_s_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_rpc_uint32 (xdrs, &objp->delay_threshold))
+ return FALSE;
+ if (!xdr_rpc_struct_loc_time_download_source_s_type_servers (xdrs, objp->servers))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_struct_loc_predicted_orbits_data_source_s_type_servers_ptr (XDR *xdrs, rpc_struct_loc_predicted_orbits_data_source_s_type_servers_ptr *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_string (xdrs, objp, 256))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_struct_loc_predicted_orbits_data_source_s_type_servers (XDR *xdrs, rpc_struct_loc_predicted_orbits_data_source_s_type_servers objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_vector (xdrs, (char *)objp, 3,
+ sizeof (rpc_struct_loc_predicted_orbits_data_source_s_type_servers_ptr), (xdrproc_t) xdr_rpc_struct_loc_predicted_orbits_data_source_s_type_servers_ptr))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_predicted_orbits_data_source_s_type (XDR *xdrs, rpc_loc_predicted_orbits_data_source_s_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_rpc_uint32 (xdrs, &objp->max_file_size))
+ return FALSE;
+ if (!xdr_rpc_uint32 (xdrs, &objp->max_part_size))
+ return FALSE;
+ if (!xdr_rpc_struct_loc_predicted_orbits_data_source_s_type_servers (xdrs, objp->servers))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_pos_inj_request_s_type (XDR *xdrs, rpc_loc_pos_inj_request_s_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_rpc_uint32 (xdrs, &objp->flags))
+ return FALSE;
+ if (!xdr_double (xdrs, &objp->latitude))
+ return FALSE;
+ if (!xdr_double (xdrs, &objp->longitude))
+ return FALSE;
+ if (!xdr_rpc_uint32 (xdrs, &objp->position_uncertainty))
+ return FALSE;
+ if (!xdr_rpc_uint64 (xdrs, &objp->timestamp))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_assist_data_request_payload_u_type (XDR *xdrs, rpc_loc_assist_data_request_payload_u_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_rpc_loc_assist_data_request_e_type (xdrs, &objp->disc))
+ return FALSE;
+ switch (objp->disc) {
+ case RPC_LOC_ASSIST_DATA_TIME_REQ:
+ if (!xdr_rpc_loc_time_download_source_s_type (xdrs, &objp->rpc_loc_assist_data_request_payload_u_type_u.time_download))
+ return FALSE;
+ break;
+ case RPC_LOC_ASSIST_DATA_PREDICTED_ORBITS_REQ:
+ if (!xdr_rpc_loc_predicted_orbits_data_source_s_type (xdrs, &objp->rpc_loc_assist_data_request_payload_u_type_u.data_download))
+ return FALSE;
+ break;
+ case RPC_LOC_ASSIST_DATA_POSITION_INJECTION_REQ:
+ if (!xdr_rpc_loc_pos_inj_request_s_type (xdrs, &objp->rpc_loc_assist_data_request_payload_u_type_u.pos_injection))
+ return FALSE;
+ break;
+ default:
+ break;
+ }
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_assist_data_request_s_type (XDR *xdrs, rpc_loc_assist_data_request_s_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_rpc_loc_assist_data_request_e_type (xdrs, &objp->event))
+ return FALSE;
+ if (!xdr_rpc_loc_assist_data_request_payload_u_type (xdrs, &objp->payload))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_server_connection_handle (XDR *xdrs, rpc_loc_server_connection_handle *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_rpc_uint32 (xdrs, objp))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_server_protocol_e_type (XDR *xdrs, rpc_loc_server_protocol_e_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_enum (xdrs, (enum_t *) objp))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_server_connection_e_type (XDR *xdrs, rpc_loc_server_connection_e_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_enum (xdrs, (enum_t *) objp))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_server_request_e_type (XDR *xdrs, rpc_loc_server_request_e_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_enum (xdrs, (enum_t *) objp))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_server_open_req_s_type (XDR *xdrs, rpc_loc_server_open_req_s_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_rpc_loc_server_connection_handle (xdrs, &objp->conn_handle))
+ return FALSE;
+ if (!xdr_rpc_loc_server_protocol_e_type (xdrs, &objp->protocol))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_server_multi_open_req_s_type (XDR *xdrs, rpc_loc_server_multi_open_req_s_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_rpc_loc_server_connection_handle (xdrs, &objp->conn_handle))
+ return FALSE;
+ if (!xdr_rpc_loc_server_protocol_e_type (xdrs, &objp->protocol))
+ return FALSE;
+ if (!xdr_rpc_loc_server_connection_e_type (xdrs, &objp->connection_type))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_server_close_req_s_type (XDR *xdrs, rpc_loc_server_close_req_s_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_rpc_loc_server_connection_handle (xdrs, &objp->conn_handle))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_server_request_u_type (XDR *xdrs, rpc_loc_server_request_u_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_rpc_loc_server_request_e_type (xdrs, &objp->disc))
+ return FALSE;
+ switch (objp->disc) {
+ case RPC_LOC_SERVER_REQUEST_OPEN:
+ if (!xdr_rpc_loc_server_open_req_s_type (xdrs, &objp->rpc_loc_server_request_u_type_u.open_req))
+ return FALSE;
+ break;
+ case RPC_LOC_SERVER_REQUEST_CLOSE:
+ if (!xdr_rpc_loc_server_close_req_s_type (xdrs, &objp->rpc_loc_server_request_u_type_u.close_req))
+ return FALSE;
+ break;
+ case RPC_LOC_SERVER_REQUEST_MULTI_OPEN:
+ if (!xdr_rpc_loc_server_multi_open_req_s_type (xdrs, &objp->rpc_loc_server_request_u_type_u.multi_open_req))
+ return FALSE;
+ break;
+ default:
+ break;
+ }
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_server_request_s_type (XDR *xdrs, rpc_loc_server_request_s_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_rpc_loc_server_request_e_type (xdrs, &objp->event))
+ return FALSE;
+ if (!xdr_rpc_loc_server_request_u_type (xdrs, &objp->payload))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_qwip_request_e_type (XDR *xdrs, rpc_loc_qwip_request_e_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_enum (xdrs, (enum_t *) objp))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_qwip_request_s_type (XDR *xdrs, rpc_loc_qwip_request_s_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_rpc_loc_qwip_request_e_type (xdrs, &objp->request_type))
+ return FALSE;
+ if (!xdr_rpc_uint16 (xdrs, &objp->tbf_ms))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_reserved_payload_s_type (XDR *xdrs, rpc_loc_reserved_payload_s_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_rpc_uint16 (xdrs, &objp->data_size))
+ return FALSE;
+ if (!xdr_bytes (xdrs, (char **)&objp->data.data_val, (u_int *) &objp->data.data_len, ~0))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_ioctl_e_type (XDR *xdrs, rpc_loc_ioctl_e_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_enum (xdrs, (enum_t *) objp))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_api_version_s_type (XDR *xdrs, rpc_loc_api_version_s_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_u_char (xdrs, &objp->major))
+ return FALSE;
+ if (!xdr_u_char (xdrs, &objp->minor))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_fix_recurrence_e_type (XDR *xdrs, rpc_loc_fix_recurrence_e_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_enum (xdrs, (enum_t *) objp))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_operation_mode_e_type (XDR *xdrs, rpc_loc_operation_mode_e_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_enum (xdrs, (enum_t *) objp))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_notify_e_type (XDR *xdrs, rpc_loc_notify_e_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_enum (xdrs, (enum_t *) objp))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_fix_criteria_s_type (XDR *xdrs, rpc_loc_fix_criteria_s_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_rpc_uint32 (xdrs, &objp->valid_mask))
+ return FALSE;
+ if (!xdr_rpc_loc_fix_recurrence_e_type (xdrs, &objp->recurrence_type))
+ return FALSE;
+ if (!xdr_rpc_loc_operation_mode_e_type (xdrs, &objp->preferred_operation_mode))
+ return FALSE;
+ if (!xdr_rpc_uint32 (xdrs, &objp->preferred_accuracy))
+ return FALSE;
+ if (!xdr_rpc_uint32 (xdrs, &objp->preferred_response_time))
+ return FALSE;
+ if (!xdr_rpc_boolean (xdrs, &objp->intermediate_pos_report_enabled))
+ return FALSE;
+ if (!xdr_rpc_loc_notify_e_type (xdrs, &objp->notify_type))
+ return FALSE;
+ if (!xdr_rpc_uint32 (xdrs, &objp->min_interval))
+ return FALSE;
+ if (!xdr_float (xdrs, &objp->min_distance))
+ return FALSE;
+ if (!xdr_rpc_uint32 (xdrs, &objp->min_dist_sample_interval))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_ni_user_resp_e_type (XDR *xdrs, rpc_loc_ni_user_resp_e_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_enum (xdrs, (enum_t *) objp))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_user_verify_s_type (XDR *xdrs, rpc_loc_user_verify_s_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_rpc_loc_ni_user_resp_e_type (xdrs, &objp->user_resp))
+ return FALSE;
+ if (!xdr_rpc_loc_ni_event_s_type (xdrs, &objp->ni_event_pass_back))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_predicted_orbits_data_format_e_type (XDR *xdrs, rpc_loc_predicted_orbits_data_format_e_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_enum (xdrs, (enum_t *) objp))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_predicted_orbits_data_s_type (XDR *xdrs, rpc_loc_predicted_orbits_data_s_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_rpc_loc_predicted_orbits_data_format_e_type (xdrs, &objp->format_type))
+ return FALSE;
+ if (!xdr_rpc_uint32 (xdrs, &objp->total_size))
+ return FALSE;
+ if (!xdr_rpc_uint8 (xdrs, &objp->total_parts))
+ return FALSE;
+ if (!xdr_rpc_uint8 (xdrs, &objp->part))
+ return FALSE;
+ if (!xdr_rpc_uint16 (xdrs, &objp->part_len))
+ return FALSE;
+ if (!xdr_bytes (xdrs, (char **)&objp->data_ptr.data_ptr_val, (u_int *) &objp->data_ptr.data_ptr_len, ~0))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_predicted_orbits_data_validity_report_s_type (XDR *xdrs, rpc_loc_predicted_orbits_data_validity_report_s_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_rpc_uint64 (xdrs, &objp->start_time_utc))
+ return FALSE;
+ if (!xdr_rpc_uint16 (xdrs, &objp->valid_duration_hrs))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_predicted_orbits_auto_download_config_s_type (XDR *xdrs, rpc_loc_predicted_orbits_auto_download_config_s_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_rpc_boolean (xdrs, &objp->enable))
+ return FALSE;
+ if (!xdr_u_char (xdrs, &objp->auto_check_every_hrs))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_assist_data_time_s_type (XDR *xdrs, rpc_loc_assist_data_time_s_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_rpc_uint64 (xdrs, &objp->time_utc))
+ return FALSE;
+ if (!xdr_rpc_uint32 (xdrs, &objp->uncertainty))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_assist_pos_valid_mask_type (XDR *xdrs, rpc_loc_assist_pos_valid_mask_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_rpc_uint64 (xdrs, objp))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_assist_data_pos_s_type (XDR *xdrs, rpc_loc_assist_data_pos_s_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_rpc_loc_assist_pos_valid_mask_type (xdrs, &objp->valid_mask))
+ return FALSE;
+ if (!xdr_rpc_uint64 (xdrs, &objp->timestamp_utc))
+ return FALSE;
+ if (!xdr_double (xdrs, &objp->latitude))
+ return FALSE;
+ if (!xdr_double (xdrs, &objp->longitude))
+ return FALSE;
+ if (!xdr_float (xdrs, &objp->altitude_wrt_ellipsoid))
+ return FALSE;
+ if (!xdr_float (xdrs, &objp->altitude_wrt_mean_sea_level))
+ return FALSE;
+ if (!xdr_float (xdrs, &objp->hor_unc_circular))
+ return FALSE;
+ if (!xdr_float (xdrs, &objp->vert_unc))
+ return FALSE;
+ if (!xdr_u_char (xdrs, &objp->confidence_horizontal))
+ return FALSE;
+ if (!xdr_u_char (xdrs, &objp->confidence_vertical))
+ return FALSE;
+ if (!xdr_rpc_int32 (xdrs, &objp->timestamp_age))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_server_open_status_e_type (XDR *xdrs, rpc_loc_server_open_status_e_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_enum (xdrs, (enum_t *) objp))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_server_pdp_type_e_type (XDR *xdrs, rpc_loc_server_pdp_type_e_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_enum (xdrs, (enum_t *) objp))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_server_open_status_s_type (XDR *xdrs, rpc_loc_server_open_status_s_type *objp)
+{
+ register int32_t *buf;
+
+ int i;
+ if (!xdr_rpc_loc_server_connection_handle (xdrs, &objp->conn_handle))
+ return FALSE;
+ if (!xdr_rpc_loc_server_open_status_e_type (xdrs, &objp->open_status))
+ return FALSE;
+ if (!xdr_opaque (xdrs, objp->apn_name, 100))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_server_multi_open_status_s_type (XDR *xdrs, rpc_loc_server_multi_open_status_s_type *objp)
+{
+ register int32_t *buf;
+
+ int i;
+ if (!xdr_rpc_loc_server_connection_handle (xdrs, &objp->conn_handle))
+ return FALSE;
+ if (!xdr_rpc_loc_server_open_status_e_type (xdrs, &objp->open_status))
+ return FALSE;
+ if (!xdr_rpc_loc_server_pdp_type_e_type (xdrs, &objp->pdp_type))
+ return FALSE;
+ if (!xdr_opaque (xdrs, objp->apn_name, 100))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_server_close_status_e_type (XDR *xdrs, rpc_loc_server_close_status_e_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_enum (xdrs, (enum_t *) objp))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_server_close_status_s_type (XDR *xdrs, rpc_loc_server_close_status_s_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_rpc_loc_server_connection_handle (xdrs, &objp->conn_handle))
+ return FALSE;
+ if (!xdr_rpc_loc_server_close_status_e_type (xdrs, &objp->close_status))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_wiper_fix_time_s_type (XDR *xdrs, rpc_loc_wiper_fix_time_s_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_rpc_uint32 (xdrs, &objp->slow_clock_count))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_wiper_fix_pos_s_type (XDR *xdrs, rpc_loc_wiper_fix_pos_s_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_rpc_int32 (xdrs, &objp->lat))
+ return FALSE;
+ if (!xdr_rpc_int32 (xdrs, &objp->lon))
+ return FALSE;
+ if (!xdr_rpc_uint16 (xdrs, &objp->HEPE))
+ return FALSE;
+ if (!xdr_rpc_uint8 (xdrs, &objp->num_of_aps_used))
+ return FALSE;
+ if (!xdr_rpc_uint8 (xdrs, &objp->fix_error_code))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_wiper_ap_info_s_type (XDR *xdrs, rpc_loc_wiper_ap_info_s_type *objp)
+{
+ register int32_t *buf;
+
+ int i;
+ if (!xdr_opaque (xdrs, objp->mac_addr, 6))
+ return FALSE;
+ if (!xdr_rpc_int32 (xdrs, &objp->rssi))
+ return FALSE;
+ if (!xdr_rpc_uint16 (xdrs, &objp->channel))
+ return FALSE;
+ if (!xdr_rpc_uint8 (xdrs, &objp->ap_qualifier))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_wiper_ap_set_s_type (XDR *xdrs, rpc_loc_wiper_ap_set_s_type *objp)
+{
+ register int32_t *buf;
+
+ int i;
+ if (!xdr_rpc_uint8 (xdrs, &objp->num_of_aps))
+ return FALSE;
+ if (!xdr_vector (xdrs, (char *)objp->ap_info, 50,
+ sizeof (rpc_loc_wiper_ap_info_s_type), (xdrproc_t) xdr_rpc_loc_wiper_ap_info_s_type))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_wiper_position_report_s_type (XDR *xdrs, rpc_loc_wiper_position_report_s_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_rpc_uint8 (xdrs, &objp->wiper_valid_info_flag))
+ return FALSE;
+ if (!xdr_rpc_loc_wiper_fix_time_s_type (xdrs, &objp->wiper_fix_time))
+ return FALSE;
+ if (!xdr_rpc_loc_wiper_fix_pos_s_type (xdrs, &objp->wiper_fix_position))
+ return FALSE;
+ if (!xdr_rpc_loc_wiper_ap_set_s_type (xdrs, &objp->wiper_ap_set))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_wiper_status_e_type (XDR *xdrs, rpc_loc_wiper_status_e_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_enum (xdrs, (enum_t *) objp))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_fs_operation_e_type (XDR *xdrs, rpc_loc_fs_operation_e_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_enum (xdrs, (enum_t *) objp))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_efs_data_s_type (XDR *xdrs, rpc_loc_efs_data_s_type *objp)
+{
+ register int32_t *buf;
+
+ int i;
+ if (!xdr_opaque (xdrs, objp->filename, 64))
+ return FALSE;
+ if (!xdr_rpc_loc_fs_operation_e_type (xdrs, &objp->operation))
+ return FALSE;
+ if (!xdr_rpc_uint32 (xdrs, &objp->total_size))
+ return FALSE;
+ if (!xdr_bytes (xdrs, (char **)&objp->data_ptr.data_ptr_val, (u_int *) &objp->data_ptr.data_ptr_len, ~0))
+ return FALSE;
+ if (!xdr_rpc_uint32 (xdrs, &objp->part_len))
+ return FALSE;
+ if (!xdr_rpc_uint8 (xdrs, &objp->part))
+ return FALSE;
+ if (!xdr_rpc_uint8 (xdrs, &objp->total_parts))
+ return FALSE;
+ if (!xdr_rpc_uint32 (xdrs, &objp->reserved))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_error_estimate_config_e_type (XDR *xdrs, rpc_loc_error_estimate_config_e_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_enum (xdrs, (enum_t *) objp))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_apn_profiles_type (XDR *xdrs, rpc_loc_apn_profiles_type *objp)
+{
+ register int32_t *buf;
+
+ int i;
+ if (!xdr_rpc_uint32 (xdrs, &objp->srv_system_type))
+ return FALSE;
+ if (!xdr_rpc_uint32 (xdrs, &objp->pdp_type))
+ return FALSE;
+ if (!xdr_rpc_uint32 (xdrs, &objp->reserved))
+ return FALSE;
+ if (!xdr_opaque (xdrs, objp->apn_name, 100))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_lock_e_type (XDR *xdrs, rpc_loc_lock_e_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_enum (xdrs, (enum_t *) objp))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_nmea_sentence_type (XDR *xdrs, rpc_loc_nmea_sentence_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_rpc_uint32 (xdrs, objp))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_assist_data_type (XDR *xdrs, rpc_loc_assist_data_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_rpc_uint32 (xdrs, objp))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_assist_data_delete_s_type (XDR *xdrs, rpc_loc_assist_data_delete_s_type *objp)
+{
+ register int32_t *buf;
+
+ int i;
+ if (!xdr_rpc_loc_assist_data_type (xdrs, &objp->type))
+ return FALSE;
+ if (!xdr_vector (xdrs, (char *)objp->reserved, 8,
+ sizeof (rpc_uint32), (xdrproc_t) xdr_rpc_uint32))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_ioctl_data_u_type (XDR *xdrs, rpc_loc_ioctl_data_u_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_rpc_loc_ioctl_e_type (xdrs, &objp->disc))
+ return FALSE;
+ switch (objp->disc) {
+ case RPC_LOC_IOCTL_SET_FIX_CRITERIA:
+ if (!xdr_rpc_loc_fix_criteria_s_type (xdrs, &objp->rpc_loc_ioctl_data_u_type_u.fix_criteria))
+ return FALSE;
+ break;
+ case RPC_LOC_IOCTL_INFORM_NI_USER_RESPONSE:
+ if (!xdr_rpc_loc_user_verify_s_type (xdrs, &objp->rpc_loc_ioctl_data_u_type_u.user_verify_resp))
+ return FALSE;
+ break;
+ case RPC_LOC_IOCTL_INJECT_PREDICTED_ORBITS_DATA:
+ if (!xdr_rpc_loc_predicted_orbits_data_s_type (xdrs, &objp->rpc_loc_ioctl_data_u_type_u.predicted_orbits_data))
+ return FALSE;
+ break;
+ case RPC_LOC_IOCTL_SET_PREDICTED_ORBITS_DATA_AUTO_DOWNLOAD:
+ if (!xdr_rpc_loc_predicted_orbits_auto_download_config_s_type (xdrs, &objp->rpc_loc_ioctl_data_u_type_u.predicted_orbits_auto_download))
+ return FALSE;
+ break;
+ case RPC_LOC_IOCTL_INJECT_UTC_TIME:
+ if (!xdr_rpc_loc_assist_data_time_s_type (xdrs, &objp->rpc_loc_ioctl_data_u_type_u.assistance_data_time))
+ return FALSE;
+ break;
+ case RPC_LOC_IOCTL_INJECT_POSITION:
+ if (!xdr_rpc_loc_assist_data_pos_s_type (xdrs, &objp->rpc_loc_ioctl_data_u_type_u.assistance_data_position))
+ return FALSE;
+ break;
+ case RPC_LOC_IOCTL_INFORM_SERVER_OPEN_STATUS:
+ if (!xdr_rpc_loc_server_open_status_s_type (xdrs, &objp->rpc_loc_ioctl_data_u_type_u.conn_open_status))
+ return FALSE;
+ break;
+ case RPC_LOC_IOCTL_INFORM_SERVER_CLOSE_STATUS:
+ if (!xdr_rpc_loc_server_close_status_s_type (xdrs, &objp->rpc_loc_ioctl_data_u_type_u.conn_close_status))
+ return FALSE;
+ break;
+ case RPC_LOC_IOCTL_SEND_WIPER_POSITION_REPORT:
+ if (!xdr_rpc_loc_wiper_position_report_s_type (xdrs, &objp->rpc_loc_ioctl_data_u_type_u.wiper_pos))
+ return FALSE;
+ break;
+ case RPC_LOC_IOCTL_NOTIFY_WIPER_STATUS:
+ if (!xdr_rpc_loc_wiper_status_e_type (xdrs, &objp->rpc_loc_ioctl_data_u_type_u.wiper_status))
+ return FALSE;
+ break;
+ case RPC_LOC_IOCTL_SET_ENGINE_LOCK:
+ if (!xdr_rpc_loc_lock_e_type (xdrs, &objp->rpc_loc_ioctl_data_u_type_u.engine_lock))
+ return FALSE;
+ break;
+ case RPC_LOC_IOCTL_SET_SBAS_CONFIG:
+ if (!xdr_rpc_boolean (xdrs, &objp->rpc_loc_ioctl_data_u_type_u.sbas_mode))
+ return FALSE;
+ break;
+ case RPC_LOC_IOCTL_SET_NMEA_TYPES:
+ if (!xdr_rpc_loc_nmea_sentence_type (xdrs, &objp->rpc_loc_ioctl_data_u_type_u.nmea_types))
+ return FALSE;
+ break;
+ case RPC_LOC_IOCTL_SET_ON_DEMAND_LPM:
+ if (!xdr_rpc_boolean (xdrs, &objp->rpc_loc_ioctl_data_u_type_u.on_demand_lpm))
+ return FALSE;
+ break;
+ case RPC_LOC_IOCTL_SET_CDMA_PDE_SERVER_ADDR:
+ case RPC_LOC_IOCTL_SET_CDMA_MPC_SERVER_ADDR:
+ case RPC_LOC_IOCTL_SET_UMTS_SLP_SERVER_ADDR:
+ case RPC_LOC_IOCTL_SET_CUSTOM_PDE_SERVER_ADDR:
+ if (!xdr_rpc_loc_server_info_s_type (xdrs, &objp->rpc_loc_ioctl_data_u_type_u.server_addr))
+ return FALSE;
+ break;
+ case RPC_LOC_IOCTL_DELETE_ASSIST_DATA:
+ if (!xdr_rpc_loc_assist_data_delete_s_type (xdrs, &objp->rpc_loc_ioctl_data_u_type_u.assist_data_delete))
+ return FALSE;
+ break;
+ case RPC_LOC_IOCTL_ACCESS_EFS_DATA:
+ if (!xdr_rpc_loc_efs_data_s_type (xdrs, &objp->rpc_loc_ioctl_data_u_type_u.efs_data))
+ return FALSE;
+ break;
+ case RPC_LOC_IOCTL_ERROR_ESTIMATE_CONFIG:
+ if (!xdr_rpc_loc_error_estimate_config_e_type (xdrs, &objp->rpc_loc_ioctl_data_u_type_u.error_estimate_config))
+ return FALSE;
+ break;
+ case RPC_LOC_IOCTL_SET_XTRA_T_SESSION_CONTROL:
+ if (!xdr_rpc_uint8 (xdrs, &objp->rpc_loc_ioctl_data_u_type_u.xtra_t_session_control))
+ return FALSE;
+ break;
+ case RPC_LOC_IOCTL_SET_LBS_APN_PROFILE:
+ case RPC_LOC_IOCTL_SET_XTRA_APN_PROFILE:
+ if (!xdr_vector (xdrs, (char *)objp->rpc_loc_ioctl_data_u_type_u.apn_profiles, 6,
+ sizeof (rpc_loc_apn_profiles_type), (xdrproc_t) xdr_rpc_loc_apn_profiles_type))
+ return FALSE;
+ break;
+ case RPC_LOC_IOCTL_SET_DATA_ENABLE:
+ if (!xdr_rpc_boolean (xdrs, &objp->rpc_loc_ioctl_data_u_type_u.data_enable))
+ return FALSE;
+ break;
+ case RPC_LOC_IOCTL_SET_SUPL_VERSION:
+ if (!xdr_rpc_uint32 (xdrs, &objp->rpc_loc_ioctl_data_u_type_u.supl_version))
+ return FALSE;
+ break;
+ case RPC_LOC_IOCTL_INFORM_SERVER_MULTI_OPEN_STATUS:
+ if (!xdr_rpc_loc_server_multi_open_status_s_type (xdrs, &objp->rpc_loc_ioctl_data_u_type_u.multi_conn_open_status))
+ return FALSE;
+ break;
+ case RPC_LOC_IOCTL_RESERVED_CMD:
+ if (!xdr_rpc_loc_reserved_payload_s_type (xdrs, &objp->rpc_loc_ioctl_data_u_type_u.reserved))
+ return FALSE;
+ break;
+ default:
+ break;
+ }
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_ioctl_callback_data_u_type (XDR *xdrs, rpc_loc_ioctl_callback_data_u_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_rpc_loc_ioctl_e_type (xdrs, &objp->disc))
+ return FALSE;
+ switch (objp->disc) {
+ case RPC_LOC_IOCTL_GET_API_VERSION:
+ if (!xdr_rpc_loc_api_version_s_type (xdrs, &objp->rpc_loc_ioctl_callback_data_u_type_u.api_version))
+ return FALSE;
+ break;
+ case RPC_LOC_IOCTL_GET_FIX_CRITERIA:
+ if (!xdr_rpc_loc_fix_criteria_s_type (xdrs, &objp->rpc_loc_ioctl_callback_data_u_type_u.fix_criteria))
+ return FALSE;
+ break;
+ case RPC_LOC_IOCTL_GET_ENGINE_LOCK:
+ if (!xdr_rpc_loc_lock_e_type (xdrs, &objp->rpc_loc_ioctl_callback_data_u_type_u.engine_lock))
+ return FALSE;
+ break;
+ case RPC_LOC_IOCTL_GET_SBAS_CONFIG:
+ if (!xdr_rpc_boolean (xdrs, &objp->rpc_loc_ioctl_callback_data_u_type_u.sbas_mode))
+ return FALSE;
+ break;
+ case RPC_LOC_IOCTL_GET_NMEA_TYPES:
+ if (!xdr_rpc_loc_nmea_sentence_type (xdrs, &objp->rpc_loc_ioctl_callback_data_u_type_u.nmea_types))
+ return FALSE;
+ break;
+ case RPC_LOC_IOCTL_GET_ON_DEMAND_LPM:
+ if (!xdr_rpc_boolean (xdrs, &objp->rpc_loc_ioctl_callback_data_u_type_u.on_demand_lpm))
+ return FALSE;
+ break;
+ case RPC_LOC_IOCTL_GET_CDMA_PDE_SERVER_ADDR:
+ case RPC_LOC_IOCTL_GET_CDMA_MPC_SERVER_ADDR:
+ case RPC_LOC_IOCTL_GET_UMTS_SLP_SERVER_ADDR:
+ case RPC_LOC_IOCTL_GET_CUSTOM_PDE_SERVER_ADDR:
+ if (!xdr_rpc_loc_server_info_s_type (xdrs, &objp->rpc_loc_ioctl_callback_data_u_type_u.server_addr))
+ return FALSE;
+ break;
+ case RPC_LOC_IOCTL_QUERY_PREDICTED_ORBITS_DATA_SOURCE:
+ if (!xdr_rpc_loc_predicted_orbits_data_source_s_type (xdrs, &objp->rpc_loc_ioctl_callback_data_u_type_u.predicted_orbits_data_source))
+ return FALSE;
+ break;
+ case RPC_LOC_IOCTL_QUERY_PREDICTED_ORBITS_DATA_VALIDITY:
+ if (!xdr_rpc_loc_predicted_orbits_data_validity_report_s_type (xdrs, &objp->rpc_loc_ioctl_callback_data_u_type_u.predicted_orbits_data_validity))
+ return FALSE;
+ break;
+ case RPC_LOC_IOCTL_GET_XTRA_T_SESSION_CONTROL:
+ if (!xdr_rpc_uint8 (xdrs, &objp->rpc_loc_ioctl_callback_data_u_type_u.xtra_t_session_control))
+ return FALSE;
+ break;
+ case RPC_LOC_IOCTL_GET_LBS_APN_PROFILE:
+ case RPC_LOC_IOCTL_GET_XTRA_APN_PROFILE:
+ if (!xdr_vector (xdrs, (char *)objp->rpc_loc_ioctl_callback_data_u_type_u.apn_profiles, 6,
+ sizeof (rpc_loc_apn_profiles_type), (xdrproc_t) xdr_rpc_loc_apn_profiles_type))
+ return FALSE;
+ break;
+ case RPC_LOC_IOCTL_GET_SUPL_VERSION:
+ if (!xdr_rpc_uint32 (xdrs, &objp->rpc_loc_ioctl_callback_data_u_type_u.supl_version))
+ return FALSE;
+ break;
+ default:
+ break;
+ }
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_ioctl_callback_s_type (XDR *xdrs, rpc_loc_ioctl_callback_s_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_rpc_loc_ioctl_e_type (xdrs, &objp->type))
+ return FALSE;
+ if (!xdr_rpc_int32 (xdrs, &objp->status))
+ return FALSE;
+ if (!xdr_rpc_loc_ioctl_callback_data_u_type (xdrs, &objp->data))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_event_payload_u_type (XDR *xdrs, rpc_loc_event_payload_u_type *objp)
+{
+ register int32_t *buf;
+
+ if (!xdr_u_quad_t (xdrs, &objp->disc))
+ return FALSE;
+ switch (objp->disc) {
+ case RPC_LOC_EVENT_PARSED_POSITION_REPORT:
+ if (!xdr_rpc_loc_parsed_position_s_type (xdrs, &objp->rpc_loc_event_payload_u_type_u.parsed_location_report))
+ return FALSE;
+ break;
+ case RPC_LOC_EVENT_SATELLITE_REPORT:
+ if (!xdr_rpc_loc_gnss_info_s_type (xdrs, &objp->rpc_loc_event_payload_u_type_u.gnss_report))
+ return FALSE;
+ break;
+ case RPC_LOC_EVENT_NMEA_POSITION_REPORT:
+ case RPC_LOC_EVENT_NMEA_1HZ_REPORT:
+ if (!xdr_rpc_loc_nmea_report_s_type (xdrs, &objp->rpc_loc_event_payload_u_type_u.nmea_report))
+ return FALSE;
+ break;
+ case RPC_LOC_EVENT_NI_NOTIFY_VERIFY_REQUEST:
+ if (!xdr_rpc_loc_ni_event_s_type (xdrs, &objp->rpc_loc_event_payload_u_type_u.ni_request))
+ return FALSE;
+ break;
+ case RPC_LOC_EVENT_ASSISTANCE_DATA_REQUEST:
+ if (!xdr_rpc_loc_assist_data_request_s_type (xdrs, &objp->rpc_loc_event_payload_u_type_u.assist_data_request))
+ return FALSE;
+ break;
+ case RPC_LOC_EVENT_LOCATION_SERVER_REQUEST:
+ if (!xdr_rpc_loc_server_request_s_type (xdrs, &objp->rpc_loc_event_payload_u_type_u.loc_server_request))
+ return FALSE;
+ break;
+ case RPC_LOC_EVENT_IOCTL_REPORT:
+ if (!xdr_rpc_loc_ioctl_callback_s_type (xdrs, &objp->rpc_loc_event_payload_u_type_u.ioctl_report))
+ return FALSE;
+ break;
+ case RPC_LOC_EVENT_STATUS_REPORT:
+ if (!xdr_rpc_loc_status_event_s_type (xdrs, &objp->rpc_loc_event_payload_u_type_u.status_report))
+ return FALSE;
+ break;
+ case RPC_LOC_EVENT_WPS_NEEDED_REQUEST:
+ if (!xdr_rpc_loc_qwip_request_s_type (xdrs, &objp->rpc_loc_event_payload_u_type_u.qwip_request))
+ return FALSE;
+ break;
+ case RPC_LOC_EVENT_RESERVED:
+ if (!xdr_rpc_loc_reserved_payload_s_type (xdrs, &objp->rpc_loc_event_payload_u_type_u.reserved))
+ return FALSE;
+ break;
+ default:
+ break;
+ }
+ return TRUE;
+}
diff --git a/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/src/loc_api_rpcgen_xdr.c b/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/src/loc_api_rpcgen_xdr.c
new file mode 100644
index 0000000..a0fdcab
--- /dev/null
+++ b/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/src/loc_api_rpcgen_xdr.c
@@ -0,0 +1,199 @@
+/* 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
+ * 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.
+ *
+ */
+/*
+ * Please do not edit this file.
+ * It was generated using rpcgen.
+ */
+
+#include "loc_api_rpcgen_rpc.h"
+
+bool_t
+xdr_rpc_loc_api_api_versions_return_type (XDR *xdrs, rpc_loc_api_api_versions_return_type *objp)
+{
+;
+
+ if (!xdr_array (xdrs, (char **)&objp->rpc_loc_api_api_versions_return_type_val, (u_int *) &objp->rpc_loc_api_api_versions_return_type_len, ~0,
+ sizeof (rpc_uint32), (xdrproc_t) xdr_rpc_uint32))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_event_cb_f_type (XDR *xdrs, rpc_loc_event_cb_f_type *objp)
+{
+;
+
+ if (!xdr_rpc_uint32 (xdrs, objp))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_open_args (XDR *xdrs, rpc_loc_open_args *objp)
+{
+;
+
+ if (!xdr_rpc_loc_event_mask_type (xdrs, &objp->event_reg_mask))
+ return FALSE;
+ if (!xdr_rpc_loc_event_cb_f_type (xdrs, &objp->event_callback))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_close_args (XDR *xdrs, rpc_loc_close_args *objp)
+{
+;
+
+ if (!xdr_rpc_loc_client_handle_type (xdrs, &objp->handle))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_start_fix_args (XDR *xdrs, rpc_loc_start_fix_args *objp)
+{
+;
+
+ if (!xdr_rpc_loc_client_handle_type (xdrs, &objp->handle))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_stop_fix_args (XDR *xdrs, rpc_loc_stop_fix_args *objp)
+{
+;
+
+ if (!xdr_rpc_loc_client_handle_type (xdrs, &objp->handle))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_ioctl_args (XDR *xdrs, rpc_loc_ioctl_args *objp)
+{
+;
+
+ if (!xdr_rpc_loc_client_handle_type (xdrs, &objp->handle))
+ return FALSE;
+ if (!xdr_rpc_loc_ioctl_e_type (xdrs, &objp->ioctl_type))
+ return FALSE;
+ if (!xdr_pointer (xdrs, (char **)&objp->ioctl_data, sizeof (rpc_loc_ioctl_data_u_type), (xdrproc_t) xdr_rpc_loc_ioctl_data_u_type))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_api_api_version_s_args (XDR *xdrs, rpc_loc_api_api_version_s_args *objp)
+{
+;
+
+ if (!xdr_rpc_boolean (xdrs, &objp->len_not_null))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_api_rpc_glue_code_info_remote_rets (XDR *xdrs, rpc_loc_api_rpc_glue_code_info_remote_rets *objp)
+{
+;
+
+ if (!xdr_rpc_uint32 (xdrs, &objp->toolvers))
+ return FALSE;
+ if (!xdr_rpc_uint32 (xdrs, &objp->features))
+ return FALSE;
+ if (!xdr_rpc_uint32 (xdrs, &objp->proghash))
+ return FALSE;
+ if (!xdr_rpc_uint32 (xdrs, &objp->cbproghash))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_open_rets (XDR *xdrs, rpc_loc_open_rets *objp)
+{
+;
+
+ if (!xdr_rpc_loc_client_handle_type (xdrs, &objp->loc_open_result))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_close_rets (XDR *xdrs, rpc_loc_close_rets *objp)
+{
+;
+
+ if (!xdr_rpc_int32 (xdrs, &objp->loc_close_result))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_start_fix_rets (XDR *xdrs, rpc_loc_start_fix_rets *objp)
+{
+;
+
+ if (!xdr_rpc_int32 (xdrs, &objp->loc_start_fix_result))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_stop_fix_rets (XDR *xdrs, rpc_loc_stop_fix_rets *objp)
+{
+;
+
+ if (!xdr_rpc_int32 (xdrs, &objp->loc_stop_fix_result))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_ioctl_rets (XDR *xdrs, rpc_loc_ioctl_rets *objp)
+{
+;
+
+ if (!xdr_rpc_int32 (xdrs, &objp->loc_ioctl_result))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_rpc_loc_api_api_versions_rets (XDR *xdrs, rpc_loc_api_api_versions_rets *objp)
+{
+;
+
+ if (!xdr_rpc_loc_api_api_versions_return_type (xdrs, &objp->loc_api_api_versions_result))
+ return FALSE;
+ if (!xdr_pointer (xdrs, (char **)&objp->len, sizeof (rpc_uint32), (xdrproc_t) xdr_rpc_uint32))
+ return FALSE;
+ return TRUE;
+}
diff --git a/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/src/loc_apicb_appinit.c b/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/src/loc_apicb_appinit.c
new file mode 100644
index 0000000..b469eb0
--- /dev/null
+++ b/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/src/loc_apicb_appinit.c
@@ -0,0 +1,74 @@
+/* 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
+ * 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 "librpc.h"
+#include "loc_api_rpcgen_rpc.h"
+#include "loc_api_rpcgen_cb_rpc.h"
+
+
+#define RPC_FUNC_VERSION_BASE(a,b) a ## b
+#define RPC_CB_FUNC_VERS(a,b) RPC_FUNC_VERSION_BASE(a,b)
+
+
+static SVCXPRT* svrPort = NULL;
+
+extern void RPC_CB_FUNC_VERS(loc_apicbprog_,LOC_APICBVERS_0001)(struct svc_req *rqstp, register SVCXPRT *transp);
+
+int loc_apicb_app_init(void)
+{
+
+ /* Register a callback server to use the loc_apicbprog_0x00010001 */
+ if (svrPort == NULL) {
+ svrPort = svcrtr_create();
+ }
+ if (!svrPort) return -1;
+
+ xprt_register(svrPort);
+
+
+
+ if(svc_register(svrPort, LOC_APICBPROG,LOC_APICBVERS_0001, RPC_CB_FUNC_VERS(loc_apicbprog_,LOC_APICBVERS_0001),0))
+ {
+ return 0;
+ }
+ else
+ {
+ return -1;
+ }
+}
+void loc_apicb_app_deinit(void)
+{
+
+ if (svrPort == NULL)
+ {
+ return;
+ }
+
+
+ svc_unregister(svrPort, LOC_APICBPROG,LOC_APICBVERS_0001);
+}
diff --git a/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/xdr/loc_api.xdr b/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/xdr/loc_api.xdr
new file mode 100644
index 0000000..82dca56
--- /dev/null
+++ b/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/xdr/loc_api.xdr
@@ -0,0 +1,261 @@
+/* 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
+ * 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.
+ *
+ */
+/* LOC_API TOOL VERSION: 4.48 */
+/* GENERATED: TUE JUN 14 2011 */
+/*=============================================================================
+ L O C _ A P I . X D R
+
+GENERAL DESCRIPTION
+ This is an AUTO GENERATED file that provides an xdr compatible definition of
+ the loc_api API.
+
+ ---------------------------------------------------------------------------
+
+
+ ---------------------------------------------------------------------------
+=============================================================================*/
+
+/*=============================================================================
+
+ Edit History
+
+ AUTO GENERATED
+
+Generated by following versions of Htorpc modules:
+Id: //source/qcom/qct/core/mproc/tools/rel/2h09/htorpc/htorpc.pl#1
+Id: //source/qcom/qct/core/mproc/tools/rel/2h09/htorpc/lib/Htorpc/Start.pm#1
+Id: //source/qcom/qct/core/mproc/tools/rel/2h09/htorpc/lib/Htorpc/Htoxdr.pm#1
+Id: //source/qcom/qct/core/mproc/tools/rel/2h09/htorpc/lib/Htorpc/XDR.pm#3
+Id: //source/qcom/qct/core/mproc/tools/rel/2h09/htorpc/lib/Htorpc/Output.pm#5
+Id: //source/qcom/qct/core/mproc/tools/rel/2h09/htorpc/lib/Htorpc/Parser.pm#1
+Id: //source/qcom/qct/core/mproc/tools/rel/2h09/htorpc/lib/Htorpc/Metacomments.pm#1
+Id: //source/qcom/qct/core/mproc/tools/rel/2h09/htorpc/lib/Htorpc/SymbolTable.pm#1
+
+loc_api Definition File(s):
+Id: //source/qcom/qct/modem/api/gps/main/latest/loc_api.h#24
+=============================================================================*/
+/*=============================================================================
+$Header$
+=============================================================================*/
+
+
+
+typedef rpc_uint32 rpc_loc_api_api_versions_return_type<>;
+
+/*
+ * Declare an rpc_uint32 type for each callback type in the API
+ */
+typedef rpc_uint32 rpc_loc_event_cb_f_type;
+
+
+
+/*
+ * These are struct declarations for the function arguments
+ */
+
+struct rpc_loc_open_args {
+ rpc_loc_event_mask_type event_reg_mask;
+ rpc_loc_event_cb_f_type event_callback;
+};
+
+struct rpc_loc_close_args {
+ rpc_loc_client_handle_type handle;
+};
+
+struct rpc_loc_start_fix_args {
+ rpc_loc_client_handle_type handle;
+};
+
+struct rpc_loc_stop_fix_args {
+ rpc_loc_client_handle_type handle;
+};
+
+struct rpc_loc_ioctl_args {
+ rpc_loc_client_handle_type handle;
+ rpc_loc_ioctl_e_type ioctl_type;
+ rpc_loc_ioctl_data_u_type *ioctl_data;
+};
+
+
+
+struct rpc_loc_api_api_version_s_args {
+ rpc_boolean len_not_null;
+};
+
+/*
+ * These are struct declarations for the function results
+ */
+
+struct rpc_loc_api_rpc_glue_code_info_remote_rets {
+ rpc_uint32 toolvers; /* Tool version */
+ rpc_uint32 features; /* Features turned on in the code.
+ * 0x00000001 ONCRPC Server Cleanup Support
+ */
+ rpc_uint32 proghash; /* Unique hash value for the API XDR definition */
+ rpc_uint32 cbproghash; /* Unique hash value for the Callbacks' XDR definition */
+};
+
+struct rpc_loc_open_rets {
+ rpc_loc_client_handle_type loc_open_result;
+};
+
+struct rpc_loc_close_rets {
+ rpc_int32 loc_close_result;
+};
+
+struct rpc_loc_start_fix_rets {
+ rpc_int32 loc_start_fix_result;
+};
+
+struct rpc_loc_stop_fix_rets {
+ rpc_int32 loc_stop_fix_result;
+};
+
+struct rpc_loc_ioctl_rets {
+ rpc_int32 loc_ioctl_result;
+};
+
+ struct rpc_loc_api_api_versions_rets {
+ rpc_loc_api_api_versions_return_type loc_api_api_versions_result;
+ rpc_uint32 *len;
+};
+
+/*
+ * XDR definition of the LOC_API program ( vers. 0x00050006 )
+ */
+
+program LOC_APIPROG {
+ version LOC_APIVERS_0001 {
+
+ void
+ rpc_loc_api_null( void ) = 0;
+
+ rpc_loc_api_rpc_glue_code_info_remote_rets
+ rpc_loc_api_rpc_glue_code_info_remote( void ) = 1;
+
+ rpc_loc_open_rets
+ rpc_loc_open( rpc_loc_open_args ) = 2;
+
+ rpc_loc_close_rets
+ rpc_loc_close( rpc_loc_close_args ) = 3;
+
+ rpc_loc_start_fix_rets
+ rpc_loc_start_fix( rpc_loc_start_fix_args ) = 4;
+
+ rpc_loc_stop_fix_rets
+ rpc_loc_stop_fix( rpc_loc_stop_fix_args ) = 5;
+
+ rpc_loc_ioctl_rets
+ rpc_loc_ioctl( rpc_loc_ioctl_args ) = 6;
+
+ rpc_loc_api_api_versions_rets
+ rpc_loc_api_api_versions( void ) = 0xFFFFFFFF;
+
+
+
+
+ } = 0x00050001;
+
+version LOC_APIVERS_0002 {
+
+/* Following elements added in enum rpc_loc_assist_data_request_e_type in 0x00050002
+RPC_LOC_ASSIST_DATA_POSITION_INJECTION_REQ
+*/
+/* Following elements added in enum rpc_loc_ioctl_e_type in 0x00050002
+RPC_LOC_IOCTL_GET_XTRA_T_SESSION_CONTROL
+RPC_LOC_IOCTL_RESERVED_CMD
+RPC_LOC_IOCTL_SET_XTRA_T_SESSION_CONTROL
+*/
+
+ void
+ rpc_loc_api_null( void ) = 0;
+
+ } = 0x00050002;
+
+version LOC_APIVERS_0003 {
+
+/* Following elements added in enum rpc_loc_ioctl_e_type in 0x00050003
+RPC_LOC_IOCTL_SET_DATA_ENABLE
+RPC_LOC_IOCTL_SET_LBS_APN_PROFILE
+RPC_LOC_IOCTL_GET_XTRA_APN_PROFILE
+RPC_LOC_IOCTL_GET_LBS_APN_PROFILE
+RPC_LOC_IOCTL_SET_XTRA_APN_PROFILE
+*/
+
+ void
+ rpc_loc_api_null( void ) = 0;
+
+ } = 0x00050003;
+
+version LOC_APIVERS_0004 {
+
+/* Following elements added in enum rpc_loc_ioctl_e_type in 0x00050004
+RPC_LOC_IOCTL_GET_SUPL_VERSION
+RPC_LOC_IOCTL_SET_SUPL_VERSION
+*/
+
+ void
+ rpc_loc_api_null( void ) = 0;
+
+ } = 0x00050004;
+
+version LOC_APIVERS_0005 {
+
+/* Following elements added in enum rpc_loc_server_addr_e_type in 0x00050005
+RPC_LOC_SERVER_ADDR_IPV6
+*/
+/* Following elements added in enum rpc_loc_ioctl_e_type in 0x00050005
+RPC_LOC_IOCTL_ERROR_ESTIMATE_CONFIG
+*/
+
+ void
+ rpc_loc_api_null( void ) = 0;
+
+ } = 0x00050005;
+
+
+
+ version LOC_APIVERS_0006 {
+
+/* Following elements added in enum rpc_loc_ioctl_e_type in 0x00050006
+RPC_LOC_IOCTL_INFORM_SERVER_MULTI_OPEN_STATUS
+*/
+/* Following elements added in enum rpc_loc_server_request_e_type in 0x00050006
+RPC_LOC_SERVER_REQUEST_MULTI_OPEN
+*/
+
+ void
+ rpc_loc_api_null( void ) = 0;
+
+ } = 0x00050006;
+
+
+} = 0x3000008C;
+
+const LOC_APIVERS = 0x00050006;
diff --git a/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/xdr/loc_api_cb.xdr b/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/xdr/loc_api_cb.xdr
new file mode 100644
index 0000000..4756c6c
--- /dev/null
+++ b/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/xdr/loc_api_cb.xdr
@@ -0,0 +1,187 @@
+/* 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
+ * 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.
+ *
+ */
+/* LOC_API TOOL VERSION: 4.48 */
+/* GENERATED: TUE JUN 14 2011 */
+/*=============================================================================
+ L O C _ A P I _ C B . X D R
+
+GENERAL DESCRIPTION
+ This is an AUTO GENERATED file that provides an xdr compatible definition of
+ an api that represents the grouping of the different callback functions the
+ loc_api API supports.
+
+ ---------------------------------------------------------------------------
+
+
+ ---------------------------------------------------------------------------
+=============================================================================*/
+
+/*=============================================================================
+
+ Edit History
+
+ AUTO GENERATED
+
+Generated by following versions of Htorpc modules:
+Id: //source/qcom/qct/core/mproc/tools/rel/2h09/htorpc/htorpc.pl#1
+Id: //source/qcom/qct/core/mproc/tools/rel/2h09/htorpc/lib/Htorpc/Start.pm#1
+Id: //source/qcom/qct/core/mproc/tools/rel/2h09/htorpc/lib/Htorpc/Htoxdr.pm#1
+Id: //source/qcom/qct/core/mproc/tools/rel/2h09/htorpc/lib/Htorpc/XDR.pm#3
+Id: //source/qcom/qct/core/mproc/tools/rel/2h09/htorpc/lib/Htorpc/Output.pm#5
+Id: //source/qcom/qct/core/mproc/tools/rel/2h09/htorpc/lib/Htorpc/Parser.pm#1
+Id: //source/qcom/qct/core/mproc/tools/rel/2h09/htorpc/lib/Htorpc/Metacomments.pm#1
+Id: //source/qcom/qct/core/mproc/tools/rel/2h09/htorpc/lib/Htorpc/SymbolTable.pm#1
+
+loc_api Definition File(s):
+Id: //source/qcom/qct/modem/api/gps/main/latest/loc_api.h#24
+=============================================================================*/
+/*=============================================================================
+$Header$
+=============================================================================*/
+
+
+
+
+/*
+ * These are struct declarations for the function arguments
+ */
+
+struct rpc_loc_event_cb_f_type_args {
+ rpc_uint32 cb_id;
+ rpc_loc_client_handle_type loc_handle;
+ rpc_loc_event_mask_type loc_event;
+ rpc_loc_event_payload_u_type *loc_event_payload;
+};
+
+
+
+
+
+/*
+ * These are struct declaratios for the function results
+ */
+
+struct rpc_loc_event_cb_f_type_rets {
+ rpc_int32 loc_event_cb_f_type_result;
+};
+
+
+
+/*
+ * XDR definition of the LOC_API callback program ( vers. 0x00050006 )
+ */
+
+program LOC_APICBPROG {
+ version LOC_APICBVERS_0001 {
+
+ rpc_loc_event_cb_f_type_rets
+ rpc_loc_event_cb_f_type( rpc_loc_event_cb_f_type_args ) = 1;
+
+
+
+
+ } = 0x00050001;
+
+version LOC_APICBVERS_0002 {
+
+/* Following elements added in enum rpc_loc_assist_data_request_e_type in 0x00050002
+RPC_LOC_ASSIST_DATA_POSITION_INJECTION_REQ
+*/
+/* Following elements added in enum rpc_loc_ioctl_e_type in 0x00050002
+RPC_LOC_IOCTL_GET_XTRA_T_SESSION_CONTROL
+RPC_LOC_IOCTL_RESERVED_CMD
+RPC_LOC_IOCTL_SET_XTRA_T_SESSION_CONTROL
+*/
+
+ int
+ rpc_loc_api_cb_null( void ) = 0xffffff00;
+
+ } = 0x00050002;
+
+version LOC_APICBVERS_0003 {
+
+/* Following elements added in enum rpc_loc_ioctl_e_type in 0x00050003
+RPC_LOC_IOCTL_SET_DATA_ENABLE
+RPC_LOC_IOCTL_SET_LBS_APN_PROFILE
+RPC_LOC_IOCTL_GET_XTRA_APN_PROFILE
+RPC_LOC_IOCTL_GET_LBS_APN_PROFILE
+RPC_LOC_IOCTL_SET_XTRA_APN_PROFILE
+*/
+
+ int
+ rpc_loc_api_cb_null( void ) = 0xffffff00;
+
+ } = 0x00050003;
+
+version LOC_APICBVERS_0004 {
+
+/* Following elements added in enum rpc_loc_ioctl_e_type in 0x00050004
+RPC_LOC_IOCTL_GET_SUPL_VERSION
+RPC_LOC_IOCTL_SET_SUPL_VERSION
+*/
+
+ int
+ rpc_loc_api_cb_null( void ) = 0xffffff00;
+
+ } = 0x00050004;
+
+version LOC_APICBVERS_0005 {
+
+/* Following elements added in enum rpc_loc_server_addr_e_type in 0x00050005
+RPC_LOC_SERVER_ADDR_IPV6
+*/
+/* Following elements added in enum rpc_loc_ioctl_e_type in 0x00050005
+RPC_LOC_IOCTL_ERROR_ESTIMATE_CONFIG
+*/
+
+ int
+ rpc_loc_api_cb_null( void ) = 0xffffff00;
+
+ } = 0x00050005;
+
+
+
+ version LOC_APICBVERS_0006 {
+
+/* Following elements added in enum rpc_loc_ioctl_e_type in 0x00050006
+RPC_LOC_IOCTL_INFORM_SERVER_MULTI_OPEN_STATUS
+*/
+/* Following elements added in enum rpc_loc_server_request_e_type in 0x00050006
+RPC_LOC_SERVER_REQUEST_MULTI_OPEN
+*/
+
+ int
+ rpc_loc_api_cb_null( void ) = 0xffffff00;
+
+ } = 0x00050006;
+
+
+} = 0x3100008C;
+
+const LOC_APICBVERS = 0x00050006;
diff --git a/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/xdr/loc_api_common.xdr b/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/xdr/loc_api_common.xdr
new file mode 100644
index 0000000..e059c66
--- /dev/null
+++ b/msm8909/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/xdr/loc_api_common.xdr
@@ -0,0 +1,1021 @@
+/* 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
+ * 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.
+ *
+ */
+/* LOC_API TOOL VERSION: 4.48 */
+/* GENERATED: TUE JUN 14 2011 */
+/*=============================================================================
+ L O C _ A P I _ C O M M O N . X D R
+
+GENERAL DESCRIPTION
+ This is an AUTO GENERATED file that provides an xdr compatible definition of
+ an api that represents the grouping of the different callback functions the
+ loc_api API supports.
+
+ ---------------------------------------------------------------------------
+
+
+ ---------------------------------------------------------------------------
+=============================================================================*/
+
+/*=============================================================================
+
+ Edit History
+
+ AUTO GENERATED
+
+Generated by following versions of Htorpc modules:
+Id: //source/qcom/qct/core/mproc/tools/rel/2h09/htorpc/htorpc.pl#1
+Id: //source/qcom/qct/core/mproc/tools/rel/2h09/htorpc/lib/Htorpc/Start.pm#1
+Id: //source/qcom/qct/core/mproc/tools/rel/2h09/htorpc/lib/Htorpc/Htoxdr.pm#1
+Id: //source/qcom/qct/core/mproc/tools/rel/2h09/htorpc/lib/Htorpc/XDR.pm#3
+Id: //source/qcom/qct/core/mproc/tools/rel/2h09/htorpc/lib/Htorpc/Output.pm#5
+Id: //source/qcom/qct/core/mproc/tools/rel/2h09/htorpc/lib/Htorpc/Parser.pm#1
+Id: //source/qcom/qct/core/mproc/tools/rel/2h09/htorpc/lib/Htorpc/Metacomments.pm#1
+Id: //source/qcom/qct/core/mproc/tools/rel/2h09/htorpc/lib/Htorpc/SymbolTable.pm#1
+
+loc_api Definition File(s):
+Id: //source/qcom/qct/modem/api/gps/main/latest/loc_api.h#24
+=============================================================================*/
+/*=============================================================================
+$Header$
+=============================================================================*/
+
+
+
+const LOC_API_TOOLVERS = 0x00040030;
+const LOC_API_FEATURES = 0x00000001;
+
+const RPC_LOC_EVENT_STATUS_REPORT = 0x00000100;
+
+const RPC_LOC_EVENT_ASSISTANCE_DATA_REQUEST = 0x00000020;
+
+const RPC_LOC_EVENT_WPS_NEEDED_REQUEST = 0x00000200;
+
+const RPC_LOC_EVENT_SATELLITE_REPORT = 0x00000002;
+
+const RPC_LOC_EVENT_PARSED_POSITION_REPORT = 0x00000001;
+
+const RPC_LOC_EVENT_RESERVED = 0x8000000000000000;
+
+const RPC_LOC_EVENT_LOCATION_SERVER_REQUEST = 0x00000040;
+
+const RPC_LOC_EVENT_NMEA_POSITION_REPORT = 0x00000008;
+
+const RPC_LOC_EVENT_IOCTL_REPORT = 0x00000080;
+
+const RPC_LOC_EVENT_NMEA_1HZ_REPORT = 0x00000004;
+
+const RPC_LOC_EVENT_NI_NOTIFY_VERIFY_REQUEST = 0x00000010;
+
+const RPC_LOC_API_CB_NULL_VERSION = 0x00050002;
+const RPC_LOC_EVENT_CB_F_TYPE_VERSION = 0x00050001;
+const RPC_LOC_API_API_VERSIONS_VERSION = 0x00050001;
+const RPC_LOC_STOP_FIX_VERSION = 0x00050001;
+const RPC_LOC_START_FIX_VERSION = 0x00050001;
+const RPC_LOC_IOCTL_VERSION = 0x00050001;
+const RPC_LOC_CLOSE_VERSION = 0x00050001;
+const RPC_LOC_API_RPC_GLUE_CODE_INFO_REMOTE_VERSION = 0x00050001;
+const RPC_LOC_OPEN_VERSION = 0x00050001;
+const RPC_LOC_API_NULL_VERSION = 0x00050001;
+const RPC_LOC_API_API_MAJOR_NUM = 0x0005;
+const RPC_LOC_APIAPI_VERSION_IS_HASHKEY = 0;
+
+typedef rpc_int32 rpc_loc_client_handle_type;
+
+typedef rpc_uint64 rpc_loc_event_mask_type;
+
+typedef rpc_uint64 rpc_loc_position_valid_mask_type;
+
+typedef rpc_uint32 rpc_loc_pos_technology_mask_type;
+
+enum rpc_loc_session_status_e_type {
+ RPC_LOC_SESS_STATUS_SUCCESS = 0,
+ RPC_LOC_SESS_STATUS_IN_PROGESS = 1,
+ RPC_LOC_SESS_STATUS_GENERAL_FAILURE = 2,
+ RPC_LOC_SESS_STATUS_TIMEOUT = 3,
+ RPC_LOC_SESS_STATUS_USER_END = 4,
+ RPC_LOC_SESS_STATUS_BAD_PARAMETER = 5,
+ RPC_LOC_SESS_STATUS_PHONE_OFFLINE = 6,
+ RPC_LOC_SESS_STATUS_ENGINE_LOCKED = 7,
+ RPC_LOC_SESS_STATUS_MAX = 268435456
+};
+
+struct rpc_loc_calendar_time_s_type {
+ rpc_uint16 year;
+ unsigned char month;
+ unsigned char day_of_week;
+ unsigned char day;
+ unsigned char hour;
+ unsigned char minute;
+ unsigned char second;
+ rpc_uint16 millisecond;
+};
+
+struct rpc_loc_parsed_position_s_type {
+ rpc_loc_position_valid_mask_type valid_mask;
+ rpc_loc_session_status_e_type session_status;
+ rpc_loc_calendar_time_s_type timestamp_calendar;
+ rpc_uint64 timestamp_utc;
+ rpc_uint8 leap_seconds;
+ float time_unc;
+ double latitude;
+ double longitude;
+ float altitude_wrt_ellipsoid;
+ float altitude_wrt_mean_sea_level;
+ float speed_horizontal;
+ float speed_vertical;
+ float heading;
+ float hor_unc_circular;
+ float hor_unc_ellipse_semi_major;
+ float hor_unc_ellipse_semi_minor;
+ float hor_unc_ellipse_orient_azimuth;
+ float vert_unc;
+ float speed_unc;
+ float heading_unc;
+ unsigned char confidence_horizontal;
+ unsigned char confidence_vertical;
+ float magnetic_deviation;
+ rpc_loc_pos_technology_mask_type technology_mask;
+};
+
+enum rpc_loc_sv_system_e_type {
+ RPC_LOC_SV_SYSTEM_GPS = 1,
+ RPC_LOC_SV_SYSTEM_GALILEO = 2,
+ RPC_LOC_SV_SYSTEM_SBAS = 3,
+ RPC_LOC_SV_SYSTEM_COMPASS = 4,
+ RPC_LOC_SV_SYSTEM_GLONASS = 5,
+ RPC_LOC_SV_SYSTEM_MAX = 268435456
+};
+
+enum rpc_loc_sv_status_e_type {
+ RPC_LOC_SV_STATUS_IDLE = 1,
+ RPC_LOC_SV_STATUS_SEARCH = 2,
+ RPC_LOC_SV_STATUS_TRACK = 3,
+ RPC_LOC_SV_STATUS_MAX = 268435456
+};
+
+typedef rpc_uint32 rpc_loc_sv_info_valid_mask_type;
+
+struct rpc_loc_sv_info_s_type {
+ rpc_loc_sv_info_valid_mask_type valid_mask;
+ rpc_loc_sv_system_e_type system;
+ rpc_uint8 prn;
+ rpc_uint8 health_status;
+ rpc_loc_sv_status_e_type process_status;
+ rpc_boolean has_eph;
+ rpc_boolean has_alm;
+ float elevation;
+ float azimuth;
+ float snr;
+};
+
+typedef rpc_uint32 rpc_loc_gnss_info_valid_mask_type;
+
+struct rpc_loc_gnss_info_s_type {
+ rpc_loc_gnss_info_valid_mask_type valid_mask;
+ float position_dop;
+ float horizontal_dop;
+ float vertical_dop;
+ rpc_boolean altitude_assumed;
+ rpc_uint16 sv_count;
+ rpc_loc_sv_info_s_type sv_list<80>; /* EVAL:[LOC_API_MAX_SV_COUNT]*/
+};
+
+struct rpc_loc_nmea_report_s_type {
+ rpc_uint16 length;
+ opaque nmea_sentences[200];
+};
+
+enum rpc_loc_status_event_e_type {
+ RPC_LOC_STATUS_EVENT_ENGINE_STATE = 1,
+ RPC_LOC_STATUS_EVENT_FIX_SESSION_STATE = 2,
+ RPC_LOC_STATUS_EVENT_MAX = 268435456
+};
+
+enum rpc_loc_engine_state_e_type {
+ RPC_LOC_ENGINE_STATE_ON = 1,
+ RPC_LOC_ENGINE_STATE_OFF = 2,
+ RPC_LOC_ENGINE_STATE_MAX = 268435456
+};
+
+enum rpc_loc_fix_session_state_e_type {
+ RPC_LOC_FIX_SESSION_STATE_BEGIN = 1,
+ RPC_LOC_FIX_SESSION_STATE_END = 2,
+ RPC_LOC_FIX_SESSION_STATE_MAX = 268435456
+};
+
+union rpc_loc_status_event_payload_u_type switch (rpc_loc_status_event_e_type disc) {
+ case RPC_LOC_STATUS_EVENT_ENGINE_STATE:
+ rpc_loc_engine_state_e_type engine_state;
+ case RPC_LOC_STATUS_EVENT_FIX_SESSION_STATE:
+ rpc_loc_fix_session_state_e_type fix_session_state;
+ default:
+ void;
+};
+
+struct rpc_loc_status_event_s_type {
+ rpc_loc_status_event_e_type event;
+ rpc_loc_status_event_payload_u_type payload;
+};
+
+enum rpc_loc_server_addr_e_type {
+ RPC_LOC_SERVER_ADDR_IPV4 = 1,
+ RPC_LOC_SERVER_ADDR_URL = 2,
+ RPC_LOC_SERVER_ADDR_IPV6 = 3,
+ RPC_LOC_SERVER_ADDR_MAX = 268435456
+};
+
+struct rpc_loc_server_addr_ipv4_type {
+ rpc_uint32 addr;
+ rpc_uint16 port;
+};
+
+struct rpc_loc_server_addr_url_type {
+ rpc_uint16 length;
+ opaque addr[256];
+};
+
+struct rpc_loc_server_addr_ipv6_type {
+ rpc_uint16 addr[8];
+ rpc_uint32 port;
+};
+
+union rpc_loc_server_addr_u_type switch (rpc_loc_server_addr_e_type disc) {
+ case RPC_LOC_SERVER_ADDR_IPV4:
+ rpc_loc_server_addr_ipv4_type ipv4;
+ case RPC_LOC_SERVER_ADDR_URL:
+ rpc_loc_server_addr_url_type url;
+ case RPC_LOC_SERVER_ADDR_IPV6:
+ rpc_loc_server_addr_ipv6_type ipv6;
+ default:
+ void;
+};
+
+struct rpc_loc_server_info_s_type {
+ rpc_loc_server_addr_e_type addr_type;
+ rpc_loc_server_addr_u_type addr_info;
+};
+
+enum rpc_loc_ni_notify_verify_e_type {
+ RPC_LOC_NI_USER_NO_NOTIFY_NO_VERIFY = 1,
+ RPC_LOC_NI_USER_NOTIFY_ONLY = 2,
+ RPC_LOC_NI_USER_NOTIFY_VERIFY_ALLOW_NO_RESP = 3,
+ RPC_LOC_NI_USER_NOTIFY_VERIFY_NOT_ALLOW_NO_RESP = 4,
+ RPC_LOC_NI_USER_PRIVACY_OVERRIDE = 5,
+ RPC_LOC_NI_USER_NOTIFY_VERITY_TYPE_MAX = 268435456
+};
+
+enum rpc_loc_ni_event_e_type {
+ RPC_LOC_NI_EVENT_VX_NOTIFY_VERIFY_REQ = 1,
+ RPC_LOC_NI_EVENT_SUPL_NOTIFY_VERIFY_REQ = 2,
+ RPC_LOC_NI_EVENT_UMTS_CP_NOTIFY_VERIFY_REQ = 3,
+ RPC_LOC_NI_EVENT_VX_SERVICE_INTERACTION_REQ = 4,
+ RPC_LOC_NI_EVENT_MAX = 268435456
+};
+
+enum rpc_loc_ni_datacoding_scheme_e_type {
+ RPC_LOC_NI_PRESUPL_ISO646IRV = 0,
+ RPC_LOC_NI_PRESUPL_ISO8859 = 1,
+ RPC_LOC_NI_PRESUPL_UTF8 = 2,
+ RPC_LOC_NI_PRESUPL_UTF16 = 3,
+ RPC_LOC_NI_PRESUPL_UCS2 = 4,
+ RPC_LOC_NI_PRESUPL_GSM_DEFAULT = 5,
+ RPC_LOC_NI_PRESUPL_SHIFT_JIS = 6,
+ RPC_LOC_NI_PRESUPL_JIS = 7,
+ RPC_LOC_NI_PRESUPL_EUC = 8,
+ RPC_LOC_NI_PRESUPL_GB2312 = 9,
+ RPC_LOC_NI_PRESUPL_CNS11643 = 10,
+ RPC_LOC_NI_PRESUPL_KSC1001 = 11,
+ RPC_LOC_NI_PRESUPL_ENCODING_UNKNOWN = 2147483647,
+ RPC_LOC_NI_SS_GERMAN = 12,
+ RPC_LOC_NI_SS_ENGLISH = 13,
+ RPC_LOC_NI_SS_ITALIAN = 14,
+ RPC_LOC_NI_SS_FRENCH = 15,
+ RPC_LOC_NI_SS_SPANISH = 16,
+ RPC_LOC_NI_SS_DUTCH = 17,
+ RPC_LOC_NI_SS_SWEDISH = 18,
+ RPC_LOC_NI_SS_DANISH = 19,
+ RPC_LOC_NI_SS_PORTUGUESE = 20,
+ RPC_LOC_NI_SS_FINNISH = 21,
+ RPC_LOC_NI_SS_NORWEGIAN = 22,
+ RPC_LOC_NI_SS_GREEK = 23,
+ RPC_LOC_NI_SS_TURKISH = 24,
+ RPC_LOC_NI_SS_HUNGARIAN = 25,
+ RPC_LOC_NI_SS_POLISH = 26,
+ RPC_LOC_NI_SS_LANGUAGE_UNSPEC = 27,
+ RPC_LOC_NI_SUPL_UTF8 = 28,
+ RPC_LOC_NI_SUPL_UCS2 = 29,
+ RPC_LOC_NI_SUPL_GSM_DEFAULT = 30,
+ RPC_LOC_NI_SUPL_ENCODING_UNKNOWN = 2147483647
+};
+
+enum rpc_loc_ni_vx_requester_id_encoding_scheme_e_type {
+ RPC_LOC_NI_VX_OCTET = 0,
+ RPC_LOC_NI_VX_EXN_PROTOCOL_MSG = 1,
+ RPC_LOC_NI_VX_ASCII = 2,
+ RPC_LOC_NI_VX_IA5 = 3,
+ RPC_LOC_NI_VX_UNICODE = 4,
+ RPC_LOC_NI_VX_SHIFT_JIS = 5,
+ RPC_LOC_NI_VX_KOREAN = 6,
+ RPC_LOC_NI_VX_LATIN_HEBREW = 7,
+ RPC_LOC_NI_VX_LATIN = 8,
+ RPC_LOC_NI_VX_GSM = 9,
+ RPC_LOC_NI_VX_ENCODING_TYPE_MAX = 268435456
+};
+
+enum rpc_loc_ni_vx_pos_mode_e_type {
+ RPC_LOC_VX_MS_ASSISTED_ONLY = 1,
+ RPC_LOC_VX_MS_BASED_ONLY = 2,
+ RPC_LOC_VX_MS_ASSISTED_PREF_MSBASED_ALLWD = 3,
+ RPC_LOC_VX_MS_BASED_PREF_ASSISTED_ALLWD = 4,
+ RPC_LOC_VX_POS_MODE_MAX = 268435456
+};
+
+struct rpc_loc_ni_vx_requester_id_s_type {
+ unsigned char requester_id_length;
+ opaque requester_id[200];
+};
+
+struct rpc_loc_ni_vx_notify_verify_req_s_type {
+ rpc_loc_ni_notify_verify_e_type notification_priv_type;
+ unsigned char pos_qos_incl;
+ unsigned char pos_qos;
+ rpc_uint32 num_fixes;
+ rpc_uint32 tbf;
+ rpc_loc_ni_vx_pos_mode_e_type pos_mode;
+ rpc_loc_ni_vx_requester_id_encoding_scheme_e_type encoding_scheme;
+ rpc_loc_ni_vx_requester_id_s_type requester_id;
+ rpc_uint16 user_resp_timer_val;
+};
+
+enum rpc_loc_ni_supl_pos_method_e_type {
+ RPC_LOC_NI_POSMETHOD_AGPS_SETASSISTED = 1,
+ RPC_LOC_NI_POSMETHOD_AGPS_SETBASED = 2,
+ RPC_LOC_NI_POSMETHOD_AGPS_SETASSISTED_PREF = 3,
+ RPC_LOC_NI_POSMETHOD_AGPS_SETBASED_PREF = 4,
+ RPC_LOC_NI_POSMETHOD_AUTONOMOUS_GPS = 5,
+ RPC_LOC_NI_POSMETHOD_AFLT = 6,
+ RPC_LOC_NI_POSMETHOD_ECID = 7,
+ RPC_LOC_NI_POSMETHOD_EOTD = 8,
+ RPC_LOC_NI_POSMETHOD_OTDOA = 9,
+ RPC_LOC_NI_POSMETHOD_NO_POSITION = 10,
+ RPC_LOC_NI_POSMETHOD_MAX = 268435456
+};
+
+struct rpc_loc_ni_supl_slp_session_id_s_type {
+ unsigned char presence;
+ opaque session_id[4];
+ rpc_loc_server_info_s_type slp_address;
+};
+
+struct rpc_loc_ni_requestor_id_s_type {
+ unsigned char data_coding_scheme;
+ opaque requestor_id_string[200];
+ unsigned char string_len;
+};
+
+struct rpc_loc_ni_supl_client_name_s_type {
+ unsigned char data_coding_scheme;
+ opaque client_name_string[64];
+ unsigned char string_len;
+};
+
+struct rpc_loc_ni_supl_qop_s_type {
+ unsigned char bit_mask;
+ unsigned char horacc;
+ unsigned char veracc;
+ rpc_uint16 maxLocAge;
+ unsigned char delay;
+};
+
+struct rpc_loc_ni_supl_notify_verify_req_s_type {
+ rpc_loc_ni_notify_verify_e_type notification_priv_type;
+ rpc_uint16 flags;
+ rpc_loc_ni_supl_slp_session_id_s_type supl_slp_session_id;
+ opaque supl_hash[8];
+ rpc_loc_ni_datacoding_scheme_e_type datacoding_scheme;
+ rpc_loc_ni_supl_pos_method_e_type pos_method;
+ rpc_loc_ni_requestor_id_s_type requestor_id;
+ rpc_loc_ni_supl_client_name_s_type client_name;
+ rpc_loc_ni_supl_qop_s_type supl_qop;
+ rpc_uint16 user_response_timer;
+};
+
+struct rpc_loc_ni_ext_client_address_s_type {
+ unsigned char ext_client_address_len;
+ opaque ext_client_address[20];
+};
+
+enum rpc_loc_ni_location_type_e_type {
+ RPC_LOC_NI_LOCATIONTYPE_CURRENT_LOCATION = 1,
+ RPC_LOC_NI_LOCATIONTYPE_CURRENT_OR_LAST_KNOWN_LOCATION = 2,
+ RPC_LOC_NI_LOCATIONTYPE_INITIAL_LOCATION = 3,
+ RPC_LOC_NI_LOCATIONTYPE_MAX = 268435456
+};
+
+struct rpc_loc_ni_deferred_location_s_type {
+ unsigned char unused_bits;
+ unsigned char ms_available;
+};
+
+struct rpc_loc_ni_codeword_string_s_type {
+ unsigned char data_coding_scheme;
+ opaque lcs_codeword_string[20];
+ unsigned char string_len;
+};
+
+struct rpc_loc_ni_service_type_id_s_type {
+ unsigned char lcs_service_type_id;
+};
+
+struct rpc_loc_ni_umts_cp_notify_verify_req_s_type {
+ rpc_loc_ni_notify_verify_e_type notification_priv_type;
+ unsigned char invoke_id;
+ rpc_uint16 flags;
+ unsigned char notification_length;
+ opaque notification_text[64];
+ rpc_loc_ni_datacoding_scheme_e_type datacoding_scheme;
+ rpc_loc_ni_ext_client_address_s_type ext_client_address_data;
+ rpc_loc_ni_location_type_e_type location_type;
+ rpc_loc_ni_deferred_location_s_type deferred_location;
+ rpc_loc_ni_requestor_id_s_type requestor_id;
+ rpc_loc_ni_codeword_string_s_type codeword_string;
+ rpc_loc_ni_service_type_id_s_type service_type_id;
+ rpc_uint16 user_response_timer;
+};
+
+enum rpc_loc_ni_service_interaction_e_type {
+ RPC_LOC_NI_SERVICE_INTERACTION_ONGOING_NI_INCOMING_MO = 1,
+ RPC_LOC_NI_SERVICE_INTERACTION_MAX = 268435456
+};
+
+struct rpc_loc_ni_vx_service_interaction_req_s_type {
+ rpc_loc_ni_vx_notify_verify_req_s_type ni_vx_req;
+ rpc_loc_ni_service_interaction_e_type service_interation_type;
+};
+
+union rpc_loc_ni_event_payload_u_type switch (rpc_loc_ni_event_e_type disc) {
+ case RPC_LOC_NI_EVENT_VX_NOTIFY_VERIFY_REQ:
+ rpc_loc_ni_vx_notify_verify_req_s_type vx_req;
+ case RPC_LOC_NI_EVENT_SUPL_NOTIFY_VERIFY_REQ:
+ rpc_loc_ni_supl_notify_verify_req_s_type supl_req;
+ case RPC_LOC_NI_EVENT_UMTS_CP_NOTIFY_VERIFY_REQ:
+ rpc_loc_ni_umts_cp_notify_verify_req_s_type umts_cp_req;
+ case RPC_LOC_NI_EVENT_VX_SERVICE_INTERACTION_REQ:
+ rpc_loc_ni_vx_service_interaction_req_s_type service_interaction_req;
+ default:
+ void;
+};
+
+struct rpc_loc_ni_event_s_type {
+ rpc_loc_ni_event_e_type event;
+ rpc_loc_ni_event_payload_u_type payload;
+};
+
+enum rpc_loc_assist_data_request_e_type {
+ RPC_LOC_ASSIST_DATA_TIME_REQ = 1,
+ RPC_LOC_ASSIST_DATA_PREDICTED_ORBITS_REQ = 2,
+ RPC_LOC_ASSIST_DATA_POSITION_INJECTION_REQ = 3,
+ RPC_LOC_ASSIST_DATA_MAX = 268435456
+};
+
+typedef string rpc_struct_loc_time_download_source_s_type_servers_ptr<256>; /* EVAL:[LOC_API_MAX_SERVER_ADDR_LENGTH]*/
+
+typedef rpc_struct_loc_time_download_source_s_type_servers_ptr rpc_struct_loc_time_download_source_s_type_servers[3];
+
+struct rpc_loc_time_download_source_s_type {
+ rpc_uint32 delay_threshold;
+ rpc_struct_loc_time_download_source_s_type_servers servers;
+};
+
+typedef string rpc_struct_loc_predicted_orbits_data_source_s_type_servers_ptr<LOC_API_MAX_SERVER_ADDR_LENGTH>;
+
+typedef rpc_struct_loc_predicted_orbits_data_source_s_type_servers_ptr rpc_struct_loc_predicted_orbits_data_source_s_type_servers[3];
+
+struct rpc_loc_predicted_orbits_data_source_s_type {
+ rpc_uint32 max_file_size;
+ rpc_uint32 max_part_size;
+ rpc_struct_loc_predicted_orbits_data_source_s_type_servers servers;
+};
+
+struct rpc_loc_pos_inj_request_s_type {
+ rpc_uint32 flags;
+ double latitude;
+ double longitude;
+ rpc_uint32 position_uncertainty;
+ rpc_uint64 timestamp;
+};
+
+union rpc_loc_assist_data_request_payload_u_type switch (rpc_loc_assist_data_request_e_type disc) {
+ case RPC_LOC_ASSIST_DATA_TIME_REQ:
+ rpc_loc_time_download_source_s_type time_download;
+ case RPC_LOC_ASSIST_DATA_PREDICTED_ORBITS_REQ:
+ rpc_loc_predicted_orbits_data_source_s_type data_download;
+ case RPC_LOC_ASSIST_DATA_POSITION_INJECTION_REQ:
+ rpc_loc_pos_inj_request_s_type pos_injection;
+ default:
+ void;
+};
+
+struct rpc_loc_assist_data_request_s_type {
+ rpc_loc_assist_data_request_e_type event;
+ rpc_loc_assist_data_request_payload_u_type payload;
+};
+
+typedef rpc_uint32 rpc_loc_server_connection_handle;
+
+enum rpc_loc_server_protocol_e_type {
+ RPC_LOC_SERVER_PROTOCOL_DEFAULT = 0,
+ RPC_LOC_SERVER_PROTOCOL_SUPL = 1,
+ RPC_LOC_SERVER_PROTOCOL_VX_MPC = 2,
+ RPC_LOC_SERVER_PROTOCOL_VX_PDE = 3,
+ RPC_LOC_SERVER_PROTOCOL_MAX = 16777216
+};
+
+enum rpc_loc_server_connection_e_type {
+ RPC_LOC_SERVER_CONNECTION_LBS = 0,
+ RPC_LOC_SERVER_CONNECTION_WWAN_INTERNET,
+ RPC_LOC_SERVER_CONNECTION_MAX = 16777216
+};
+
+enum rpc_loc_server_request_e_type {
+ RPC_LOC_SERVER_REQUEST_OPEN = 1,
+ RPC_LOC_SERVER_REQUEST_CLOSE = 2,
+ RPC_LOC_SERVER_REQUEST_MULTI_OPEN = 3,
+ RPC_LOC_SERVER_REQUEST_MAX = 268435456
+};
+
+struct rpc_loc_server_open_req_s_type {
+ rpc_loc_server_connection_handle conn_handle;
+ rpc_loc_server_protocol_e_type protocol;
+};
+
+struct rpc_loc_server_multi_open_req_s_type {
+ rpc_loc_server_connection_handle conn_handle;
+ rpc_loc_server_protocol_e_type protocol;
+ rpc_loc_server_connection_e_type connection_type;
+};
+
+struct rpc_loc_server_close_req_s_type {
+ rpc_loc_server_connection_handle conn_handle;
+};
+
+union rpc_loc_server_request_u_type switch (rpc_loc_server_request_e_type disc) {
+ case RPC_LOC_SERVER_REQUEST_OPEN:
+ rpc_loc_server_open_req_s_type open_req;
+ case RPC_LOC_SERVER_REQUEST_CLOSE:
+ rpc_loc_server_close_req_s_type close_req;
+ case RPC_LOC_SERVER_REQUEST_MULTI_OPEN:
+ rpc_loc_server_multi_open_req_s_type multi_open_req;
+ default:
+ void;
+};
+
+struct rpc_loc_server_request_s_type {
+ rpc_loc_server_request_e_type event;
+ rpc_loc_server_request_u_type payload;
+};
+
+enum rpc_loc_qwip_request_e_type {
+ RPC_LOC_QWIP_START_PERIODIC_HI_FREQ_FIXES = 0,
+ RPC_LOC_QWIP_START_PERIODIC_KEEP_WARM,
+ RPC_LOC_QWIP_STOP_PERIODIC_FIXES,
+ RPC_LOC_QWIP_SUSPEND,
+ RPC_LOC_QWIP_REQUEST_MAX = 268435456
+};
+
+struct rpc_loc_qwip_request_s_type {
+ rpc_loc_qwip_request_e_type request_type;
+ rpc_uint16 tbf_ms;
+};
+
+struct rpc_loc_reserved_payload_s_type {
+ rpc_uint16 data_size;
+ opaque data<>;
+};
+
+enum rpc_loc_ioctl_e_type {
+ RPC_LOC_IOCTL_GET_API_VERSION = 1,
+ RPC_LOC_IOCTL_SET_FIX_CRITERIA = 2,
+ RPC_LOC_IOCTL_GET_FIX_CRITERIA = 3,
+ RPC_LOC_IOCTL_SERVICE_START_INDEX = 400,
+ RPC_LOC_IOCTL_INFORM_NI_USER_RESPONSE = 400,
+ RPC_LOC_IOCTL_INJECT_PREDICTED_ORBITS_DATA = 401,
+ RPC_LOC_IOCTL_QUERY_PREDICTED_ORBITS_DATA_VALIDITY = 402,
+ RPC_LOC_IOCTL_QUERY_PREDICTED_ORBITS_DATA_SOURCE = 403,
+ RPC_LOC_IOCTL_SET_PREDICTED_ORBITS_DATA_AUTO_DOWNLOAD = 404,
+ RPC_LOC_IOCTL_INJECT_UTC_TIME = 405,
+ RPC_LOC_IOCTL_INJECT_RTC_VALUE = 406,
+ RPC_LOC_IOCTL_INJECT_POSITION = 407,
+ RPC_LOC_IOCTL_QUERY_ENGINE_STATE = 408,
+ RPC_LOC_IOCTL_INFORM_SERVER_OPEN_STATUS = 409,
+ RPC_LOC_IOCTL_INFORM_SERVER_CLOSE_STATUS = 410,
+ RPC_LOC_IOCTL_SEND_WIPER_POSITION_REPORT = 411,
+ RPC_LOC_IOCTL_NOTIFY_WIPER_STATUS = 412,
+ RPC_LOC_IOCTL_ACCESS_EFS_DATA = 413,
+ RPC_LOC_IOCTL_ERROR_ESTIMATE_CONFIG = 414,
+ RPC_LOC_IOCTL_INFORM_SERVER_MULTI_OPEN_STATUS = 415,
+ RPC_LOC_IOCTL_NV_SETTINGS_START_INDEX = 800,
+ RPC_LOC_IOCTL_SET_ENGINE_LOCK = 800,
+ RPC_LOC_IOCTL_GET_ENGINE_LOCK = 801,
+ RPC_LOC_IOCTL_SET_SBAS_CONFIG = 802,
+ RPC_LOC_IOCTL_GET_SBAS_CONFIG = 803,
+ RPC_LOC_IOCTL_SET_NMEA_TYPES = 804,
+ RPC_LOC_IOCTL_GET_NMEA_TYPES = 805,
+ RPC_LOC_IOCTL_SET_CDMA_PDE_SERVER_ADDR = 806,
+ RPC_LOC_IOCTL_GET_CDMA_PDE_SERVER_ADDR = 807,
+ RPC_LOC_IOCTL_SET_CDMA_MPC_SERVER_ADDR = 808,
+ RPC_LOC_IOCTL_GET_CDMA_MPC_SERVER_ADDR = 809,
+ RPC_LOC_IOCTL_SET_UMTS_SLP_SERVER_ADDR = 810,
+ RPC_LOC_IOCTL_GET_UMTS_SLP_SERVER_ADDR = 811,
+ RPC_LOC_IOCTL_SET_ON_DEMAND_LPM = 812,
+ RPC_LOC_IOCTL_GET_ON_DEMAND_LPM = 813,
+ RPC_LOC_IOCTL_SET_XTRA_T_SESSION_CONTROL = 814,
+ RPC_LOC_IOCTL_GET_XTRA_T_SESSION_CONTROL = 815,
+ RPC_LOC_IOCTL_SET_LBS_APN_PROFILE = 816,
+ RPC_LOC_IOCTL_GET_LBS_APN_PROFILE = 817,
+ RPC_LOC_IOCTL_SET_XTRA_APN_PROFILE = 818,
+ RPC_LOC_IOCTL_GET_XTRA_APN_PROFILE = 819,
+ RPC_LOC_IOCTL_SET_DATA_ENABLE = 820,
+ RPC_LOC_IOCTL_SET_SUPL_VERSION = 821,
+ RPC_LOC_IOCTL_GET_SUPL_VERSION = 822,
+ RPC_LOC_IOCTL_PROPRIETARY_START_INDEX = 1000,
+ RPC_LOC_IOCTL_DELETE_ASSIST_DATA = 1000,
+ RPC_LOC_IOCTL_SET_CUSTOM_PDE_SERVER_ADDR = 1001,
+ RPC_LOC_IOCTL_GET_CUSTOM_PDE_SERVER_ADDR = 1002,
+ RPC_LOC_IOCTL_RESERVED_CMD = 8000,
+ RPC_LOC_IOCTL_THIRD_PARTY_START_INDEX = 1073741824
+};
+
+struct rpc_loc_api_version_s_type {
+ unsigned char major;
+ unsigned char minor;
+};
+
+enum rpc_loc_fix_recurrence_e_type {
+ RPC_LOC_PERIODIC_FIX = 1,
+ RPC_LOC_SINGLE_FIX = 2,
+ RPC_LOC_FIX_SESSION_TYPE_MAX = 268435456
+};
+
+enum rpc_loc_operation_mode_e_type {
+ RPC_LOC_OPER_MODE_DEFAULT = 1,
+ RPC_LOC_OPER_MODE_MSB = 2,
+ RPC_LOC_OPER_MODE_MSA = 3,
+ RPC_LOC_OPER_MODE_STANDALONE = 4,
+ RPC_LOC_OPER_MODE_SPEED_OPTIMAL = 5,
+ RPC_LOC_OPER_MODE_ACCURACY_OPTIMAL = 6,
+ RPC_LOC_OPER_MODE_DATA_OPTIMAL = 7,
+ RPC_LOC_OPER_MODE_CELL_ID = 8,
+ RPC_LOC_OPER_MODE_MAX = 268435456
+};
+
+enum rpc_loc_notify_e_type {
+ RPC_LOC_NOTIFY_ON_INTERVAL = 1,
+ RPC_LOC_NOTIFY_ON_DISTANCE = 2,
+ RPC_LOC_NOTIFY_ON_ANY = 3,
+ RPC_LOC_NOTIFY_ON_ALL = 4,
+ RPC_LOC_NOTIFY_TYPE_MAX = 268435456
+};
+
+struct rpc_loc_fix_criteria_s_type {
+ rpc_uint32 valid_mask;
+ rpc_loc_fix_recurrence_e_type recurrence_type;
+ rpc_loc_operation_mode_e_type preferred_operation_mode;
+ rpc_uint32 preferred_accuracy;
+ rpc_uint32 preferred_response_time;
+ rpc_boolean intermediate_pos_report_enabled;
+ rpc_loc_notify_e_type notify_type;
+ rpc_uint32 min_interval;
+ float min_distance;
+ rpc_uint32 min_dist_sample_interval;
+};
+
+enum rpc_loc_ni_user_resp_e_type {
+ RPC_LOC_NI_LCS_NOTIFY_VERIFY_ACCEPT = 1,
+ RPC_LOC_NI_LCS_NOTIFY_VERIFY_DENY = 2,
+ RPC_LOC_NI_LCS_NOTIFY_VERIFY_NORESP = 3,
+ RPC_LOC_NI_LCS_NOTIFY_VERIFY_MAX = 268435456
+};
+
+struct rpc_loc_user_verify_s_type {
+ rpc_loc_ni_user_resp_e_type user_resp;
+ rpc_loc_ni_event_s_type ni_event_pass_back;
+};
+
+enum rpc_loc_predicted_orbits_data_format_e_type {
+ RPC_LOC_PREDICTED_ORBITS_XTRA = 0,
+ RPC_LOC_PREDICTED_ORBITS_FORMAT_MAX = 268435456
+};
+
+struct rpc_loc_predicted_orbits_data_s_type {
+ rpc_loc_predicted_orbits_data_format_e_type format_type;
+ rpc_uint32 total_size;
+ rpc_uint8 total_parts;
+ rpc_uint8 part;
+ rpc_uint16 part_len;
+ opaque data_ptr<>;
+};
+
+struct rpc_loc_predicted_orbits_data_validity_report_s_type {
+ rpc_uint64 start_time_utc;
+ rpc_uint16 valid_duration_hrs;
+};
+
+struct rpc_loc_predicted_orbits_auto_download_config_s_type {
+ rpc_boolean enable;
+ unsigned char auto_check_every_hrs;
+};
+
+struct rpc_loc_assist_data_time_s_type {
+ rpc_uint64 time_utc;
+ rpc_uint32 uncertainty;
+};
+
+typedef rpc_uint64 rpc_loc_assist_pos_valid_mask_type;
+
+struct rpc_loc_assist_data_pos_s_type {
+ rpc_loc_assist_pos_valid_mask_type valid_mask;
+ rpc_uint64 timestamp_utc;
+ double latitude;
+ double longitude;
+ float altitude_wrt_ellipsoid;
+ float altitude_wrt_mean_sea_level;
+ float hor_unc_circular;
+ float vert_unc;
+ unsigned char confidence_horizontal;
+ unsigned char confidence_vertical;
+ rpc_int32 timestamp_age;
+};
+
+enum rpc_loc_server_open_status_e_type {
+ RPC_LOC_SERVER_OPEN_SUCCESS = 1,
+ RPC_LOC_SERVER_OPEN_FAIL = 2,
+ RPC_LOC_SERVER_OPEN_STATUS_MAX = 268435456
+};
+
+enum rpc_loc_server_pdp_type_e_type {
+ RPC_LOC_SERVER_PDP_IP = 0,
+ RPC_LOC_SERVER_PDP_PPP,
+ RPC_LOC_SERVER_PDP_IPV6,
+ RPC_LOC_SERVER_PDP_IPV4V6,
+ RPC_LOC_SERVER_PDP_MAX = 268435456
+};
+
+struct rpc_loc_server_open_status_s_type {
+ rpc_loc_server_connection_handle conn_handle;
+ rpc_loc_server_open_status_e_type open_status;
+ opaque apn_name[100];
+};
+
+struct rpc_loc_server_multi_open_status_s_type {
+ rpc_loc_server_connection_handle conn_handle;
+ rpc_loc_server_open_status_e_type open_status;
+ rpc_loc_server_pdp_type_e_type pdp_type;
+ opaque apn_name[100];
+};
+
+enum rpc_loc_server_close_status_e_type {
+ RPC_LOC_SERVER_CLOSE_SUCCESS = 1,
+ RPC_LOC_SERVER_CLOSE_FAIL = 2,
+ RPC_LOC_SERVER_CLOSE_STATUS_MAX = 268435456
+};
+
+struct rpc_loc_server_close_status_s_type {
+ rpc_loc_server_connection_handle conn_handle;
+ rpc_loc_server_close_status_e_type close_status;
+};
+
+struct rpc_loc_wiper_fix_time_s_type {
+ rpc_uint32 slow_clock_count;
+};
+
+struct rpc_loc_wiper_fix_pos_s_type {
+ rpc_int32 lat;
+ rpc_int32 lon;
+ rpc_uint16 HEPE;
+ rpc_uint8 num_of_aps_used;
+ rpc_uint8 fix_error_code;
+};
+
+struct rpc_loc_wiper_ap_info_s_type {
+ opaque mac_addr[6];
+ rpc_int32 rssi;
+ rpc_uint16 channel;
+ rpc_uint8 ap_qualifier;
+};
+
+struct rpc_loc_wiper_ap_set_s_type {
+ rpc_uint8 num_of_aps;
+ rpc_loc_wiper_ap_info_s_type ap_info[50];
+};
+
+struct rpc_loc_wiper_position_report_s_type {
+ rpc_uint8 wiper_valid_info_flag;
+ rpc_loc_wiper_fix_time_s_type wiper_fix_time;
+ rpc_loc_wiper_fix_pos_s_type wiper_fix_position;
+ rpc_loc_wiper_ap_set_s_type wiper_ap_set;
+};
+
+enum rpc_loc_wiper_status_e_type {
+ RPC_LOC_WIPER_STATUS_AVAILABLE = 1,
+ RPC_LOC_WIPER_STATUS_UNAVAILABLE = 2,
+ RPC_LOC_WIPER_STATUS_E_SIZE = 268435456
+};
+
+enum rpc_loc_fs_operation_e_type {
+ RPC_LOC_FS_CREATE_WRITE_FILE = 1,
+ RPC_LOC_FS_APPEND_FILE = 2,
+ RPC_LOC_FS_DELETE_FILE = 3,
+ RPC_LOC_FS_READ_FILE = 4,
+ RPC_LOC_FS_MAX = 268435456
+};
+
+struct rpc_loc_efs_data_s_type {
+ opaque filename[64];
+ rpc_loc_fs_operation_e_type operation;
+ rpc_uint32 total_size;
+ opaque data_ptr<>;
+ rpc_uint32 part_len;
+ rpc_uint8 part;
+ rpc_uint8 total_parts;
+ rpc_uint32 reserved;
+};
+
+enum rpc_loc_error_estimate_config_e_type {
+ RPC_LOC_ERROR_ESTIMATE_CONFIG_SET = 1,
+ RPC_LOC_ERROR_ESTIMATE_CONFIG_CLEAR = 2,
+ RPC_LOC_ERROR_ESTIMATE_MAX = 268435456
+};
+
+struct rpc_loc_apn_profiles_type {
+ rpc_uint32 srv_system_type;
+ rpc_uint32 pdp_type;
+ rpc_uint32 reserved;
+ opaque apn_name[100];
+};
+
+enum rpc_loc_lock_e_type {
+ RPC_LOC_LOCK_NONE = 1,
+ RPC_LOC_LOCK_MI = 2,
+ RPC_LOC_LOCK_MT = 3,
+ RPC_LOC_LOCK_ALL = 4,
+ RPC_LOC_LOCK_MAX = 268435456
+};
+
+typedef rpc_uint32 rpc_loc_nmea_sentence_type;
+
+typedef rpc_uint32 rpc_loc_assist_data_type;
+
+struct rpc_loc_assist_data_delete_s_type {
+ rpc_loc_assist_data_type type;
+ rpc_uint32 reserved[8];
+};
+
+union rpc_loc_ioctl_data_u_type switch (rpc_loc_ioctl_e_type disc) {
+ case RPC_LOC_IOCTL_SET_FIX_CRITERIA:
+ rpc_loc_fix_criteria_s_type fix_criteria;
+ case RPC_LOC_IOCTL_INFORM_NI_USER_RESPONSE:
+ rpc_loc_user_verify_s_type user_verify_resp;
+ case RPC_LOC_IOCTL_INJECT_PREDICTED_ORBITS_DATA:
+ rpc_loc_predicted_orbits_data_s_type predicted_orbits_data;
+ case RPC_LOC_IOCTL_SET_PREDICTED_ORBITS_DATA_AUTO_DOWNLOAD:
+ rpc_loc_predicted_orbits_auto_download_config_s_type predicted_orbits_auto_download;
+ case RPC_LOC_IOCTL_INJECT_UTC_TIME:
+ rpc_loc_assist_data_time_s_type assistance_data_time;
+ case RPC_LOC_IOCTL_INJECT_POSITION:
+ rpc_loc_assist_data_pos_s_type assistance_data_position;
+ case RPC_LOC_IOCTL_INFORM_SERVER_OPEN_STATUS:
+ rpc_loc_server_open_status_s_type conn_open_status;
+ case RPC_LOC_IOCTL_INFORM_SERVER_CLOSE_STATUS:
+ rpc_loc_server_close_status_s_type conn_close_status;
+ case RPC_LOC_IOCTL_SEND_WIPER_POSITION_REPORT:
+ rpc_loc_wiper_position_report_s_type wiper_pos;
+ case RPC_LOC_IOCTL_NOTIFY_WIPER_STATUS:
+ rpc_loc_wiper_status_e_type wiper_status;
+ case RPC_LOC_IOCTL_SET_ENGINE_LOCK:
+ rpc_loc_lock_e_type engine_lock;
+ case RPC_LOC_IOCTL_SET_SBAS_CONFIG:
+ rpc_boolean sbas_mode;
+ case RPC_LOC_IOCTL_SET_NMEA_TYPES:
+ rpc_loc_nmea_sentence_type nmea_types;
+ case RPC_LOC_IOCTL_SET_ON_DEMAND_LPM:
+ rpc_boolean on_demand_lpm;
+ case RPC_LOC_IOCTL_SET_CDMA_PDE_SERVER_ADDR:
+ case RPC_LOC_IOCTL_SET_CDMA_MPC_SERVER_ADDR:
+ case RPC_LOC_IOCTL_SET_UMTS_SLP_SERVER_ADDR:
+ case RPC_LOC_IOCTL_SET_CUSTOM_PDE_SERVER_ADDR:
+ rpc_loc_server_info_s_type server_addr;
+ case RPC_LOC_IOCTL_DELETE_ASSIST_DATA:
+ rpc_loc_assist_data_delete_s_type assist_data_delete;
+ case RPC_LOC_IOCTL_ACCESS_EFS_DATA:
+ rpc_loc_efs_data_s_type efs_data;
+ case RPC_LOC_IOCTL_ERROR_ESTIMATE_CONFIG:
+ rpc_loc_error_estimate_config_e_type error_estimate_config;
+ case RPC_LOC_IOCTL_SET_XTRA_T_SESSION_CONTROL:
+ rpc_uint8 xtra_t_session_control;
+ case RPC_LOC_IOCTL_SET_LBS_APN_PROFILE:
+ case RPC_LOC_IOCTL_SET_XTRA_APN_PROFILE:
+ rpc_loc_apn_profiles_type apn_profiles[6];
+ case RPC_LOC_IOCTL_SET_DATA_ENABLE:
+ rpc_boolean data_enable;
+ case RPC_LOC_IOCTL_SET_SUPL_VERSION:
+ rpc_uint32 supl_version;
+ case RPC_LOC_IOCTL_INFORM_SERVER_MULTI_OPEN_STATUS:
+ rpc_loc_server_multi_open_status_s_type multi_conn_open_status;
+ case RPC_LOC_IOCTL_RESERVED_CMD:
+ rpc_loc_reserved_payload_s_type reserved;
+ default:
+ void;
+};
+
+union rpc_loc_ioctl_callback_data_u_type switch (rpc_loc_ioctl_e_type disc) {
+ case RPC_LOC_IOCTL_GET_API_VERSION:
+ rpc_loc_api_version_s_type api_version;
+ case RPC_LOC_IOCTL_GET_FIX_CRITERIA:
+ rpc_loc_fix_criteria_s_type fix_criteria;
+ case RPC_LOC_IOCTL_GET_ENGINE_LOCK:
+ rpc_loc_lock_e_type engine_lock;
+ case RPC_LOC_IOCTL_GET_SBAS_CONFIG:
+ rpc_boolean sbas_mode;
+ case RPC_LOC_IOCTL_GET_NMEA_TYPES:
+ rpc_loc_nmea_sentence_type nmea_types;
+ case RPC_LOC_IOCTL_GET_ON_DEMAND_LPM:
+ rpc_boolean on_demand_lpm;
+ case RPC_LOC_IOCTL_GET_CDMA_PDE_SERVER_ADDR:
+ case RPC_LOC_IOCTL_GET_CDMA_MPC_SERVER_ADDR:
+ case RPC_LOC_IOCTL_GET_UMTS_SLP_SERVER_ADDR:
+ case RPC_LOC_IOCTL_GET_CUSTOM_PDE_SERVER_ADDR:
+ rpc_loc_server_info_s_type server_addr;
+ case RPC_LOC_IOCTL_QUERY_PREDICTED_ORBITS_DATA_SOURCE:
+ rpc_loc_predicted_orbits_data_source_s_type predicted_orbits_data_source;
+ case RPC_LOC_IOCTL_QUERY_PREDICTED_ORBITS_DATA_VALIDITY:
+ rpc_loc_predicted_orbits_data_validity_report_s_type predicted_orbits_data_validity;
+ case RPC_LOC_IOCTL_GET_XTRA_T_SESSION_CONTROL:
+ rpc_uint8 xtra_t_session_control;
+ case RPC_LOC_IOCTL_GET_LBS_APN_PROFILE:
+ case RPC_LOC_IOCTL_GET_XTRA_APN_PROFILE:
+ rpc_loc_apn_profiles_type apn_profiles[6];
+ case RPC_LOC_IOCTL_GET_SUPL_VERSION:
+ rpc_uint32 supl_version;
+ default:
+ void;
+};
+
+struct rpc_loc_ioctl_callback_s_type {
+ rpc_loc_ioctl_e_type type;
+ rpc_int32 status;
+ rpc_loc_ioctl_callback_data_u_type data;
+};
+
+union rpc_loc_event_payload_u_type switch (unsigned hyper disc) {
+ case RPC_LOC_EVENT_PARSED_POSITION_REPORT:
+ rpc_loc_parsed_position_s_type parsed_location_report;
+ case RPC_LOC_EVENT_SATELLITE_REPORT:
+ rpc_loc_gnss_info_s_type gnss_report;
+ case RPC_LOC_EVENT_NMEA_POSITION_REPORT:
+ case RPC_LOC_EVENT_NMEA_1HZ_REPORT:
+ rpc_loc_nmea_report_s_type nmea_report;
+ case RPC_LOC_EVENT_NI_NOTIFY_VERIFY_REQUEST:
+ rpc_loc_ni_event_s_type ni_request;
+ case RPC_LOC_EVENT_ASSISTANCE_DATA_REQUEST:
+ rpc_loc_assist_data_request_s_type assist_data_request;
+ case RPC_LOC_EVENT_LOCATION_SERVER_REQUEST:
+ rpc_loc_server_request_s_type loc_server_request;
+ case RPC_LOC_EVENT_IOCTL_REPORT:
+ rpc_loc_ioctl_callback_s_type ioctl_report;
+ case RPC_LOC_EVENT_STATUS_REPORT:
+ rpc_loc_status_event_s_type status_report;
+ case RPC_LOC_EVENT_WPS_NEEDED_REQUEST:
+ rpc_loc_qwip_request_s_type qwip_request;
+ case RPC_LOC_EVENT_RESERVED:
+ rpc_loc_reserved_payload_s_type reserved;
+ default:
+ void;
+};
+
diff --git a/msm8909/loc_api/libloc_api_50001/Android.mk b/msm8909/loc_api/libloc_api_50001/Android.mk
new file mode 100644
index 0000000..62905e8
--- /dev/null
+++ b/msm8909/loc_api/libloc_api_50001/Android.mk
@@ -0,0 +1,106 @@
+ifneq ($(BUILD_TINY_ANDROID),true)
+#Compile this library only for builds with the latest modem image
+
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := libloc_eng
+LOCAL_MODULE_OWNER := qcom
+
+LOCAL_MODULE_TAGS := optional
+
+LOCAL_SHARED_LIBRARIES := \
+ libutils \
+ libcutils \
+ libdl \
+ liblog \
+ libloc_core \
+ libgps.utils
+
+LOCAL_SRC_FILES += \
+ loc_eng.cpp \
+ loc_eng_agps.cpp \
+ loc_eng_xtra.cpp \
+ loc_eng_ni.cpp \
+ loc_eng_log.cpp \
+ loc_eng_nmea.cpp \
+ LocEngAdapter.cpp
+
+LOCAL_SRC_FILES += \
+ loc_eng_dmn_conn.cpp \
+ loc_eng_dmn_conn_handler.cpp \
+ loc_eng_dmn_conn_thread_helper.c \
+ loc_eng_dmn_conn_glue_msg.c \
+ loc_eng_dmn_conn_glue_pipe.c
+
+LOCAL_CFLAGS += \
+ -fno-short-enums \
+ -D_ANDROID_
+
+LOCAL_C_INCLUDES:= \
+ $(TARGET_OUT_HEADERS)/gps.utils \
+ $(TARGET_OUT_HEADERS)/libloc_core \
+ hardware/qcom/gps/loc_api/libloc_api_50001 \
+ $(TARGET_OUT_HEADERS)/libflp
+
+LOCAL_COPY_HEADERS_TO:= libloc_eng/
+LOCAL_COPY_HEADERS:= \
+ LocEngAdapter.h \
+ loc.h \
+ loc_eng.h \
+ loc_eng_xtra.h \
+ loc_eng_ni.h \
+ loc_eng_agps.h \
+ loc_eng_msg.h \
+ loc_eng_log.h
+
+LOCAL_PRELINK_MODULE := false
+
+include $(BUILD_SHARED_LIBRARY)
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := gps.$(BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE)
+LOCAL_MODULE_OWNER := qcom
+
+LOCAL_MODULE_TAGS := optional
+
+## Libs
+
+LOCAL_SHARED_LIBRARIES := \
+ libutils \
+ libcutils \
+ liblog \
+ libloc_eng \
+ libloc_core \
+ libgps.utils \
+ libdl
+
+ifneq ($(filter $(TARGET_DEVICE), apq8084 msm8960), false)
+endif
+
+LOCAL_SRC_FILES += \
+ loc.cpp \
+ gps.c
+
+LOCAL_CFLAGS += \
+ -fno-short-enums \
+ -D_ANDROID_ \
+
+ifeq ($(TARGET_USES_QCOM_BSP), true)
+LOCAL_CFLAGS += -DTARGET_USES_QCOM_BSP
+endif
+
+## Includes
+LOCAL_C_INCLUDES:= \
+ $(TARGET_OUT_HEADERS)/gps.utils \
+ $(TARGET_OUT_HEADERS)/libloc_core \
+ $(TARGET_OUT_HEADERS)/libflp
+
+LOCAL_PRELINK_MODULE := false
+LOCAL_MODULE_RELATIVE_PATH := hw
+
+include $(BUILD_SHARED_LIBRARY)
+
+endif # not BUILD_TINY_ANDROID
diff --git a/msm8909/loc_api/libloc_api_50001/LocEngAdapter.cpp b/msm8909/loc_api/libloc_api_50001/LocEngAdapter.cpp
new file mode 100644
index 0000000..35447d4
--- /dev/null
+++ b/msm8909/loc_api/libloc_api_50001/LocEngAdapter.cpp
@@ -0,0 +1,544 @@
+/* Copyright (c) 2011-2015, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * 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
+#define LOG_TAG "LocSvc_EngAdapter"
+
+#include <sys/stat.h>
+#include <errno.h>
+#include <ctype.h>
+#include <cutils/properties.h>
+#include <LocEngAdapter.h>
+#include "loc_eng_msg.h"
+#include "loc_log.h"
+
+#define CHIPSET_SERIAL_NUMBER_MAX_LEN 16
+#define USER_AGENT_MAX_LEN 512
+
+using namespace loc_core;
+
+LocInternalAdapter::LocInternalAdapter(LocEngAdapter* adapter) :
+ LocAdapterBase(adapter->getMsgTask()),
+ mLocEngAdapter(adapter)
+{
+}
+void LocInternalAdapter::setPositionModeInt(LocPosMode& posMode) {
+ sendMsg(new LocEngPositionMode(mLocEngAdapter, posMode));
+}
+void LocInternalAdapter::startFixInt() {
+ sendMsg(new LocEngStartFix(mLocEngAdapter));
+}
+void LocInternalAdapter::stopFixInt() {
+ sendMsg(new LocEngStopFix(mLocEngAdapter));
+}
+void LocInternalAdapter::getZppInt() {
+ sendMsg(new LocEngGetZpp(mLocEngAdapter));
+}
+
+LocEngAdapter::LocEngAdapter(LOC_API_ADAPTER_EVENT_MASK_T mask,
+ void* owner, ContextBase* context,
+ LocThread::tCreate tCreator) :
+ LocAdapterBase(mask,
+ //Get the AFW context if VzW context has not already been intialized in
+ //loc_ext
+ context == NULL?
+ LocDualContext::getLocFgContext(tCreator,
+ NULL,
+ LocDualContext::mLocationHalName,
+ false)
+ :context),
+ mOwner(owner), mInternalAdapter(new LocInternalAdapter(this)),
+ mUlp(new UlpProxyBase()), mNavigating(false),
+ mSupportsAgpsRequests(false),
+ mSupportsPositionInjection(false),
+ mSupportsTimeInjection(false),
+ mPowerVote(0)
+{
+ memset(&mFixCriteria, 0, sizeof(mFixCriteria));
+ mFixCriteria.mode = LOC_POSITION_MODE_INVALID;
+ LOC_LOGD("LocEngAdapter created");
+}
+
+inline
+LocEngAdapter::~LocEngAdapter()
+{
+ delete mInternalAdapter;
+ LOC_LOGV("LocEngAdapter deleted");
+}
+
+void LocEngAdapter::setXtraUserAgent() {
+ struct LocSetXtraUserAgent : public LocMsg {
+ const ContextBase* const mContext;
+ inline LocSetXtraUserAgent(ContextBase* context) :
+ LocMsg(), mContext(context) {
+ }
+ virtual void proc() const {
+ char release[PROPERTY_VALUE_MAX];
+ char manufacture[PROPERTY_VALUE_MAX];
+ char model[PROPERTY_VALUE_MAX];
+ char carrier[PROPERTY_VALUE_MAX];
+ char board[PROPERTY_VALUE_MAX];
+ char brand[PROPERTY_VALUE_MAX];
+ char chipsetsn[CHIPSET_SERIAL_NUMBER_MAX_LEN];
+ char userAgent[USER_AGENT_MAX_LEN];
+ const char defVal[] = "-";
+
+ property_get("ro.build.version.release", release, defVal);
+ property_get("ro.product.manufacturer", manufacture, defVal);
+ property_get("ro.product.model", model, defVal);
+ property_get("ro.carrier", carrier, defVal);
+ property_get("ro.product.board", board, defVal);
+ property_get("ro.product.brand", brand, defVal);
+ getChipsetSerialNo(chipsetsn, sizeof(chipsetsn), defVal);
+
+ snprintf(userAgent, sizeof(userAgent), "A/%s/%s/%s/%s/%s/QCX3/s%u/-/%s/-/%s/-/-/-",
+ release, manufacture, model, board, carrier,
+ mContext->getIzatDevId(), chipsetsn, brand);
+
+ for (int i = 0; i < sizeof(userAgent) && userAgent[i]; i++) {
+ if (' ' == userAgent[i]) userAgent[i] = '#';
+ }
+
+ saveUserAgentString(userAgent, strlen(userAgent));
+ LOC_LOGV("%s] UserAgent %s", __func__, userAgent);
+ }
+
+ void saveUserAgentString(const char* data, const int len) const {
+ const char XTRA_FOLDER[] = "/data/misc/location/xtra";
+ const char USER_AGENT_FILE[] = "/data/misc/location/xtra/useragent.txt";
+
+ if (data == NULL || len < 1) {
+ LOC_LOGE("%s:%d]: invalid input data = %p len = %d", __func__, __LINE__, data, len);
+ return;
+ }
+
+ struct stat s;
+ int err = stat(XTRA_FOLDER, &s);
+ if (err < 0) {
+ if (ENOENT == errno) {
+ if (mkdir(XTRA_FOLDER, 0700) < 0) {
+ LOC_LOGE("%s:%d]: make XTRA_FOLDER failed", __func__, __LINE__);
+ return;
+ }
+ } else {
+ LOC_LOGE("%s:%d]: XTRA_FOLDER invalid", __func__, __LINE__);
+ return;
+ }
+ }
+
+ FILE* file = fopen(USER_AGENT_FILE, "wt");
+ if (file == NULL) {
+ LOC_LOGE("%s:%d]: open USER_AGENT_FILE failed", __func__, __LINE__);
+ return;
+ }
+
+ size_t written = fwrite(data, 1, len, file);
+ fclose(file);
+ file = NULL;
+
+ // set file permission
+ chmod(USER_AGENT_FILE, 0600);
+
+ if (written != len) {
+ LOC_LOGE("%s:%d]: write USER_AGENT_FILE failed", __func__, __LINE__);
+ }
+ }
+
+ void getChipsetSerialNo(char buf[], int buflen, const char def[]) const {
+ const char SOC_SERIAL_NUMBER[] = "/sys/devices/soc0/serial_number";
+
+ FILE* file = fopen(SOC_SERIAL_NUMBER, "rt");
+ if (file == NULL) {
+ // use default upon unreadable file
+ strlcpy(buf, def, buflen);
+
+ } else {
+ size_t size = fread(buf, 1, buflen - 1, file);
+ if (size == 0) {
+ // use default upon empty file
+ strlcpy(buf, def, buflen);
+
+ } else {
+ buf[size] = '\0';
+ }
+
+ fclose(file);
+
+ // remove trailing spaces
+ size_t len = strlen(buf);
+ while (--len >= 0 && isspace(buf[len])) {
+ buf[len] = '\0';
+ }
+ }
+
+ return;
+ }
+
+ };
+
+ sendMsg(new LocSetXtraUserAgent(mContext));
+}
+
+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;
+ }
+
+ 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;
+}
+
+int LocEngAdapter::setGpsLockMsg(LOC_GPS_LOCK_MASK lockMask)
+{
+ struct LocEngAdapterGpsLock : public LocMsg {
+ LocEngAdapter* mAdapter;
+ LOC_GPS_LOCK_MASK mLockMask;
+ inline LocEngAdapterGpsLock(LocEngAdapter* adapter, LOC_GPS_LOCK_MASK lockMask) :
+ LocMsg(), mAdapter(adapter), mLockMask(lockMask)
+ {
+ locallog();
+ }
+ inline virtual void proc() const {
+ mAdapter->setGpsLock(mLockMask);
+ }
+ inline void locallog() const {
+ LOC_LOGV("LocEngAdapterGpsLock - mLockMask: %x", mLockMask);
+ }
+ inline virtual void log() const {
+ locallog();
+ }
+ };
+ sendMsg(new LocEngAdapterGpsLock(this, lockMask));
+ return 0;
+}
+
+void LocEngAdapter::requestPowerVote()
+{
+ if (getPowerVoteRight()) {
+ /* 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.
+ */
+ bool powerUp = getPowerVote();
+ LOC_LOGV("LocEngAdapterVotePower - Vote Power: %d", (int)powerUp);
+ setGpsLock(powerUp ? 103 : 101);
+ }
+}
+
+void LocInternalAdapter::reportPosition(UlpLocation &location,
+ GpsLocationExtended &locationExtended,
+ void* locationExt,
+ enum loc_sess_status status,
+ LocPosTechMask loc_technology_mask)
+{
+ sendMsg(new LocEngReportPosition(mLocEngAdapter,
+ location,
+ locationExtended,
+ locationExt,
+ status,
+ loc_technology_mask));
+}
+
+
+void LocEngAdapter::reportPosition(UlpLocation &location,
+ GpsLocationExtended &locationExtended,
+ void* locationExt,
+ enum loc_sess_status status,
+ LocPosTechMask loc_technology_mask)
+{
+ if (! mUlp->reportPosition(location,
+ locationExtended,
+ locationExt,
+ status,
+ loc_technology_mask )) {
+ mInternalAdapter->reportPosition(location,
+ locationExtended,
+ locationExt,
+ status,
+ loc_technology_mask);
+ }
+}
+
+void LocInternalAdapter::reportSv(GnssSvStatus &svStatus,
+ GpsLocationExtended &locationExtended,
+ void* svExt){
+ sendMsg(new LocEngReportSv(mLocEngAdapter, svStatus,
+ locationExtended, svExt));
+}
+
+void LocEngAdapter::reportSv(GnssSvStatus &svStatus,
+ GpsLocationExtended &locationExtended,
+ void* svExt)
+{
+
+ // We want to send SV info to ULP to help it in determining GNSS
+ // signal strength ULP will forward the SV reports to HAL without
+ // any modifications
+ if (! mUlp->reportSv(svStatus, locationExtended, svExt)) {
+ mInternalAdapter->reportSv(svStatus, locationExtended, svExt);
+ }
+}
+
+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));
+}
+
+void LocEngAdapter::reportStatus(GpsStatusValue status)
+{
+ if (!mUlp->reportStatus(status)) {
+ mInternalAdapter->reportStatus(status);
+ }
+}
+
+inline
+void LocEngAdapter::reportNmea(const char* nmea, int length)
+{
+ sendMsg(new LocEngReportNmea(mOwner, nmea, length));
+}
+
+inline
+bool LocEngAdapter::reportXtraServer(const char* url1,
+ const char* url2,
+ const char* url3,
+ const int maxlength)
+{
+ if (mSupportsAgpsRequests) {
+ sendMsg(new LocEngReportXtraServer(mOwner, url1,
+ url2, url3, maxlength));
+ }
+ return mSupportsAgpsRequests;
+}
+
+inline
+bool LocEngAdapter::requestATL(int connHandle, AGpsType agps_type)
+{
+ if (mSupportsAgpsRequests) {
+ sendMsg(new LocEngRequestATL(mOwner,
+ connHandle, agps_type));
+ }
+ return mSupportsAgpsRequests;
+}
+
+inline
+bool LocEngAdapter::releaseATL(int connHandle)
+{
+ if (mSupportsAgpsRequests) {
+ sendMsg(new LocEngReleaseATL(mOwner, connHandle));
+ }
+ return mSupportsAgpsRequests;
+}
+
+inline
+bool LocEngAdapter::requestXtraData()
+{
+ if (mSupportsAgpsRequests) {
+ sendMsg(new LocEngRequestXtra(mOwner));
+ }
+ return mSupportsAgpsRequests;
+}
+
+inline
+bool LocEngAdapter::requestTime()
+{
+ if (mSupportsAgpsRequests) {
+ sendMsg(new LocEngRequestTime(mOwner));
+ }
+ return mSupportsAgpsRequests;
+}
+
+inline
+bool LocEngAdapter::requestNiNotify(GpsNiNotification ¬if, const void* data)
+{
+ if (mSupportsAgpsRequests) {
+ notif.size = sizeof(notif);
+ notif.timeout = LOC_NI_NO_RESPONSE_TIME;
+
+ sendMsg(new LocEngRequestNi(mOwner, notif, data));
+ }
+ return mSupportsAgpsRequests;
+}
+
+inline
+bool LocEngAdapter::requestSuplES(int connHandle)
+{
+ if (mSupportsAgpsRequests)
+ sendMsg(new LocEngRequestSuplEs(mOwner, connHandle));
+ return mSupportsAgpsRequests;
+}
+
+inline
+bool LocEngAdapter::reportDataCallOpened()
+{
+ if(mSupportsAgpsRequests)
+ sendMsg(new LocEngSuplEsOpened(mOwner));
+ return mSupportsAgpsRequests;
+}
+
+inline
+bool LocEngAdapter::reportDataCallClosed()
+{
+ if(mSupportsAgpsRequests)
+ sendMsg(new LocEngSuplEsClosed(mOwner));
+ return mSupportsAgpsRequests;
+}
+
+inline
+void LocEngAdapter::handleEngineDownEvent()
+{
+ sendMsg(new LocEngDown(mOwner));
+}
+
+inline
+void LocEngAdapter::handleEngineUpEvent()
+{
+ sendMsg(new LocEngUp(mOwner));
+}
+
+enum loc_api_adapter_err LocEngAdapter::setTime(GpsUtcTime time,
+ int64_t timeReference,
+ int uncertainty)
+{
+ loc_api_adapter_err result = LOC_API_ADAPTER_ERR_SUCCESS;
+
+ LOC_LOGD("%s:%d]: mSupportsTimeInjection is %d",
+ __func__, __LINE__, mSupportsTimeInjection);
+
+ if (mSupportsTimeInjection) {
+ LOC_LOGD("%s:%d]: Injecting time", __func__, __LINE__);
+ result = mLocApi->setTime(time, timeReference, uncertainty);
+ } else {
+ mSupportsTimeInjection = true;
+ }
+ return result;
+}
+
+enum loc_api_adapter_err LocEngAdapter::setXtraVersionCheck(int check)
+{
+ enum loc_api_adapter_err ret;
+ ENTRY_LOG();
+ enum xtra_version_check eCheck;
+ switch (check) {
+ case 0:
+ eCheck = DISABLED;
+ break;
+ case 1:
+ eCheck = AUTO;
+ break;
+ case 2:
+ eCheck = XTRA2;
+ break;
+ case 3:
+ eCheck = XTRA3;
+ break;
+ default:
+ eCheck = DISABLED;
+ }
+ ret = mLocApi->setXtraVersionCheck(eCheck);
+ EXIT_LOG(%d, ret);
+ return ret;
+}
+
+void LocEngAdapter::reportGpsMeasurementData(GpsData &gpsMeasurementData)
+{
+ sendMsg(new LocEngReportGpsMeasurement(mOwner,
+ gpsMeasurementData));
+}
+
+/*
+ Update Registration Mask
+ */
+void LocEngAdapter::updateRegistrationMask(LOC_API_ADAPTER_EVENT_MASK_T event,
+ loc_registration_mask_status isEnabled)
+{
+ LOC_LOGD("entering %s", __func__);
+ int result = LOC_API_ADAPTER_ERR_FAILURE;
+ result = mLocApi->updateRegistrationMask(event, isEnabled);
+ if (result == LOC_API_ADAPTER_ERR_SUCCESS) {
+ LOC_LOGD("%s] update registration mask succeed.", __func__);
+ } else {
+ LOC_LOGE("%s] update registration mask failed.", __func__);
+ }
+}
+
+/*
+ Set Gnss Constellation Config
+ */
+bool LocEngAdapter::gnssConstellationConfig()
+{
+ LOC_LOGD("entering %s", __func__);
+ bool result = false;
+ result = mLocApi->gnssConstellationConfig();
+ return result;
+}
diff --git a/msm8909/loc_api/libloc_api_50001/LocEngAdapter.h b/msm8909/loc_api/libloc_api_50001/LocEngAdapter.h
new file mode 100644
index 0000000..a193e81
--- /dev/null
+++ b/msm8909/loc_api/libloc_api_50001/LocEngAdapter.h
@@ -0,0 +1,351 @@
+/* Copyright (c) 2011-2015, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * 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_API_ENG_ADAPTER_H
+#define LOC_API_ENG_ADAPTER_H
+
+#include <ctype.h>
+#include <hardware/gps.h>
+#include <loc.h>
+#include <loc_eng_log.h>
+#include <log_util.h>
+#include <LocAdapterBase.h>
+#include <LocDualContext.h>
+#include <UlpProxyBase.h>
+#include <platform_lib_includes.h>
+
+#define MAX_URL_LEN 256
+
+using namespace loc_core;
+
+class LocEngAdapter;
+
+class LocInternalAdapter : public LocAdapterBase {
+ LocEngAdapter* mLocEngAdapter;
+public:
+ LocInternalAdapter(LocEngAdapter* adapter);
+
+ virtual void reportPosition(UlpLocation &location,
+ GpsLocationExtended &locationExtended,
+ void* locationExt,
+ enum loc_sess_status status,
+ LocPosTechMask loc_technology_mask);
+ virtual void reportSv(GnssSvStatus &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);
+};
+
+typedef void (*loc_msg_sender)(void* loc_eng_data_p, void* msgp);
+
+class LocEngAdapter : public LocAdapterBase {
+ void* mOwner;
+ LocInternalAdapter* mInternalAdapter;
+ 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 mSupportsTimeInjection;
+
+ LocEngAdapter(LOC_API_ADAPTER_EVENT_MASK_T mask,
+ void* owner, ContextBase* context,
+ LocThread::tCreate tCreator);
+ virtual ~LocEngAdapter();
+
+ virtual void setUlpProxy(UlpProxyBase* ulp);
+ void setXtraUserAgent();
+ inline void requestUlp(unsigned long capabilities) {
+ mContext->requestUlp(mInternalAdapter, capabilities);
+ }
+ 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 const MsgTask* getMsgTask() { return mMsgTask; }
+
+ inline enum loc_api_adapter_err
+ startFix()
+ {
+ return mLocApi->startFix(mFixCriteria);
+ }
+ inline enum loc_api_adapter_err
+ stopFix()
+ {
+ return mLocApi->stopFix();
+ }
+ inline enum loc_api_adapter_err
+ deleteAidingData(GpsAidingData f)
+ {
+ return mLocApi->deleteAidingData(f);
+ }
+ inline enum loc_api_adapter_err
+ enableData(int enable)
+ {
+ return mLocApi->enableData(enable);
+ }
+ inline enum loc_api_adapter_err
+ setAPN(char* apn, int len)
+ {
+ return mLocApi->setAPN(apn, len);
+ }
+ inline enum loc_api_adapter_err
+ injectPosition(double latitude, double longitude, float accuracy)
+ {
+ return mLocApi->injectPosition(latitude, longitude, accuracy);
+ }
+ inline enum loc_api_adapter_err
+ setXtraData(char* data, int length)
+ {
+ return mLocApi->setXtraData(data, length);
+ }
+ inline enum loc_api_adapter_err
+ requestXtraServer()
+ {
+ return mLocApi->requestXtraServer();
+ }
+ inline enum loc_api_adapter_err
+ atlOpenStatus(int handle, int is_succ, char* apn, AGpsBearerType bearer, AGpsType agpsType)
+ {
+ return mLocApi->atlOpenStatus(handle, is_succ, apn, bearer, agpsType);
+ }
+ inline enum loc_api_adapter_err
+ atlCloseStatus(int handle, int is_succ)
+ {
+ return mLocApi->atlCloseStatus(handle, is_succ);
+ }
+ inline enum loc_api_adapter_err
+ setPositionMode(const LocPosMode *posMode)
+ {
+ if (NULL != posMode) {
+ mFixCriteria = *posMode;
+ }
+ return mLocApi->setPositionMode(mFixCriteria);
+ }
+ inline enum loc_api_adapter_err
+ setServer(const char* url, int len)
+ {
+ return mLocApi->setServer(url, len);
+ }
+ inline enum loc_api_adapter_err
+ setServer(unsigned int ip, int port,
+ LocServerType type)
+ {
+ return mLocApi->setServer(ip, port, type);
+ }
+ inline enum loc_api_adapter_err
+ informNiResponse(GpsUserResponseType userResponse, const void* passThroughData)
+ {
+ return mLocApi->informNiResponse(userResponse, passThroughData);
+ }
+ inline enum loc_api_adapter_err
+ setSUPLVersion(uint32_t version)
+ {
+ return mLocApi->setSUPLVersion(version);
+ }
+ inline enum loc_api_adapter_err
+ setLPPConfig(uint32_t profile)
+ {
+ return mLocApi->setLPPConfig(profile);
+ }
+ inline enum loc_api_adapter_err
+ setSensorControlConfig(int sensorUsage, int sensorProvider)
+ {
+ return mLocApi->setSensorControlConfig(sensorUsage, sensorProvider);
+ }
+ inline enum loc_api_adapter_err
+ setSensorProperties(bool gyroBiasVarianceRandomWalk_valid, float gyroBiasVarianceRandomWalk,
+ bool accelBiasVarianceRandomWalk_valid, float accelBiasVarianceRandomWalk,
+ bool angleBiasVarianceRandomWalk_valid, float angleBiasVarianceRandomWalk,
+ bool rateBiasVarianceRandomWalk_valid, float rateBiasVarianceRandomWalk,
+ bool velocityBiasVarianceRandomWalk_valid, float velocityBiasVarianceRandomWalk)
+ {
+ return mLocApi->setSensorProperties(gyroBiasVarianceRandomWalk_valid, gyroBiasVarianceRandomWalk,
+ accelBiasVarianceRandomWalk_valid, accelBiasVarianceRandomWalk,
+ angleBiasVarianceRandomWalk_valid, angleBiasVarianceRandomWalk,
+ rateBiasVarianceRandomWalk_valid, rateBiasVarianceRandomWalk,
+ velocityBiasVarianceRandomWalk_valid, velocityBiasVarianceRandomWalk);
+ }
+ inline virtual enum loc_api_adapter_err
+ setSensorPerfControlConfig(int controlMode, int accelSamplesPerBatch, int accelBatchesPerSec,
+ int gyroSamplesPerBatch, int gyroBatchesPerSec,
+ int accelSamplesPerBatchHigh, int accelBatchesPerSecHigh,
+ int gyroSamplesPerBatchHigh, int gyroBatchesPerSecHigh, int algorithmConfig)
+ {
+ return mLocApi->setSensorPerfControlConfig(controlMode, accelSamplesPerBatch, accelBatchesPerSec,
+ gyroSamplesPerBatch, gyroBatchesPerSec,
+ accelSamplesPerBatchHigh, accelBatchesPerSecHigh,
+ gyroSamplesPerBatchHigh, gyroBatchesPerSecHigh,
+ algorithmConfig);
+ }
+ inline virtual enum loc_api_adapter_err
+ setExtPowerConfig(int isBatteryCharging)
+ {
+ return mLocApi->setExtPowerConfig(isBatteryCharging);
+ }
+ inline virtual enum loc_api_adapter_err
+ setAGLONASSProtocol(unsigned long aGlonassProtocol)
+ {
+ return mLocApi->setAGLONASSProtocol(aGlonassProtocol);
+ }
+ inline virtual int initDataServiceClient()
+ {
+ return mLocApi->initDataServiceClient();
+ }
+ inline virtual int openAndStartDataCall()
+ {
+ return mLocApi->openAndStartDataCall();
+ }
+ inline virtual void stopDataCall()
+ {
+ mLocApi->stopDataCall();
+ }
+ inline virtual void closeDataCall()
+ {
+ mLocApi->closeDataCall();
+ }
+ inline enum loc_api_adapter_err
+ getZpp(GpsLocation &zppLoc, LocPosTechMask &tech_mask)
+ {
+ return mLocApi->getBestAvailableZppFix(zppLoc, tech_mask);
+ }
+ enum loc_api_adapter_err setTime(GpsUtcTime time,
+ int64_t timeReference,
+ int uncertainty);
+ enum loc_api_adapter_err setXtraVersionCheck(int check);
+ inline virtual void installAGpsCert(const DerEncodedCertificate* pData,
+ size_t length,
+ uint32_t slotBitMask)
+ {
+ mLocApi->installAGpsCert(pData, length, slotBitMask);
+ }
+ virtual void handleEngineDownEvent();
+ virtual void handleEngineUpEvent();
+ virtual void reportPosition(UlpLocation &location,
+ GpsLocationExtended &locationExtended,
+ void* locationExt,
+ enum loc_sess_status status,
+ LocPosTechMask loc_technology_mask);
+ virtual void reportSv(GnssSvStatus &svStatus,
+ GpsLocationExtended &locationExtended,
+ void* svExt);
+ virtual void reportStatus(GpsStatusValue status);
+ virtual void reportNmea(const char* nmea, int length);
+ virtual bool reportXtraServer(const char* url1, const char* url2,
+ const char* url3, const int maxlength);
+ virtual bool requestXtraData();
+ virtual bool requestTime();
+ virtual bool requestATL(int connHandle, AGpsType agps_type);
+ virtual bool releaseATL(int connHandle);
+ virtual bool requestNiNotify(GpsNiNotification ¬ify, const void* data);
+ virtual bool requestSuplES(int connHandle);
+ virtual bool reportDataCallOpened();
+ virtual bool reportDataCallClosed();
+ virtual void reportGpsMeasurementData(GpsData &gpsMeasurementData);
+
+ inline const LocPosMode& getPositionMode() const
+ {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();
+ mContext->modemPowerVote(powerOn);
+ }
+ 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(LOC_GPS_LOCK_MASK lock)
+ {
+ return mLocApi->setGpsLock(lock);
+ }
+
+ int setGpsLockMsg(LOC_GPS_LOCK_MASK lock);
+
+ /*
+ Returns
+ Current value of GPS lock on success
+ -1 on failure
+ */
+ inline int getGpsLock()
+ {
+ return mLocApi->getGpsLock();
+ }
+
+ /*
+ Update Registration Mask
+ */
+ void updateRegistrationMask(LOC_API_ADAPTER_EVENT_MASK_T event,
+ loc_registration_mask_status isEnabled);
+
+ /*
+ Set Gnss Constellation Config
+ */
+ bool gnssConstellationConfig();
+};
+
+#endif //LOC_API_ENG_ADAPTER_H
diff --git a/msm8909/loc_api/libloc_api_50001/Makefile.am b/msm8909/loc_api/libloc_api_50001/Makefile.am
new file mode 100644
index 0000000..2374357
--- /dev/null
+++ b/msm8909/loc_api/libloc_api_50001/Makefile.am
@@ -0,0 +1,76 @@
+AM_CFLAGS = \
+ -I../../utils \
+ -I../../platform_lib_abstractions \
+ -fno-short-enums \
+ -DFEATURE_GNSS_BIT_API
+
+libloc_adapter_so_la_SOURCES = loc_eng_log.cpp LocEngAdapter.cpp
+
+if USE_GLIB
+libloc_adapter_so_la_CFLAGS = -DUSE_GLIB $(AM_CFLAGS) @GLIB_CFLAGS@
+libloc_adapter_so_la_LDFLAGS = -lstdc++ -lpthread @GLIB_LIBS@ -shared -version-info 1:0:0
+libloc_adapter_so_la_CPPFLAGS = -DUSE_GLIB $(AM_CFLAGS) $(AM_CPPFLAGS) @GLIB_CFLAGS@
+else
+libloc_adapter_so_la_CFLAGS = $(AM_CFLAGS)
+libloc_adapter_so_la_LDFLAGS = -lpthread -shared -version-info 1:0:0
+libloc_adapter_so_la_CPPFLAGS = $(AM_CFLAGS) $(AM_CPPFLAGS)
+endif
+libloc_adapter_so_la_LIBADD = -lstdc++ -lcutils ../../utils/libgps_utils_so.la
+
+
+libloc_eng_so_la_SOURCES = \
+ loc_eng.cpp \
+ loc_eng_agps.cpp \
+ loc_eng_xtra.cpp \
+ loc_eng_ni.cpp \
+ loc_eng_log.cpp \
+ loc_eng_dmn_conn.cpp \
+ loc_eng_dmn_conn_handler.cpp \
+ loc_eng_dmn_conn_thread_helper.c \
+ loc_eng_dmn_conn_glue_msg.c \
+ loc_eng_dmn_conn_glue_pipe.c
+
+
+if USE_GLIB
+libloc_eng_so_la_CFLAGS = -DUSE_GLIB $(AM_CFLAGS) @GLIB_CFLAGS@
+libloc_eng_so_la_LDFLAGS = -lstdc++ -lpthread @GLIB_LIBS@ -shared -version-info 1:0:0
+libloc_eng_so_la_CPPFLAGS = -DUSE_GLIB $(AM_CFLAGS) $(AM_CPPFLAGS) @GLIB_CFLAGS@
+else
+libloc_eng_so_la_CFLAGS = $(AM_CFLAGS)
+libloc_eng_so_la_LDFLAGS = -lpthread -shared -version-info 1:0:0
+libloc_eng_so_la_CPPFLAGS = $(AM_CFLAGS) $(AM_CPPFLAGS)
+endif
+
+libloc_eng_so_la_LIBADD = -lstdc++ -lcutils -ldl ../../utils/libgps_utils_so.la libloc_adapter_so.la
+
+
+libgps_default_so_la_SOURCES = \
+ loc.cpp \
+ gps.c
+
+if USE_GLIB
+libgps_default_so_la_CFLAGS = -DUSE_GLIB $(AM_CFLAGS) @GLIB_CFLAGS@
+libgps_default_so_la_LDFLAGS = -lstdc++ -lpthread @GLIB_LIBS@ -shared -version-info 1:0:0
+libgps_default_so_la_CPPFLAGS = -DUSE_GLIB $(AM_CFLAGS) $(AM_CPPFLAGS) @GLIB_CFLAGS@
+else
+libgps_default_so_la_CFLAGS = $(AM_CFLAGS)
+libgps_default_so_la_LDFLAGS = -lpthread -shared -version-info 1:0:0
+libgps_default_so_la_CPPFLAGS = $(AM_CFLAGS) $(AM_CPPFLAGS)
+endif
+
+libgps_default_so_la_LIBADD = -lstdc++ -lcutils ../../utils/libgps_utils_so.la -ldl libloc_eng_so.la
+
+library_include_HEADERS = \
+ LocEngAdapter.h \
+ loc.h \
+ loc_eng.h \
+ loc_eng_xtra.h \
+ loc_eng_ni.h \
+ loc_eng_agps.h \
+ loc_eng_msg.h \
+ loc_eng_log.h
+
+library_includedir = $(pkgincludedir)/libloc_api_50001
+
+#Create and Install libraries
+lib_LTLIBRARIES = libloc_adapter_so.la libloc_eng_so.la libgps_default_so.la
diff --git a/msm8909/loc_api/libloc_api_50001/gps.c b/msm8909/loc_api/libloc_api_50001/gps.c
new file mode 100644
index 0000000..29f20f4
--- /dev/null
+++ b/msm8909/loc_api/libloc_api_50001/gps.c
@@ -0,0 +1,73 @@
+/* Copyright (c) 2011,2015 The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * 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 <hardware/gps.h>
+
+#include <stdlib.h>
+#include <string.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 = (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;
+ dev->common.version = 0;
+ dev->common.module = (struct hw_module_t*)module;
+ dev->get_gps_interface = gps__get_gps_interface;
+
+ *device = (struct hw_device_t*)dev;
+ return 0;
+}
+
+static struct hw_module_methods_t gps_module_methods = {
+ .open = open_gps
+};
+
+struct hw_module_t HAL_MODULE_INFO_SYM = {
+ .tag = HARDWARE_MODULE_TAG,
+ .module_api_version = 1,
+ .hal_api_version = 0,
+ .id = GPS_HARDWARE_MODULE_ID,
+ .name = "loc_api GPS Module",
+ .author = "Qualcomm USA, Inc.",
+ .methods = &gps_module_methods,
+};
diff --git a/msm8909/loc_api/libloc_api_50001/loc.cpp b/msm8909/loc_api/libloc_api_50001/loc.cpp
new file mode 100644
index 0000000..505fc94
--- /dev/null
+++ b/msm8909/loc_api/libloc_api_50001/loc.cpp
@@ -0,0 +1,1077 @@
+/* Copyright (c) 2011-2015, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * 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
+#define LOG_TAG "LocSvc_afw"
+
+#include <hardware/gps.h>
+#include <gps_extended.h>
+#include <loc_eng.h>
+#include <loc_target.h>
+#include <loc_log.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <dlfcn.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <LocDualContext.h>
+#include <cutils/properties.h>
+
+using namespace loc_core;
+
+#define LOC_PM_CLIENT_NAME "GPS"
+
+//Globals defns
+static gps_location_callback gps_loc_cb = NULL;
+static gps_sv_status_callback gps_sv_cb = NULL;
+
+static void local_loc_cb(UlpLocation* location, void* locExt);
+static void local_sv_cb(GpsSvStatus* sv_status, void* svExt);
+
+static const GpsGeofencingInterface* get_geofence_interface(void);
+
+// Function declarations for sLocEngInterface
+static int loc_init(GpsCallbacks* callbacks);
+static int loc_start();
+static int loc_stop();
+static void loc_cleanup();
+static int loc_inject_time(GpsUtcTime time, int64_t timeReference, int uncertainty);
+static int loc_inject_location(double latitude, double longitude, float accuracy);
+static void loc_delete_aiding_data(GpsAidingData f);
+static int loc_set_position_mode(GpsPositionMode mode, GpsPositionRecurrence recurrence,
+ uint32_t min_interval, uint32_t preferred_accuracy,
+ uint32_t preferred_time);
+static const void* loc_get_extension(const char* name);
+// Defines the GpsInterface in gps.h
+static const GpsInterface sLocEngInterface =
+{
+ sizeof(GpsInterface),
+ loc_init,
+ loc_start,
+ loc_stop,
+ loc_cleanup,
+ loc_inject_time,
+ loc_inject_location,
+ loc_delete_aiding_data,
+ loc_set_position_mode,
+ loc_get_extension
+};
+
+// Function declarations for sLocEngAGpsInterface
+static void loc_agps_init(AGpsCallbacks* callbacks);
+static int loc_agps_open(const char* apn);
+static int loc_agps_closed();
+static int loc_agps_open_failed();
+static int loc_agps_set_server(AGpsType type, const char *hostname, int port);
+static int loc_agps_open_with_apniptype( const char* apn, ApnIpType apnIpType);
+
+static const AGpsInterface sLocEngAGpsInterface =
+{
+ sizeof(AGpsInterface),
+ loc_agps_init,
+ loc_agps_open,
+ loc_agps_closed,
+ loc_agps_open_failed,
+ loc_agps_set_server,
+ loc_agps_open_with_apniptype
+};
+
+static int loc_xtra_init(GpsXtraCallbacks* callbacks);
+static int loc_xtra_inject_data(char* data, int length);
+
+static const GpsXtraInterface sLocEngXTRAInterface =
+{
+ sizeof(GpsXtraInterface),
+ loc_xtra_init,
+ loc_xtra_inject_data
+};
+
+static void loc_ni_init(GpsNiCallbacks *callbacks);
+static void loc_ni_respond(int notif_id, GpsUserResponseType user_response);
+
+static const GpsNiInterface sLocEngNiInterface =
+{
+ sizeof(GpsNiInterface),
+ loc_ni_init,
+ loc_ni_respond,
+};
+
+static int loc_gps_measurement_init(GpsMeasurementCallbacks* callbacks);
+static void loc_gps_measurement_close();
+
+static const GpsMeasurementInterface sLocEngGpsMeasurementInterface =
+{
+ sizeof(GpsMeasurementInterface),
+ loc_gps_measurement_init,
+ loc_gps_measurement_close
+};
+
+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);
+static void loc_agps_ril_ni_message(uint8_t *msg, size_t len);
+static void loc_agps_ril_update_network_state(int connected, int type, int roaming, const char* extra_info);
+static void loc_agps_ril_update_network_availability(int avaiable, const char* apn);
+
+static const AGpsRilInterface sLocEngAGpsRilInterface =
+{
+ sizeof(AGpsRilInterface),
+ loc_agps_ril_init,
+ loc_agps_ril_set_ref_location,
+ loc_agps_ril_set_set_id,
+ loc_agps_ril_ni_message,
+ loc_agps_ril_update_network_state,
+ loc_agps_ril_update_network_availability
+};
+
+static int loc_agps_install_certificates(const DerEncodedCertificate* certificates,
+ size_t length);
+static int loc_agps_revoke_certificates(const Sha1CertificateFingerprint* fingerprints,
+ size_t length);
+
+static const SuplCertificateInterface sLocEngAGpsCertInterface =
+{
+ sizeof(SuplCertificateInterface),
+ loc_agps_install_certificates,
+ loc_agps_revoke_certificates
+};
+
+static void loc_configuration_update(const char* config_data, int32_t length);
+
+static const GnssConfigurationInterface sLocEngConfigInterface =
+{
+ sizeof(GnssConfigurationInterface),
+ loc_configuration_update
+};
+
+static loc_eng_data_s_type loc_afw_data;
+static int gss_fd = -1;
+static int sGnssType = GNSS_UNKNOWN;
+/*===========================================================================
+FUNCTION gps_get_hardware_interface
+
+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 ()
+{
+ ENTRY_LOG_CALLFLOW();
+ const GpsInterface* ret_val;
+
+ char propBuf[PROPERTY_VALUE_MAX];
+
+ loc_eng_read_config();
+
+ // check to see if GPS should be disabled
+ property_get("gps.disable", propBuf, "");
+ if (propBuf[0] == '1')
+ {
+ LOC_LOGD("gps_get_interface returning NULL because gps.disable=1\n");
+ ret_val = NULL;
+ } else {
+ ret_val = &sLocEngInterface;
+ }
+
+ loc_eng_read_config();
+
+ EXIT_LOG(%p, ret_val);
+ return ret_val;
+}
+
+// for gps.c
+extern "C" const GpsInterface* get_gps_interface()
+{
+ unsigned int target = TARGET_DEFAULT;
+ loc_eng_read_config();
+
+ target = loc_get_target();
+ LOC_LOGD("Target name check returned %s", loc_get_target_name(target));
+
+ sGnssType = getTargetGnssType(target);
+ switch (sGnssType)
+ {
+ case GNSS_GSS:
+ case GNSS_AUTO:
+ //APQ8064
+ gps_conf.CAPABILITIES &= ~(GPS_CAPABILITY_MSA | GPS_CAPABILITY_MSB);
+ gss_fd = open("/dev/gss", O_RDONLY);
+ if (gss_fd < 0) {
+ LOC_LOGE("GSS open failed: %s\n", strerror(errno));
+ }
+ else {
+ 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.");
+ 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;
+}
+
+/*===========================================================================
+FUNCTION loc_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/Ax
+
+===========================================================================*/
+static int loc_init(GpsCallbacks* callbacks)
+{
+ int retVal = -1;
+ ENTRY_LOG();
+ LOC_API_ADAPTER_EVENT_MASK_T event;
+
+ if (NULL == callbacks) {
+ LOC_LOGE("loc_init failed. cb = NULL\n");
+ EXIT_LOG(%d, retVal);
+ return retVal;
+ }
+
+ event = LOC_API_ADAPTER_BIT_PARSED_POSITION_REPORT |
+ LOC_API_ADAPTER_BIT_SATELLITE_REPORT |
+ LOC_API_ADAPTER_BIT_LOCATION_SERVER_REQUEST |
+ LOC_API_ADAPTER_BIT_ASSISTANCE_DATA_REQUEST |
+ LOC_API_ADAPTER_BIT_IOCTL_REPORT |
+ LOC_API_ADAPTER_BIT_STATUS_REPORT |
+ LOC_API_ADAPTER_BIT_NMEA_1HZ_REPORT |
+ LOC_API_ADAPTER_BIT_NI_NOTIFY_VERIFY_REQUEST;
+
+ LocCallbacks clientCallbacks = {local_loc_cb, /* location_cb */
+ callbacks->status_cb, /* status_cb */
+ local_sv_cb, /* sv_status_cb */
+ callbacks->nmea_cb, /* nmea_cb */
+ callbacks->set_capabilities_cb, /* set_capabilities_cb */
+ callbacks->acquire_wakelock_cb, /* acquire_wakelock_cb */
+ callbacks->release_wakelock_cb, /* release_wakelock_cb */
+ callbacks->create_thread_cb, /* create_thread_cb */
+ NULL, /* location_ext_parser */
+ NULL, /* sv_ext_parser */
+ 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);
+ loc_afw_data.adapter->mSupportsAgpsRequests = !loc_afw_data.adapter->hasAgpsExtendedCapabilities();
+ loc_afw_data.adapter->mSupportsPositionInjection = !loc_afw_data.adapter->hasCPIExtendedCapabilities();
+ loc_afw_data.adapter->mSupportsTimeInjection = !loc_afw_data.adapter->hasCPIExtendedCapabilities();
+ loc_afw_data.adapter->setGpsLockMsg(0);
+ loc_afw_data.adapter->requestUlp(getCarrierCapabilities());
+ loc_afw_data.adapter->setXtraUserAgent();
+
+ if(retVal) {
+ LOC_LOGE("loc_eng_init() fail!");
+ goto err;
+ }
+
+ loc_afw_data.adapter->setPowerVoteRight(loc_get_target() == TARGET_QCA1530);
+ loc_afw_data.adapter->setPowerVote(true);
+
+ LOC_LOGD("loc_eng_init() success!");
+
+err:
+ EXIT_LOG(%d, retVal);
+ return retVal;
+}
+
+/*===========================================================================
+FUNCTION loc_cleanup
+
+DESCRIPTION
+ Cleans location engine. The location client handle will be released.
+
+DEPENDENCIES
+ None
+
+RETURN VALUE
+ None
+
+SIDE EFFECTS
+ N/A
+
+===========================================================================*/
+static void loc_cleanup()
+{
+ ENTRY_LOG();
+
+ loc_afw_data.adapter->setPowerVote(false);
+ loc_afw_data.adapter->setGpsLockMsg(gps_conf.GPS_LOCK);
+
+ loc_eng_cleanup(loc_afw_data);
+ gps_loc_cb = NULL;
+ gps_sv_cb = NULL;
+
+ EXIT_LOG(%s, VOID_RET);
+}
+
+/*===========================================================================
+FUNCTION loc_start
+
+DESCRIPTION
+ Starts the tracking session
+
+DEPENDENCIES
+ None
+
+RETURN VALUE
+ 0: success
+
+SIDE EFFECTS
+ N/A
+
+===========================================================================*/
+static int loc_start()
+{
+ ENTRY_LOG();
+ int ret_val = loc_eng_start(loc_afw_data);
+
+ EXIT_LOG(%d, ret_val);
+ return ret_val;
+}
+
+/*===========================================================================
+FUNCTION loc_stop
+
+DESCRIPTION
+ Stops the tracking session
+
+DEPENDENCIES
+ None
+
+RETURN VALUE
+ 0: success
+
+SIDE EFFECTS
+ N/A
+
+===========================================================================*/
+static int loc_stop()
+{
+ ENTRY_LOG();
+ int ret_val = -1;
+ ret_val = loc_eng_stop(loc_afw_data);
+
+ EXIT_LOG(%d, ret_val);
+ return ret_val;
+}
+
+/*===========================================================================
+FUNCTION loc_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_set_position_mode(GpsPositionMode mode,
+ GpsPositionRecurrence recurrence,
+ uint32_t min_interval,
+ uint32_t preferred_accuracy,
+ uint32_t preferred_time)
+{
+ ENTRY_LOG();
+ int ret_val = -1;
+ LocPositionMode locMode;
+ switch (mode) {
+ case GPS_POSITION_MODE_MS_BASED:
+ locMode = LOC_POSITION_MODE_MS_BASED;
+ break;
+ case GPS_POSITION_MODE_MS_ASSISTED:
+ locMode = LOC_POSITION_MODE_MS_ASSISTED;
+ break;
+ default:
+ locMode = LOC_POSITION_MODE_STANDALONE;
+ break;
+ }
+
+ LocPosMode params(locMode, recurrence, min_interval,
+ preferred_accuracy, preferred_time, NULL, NULL);
+ ret_val = loc_eng_set_position_mode(loc_afw_data, params);
+
+ EXIT_LOG(%d, ret_val);
+ return ret_val;
+}
+
+/*===========================================================================
+FUNCTION loc_inject_time
+
+DESCRIPTION
+ This is used by Java native function to do time injection.
+
+DEPENDENCIES
+ None
+
+RETURN VALUE
+ 0
+
+SIDE EFFECTS
+ N/A
+
+===========================================================================*/
+static int loc_inject_time(GpsUtcTime time, int64_t timeReference, int uncertainty)
+{
+ ENTRY_LOG();
+ int ret_val = 0;
+
+ ret_val = loc_eng_inject_time(loc_afw_data, time,
+ timeReference, uncertainty);
+
+ EXIT_LOG(%d, ret_val);
+ return ret_val;
+}
+
+
+/*===========================================================================
+FUNCTION loc_inject_location
+
+DESCRIPTION
+ This is used by Java native function to do location injection.
+
+DEPENDENCIES
+ None
+
+RETURN VALUE
+ 0 : Successful
+ error code : Failure
+
+SIDE EFFECTS
+ N/A
+===========================================================================*/
+static int loc_inject_location(double latitude, double longitude, float accuracy)
+{
+ ENTRY_LOG();
+
+ int ret_val = 0;
+ ret_val = loc_eng_inject_location(loc_afw_data, latitude, longitude, accuracy);
+
+ EXIT_LOG(%d, ret_val);
+ return ret_val;
+}
+
+
+/*===========================================================================
+FUNCTION loc_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
+ None