sec: Send SIM I/O requests one after another
[samsung-ril.git] / samsung-ril.h
1 /**
2  * This file is part of samsung-ril.
3  *
4  * Copyright (C) 2010-2011 Joerie de Gram <j.de.gram@gmail.com>
5  * Copyright (C) 2011-2012 Paul Kocialkowski <contact@paulk.fr>
6  *
7  * samsung-ril is free software: you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation, either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * samsung-ril is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with samsung-ril.  If not, see <http://www.gnu.org/licenses/>.
19  *
20  */
21
22 #ifndef _SAMSUNG_RIL_H_
23 #define _SAMSUNG_RIL_H_
24
25 #include <pthread.h>
26
27 #include <utils/Log.h>
28 #include <telephony/ril.h>
29
30 #include <radio.h>
31
32 #include "ipc.h"
33 #include "srs.h"
34
35 /**
36  * Defines
37  */
38
39 #ifndef LOGE
40         #define LOGE ALOGE
41 #endif
42
43 #ifndef LOGI
44         #define LOGI ALOGI
45 #endif
46
47 #ifndef LOGD
48         #define LOGD ALOGD
49 #endif
50
51 #define RIL_VERSION_STRING "Samsung RIL"
52
53 #define RIL_LOCK() pthread_mutex_lock(&ril_data.mutex)
54 #define RIL_UNLOCK() pthread_mutex_unlock(&ril_data.mutex)
55 #define RIL_CLIENT_LOCK(client) pthread_mutex_lock(&(client->mutex))
56 #define RIL_CLIENT_UNLOCK(client) pthread_mutex_unlock(&(client->mutex))
57
58 #define RIL_TOKEN_DATA_WAITING  (RIL_Token) 0xff
59
60 /**
61  * RIL client
62  */
63
64 struct ril_client;
65
66 struct ril_client_funcs {
67         int (*create)(struct ril_client *client);
68         int (*destroy)(struct ril_client *client);
69         int (*read_loop)(struct ril_client *client);
70 };
71
72 typedef enum {
73         RIL_CLIENT_NULL         = 0,
74         RIL_CLIENT_CREATED      = 1,
75         RIL_CLIENT_READY        = 2,
76         RIL_CLIENT_DESTROYED    = 3,
77         RIL_CLIENT_ERROR        = 4,
78 } ril_client_state;
79
80 struct ril_client {
81         struct ril_client_funcs funcs;
82         ril_client_state state;
83
84         void *data;
85
86         pthread_t thread;
87         pthread_mutex_t mutex;
88 };
89
90 struct ril_client *ril_client_new(struct ril_client_funcs *client_funcs);
91 int ril_client_free(struct ril_client *client);
92 int ril_client_create(struct ril_client *client);
93 int ril_client_destroy(struct ril_client *client);
94 int ril_client_thread_start(struct ril_client *client);
95
96 /**
97  * RIL requests
98  */
99
100 struct ril_request_info {
101         RIL_Token token;
102         int id;
103         int canceled;
104 };
105
106 int ril_request_id_get(void);
107 int ril_request_id_set(int id);
108 int ril_request_register(RIL_Token t, int id);
109 void ril_request_unregister(struct ril_request_info *request);
110 struct ril_request_info *ril_request_info_find_id(int id);
111 struct ril_request_info *ril_request_info_find_token(RIL_Token t);
112 int ril_request_set_canceled(RIL_Token t, int canceled);
113 int ril_request_get_canceled(RIL_Token t);
114 RIL_Token ril_request_get_token(int id);
115 int ril_request_get_id(RIL_Token t);
116
117 void ril_request_complete(RIL_Token t, RIL_Errno e, void *data, size_t length);
118 void ril_request_unsolicited(int request, void *data, size_t length);
119 void ril_request_timed_callback(RIL_TimedCallback callback, void *data, const struct timeval *time);
120
121 /**
122  * RIL tokens
123  */
124
125 struct ril_tokens {
126         RIL_Token radio_power;
127         RIL_Token pin_status;
128         RIL_Token get_imei;
129         RIL_Token get_imeisv;
130         RIL_Token baseband_version;
131
132         RIL_Token registration_state;
133         RIL_Token gprs_registration_state;
134         RIL_Token operator;
135
136         RIL_Token outgoing_sms;
137         RIL_Token sim_io;
138 };
139
140 void ril_tokens_check(void);
141
142 /**
143  * RIL state
144  */
145
146 typedef enum {
147         SIM_STATE_ABSENT                        = 0,
148         SIM_STATE_NOT_READY                     = 1,
149         SIM_STATE_READY                         = 2,
150         SIM_STATE_PIN                           = 3,
151         SIM_STATE_PUK                           = 4,
152         SIM_STATE_BLOCKED                       = 5,
153         SIM_STATE_NETWORK_PERSO                 = 6,
154         SIM_STATE_NETWORK_SUBSET_PERSO          = 7,
155         SIM_STATE_CORPORATE_PERSO               = 8,
156         SIM_STATE_SERVICE_PROVIDER_PERSO        = 9,
157 } ril_sim_state;
158
159 struct ril_state {
160         RIL_RadioState radio_state;
161         ril_sim_state sim_state;
162         int power_state;
163
164         struct ipc_sec_sim_status_response sim_pin_status;
165         struct ipc_sec_sim_icc_type sim_type;
166
167         struct ipc_net_regist_response netinfo;
168         struct ipc_net_regist_response gprs_netinfo;
169         struct ipc_net_current_plmn_response plmndata;
170
171         struct ipc_call_status call_status;
172
173         int gprs_last_failed_cid;
174
175         unsigned char dtmf_tone;
176         unsigned char ussd_state;
177
178         unsigned char sms_incoming_msg_tpid;
179 };
180
181 /**
182  * RIL data
183  */
184
185 struct ril_data {
186         struct RIL_Env *env;
187
188         struct ril_state state;
189         struct ril_tokens tokens;
190         struct list_head *gprs_connections;
191         struct list_head *incoming_sms;
192         struct list_head *outgoing_sms;
193         struct list_head *sim_io;
194         struct list_head *generic_responses;
195         struct list_head *requests;
196         int request_id;
197
198         struct ril_client *ipc_fmt_client;
199         struct ril_client *ipc_rfs_client;
200         struct ril_client *srs_client;
201
202         pthread_mutex_t mutex;
203 };
204
205 extern struct ril_data ril_data;
206
207 /**
208  * Dispatch functions
209  */
210
211 void ipc_fmt_dispatch(struct ipc_message_info *info);
212 void ipc_rfs_dispatch(struct ipc_message_info *info);
213 void srs_dispatch(struct srs_message *message);
214
215 /* GEN */
216
217 struct ipc_gen_phone_res_expect_info {
218         unsigned char aseq;
219         unsigned short command;
220         void (*func)(struct ipc_message_info *info);
221         int complete;
222         int abort;
223 };
224
225 int ipc_gen_phone_res_expect_register(unsigned char aseq, unsigned short command,
226         void (*func)(struct ipc_message_info *info), int complete, int abort);
227 void ipc_gen_phone_res_expect_unregister(struct ipc_gen_phone_res_expect_info *expect);
228 struct ipc_gen_phone_res_expect_info *ipc_gen_phone_res_expect_find_aseq(unsigned char aseq);
229 int ipc_gen_phone_res_expect_to_func(unsigned char aseq, unsigned short command,
230         void (*func)(struct ipc_message_info *info));
231 int ipc_gen_phone_res_expect_to_complete(unsigned char aseq, unsigned short command);
232 int ipc_gen_phone_res_expect_to_abort(unsigned char aseq, unsigned short command);
233
234 void ipc_gen_phone_res(struct ipc_message_info *info);
235
236 /* PWR */
237
238 void ipc_pwr_phone_pwr_up(void);
239 void ipc_pwr_phone_state(struct ipc_message_info *info);
240 void ril_request_radio_power(RIL_Token t, void *data, size_t datalen);
241
242 /* DISP */
243
244 void ril_request_signal_strength(RIL_Token t);
245 void ipc_disp_icon_info(struct ipc_message_info *info);
246 void ipc_disp_rssi_info(struct ipc_message_info *info);
247
248 /* MISC */
249
250 void ril_request_get_imei(RIL_Token t);
251 void ril_request_get_imeisv(RIL_Token t);
252 void ipc_misc_me_sn(struct ipc_message_info *info);
253 void ril_request_baseband_version(RIL_Token t);
254 void ipc_misc_me_version(struct ipc_message_info *info);
255 void ril_request_get_imsi(RIL_Token t);
256 void ipc_misc_me_imsi(struct ipc_message_info *info);
257 void ipc_misc_time_info(struct ipc_message_info *info);
258
259 /* SAT */
260 void ril_request_report_stk_service_is_running(RIL_Token t);
261 void ipc_sat_proactive_cmd(struct ipc_message_info *info);
262 void ril_request_stk_send_terminal_response(RIL_Token t, void *data, size_t datalen);
263 void ril_request_stk_send_envelope_command(RIL_Token t, void *data, size_t datalen);
264 void ipc_sat_envelope_cmd(struct ipc_message_info *info);
265
266 /* SS */
267
268 void ril_request_send_ussd(RIL_Token t, void *data, size_t datalen);
269 void ril_request_cancel_ussd(RIL_Token t, void *data, size_t datalen);
270 void ipc_ss_ussd(struct ipc_message_info *info);
271
272 /* SEC */
273
274 struct ril_request_sim_io_info {
275         unsigned char command;
276         unsigned short fileid;
277         unsigned char p1;
278         unsigned char p2;
279         unsigned char p3;
280         void *data;
281         int length;
282
283         RIL_Token token;
284 };
285
286 void ril_state_update(ril_sim_state status);
287 void ipc_sec_sim_status(struct ipc_message_info *info);
288 void ril_request_get_sim_status(RIL_Token t);
289 void ril_request_sim_io_next(void);
290 void ril_request_sim_io_complete(RIL_Token t, unsigned char command, unsigned short fileid,
291         unsigned char p1, unsigned char p2, unsigned char p3, void *data, int length);
292 void ril_request_sim_io(RIL_Token t, void *data, int length);
293 void ipc_sec_rsim_access(struct ipc_message_info *info);
294 void ipc_sec_sim_status_complete(struct ipc_message_info *info);
295 void ipc_sec_lock_info(struct ipc_message_info *info);
296 void ril_request_enter_sim_pin(RIL_Token t, void *data, size_t datalen);
297 void ril_request_change_sim_pin(RIL_Token t, void *data, size_t datalen);
298 void ril_request_enter_sim_puk(RIL_Token t, void *data, size_t datalen);
299 void ril_request_query_facility_lock(RIL_Token t, void *data, size_t datalen);
300 void ipc_sec_phone_lock(struct ipc_message_info *info);
301 void ipc_sec_phone_lock_complete(struct ipc_message_info *info);
302 void ril_request_set_facility_lock(RIL_Token t, void *data, size_t datalen);
303
304 /* NET */
305
306 void ril_plmn_split(char *plmn_data, char **plmn, unsigned int *mcc, unsigned int *mnc);
307 void ril_plmn_string(char *plmn_data, char *response[3]);
308 unsigned char ril_plmn_act_get(char *plmn_data);
309 void ril_request_operator(RIL_Token t);
310 void ipc_net_current_plmn(struct ipc_message_info *message);
311 #if RIL_VERSION >= 6
312 void ril_request_voice_registration_state(RIL_Token t);
313 void ril_request_data_registration_state(RIL_Token t);
314 #else
315 void ril_request_registration_state(RIL_Token t);
316 void ril_request_gprs_registration_state(RIL_Token t);
317 #endif
318 void ipc_net_regist(struct ipc_message_info *message);
319 void ril_request_query_available_networks(RIL_Token t);
320 void ipc_net_plmn_list(struct ipc_message_info *info);
321 void ril_request_get_preferred_network_type(RIL_Token t);
322 void ril_request_set_preferred_network_type(RIL_Token t, void *data, size_t datalen);
323 void ipc_net_mode_sel(struct ipc_message_info *info);
324 void ril_request_query_network_selection_mode(RIL_Token t);
325 void ipc_net_plmn_sel(struct ipc_message_info *info);
326 void ril_request_set_network_selection_automatic(RIL_Token t);
327 void ril_request_set_network_selection_manual(RIL_Token t, void *data, size_t datalen);
328
329 /* SMS */
330
331 struct ipc_sms_incoming_msg_info {
332         char *pdu;
333         int length;
334
335         unsigned char type;
336         unsigned char tpid;
337 };
338
339 struct ril_request_send_sms_info {
340         char *pdu;
341         int pdu_length;
342         unsigned char *smsc;
343         int smsc_length;
344
345         RIL_Token token;
346 };
347
348 int ril_request_send_sms_register(char *pdu, int pdu_length, unsigned char *smsc, int smsc_length, RIL_Token t);
349 void ril_request_send_sms_unregister(struct ril_request_send_sms_info *send_sms);
350 struct ril_request_send_sms_info *ril_request_send_sms_info_find(void);
351 struct ril_request_send_sms_info *ril_request_send_sms_info_find_token(RIL_Token t);
352
353 void ril_request_send_sms_next(void);
354 void ril_request_send_sms_complete(RIL_Token t, char *pdu, int pdu_length, unsigned char *smsc, int smsc_length);
355 void ril_request_send_sms(RIL_Token t, void *data, size_t length);
356 void ril_request_send_sms_expect_more(RIL_Token t, void *data, size_t length);
357 void ipc_sms_svc_center_addr(struct ipc_message_info *info);
358 void ipc_sms_send_msg_complete(struct ipc_message_info *info);
359 void ipc_sms_send_msg(struct ipc_message_info *info);
360
361 int ipc_sms_incoming_msg_register(char *pdu, int length, unsigned char type, unsigned char tpid);
362 void ipc_sms_incoming_msg_unregister(struct ipc_sms_incoming_msg_info *incoming_msg);
363 struct ipc_sms_incoming_msg_info *ipc_sms_incoming_msg_info_find(void);
364
365 void ipc_sms_incoming_msg_complete(char *pdu, int length, unsigned char type, unsigned char tpid);
366 void ipc_sms_incoming_msg(struct ipc_message_info *info);
367 void ril_request_sms_acknowledge(RIL_Token t, void *data, size_t length);
368 void ipc_sms_deliver_report(struct ipc_message_info *info);
369
370 void ipc_sms_device_ready(struct ipc_message_info *info);
371
372 /* Call */
373
374 void ipc_call_incoming(struct ipc_message_info *info);
375 void ipc_call_status(struct ipc_message_info *info);
376 void ril_request_dial(RIL_Token t, void *data, size_t datalen);
377 void ril_request_get_current_calls(RIL_Token t);
378 void ipc_call_list(struct ipc_message_info *info);
379 void ril_request_hangup(RIL_Token t);
380 void ril_request_answer(RIL_Token t);
381 void ril_request_last_call_fail_cause(RIL_Token t);
382 void ril_request_dtmf(RIL_Token t, void *data, int length);
383 void ipc_call_burst_dtmf(struct ipc_message_info *info);
384 void ril_request_dtmf_start(RIL_Token t, void *data, int length);
385 void ril_request_dtmf_stop(RIL_Token t);
386
387 /* SND */
388
389 void ril_request_set_mute(RIL_Token t, void *data, size_t datalen);
390 void srs_snd_set_call_clock_sync(struct srs_message *message);
391 void srs_snd_set_call_volume(struct srs_message *message);
392 void srs_snd_set_call_audio_path(struct srs_message *message);
393
394 /* GPRS */
395
396 struct ril_gprs_connection {
397         int cid;
398         int enabled;
399 #if RIL_VERSION >= 6
400         RIL_DataCallFailCause fail_cause;
401 #else
402         RIL_LastDataCallActivateFailCause fail_cause;
403 #endif
404         char *interface;
405
406         RIL_Token token;
407         struct ipc_gprs_pdp_context_set context;
408         struct ipc_gprs_define_pdp_context define_context;
409         struct ipc_gprs_ip_configuration ip_configuration;
410 };
411
412 int ril_gprs_connection_register(int cid);
413 void ril_gprs_connection_unregister(struct ril_gprs_connection *gprs_connection);
414 struct ril_gprs_connection *ril_gprs_connection_find_cid(int cid);
415 struct ril_gprs_connection *ril_gprs_connection_find_token(RIL_Token t);
416 struct ril_gprs_connection *ril_gprs_connection_start(void);
417 void ril_gprs_connection_stop(struct ril_gprs_connection *gprs_connection);
418
419 void ril_request_setup_data_call(RIL_Token t, void *data, int length);
420 void ril_request_deactivate_data_call(RIL_Token t, void *data, int length);
421 void ipc_gprs_ip_configuration(struct ipc_message_info *info);
422 void ipc_gprs_call_status(struct ipc_message_info *info);
423 void ril_request_last_data_call_fail_cause(RIL_Token t);
424 void ipc_gprs_pdp_context(struct ipc_message_info *info);
425 void ril_unsol_data_call_list_changed(void);
426 void ril_request_data_call_list(RIL_Token t);
427
428 /* RFS */
429
430 void ipc_rfs_nv_read_item(struct ipc_message_info *info);
431 void ipc_rfs_nv_write_item(struct ipc_message_info *info);
432
433 #endif