Squashed 'LYNQ_PUBLIC/' content from commit 79d8f932f
git-subtree-dir: LYNQ_PUBLIC
git-subtree-split: 79d8f932fb4ebc4b5aec6c5ace97634912394272
Change-Id: If2527ba937f56fe989487bf71e996f7cfd9fbe61
diff --git a/IC_src/mtk/lib/liblynq-gnss/include/lynq_gnss.h b/IC_src/mtk/lib/liblynq-gnss/include/lynq_gnss.h
new file mode 100755
index 0000000..362baaf
--- /dev/null
+++ b/IC_src/mtk/lib/liblynq-gnss/include/lynq_gnss.h
@@ -0,0 +1,122 @@
+#ifndef LYNQ_GNSS_H
+#define LYNQ_GNSS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "gpshal.h"
+#include "hal2mnl_interface.h"
+
+typedef enum{
+ LYNQ_MODE_GPS_GLONASS = 0,
+ LYNQ_MODE_GPS_BEIDOU,
+ LYNQ_MODE_GPS_GLONASS_BEIDOU,
+ LYNQ_MODE_GPS,
+ LYNQ_MODE_BEIDOU,
+ LYNQ_MODE_GLONASS,
+ LYNQ_MODE_GPS_GLONASS_BEIDOU_GALILEO,
+ LYNQ_MODE_GPS_GALILEO,
+ LYNQ_MODE_GPS_GLONASS_GALILEO,
+ LYNQ_MODE_GPS_GALILEO_ONLY,
+ LYNQ_MODE_GPS_GLONASS_BEIDOU_GALILEO_NAVIC,
+ LYNQ_MODE_GNSS_END
+}LYNQ_GNSS_MODE_CONFIGURATION;
+
+typedef enum{
+ LYNQ_SWITCH_DISABLE = 0,
+ LYNQ_SWITCH_ENABLE
+}LYNQ_CONF_SWITCH;
+
+typedef struct {
+ GpsLocation legacyLocation;
+
+ float horizontalAccuracyMeters;
+
+ /**
+ * Represents expected vertical position accuracy in meters
+ * (68% confidence).
+ */
+ float verticalAccuracyMeters;
+
+ /**
+ * Represents expected speed accuracy in meter per seconds
+ * (68% confidence).
+ */
+ float speedAccuracyMetersPerSecond;
+
+ /**
+ * Represents expected bearing accuracy in degrees
+ * (68% confidence).
+ */
+ float bearingAccuracyDegrees;
+} lynq_GpsLocation_ext;
+
+typedef void (*gps_location_callback_ext)(lynq_GpsLocation_ext* location);
+
+// typedef void (* gps_status_callback)(GpsStatus* status);
+
+// typedef void (* gps_nmea_callback)(GpsUtcTime timestamp, const char* nmea, int length);
+
+// typedef pthread_t (* gps_create_thread)(const char* name, void (*start)(void *), void* arg);
+
+//typedef void (*gnss_measurement_ext_callback) (GnssData_ext* data);
+
+
+typedef struct
+{
+ size_t size;
+ gps_location_callback_ext lynq_location_cb;
+ gps_status_callback lynq_status_cb;
+ gps_nmea_callback lynq_nmea_cb;
+ gps_create_thread lynq_create_thread_cb;
+}lynq_gnss_cb;
+
+typedef struct
+{
+ size_t size;
+ gnss_measurement_ext_callback lynq_measurement_callback;
+}lynq_raw_gnss_cbs;
+
+typedef void ( *lynq_atsvc_incb )(const char *input,const int length);
+typedef void ( *lynq_atsvc_outcb )(char *output,int out_size,int type);
+lynq_atsvc_incb lynq_register_gnss(lynq_atsvc_outcb out_cb);
+lynq_atsvc_outcb atsvc_gnss_outcb;
+
+int lynq_gnss_init(void);
+
+int lynq_gnss_deinit(void);
+
+int lynq_gnss_callback_reg(lynq_gnss_cb* callbacks);
+
+int lynq_gnss_start(void);
+
+int lynq_gnss_stop(void);
+
+int lynq_gnss_inject_time(GpsUtcTime time, int64_t timeReference, int uncertainty);
+
+int lynq_gnss_inject_location(double latitude,double longitude,float accuracy);
+
+int lynq_gnss_delete_aiding_data(GpsAidingData flags);
+
+int lynq_gnss_inject_fused_location(double latitude,double longitude,float accuracy);
+
+int lynq_gnss_start_raw_meas_mode(lynq_raw_gnss_cbs* raw_gnss_cbs);
+
+int lynq_gnss_stop_raw_meas_mode();
+
+int lynq_gnss_set_start_mode(LYNQ_GNSS_MODE_CONFIGURATION start_mode);
+
+int lynq_gnss_epo_switch(LYNQ_CONF_SWITCH switch_op);
+
+int lynq_gnss_output_frequency_set(int frequency);
+
+int lynq_agps_set_enabled(LYNQ_CONF_SWITCH agps_status);
+
+int lynq_agps_get_enabled_status(int *status);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
\ No newline at end of file
diff --git a/IC_src/mtk/lib/liblynq-gnss/makefile b/IC_src/mtk/lib/liblynq-gnss/makefile
new file mode 100755
index 0000000..f1ca7fc
--- /dev/null
+++ b/IC_src/mtk/lib/liblynq-gnss/makefile
@@ -0,0 +1,62 @@
+SHELL = /bin/sh
+RM = rm -f
+
+
+LOCAL_CFLAGS := \
+ -Wall \
+ -g \
+ -Wall \
+ -fPIC \
+ -shared \
+ -D__COMPILE_OPTION__ \
+ -D__LINUX_OS__ \
+
+CPPFLAGS=\
+ -std=c++11 \
+
+LOCAL_PATH = .
+
+LOCAL_C_INCLUDES = \
+ -I$(LOCAL_PATH)/include \
+ -I$(ROOT)$(includedir)/gps_hal \
+ -I$(ROOT)$(includedir)/gps_hal/inc \
+ -I$(ROOT)$(includedir)/gps_hal/hardware \
+ -I$(ROOT)$(includedir)/liblog \
+
+LOCAL_LIBS := \
+ -L. \
+ -ldl \
+ -lrt \
+ -llog \
+ -lutils \
+ -lcutils \
+ -lgnsshal \
+ -lpthread \
+# -llynq-log \
+
+$(warning libs=$(LOCAL_LIBS))
+
+CXXSRC=\
+
+SOURCES = $(wildcard *.c wildcard src/*.c)
+
+EXECUTABLE = liblynq-gnss.so
+
+COBJS=$(SOURCES:.c=.o)
+$(warning test)
+all: $(EXECUTABLE)
+$(EXECUTABLE): $(COBJS)
+ $(CXX) -shared -Wl,--no-undefined $(COBJS) $(LOCAL_LIBS) $(LOCAL_CFLAGS) $(LOCAL_C_INCLUDES) -o $@
+
+%.o: %.c
+ $(warning ----->build $<)
+ $(CC) $(LOCAL_C_INCLUDES) $(LOCAL_CFLAGS) $(LOCAL_LIBS) -o $@ -c $<
+
+.PHONY: install clean
+install:
+ mkdir -p $(ROOT)$(base_libdir)/
+ install $(EXECUTABLE) $(ROOT)$(base_libdir)/
+
+clean:
+ rm -f $(EXECUTABLE) rm -rf *.o
+ find ./ -name *.o | xargs rm -rf
diff --git a/IC_src/mtk/lib/liblynq-gnss/src/lynq_agps.c b/IC_src/mtk/lib/liblynq-gnss/src/lynq_agps.c
new file mode 100644
index 0000000..b457941
--- /dev/null
+++ b/IC_src/mtk/lib/liblynq-gnss/src/lynq_agps.c
@@ -0,0 +1,510 @@
+#include <stdio.h>
+#include <sys/socket.h>
+#include <string.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <netinet/in.h>
+#include <sys/un.h>
+#include <log/log.h>
+
+
+#include "lynq_gnss.h"
+#include "lynq_agps.h"
+
+#define LOG_TAG "LYNQ_AGPS"
+
+
+// -1 means failure
+int do_socket_connect(const char* path)
+{
+ struct sockaddr_un addr;
+ int fd = socket(PF_LOCAL, SOCK_STREAM, 0);
+ if(fd < 0) {
+ RLOGD("socket() failed fd=%d\n", fd);
+ return -1;
+ }
+
+ memset(&addr, 0, sizeof(addr));
+ addr.sun_path[0] = 0;
+ memcpy(addr.sun_path + 1, path, strlen(path));
+ addr.sun_family = AF_UNIX;
+
+ if (connect(fd, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
+ RLOGD("connect failed reason=[%s] path=[%s]\n", strerror(errno), path);
+ close(fd);
+ return -1;
+ }
+
+ return fd;
+}
+
+//get
+char get_byte(char* buff, int* offset)
+{
+ char ret = buff[*offset];
+ *offset += 1;
+ return ret;
+}
+
+short get_short(char* buff, int* offset)
+{
+ short ret = 0;
+ ret |= get_byte(buff, offset) & 0xff;
+ ret |= (get_byte(buff, offset) << 8);
+ return ret;
+}
+
+int get_int(char* buff, int* offset)
+{
+ int ret = 0;
+ ret |= get_short(buff, offset) & 0xffff;
+ ret |= (get_short(buff, offset) << 16);
+ return ret;
+}
+
+int socket_connect() {
+ return do_socket_connect("agpsd2");
+}
+
+//-1 means failure
+static int safe_write(int fd, void* buf, int len)
+{
+ int n, retry = 10;
+
+ if(fd < 0 || buf == NULL || len < 0) {
+ RLOGD("safe_write fd=%d buf=%p len=%d\n", fd, buf, len);
+ return -1;
+ }
+
+ while((n = write(fd, buf, len)) != len) {
+ if(errno == EINTR) continue;
+ if(errno == EAGAIN) {
+ if(retry-- > 0) {
+ usleep(100 * 1000);
+ continue;
+ }
+ goto exit;
+ }
+ goto exit;
+ }
+ return n;
+exit:
+ RLOGD("safe_write reason=[%s]%d\n", strerror(errno), errno);
+ return -1;
+}
+
+//-1 means failure
+static int safe_read(int fd, void* buf, int len)
+{
+ int n, retry = 10;
+
+ if(fd < 0 || buf == NULL || len < 0)
+ {
+ RLOGD("safe_read fd=%d buf=%p len=%d\n", fd, buf, len);
+ return -1;
+ }
+
+ if(len == 0)
+ {
+ return 0;
+ }
+
+ while((n = read(fd, buf, len)) < 0)
+ {
+ if(errno == EINTR)
+ {
+ RLOGD("safe read interrupt");
+ continue;
+ }
+ if(errno == EAGAIN)
+ {
+ if(retry-- > 0)
+ {
+ usleep(100 * 1000);
+ continue;
+ }
+ goto exit;
+ }
+ goto exit;
+ }
+ return n;
+
+exit:
+ if(errno != EAGAIN)
+ {
+ RLOGD("safe_read reason=[%s] fd=%d len=%d buf=%p\n",
+ strerror(errno), fd, len, buf);
+ }
+ return -1;
+}
+
+static char socket_get_byte(int fd)
+{
+ int read_len = 0;
+ char buff[1] = {0};
+ int offset = 0;
+
+ read_len = safe_read(fd, buff, sizeof(buff));
+ if(read_len != sizeof(buff))
+ {
+ RLOGD("socket_get_byte read_len=%d\n", read_len);
+ }
+ return get_byte(buff, &offset);
+}
+
+static int socket_get_int(int fd)
+{
+ int read_len = 0;
+ char buff[4] = {0};
+ int offset = 0;
+
+ read_len = safe_read(fd, buff, sizeof(buff));
+ if(read_len != sizeof(buff))
+ {
+ RLOGD("socket_get_int read_len=%d\n", read_len);
+ }
+ return get_int(buff, &offset);
+}
+
+static char* socket_get_string(int fd, char* buff, int buff_len)
+{
+ int read_len = 0;
+
+ char ret = socket_get_byte(fd);
+ if(ret == 0)
+ {
+ return NULL;
+ }
+ else
+ {
+ int len = socket_get_int(fd);
+ if(len > buff_len)
+ {
+ RLOGD("socket_get_string your buff len=%d is too small, need len=%d\n",
+ buff_len, len);
+ return NULL;
+ }
+
+ read_len = safe_read(fd, buff, len);
+ if(read_len != len)
+ {
+ RLOGD("socket_get_string read_len=%d len=%d\n", read_len, len);
+ return NULL;
+ }
+
+ return buff;
+ }
+}
+
+
+static int socket_get_binary(int fd, char* buff)
+{
+ int read_len = 0;
+
+ int len = socket_get_int(fd);
+ if(len > 0)
+ {
+ read_len = safe_read(fd, buff, len);
+ if(read_len != len)
+ {
+ RLOGD("socket_get_binary read_len=%d len=%d\n", read_len, len);
+ return 0;
+ }
+ }
+ return len;
+}
+
+void put_byte(char* buff, int* offset, const char input)
+{
+ *((char*)&buff[*offset]) = input;
+ *offset += 1;
+}
+
+void put_short(char* buff, int* offset, const short input)
+{
+ put_byte(buff, offset, input & 0xff);
+ put_byte(buff, offset, (input >> 8) & 0xff);
+}
+
+void put_int(char* buff, int* offset, const int input)
+{
+ put_short(buff, offset, input & 0xffff);
+ put_short(buff, offset, (input >> 16) & 0xffff);
+}
+
+int set_template_1(app_mgr_cmd_enum cmd,char data)
+{
+ char buff[MAX_BUFF_SIZE] = {0};
+ int offset = 0;
+ int fd = 0;
+
+ fd = socket_connect();
+ if(fd < 0)
+ {
+ RLOGD("Socket connect fail");
+ return -1;
+ }
+ RLOGD("Set template start fd:%d cmd:%d data:%d",fd,cmd,data);
+ // write
+ put_int(buff, &offset, cmd);
+ put_byte(buff, &offset, data);
+ if(safe_write(fd, buff, offset) == -1)
+ {
+ RLOGD("set_template_1 Safe write fail");
+ close(fd);
+ return -1;
+ }
+
+ // read ACK
+ socket_get_byte(fd);
+
+ close(fd);
+ return 0;
+}
+
+int get_template_agps_config(app_mgr_cmd_enum cmd,agps_intf_agps_config *config)
+{
+ char buff[MAX_BUFF_SIZE] = {0};
+ int offset = 0;
+ int fd = 0;
+
+ fd = socket_connect();
+ if(fd < 0)
+ {
+ RLOGD("Socket connect fail");
+ return -1;
+ }
+ RLOGD("get_template_agps_config start fd:%d cmd:%d",fd,cmd);
+
+ // write
+ put_int(buff, &offset, cmd);
+ if(safe_write(fd, buff, offset) == -1)
+ {
+ RLOGD("get_template_agps_config Safe write fail");
+ close(fd);
+ return -1;
+ }
+
+ // read
+ config->agps_setting.agps_enable = socket_get_byte(fd);
+ config->agps_setting.agps_protocol = socket_get_int(fd);
+ config->agps_setting.gpevt = socket_get_byte(fd);
+
+ config->cp_setting.molr_pos_method = socket_get_int(fd);
+ config->cp_setting.external_addr_enable = socket_get_byte(fd);
+ socket_get_string(fd, config->cp_setting.external_addr, sizeof(config->cp_setting.external_addr));
+ config->cp_setting.mlc_number_enable = socket_get_byte(fd);
+ socket_get_string(fd, config->cp_setting.mlc_number, sizeof(config->cp_setting.mlc_number));
+ config->cp_setting.cp_auto_reset = socket_get_byte(fd);
+ config->cp_setting.epc_molr_lpp_payload_enable = socket_get_byte(fd);
+ config->cp_setting.epc_molr_lpp_payload_len =
+ socket_get_binary(fd, config->cp_setting.epc_molr_lpp_payload);
+
+ config->up_setting.ca_enable = socket_get_byte(fd);
+ config->up_setting.ni_request = socket_get_byte(fd);
+ config->up_setting.roaming = socket_get_byte(fd);
+ config->up_setting.cdma_preferred = socket_get_int(fd);
+ config->up_setting.pref_method = socket_get_int(fd);
+ config->up_setting.supl_version = socket_get_int(fd);
+ config->up_setting.tls_version = socket_get_int(fd);
+ config->up_setting.supl_log = socket_get_byte(fd);
+ config->up_setting.msa_enable = socket_get_byte(fd);
+ config->up_setting.msb_enable = socket_get_byte(fd);
+ config->up_setting.ecid_enable = socket_get_byte(fd);
+ config->up_setting.otdoa_enable = socket_get_byte(fd);
+ config->up_setting.qop_hacc = socket_get_int(fd);
+ config->up_setting.qop_vacc = socket_get_int(fd);
+ config->up_setting.qop_loc_age = socket_get_int(fd);
+ config->up_setting.qop_delay = socket_get_int(fd);
+ config->up_setting.lpp_enable = socket_get_byte(fd);
+ config->up_setting.cert_from_sdcard = socket_get_byte(fd);
+ if(cmd >= APP_MGR_CMD_GET_CONFIG_V14)
+ {
+ config->up_setting.auto_profile_enable = socket_get_byte(fd);
+ config->up_setting.ut2 = socket_get_byte(fd);
+ config->up_setting.ut3 = socket_get_byte(fd);
+ config->up_setting.apn_enable = socket_get_byte(fd);
+ config->up_setting.sync_to_slp = socket_get_byte(fd);
+ config->up_setting.udp_enable = socket_get_byte(fd);
+ config->up_setting.autonomous_enable = socket_get_byte(fd);
+ config->up_setting.aflt_enable = socket_get_byte(fd);
+ config->up_setting.imsi_enable = socket_get_byte(fd);
+
+ config->gnss_setting.sib8_sib16_enable = socket_get_byte(fd);
+ config->gnss_setting.gps_satellite_enable = socket_get_byte(fd);
+ config->gnss_setting.glonass_satellite_enable = socket_get_byte(fd);
+ config->gnss_setting.beidou_satellite_enable = socket_get_byte(fd);
+ config->gnss_setting.galileo_satellite_enable = socket_get_byte(fd);
+ config->gnss_setting.gps_satellite_support = socket_get_byte(fd);
+ config->gnss_setting.glonass_satellite_support = socket_get_byte(fd);
+ config->gnss_setting.beidou_satellite_support = socket_get_byte(fd);
+ config->gnss_setting.galileo_satellite_support = socket_get_byte(fd);
+
+ config->up_setting.supl_ver_minor = socket_get_byte(fd);
+ config->up_setting.supl_ver_ser_ind = socket_get_byte(fd);
+
+ config->gnss_setting.a_glonass_satellite_enable = socket_get_byte(fd);
+ }
+
+ socket_get_string(fd, config->cur_supl_profile.name, sizeof(config->cur_supl_profile.name));
+ socket_get_string(fd, config->cur_supl_profile.addr, sizeof(config->cur_supl_profile.addr));
+ config->cur_supl_profile.port = socket_get_int(fd);
+ config->cur_supl_profile.tls = socket_get_byte(fd);
+ socket_get_string(fd, config->cur_supl_profile.mcc_mnc, sizeof(config->cur_supl_profile.mcc_mnc));
+ socket_get_string(fd, config->cur_supl_profile.app_id, sizeof(config->cur_supl_profile.app_id));
+ socket_get_string(fd, config->cur_supl_profile.provider_id, sizeof(config->cur_supl_profile.provider_id));
+ socket_get_string(fd, config->cur_supl_profile.default_apn, sizeof(config->cur_supl_profile.default_apn));
+ socket_get_string(fd, config->cur_supl_profile.optional_apn, sizeof(config->cur_supl_profile.optional_apn));
+ socket_get_string(fd, config->cur_supl_profile.optional_apn_2, sizeof(config->cur_supl_profile.optional_apn_2));
+ socket_get_string(fd, config->cur_supl_profile.address_type, sizeof(config->cur_supl_profile.address_type));
+
+ if(cmd >= APP_MGR_CMD_GET_CONFIG_V14)
+ {
+ socket_get_string(fd, config->cdma_profile.name, sizeof(config->cdma_profile.name));
+ config->cdma_profile.mcp_enable = socket_get_byte(fd);;
+ socket_get_string(fd, config->cdma_profile.mcp_addr, sizeof(config->cdma_profile.mcp_addr));
+ config->cdma_profile.mcp_port = socket_get_int(fd);;
+ config->cdma_profile.pde_addr_valid = socket_get_byte(fd);;
+ config->cdma_profile.pde_ip_type = socket_get_int(fd);;
+ socket_get_string(fd, config->cdma_profile.pde_addr, sizeof(config->cdma_profile.pde_addr));
+ config->cdma_profile.pde_port = socket_get_int(fd);;
+ config->cdma_profile.pde_url_valid = socket_get_byte(fd);;
+ socket_get_string(fd, config->cdma_profile.pde_url_addr, sizeof(config->cdma_profile.pde_url_addr));
+ }
+
+ if(cmd >= APP_MGR_CMD_GET_CONFIG_V20)
+ {
+ //V15
+ config->agps_setting.e911_gps_icon_enable = socket_get_byte(fd);
+ //V16
+ config->agps_setting.e911_open_gps = socket_get_byte(fd);
+ //V17
+ config->gnss_setting.a_gps_satellite_enable = socket_get_byte(fd);
+ config->gnss_setting.a_beidou_satellite_enable = socket_get_byte(fd);
+ config->gnss_setting.a_galileo_satellite_enable = socket_get_byte(fd);
+ //V18
+ config->up_setting.sha_version = socket_get_int(fd);
+ config->up_setting.preferred_2g3g_cell_age = socket_get_int(fd);
+ config->up_setting.ut1 = socket_get_byte(fd);
+ config->up_setting.no_sensitive_log = socket_get_byte(fd);
+ config->up_setting.tls_reuse_enable = socket_get_byte(fd);
+ config->up_setting.imsi_cache_enable = socket_get_byte(fd);
+ config->up_setting.supl_raw_data_enable = socket_get_byte(fd);
+ config->up_setting.tc10_enable = socket_get_byte(fd);
+ config->up_setting.tc10_use_apn = socket_get_byte(fd);
+ config->up_setting.tc10_use_fw_dns = socket_get_byte(fd);
+ config->up_setting.allow_ni_for_gps_off = socket_get_byte(fd);
+ config->up_setting.force_otdoa_assist_req = socket_get_byte(fd);
+ config->cp_setting.reject_non911_nilr_enable = socket_get_byte(fd);
+ config->cp_setting.cp_2g_disable = socket_get_byte(fd);
+ config->cp_setting.cp_3g_disable = socket_get_byte(fd);
+ config->cp_setting.cp_4g_disable = socket_get_byte(fd);
+ config->agps_setting.tc10_ignore_fw_config = socket_get_byte(fd);
+ config->agps_setting.lppe_hide_wifi_bt_status = socket_get_byte(fd);
+ //V19
+ config->agps_setting.lppe_network_location_disable = socket_get_byte(fd);
+ config->cp_setting.cp_lppe_enable = socket_get_byte(fd);
+ config->up_setting.up_lppe_enable = socket_get_byte(fd);
+ //V20
+ config->cp_setting.support_cp_lppe = socket_get_byte(fd);
+ config->gnss_setting.mnl_support_lppe = socket_get_byte(fd);
+ }
+
+ if(cmd >= APP_MGR_CMD_GET_CONFIG_V21)
+ {
+ config->agps_setting.agps_nvram_enable = socket_get_byte(fd);
+ config->agps_setting.lbs_log_enable = socket_get_byte(fd);
+ config->agps_setting.lppe_crowd_source_confident = socket_get_int(fd);
+
+ config->up_setting.esupl_apn_mode = socket_get_int(fd);
+ config->up_setting.tcp_keepalive = socket_get_int(fd);
+ config->up_setting.aosp_profile_enable = socket_get_byte(fd);
+ config->up_setting.bind_nlp_setting_to_supl = socket_get_byte(fd);
+ }
+
+ if(cmd >= APP_MGR_CMD_GET_CONFIG_V22)
+ {
+ config->agps_setting.ignore_si_for_e911 = socket_get_byte(fd);
+ config->cp_setting.cp_lppe_wlan_enable = socket_get_byte(fd);
+ config->cp_setting.cp_lppe_srn_enable = socket_get_byte(fd);
+ config->cp_setting.cp_lppe_sensor_enable = socket_get_byte(fd);
+ config->cp_setting.cp_lppe_dbh_enable = socket_get_byte(fd);
+
+ config->up_setting.up_lppe_wlan_enable = socket_get_byte(fd);
+ config->up_setting.up_lppe_srn_enable = socket_get_byte(fd);
+ config->up_setting.up_lppe_sensor_enable = socket_get_byte(fd);
+ config->up_setting.up_lppe_dbh_enable = socket_get_byte(fd);
+ config->up_setting.ip_version_prefer = socket_get_int(fd);
+ config->up_setting.up_lppe_in_2g3g_disable = socket_get_byte(fd);
+ config->up_setting.up_rrlp_in_4g_disable = socket_get_byte(fd);
+ config->up_setting.up_si_disable = socket_get_byte(fd);
+ }
+
+ if(cmd >= APP_MGR_CMD_GET_CONFIG_V23)
+ {
+ config->up_setting.use_ni_slp = socket_get_byte(fd);
+ config->agps_setting.use_tc10_config = socket_get_byte(fd);
+ config->agps_setting.lppe_def_nlp_enable = socket_get_byte(fd);
+ }
+
+ if(cmd >= APP_MGR_CMD_GET_CONFIG_V24)
+ {
+ config->agps_setting.emergency_ext_secs = socket_get_int(fd);
+ config->up_setting.aosp_pos_mode_enable = socket_get_byte(fd);
+ config->up_setting.privacy_override_mode = socket_get_int(fd);
+ }
+
+ config->valid = 1;
+ // read ACK
+ socket_get_byte(fd);
+ RLOGD("Socket read ACK sucess, close fd");
+ close(fd);
+ return 0;
+}
+
+int agps_get_total_status(agps_intf_agps_config *config)
+{
+ if (NULL == config)
+ {
+ RLOGD("agps_get_total_status incoming paramter error");
+ }
+ int res = 0;
+ res = get_template_agps_config(APP_MGR_CMD_GET_CONFIG_V24,config);
+ return res;
+}
+
+
+int lynq_agps_set_enabled(LYNQ_CONF_SWITCH agps_status)
+{
+ int ret = -1;
+ RLOGD("[LYNQ_GNSS]set agps:%d",agps_status);
+ ret = set_template_1(APP_MGR_CMD_SET_AGPS_ENABLE,agps_status);
+ if (ret != 0)
+ {
+ RLOGD("set AGPS error ret = %d",ret);
+ return ret;
+ }
+ return ret;
+}
+
+int lynq_agps_get_enabled_status(int *status)
+{
+ int ret = 0;
+ if (NULL == status)
+ {
+ RLOGD("incoming paramter error");
+ return -1;
+ }
+
+ agps_intf_agps_config config;
+ memset(&config, 0, sizeof(config));
+ ret = agps_get_total_status(&config);
+ if (ret != 0)
+ {
+ RLOGD("agps get status fail");
+ return ret;
+ }
+ *status = config.agps_setting.agps_enable;
+ RLOGD("[LYNQ_GNSS]agps status:%d",*status);
+ return ret;
+}
\ No newline at end of file
diff --git a/IC_src/mtk/lib/liblynq-gnss/src/lynq_agps.h b/IC_src/mtk/lib/liblynq-gnss/src/lynq_agps.h
new file mode 100644
index 0000000..f3da3d3
--- /dev/null
+++ b/IC_src/mtk/lib/liblynq-gnss/src/lynq_agps.h
@@ -0,0 +1,393 @@
+#ifndef LYNQ_AGPS_H
+#define LYNQ_AGPS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*Copy for agps_interface.h*/
+#define agps_bool char
+
+#define MAX_BUFF_SIZE 8192
+#define SUPL_PROFILES_NUM 30
+
+#define AGPS_INTF_STRING_LEN 64
+#define AGPS_SUPL_ADDR_LEN 128
+#define MNL_MCC_STRING_LEN 16
+#define EXTERNAL_ADD_LEN 20
+#define MLC_NUMBER_LEN 20
+#define EPC_MOLR_LPP_PAYLOAD_LEN 300
+#define SUPL_PROFILES_NUM 30
+#define PROFILING_MESSAGE_LEN 64
+#define PROFILING_ELEMENT_NUM 20
+
+typedef enum {
+ // Command Enum APP -> AGPSD
+ APP_MGR_CMD_CODER_TEST = 0,
+ APP_MGR_CMD_VERSION = 1,
+
+ APP_MGR_CMD_GET_CONFIG = 100, //AgpsConfig
+ APP_MGR_CMD_GET_OMA_CP_SUPL_PROFILE = 101,
+ APP_MGR_CMD_GET_SYSTEM_PROPERTY = 102,
+ APP_MGR_CMD_GET_AGPS_PROFILING = 103,
+ APP_MGR_CMD_GET_EMULATOR_MODE = 104,
+ APP_MGR_CMD_GET_CONFIG_V2 = 105,
+ APP_MGR_CMD_GET_CONFIG_V3 = 106, // add cert_from_sdcard
+ APP_MGR_CMD_GET_CONFIG_V14 = 117,
+ APP_MGR_CMD_GET_CONFIG_V20 = 123,
+ APP_MGR_CMD_GET_CONFIG_V21 = 124,
+ APP_MGR_CMD_GET_CONFIG_V22 = 125,
+ APP_MGR_CMD_GET_CONFIG_V23 = 126,
+ APP_MGR_CMD_GET_CONFIG_V24 = 127,
+
+ APP_MGR_CMD_SET_AGPS_ENABLE = 200,
+ APP_MGR_CMD_SET_PROTOCOL,
+ APP_MGR_CMD_SET_CDMA_PREF,
+ APP_MGR_CMD_SET_UP_PREF_METHOD,
+ APP_MGR_CMD_SET_POS_TECHNOLOGY_MSA,
+ APP_MGR_CMD_SET_POS_TECHNOLOGY_MSB,
+ APP_MGR_CMD_SET_POS_TECHNOLOGY_ECID,
+ APP_MGR_CMD_SET_POS_TECHNOLOGY_OTDOA,
+ APP_MGR_CMD_SET_SUPL_VERSION,
+ APP_MGR_CMD_SET_SUPL_PROFILE, //AgpsProfil
+ APP_MGR_CMD_SET_QOP = 210, //AgpsQoP
+ APP_MGR_CMD_SET_MOLR_POS_METHDO,
+ APP_MGR_CMD_SET_EXTERNAL_ADDR,
+ APP_MGR_CMD_SET_MLC_NUMBER,
+ APP_MGR_CMD_SET_CP_AUTO_RESET,
+ APP_MGR_CMD_SET_ALLOW_NI,
+ APP_MGR_CMD_SET_ALLOW_ROAMING,
+ APP_MGR_CMD_SET_SUPL_2_FILE,
+ APP_MGR_CMD_SET_RESET_TO_DEFAULT,
+ APP_MGR_CMD_SET_OMA_CP_SUPL_PROFILE,
+ APP_MGR_CMD_SET_NI_REQ = 220, //un-implemented for test
+ APP_MGR_CMD_SET_EPC_MOLR_PDU_ENABLE,
+ APP_MGR_CMD_SET_EPC_MOLR_PDU,
+ APP_MGR_CMD_SET_TLS_VERSION,
+ APP_MGR_CMD_SET_CA_ENABLE,
+ APP_MGR_CMD_SET_UDP_ENABLE,
+ APP_MGR_CMD_SET_LPP_ENABLE,
+ APP_MGR_CMD_SET_CERT_FROM_SDCARD_ENABLE,
+ APP_MGR_CMD_SET_AUTO_PROFILE_ENABLE,
+ APP_MGR_CMD_SET_UT2,
+ APP_MGR_CMD_SET_UT3 = 230,
+ APP_MGR_CMD_SET_SUPL_APN_ENABLE,
+ APP_MGR_CMD_SET_SYNC_TO_SLP,
+ APP_MGR_CMD_SET_UDP_ENABLE_V2,
+ APP_MGR_CMD_SET_AUTONOMOUS_ENABLE,
+ APP_MGR_CMD_SET_AFLT_ENABLE,
+ APP_MGR_CMD_SET_IMSI_ENABLE,
+ APP_MGR_CMD_SET_SIB8_16_ENABLE,
+ APP_MGR_CMD_SET_GPS_ENABLE,
+ APP_MGR_CMD_SET_GLONASS_ENABLE,
+ APP_MGR_CMD_SET_BEIDOU_ENABLE = 240,
+ APP_MGR_CMD_SET_GALILEO_ENABLE,
+ APP_MGR_CMD_SET_SUPL_SHA_VERSION,
+ APP_MGR_CMD_SET_SUPL_TLS_VERSION,
+ APP_MGR_CMD_SET_SUPL_VER_MINOR,
+ APP_MGR_CMD_SET_SUPL_VER_SER_IND,
+ APP_MGR_CMD_SET_A_GLONASS_ENABLE,
+ APP_MGR_CMD_SET_PDE_PROFILE,
+ APP_MGR_CMD_SET_E911_GPS_ICON_ENABLE,
+ APP_MGR_CMD_SET_E911_OPEN_GPS_ENABLE,
+ APP_MGR_CMD_SET_A_GPS_ENABLE = 250,
+ APP_MGR_CMD_SET_A_BEIDOU_ENABLE,
+ APP_MGR_CMD_SET_A_GALILEO_ENABLE,
+ APP_MGR_CMD_SET_PREF_2G3G_CELL_AGE,
+ APP_MGR_CMD_SET_UT1,
+ APP_MGR_CMD_SET_NO_SENSITIVE_LOG,
+ APP_MGR_CMD_SET_TLS_REUSE_ENABLE,
+ APP_MGR_CMD_SET_IMSI_CACHE_ENABLE,
+ APP_MGR_CMD_SET_SUPL_RAW_DATA_ENABLE,
+ APP_MGR_CMD_SET_TC10_ENABLE,
+ APP_MGR_CMD_SET_TC10_USE_APN = 260,
+ APP_MGR_CMD_SET_TC10_USE_FW_DNS,
+ APP_MGR_CMD_SET_ALLOW_NI_FOR_GPS_OFF,
+ APP_MGR_CMD_SET_FORCE_OTDOA_ASSIST_REQ,
+ APP_MGR_CMD_SET_REJECT_NON911_NILR_ENABLE,
+ APP_MGR_CMD_SET_CP_2G_DISABLE,
+ APP_MGR_CMD_SET_CP_3G_DISABLE,
+ APP_MGR_CMD_SET_CP_4G_DISABLE,
+ APP_MGR_CMD_SET_TC10_IGNORE_FW_CONFIG,
+ APP_MGR_CMD_SET_LPPE_HIDE_WIFI_BT_STATUS,
+ APP_MGR_CMD_SET_LPPE_NETWORK_LOCATION_DISABLE = 270,
+ APP_MGR_CMD_SET_LPPE_CP_ENABLE,
+ APP_MGR_CMD_SET_LPPE_UP_ENABLE,
+ APP_MGR_CMD_SET_VZW_DEBUG_SCREEN_ENABLE,
+ APP_MGR_CMD_SET_AOSP_PROFILE_ENABLE,
+ APP_MGR_CMD_SET_BIND_NLP_SETTING_TO_SUPL,
+ APP_MGR_CMD_SET_ESUPL_APN_MODE,
+ APP_MGR_CMD_SET_TCP_KEEPALIVE,
+ APP_MGR_CMD_SET_AGPS_NVRAM_ENABLE,
+ APP_MGR_CMD_SET_LBS_LOG_ENABLE,
+ APP_MGR_CMD_SET_LPPE_CROWD_SOURCE_CONFIDENT = 280,
+ APP_MGR_CMD_SET_IGNORE_SI_FOR_E911,
+ APP_MGR_CMD_SET_LPPE_CP_WLAN_ENABLE,
+ APP_MGR_CMD_SET_LPPE_CP_SRN_ENABLE,
+ APP_MGR_CMD_SET_LPPE_CP_SENSOR_ENABLE,
+ APP_MGR_CMD_SET_LPPE_CP_DBH_ENABLE,
+ APP_MGR_CMD_SET_LPPE_UP_WLAN_ENABLE,
+ APP_MGR_CMD_SET_LPPE_UP_SRN_ENABLE,
+ APP_MGR_CMD_SET_LPPE_UP_SENSOR_ENABLE,
+ APP_MGR_CMD_SET_LPPE_UP_DBH_ENABLE,
+ APP_MGR_CMD_SET_IP_VERSION_PREFER = 290,
+ APP_MGR_CMD_SET_UP_LPP_IN_2G3G_DISABLE,
+ APP_MGR_CMD_SET_UP_RRLP_IN_4G_DISABLE,
+ APP_MGR_CMD_UP_SI_DISABLE,
+
+ // To implement
+ APP_MGR_CMD_SET_USE_NI_SLP,
+ APP_MGR_CMD_SET_USE_TC10_CONFIG,
+ APP_MGR_CMD_SET_LPPE_DEF_NLP_ENABLE,
+ APP_MGR_CMD_SET_AOSP_POS_MODE_ENABLE,
+ APP_MGR_CMD_SET_PRIVACY_OVERRIDE_MODE,
+ APP_MGR_CMD_SET_EMERGENCY_EXT_SECS, // 299
+
+
+ APP_MGR_CMD_START_PERIODIC = 300,
+ APP_MGR_CMD_ABORT_PERIODIC,
+ APP_MGR_CMD_START_AREA_EVENT,
+ APP_MGR_CMD_ABORT_AREA_EVENT,
+
+ APP_MGR_CMD_START_TEST_CASE = 400,
+ APP_MGR_CMD_START_TEST_BUTTON,
+ APP_MGR_CMD_START_RESET_AGPSD,
+ APP_MGR_CMD_START_EMULATOR_MODE,
+
+
+ // To implement
+ APP_MGR_CMD_SET_TC10_SUPL_SSL_METHOD = 500,
+ APP_MGR_CMD_SET_TC10_AUTO_SUPL_VER_FOR_NI,
+ APP_MGR_CMD_SET_TC10_SUPL_VER_SKT_NI,
+ APP_MGR_CMD_SET_TC10_USE_APN_NI,
+ APP_MGR_CMD_SET_TC10_USE_APN_SI,
+ APP_MGR_CMD_SET_CP_PRIVACY_OVERRIDE,
+ APP_MGR_CMD_SET_SUPL_ADDR_NI,
+ APP_MGR_CMD_SET_RRLP_GOOGLE_SUPL,
+ APP_MGR_CMD_SET_SUPL2_CAP_EXT_DISABLE,
+ APP_MGR_CMD_SET_NI_STATISTIC_ENABLE,
+ APP_MGR_CMD_SET_UP_OPERATION_MODE, // 510
+ APP_MGR_CMD_SET_GLONASS_MSA_ENABLE,
+ APP_MGR_CMD_SET_GLONASS_MSB_ENABLE,
+ APP_MGR_CMD_SET_BEIDOU_MSA_ENABLE,
+ APP_MGR_CMD_SET_BEIDOU_MSB_ENABLE,
+ APP_MGR_CMD_SET_GALILEO_MSA_ENABLE,
+ APP_MGR_CMD_SET_GALILEO_MSB_ENABLE,
+ APP_MGR_CMD_SET_TC10_AUTO_SUPL_VER_FOR_ENI,
+ APP_MGR_CMD_SET_TC10_CP_LPP_GUARD_TIME_SEC,
+ APP_MGR_CMD_SET_TC10_CP_CAPABILITY_VALID_ENABLE,
+ APP_MGR_CMD_SET_TC10_CP_CAPABILITY_ENABLE, // 520
+ APP_MGR_CMD_SET_IGNORE_EMERGENCY_EXT_SECS_FROM_FRAMEWORK,
+ APP_MGR_CMD_GET_AGPSD_VERSION,
+ APP_MGR_CMD_GET_IMSI,
+} app_mgr_cmd_enum;
+
+typedef enum {
+ AGPS_INTF_PDE_IP_TYPE_IPV4 = 0,
+ AGPS_INTF_PDE_IP_TYPE_IPV6 = 1,
+} agps_intf_pde_ip_type;
+
+typedef enum {
+ AGPS_INTF_CDMA_PREFERRED_WCDMA = 0,
+ AGPS_INTF_CDMA_PREFERRED_CDMA = 1,
+ AGPS_INTF_CDMA_PREFERRED_CDMA_FORCE = 2,
+} agps_intf_cdma_preferred;
+
+typedef enum {
+ AGPS_INTF_PREF_METHOD_MSA = 0,
+ AGPS_INTF_PREF_METHOD_MSB = 1,
+ AGPS_INTF_PREF_METHOD_NO_PREF = 2,
+} agps_intf_pref_method;
+
+typedef enum {
+ AGPS_INTF_AGPS_PROTOCOL_UP = 0,
+ AGPS_INTF_AGPS_PROTOCOL_CP = 1,
+} agps_intf_agps_protocol;
+
+typedef enum {
+ AGPS_INTF_SUPL_VERSION_1 = 1,
+ AGPS_INTF_SUPL_VERSION_2 = 2,
+} agps_intf_supl_version;
+
+typedef enum {
+ AGPS_INTF_TLS_VERSION_1_0 = 0,
+ AGPS_INTF_TLS_VERSION_1_1 = 1,
+ AGPS_INTF_TLS_VERSION_1_2 = 2,
+} agps_intf_tls_version;
+
+typedef enum {
+ AGPS_INTF_ESUPL_APN_EIMS_IMS = 0,
+ AGPS_INTF_ESUPL_APN_EIMS = 1,
+ AGPS_INTF_ESUPL_APN_IMS = 2,
+ AGPS_INTF_ESUPL_APN_AS_NORMAL = 3,
+} agps_intf_esupl_apn;
+
+typedef enum {
+ AGPS_INTF_MOLR_POS_METHOD_LOC_EST = 0,
+ AGPS_INTF_MOLR_POS_METHOD_ASSIST_DATA = 1,
+} agps_intf_molr_pos_method;
+
+typedef struct {
+ char name[AGPS_INTF_STRING_LEN];
+ char addr[AGPS_SUPL_ADDR_LEN];
+ int port;
+ agps_bool tls;
+ char mcc_mnc[MNL_MCC_STRING_LEN];
+ char app_id[AGPS_INTF_STRING_LEN];
+ char provider_id[AGPS_INTF_STRING_LEN];
+ char default_apn[AGPS_INTF_STRING_LEN];
+ char optional_apn[AGPS_INTF_STRING_LEN];
+ char optional_apn_2[AGPS_INTF_STRING_LEN];
+ char address_type[AGPS_INTF_STRING_LEN];
+} agps_intf_supl_profile;
+
+typedef struct {
+ char name[AGPS_INTF_STRING_LEN];
+ agps_bool mcp_enable;
+ char mcp_addr[AGPS_INTF_STRING_LEN];
+ int mcp_port;
+ agps_bool pde_addr_valid;
+ agps_intf_pde_ip_type pde_ip_type; //0=IPV4 1=IPV6
+ char pde_addr[AGPS_INTF_STRING_LEN];
+ int pde_port;
+ agps_bool pde_url_valid;
+ char pde_url_addr[AGPS_INTF_STRING_LEN];
+} agps_intf_cdma_profile;
+
+typedef struct {
+ agps_bool agps_enable;
+ agps_intf_agps_protocol agps_protocol;
+ agps_bool gpevt;
+ agps_bool e911_gps_icon_enable;
+ agps_bool e911_open_gps;
+ agps_bool tc10_ignore_fw_config;
+ agps_bool lppe_hide_wifi_bt_status;
+ agps_bool lppe_network_location_disable;
+ agps_bool agps_nvram_enable;
+ agps_bool lbs_log_enable;
+ int lppe_crowd_source_confident;
+ agps_bool ignore_si_for_e911; // North America operator 'V' asks us to ignore SI triggered by GMS
+ agps_bool use_tc10_config;
+ agps_bool lppe_def_nlp_enable;
+ int emergency_ext_secs;
+} agps_intf_agps_setting;
+
+typedef struct {
+ agps_intf_molr_pos_method molr_pos_method;
+ agps_bool external_addr_enable;
+ char external_addr[EXTERNAL_ADD_LEN];
+ agps_bool mlc_number_enable;
+ char mlc_number[MLC_NUMBER_LEN];
+ agps_bool cp_auto_reset;
+ agps_bool epc_molr_lpp_payload_enable;
+ int epc_molr_lpp_payload_len;
+ char epc_molr_lpp_payload[EPC_MOLR_LPP_PAYLOAD_LEN];
+ agps_bool cp_lppe_enable;
+ agps_bool support_cp_lppe;
+ agps_bool reject_non911_nilr_enable;
+ agps_bool cp_2g_disable;
+ agps_bool cp_3g_disable;
+ agps_bool cp_4g_disable;
+ agps_bool cp_lppe_wlan_enable;
+ agps_bool cp_lppe_srn_enable;
+ agps_bool cp_lppe_sensor_enable;
+ agps_bool cp_lppe_dbh_enable;
+} agps_intf_cp_setting;
+
+typedef struct {
+ agps_bool ca_enable;
+ agps_bool ni_request;
+ agps_bool roaming;
+ agps_intf_cdma_preferred cdma_preferred;
+ agps_intf_pref_method pref_method;
+ agps_intf_supl_version supl_version;
+ agps_intf_tls_version tls_version;
+ agps_bool supl_log;
+ agps_bool msa_enable;
+ agps_bool msb_enable;
+ agps_bool ecid_enable;
+ agps_bool otdoa_enable;
+ int qop_hacc;
+ int qop_vacc;
+ int qop_loc_age;
+ int qop_delay;
+ agps_bool lpp_enable;
+ agps_bool cert_from_sdcard;
+ agps_bool auto_profile_enable;
+ char ut2;
+ char ut3;
+ agps_bool apn_enable;
+ agps_bool sync_to_slp;
+ agps_bool udp_enable;
+ agps_bool autonomous_enable;
+ agps_bool aflt_enable;
+ agps_bool imsi_enable;
+ char supl_ver_minor;
+ char supl_ver_ser_ind;
+ int sha_version; // 0: SHA1 for SUPL1.0 and SHA256 for SUPL2.0, 1: SHA1 for SUPL1.0 and SUPL2.0, 2: SHA256 for SUPL1.0 and SUPL2.0
+ int preferred_2g3g_cell_age;
+ char ut1;
+ agps_bool no_sensitive_log;
+ agps_bool tls_reuse_enable;
+ agps_bool imsi_cache_enable;
+ agps_bool supl_raw_data_enable;
+ agps_bool tc10_enable;
+ agps_bool tc10_use_apn;
+ agps_bool tc10_use_fw_dns;
+ agps_bool allow_ni_for_gps_off;
+ agps_bool force_otdoa_assist_req;
+ agps_bool up_lppe_enable;
+ agps_intf_esupl_apn esupl_apn_mode;
+ int tcp_keepalive;
+ agps_bool aosp_profile_enable;
+ agps_bool bind_nlp_setting_to_supl;
+ agps_bool up_lppe_wlan_enable;
+ agps_bool up_lppe_srn_enable;
+ agps_bool up_lppe_sensor_enable;
+ agps_bool up_lppe_dbh_enable;
+ int ip_version_prefer; //0=IPv6 prefer 1=IPv4 prefer
+ agps_bool up_lppe_in_2g3g_disable; // For ATT SUPL server
+ agps_bool up_rrlp_in_4g_disable; // For ATT SUPL server
+ agps_bool up_si_disable; // For Sprint
+ agps_bool use_ni_slp; // tc10 (ALPS04423530)
+ agps_bool aosp_pos_mode_enable;
+ int privacy_override_mode;
+} agps_intf_up_setting;
+
+typedef struct {
+ agps_bool sib8_sib16_enable;
+ agps_bool gps_satellite_enable;
+ agps_bool glonass_satellite_enable;
+ agps_bool beidou_satellite_enable;
+ agps_bool galileo_satellite_enable;
+ agps_bool a_glonass_satellite_enable;
+
+ agps_bool gps_satellite_support;
+ agps_bool glonass_satellite_support;
+ agps_bool beidou_satellite_support;
+ agps_bool galileo_satellite_support;
+
+ agps_bool a_gps_satellite_enable;
+ agps_bool a_beidou_satellite_enable;
+ agps_bool a_galileo_satellite_enable;
+
+ agps_bool mnl_support_lppe;
+} agps_intf_gnss_setting;
+
+typedef struct {
+ int supl_profiles_num;
+ agps_intf_supl_profile supl_profiles[SUPL_PROFILES_NUM];
+ agps_intf_supl_profile cur_supl_profile;
+ agps_intf_cdma_profile cdma_profile;
+ agps_intf_agps_setting agps_setting;
+ agps_intf_cp_setting cp_setting;
+ agps_intf_up_setting up_setting;
+ agps_intf_gnss_setting gnss_setting;
+ agps_bool valid;
+} agps_intf_agps_config;
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif
\ No newline at end of file
diff --git a/IC_src/mtk/lib/liblynq-gnss/src/lynq_callback.c b/IC_src/mtk/lib/liblynq-gnss/src/lynq_callback.c
new file mode 100755
index 0000000..b8a402f
--- /dev/null
+++ b/IC_src/mtk/lib/liblynq-gnss/src/lynq_callback.c
@@ -0,0 +1,209 @@
+#include<pthread.h>
+#include<stdio.h>
+#include<unistd.h>
+#include<errno.h>
+#include<string.h>
+
+#include"lynq_gnsshal.h"
+#include"mtk_lbs_utility.h"
+#include"lynq_gnss.h"
+
+extern lynq_gnss_cb* lynq_callbacks;
+extern lynq_raw_gnss_cbs *lynq_meas_callbacks;
+
+void lynq_gps_location_callback(GpsLocation_ext* location)
+{
+ GpsLocation_ext* loc = (GpsLocation_ext *)location;
+ lynq_GpsLocation_ext lynq_loc;
+ //lynq_loc.legacyLocation.size = loc->legacyLocation.size;
+ lynq_loc.legacyLocation.size = sizeof(lynq_GpsLocation_ext);
+ lynq_loc.legacyLocation.flags = loc->legacyLocation.flags;
+ lynq_loc.legacyLocation.latitude = loc->legacyLocation.latitude;
+ lynq_loc.legacyLocation.longitude = loc->legacyLocation.longitude;
+ lynq_loc.legacyLocation.altitude = loc->legacyLocation.altitude;
+ lynq_loc.legacyLocation.speed = loc->legacyLocation.speed;
+ lynq_loc.legacyLocation.bearing = loc->legacyLocation.bearing;
+ lynq_loc.legacyLocation.accuracy = loc->legacyLocation.accuracy;
+ lynq_loc.legacyLocation.timestamp = loc->legacyLocation.timestamp;
+ lynq_loc.horizontalAccuracyMeters = loc->horizontalAccuracyMeters;
+ lynq_loc.verticalAccuracyMeters = loc->speedAccuracyMetersPerSecond;
+ lynq_loc.bearingAccuracyDegrees = loc->bearingAccuracyDegrees;
+ lynq_callbacks->lynq_location_cb(&lynq_loc);
+}
+
+void lynq_gps_status_callback(GpsStatus* status)
+{
+ lynq_callbacks->lynq_status_cb(status);
+}
+
+void lynq_gps_sv_status_callback(GpsSvStatus* sv_info)
+{
+
+}
+
+void lynq_gps_nmea_callback(GpsUtcTime timestamp, const char* nmea, int length)
+{
+ lynq_callbacks->lynq_nmea_cb(timestamp,nmea,length);
+
+}
+
+void lynq_gps_set_capabilities(uint32_t capabilities)
+{
+
+}
+
+void lynq_gps_acquire_wakelock(void)
+{
+
+}
+
+void lynq_gps_release_wakelock(void)
+{
+
+}
+
+void lynq_gps_request_utc_time(void)
+{
+
+}
+
+void lynq_set_system_info_cb(const GnssSystemInfo* info)
+{
+
+}
+
+void lynq_gnss_sv_status_cb(GnssSvStatus_ext* sv_info)
+{
+
+}
+
+pthread_t lynq_gps_create_thread(const char* name, void (*start)(void *), void* arg)
+{
+ lynq_callbacks->lynq_create_thread_cb(name,(void *(*)(void *))start,arg);
+}
+
+void lynq_gnss_set_name_cb(const char* name, int length)
+{
+
+}
+
+void lynq_gnss_request_location_cb(bool independentFromGnss, bool isUserEmergency)
+{
+
+}
+
+void lynq_agnss_location_callback(GpsLocation_ext* location) {
+
+}
+
+
+GpsCallbacks_ext lynq_gps_callbacks_gnss = {
+ .size = sizeof(GpsCallbacks_ext),
+ .location_cb = lynq_gps_location_callback,
+ .status_cb = lynq_gps_status_callback,
+ .sv_status_cb = lynq_gps_sv_status_callback,
+ .nmea_cb = lynq_gps_nmea_callback,
+ .set_capabilities_cb = lynq_gps_set_capabilities,
+ .acquire_wakelock_cb = lynq_gps_acquire_wakelock,
+ .release_wakelock_cb = lynq_gps_release_wakelock,
+ .create_thread_cb = lynq_gps_create_thread,
+ .request_utc_time_cb = lynq_gps_request_utc_time,
+ .set_system_info_cb = lynq_set_system_info_cb,
+ .gnss_sv_status_cb = lynq_gnss_sv_status_cb,
+ .set_name_cb = lynq_gnss_set_name_cb,
+ .request_location_cb = lynq_gnss_request_location_cb,
+ .agps_location_cb = lynq_agnss_location_callback,
+};
+
+GpsCallbacks_ext* lynq__get_gps_callbacks(void)
+{
+ return &lynq_gps_callbacks_gnss;
+}
+
+void lynq_measurement_callback(GpsData *data)
+{
+
+}
+
+void lynq_gnss_measurement_callback(GnssData_ext* data)
+{
+ lynq_meas_callbacks->lynq_measurement_callback(data);
+ return;
+}
+
+GpsMeasurementCallbacks_ext lynq_test_raw_callbacks = {
+ .size = sizeof(GpsMeasurementCallbacks_ext),
+ .measurement_callback = lynq_measurement_callback,
+ .gnss_measurement_callback = lynq_gnss_measurement_callback,
+};
+
+GpsMeasurementCallbacks_ext* lynq_gnss_get_raw_callbacks(void)
+{
+ return &lynq_test_raw_callbacks;
+}
+
+
+void lynq_at_gps_location_callback(lynq_GpsLocation_ext* location)
+{
+
+}
+
+void lynq_at_gps_status_callback(GpsStatus* status)
+{
+
+}
+
+#define NMEA_ACC "ACCURACY"
+#define NMEA_GSA "GSA"
+#define NMEA_RMC "RMC"
+#define NMEA_GGA "GGA"
+#define NMEA_VTG "VTG"
+#define NMEA_GSV "GSV"
+
+void lynq_at_gps_nmea_callback(GpsUtcTime timestamp, const char* nmea, int length)
+{
+ if (at_gpsnmea_status == 1)
+ {
+ if(strncmp(nmea+3,NMEA_GSA,strlen(NMEA_GSA))==0 || strncmp(nmea+3,NMEA_RMC,strlen(NMEA_RMC)) == 0 || \
+ strncmp(nmea+3,NMEA_GGA,strlen(NMEA_GGA)) == 0 || strncmp(nmea+3,NMEA_VTG,strlen(NMEA_VTG)) == 0|| \
+ strncmp(nmea+3,NMEA_GSV,strlen(NMEA_GSV)) == 0)
+ {
+ atsvc_gnss_outcb(nmea,strlen(nmea),1);
+ }
+ }
+}
+
+
+
+pthread_t lynq_at_gps_create_thread(const char* name, void (*start)(void *), void* arg)
+{
+ pthread_t at_ntid = 0;
+ int ret = 0;
+
+ ret = pthread_create(&at_ntid, NULL, (void *(*)(void *))start, arg);
+
+ if(ret != 0)
+ {
+ printf("thread %s create fail(%s)!\r\n", name, strerror(errno));
+ at_ntid = 0;
+ }
+ else
+ {
+ printf("tread %s create success!\r\n", name);
+ }
+
+ return at_ntid;
+}
+
+lynq_gnss_cb lynq_at_gnss_callbacks = {
+ .size = sizeof(lynq_gnss_cb),
+ .lynq_location_cb =lynq_at_gps_location_callback,
+ .lynq_status_cb = lynq_at_gps_status_callback,
+ .lynq_nmea_cb = lynq_at_gps_nmea_callback,
+ .lynq_create_thread_cb = lynq_at_gps_create_thread,
+};
+
+lynq_gnss_cb* lynq_at_get__gnss_callbacks(void)
+{
+ return &lynq_at_gnss_callbacks;
+}
diff --git a/IC_src/mtk/lib/liblynq-gnss/src/lynq_gnss.c b/IC_src/mtk/lib/liblynq-gnss/src/lynq_gnss.c
new file mode 100755
index 0000000..a812738
--- /dev/null
+++ b/IC_src/mtk/lib/liblynq-gnss/src/lynq_gnss.c
@@ -0,0 +1,620 @@
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <unistd.h>
+#include <sys/time.h>
+#include <time.h>
+#include <signal.h>
+#include <string.h>
+#include <errno.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <arpa/inet.h>
+#include <dlfcn.h>
+#include <stdlib.h>
+#include <semaphore.h>
+#include <pthread.h>
+#include <log/log.h>
+#include <stdlib.h>
+
+#include "lynq_gnss.h"
+#include "gpshal.h"
+#include "hal2mnl_interface.h"
+#include "lynq_gnsshal.h"
+#include "mtk_lbs_utility.h"
+#include "lynq_prop.h"
+#include "mnldinf_utility.h"
+
+#define LOG_TAG "LYNQ_GNSS"
+
+
+lynq_gnss_cb* lynq_callbacks =NULL ;
+lynq_raw_gnss_cbs* lynq_meas_callbacks = NULL;
+
+GpsCallbacks_ext* turn_cbs = NULL;
+GpsMeasurementCallbacks_ext* raw_cbs = NULL;
+
+lynq_gnss_cb* lynq_at_callbacks = NULL ;
+/**
+ * @brief mark gnss initialization state
+ * 0: deinit state
+ * 1: init state
+ */
+static int g_lynq_gnss_init_flag = 0;
+
+static int g_lynq_gnss_calback_flag = 0;
+
+/**
+ * @brief mark gnss raw meas state
+ * 0: deinit state
+ * 1: init state
+ */
+static int g_lynq_gnss_raw_meas_flag = 0;
+
+int lynq_gnss_init(void)
+{
+ if (g_lynq_gnss_init_flag == 1)
+ {
+ RLOGD("init twice is not allowed");
+ return -1;
+ }
+ if (g_lynq_gnss_calback_flag == 0)
+ {
+ RLOGD("Plz Reg callback before init");
+ return -1;
+ }
+ g_lynq_gnss_init_flag = 1;
+ gpshal_set_gps_state_intent(GPSHAL_STATE_INIT);
+ gpshal2mnl_gps_init();
+ g_gpshal_ctx.mnl_retry_timer = mnldinf_init_timer(gpshal_mnl_retry_routine);
+ return 0;
+}
+
+int lynq_gnss_callback_reg(lynq_gnss_cb* callbacks)
+{
+ int i=0;
+ if (NULL == callbacks)
+ {
+ RLOGD("illegal callbacks!!!");
+ return -1;
+ }
+ mnldinf_wake_lock_init();
+ lynq_callbacks = callbacks;
+ turn_cbs = lynq__get_gps_callbacks();
+ if(turn_cbs == NULL)
+ {
+ RLOGD("callbacks error");
+ return -1;
+ }
+ for(i=0;i<5;i++)
+ {
+ RLOGD("The callback_gps_state:%s",gpshal_state_to_string(g_gpshal_ctx.gps_state));
+ if(gpshal_gpscbs_save(turn_cbs) != 0)
+ {
+ RLOGD("For cbs save error\r\n");
+ }
+ RLOGD("The callback_gps_state:%s",gpshal_state_to_string(g_gpshal_ctx.gps_state));
+ if(g_gpshal_ctx.gps_state != GPSHAL_STATE_UNKNOWN)
+ {
+ break;
+ }
+ sleep(1);
+ }
+ if(i>=5)
+ {
+ RLOGD("For cbs save error2\r\n");
+ return -1;
+ }
+ g_lynq_gnss_calback_flag = 1;
+ return 0;
+}
+
+int lynq_gnss_deinit(void)
+{
+ if (g_lynq_gnss_init_flag == 0)
+ {
+ RLOGD("deinit twice is not allowed");
+ return -1;
+ }
+ timer_t retry_timer;
+ gpshal_set_gps_state_intent(GPSHAL_STATE_CLEANUP);
+ gpshal2mnl_gps_cleanup();
+ RLOGD("WAKE_LOCK_Begin");
+ mnldinf_wake_lock_deinit();
+ RLOGD("WAKE_LOCK_END");
+ retry_timer = g_gpshal_ctx.mnl_retry_timer;
+ g_gpshal_ctx.mnl_retry_timer = INVALID_TIMERID;
+ RLOGD("timer deinit start");
+ if(mnldinf_deinit_timer(retry_timer) == -1) {
+ RLOGD("retry_timer deinit fail:%s", strerror(errno));
+ return -1;
+ }
+ RLOGD("timer de init end");
+ g_lynq_gnss_calback_flag = 0;
+ g_lynq_gnss_init_flag = 0;
+ return 0;
+}
+
+int lynq_gnss_start(void)
+{
+ if (g_lynq_gnss_init_flag == 0)
+ {
+ RLOGD("start is not allowed");
+ return -1;
+ }
+ //memset(&lynq_debug_data, 0, sizeof(DebugData));
+ gpshal_set_gps_state_intent(GPSHAL_STATE_START);
+ gpshal2mnl_gps_start();
+ return 0;
+}
+
+int lynq_gnss_stop(void)
+{
+ if (g_lynq_gnss_init_flag == 0)
+ {
+ RLOGD("stop is not allowed");
+ return -1;
+ }
+ gpshal_set_gps_state_intent(GPSHAL_STATE_STOP);
+ gpshal2mnl_gps_stop();
+ return 0;
+}
+
+int lynq_gnss_inject_time(GpsUtcTime time, int64_t timeReference, int uncertainty)
+{
+ if (hal2mnl_gps_inject_time(time, timeReference, uncertainty) == -1) {
+ RLOGD("hal2mnl_gps_inject_time failed because of safe_sendto fail ,strerror:%s \n", strerror(errno));
+ return -1;
+ }
+ return 0;
+}
+
+int lynq_gnss_inject_location(
+ double latitude,
+ double longitude,
+ float accuracy) {
+ if (hal2mnl_gps_inject_location(latitude, longitude, accuracy) == -1) {
+ RLOGD("hal2mnl_gps_inject_location failed because of safe_sendto fail ,strerror:%s \n", strerror(errno));
+ return -1;
+ }
+ return 0;
+}
+
+int lynq_gnss_delete_aiding_data(GpsAidingData flags) {
+ if (hal2mnl_gps_delete_aiding_data(flags) == -1) {
+ RLOGD("hal2mnl_gps_delete_aiding_data failed because of safe_sendto fail ,strerror:%s \n", strerror(errno));
+ return -1;
+ }
+ return 0;
+}
+
+int lynq_gnss_inject_fused_location(
+ double latitude,
+ double longitude,
+ float accuracy) {
+ // TODO: hal2mnl_gps_inject_fused_location(latitude, longitude, accuracy);
+ UNUSED(latitude);
+ UNUSED(longitude);
+ UNUSED(accuracy);
+ return 0; // 0:ok, non-zero: error; but GPS JNI will ignore it
+}
+/*get extension*/
+int lynq_gnss_start_raw_meas_mode(lynq_raw_gnss_cbs* raw_gnss_cbs)
+{
+ if (g_lynq_gnss_raw_meas_flag == 1)
+ {
+ RLOGD("start twice is not allowed");
+ return -1;
+ }
+ g_lynq_gnss_raw_meas_flag = 1;
+
+ lynq_meas_callbacks = raw_gnss_cbs;
+ raw_cbs = lynq_gnss_get_raw_callbacks();
+ if (NULL == raw_cbs)
+ {
+ RLOGD("callbacks error");
+ return -2;
+ }
+ g_gpshal_ctx.meas_cbs = raw_cbs;
+ RLOGD("liblynq-gnss:Test for adress %p",g_gpshal_ctx.meas_cbs);
+ int ret = hal2mnl_set_gps_measurement(true, true);
+ return (ret > 0)?
+ GPS_GEOFENCE_OPERATION_SUCCESS :
+ GPS_GEOFENCE_ERROR_GENERIC;
+}
+
+int lynq_gnss_stop_raw_meas_mode()
+{
+ if (g_lynq_gnss_raw_meas_flag == 0)
+ {
+ RLOGD("must start raw meas first");
+ return -1;
+ }
+ if (hal2mnl_set_gps_measurement(false, false) == -1) {
+ LOGE("hal2mnl_set_gps_measurement failed because of safe_sendto fail ,strerror:%s \n", strerror(errno));
+ }
+ RLOGD("typethree test: stop gps raw measurement");
+ return 0;
+}
+
+int lynq_gnss_set_start_mode(LYNQ_GNSS_MODE_CONFIGURATION start_mode)
+{
+ int ret = 0;
+ switch (start_mode)
+ {
+ case LYNQ_MODE_GPS_GLONASS:
+ mnld_write_cfg(LYNQ_GNSS_MODE , LYNQ_CONF_GPS_GLONASS);
+ break;
+
+ case LYNQ_MODE_GPS_BEIDOU:
+ mnld_write_cfg(LYNQ_GNSS_MODE , LYNQ_CONF_GPS_BEIDOU);
+ break;
+
+ case LYNQ_MODE_GPS_GLONASS_BEIDOU:
+ mnld_write_cfg(LYNQ_GNSS_MODE , LYNQ_CONF_GPS_GLONASS_BEIDOU);
+ break;
+
+ case LYNQ_MODE_GPS:
+ mnld_write_cfg(LYNQ_GNSS_MODE , LYNQ_CONF_GPS);
+ break;
+
+ case LYNQ_MODE_BEIDOU:
+ mnld_write_cfg(LYNQ_GNSS_MODE , LYNQ_CONF_BEIDOU);
+ break;
+
+ case LYNQ_MODE_GLONASS:
+ mnld_write_cfg(LYNQ_GNSS_MODE , LYNQ_CONF_GLONASS);
+ break;
+
+ case LYNQ_MODE_GPS_GLONASS_BEIDOU_GALILEO:
+ mnld_write_cfg(LYNQ_GNSS_MODE , LYNQ_CONF_GPS_GLONASS_BEIDOU_GALILEO);
+
+ break;
+
+ case LYNQ_MODE_GPS_GALILEO:
+ mnld_write_cfg(LYNQ_GNSS_MODE , LYNQ_CONF_GPS_GALILEO);
+
+ break;
+
+ case LYNQ_MODE_GPS_GLONASS_GALILEO:
+ mnld_write_cfg(LYNQ_GNSS_MODE , LYNQ_CONF_GPS_GLONASS_GALILEO);
+
+ break;
+
+ case LYNQ_MODE_GPS_GALILEO_ONLY:
+ mnld_write_cfg(LYNQ_GNSS_MODE , LYNQ_CONF_GPS_GALILEO_ONLY);
+
+ break;
+
+ case LYNQ_MODE_GPS_GLONASS_BEIDOU_GALILEO_NAVIC:
+ mnld_write_cfg(LYNQ_GNSS_MODE , LYNQ_CONF_GPS_GLONASS_BEIDOU_GALILEO_NAVIC);
+
+ break;
+ default:
+ RLOGD("unknown type of GNSS MODE");
+ ret = -1;
+ break;
+ }
+
+ return ret;
+}
+
+int lynq_gnss_debug_switch(LYNQ_CONF_SWITCH switch_op)
+{
+ int ret = 0;
+ switch (switch_op)
+ {
+ case LYNQ_SWITCH_DISABLE:
+ mnld_write_cfg(LYNQ_DEBUG_STATUS,LYNQ_CONFIG_DISABLE);
+ break;
+ case LYNQ_SWITCH_ENABLE:
+ mnld_write_cfg(LYNQ_DEBUG_STATUS,LYNQ_CONFIG_ENABLE);
+ break;
+ default:
+ RLOGD("unknown op");
+ ret = -1;
+ break;
+ }
+ return ret;
+}
+
+int lynq_gnss_epo_switch(LYNQ_CONF_SWITCH switch_op)
+{
+ int ret = 0;
+ switch (switch_op)
+ {
+ case LYNQ_SWITCH_DISABLE:
+ mnld_write_cfg(LYNQ_EPO_STATUS,LYNQ_CONFIG_DISABLE);
+ break;
+ case LYNQ_SWITCH_ENABLE:
+ mnld_write_cfg(LYNQ_EPO_STATUS,LYNQ_CONFIG_ENABLE);
+ break;
+ default:
+ RLOGD("unknown op");
+ ret = -1;
+ break;
+ }
+ return ret;
+}
+
+int lynq_gnss_output_frequency_set(int frequency)
+{
+ int frequency_turn = frequency;
+
+ int freq_num = 1000/frequency_turn;
+ char freq[LYNQ_MAX_FRREQUENCY];
+ sprintf(freq, "%d", freq_num);
+ mnld_write_cfg(LYNQ_OUTPUT_FREQUENCY,freq);
+ return 0;
+}
+
+lynq_atsvc_outcb atsvc_gnss_outcb;
+void atsvc_incb_entity(const char *input,const int length);
+int lynq_at_cgps(int at_type,char *at_paramter);
+int lynq_at_cgpsnmea(int at_type,char *at_paramter);
+
+int at_gps_status = 0;
+int at_gpsnmea_status = 0;
+
+int strUpper(char * str)
+{
+ int i=0;
+ while(1)
+ {
+ if(str[i]=='\0')
+ {
+ break;
+ }
+ if(str[i]>='a'&&str[i]<='z')
+ {
+ str[i]=str[i]-32;
+ }
+ i++;
+ }
+ return 0;
+}
+
+int gnss_at_cmd_parse(char *cmd,char *parse_cmd[],int* at_type)
+{
+ if (NULL == cmd || NULL == parse_cmd || NULL == at_type)
+ {
+ return -1;
+ }
+ int ret = 0;
+ int at_type_jug = 0;
+ int cmd_size;
+ char cmd_buf[128] = {0};
+ char buffer1[128] = {0};
+ char buffer2[128] = {0};
+ bzero(cmd_buf,128);
+ bzero(buffer1,128);
+ bzero(buffer2,128);
+ cmd_size = strlen(cmd);
+ memcpy(cmd_buf,cmd,cmd_size);
+ strUpper(cmd_buf);
+ ret = sscanf(cmd_buf, "%[^=]=%[^=]", buffer1,buffer2);
+ if (ret == 1)
+ {
+ *at_type = 1;
+ sscanf(buffer1, "%[^?]", buffer2);
+ strcpy(parse_cmd[0],buffer2);
+ return 0;
+ }
+ else if (ret == 2)
+ {
+ at_type_jug = strcmp(buffer2,"?");
+ RLOGD("at_type_jug :%d",at_type_jug);
+ if (at_type_jug == 0)
+ {
+ *at_type = 0;
+ strcpy(parse_cmd[0],buffer1);
+ return 0;
+ }
+ else
+ {
+ *at_type = 2;
+ RLOGD("Buffertest1:buffer1 :%s buffer2 :%s",buffer1,buffer2);
+ strcpy(parse_cmd[0],buffer1);
+ strcpy(parse_cmd[1],buffer2);
+ RLOGD("buffer1 :%s buffer2 :%s",parse_cmd[0],parse_cmd[1]);
+ return 0;
+ }
+ }
+ else
+ {
+ RLOGD("unknown paramters");
+ return -1;
+ }
+}
+
+lynq_atsvc_incb lynq_register_gnss(lynq_atsvc_outcb out_cb)
+{
+ char reg_return[100] = {0};
+ if(NULL == out_cb)
+ {
+ RLOGD("out cb is null");
+ return NULL;
+ }
+ atsvc_gnss_outcb=out_cb;
+ memcpy(reg_return,"gnss register success\r\n",24);
+ atsvc_gnss_outcb(reg_return,24,0);
+ return atsvc_incb_entity;
+}
+
+
+void atsvc_incb_entity(const char *input,const int length)
+{
+ int res = 0;
+ int income_at_type = 0;
+ char at_cmd[512]={0};
+ char gnss_at_cmd[100] = {0};
+ char *parse_atcmd[128]; //argv[0]:at cmd,argv[2]:at paramter
+ if(NULL == input)
+ {
+ RLOGD("input is null");
+ memcpy(gnss_at_cmd,"+CME ERROR: 100\r\n",strlen("+CME ERROR: 100\r\n"));
+ atsvc_gnss_outcb(gnss_at_cmd,strlen("+CME ERROR: 100\r\n"),0);
+ return -1;
+ }
+ if (strlen(input) >= 128)
+ {
+ RLOGD("input size more than 128");
+ memcpy(gnss_at_cmd,"+CME ERROR: 100\r\n",strlen("+CME ERROR: 100\r\n"));
+ atsvc_gnss_outcb(gnss_at_cmd,strlen("+CME ERROR: 100\r\n"),0);
+ return -1;
+ }
+ bzero(at_cmd,512);
+ memcpy(at_cmd,input,strlen(input));
+ res = gnss_at_cmd_parse(at_cmd,parse_atcmd,&income_at_type);
+ if (res != 0)
+ {
+ RLOGD("parse at cmd error");
+ return -1;
+ }
+
+ if (!strcmp(parse_atcmd[0], "AT+CGPS"))
+ {
+ res = lynq_at_cgps(income_at_type,parse_atcmd[1]);
+ if (res != 0)
+ {
+ RLOGD("cgps unknown error");
+ }
+ }
+ else if (!strcmp(parse_atcmd[0], "AT+CGPSNMEA"))
+ {
+ lynq_at_cgpsnmea(income_at_type,parse_atcmd[1]);
+ }
+ else
+ {
+ memcpy(gnss_at_cmd,"+CME ERROR: 100\r\n",strlen("+CME ERROR: 100\r\n"));
+ }
+ memcpy(gnss_at_cmd,"OK\r\n",4);
+ atsvc_gnss_outcb(gnss_at_cmd,4,0);
+}
+
+
+int lynq_at_cgps(int at_type,char *at_paramter)
+{
+ int ret = 0;
+ char cgps_at_res[512]={};
+
+ if (at_type == LYNQ_ATCMD_TEST)
+ {
+ bzero(cgps_at_res,512);
+ memcpy(cgps_at_res,"+CGPS:(0,1)\r\n",strlen("+CGPS:(0,1)"));
+ atsvc_gnss_outcb(cgps_at_res,strlen("+CGPS:(0,1)\r\n"),0);
+ return 0;
+ }
+ else if(at_type == LYNQ_ATCMD_READ)
+ {
+ bzero(cgps_at_res,512);
+ sprintf(cgps_at_res,"+CGPS:<%d>",at_gps_status);
+ atsvc_gnss_outcb(cgps_at_res,strlen(cgps_at_res),0);
+ return 0;
+ }
+ else if(at_type == LYNQ_ATCMD_WRITE)
+ {
+ if (at_gps_status != atoi(at_paramter))
+ {
+ at_gps_status = atoi(at_paramter);
+ }
+ else
+ {
+ bzero(cgps_at_res,512);
+ memcpy(cgps_at_res,"+CGPS ERROR: same status\r\n",strlen("+CGPS ERROR: same status\r\n"));
+ atsvc_gnss_outcb(cgps_at_res,strlen(cgps_at_res),0);
+ return -1;
+ }
+ if (at_gps_status == 0)
+ {
+ ret = lynq_gnss_stop();
+ if (ret != 0)
+ {
+ RLOGD("lynq gnss stop fail");
+ return -1;
+ }
+ ret = lynq_gnss_deinit();
+ if (ret != 0)
+ {
+ RLOGD("lynq gnss deinit fail");
+ return -1;
+ }
+ bzero(cgps_at_res,512);
+ memcpy(cgps_at_res,"+CGPS OK\r\n",strlen("+CGPS OK\r\n"));
+ atsvc_gnss_outcb(cgps_at_res,strlen(cgps_at_res),0);
+ }
+ else if(at_gps_status == 1)
+ {
+ lynq_at_callbacks = lynq_at_get__gnss_callbacks();
+ ret = lynq_gnss_callback_reg(lynq_at_callbacks);
+ if (ret != 0)
+ {
+ RLOGD("lynq gnss callback reg fail");
+ return -1;
+ }
+ ret = lynq_gnss_init();
+ if (ret != 0)
+ {
+ RLOGD("lynq gnss init fail");
+ return -1;
+ }
+ ret = lynq_gnss_start();
+ if (ret != 0)
+ {
+ RLOGD("lynq gnss init fail");
+ return -1;
+ }
+ bzero(cgps_at_res,512);
+ memcpy(cgps_at_res,"+CGPS OK\r\n",strlen("+CGPS OK\r\n"));
+ atsvc_gnss_outcb(cgps_at_res,strlen(cgps_at_res),0);
+ }
+ else
+ {
+ RLOGD("unknown at paramters");
+ bzero(cgps_at_res,512);
+ memcpy(cgps_at_res,"+CGPS ERROR: 100\r\n",strlen("+CGPS ERROR: 100\r\n"));
+ atsvc_gnss_outcb(cgps_at_res,strlen("+CGPS ERROR: 100\r\n"),0);
+ }
+ return 0;
+ }
+}
+
+
+int lynq_at_cgpsnmea(int at_type,char *at_paramter)
+{
+ int ret = 0;
+ char cgpsnmea_at_res[512]={};
+
+ if (at_type == LYNQ_ATCMD_TEST)
+ {
+ bzero(cgpsnmea_at_res,512);
+ memcpy(cgpsnmea_at_res,"+CGPSNMEA:(0,1)\r\n",strlen("+CGPSNMEA:(0,1)"));
+ atsvc_gnss_outcb(cgpsnmea_at_res,strlen(cgpsnmea_at_res),0);
+ return 0;
+ }
+ else if(at_type == LYNQ_ATCMD_READ)
+ {
+ bzero(cgpsnmea_at_res,512);
+ sprintf(cgpsnmea_at_res,"+CGPSNMEA:<%d>",at_gpsnmea_status);
+ atsvc_gnss_outcb(cgpsnmea_at_res,strlen(cgpsnmea_at_res),0);
+ return 0;
+ }
+ else if(at_type == LYNQ_ATCMD_WRITE)
+ {
+ if (at_gpsnmea_status != atoi(at_paramter))
+ {
+ at_gpsnmea_status = atoi(at_paramter);
+ bzero(cgpsnmea_at_res,512);
+ memcpy(cgpsnmea_at_res,"+CGPSNMEA OK\r\n",strlen("+CGPSNMEA OK\r\n"));
+ atsvc_gnss_outcb(cgpsnmea_at_res,strlen(cgpsnmea_at_res),0);
+ }
+ else
+ {
+ RLOGD("unknown at paramters");
+ bzero(cgpsnmea_at_res,512);
+ memcpy(cgpsnmea_at_res,"+CGPSNMEA ERROR: 100\r\n",strlen("+CGPSNMEA ERROR: 100\r\n"));
+ atsvc_gnss_outcb(cgpsnmea_at_res,strlen(cgpsnmea_at_res),0);
+ }
+ return 0;
+ }
+}
\ No newline at end of file
diff --git a/IC_src/mtk/lib/liblynq-gnss/src/lynq_gnsshal.h b/IC_src/mtk/lib/liblynq-gnss/src/lynq_gnsshal.h
new file mode 100755
index 0000000..04938c9
--- /dev/null
+++ b/IC_src/mtk/lib/liblynq-gnss/src/lynq_gnsshal.h
@@ -0,0 +1,56 @@
+#ifndef LYNQ_GNSSHAL_H
+#define LYNQ_GNSSHAL_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include<pthread.h>
+#include "lynq_gnss.h"
+#include "hardware/gps_mtk.h"
+#include "hal2mnl_interface.h"
+#include "gpshal.h"
+#include "gps_mtk.h"
+
+#define LYNQ_GNSS_MODE "GNSS_MODE"
+#define LYNQ_DEBUG_STATUS "debug.dbg2file"
+#define LYNQ_EPO_STATUS "EPO_enabled"
+#define LYNQ_OUTPUT_FREQUENCY "fix_interval"
+
+#define LYNQ_CONF_GPS_GLONASS "0"
+#define LYNQ_CONF_GPS_BEIDOU "1"
+#define LYNQ_CONF_GPS_GLONASS_BEIDOU "2"
+#define LYNQ_CONF_GPS "3"
+#define LYNQ_CONF_BEIDOU "4"
+#define LYNQ_CONF_GLONASS "5"
+#define LYNQ_CONF_GPS_GLONASS_BEIDOU_GALILEO "6"
+#define LYNQ_CONF_GPS_GALILEO "7"
+#define LYNQ_CONF_GPS_GLONASS_GALILEO "8"
+#define LYNQ_CONF_GPS_GALILEO_ONLY "9"
+#define LYNQ_CONF_GPS_GLONASS_BEIDOU_GALILEO_NAVIC "10"
+
+#define LYNQ_CONFIG_DISABLE "0"
+#define LYNQ_CONFIG_ENABLE "1"
+
+#define LYNQ_MAX_FRREQUENCY 16
+
+GpsCallbacks_ext* lynq__get_gps_callbacks(void);
+
+GpsMeasurementCallbacks_ext* lynq_gnss_get_raw_callbacks(void);
+
+lynq_gnss_cb* lynq_at_get__gnss_callbacks(void);
+
+extern lynq_atsvc_outcb atsvc_gnss_outcb;
+extern int at_gpsnmea_status;
+
+typedef enum{
+ LYNQ_ATCMD_TEST = 0,
+ LYNQ_ATCMD_READ,
+ LYNQ_ATCMD_WRITE
+}LYNQ_ATCMD_TYPE;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
\ No newline at end of file
diff --git a/IC_src/mtk/lib/liblynq-gnss/src/lynq_prop.c b/IC_src/mtk/lib/liblynq-gnss/src/lynq_prop.c
new file mode 100755
index 0000000..deaacc2
--- /dev/null
+++ b/IC_src/mtk/lib/liblynq-gnss/src/lynq_prop.c
@@ -0,0 +1,107 @@
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <sys/time.h>
+#include <errno.h>
+#include <unistd.h>
+#include <log/log.h>
+
+#include "lynq_prop.h"
+
+#define PROPBUF_SIZE 512
+
+
+const char *mnl_prop_path[] = {
+ "/etc/gnss/mnl.prop", /*mainly for target*/
+ "/sbin/mnl.prop", /*mainly for emulator*/
+};
+
+int write_prop(const char *file_name, char* key, char* val) {
+ if(NULL == file_name||NULL == key|| NULL == val)
+ {
+ RLOGD("incoming char error");
+ return -1;
+ }
+ char linebuffer[PROPBUF_SIZE] = {0};
+ char buffer1[PROPBUF_SIZE] = {0};
+ char buffer2[PROPBUF_SIZE] = {0};
+
+ int line_len = 0;
+ int len = 0;
+ int res;
+ int changed = 0;
+ FILE *fp = NULL;
+
+ if (0 != access(file_name, F_OK)) { // if file is not exit, create file
+ RLOGD("access file error(%s), Try to create file", file_name);
+
+ fp = fopen(file_name, "w"); //Create file
+ if (fp == NULL) {
+ RLOGD("create file %s fail(%s)", file_name, strerror(errno));
+ return -1;
+ }
+ } else {
+ fp = fopen(file_name, "r+"); //Read and write
+ if(fp == NULL)
+ {
+ RLOGD("open error, %s", strerror(errno));
+ return -1;
+ }
+ }
+
+ while(fgets(linebuffer, PROPBUF_SIZE, fp)) {
+ line_len = strlen(linebuffer);
+ len += line_len;
+ sscanf(linebuffer, "%[^=]=%[^=]", buffer1,buffer2);
+ RLOGD("buffer1:%s, buffer2:%s", buffer1, buffer2);
+ if(!strcmp(key, buffer1)) {
+ len -= strlen(linebuffer);
+ res = fseek(fp, len, SEEK_SET);
+ if(res < 0) {
+ RLOGD("fseek fail, %s", strerror(errno));
+ fclose(fp);
+ return -1;
+ }
+ RLOGD("Before modify [%s=%s] in file [%s]", buffer1, buffer2, file_name);
+ memset(buffer2, 0, PROPBUF_SIZE);
+ LYNQ_STRNCPY(buffer2, val, PROPBUF_SIZE);
+ strncat(buffer1, "=", PROPBUF_SIZE - strlen(buffer1) - 1);
+ strncat(buffer1, buffer2, PROPBUF_SIZE - strlen(buffer1) - 1);
+ strncat(buffer1, "\n", PROPBUF_SIZE - strlen(buffer1) - 1);
+ RLOGD("After modify [%s] in file [%s]", buffer1, file_name);
+ changed = 1;
+ fprintf(fp, "%s", buffer1);
+ fclose(fp);
+ return 0;
+ }
+ }
+ if(changed == 0) { //Not find key
+ memset(linebuffer, 0, PROPBUF_SIZE);
+ strncat(linebuffer, "\n", PROPBUF_SIZE - strlen(linebuffer) - 1);
+ strncat(linebuffer, key, PROPBUF_SIZE - strlen(linebuffer) - 1);
+ strncat(linebuffer, "=", PROPBUF_SIZE - strlen(linebuffer) - 1);
+ strncat(linebuffer, val, PROPBUF_SIZE - strlen(linebuffer) - 1);
+ strncat(linebuffer, "\n", PROPBUF_SIZE - strlen(buffer1) - 1);
+ RLOGD("Add config [%s] to file [%s]", linebuffer, file_name);
+ res = fseek(fp, 0, SEEK_END);
+ if(res < 0) {
+ RLOGD("fseek fail, %s", strerror(errno));
+ fclose(fp);
+ return -1;
+ }
+ fprintf(fp, "%s", linebuffer);
+
+ fclose(fp);
+ }
+ return 0;
+}
+
+void mnld_write_cfg(char* key, char* val) {
+ int idx;
+ int cnt = sizeof(mnl_prop_path)/sizeof(mnl_prop_path[0]);
+
+ for (idx = 0; idx < cnt; idx++) {
+ if (!write_prop(mnl_prop_path[idx], key, val))
+ break;
+ }
+}
\ No newline at end of file
diff --git a/IC_src/mtk/lib/liblynq-gnss/src/lynq_prop.h b/IC_src/mtk/lib/liblynq-gnss/src/lynq_prop.h
new file mode 100755
index 0000000..cad51bf
--- /dev/null
+++ b/IC_src/mtk/lib/liblynq-gnss/src/lynq_prop.h
@@ -0,0 +1,27 @@
+#ifndef LYNQ_PROP_H
+#define LYNQ_PROP_H
+
+#ifdef _cplusplus
+extern "C" {
+#endif
+
+#define MTK_GPS_DATA_PATH "\"/etc/gnss/\""
+
+#define LYNQ_STRNCPY(dst,src,size) do{\
+ strncpy((char *)(dst), (char *)(src), (size - 1));\
+ (dst)[size - 1] = '\0';\
+ }while(0)
+
+
+
+#define F_OK 0
+
+int write_prop(const char *file_name, char* key, char* val);
+
+void mnld_write_cfg(char* key, char* val);
+
+#ifdef _cplusplus
+}
+#endif
+
+#endif