From 00fd7bc33b6453a3cb0490ca1e89e0502b77b5b5 Mon Sep 17 00:00:00 2001 From: Jiafei Wen Date: Mon, 3 Nov 2014 14:27:23 -0800 Subject: [PATCH 1/7] Report 2D speed rather than 3D speed. According to Android API standard, it should be only the horizontal speed. Therefore, the speed should be reported in 2D rather than 3D. Change-Id: Ie42aa350637b56394869bac0af0207a5aceeede6 CRs-fixed: 745419 --- .../libloc_api-rpc-glue/src/LocApiRpc.cpp | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/LocApiRpc.cpp b/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/LocApiRpc.cpp index 87d6b7c5..dbfc2fb7 100644 --- a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/LocApiRpc.cpp +++ b/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/LocApiRpc.cpp @@ -715,12 +715,10 @@ void LocApiRpc::reportPosition(const rpc_loc_parsed_position_s_type *location_re } // Speed - if ((location_report_ptr->valid_mask & RPC_LOC_POS_VALID_SPEED_HORIZONTAL) && - (location_report_ptr->valid_mask & RPC_LOC_POS_VALID_SPEED_VERTICAL)) + if (location_report_ptr->valid_mask & RPC_LOC_POS_VALID_SPEED_HORIZONTAL) { location.gpsLocation.flags |= GPS_LOCATION_HAS_SPEED; - location.gpsLocation.speed = sqrt(location_report_ptr->speed_horizontal * location_report_ptr->speed_horizontal + - location_report_ptr->speed_vertical * location_report_ptr->speed_vertical); + location.gpsLocation.speed = location_report_ptr->speed_horizontal; } // Heading From a328080552484b592378c617d6fe28a225f649d0 Mon Sep 17 00:00:00 2001 From: Jiafei Wen Date: Fri, 26 Sep 2014 17:00:09 -0700 Subject: [PATCH 2/7] Remove Redundant Log This change removes redundant log printing, including SV info and position report. Change-Id: Ifcf827f73e6c940e3fcb93402bc7a4b22e9a9d4e CRs-fixed: 765333 --- core/LocApiBase.cpp | 24 ++++++++++++++++++++++++ loc_api/libloc_api_50001/loc_eng.cpp | 25 ++----------------------- 2 files changed, 26 insertions(+), 23 deletions(-) diff --git a/core/LocApiBase.cpp b/core/LocApiBase.cpp index 43332dcf..82bfe21e 100644 --- a/core/LocApiBase.cpp +++ b/core/LocApiBase.cpp @@ -232,6 +232,17 @@ void LocApiBase::reportPosition(UlpLocation &location, 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, @@ -246,6 +257,19 @@ void LocApiBase::reportSv(GpsSvStatus &svStatus, GpsLocationExtended &locationExtended, void* svExt) { + // print the SV info before delivering + LOC_LOGV("num sv: %d\n ephemeris mask: %dxn almanac mask: %x\n used" + " in fix mask: %x\n sv: prn snr elevation azimuth", + svStatus.num_svs, svStatus.ephemeris_mask, + svStatus.almanac_mask, svStatus.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, diff --git a/loc_api/libloc_api_50001/loc_eng.cpp b/loc_api/libloc_api_50001/loc_eng.cpp index c74299e3..ec53a7d3 100644 --- a/loc_api/libloc_api_50001/loc_eng.cpp +++ b/loc_api/libloc_api_50001/loc_eng.cpp @@ -819,16 +819,7 @@ void LocEngReportPosition::proc() const { } } void LocEngReportPosition::locallog() const { - LOC_LOGV("flags: %d\n source: %d\n latitude: %f\n longitude: %f\n " - "altitude: %f\n speed: %f\n bearing: %f\n accuracy: %f\n " - "timestamp: %lld\n rawDataSize: %d\n rawData: %p\n Session" - " status: %d\n Technology mask: %u", - mLocation.gpsLocation.flags, mLocation.position_source, - mLocation.gpsLocation.latitude, mLocation.gpsLocation.longitude, - mLocation.gpsLocation.altitude, mLocation.gpsLocation.speed, - mLocation.gpsLocation.bearing, mLocation.gpsLocation.accuracy, - mLocation.gpsLocation.timestamp, mLocation.rawDataSize, - mLocation.rawData, mStatus, mTechMask); + LOC_LOGV("LocEngReportPosition"); } void LocEngReportPosition::log() const { locallog(); @@ -869,19 +860,7 @@ void LocEngReportSv::proc() const { } } void LocEngReportSv::locallog() const { - LOC_LOGV("num sv: %d\n ephemeris mask: %dxn almanac mask: %x\n " - "used in fix mask: %x\n sv: prn snr " - "elevation azimuth", - mSvStatus.num_svs, mSvStatus.ephemeris_mask, - mSvStatus.almanac_mask, mSvStatus.used_in_fix_mask); - for (int i = 0; i < mSvStatus.num_svs && i < GPS_MAX_SVS; i++) { - LOC_LOGV(" %d: %d %f %f %f\n ", - i, - mSvStatus.sv_list[i].prn, - mSvStatus.sv_list[i].snr, - mSvStatus.sv_list[i].elevation, - mSvStatus.sv_list[i].azimuth); - } + LOC_LOGV("%s:%d] LocEngReportSv",__func__, __LINE__); } inline void LocEngReportSv::log() const { locallog(); From 7e9e68a3af03803d2e0ce792d750dd5bd8338e6c Mon Sep 17 00:00:00 2001 From: Dante Russo Date: Mon, 15 Dec 2014 17:49:40 -0800 Subject: [PATCH 3/7] support reinjecting supl url for sim hot swap modem might reset during sim hot swap, in which case the prior supl url shall be remembered so that can be reinjected. This change enables it. CRs-fixed: 771493 Change-Id: I86ec898a54bc8706720c29a1ea67ce27153ee981 --- loc_api/libloc_api_50001/loc_eng.cpp | 40 ++++++++++++++-------------- 1 file changed, 20 insertions(+), 20 deletions(-) diff --git a/loc_api/libloc_api_50001/loc_eng.cpp b/loc_api/libloc_api_50001/loc_eng.cpp index 1b301060..6919aab4 100644 --- a/loc_api/libloc_api_50001/loc_eng.cpp +++ b/loc_api/libloc_api_50001/loc_eng.cpp @@ -2523,29 +2523,29 @@ int loc_eng_set_server_proxy(loc_eng_data_s_type &loc_eng_data, ENTRY_LOG_CALLFLOW(); int ret_val = 0; + LOC_LOGV("save the address, type: %d, hostname: %s, port: %d", + (int) type, hostname, port); + switch (type) + { + case LOC_AGPS_SUPL_SERVER: + strlcpy(loc_eng_data.supl_host_buf, hostname, + sizeof(loc_eng_data.supl_host_buf)); + loc_eng_data.supl_port_buf = port; + loc_eng_data.supl_host_set = 1; + break; + case LOC_AGPS_CDMA_PDE_SERVER: + strlcpy(loc_eng_data.c2k_host_buf, hostname, + sizeof(loc_eng_data.c2k_host_buf)); + loc_eng_data.c2k_port_buf = port; + loc_eng_data.c2k_host_set = 1; + break; + default: + LOC_LOGE("loc_eng_set_server_proxy, unknown server type = %d", (int) type); + } + if (NULL != loc_eng_data.adapter) { ret_val = loc_eng_set_server(loc_eng_data, type, hostname, port); - } else { - LOC_LOGW("set_server called before init. save the address, type: %d, hostname: %s, port: %d", - (int) type, hostname, port); - switch (type) - { - case LOC_AGPS_SUPL_SERVER: - strlcpy(loc_eng_data.supl_host_buf, hostname, - sizeof(loc_eng_data.supl_host_buf)); - loc_eng_data.supl_port_buf = port; - loc_eng_data.supl_host_set = 1; - break; - case LOC_AGPS_CDMA_PDE_SERVER: - strlcpy(loc_eng_data.c2k_host_buf, hostname, - sizeof(loc_eng_data.c2k_host_buf)); - loc_eng_data.c2k_port_buf = port; - loc_eng_data.c2k_host_set = 1; - break; - default: - LOC_LOGE("loc_eng_set_server_proxy, unknown server type = %d", (int) type); - } } EXIT_LOG(%d, ret_val); From f014665a5299f281695c8d098f7444afbf623057 Mon Sep 17 00:00:00 2001 From: Kevin Tang Date: Mon, 15 Dec 2014 10:51:42 -0800 Subject: [PATCH 4/7] Enable "auto" target for APQ8960 Automotive ADP platform APQ8960 Automotive platforms use "auto" as a target name for ro.baseband property. Appropriate GPS driver changes were, 1. define GNSS_AUTO enum constant 2. Enable GNSS drivers for "auto" target. Change-Id: I463db7ac1c3e2dd6101e457ad723bb16adf5aacb CRs-Fixed: 771597 --- loc_api/libloc_api_50001/loc.cpp | 1 + utils/loc_log.cpp | 1 + utils/loc_target.cpp | 6 ++++++ utils/loc_target.h | 2 ++ 4 files changed, 10 insertions(+) diff --git a/loc_api/libloc_api_50001/loc.cpp b/loc_api/libloc_api_50001/loc.cpp index 2bcfc7b0..158176f5 100644 --- a/loc_api/libloc_api_50001/loc.cpp +++ b/loc_api/libloc_api_50001/loc.cpp @@ -247,6 +247,7 @@ extern "C" const GpsInterface* get_gps_interface() switch (gnssType) { case GNSS_GSS: + case GNSS_AUTO: //APQ8064 gps_conf.CAPABILITIES &= ~(GPS_CAPABILITY_MSA | GPS_CAPABILITY_MSB); gss_fd = open("/dev/gss", O_RDONLY); diff --git a/utils/loc_log.cpp b/utils/loc_log.cpp index 392966ee..18182b74 100644 --- a/utils/loc_log.cpp +++ b/utils/loc_log.cpp @@ -113,6 +113,7 @@ loc_name_val_s_type target_name[] = NAME_VAL(GNSS_GSS), NAME_VAL(GNSS_MDM), NAME_VAL(GNSS_QCA1530), + NAME_VAL(GNSS_AUTO), NAME_VAL(GNSS_UNKNOWN) }; diff --git a/utils/loc_target.cpp b/utils/loc_target.cpp index 8dbe885e..080e5768 100644 --- a/utils/loc_target.cpp +++ b/utils/loc_target.cpp @@ -53,6 +53,7 @@ #define STR_SURF "Surf" #define STR_MTP "MTP" #define STR_APQ "apq" +#define STR_AUTO "auto" #define IS_STR_END(c) ((c) == '\0' || (c) == '\n' || (c) == '\r') #define LENGTH(s) (sizeof(s) - 1) #define GPS_CHECK_NO_ERROR 0 @@ -207,6 +208,11 @@ unsigned int loc_get_target(void) } else { read_a_line(id_dep, rd_id, LINE_LEN); } + if( !memcmp(baseband, STR_AUTO, LENGTH(STR_AUTO)) ) + { + gTarget = TARGET_AUTO; + goto detected; + } if( !memcmp(rd_hw_platform, STR_MTP, LENGTH(STR_MTP)) ){ if( !memcmp(rd_id, PDS_ID_1, LENGTH(PDS_ID_1)) && IS_STR_END(rd_id[LENGTH(PDS_ID_1)]) ) diff --git a/utils/loc_target.h b/utils/loc_target.h index 208a34cb..d7364e91 100644 --- a/utils/loc_target.h +++ b/utils/loc_target.h @@ -36,6 +36,7 @@ #define TARGET_MSM_NO_SSC TARGET_SET(GNSS_MSM, NO_SSC) #define TARGET_QCA1530 TARGET_SET(GNSS_QCA1530, NO_SSC) #define TARGET_PDS TARGET_SET(GNSS_PDS, NO_SSC) +#define TARGET_AUTO TARGET_SET(GNSS_AUTO, NO_SSC) #define TARGET_UNKNOWN TARGET_SET(GNSS_UNKNOWN, NO_SSC) #define getTargetGnssType(target) (target>>1) @@ -62,6 +63,7 @@ typedef enum { GNSS_MDM, GNSS_QCA1530, GNSS_PDS, + GNSS_AUTO, GNSS_UNKNOWN }GNSS_TARGET; From f311c16b0a3fde00ff4648070ce9064dfaa3b32f Mon Sep 17 00:00:00 2001 From: Kevin Tang Date: Fri, 12 Dec 2014 15:49:26 -0800 Subject: [PATCH 5/7] gps.conf parameters are in sap.conf table due to merge issue, some of the parameters to come out from gps.conf are placed in the table that expects from sap.conf. Moving them into the right place. Change-Id: Ice988b06d0d87bdbc0225296898d6aaad701743f CRs-Fixed: 760152 --- loc_api/libloc_api_50001/loc_eng.cpp | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-) diff --git a/loc_api/libloc_api_50001/loc_eng.cpp b/loc_api/libloc_api_50001/loc_eng.cpp index c0d33046..18ffc5ef 100644 --- a/loc_api/libloc_api_50001/loc_eng.cpp +++ b/loc_api/libloc_api_50001/loc_eng.cpp @@ -106,6 +106,10 @@ static loc_param_s_type gps_conf_table[] = {"ACCURACY_THRES", &gps_conf.ACCURACY_THRES, NULL, 'n'}, {"NMEA_PROVIDER", &gps_conf.NMEA_PROVIDER, NULL, 'n'}, {"CAPABILITIES", &gps_conf.CAPABILITIES, NULL, 'n'}, + {"XTRA_VERSION_CHECK", &gps_conf.XTRA_VERSION_CHECK, NULL, 'n'}, + {"XTRA_SERVER_1", &gps_conf.XTRA_SERVER_1, NULL, 's'}, + {"XTRA_SERVER_2", &gps_conf.XTRA_SERVER_2, NULL, 's'}, + {"XTRA_SERVER_3", &gps_conf.XTRA_SERVER_3, NULL, 's'}, {"USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL", &gps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL, NULL, 'n'}, }; @@ -127,12 +131,7 @@ static loc_param_s_type sap_conf_table[] = {"SENSOR_CONTROL_MODE", &sap_conf.SENSOR_CONTROL_MODE, NULL, 'n'}, {"SENSOR_USAGE", &sap_conf.SENSOR_USAGE, NULL, 'n'}, {"SENSOR_ALGORITHM_CONFIG_MASK", &sap_conf.SENSOR_ALGORITHM_CONFIG_MASK, NULL, 'n'}, - {"SENSOR_PROVIDER", &sap_conf.SENSOR_PROVIDER, NULL, 'n'}, - {"XTRA_VERSION_CHECK", &gps_conf.XTRA_VERSION_CHECK, NULL, 'n'}, - {"XTRA_SERVER_1", &gps_conf.XTRA_SERVER_1, NULL, 's'}, - {"XTRA_SERVER_2", &gps_conf.XTRA_SERVER_2, NULL, 's'}, - {"XTRA_SERVER_3", &gps_conf.XTRA_SERVER_3, NULL, 's'}, - {"AGPS_CERT_WRITABLE_MASK", &gps_conf.AGPS_CERT_WRITABLE_MASK, NULL, 'n'} + {"SENSOR_PROVIDER", &sap_conf.SENSOR_PROVIDER, NULL, 'n'} }; static void loc_default_parameters(void) From 98e1f83ff46ec7d2a417719bbaf2a91424954896 Mon Sep 17 00:00:00 2001 From: Ruifeng Xu Date: Mon, 25 Aug 2014 15:39:02 -0700 Subject: [PATCH 6/7] Added new events and masks for GDT AP These events and masks are for bulk data transfer between AP and MP. CRs-fixed:766059 Change-Id: Id795316a9b114d6984969ad9eadb8d2c66b1743b --- core/gps_extended_c.h | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/core/gps_extended_c.h b/core/gps_extended_c.h index 5140a6c6..acf92b36 100644 --- a/core/gps_extended_c.h +++ b/core/gps_extended_c.h @@ -345,6 +345,8 @@ enum loc_api_adapter_event_index { 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_EVENT_MAX }; @@ -371,6 +373,8 @@ enum loc_api_adapter_event_index { #define LOC_API_ADAPTER_BIT_REQUEST_WIFI_AP_DATA (1< Date: Mon, 15 Dec 2014 17:47:50 -0800 Subject: [PATCH 7/7] GNSS measurement Implementation of GNSS Measurements support. In GPS HAL, Only GPS Measurements report will be collected from modem. CRs-fixed: 771496 Change-Id: Ief4368099df4ff573ad1a764f4156d63685e936d --- core/LocAdapterBase.cpp | 4 + core/LocAdapterBase.h | 1 + core/LocApiBase.cpp | 16 ++ core/LocApiBase.h | 12 ++ core/LocDualContext.cpp | 3 +- core/gps_extended_c.h | 2 + loc_api/libloc_api_50001/LocEngAdapter.cpp | 33 +++ loc_api/libloc_api_50001/LocEngAdapter.h | 11 + loc_api/libloc_api_50001/loc.cpp | 65 ++++++ loc_api/libloc_api_50001/loc_eng.cpp | 225 +++++++++++++++++++-- loc_api/libloc_api_50001/loc_eng.h | 4 + loc_api/libloc_api_50001/loc_eng_msg.h | 10 + 12 files changed, 370 insertions(+), 16 deletions(-) diff --git a/core/LocAdapterBase.cpp b/core/LocAdapterBase.cpp index eea8eddf..23184dff 100644 --- a/core/LocAdapterBase.cpp +++ b/core/LocAdapterBase.cpp @@ -132,4 +132,8 @@ DEFAULT_IMPL(false) void LocAdapterBase:: shutdown() DEFAULT_IMPL() + +void LocAdapterBase:: + reportGpsMeasurementData(GpsData &gpsMeasurementData) +DEFAULT_IMPL() } // namespace loc_core diff --git a/core/LocAdapterBase.h b/core/LocAdapterBase.h index 2fec3128..9d5f6a81 100644 --- a/core/LocAdapterBase.h +++ b/core/LocAdapterBase.h @@ -112,6 +112,7 @@ public: inline virtual bool isInSession() { return false; } virtual void shutdown(); ContextBase* getContext() const { return mContext; } + virtual void reportGpsMeasurementData(GpsData &gpsMeasurementData); }; } // namespace loc_core diff --git a/core/LocApiBase.cpp b/core/LocApiBase.cpp index 82bfe21e..f56694e7 100644 --- a/core/LocApiBase.cpp +++ b/core/LocApiBase.cpp @@ -363,6 +363,12 @@ void* LocApiBase :: getSibling() 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) @@ -526,4 +532,14 @@ 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/core/LocApiBase.h b/core/LocApiBase.h index f68cf739..414769b5 100644 --- a/core/LocApiBase.h +++ b/core/LocApiBase.h @@ -130,6 +130,7 @@ public: 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: @@ -237,7 +238,18 @@ public: -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, diff --git a/core/LocDualContext.cpp b/core/LocDualContext.cpp index ab151109..41ad4f0a 100644 --- a/core/LocDualContext.cpp +++ b/core/LocDualContext.cpp @@ -50,7 +50,8 @@ LocDualContext::mBgExclMask = 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_GEOFENCE_GEN_ALERT | + LOC_API_ADAPTER_BIT_GNSS_MEASUREMENT); const MsgTask* LocDualContext::mMsgTask = NULL; ContextBase* LocDualContext::mFgContext = NULL; diff --git a/core/gps_extended_c.h b/core/gps_extended_c.h index acf92b36..8a4e340f 100644 --- a/core/gps_extended_c.h +++ b/core/gps_extended_c.h @@ -347,6 +347,7 @@ enum loc_api_adapter_event_index { 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_EVENT_MAX }; @@ -375,6 +376,7 @@ enum loc_api_adapter_event_index { #define LOC_API_ADAPTER_BIT_BATCHED_POSITION_REPORT (1<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/loc_api/libloc_api_50001/LocEngAdapter.h b/loc_api/libloc_api_50001/LocEngAdapter.h index b857d198..e5d10184 100644 --- a/loc_api/libloc_api_50001/LocEngAdapter.h +++ b/loc_api/libloc_api_50001/LocEngAdapter.h @@ -284,6 +284,7 @@ public: virtual bool requestSuplES(int connHandle); virtual bool reportDataCallOpened(); virtual bool reportDataCallClosed(); + virtual void reportGpsMeasurementData(GpsData &gpsMeasurementData); inline const LocPosMode& getPositionMode() const {return mFixCriteria;} @@ -334,6 +335,16 @@ public: 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/loc_api/libloc_api_50001/loc.cpp b/loc_api/libloc_api_50001/loc.cpp index 158176f5..4cf4ba95 100644 --- a/loc_api/libloc_api_50001/loc.cpp +++ b/loc_api/libloc_api_50001/loc.cpp @@ -150,6 +150,17 @@ typedef struct { static s_loc_mdm_info loc_mdm_info; static void loc_pm_event_notifier(void *client_data, enum pm_event event); #endif /*MODEM_POWER_VOTE*/ +// For shutting down MDM in fusion devices +static int mdm_fd = -1; +static int loc_gps_measurement_init(GpsMeasurementCallbacks* callbacks); +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); @@ -776,6 +787,10 @@ const void* loc_get_extension(const char* name) { ret_val = &sLocEngConfigInterface; } + else if (strcmp(name, GPS_MEASUREMENT_INTERFACE) == 0) + { + ret_val = &sLocEngGpsMeasurementInterface; + } else { LOC_LOGE ("get_extension: Invalid interface passed in\n"); @@ -983,6 +998,56 @@ static int loc_xtra_inject_data(char* data, int length) return ret_val; } +/*=========================================================================== +FUNCTION loc_gps_measurement_init + +DESCRIPTION + This function initializes the gps measurement interface + +DEPENDENCIES + NONE + +RETURN VALUE + None + +SIDE EFFECTS + N/A + +===========================================================================*/ +static int loc_gps_measurement_init(GpsMeasurementCallbacks* callbacks) +{ + ENTRY_LOG(); + int ret_val = loc_eng_gps_measurement_init(loc_afw_data, + callbacks); + + EXIT_LOG(%d, ret_val); + return ret_val; +} + +/*=========================================================================== +FUNCTION loc_gps_measurement_close + +DESCRIPTION + This function closes the gps measurement interface + +DEPENDENCIES + NONE + +RETURN VALUE + None + +SIDE EFFECTS + N/A + +===========================================================================*/ +static void loc_gps_measurement_close() +{ + ENTRY_LOG(); + loc_eng_gps_measurement_close(loc_afw_data); + + EXIT_LOG(%s, VOID_RET); +} + /*=========================================================================== FUNCTION loc_ni_init diff --git a/loc_api/libloc_api_50001/loc_eng.cpp b/loc_api/libloc_api_50001/loc_eng.cpp index 18ffc5ef..448cc793 100644 --- a/loc_api/libloc_api_50001/loc_eng.cpp +++ b/loc_api/libloc_api_50001/loc_eng.cpp @@ -1372,6 +1372,33 @@ struct LocEngEnableData : public LocMsg { // case LOC_ENG_MSG_INJECT_XTRA_DATA: // loc_eng_xtra.cpp +// case LOC_ENG_MSG_SET_CAPABILITIES: +struct LocEngSetCapabilities : public LocMsg { + loc_eng_data_s_type* mLocEng; + inline LocEngSetCapabilities(loc_eng_data_s_type* locEng) : + LocMsg(), mLocEng(locEng) + { + locallog(); + } + inline virtual void proc() const { + if (NULL != mLocEng->set_capabilities_cb) { + LOC_LOGV("calling set_capabilities_cb 0x%x", + gps_conf.CAPABILITIES); + mLocEng->set_capabilities_cb(gps_conf.CAPABILITIES); + } else { + LOC_LOGV("set_capabilities_cb is NULL.\n"); + } + } + inline void locallog() const + { + LOC_LOGV("LocEngSetCapabilities"); + } + inline virtual void log() const + { + locallog(); + } +}; + // case LOC_ENG_MSG_LOC_INIT: struct LocEngInit : public LocMsg { loc_eng_data_s_type* mLocEng; @@ -1382,6 +1409,8 @@ struct LocEngInit : public LocMsg { } inline virtual void proc() const { loc_eng_reinit(*mLocEng); + // set the capabilities + mLocEng->adapter->sendMsg(new LocEngSetCapabilities(mLocEng)); } inline void locallog() const { @@ -1571,6 +1600,99 @@ struct LocEngInstallAGpsCert : public LocMsg { } }; +struct LocEngUpdateRegistrationMask : public LocMsg { + loc_eng_data_s_type* mLocEng; + LOC_API_ADAPTER_EVENT_MASK_T mMask; + loc_registration_mask_status mIsEnabled; + inline LocEngUpdateRegistrationMask(loc_eng_data_s_type* locEng, + LOC_API_ADAPTER_EVENT_MASK_T mask, + loc_registration_mask_status isEnabled) : + LocMsg(), mLocEng(locEng), mMask(mask), mIsEnabled(isEnabled) { + locallog(); + } + inline virtual void proc() const { + loc_eng_data_s_type *locEng = (loc_eng_data_s_type *)mLocEng; + locEng->adapter->updateRegistrationMask(mMask, + mIsEnabled); + } + void locallog() const { + LOC_LOGV("LocEngUpdateRegistrationMask\n"); + } + virtual void log() const { + locallog(); + } +}; + +struct LocEngGnssConstellationConfig : public LocMsg { + LocEngAdapter* mAdapter; + inline LocEngGnssConstellationConfig(LocEngAdapter* adapter) : + LocMsg(), mAdapter(adapter) { + locallog(); + } + inline virtual void proc() const { + if (mAdapter->gnssConstellationConfig()) { + LOC_LOGV("Modem supports GNSS measurements\n"); + gps_conf.CAPABILITIES |= GPS_CAPABILITY_MEASUREMENTS; + } else { + LOC_LOGV("Modem does not support GNSS measurements\n"); + } + } + void locallog() const { + LOC_LOGV("LocEngGnssConstellationConfig\n"); + } + virtual void log() const { + locallog(); + } +}; + +// case LOC_ENG_MSG_REPORT_GNSS_MEASUREMENT: +LocEngReportGpsMeasurement::LocEngReportGpsMeasurement(void* locEng, + GpsData &gpsData) : + LocMsg(), mLocEng(locEng), mGpsData(gpsData) +{ + locallog(); +} +void LocEngReportGpsMeasurement::proc() const { + loc_eng_data_s_type* locEng = (loc_eng_data_s_type*) mLocEng; + if (locEng->mute_session_state != LOC_MUTE_SESS_IN_SESSION) + { + if (locEng->gps_measurement_cb != NULL) { + locEng->gps_measurement_cb((GpsData*)&(mGpsData)); + } + } +} +void LocEngReportGpsMeasurement::locallog() const { + IF_LOC_LOGV { + LOC_LOGV("%s:%d]: Received in GPS HAL." + "GNSS Measurements count: %d \n", + __func__, __LINE__, mGpsData.measurement_count); + for (int i =0; i< mGpsData.measurement_count && i < GPS_MAX_SVS; i++) { + LOC_LOGV(" GNSS measurement data in GPS HAL: \n" + " GPS_HAL => Measurement ID | prn | time_offset_ns | state |" + " received_gps_tow_ns| c_n0_dbhz | pseudorange_rate_mps |" + " pseudorange_rate_uncertainty_mps |" + " accumulated_delta_range_state | flags \n" + " GPS_HAL => %d | %d | %f | %d | %lld | %f | %f | %f | %d | %d \n", + i, + mGpsData.measurements[i].prn, + mGpsData.measurements[i].time_offset_ns, + mGpsData.measurements[i].state, + mGpsData.measurements[i].received_gps_tow_ns, + mGpsData.measurements[i].c_n0_dbhz, + mGpsData.measurements[i].pseudorange_rate_mps, + mGpsData.measurements[i].pseudorange_rate_uncertainty_mps, + mGpsData.measurements[i].accumulated_delta_range_state, + mGpsData.measurements[i].flags); + } + LOC_LOGV(" GPS_HAL => Clocks Info: type | time_ns \n" + " GPS_HAL => Clocks Info: %d | %lld", mGpsData.clock.type, + mGpsData.clock.time_ns); + } +} +inline void LocEngReportGpsMeasurement::log() const { + locallog(); +} + /********************************************************************* * Initialization checking macros *********************************************************************/ @@ -1638,10 +1760,6 @@ int loc_eng_init(loc_eng_data_s_type &loc_eng_data, LocCallbacks* callbacks, memset(&loc_eng_data, 0, sizeof (loc_eng_data)); - if (NULL != callbacks->set_capabilities_cb) { - callbacks->set_capabilities_cb(gps_conf.CAPABILITIES); - } - // Save callbacks loc_eng_data.location_cb = callbacks->location_cb; loc_eng_data.sv_status_cb = callbacks->sv_status_cb; @@ -1690,6 +1808,7 @@ static int loc_eng_reinit(loc_eng_data_s_type &loc_eng_data) int ret_val = LOC_API_ADAPTER_ERR_SUCCESS; LocEngAdapter* adapter = loc_eng_data.adapter; + adapter->sendMsg(new LocEngGnssConstellationConfig(adapter)); adapter->sendMsg(new LocEngSuplVer(adapter, gps_conf.SUPL_VER)); adapter->sendMsg(new LocEngLppConfig(adapter, gps_conf.LPP_PROFILE)); adapter->sendMsg(new LocEngSensorControlConfig(adapter, sap_conf.SENSOR_USAGE, @@ -2626,33 +2745,32 @@ void loc_eng_configuration_update (loc_eng_data_s_type &loc_eng_data, ENTRY_LOG_CALLFLOW(); if (config_data && length > 0) { - loc_gps_cfg_s_type gps_conf_old = gps_conf; + loc_gps_cfg_s_type gps_conf_tmp = gps_conf; UTIL_UPDATE_CONF(config_data, length, gps_conf_table); LocEngAdapter* adapter = loc_eng_data.adapter; // it is possible that HAL is not init'ed at this time if (adapter) { - if (gps_conf_old.SUPL_VER != gps_conf.SUPL_VER) { + if (gps_conf_tmp.SUPL_VER != gps_conf.SUPL_VER) { adapter->sendMsg(new LocEngSuplVer(adapter, gps_conf.SUPL_VER)); } - if (gps_conf_old.LPP_PROFILE != gps_conf.LPP_PROFILE) { + if (gps_conf_tmp.LPP_PROFILE != gps_conf.LPP_PROFILE) { adapter->sendMsg(new LocEngLppConfig(adapter, gps_conf.LPP_PROFILE)); } - if (gps_conf_old.A_GLONASS_POS_PROTOCOL_SELECT != gps_conf.A_GLONASS_POS_PROTOCOL_SELECT) { + if (gps_conf_tmp.A_GLONASS_POS_PROTOCOL_SELECT != gps_conf.A_GLONASS_POS_PROTOCOL_SELECT) { adapter->sendMsg(new LocEngAGlonassProtocol(adapter, gps_conf.A_GLONASS_POS_PROTOCOL_SELECT)); } - if (gps_conf_old.SUPL_MODE != gps_conf.SUPL_MODE) { + if (gps_conf_tmp.SUPL_MODE != gps_conf.SUPL_MODE) { adapter->sendMsg(new LocEngSuplMode(adapter->getUlpProxy())); } } - gps_conf_old.SUPL_VER = gps_conf.SUPL_VER; - gps_conf_old.LPP_PROFILE = gps_conf.LPP_PROFILE; - gps_conf_old.A_GLONASS_POS_PROTOCOL_SELECT = gps_conf.A_GLONASS_POS_PROTOCOL_SELECT; - gps_conf_old.SUPL_MODE = gps_conf.SUPL_MODE; - gps_conf = gps_conf_old; - + gps_conf_tmp.SUPL_VER = gps_conf.SUPL_VER; + gps_conf_tmp.LPP_PROFILE = gps_conf.LPP_PROFILE; + gps_conf_tmp.A_GLONASS_POS_PROTOCOL_SELECT = gps_conf.A_GLONASS_POS_PROTOCOL_SELECT; + gps_conf_tmp.GPS_LOCK = gps_conf.GPS_LOCK; + gps_conf = gps_conf_tmp; } EXIT_LOG(%s, VOID_RET); @@ -2862,3 +2980,80 @@ void loc_eng_handle_shutdown(loc_eng_data_s_type &locEng) locEng.shutdown_cb(); EXIT_LOG(%d, 0); } + +/*=========================================================================== +FUNCTION loc_eng_gps_measurement_init + +DESCRIPTION + Initialize gps measurement module. + +DEPENDENCIES + N/A + +RETURN VALUE + 0: success + +SIDE EFFECTS + N/A + +===========================================================================*/ +int loc_eng_gps_measurement_init(loc_eng_data_s_type &loc_eng_data, + GpsMeasurementCallbacks* callbacks) +{ + ENTRY_LOG_CALLFLOW(); + + STATE_CHECK((NULL == loc_eng_data.gps_measurement_cb), + "gps measurement already initialized", + return GPS_MEASUREMENT_ERROR_ALREADY_INIT); + STATE_CHECK((callbacks != NULL), + "callbacks can not be NULL", + return GPS_MEASUREMENT_ERROR_GENERIC); + STATE_CHECK(loc_eng_data.adapter, + "GpsInterface must be initialized first", + return GPS_MEASUREMENT_ERROR_GENERIC); + + // updated the mask + LOC_API_ADAPTER_EVENT_MASK_T event = LOC_API_ADAPTER_BIT_GNSS_MEASUREMENT; + loc_eng_data.adapter->sendMsg(new LocEngUpdateRegistrationMask( + &loc_eng_data, + event, + LOC_REGISTRATION_MASK_ENABLED)); + // set up the callback + loc_eng_data.gps_measurement_cb = callbacks->measurement_callback; + LOC_LOGD ("%s, event masks updated successfully", __func__); + + return GPS_MEASUREMENT_OPERATION_SUCCESS; +} + +/*=========================================================================== +FUNCTION loc_eng_gps_measurement_close + +DESCRIPTION + Close gps measurement module. + +DEPENDENCIES + N/A + +RETURN VALUE + N/A + +SIDE EFFECTS + N/A + +===========================================================================*/ +void loc_eng_gps_measurement_close(loc_eng_data_s_type &loc_eng_data) +{ + ENTRY_LOG_CALLFLOW(); + + INIT_CHECK(loc_eng_data.adapter, return); + + // updated the mask + LOC_API_ADAPTER_EVENT_MASK_T event = LOC_API_ADAPTER_BIT_GNSS_MEASUREMENT; + loc_eng_data.adapter->sendMsg(new LocEngUpdateRegistrationMask( + &loc_eng_data, + event, + LOC_REGISTRATION_MASK_DISABLED)); + // set up the callback + loc_eng_data.gps_measurement_cb = NULL; + EXIT_LOG(%d, 0); +} diff --git a/loc_api/libloc_api_50001/loc_eng.h b/loc_api/libloc_api_50001/loc_eng.h index d049afae..813da482 100644 --- a/loc_api/libloc_api_50001/loc_eng.h +++ b/loc_api/libloc_api_50001/loc_eng.h @@ -94,6 +94,7 @@ typedef struct loc_eng_data_s gps_acquire_wakelock acquire_wakelock_cb; gps_release_wakelock release_wakelock_cb; gps_request_utc_time request_utc_time_cb; + gps_measurement_callback gps_measurement_cb; boolean intermediateFix; AGpsStatusValue agps_status; loc_eng_xtra_data_s_type xtra_module_data; @@ -259,6 +260,9 @@ extern void loc_eng_ni_reset_on_engine_restart(loc_eng_data_s_type &loc_eng_data void loc_eng_configuration_update (loc_eng_data_s_type &loc_eng_data, const char* config_data, int32_t length); +int loc_eng_gps_measurement_init(loc_eng_data_s_type &loc_eng_data, + GpsMeasurementCallbacks* callbacks); +void loc_eng_gps_measurement_close(loc_eng_data_s_type &loc_eng_data); #ifdef __cplusplus } diff --git a/loc_api/libloc_api_50001/loc_eng_msg.h b/loc_api/libloc_api_50001/loc_eng_msg.h index b767dc5f..e3c48fb4 100644 --- a/loc_api/libloc_api_50001/loc_eng_msg.h +++ b/loc_api/libloc_api_50001/loc_eng_msg.h @@ -289,6 +289,16 @@ struct LocEngGetZpp : public LocMsg { void send() const; }; +struct LocEngReportGpsMeasurement : public LocMsg { + void* mLocEng; + const GpsData mGpsData; + LocEngReportGpsMeasurement(void* locEng, + GpsData &gpsData); + virtual void proc() const; + void locallog() const; + virtual void log() const; +}; + struct LocEngShutdown : public LocMsg { LocEngAdapter* mAdapter; LocEngShutdown(LocEngAdapter* adapter);