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 Paul Kocialkowski <contact@oaulk.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 "compat.h"
  33 #include "ipc.h"
  34 #include "srs.h"
  35
  36 /**
  37  * Defines
  38  */
  39
  40 #define RIL_VERSION_STRING "Samsung RIL"
  41
  42 #define RIL_LOCK() pthread_mutex_lock(&ril_data.mutex)
  43 #define RIL_UNLOCK() pthread_mutex_unlock(&ril_data.mutex)
  44 #define RIL_CLIENT_LOCK(client) pthread_mutex_lock(&(client->mutex))
  45 #define RIL_CLIENT_UNLOCK(client) pthread_mutex_unlock(&(client->mutex))
  46
  47 #define RIL_TOKEN_DATA_WAITING  (RIL_Token) 0xff
  48
  49 /**
  50  * RIL client
  51  */
  52
  53 struct ril_client;
  54
  55 struct ril_client_funcs {
  56         int (*create)(struct ril_client *client);
  57         int (*destroy)(struct ril_client *client);
  58         int (*read_loop)(struct ril_client *client);
  59 };
  60
  61 typedef enum {
  62         RIL_CLIENT_NULL         = 0,
  63         RIL_CLIENT_CREATED      = 1,
  64         RIL_CLIENT_READY        = 2,
  65         RIL_CLIENT_DESTROYED    = 3,
  66         RIL_CLIENT_ERROR        = 4,
  67 } ril_client_state;
  68
  69 struct ril_client {
  70         struct ril_client_funcs funcs;
  71         ril_client_state state;
  72
  73         void *data;
  74
  75         pthread_t thread;
  76         pthread_mutex_t mutex;
  77 };
  78
  79 struct ril_client *ril_client_new(struct ril_client_funcs *client_funcs);
  80 int ril_client_free(struct ril_client *client);
  81 int ril_client_create(struct ril_client *client);
  82 int ril_client_destroy(struct ril_client *client);
  83 int ril_client_thread_start(struct ril_client *client);
  84
  85 /**
  86  * RIL requests
  87  */
  88
  89 struct ril_request_info {
  90         RIL_Token token;
  91         int id;
  92         int canceled;
  93 };
  94
  95 int ril_request_id_get(void);
  96 int ril_request_id_set(int id);
  97 int ril_request_register(RIL_Token t, int id);
  98 void ril_request_unregister(struct ril_request_info *request);
  99 struct ril_request_info *ril_request_info_find_id(int id);
 100 struct ril_request_info *ril_request_info_find_token(RIL_Token t);
 101 int ril_request_set_canceled(RIL_Token t, int canceled);
 102 int ril_request_get_canceled(RIL_Token t);
 103 RIL_Token ril_request_get_token(int id);
 104 int ril_request_get_id(RIL_Token t);
 105
 106 void ril_request_complete(RIL_Token t, RIL_Errno e, void *data, size_t length);
 107 void ril_request_unsolicited(int request, void *data, size_t length);
 108 void ril_request_timed_callback(RIL_TimedCallback callback, void *data, const struct timeval *time);
 109
 110 /**
 111  * RIL tokens
 112  */
 113
 114 struct ril_tokens {
 115         RIL_Token radio_power;
 116         RIL_Token pin_status;
 117         RIL_Token get_imei;
 118         RIL_Token get_imeisv;
 119         RIL_Token baseband_version;
 120
 121         RIL_Token registration_state;
 122         RIL_Token gprs_registration_state;
 123         RIL_Token operator;
 124 };
 125
 126 void ril_tokens_check(void);
 127
 128 /**
 129  * RIL state
 130  */
 131
 132 typedef enum {
 133         SIM_STATE_ABSENT                        = 0,
 134         SIM_STATE_NOT_READY                     = 1,
 135         SIM_STATE_READY                         = 2,
 136         SIM_STATE_PIN                           = 3,
 137         SIM_STATE_PUK                           = 4,
 138         SIM_STATE_BLOCKED                       = 5,
 139         SIM_STATE_NETWORK_PERSO                 = 6,
 140         SIM_STATE_NETWORK_SUBSET_PERSO          = 7,
 141         SIM_STATE_CORPORATE_PERSO               = 8,
 142         SIM_STATE_SERVICE_PROVIDER_PERSO        = 9,
 143 } ril_sim_state;
 144
 145 struct ril_state {
 146         RIL_RadioState radio_state;
 147         ril_sim_state sim_state;
 148         int power_state;
 149
 150         struct ipc_sec_sim_status_response sim_pin_status;
 151         struct ipc_sec_sim_icc_type sim_type;
 152
 153         struct ipc_net_regist_response netinfo;
 154         struct ipc_net_regist_response gprs_netinfo;
 155         struct ipc_net_current_plmn_response plmndata;
 156
 157         struct ipc_call_status call_status;
 158
 159         int gprs_last_failed_cid;
 160
 161         unsigned char dtmf_tone;
 162         unsigned char ussd_state;
 163
 164         unsigned char sms_incoming_msg_tpid;
 165 };
 166
 167 void ril_state_lpm(void);
 168
 169 /**
 170  * RIL data
 171  */
 172
 173 struct ril_data {
 174         struct RIL_Env *env;
 175
 176         struct ril_state state;
 177         struct ril_tokens tokens;
 178         struct list_head *gprs_connections;
 179         struct list_head *incoming_sms;
 180         struct list_head *outgoing_sms;
 181         struct list_head *generic_responses;
 182         struct list_head *requests;
 183         int request_id;
 184
 185         struct ril_client *ipc_fmt_client;
 186         struct ril_client *ipc_rfs_client;
 187         struct ril_client *srs_client;
 188
 189         pthread_mutex_t mutex;
 190 };
 191
 192 extern struct ril_data ril_data;
 193
 194 /**
 195  * Dispatch functions
 196  */
 197
 198 void ipc_fmt_dispatch(struct ipc_message_info *info);
 199 void ipc_rfs_dispatch(struct ipc_message_info *info);
 200 void srs_dispatch(int fd, struct srs_message *message);
 201
 202 /* GEN */
 203
 204 struct ipc_gen_phone_res_expect_info {
 205         unsigned char aseq;
 206         unsigned short command;
 207         void (*func)(struct ipc_message_info *info);
 208         int complete;
 209         int abort;
 210 };
 211
 212 int ipc_gen_phone_res_expect_register(unsigned char aseq, unsigned short command,
 213         void (*func)(struct ipc_message_info *info), int complete, int abort);
 214 void ipc_gen_phone_res_expect_unregister(struct ipc_gen_phone_res_expect_info *expect);
 215 struct ipc_gen_phone_res_expect_info *ipc_gen_phone_res_expect_find_aseq(unsigned char aseq);
 216 int ipc_gen_phone_res_expect_to_func(unsigned char aseq, unsigned short command,
 217         void (*func)(struct ipc_message_info *info));
 218 int ipc_gen_phone_res_expect_to_complete(unsigned char aseq, unsigned short command);
 219 int ipc_gen_phone_res_expect_to_abort(unsigned char aseq, unsigned short command);
 220
 221 void ipc_gen_phone_res(struct ipc_message_info *info);
 222
 223 /* PWR */
 224
 225 void ipc_pwr_phone_pwr_up(void);
 226 void ipc_pwr_phone_state(struct ipc_message_info *info);
 227 void ril_request_radio_power(RIL_Token t, void *data, size_t datalen);
 228
 229 /* DISP */
 230
 231 void ril_request_signal_strength(RIL_Token t);
 232 void ipc_disp_icon_info(struct ipc_message_info *info);
 233 void ipc_disp_rssi_info(struct ipc_message_info *info);
 234
 235 /* MISC */
 236
 237 void ril_request_get_imei(RIL_Token t);
 238 void ril_request_get_imeisv(RIL_Token t);
 239 void ipc_misc_me_sn(struct ipc_message_info *info);
 240 void ril_request_baseband_version(RIL_Token t);
 241 void ipc_misc_me_version(struct ipc_message_info *info);
 242 void ril_request_get_imsi(RIL_Token t);
 243 void ipc_misc_me_imsi(struct ipc_message_info *info);
 244 void ipc_misc_time_info(struct ipc_message_info *info);
 245
 246 /* SAT */
 247 void respondSatProactiveCmd(struct ipc_message_info *request);
 248 void requestSatSendTerminalResponse(RIL_Token t, void *data, size_t datalen);
 249 void requestSatSendEnvelopeCommand(RIL_Token t, void *data, size_t datalen);
 250 void respondSatEnvelopeCmd(struct ipc_message_info *request);
 251
 252 /* SS */
 253
 254 void ril_request_send_ussd(RIL_Token t, void *data, size_t datalen);
 255 void ril_request_cancel_ussd(RIL_Token t, void *data, size_t datalen);
 256 void ipc_ss_ussd(struct ipc_message_info *info);
 257
 258 /* SEC */
 259
 260 void ril_state_update(ril_sim_state status);
 261 void ipc_sec_sim_status(struct ipc_message_info *info);
 262 void ril_request_get_sim_status(RIL_Token t);
 263 void ril_request_sim_io(RIL_Token t, void *data, size_t datalen);
 264 void ipc_sec_rsim_access(struct ipc_message_info *info);
 265 void ipc_sec_sim_status_complete(struct ipc_message_info *info);
 266 void ipc_sec_lock_info(struct ipc_message_info *info);
 267 void ril_request_enter_sim_pin(RIL_Token t, void *data, size_t datalen);
 268 void ril_request_change_sim_pin(RIL_Token t, void *data, size_t datalen);
 269 void ril_request_enter_sim_puk(RIL_Token t, void *data, size_t datalen);
 270 void ril_request_query_facility_lock(RIL_Token t, void *data, size_t datalen);
 271 void ipc_sec_phone_lock(struct ipc_message_info *info);
 272 void ipc_sec_phone_lock_complete(struct ipc_message_info *info);
 273 void ril_request_set_facility_lock(RIL_Token t, void *data, size_t datalen);
 274
 275 /* NET */
 276
 277 void ril_plmn_split(char *plmn_data, char **plmn, unsigned int *mcc, unsigned int *mnc);
 278 void ril_plmn_string(char *plmn_data, char *response[3]);
 279 unsigned char ril_plmn_act_get(char *plmn_data);
 280 void ril_request_operator(RIL_Token t);
 281 void ipc_net_current_plmn(struct ipc_message_info *message);
 282 void ril_request_registration_state(RIL_Token t);
 283 void ril_request_gprs_registration_state(RIL_Token t);
 284 void ipc_net_regist(struct ipc_message_info *message);
 285 void ril_request_query_available_networks(RIL_Token t);
 286 void ipc_net_plmn_list(struct ipc_message_info *info);
 287 void ril_request_get_preferred_network_type(RIL_Token t);
 288 void ril_request_set_preferred_network_type(RIL_Token t, void *data, size_t datalen);
 289 void ipc_net_mode_sel(struct ipc_message_info *info);
 290 void ril_request_query_network_selection_mode(RIL_Token t);
 291 void ipc_net_plmn_sel(struct ipc_message_info *info);
 292 void ril_request_set_network_selection_automatic(RIL_Token t);
 293 void ril_request_set_network_selection_manual(RIL_Token t, void *data, size_t datalen);
 294
 295 /* SMS */
 296
 297 struct ipc_sms_incoming_msg_info {
 298         char *pdu;
 299         int length;
 300
 301         unsigned char type;
 302         unsigned char tpid;
 303 };
 304
 305 struct ril_request_sms {
 306         char *pdu;
 307         int pdu_len;
 308         char *smsc;
 309         int smsc_len;
 310
 311         unsigned char aseq;
 312 };
 313
 314 void ril_request_sms_init(void);
 315 void ril_request_sms_del(int id);
 316 void ril_request_sms_clear(int id);
 317 int ril_request_sms_add(unsigned char aseq,
 318                         char *pdu, int pdu_len,
 319                         char *smsc, int smsc_len);
 320 int ril_request_sms_get_id(unsigned char aseq);
 321 int ril_request_sms_get_next(void);
 322 int ril_request_sms_lock_acquire(void);
 323 void ril_request_sms_lock_release(void);
 324
 325 void ril_request_send_sms(RIL_Token t, void *data, size_t datalen);
 326 void ril_request_send_sms_expect_more(RIL_Token t, void *data, size_t datalen);
 327 int ril_request_send_sms_next(void);
 328 void ril_request_send_sms_complete(RIL_Token t, char *pdu, char *smsc);
 329 void ipc_sms_send_msg_complete(struct ipc_message_info *info);
 330 void ipc_sms_svc_center_addr(struct ipc_message_info *info);
 331 void ipc_sms_send_msg(struct ipc_message_info *info);
 332
 333 int ipc_sms_incoming_msg_register(char *pdu, int length, unsigned char type, unsigned char tpid);
 334 void ipc_sms_incoming_msg_unregister(struct ipc_sms_incoming_msg_info *incoming_msg);
 335 struct ipc_sms_incoming_msg_info *ipc_sms_incoming_msg_info_find(void);
 336
 337 void ipc_sms_incoming_msg_complete(char *pdu, int length, unsigned char type, unsigned char tpid);
 338 void ipc_sms_incoming_msg(struct ipc_message_info *info);
 339 void ril_request_sms_acknowledge(RIL_Token t, void *data, size_t length);
 340 void ipc_sms_deliver_report(struct ipc_message_info *info);
 341
 342 void ipc_sms_device_ready(struct ipc_message_info *info);
 343
 344 /* Call */
 345
 346 void ipc_call_incoming(struct ipc_message_info *info);
 347 void ipc_call_status(struct ipc_message_info *info);
 348 void ril_request_dial(RIL_Token t, void *data, size_t datalen);
 349 void ril_request_get_current_calls(RIL_Token t);
 350 void ipc_call_list(struct ipc_message_info *info);
 351 void ril_request_hangup(RIL_Token t);
 352 void ril_request_answer(RIL_Token t);
 353 void ril_request_last_call_fail_cause(RIL_Token t);
 354 void ril_request_dtmf(RIL_Token t, void *data, int length);
 355 void ipc_call_burst_dtmf(struct ipc_message_info *info);
 356 void ril_request_dtmf_start(RIL_Token t, void *data, int length);
 357 void ril_request_dtmf_stop(RIL_Token t);
 358
 359 /* SND */
 360
 361 void ril_request_set_mute(RIL_Token t, void *data, size_t datalen);
 362 void srs_snd_set_call_clock_sync(struct srs_message *message);
 363 void srs_snd_set_call_volume(struct srs_message *message);
 364 void srs_snd_set_call_audio_path(struct srs_message *message);
 365
 366 /* GPRS */
 367
 368 struct ril_gprs_connection {
 369         int cid;
 370         int enabled;
 371 #if RIL_VERSION >= 6
 372         RIL_DataCallFailCause fail_cause;
 373 #else
 374         RIL_LastDataCallActivateFailCause fail_cause;
 375 #endif
 376         char *interface;
 377
 378         RIL_Token token;
 379         struct ipc_gprs_pdp_context_set context;
 380         struct ipc_gprs_define_pdp_context define_context;
 381         struct ipc_gprs_ip_configuration ip_configuration;
 382 };
 383
 384 int ril_gprs_connection_register(int cid);
 385 void ril_gprs_connection_unregister(struct ril_gprs_connection *gprs_connection);
 386 struct ril_gprs_connection *ril_gprs_connection_find_cid(int cid);
 387 struct ril_gprs_connection *ril_gprs_connection_find_token(RIL_Token t);
 388 struct ril_gprs_connection *ril_gprs_connection_start(void);
 389 void ril_gprs_connection_stop(struct ril_gprs_connection *gprs_connection);
 390
 391 void ril_request_setup_data_call(RIL_Token t, void *data, int length);
 392 void ril_request_deactivate_data_call(RIL_Token t, void *data, int length);
 393 void ipc_gprs_ip_configuration(struct ipc_message_info *info);
 394 void ipc_gprs_call_status(struct ipc_message_info *info);
 395 void ril_request_last_data_call_fail_cause(RIL_Token t);
 396 void ipc_gprs_pdp_context(struct ipc_message_info *info);
 397 void ril_unsol_data_call_list_changed(void);
 398 void ril_request_data_call_list(RIL_Token t);
 399
 400 /* RFS */
 401
 402 void ipc_rfs_nv_read_item(struct ipc_message_info *info);
 403 void ipc_rfs_nv_write_item(struct ipc_message_info *info);
 404
 405 #endif