1/* Copyright (c) 2011-2014, The Linux Foundation. All rights reserved.
2 *
3 * Redistribution and use in source and binary forms, with or without
4 * modification, are permitted provided that the following conditions are
5 * met:
6 *     * Redistributions of source code must retain the above copyright
7 *       notice, this list of conditions and the following disclaimer.
8 *     * Redistributions in binary form must reproduce the above
9 *       copyright notice, this list of conditions and the following
10 *       disclaimer in the documentation and/or other materials provided
11 *       with the distribution.
12 *     * Neither the name of The Linux Foundation, nor the names of its
13 *       contributors may be used to endorse or promote products derived
14 *       from this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
17 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
18 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
19 * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
20 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
23 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
24 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
25 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
26 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 *
28 */
29
30#define LOG_NDDEBUG 0
31#define LOG_TAG "LocSvc_afw"
32
33#include <hardware/gps.h>
34#include <gps_extended.h>
35#include <loc_eng.h>
36#include <loc_target.h>
37#include <loc_log.h>
38#include <fcntl.h>
39#include <errno.h>
40#include <dlfcn.h>
41#include <sys/types.h>
42#include <sys/stat.h>
43#include <fcntl.h>
44#include <errno.h>
45#include <LocDualContext.h>
46#include <cutils/properties.h>
47
48using namespace loc_core;
49
50//Globals defns
51static gps_location_callback gps_loc_cb = NULL;
52static gps_sv_status_callback gps_sv_cb = NULL;
53static agps_status_callback agps_status_cb = NULL;
54
55static void local_loc_cb(UlpLocation* location, void* locExt);
56static void local_sv_cb(GpsSvStatus* sv_status, void* svExt);
57static void loc_agps_status_cb(AGpsStatus* status);
58
59static const GpsGeofencingInterface* get_geofence_interface(void);
60
61// Function declarations for sLocEngInterface
62static int  loc_init(GpsCallbacks* callbacks);
63static int  loc_start();
64static int  loc_stop();
65static void loc_cleanup();
66static int  loc_inject_time(GpsUtcTime time, int64_t timeReference, int uncertainty);
67static int  loc_inject_location(double latitude, double longitude, float accuracy);
68static void loc_delete_aiding_data(GpsAidingData f);
69static int  loc_set_position_mode(GpsPositionMode mode, GpsPositionRecurrence recurrence,
70                                  uint32_t min_interval, uint32_t preferred_accuracy,
71                                  uint32_t preferred_time);
72static const void* loc_get_extension(const char* name);
73static void loc_close_mdm_node();
74// Defines the GpsInterface in gps.h
75static const GpsInterface sLocEngInterface =
76{
77   sizeof(GpsInterface),
78   loc_init,
79   loc_start,
80   loc_stop,
81   loc_cleanup,
82   loc_inject_time,
83   loc_inject_location,
84   loc_delete_aiding_data,
85   loc_set_position_mode,
86   loc_get_extension
87};
88
89// Function declarations for sLocEngAGpsInterface
90static void loc_agps_init(AGpsCallbacks* callbacks);
91static int  loc_agps_open(const char* apn);
92static int  loc_agps_closed();
93static int  loc_agps_open_failed();
94static int  loc_agps_set_server(AGpsType type, const char *hostname, int port);
95static int  loc_agps_open_with_apniptype( const char* apn, ApnIpType apnIpType);
96
97static const AGpsInterface sLocEngAGpsInterface =
98{
99   sizeof(AGpsInterface),
100   loc_agps_init,
101   loc_agps_open,
102   loc_agps_closed,
103   loc_agps_open_failed,
104   loc_agps_set_server,
105   loc_agps_open_with_apniptype
106};
107
108static int loc_xtra_init(GpsXtraCallbacks* callbacks);
109static int loc_xtra_inject_data(char* data, int length);
110
111static const GpsXtraInterface sLocEngXTRAInterface =
112{
113    sizeof(GpsXtraInterface),
114    loc_xtra_init,
115    loc_xtra_inject_data
116};
117
118static void loc_ni_init(GpsNiCallbacks *callbacks);
119static void loc_ni_respond(int notif_id, GpsUserResponseType user_response);
120
121static const GpsNiInterface sLocEngNiInterface =
122{
123   sizeof(GpsNiInterface),
124   loc_ni_init,
125   loc_ni_respond,
126};
127
128// For shutting down MDM in fusion devices
129static int mdm_fd = -1;
130static int loc_gps_measurement_init(GpsMeasurementCallbacks* callbacks);
131static void loc_gps_measurement_close();
132
133static const GpsMeasurementInterface sLocEngGpsMeasurementInterface =
134{
135    sizeof(GpsMeasurementInterface),
136    loc_gps_measurement_init,
137    loc_gps_measurement_close
138};
139
140static void loc_agps_ril_init( AGpsRilCallbacks* callbacks );
141static void loc_agps_ril_set_ref_location(const AGpsRefLocation *agps_reflocation, size_t sz_struct);
142static void loc_agps_ril_set_set_id(AGpsSetIDType type, const char* setid);
143static void loc_agps_ril_ni_message(uint8_t *msg, size_t len);
144static void loc_agps_ril_update_network_state(int connected, int type, int roaming, const char* extra_info);
145static void loc_agps_ril_update_network_availability(int avaiable, const char* apn);
146
147static const AGpsRilInterface sLocEngAGpsRilInterface =
148{
149   sizeof(AGpsRilInterface),
150   loc_agps_ril_init,
151   loc_agps_ril_set_ref_location,
152   loc_agps_ril_set_set_id,
153   loc_agps_ril_ni_message,
154   loc_agps_ril_update_network_state,
155   loc_agps_ril_update_network_availability
156};
157
158static int loc_agps_install_certificates(const DerEncodedCertificate* certificates,
159                                         size_t length);
160static int loc_agps_revoke_certificates(const Sha1CertificateFingerprint* fingerprints,
161                                        size_t length);
162
163static const SuplCertificateInterface sLocEngAGpsCertInterface =
164{
165    sizeof(SuplCertificateInterface),
166    loc_agps_install_certificates,
167    loc_agps_revoke_certificates
168};
169
170static void loc_configuration_update(const char* config_data, int32_t length);
171
172static const GnssConfigurationInterface sLocEngConfigInterface =
173{
174    sizeof(GnssConfigurationInterface),
175    loc_configuration_update
176};
177
178static loc_eng_data_s_type loc_afw_data;
179static int gss_fd = -1;
180
181/*===========================================================================
182FUNCTION    gps_get_hardware_interface
183
184DESCRIPTION
185   Returns the GPS hardware interaface based on LOC API
186   if GPS is enabled.
187
188DEPENDENCIES
189   None
190
191RETURN VALUE
192   0: success
193
194SIDE EFFECTS
195   N/A
196
197===========================================================================*/
198const GpsInterface* gps_get_hardware_interface ()
199{
200    ENTRY_LOG_CALLFLOW();
201    const GpsInterface* ret_val;
202
203    char propBuf[PROPERTY_VALUE_MAX];
204
205    loc_eng_read_config();
206
207    // check to see if GPS should be disabled
208    property_get("gps.disable", propBuf, "");
209    if (propBuf[0] == '1')
210    {
211        LOC_LOGD("gps_get_interface returning NULL because gps.disable=1\n");
212        ret_val = NULL;
213    } else {
214        ret_val = &sLocEngInterface;
215    }
216
217    loc_eng_read_config();
218
219    EXIT_LOG(%p, ret_val);
220    return ret_val;
221}
222
223// for gps.c
224extern "C" const GpsInterface* get_gps_interface()
225{
226    unsigned int target = TARGET_DEFAULT;
227    loc_eng_read_config();
228
229    target = loc_get_target();
230    LOC_LOGD("Target name check returned %s", loc_get_target_name(target));
231
232    int gnssType = getTargetGnssType(target);
233    switch (gnssType)
234    {
235    case GNSS_GSS:
236        //APQ8064
237        gps_conf.CAPABILITIES &= ~(GPS_CAPABILITY_MSA | GPS_CAPABILITY_MSB);
238        gss_fd = open("/dev/gss", O_RDONLY);
239        if (gss_fd < 0) {
240            LOC_LOGE("GSS open failed: %s\n", strerror(errno));
241        }
242        else {
243            LOC_LOGD("GSS open success! CAPABILITIES %0lx\n",
244                     gps_conf.CAPABILITIES);
245        }
246        break;
247    case GNSS_NONE:
248        //MPQ8064
249        LOC_LOGE("No GPS HW on this target. Not returning interface.");
250        return NULL;
251    case GNSS_QCA1530:
252        // qca1530 chip is present
253        gps_conf.CAPABILITIES &= ~(GPS_CAPABILITY_MSA | GPS_CAPABILITY_MSB);
254        LOC_LOGD("qca1530 present: CAPABILITIES %0lx\n", gps_conf.CAPABILITIES);
255        break;
256    }
257    return &sLocEngInterface;
258}
259
260/*===========================================================================
261FUNCTION    loc_init
262
263DESCRIPTION
264   Initialize the location engine, this include setting up global datas
265   and registers location engien with loc api service.
266
267DEPENDENCIES
268   None
269
270RETURN VALUE
271   0: success
272
273SIDE EFFECTS
274   N/Ax
275
276===========================================================================*/
277static int loc_init(GpsCallbacks* callbacks)
278{
279    int retVal = -1;
280    int i = 0;
281    ENTRY_LOG();
282    LOC_API_ADAPTER_EVENT_MASK_T event;
283
284    if (NULL == callbacks) {
285        LOC_LOGE("loc_init failed. cb = NULL\n");
286        EXIT_LOG(%d, retVal);
287        return retVal;
288    }
289
290    event = LOC_API_ADAPTER_BIT_PARSED_POSITION_REPORT |
291            LOC_API_ADAPTER_BIT_SATELLITE_REPORT |
292            LOC_API_ADAPTER_BIT_LOCATION_SERVER_REQUEST |
293            LOC_API_ADAPTER_BIT_ASSISTANCE_DATA_REQUEST |
294            LOC_API_ADAPTER_BIT_IOCTL_REPORT |
295            LOC_API_ADAPTER_BIT_STATUS_REPORT |
296            LOC_API_ADAPTER_BIT_NMEA_1HZ_REPORT |
297            LOC_API_ADAPTER_BIT_NI_NOTIFY_VERIFY_REQUEST;
298
299    LocCallbacks clientCallbacks = {local_loc_cb, /* location_cb */
300                                    callbacks->status_cb, /* status_cb */
301                                    local_sv_cb, /* sv_status_cb */
302                                    callbacks->nmea_cb, /* nmea_cb */
303                                    callbacks->set_capabilities_cb, /* set_capabilities_cb */
304                                    callbacks->acquire_wakelock_cb, /* acquire_wakelock_cb */
305                                    callbacks->release_wakelock_cb, /* release_wakelock_cb */
306                                    callbacks->create_thread_cb, /* create_thread_cb */
307                                    NULL, /* location_ext_parser */
308                                    NULL, /* sv_ext_parser */
309                                    callbacks->request_utc_time_cb, /* request_utc_time_cb */
310                                    loc_close_mdm_node  /*loc_shutdown_cb*/};
311
312    gps_loc_cb = callbacks->location_cb;
313    gps_sv_cb = callbacks->sv_status_cb;
314
315    retVal = loc_eng_init(loc_afw_data, &clientCallbacks, event, NULL);
316    loc_afw_data.adapter->mSupportsAgpsRequests = !loc_afw_data.adapter->hasAgpsExtendedCapabilities();
317    loc_afw_data.adapter->mSupportsPositionInjection = !loc_afw_data.adapter->hasCPIExtendedCapabilities();
318    loc_afw_data.adapter->setGpsLockMsg(0);
319    loc_afw_data.adapter->requestUlp(gps_conf.CAPABILITIES);
320
321    if(retVal) {
322        LOC_LOGE("loc_eng_init() fail!");
323        goto err;
324    }
325
326    loc_afw_data.adapter->setPowerVoteRight(loc_get_target() == TARGET_QCA1530);
327    loc_afw_data.adapter->setPowerVote(true);
328
329    LOC_LOGD("loc_eng_init() success!");
330
331#ifdef PLATFORM_MSM8084
332    if (mdm_fd < 0) {
333        int (*open_first_external_modem)(void);
334        const char *name = "libdetectmodem.so";
335        const char *func = "open_first_external_modem";
336        const char *error;
337
338        void *lib = ::dlopen(name, RTLD_NOW);
339        error = ::dlerror();
340        if (!lib) {
341            LOC_LOGE("%s: could not find %s: %s", __func__, name, error);
342            goto err;
343        }
344
345        open_first_external_modem = NULL;
346        *(void **)(&open_first_external_modem) = ::dlsym(lib, func);
347        error = ::dlerror();
348
349        if (!open_first_external_modem) {
350            LOC_LOGE("%s: could not find symbol %s in %s: %s",
351                     __func__, func, name, error);
352        }
353        else {
354            errno = 0;
355            mdm_fd = open_first_external_modem();
356            if (mdm_fd < 0) {
357                LOC_LOGE("%s: %s failed: %s\n", __func__, func, strerror(errno));
358            }
359            else {
360                LOC_LOGD("%s: external power up modem opened successfully\n", __func__);
361            }
362        }
363        dlclose(lib);
364    } else {
365        LOC_LOGD("powerup_node has been opened before");
366    }
367#endif //PLATFORM_MSM8084
368err:
369    EXIT_LOG(%d, retVal);
370    return retVal;
371}
372
373/*===========================================================================
374FUNCTION    loc_close_mdm_node
375
376DESCRIPTION
377   closes mdm_fd which is the modem powerup node obtained in loc_init
378
379DEPENDENCIES
380   None
381
382RETURN VALUE
383   None
384
385SIDE EFFECTS
386   N/A
387
388===========================================================================*/
389static void loc_close_mdm_node()
390{
391    ENTRY_LOG();
392    if (mdm_fd >= 0) {
393        LOC_LOGD("closing the powerup node");
394        close(mdm_fd);
395        mdm_fd = -1;
396        LOC_LOGD("finished closing the powerup node");
397    } else {
398        LOC_LOGD("powerup node has not been opened yet.");
399    }
400
401    EXIT_LOG(%s, VOID_RET);
402}
403
404/*===========================================================================
405FUNCTION    loc_cleanup
406
407DESCRIPTION
408   Cleans location engine. The location client handle will be released.
409
410DEPENDENCIES
411   None
412
413RETURN VALUE
414   None
415
416SIDE EFFECTS
417   N/A
418
419===========================================================================*/
420static void loc_cleanup()
421{
422    ENTRY_LOG();
423
424    loc_afw_data.adapter->setPowerVote(false);
425    loc_afw_data.adapter->setGpsLockMsg(gps_conf.GPS_LOCK);
426
427    loc_eng_cleanup(loc_afw_data);
428    loc_close_mdm_node();
429    gps_loc_cb = NULL;
430    gps_sv_cb = NULL;
431
432    EXIT_LOG(%s, VOID_RET);
433}
434
435/*===========================================================================
436FUNCTION    loc_start
437
438DESCRIPTION
439   Starts the tracking session
440
441DEPENDENCIES
442   None
443
444RETURN VALUE
445   0: success
446
447SIDE EFFECTS
448   N/A
449
450===========================================================================*/
451static int loc_start()
452{
453    ENTRY_LOG();
454    int ret_val = loc_eng_start(loc_afw_data);
455
456    EXIT_LOG(%d, ret_val);
457    return ret_val;
458}
459
460/*===========================================================================
461FUNCTION    loc_stop
462
463DESCRIPTION
464   Stops the tracking session
465
466DEPENDENCIES
467   None
468
469RETURN VALUE
470   0: success
471
472SIDE EFFECTS
473   N/A
474
475===========================================================================*/
476static int loc_stop()
477{
478    ENTRY_LOG();
479    int ret_val = -1;
480    ret_val = loc_eng_stop(loc_afw_data);
481
482    EXIT_LOG(%d, ret_val);
483    return ret_val;
484}
485
486/*===========================================================================
487FUNCTION    loc_set_position_mode
488
489DESCRIPTION
490   Sets the mode and fix frequency for the tracking session.
491
492DEPENDENCIES
493   None
494
495RETURN VALUE
496   0: success
497
498SIDE EFFECTS
499   N/A
500
501===========================================================================*/
502static int  loc_set_position_mode(GpsPositionMode mode,
503                                  GpsPositionRecurrence recurrence,
504                                  uint32_t min_interval,
505                                  uint32_t preferred_accuracy,
506                                  uint32_t preferred_time)
507{
508    ENTRY_LOG();
509    int ret_val = -1;
510    LocPositionMode locMode;
511    switch (mode) {
512    case GPS_POSITION_MODE_MS_BASED:
513        locMode = LOC_POSITION_MODE_MS_BASED;
514        break;
515    case GPS_POSITION_MODE_MS_ASSISTED:
516        locMode = LOC_POSITION_MODE_MS_ASSISTED;
517        break;
518    default:
519        locMode = LOC_POSITION_MODE_STANDALONE;
520        break;
521    }
522
523    LocPosMode params(locMode, recurrence, min_interval,
524                      preferred_accuracy, preferred_time, NULL, NULL);
525    ret_val = loc_eng_set_position_mode(loc_afw_data, params);
526
527    EXIT_LOG(%d, ret_val);
528    return ret_val;
529}
530
531/*===========================================================================
532FUNCTION    loc_inject_time
533
534DESCRIPTION
535   This is used by Java native function to do time injection.
536
537DEPENDENCIES
538   None
539
540RETURN VALUE
541   0
542
543SIDE EFFECTS
544   N/A
545
546===========================================================================*/
547static int loc_inject_time(GpsUtcTime time, int64_t timeReference, int uncertainty)
548{
549    ENTRY_LOG();
550    int ret_val = 0;
551
552    ret_val = loc_eng_inject_time(loc_afw_data, time,
553                                  timeReference, uncertainty);
554
555    EXIT_LOG(%d, ret_val);
556    return ret_val;
557}
558
559
560/*===========================================================================
561FUNCTION    loc_inject_location
562
563DESCRIPTION
564   This is used by Java native function to do location injection.
565
566DEPENDENCIES
567   None
568
569RETURN VALUE
570   0          : Successful
571   error code : Failure
572
573SIDE EFFECTS
574   N/A
575===========================================================================*/
576static int loc_inject_location(double latitude, double longitude, float accuracy)
577{
578    static bool initialized = false;
579    static bool enable_cpi = true;
580    ENTRY_LOG();
581
582    if (accuracy < 1000)
583    {
584      accuracy = 1000;
585    }
586
587    int ret_val = 0;
588    ret_val = loc_eng_inject_location(loc_afw_data, latitude, longitude, accuracy);
589
590    if(!initialized)
591    {
592        char value[PROPERTY_VALUE_MAX];
593        memset(value, 0, sizeof(value));
594        (void)property_get("persist.gps.qc_nlp_in_use", value, "0");
595        if(0 == strcmp(value, "1"))
596        {
597            enable_cpi = false;
598            LOC_LOGI("GPS HAL coarse position injection disabled");
599        }
600        else
601        {
602            LOC_LOGI("GPS HAL coarse position injection enabled");
603        }
604        initialized = true;
605    }
606
607    if(enable_cpi)
608    {
609      ret_val = loc_eng_inject_location(loc_afw_data, latitude, longitude, accuracy);
610    }
611    EXIT_LOG(%d, ret_val);
612    return ret_val;
613}
614
615
616/*===========================================================================
617FUNCTION    loc_delete_aiding_data
618
619DESCRIPTION
620   This is used by Java native function to delete the aiding data. The function
621   updates the global variable for the aiding data to be deleted. If the GPS
622   engine is off, the aiding data will be deleted. Otherwise, the actual action
623   will happen when gps engine is turned off.
624
625DEPENDENCIES
626   Assumes the aiding data type specified in GpsAidingData matches with
627   LOC API specification.
628
629RETURN VALUE
630   None
631
632SIDE EFFECTS
633   N/A
634
635===========================================================================*/
636static void loc_delete_aiding_data(GpsAidingData f)
637{
638    ENTRY_LOG();
639    loc_eng_delete_aiding_data(loc_afw_data, f);
640
641    EXIT_LOG(%s, VOID_RET);
642}
643
644const GpsGeofencingInterface* get_geofence_interface(void)
645{
646    ENTRY_LOG();
647    void *handle;
648    const char *error;
649    typedef const GpsGeofencingInterface* (*get_gps_geofence_interface_function) (void);
650    get_gps_geofence_interface_function get_gps_geofence_interface;
651    static const GpsGeofencingInterface* geofence_interface = NULL;
652
653    dlerror();    /* Clear any existing error */
654
655    handle = dlopen ("libgeofence.so", RTLD_NOW);
656
657    if (!handle)
658    {
659        if ((error = dlerror()) != NULL)  {
660            LOC_LOGE ("%s, dlopen for libgeofence.so failed, error = %s\n", __func__, error);
661           }
662        goto exit;
663    }
664    dlerror();    /* Clear any existing error */
665    get_gps_geofence_interface = (get_gps_geofence_interface_function)dlsym(handle, "gps_geofence_get_interface");
666    if ((error = dlerror()) != NULL)  {
667        LOC_LOGE ("%s, dlsym for get_gps_geofence_interface failed, error = %s\n", __func__, error);
668        goto exit;
669     }
670
671    geofence_interface = get_gps_geofence_interface();
672
673exit:
674    EXIT_LOG(%d, geofence_interface == NULL);
675    return geofence_interface;
676}
677/*===========================================================================
678FUNCTION    loc_get_extension
679
680DESCRIPTION
681   Get the gps extension to support XTRA.
682
683DEPENDENCIES
684   N/A
685
686RETURN VALUE
687   The GPS extension interface.
688
689SIDE EFFECTS
690   N/A
691
692===========================================================================*/
693const void* loc_get_extension(const char* name)
694{
695    ENTRY_LOG();
696    const void* ret_val = NULL;
697
698   LOC_LOGD("%s:%d] For Interface = %s\n",__func__, __LINE__, name);
699   if (strcmp(name, GPS_XTRA_INTERFACE) == 0)
700   {
701       ret_val = &sLocEngXTRAInterface;
702   }
703   else if (strcmp(name, AGPS_INTERFACE) == 0)
704   {
705       ret_val = &sLocEngAGpsInterface;
706   }
707   else if (strcmp(name, GPS_NI_INTERFACE) == 0)
708   {
709       ret_val = &sLocEngNiInterface;
710   }
711   else if (strcmp(name, AGPS_RIL_INTERFACE) == 0)
712   {
713       char baseband[PROPERTY_VALUE_MAX];
714       property_get("ro.baseband", baseband, "msm");
715       if (strcmp(baseband, "csfb") == 0)
716       {
717           ret_val = &sLocEngAGpsRilInterface;
718       }
719   }
720   else if (strcmp(name, GPS_GEOFENCING_INTERFACE) == 0)
721   {
722       if ((gps_conf.CAPABILITIES | GPS_CAPABILITY_GEOFENCING) == gps_conf.CAPABILITIES ){
723           ret_val = get_geofence_interface();
724       }
725   }
726   else if (strcmp(name, SUPL_CERTIFICATE_INTERFACE) == 0)
727   {
728       ret_val = &sLocEngAGpsCertInterface;
729   }
730   else if (strcmp(name, GNSS_CONFIGURATION_INTERFACE) == 0)
731   {
732       ret_val = &sLocEngConfigInterface;
733   }
734   else if (strcmp(name, GPS_MEASUREMENT_INTERFACE) == 0)
735   {
736       ret_val = &sLocEngGpsMeasurementInterface;
737   }
738   else
739   {
740      LOC_LOGE ("get_extension: Invalid interface passed in\n");
741   }
742    EXIT_LOG(%p, ret_val);
743    return ret_val;
744}
745
746/*===========================================================================
747FUNCTION    loc_agps_init
748
749DESCRIPTION
750   Initialize the AGps interface.
751
752DEPENDENCIES
753   NONE
754
755RETURN VALUE
756   0
757
758SIDE EFFECTS
759   N/A
760
761===========================================================================*/
762static void loc_agps_init(AGpsCallbacks* callbacks)
763{
764    ENTRY_LOG();
765    if (agps_status_cb == NULL) {
766        agps_status_cb = callbacks->status_cb;
767        callbacks->status_cb = loc_agps_status_cb;
768    }
769    loc_eng_agps_init(loc_afw_data, (AGpsExtCallbacks*)callbacks);
770    EXIT_LOG(%s, VOID_RET);
771}
772
773/*===========================================================================
774FUNCTION    loc_agps_open
775
776DESCRIPTION
777   This function is called when on-demand data connection opening is successful.
778It should inform ARM 9 about the data open result.
779
780DEPENDENCIES
781   NONE
782
783RETURN VALUE
784   0
785
786SIDE EFFECTS
787   N/A
788
789===========================================================================*/
790static int loc_agps_open(const char* apn)
791{
792    ENTRY_LOG();
793    AGpsType agpsType = AGPS_TYPE_SUPL;
794    AGpsBearerType bearerType = AGPS_APN_BEARER_IPV4;
795    int ret_val = loc_eng_agps_open(loc_afw_data, agpsType, apn, bearerType);
796
797    EXIT_LOG(%d, ret_val);
798    return ret_val;
799}
800
801/*===========================================================================
802FUNCTION    loc_agps_open_with_apniptype
803
804DESCRIPTION
805   This function is called when on-demand data connection opening is successful.
806It should inform ARM 9 about the data open result.
807
808DEPENDENCIES
809   NONE
810
811RETURN VALUE
812   0
813
814SIDE EFFECTS
815   N/A
816
817===========================================================================*/
818static int  loc_agps_open_with_apniptype(const char* apn, ApnIpType apnIpType)
819{
820    ENTRY_LOG();
821    AGpsType agpsType = AGPS_TYPE_SUPL;
822    AGpsBearerType bearerType;
823
824    switch (apnIpType) {
825        case APN_IP_IPV4:
826            bearerType = AGPS_APN_BEARER_IPV4;
827            break;
828        case APN_IP_IPV6:
829            bearerType = AGPS_APN_BEARER_IPV6;
830            break;
831        case APN_IP_IPV4V6:
832            bearerType = AGPS_APN_BEARER_IPV4V6;
833            break;
834        default:
835            bearerType = AGPS_APN_BEARER_IPV4;
836            break;
837    }
838
839    int ret_val = loc_eng_agps_open(loc_afw_data, agpsType, apn, bearerType);
840
841    EXIT_LOG(%d, ret_val);
842    return ret_val;
843}
844
845/*===========================================================================
846FUNCTION    loc_agps_closed
847
848DESCRIPTION
849   This function is called when on-demand data connection closing is done.
850It should inform ARM 9 about the data close result.
851
852DEPENDENCIES
853   NONE
854
855RETURN VALUE
856   0
857
858SIDE EFFECTS
859   N/A
860
861===========================================================================*/
862static int loc_agps_closed()
863{
864    ENTRY_LOG();
865    AGpsType agpsType = AGPS_TYPE_SUPL;
866    int ret_val = loc_eng_agps_closed(loc_afw_data, agpsType);
867
868    EXIT_LOG(%d, ret_val);
869    return ret_val;
870}
871
872/*===========================================================================
873FUNCTION    loc_agps_open_failed
874
875DESCRIPTION
876   This function is called when on-demand data connection opening has failed.
877It should inform ARM 9 about the data open result.
878
879DEPENDENCIES
880   NONE
881
882RETURN VALUE
883   0
884
885SIDE EFFECTS
886   N/A
887
888===========================================================================*/
889int loc_agps_open_failed()
890{
891    ENTRY_LOG();
892    AGpsType agpsType = AGPS_TYPE_SUPL;
893    int ret_val = loc_eng_agps_open_failed(loc_afw_data, agpsType);
894
895    EXIT_LOG(%d, ret_val);
896    return ret_val;
897}
898
899/*===========================================================================
900FUNCTION    loc_agps_set_server
901
902DESCRIPTION
903   If loc_eng_set_server is called before loc_eng_init, it doesn't work. This
904   proxy buffers server settings and calls loc_eng_set_server when the client is
905   open.
906
907DEPENDENCIES
908   NONE
909
910RETURN VALUE
911   0
912
913SIDE EFFECTS
914   N/A
915
916===========================================================================*/
917static int loc_agps_set_server(AGpsType type, const char* hostname, int port)
918{
919    ENTRY_LOG();
920    LocServerType serverType;
921    switch (type) {
922    case AGPS_TYPE_SUPL:
923        serverType = LOC_AGPS_SUPL_SERVER;
924        break;
925    case AGPS_TYPE_C2K:
926        serverType = LOC_AGPS_CDMA_PDE_SERVER;
927        break;
928    default:
929        serverType = LOC_AGPS_SUPL_SERVER;
930    }
931    int ret_val = loc_eng_set_server_proxy(loc_afw_data, serverType, hostname, port);
932
933    EXIT_LOG(%d, ret_val);
934    return ret_val;
935}
936
937/*===========================================================================
938FUNCTIONf571
939    loc_xtra_init
940
941DESCRIPTION
942   Initialize XTRA module.
943
944DEPENDENCIES
945   None
946
947RETURN VALUE
948   0: success
949
950SIDE EFFECTS
951   N/A
952
953===========================================================================*/
954static int loc_xtra_init(GpsXtraCallbacks* callbacks)
955{
956    ENTRY_LOG();
957    int ret_val = loc_eng_xtra_init(loc_afw_data, (GpsXtraExtCallbacks*)callbacks);
958
959    EXIT_LOG(%d, ret_val);
960    return ret_val;
961}
962
963
964/*===========================================================================
965FUNCTION    loc_xtra_inject_data
966
967DESCRIPTION
968   Initialize XTRA module.
969
970DEPENDENCIES
971   None
972
973RETURN VALUE
974   0: success
975
976SIDE EFFECTS
977   N/A
978
979===========================================================================*/
980static int loc_xtra_inject_data(char* data, int length)
981{
982    ENTRY_LOG();
983    int ret_val = -1;
984    if( (data != NULL) && ((unsigned int)length <= XTRA_DATA_MAX_SIZE))
985        ret_val = loc_eng_xtra_inject_data(loc_afw_data, data, length);
986    else
987        LOC_LOGE("%s, Could not inject XTRA data. Buffer address: %p, length: %d",
988                __func__, data, length);
989    EXIT_LOG(%d, ret_val);
990    return ret_val;
991}
992
993/*===========================================================================
994FUNCTION    loc_gps_measurement_init
995
996DESCRIPTION
997   This function initializes the gps measurement interface
998
999DEPENDENCIES
1000   NONE
1001
1002RETURN VALUE
1003   None
1004
1005SIDE EFFECTS
1006   N/A
1007
1008===========================================================================*/
1009static int loc_gps_measurement_init(GpsMeasurementCallbacks* callbacks)
1010{
1011    ENTRY_LOG();
1012    int ret_val = loc_eng_gps_measurement_init(loc_afw_data,
1013                                               callbacks);
1014
1015    EXIT_LOG(%d, ret_val);
1016    return ret_val;
1017}
1018
1019/*===========================================================================
1020FUNCTION    loc_gps_measurement_close
1021
1022DESCRIPTION
1023   This function closes the gps measurement interface
1024
1025DEPENDENCIES
1026   NONE
1027
1028RETURN VALUE
1029   None
1030
1031SIDE EFFECTS
1032   N/A
1033
1034===========================================================================*/
1035static void loc_gps_measurement_close()
1036{
1037    ENTRY_LOG();
1038    loc_eng_gps_measurement_close(loc_afw_data);
1039
1040    EXIT_LOG(%s, VOID_RET);
1041}
1042
1043/*===========================================================================
1044FUNCTION    loc_ni_init
1045
1046DESCRIPTION
1047   This function initializes the NI interface
1048
1049DEPENDENCIES
1050   NONE
1051
1052RETURN VALUE
1053   None
1054
1055SIDE EFFECTS
1056   N/A
1057
1058===========================================================================*/
1059void loc_ni_init(GpsNiCallbacks *callbacks)
1060{
1061    ENTRY_LOG();
1062    loc_eng_ni_init(loc_afw_data,(GpsNiExtCallbacks*) callbacks);
1063    EXIT_LOG(%s, VOID_RET);
1064}
1065
1066/*===========================================================================
1067FUNCTION    loc_ni_respond
1068
1069DESCRIPTION
1070   This function sends an NI respond to the modem processor
1071
1072DEPENDENCIES
1073   NONE
1074
1075RETURN VALUE
1076   None
1077
1078SIDE EFFECTS
1079   N/A
1080
1081===========================================================================*/
1082void loc_ni_respond(int notif_id, GpsUserResponseType user_response)
1083{
1084    ENTRY_LOG();
1085    loc_eng_ni_respond(loc_afw_data, notif_id, user_response);
1086    EXIT_LOG(%s, VOID_RET);
1087}
1088
1089// Below stub functions are members of sLocEngAGpsRilInterface
1090static void loc_agps_ril_init( AGpsRilCallbacks* callbacks ) {}
1091static void loc_agps_ril_set_ref_location(const AGpsRefLocation *agps_reflocation, size_t sz_struct) {}
1092static void loc_agps_ril_set_set_id(AGpsSetIDType type, const char* setid) {}
1093static void loc_agps_ril_ni_message(uint8_t *msg, size_t len) {}
1094static void loc_agps_ril_update_network_state(int connected, int type, int roaming, const char* extra_info) {}
1095
1096/*===========================================================================
1097FUNCTION    loc_agps_ril_update_network_availability
1098
1099DESCRIPTION
1100   Sets data call allow vs disallow flag to modem
1101   This is the only member of sLocEngAGpsRilInterface implemented.
1102
1103DEPENDENCIES
1104   None
1105
1106RETURN VALUE
1107   0: success
1108
1109SIDE EFFECTS
1110   N/A
1111
1112===========================================================================*/
1113static void loc_agps_ril_update_network_availability(int available, const char* apn)
1114{
1115    ENTRY_LOG();
1116    loc_eng_agps_ril_update_network_availability(loc_afw_data, available, apn);
1117    EXIT_LOG(%s, VOID_RET);
1118}
1119
1120static int loc_agps_install_certificates(const DerEncodedCertificate* certificates,
1121                                         size_t length)
1122{
1123    ENTRY_LOG();
1124    int ret_val = loc_eng_agps_install_certificates(loc_afw_data, certificates, length);
1125    EXIT_LOG(%d, ret_val);
1126    return ret_val;
1127}
1128static int loc_agps_revoke_certificates(const Sha1CertificateFingerprint* fingerprints,
1129                                        size_t length)
1130{
1131    ENTRY_LOG();
1132    LOC_LOGE("agps_revoke_certificates not supported");
1133    int ret_val = AGPS_CERTIFICATE_ERROR_GENERIC;
1134    EXIT_LOG(%d, ret_val);
1135    return ret_val;
1136}
1137
1138static void loc_configuration_update(const char* config_data, int32_t length)
1139{
1140    ENTRY_LOG();
1141    loc_eng_configuration_update(loc_afw_data, config_data, length);
1142    EXIT_LOG(%s, VOID_RET);
1143}
1144
1145static void local_loc_cb(UlpLocation* location, void* locExt)
1146{
1147    ENTRY_LOG();
1148    if (NULL != location) {
1149        CALLBACK_LOG_CALLFLOW("location_cb - from", %d, location->position_source);
1150
1151        if (NULL != gps_loc_cb) {
1152            gps_loc_cb(&location->gpsLocation);
1153        }
1154    }
1155    EXIT_LOG(%s, VOID_RET);
1156}
1157
1158static void local_sv_cb(GpsSvStatus* sv_status, void* svExt)
1159{
1160    ENTRY_LOG();
1161    if (NULL != gps_sv_cb) {
1162        CALLBACK_LOG_CALLFLOW("sv_status_cb -", %d, sv_status->num_svs);
1163        gps_sv_cb(sv_status);
1164    }
1165    EXIT_LOG(%s, VOID_RET);
1166}
1167
1168static void loc_agps_status_cb(AGpsStatus* status)
1169{
1170    ENTRY_LOG();
1171
1172    if (NULL != agps_status_cb) {
1173        size_t realSize = sizeof(AGpsStatus);
1174        LOC_LOGD("agps_status size=%d real-size=%d", status->size, realSize);
1175        status->size = realSize;
1176        agps_status_cb(status);
1177    }
1178    EXIT_LOG(%s, VOID_RET);
1179}
1180
1181