1/* Copyright (c) 2011 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_api_rpc_glue"
32
33#include "loc_api_log.h"
34#include "loc_log.h"
35#include "log_util.h"
36#include "platform_lib_includes.h"
37#include "rpc/rpc.h"
38#include "loc_api_fixup.h"
39
40/* Event names */
41loc_name_val_s_type loc_event_name[] =
42   {
43      NAME_VAL( RPC_LOC_EVENT_PARSED_POSITION_REPORT ),
44      NAME_VAL( RPC_LOC_EVENT_SATELLITE_REPORT ),
45      NAME_VAL( RPC_LOC_EVENT_NMEA_1HZ_REPORT ),
46      NAME_VAL( RPC_LOC_EVENT_NMEA_POSITION_REPORT ),
47      NAME_VAL( RPC_LOC_EVENT_NI_NOTIFY_VERIFY_REQUEST ),
48      NAME_VAL( RPC_LOC_EVENT_ASSISTANCE_DATA_REQUEST ),
49      NAME_VAL( RPC_LOC_EVENT_LOCATION_SERVER_REQUEST ),
50      NAME_VAL( RPC_LOC_EVENT_IOCTL_REPORT ),
51      NAME_VAL( RPC_LOC_EVENT_STATUS_REPORT ),
52      NAME_VAL( RPC_LOC_EVENT_WPS_NEEDED_REQUEST ),
53   };
54int loc_event_num = sizeof loc_event_name / sizeof(loc_name_val_s_type);
55
56/* Event names */
57loc_name_val_s_type loc_event_atl_open_name[] =
58   {
59      NAME_VAL( RPC_LOC_SERVER_REQUEST_OPEN ),
60      NAME_VAL( RPC_LOC_SERVER_REQUEST_CLOSE ),
61      NAME_VAL( RPC_LOC_SERVER_REQUEST_MULTI_OPEN )
62   };
63int loc_event_atl_open_num = sizeof loc_event_atl_open_name / sizeof(loc_name_val_s_type);
64
65/* Finds the first event found in the mask */
66const char* loc_get_event_atl_open_name(rpc_loc_server_request_e_type loc_event_atl_open)
67{
68   return loc_get_name_from_val(loc_event_atl_open_name, loc_event_atl_open_num,
69         (long) loc_event_atl_open);
70}
71
72/* IOCTL Type names */
73loc_name_val_s_type loc_ioctl_type_name[] =
74   {
75      NAME_VAL( RPC_LOC_IOCTL_GET_API_VERSION ),
76      NAME_VAL( RPC_LOC_IOCTL_SET_FIX_CRITERIA ),
77      NAME_VAL( RPC_LOC_IOCTL_GET_FIX_CRITERIA ),
78      NAME_VAL( RPC_LOC_IOCTL_INFORM_NI_USER_RESPONSE ),
79      NAME_VAL( RPC_LOC_IOCTL_INJECT_PREDICTED_ORBITS_DATA ),
80      NAME_VAL( RPC_LOC_IOCTL_QUERY_PREDICTED_ORBITS_DATA_VALIDITY ),
81      NAME_VAL( RPC_LOC_IOCTL_QUERY_PREDICTED_ORBITS_DATA_SOURCE ),
82      NAME_VAL( RPC_LOC_IOCTL_SET_PREDICTED_ORBITS_DATA_AUTO_DOWNLOAD ),
83      NAME_VAL( RPC_LOC_IOCTL_INJECT_UTC_TIME ),
84      NAME_VAL( RPC_LOC_IOCTL_INJECT_RTC_VALUE ),
85      NAME_VAL( RPC_LOC_IOCTL_INJECT_POSITION ),
86      NAME_VAL( RPC_LOC_IOCTL_QUERY_ENGINE_STATE ),
87      NAME_VAL( RPC_LOC_IOCTL_ERROR_ESTIMATE_CONFIG),
88      NAME_VAL( RPC_LOC_IOCTL_INFORM_SERVER_MULTI_OPEN_STATUS ),
89      NAME_VAL( RPC_LOC_IOCTL_INFORM_SERVER_OPEN_STATUS ),
90      NAME_VAL( RPC_LOC_IOCTL_INFORM_SERVER_CLOSE_STATUS ),
91      NAME_VAL( RPC_LOC_IOCTL_SEND_WIPER_POSITION_REPORT ),
92      NAME_VAL( RPC_LOC_IOCTL_NOTIFY_WIPER_STATUS ),
93      NAME_VAL( RPC_LOC_IOCTL_SET_ENGINE_LOCK ),
94      NAME_VAL( RPC_LOC_IOCTL_GET_ENGINE_LOCK ),
95      NAME_VAL( RPC_LOC_IOCTL_SET_SBAS_CONFIG ),
96      NAME_VAL( RPC_LOC_IOCTL_GET_SBAS_CONFIG ),
97      NAME_VAL( RPC_LOC_IOCTL_SET_NMEA_TYPES ),
98      NAME_VAL( RPC_LOC_IOCTL_GET_NMEA_TYPES ),
99      NAME_VAL( RPC_LOC_IOCTL_SET_CDMA_PDE_SERVER_ADDR ),
100      NAME_VAL( RPC_LOC_IOCTL_GET_CDMA_PDE_SERVER_ADDR ),
101      NAME_VAL( RPC_LOC_IOCTL_SET_CDMA_MPC_SERVER_ADDR ),
102      NAME_VAL( RPC_LOC_IOCTL_GET_CDMA_MPC_SERVER_ADDR ),
103      NAME_VAL( RPC_LOC_IOCTL_SET_UMTS_SLP_SERVER_ADDR ),
104      NAME_VAL( RPC_LOC_IOCTL_GET_UMTS_SLP_SERVER_ADDR ),
105      NAME_VAL( RPC_LOC_IOCTL_SET_ON_DEMAND_LPM ),
106      NAME_VAL( RPC_LOC_IOCTL_GET_ON_DEMAND_LPM ),
107      NAME_VAL( RPC_LOC_IOCTL_SET_XTRA_T_SESSION_CONTROL ),
108      NAME_VAL( RPC_LOC_IOCTL_GET_XTRA_T_SESSION_CONTROL ),
109      NAME_VAL( RPC_LOC_IOCTL_SET_LBS_APN_PROFILE ),
110      NAME_VAL( RPC_LOC_IOCTL_GET_LBS_APN_PROFILE ),
111      NAME_VAL( RPC_LOC_IOCTL_SET_XTRA_APN_PROFILE ),
112      NAME_VAL( RPC_LOC_IOCTL_GET_XTRA_APN_PROFILE ),
113      NAME_VAL( RPC_LOC_IOCTL_SET_DATA_ENABLE ),
114      NAME_VAL( RPC_LOC_IOCTL_SET_SUPL_VERSION ),
115      NAME_VAL( RPC_LOC_IOCTL_GET_SUPL_VERSION ),
116      NAME_VAL( RPC_LOC_IOCTL_DELETE_ASSIST_DATA ),
117      NAME_VAL( RPC_LOC_IOCTL_SET_CUSTOM_PDE_SERVER_ADDR ),
118      NAME_VAL( RPC_LOC_IOCTL_GET_CUSTOM_PDE_SERVER_ADDR ),
119   };
120int loc_ioctl_type_num = sizeof loc_ioctl_type_name / sizeof(loc_name_val_s_type);
121
122/* IOCTL Status names */
123loc_name_val_s_type loc_ioctl_status_name[] =
124   {
125      NAME_VAL( RPC_LOC_API_SUCCESS ),
126      NAME_VAL( RPC_LOC_API_GENERAL_FAILURE ),
127      NAME_VAL( RPC_LOC_API_UNSUPPORTED ),
128      NAME_VAL( RPC_LOC_API_INVALID_HANDLE ),
129      NAME_VAL( RPC_LOC_API_INVALID_PARAMETER ),
130      NAME_VAL( RPC_LOC_API_ENGINE_BUSY ),
131      NAME_VAL( RPC_LOC_API_PHONE_OFFLINE ),
132      NAME_VAL( RPC_LOC_API_TIMEOUT ),
133      NAME_VAL( RPC_LOC_API_RPC_FAILURE ),
134      NAME_VAL( RPC_LOC_API_RPC_MODEM_RESTART )
135   };
136int loc_ioctl_status_num = sizeof loc_ioctl_status_name / sizeof(loc_name_val_s_type);
137
138/* Fix session status names */
139loc_name_val_s_type loc_sess_status_name[] =
140   {
141      NAME_VAL( RPC_LOC_SESS_STATUS_SUCCESS ),
142      NAME_VAL( RPC_LOC_SESS_STATUS_IN_PROGESS ),
143      NAME_VAL( RPC_LOC_SESS_STATUS_GENERAL_FAILURE ),
144      NAME_VAL( RPC_LOC_SESS_STATUS_TIMEOUT ),
145      NAME_VAL( RPC_LOC_SESS_STATUS_USER_END ),
146      NAME_VAL( RPC_LOC_SESS_STATUS_BAD_PARAMETER ),
147      NAME_VAL( RPC_LOC_SESS_STATUS_PHONE_OFFLINE ),
148      NAME_VAL( RPC_LOC_SESS_STATUS_USER_END ),
149      NAME_VAL( RPC_LOC_SESS_STATUS_ENGINE_LOCKED )
150   };
151int loc_sess_status_num = sizeof loc_sess_status_name / sizeof(loc_name_val_s_type);
152
153/* Engine state names */
154loc_name_val_s_type loc_engine_state_name[] =
155   {
156      NAME_VAL( RPC_LOC_ENGINE_STATE_ON ),
157      NAME_VAL( RPC_LOC_ENGINE_STATE_OFF )
158   };
159int loc_engine_state_num = sizeof loc_engine_state_name / sizeof(loc_name_val_s_type);
160
161/* Fix session state names */
162loc_name_val_s_type loc_fix_session_state_name[] =
163   {
164      NAME_VAL( RPC_LOC_FIX_SESSION_STATE_BEGIN ),
165      NAME_VAL( RPC_LOC_FIX_SESSION_STATE_END )
166   };
167int loc_fix_session_state_num = sizeof loc_fix_session_state_name / sizeof(loc_name_val_s_type);
168
169
170static const char* log_final_interm_string(int is_final)
171{
172   return is_final ? "final" : "intermediate";
173}
174
175/* Logs parsed report */
176static void log_parsed_report(const rpc_loc_parsed_position_s_type *parsed_report)
177{
178   rpc_loc_session_status_e_type status = parsed_report->session_status;
179   LOC_LOGD("Session status: %s   Valid mask: 0x%X\n",
180         loc_get_sess_status_name(status),
181         (uint) parsed_report->valid_mask);
182   LOC_LOGD("Latitude:  %.7f (%s)\n", parsed_report->latitude,
183         log_final_interm_string(
184               (parsed_report->valid_mask & RPC_LOC_POS_VALID_LATITUDE) &&
185               parsed_report->session_status == RPC_LOC_SESS_STATUS_SUCCESS));
186   LOC_LOGD("Longitude: %.7f\n", parsed_report->longitude);
187   LOC_LOGD("Accuracy: %.7f\n", parsed_report->hor_unc_circular);
188}
189
190/* Logs status report */
191static void log_status_report(const rpc_loc_status_event_s_type *status_event)
192{
193   rpc_loc_status_event_e_type event = status_event->event;
194   switch (event) {
195   case RPC_LOC_STATUS_EVENT_ENGINE_STATE:
196      LOC_LOGD("Engine state: %s\n",
197            loc_get_engine_state_name(
198                  status_event->payload.rpc_loc_status_event_payload_u_type_u.engine_state));
199      break;
200   case RPC_LOC_STATUS_EVENT_FIX_SESSION_STATE:
201      LOC_LOGD("Fix session state: %s\n",
202            loc_get_fix_session_state_name(
203                  status_event->payload.rpc_loc_status_event_payload_u_type_u.fix_session_state));
204      break;
205   default:
206      break;
207   }
208}
209
210/* Logs valid fields in the GNSS SV constellation report */
211static void log_satellite_report(const rpc_loc_gnss_info_s_type *gnss)
212{
213   if (gnss->valid_mask & RPC_LOC_GNSS_INFO_VALID_POS_DOP)
214   {
215      LOC_LOGV("position dop: %.3f\n", (float) gnss->position_dop);
216   }
217   if (gnss->valid_mask & RPC_LOC_GNSS_INFO_VALID_HOR_DOP)
218   {
219      LOC_LOGV("horizontal dop: %.3f\n", (float) gnss->horizontal_dop);
220   }
221   if (gnss->valid_mask & RPC_LOC_GNSS_INFO_VALID_VERT_DOP)
222   {
223      LOC_LOGV("vertical dop: %.3f\n", (float) gnss->vertical_dop);
224   }
225   if (gnss->valid_mask & RPC_LOC_GNSS_INFO_VALID_ALTITUDE_ASSUMED)
226   {
227      LOC_LOGV("altitude assumed: %d\n", (int) gnss->altitude_assumed);
228   }
229   if (gnss->valid_mask & RPC_LOC_GNSS_INFO_VALID_SV_COUNT)
230   {
231      LOC_LOGD("sv count: %d\n", (int) gnss->sv_count);
232   }
233   if (gnss->valid_mask & RPC_LOC_GNSS_INFO_VALID_SV_LIST)
234   {
235      LOC_LOGV("sv list: ");
236
237      if (gnss->sv_count)
238      {
239         LOC_LOGV("\n\tsys\tprn\thlth\tproc\teph\talm\telev\tazi\tsnr\n");
240      }
241      else {
242         LOC_LOGV("empty\n");
243      }
244
245      int i;
246      for (i = 0; i < gnss->sv_count; i++)
247      {
248         const rpc_loc_sv_info_s_type *sv = &gnss->sv_list.sv_list_val[i];
249         rpc_loc_sv_info_valid_mask_type mask = sv->valid_mask;
250         LOC_LOGV("  %d: \t%d\t%d\t%d\t%d\t%d\t%d\t%.3f\t%.3f\t%.3f\n", i,
251               CHECK_MASK(int,   sv->system,         mask, RPC_LOC_SV_INFO_VALID_SYSTEM),
252               CHECK_MASK(int,   sv->prn,            mask, RPC_LOC_SV_INFO_VALID_PRN),
253               CHECK_MASK(int,   sv->health_status,  mask, RPC_LOC_SV_INFO_VALID_HEALTH_STATUS),
254               CHECK_MASK(int,   sv->process_status, mask, RPC_LOC_SV_INFO_VALID_PROCESS_STATUS),
255               CHECK_MASK(int,   sv->has_eph,        mask, RPC_LOC_SV_INFO_VALID_HAS_EPH),
256               CHECK_MASK(int,   sv->has_alm,        mask, RPC_LOC_SV_INFO_VALID_HAS_ALM),
257               CHECK_MASK(float, sv->elevation,      mask, RPC_LOC_SV_INFO_VALID_ELEVATION),
258               CHECK_MASK(float, sv->azimuth,        mask, RPC_LOC_SV_INFO_VALID_AZIMUTH),
259               CHECK_MASK(float, sv->snr,            mask, RPC_LOC_SV_INFO_VALID_SNR)
260         );
261      }
262   }
263}
264
265/* Logs a callback event */
266int loc_callback_log(
267      rpc_loc_event_mask_type               loc_event,              /* event mask           */
268      const rpc_loc_event_payload_u_type*   loc_event_payload       /* payload              */
269)
270{
271   switch (loc_event)
272   {
273   case RPC_LOC_EVENT_SATELLITE_REPORT:
274      log_satellite_report(&loc_event_payload->
275            rpc_loc_event_payload_u_type_u.gnss_report);
276      break;
277   case RPC_LOC_EVENT_STATUS_REPORT:
278      log_status_report(&loc_event_payload->
279            rpc_loc_event_payload_u_type_u.status_report);
280      break;
281   case RPC_LOC_EVENT_PARSED_POSITION_REPORT:
282      log_parsed_report(&loc_event_payload->
283            rpc_loc_event_payload_u_type_u.parsed_location_report);
284      break;
285   default:
286      break;
287   }
288
289   return 0;
290}
291
292/* Finds the first event found in the mask */
293const char* loc_get_event_name(rpc_loc_event_mask_type loc_event_mask)
294{
295   return loc_get_name_from_mask(loc_event_name, loc_event_num,
296         (long) loc_event_mask);
297}
298
299/* Finds IOCTL type name */
300const char* loc_get_ioctl_type_name(rpc_loc_ioctl_e_type ioctl_type)
301{
302   return loc_get_name_from_val(loc_ioctl_type_name, loc_ioctl_type_num,
303         (long) ioctl_type);
304}
305
306/* Finds IOCTL status name */
307const char* loc_get_ioctl_status_name(uint32 status)
308{
309   return loc_get_name_from_val(loc_ioctl_status_name, loc_ioctl_status_num,
310         (long) status);
311}
312
313/* Finds session status name */
314const char* loc_get_sess_status_name(rpc_loc_session_status_e_type status)
315{
316   return loc_get_name_from_val(loc_sess_status_name, loc_sess_status_num,
317         (long) status);
318}
319
320/* Find engine state name */
321const char* loc_get_engine_state_name(rpc_loc_engine_state_e_type state)
322{
323   return loc_get_name_from_val(loc_engine_state_name, loc_engine_state_num,
324         (long) state);
325}
326
327/* Find engine state name */
328const char* loc_get_fix_session_state_name(rpc_loc_fix_session_state_e_type state)
329{
330   return loc_get_name_from_val(loc_fix_session_state_name, loc_fix_session_state_num,
331         (long) state);
332}
333
334/* Event names */
335loc_name_val_s_type rpc_reset_event_name[] =
336{
337    NAME_VAL( RPC_SUBSYSTEM_RESTART_BEGIN ),
338    NAME_VAL( RPC_SUBSYSTEM_RESTART_END )
339};
340int rpc_reset_event_num = sizeof rpc_reset_event_name / sizeof(loc_name_val_s_type);
341
342const char* loc_get_rpc_reset_event_name(enum rpc_reset_event event)
343{
344    return loc_get_name_from_val(rpc_reset_event_name, rpc_reset_event_num, event);
345}
346