static void ril_pin_change_state(struct ofono_sim *sim,
enum ofono_sim_password_type passwd_type,
int enable, const char *passwd,
ofono_sim_lock_unlock_cb_t cb, void *data)
{
struct sim_data *sd = ofono_sim_get_data(sim);
struct cb_data *cbd;
struct parcel rilp;
struct req_pin_change_state req;
int ret = 0;
/*
* If we want to unlock a password that has not been entered yet,
* we enter it before trying to unlock. We need sd->unlock_pending as
* the password still has not yet been refreshed when this function is
* called from enter_pin_done().
*/
if (ofono_sim_get_password_type(sim) == passwd_type
&& enable == FALSE && sd->unlock_pending == FALSE) {
struct change_state_cbd *csd = g_malloc0(sizeof(*csd));
csd->sim = sim;
csd->passwd_type = passwd_type;
csd->enable = enable;
csd->passwd = passwd;
csd->cb = cb;
csd->data = data;
sd->unlock_pending = TRUE;
ril_pin_send(sim, passwd, enter_pin_done, csd);
return;
}
sd->unlock_pending = FALSE;
cbd = cb_data_new(cb, data, sim);
sd->passwd_type = passwd_type;
req.aid_str = sd->aid_str;
req.passwd_type = passwd_type;
req.enable = enable;
req.passwd = passwd;
if (!g_ril_request_pin_change_state(sd->ril,
&req,
&rilp)) {
ofono_error("Couldn't build pin change state request");
goto error;
}
ret = g_ril_send(sd->ril, RIL_REQUEST_SET_FACILITY_LOCK, &rilp,
ril_pin_change_state_cb, cbd, g_free);
error:
if (ret == 0) {
g_free(cbd);
CALLBACK_WITH_FAILURE(cb, data);
}
}
static void ril_ack_delivery(struct ofono_sms *sms)
{
struct sms_data *sd = ofono_sms_get_data(sms);
struct parcel rilp;
int ret;
int request = RIL_REQUEST_SMS_ACKNOWLEDGE;
parcel_init(&rilp);
parcel_w_int32(&rilp, 2); /* Number of int32 values in array */
parcel_w_int32(&rilp, 1); /* Successful receipt */
parcel_w_int32(&rilp, 0); /* error code */
/* TODO: should ACK be sent for either of the error cases? */
/* ACK the incoming NEW_SMS */
ret = g_ril_send(sd->ril, request,
rilp.data,
rilp.size,
ril_ack_delivery_cb, NULL, NULL);
g_ril_append_print_buf(sd->ril, "(1,0)");
g_ril_print_request(sd->ril, ret, request);
parcel_free(&rilp);
}
static void mtk_set_fast_dormancy(struct ofono_radio_settings *rs,
ofono_bool_t enable,
ofono_radio_settings_fast_dormancy_set_cb_t cb,
void *data)
{
struct radio_data *rsd = ofono_radio_settings_get_data(rs);
struct set_fd_mode *user = g_malloc0(sizeof(*user));
struct cb_data *cbd;
struct parcel rilp;
user->rst = rs;
user->on = enable;
cbd = cb_data_new(cb, data, user);
g_mtk_request_set_fd_mode(rsd->ril, MTK_FD_MODE_SCREEN_STATUS,
enable ? FALSE : TRUE, 0, &rilp);
if (g_ril_send(rsd->ril, MTK_RIL_REQUEST_SET_FD_MODE, &rilp,
mtk_set_fd_mode_cb, cbd, g_free) <= 0) {
g_free(cbd);
g_free(user);
CALLBACK_WITH_FAILURE(cb, data);
}
}
static int ril_disable(struct ofono_modem *modem)
{
DBG("%p", modem);
struct ril_data *ril = ofono_modem_get_data(modem);
struct parcel rilp;
int request = RIL_REQUEST_RADIO_POWER;
guint ret;
parcel_init(&rilp);
parcel_w_int32(&rilp, 1); /* size of array */
parcel_w_int32(&rilp, 0); /* POWER=OFF */
ofono_info("%s: RIL_REQUEST_RADIO_POWER OFF", __func__);
/* fire and forget i.e. not waiting for the callback*/
ret = g_ril_send(ril->modem, request, rilp.data,
rilp.size, NULL, NULL, NULL);
g_ril_append_print_buf(ril->modem, "(0)");
g_ril_print_request(ril->modem, ret, request);
parcel_free(&rilp);
/* this will trigger the cleanup of g_io_channel */
g_ril_unref(ril->modem);
ril->modem = NULL;
return 0;
}
static void ril_pin_send_puk(struct ofono_sim *sim,
const char *puk, const char *passwd,
ofono_sim_lock_unlock_cb_t cb, void *data)
{
struct sim_data *sd = ofono_sim_get_data(sim);
struct cb_data *cbd = cb_data_new(cb, data, sim);
struct parcel rilp;
sd->passwd_type = OFONO_SIM_PASSWORD_SIM_PUK;
parcel_init(&rilp);
parcel_w_int32(&rilp, 3);
parcel_w_string(&rilp, puk);
parcel_w_string(&rilp, passwd);
parcel_w_string(&rilp, sd->aid_str);
g_ril_append_print_buf(sd->ril, "(puk=%s,pin=%s,aid=%s)",
puk, passwd, sd->aid_str);
if (g_ril_send(sd->ril, RIL_REQUEST_ENTER_SIM_PUK, &rilp,
ril_enter_sim_puk_cb, cbd, g_free) > 0)
return;
g_free(cbd);
CALLBACK_WITH_FAILURE(cb, data);
}
static void ril_send_dtmf(struct ofono_voicecall *vc, const char *dtmf,
ofono_voicecall_cb_t cb, void *data)
{
struct voicecall_data *vd = ofono_voicecall_get_data(vc);
int len = strlen(dtmf);
struct parcel rilp;
struct ofono_error error;
char *ril_dtmf = g_try_malloc(sizeof(char) * 2);
int i;
DBG("");
/* Ril wants just one character, but we need to send as string */
ril_dtmf[1] = '\0';
for (i = 0; i < len; i++) {
parcel_init(&rilp);
ril_dtmf[0] = dtmf[i];
parcel_w_string(&rilp, ril_dtmf);
DBG("DTMF: Sending %s", ril_dtmf);
g_ril_send(vd->ril, RIL_REQUEST_DTMF, rilp.data,
rilp.size, NULL, NULL, NULL);
parcel_free(&rilp);
}
free(ril_dtmf);
/* We don't really care about errors here */
decode_ril_error(&error, "OK");
cb(&error, data);
}
static void ril_register_manual(struct ofono_netreg *netreg,
const char *mcc, const char *mnc,
ofono_netreg_register_cb_t cb, void *data)
{
struct netreg_data *nd = ofono_netreg_get_data(netreg);
struct cb_data *cbd = cb_data_new(cb, data);
char buf[OFONO_MAX_MCC_LENGTH + OFONO_MAX_MNC_LENGTH + 1];
struct parcel rilp;
int request = RIL_REQUEST_SET_NETWORK_SELECTION_MANUAL;
int ret;
/* add *netreg_data to callback */
cbd->user = nd;
parcel_init(&rilp);
/* RIL expects a char * specifying MCCMNC of network to select */
snprintf(buf, sizeof(buf), "%s%s", mcc, mnc);
parcel_w_string(&rilp, buf);
ret = g_ril_send(nd->ril, request,
rilp.data, rilp.size, ril_register_cb,
cbd, g_free);
parcel_free(&rilp);
g_ril_append_print_buf(nd->ril, "(%s)", buf);
g_ril_print_request(nd->ril, ret, request);
/* In case of error free cbd and return the cb with failure */
if (ret <= 0) {
g_free(cbd);
CALLBACK_WITH_FAILURE(cb, data);
}
}
static void ril_call_barring_set_passwd(struct ofono_call_barring *barr,
const char *lock,
const char *old_passwd,
const char *new_passwd,
ofono_call_barring_set_cb_t cb,
void *data)
{
struct barring_data *bd = ofono_call_barring_get_data(barr);
struct cb_data *cbd = cb_data_new(cb, data);
struct parcel rilp;
int ret = 0;
DBG("");
parcel_init(&rilp);
parcel_w_int32(&rilp, RIL_SET_PW_STRING_COUNT); /* Nbr of strings */
parcel_w_string(&rilp, (char *) lock); /* Facility code */
parcel_w_string(&rilp, (char *) old_passwd);
parcel_w_string(&rilp, (char *) new_passwd);
ret = g_ril_send(bd->ril, RIL_REQUEST_CHANGE_BARRING_PASSWORD,
rilp.data, rilp.size, ril_call_barring_set_passwd_cb,
cbd, g_free);
parcel_free(&rilp);
if (ret <= 0) {
ofono_error("Sending Call Barring Set PW req failed, err: %i",
ret);
g_free(cbd);
CALLBACK_WITH_FAILURE(cb, data);
}
}
static gboolean send_set_radio_cap(struct radio_data *rd,
int session, int phase, int ril_rats,
const char *logical_modem, int status,
GRilResponseFunc cb)
{
struct parcel rilp;
int version = 1;
parcel_init(&rilp);
parcel_w_int32(&rilp, version);
parcel_w_int32(&rilp, session);
parcel_w_int32(&rilp, phase);
parcel_w_int32(&rilp, ril_rats);
parcel_w_string(&rilp, logical_modem);
parcel_w_int32(&rilp, status);
g_ril_append_print_buf(rd->ril, "(%d,%d,%d,0x%X,%s,%d)", version,
session, phase, ril_rats, logical_modem, status);
if (g_ril_send(rd->ril, RIL_REQUEST_SET_RADIO_CAPABILITY,
&rilp, cb, rd, NULL) == 0)
return FALSE;
return TRUE;
}
static int ril_disable(struct ofono_modem *modem)
{
DBusConnection *conn = ofono_dbus_get_connection();
struct ril_data *rd = ofono_modem_get_data(modem);
const char *path = ofono_modem_get_path(modem);
struct parcel rilp;
int cmd_id;
char buf[4];
DBG("%p", modem);
if (g_dbus_unregister_interface(conn, path,
THERMAL_MANAGEMENT_INTERFACE))
ofono_modem_remove_interface(modem,
THERMAL_MANAGEMENT_INTERFACE);
/* RIL_OEM_HOOK_STRING_SET_MODEM_OFF = 0x000000CF */
cmd_id = 0x000000CF;
sprintf(buf, "%d", cmd_id);
parcel_init(&rilp);
parcel_w_int32(&rilp, 1);
parcel_w_string(&rilp, buf);
g_ril_append_print_buf(rd->ril, "{cmd_id=0x%02X}", cmd_id);
g_ril_send(rd->ril, RIL_REQUEST_OEM_HOOK_STRINGS, &rilp,
ril_send_power_off_cb, modem, NULL);
return -EINPROGRESS;
}
static void ril_gprs_registration_status(struct ofono_gprs *gprs,
ofono_gprs_status_cb_t cb,
void *data)
{
struct gprs_data *gd = ofono_gprs_get_data(gprs);
struct cb_data *cbd = cb_data_new(cb, data);
int request = RIL_REQUEST_DATA_REGISTRATION_STATE;
guint ret;
DBG("");
if (gd == NULL || cbd == NULL)
return;
cbd->user = gprs;
ret = g_ril_send(gd->ril, request,
NULL, 0,
((gd->rild_status == -1)
? ril_data_probe_reg_cb
: ril_data_reg_cb), cbd, g_free);
g_ril_print_request_no_args(gd->ril, ret, request);
if (ret <= 0) {
ofono_error("Send RIL_REQUEST_DATA_RESTISTRATION_STATE fail.");
g_free(cbd);
if (cb)
CALLBACK_WITH_FAILURE(cb, -1, data);
}
}
static int ril_thermal_management_enable(struct ofono_modem *modem)
{
struct ril_data *rd = ofono_modem_get_data(modem);
struct parcel rilp;
int cmd_id;
char buf[4];
DBG("");
parcel_init(&rilp);
parcel_w_int32(&rilp, 1);
/* RIL_OEM_HOOK_STRING_GET_RF_POWER_STATUS = 0x000000AB */
cmd_id = 0x000000AB;
sprintf(buf, "%d", cmd_id);
parcel_w_string(&rilp, buf);
g_ril_append_print_buf(rd->ril, "{cmd_id=0x%02X}", cmd_id);
if (g_ril_send(rd->ril, RIL_REQUEST_OEM_HOOK_STRINGS, &rilp,
get_rf_power_status_cb, modem, NULL) > 0)
return 0;
/* Error path */
return -EIO;
}
static void send_get_sim_status(struct ofono_sim *sim)
{
struct sim_data *sd = ofono_sim_get_data(sim);
g_ril_send(sd->ril, RIL_REQUEST_GET_SIM_STATUS, NULL,
sim_status_cb, sim, NULL);
}
static void ril_change_passwd(struct ofono_sim *sim,
enum ofono_sim_password_type passwd_type,
const char *old_passwd, const char *new_passwd,
ofono_sim_lock_unlock_cb_t cb, void *data)
{
struct sim_data *sd = ofono_sim_get_data(sim);
struct cb_data *cbd = cb_data_new(cb, data, sim);
struct parcel rilp;
int request = RIL_REQUEST_CHANGE_SIM_PIN;
sd->passwd_type = passwd_type;
g_ril_request_change_passwd(sd->ril,
old_passwd,
new_passwd,
sd->aid_str,
&rilp);
if (passwd_type == OFONO_SIM_PASSWORD_SIM_PIN2)
request = RIL_REQUEST_CHANGE_SIM_PIN2;
if (g_ril_send(sd->ril, request, &rilp, ril_pin_change_state_cb,
cbd, g_free) == 0) {
g_free(cbd);
CALLBACK_WITH_FAILURE(cb, data);
}
}
static void ril_template(const guint rreq, struct ofono_voicecall *vc,
GRilResponseFunc func, unsigned int affected_types,
gpointer pdata, const gsize psize,
ofono_voicecall_cb_t cb, void *data)
{
struct voicecall_data *vd = ofono_voicecall_get_data(vc);
struct change_state_req *req = g_try_new0(struct change_state_req, 1);
if (req == NULL)
goto error;
req->vc = vc;
req->cb = cb;
req->data = data;
req->affected_types = affected_types;
if (g_ril_send(vd->ril, rreq, pdata, psize, func, req, g_free) > 0)
return;
error:
g_free(req);
if (cb)
CALLBACK_WITH_FAILURE(cb, data);
}
static void set_ia_apn(struct ofono_radio_settings *rs)
{
char mccmnc[OFONO_MAX_MCC_LENGTH + OFONO_MAX_MNC_LENGTH + 1];
struct radio_data *rd = ofono_radio_settings_get_data(rs);
struct parcel rilp;
struct ofono_gprs *gprs;
const struct ofono_gprs_primary_context *ia_ctx;
if ((rd->available_rats & OFONO_RADIO_ACCESS_MODE_LTE) == 0)
return;
gprs = __ofono_atom_find(OFONO_ATOM_TYPE_GPRS, rd->modem);
if (gprs == NULL)
return;
/* Ask for APN data */
ia_ctx = ofono_gprs_get_ia_apn(gprs, mccmnc);
if (ia_ctx == NULL)
return;
g_ril_request_set_initial_attach_apn(rd->ril, ia_ctx->apn,
ia_ctx->proto, ia_ctx->username,
ia_ctx->password, mccmnc,
&rilp);
if (g_ril_send(rd->ril, RIL_REQUEST_SET_INITIAL_ATTACH_APN,
&rilp, set_ia_apn_cb, rs, NULL) == 0)
ofono_error("%s: failure sending request", __func__);
}
static void ril_dial(struct ofono_voicecall *vc,
const struct ofono_phone_number *ph,
enum ofono_clir_option clir, ofono_voicecall_cb_t cb,
void *data)
{
struct voicecall_data *vd = ofono_voicecall_get_data(vc);
struct cb_data *cbd = cb_data_new(cb, data);
struct parcel rilp;
int ret;
cbd->user = vc;
parcel_init(&rilp);
/* Number to dial */
parcel_w_string(&rilp, phone_number_to_string(ph));
/* CLIR mode */
parcel_w_int32(&rilp, clir);
/* USS, need it twice for absent */
/* TODO: Deal with USS properly */
parcel_w_int32(&rilp, 0);
parcel_w_int32(&rilp, 0);
/* Send request to RIL */
ret = g_ril_send(vd->ril, RIL_REQUEST_DIAL, rilp.data,
rilp.size, rild_cb, cbd, g_free);
parcel_free(&rilp);
/* In case of error free cbd and return the cb with failure */
if (ret <= 0) {
g_free(cbd);
CALLBACK_WITH_FAILURE(cb, data);
}
}
void ril_gprs_set_ia_apn(struct ofono_gprs *gprs, const char *apn,
enum ofono_gprs_proto proto, const char *user,
const char *passwd, const char *mccmnc,
ofono_gprs_cb_t cb, void *data)
{
struct ril_gprs_data *gd = ofono_gprs_get_data(gprs);
struct cb_data *cbd;
struct parcel rilp;
if (!ofono_modem_get_boolean(gd->modem, MODEM_PROP_LTE_CAPABLE)) {
CALLBACK_WITH_SUCCESS(cb, data);
return;
}
cbd = cb_data_new(cb, data, gprs);
g_ril_request_set_initial_attach_apn(gd->ril, apn, proto, user, passwd,
mccmnc, &rilp);
if (g_ril_send(gd->ril, RIL_REQUEST_SET_INITIAL_ATTACH_APN,
&rilp, set_ia_apn_cb, cbd, g_free) == 0) {
ofono_error("%s: failure sending request", __func__);
g_free(cbd);
CALLBACK_WITH_FAILURE(cb, data);
}
}
static void ril_network_state_change(struct ril_msg *message, gpointer user_data)
{
struct ofono_netreg *netreg = user_data;
struct netreg_data *nd = ofono_netreg_get_data(netreg);
struct cb_data *cbd = cb_data_new(ril_creg_notify, netreg);
int request = RIL_REQUEST_VOICE_REGISTRATION_STATE;
int ret;
cbd->user = nd;
if (message->req != RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED)
goto error;
g_ril_print_unsol_no_args(nd->ril, message);
ret = g_ril_send(nd->ril, request, NULL,
0, ril_creg_cb, cbd, g_free);
/* For operator update ofono will use the current_operator cb
* so we don't need to probe ril here */
g_ril_print_request_no_args(nd->ril, ret, request);
if (ret > 0)
return;
error:
ofono_error("Unable to request network state changed");
g_free(cbd);
}
static void ril_call_barring_set(struct ofono_call_barring *cb,
const char *lock, int enable,
const char *passwd, int cls,
ofono_call_barring_set_cb_t callback,
void *data)
{
struct barring_data *bd = ofono_call_barring_get_data(cb);
struct cb_data *cbd = cb_data_new(callback, data, bd);
struct parcel rilp;
char svcs_str[4];
DBG("lock: %s, enable: %d, bearer class: %d", lock, enable, cls);
FIXUP_CLS();
parcel_init(&rilp);
parcel_w_int32(&rilp, 5); /* # of strings */
parcel_w_string(&rilp, lock);
parcel_w_string(&rilp, enable ? "1" : "0");
parcel_w_string(&rilp, passwd);
snprintf(svcs_str, sizeof(svcs_str), "%d", cls);
parcel_w_string(&rilp, svcs_str);
parcel_w_string(&rilp, NULL); /* AID (for FDN, not yet supported) */
g_ril_append_print_buf(bd->ril, "(%s,%s,%s,%s,(null))",
lock, enable ? "1" : "0", passwd, svcs_str);
if (g_ril_send(bd->ril, RIL_REQUEST_SET_FACILITY_LOCK, &rilp,
ril_call_barring_set_cb, cbd, g_free) > 0)
return;
g_free(cbd);
CALLBACK_WITH_FAILURE(callback, data);
}
static void ril_set_online(struct ofono_modem *modem, ofono_bool_t online,
ofono_modem_online_cb_t callback, void *data)
{
DBG("Set online state (online = 1, offline = 0)): %i", online);
struct ril_data *ril = ofono_modem_get_data(modem);
struct cb_data *cbd = cb_data_new(callback, data);
struct parcel rilp;
int ret = 0;
parcel_init(&rilp);
parcel_w_int32(&rilp, 1); /* Number of params */
parcel_w_int32(&rilp, online); /* Radio ON = 1, Radio OFF = 0 */
ofono_info("%s: RIL_REQUEST_RADIO_POWER %d", __func__, online);
ret = g_ril_send(ril->modem, RIL_REQUEST_RADIO_POWER, rilp.data,
rilp.size, ril_set_online_cb, cbd, g_free);
parcel_free(&rilp);
DBG("RIL_REQUEST_RADIO_POWER done");
if (ret <= 0) {
g_free(cbd);
CALLBACK_WITH_FAILURE(callback, data);
} else {
if (online)
current_online_state = RIL_ONLINE_PREF;
else
current_online_state = RIL_OFFLINE;
}
}
static void ril_call_barring_set_passwd(struct ofono_call_barring *barr,
const char *lock,
const char *old_passwd,
const char *new_passwd,
ofono_call_barring_set_cb_t cb,
void *data)
{
struct barring_data *bd = ofono_call_barring_get_data(barr);
struct cb_data *cbd = cb_data_new(cb, data, bd);
struct parcel rilp;
DBG("lock %s old %s new %s", lock, old_passwd, new_passwd);
parcel_init(&rilp);
parcel_w_int32(&rilp, 3); /* # of strings */
parcel_w_string(&rilp, lock);
parcel_w_string(&rilp, old_passwd);
parcel_w_string(&rilp, new_passwd);
g_ril_append_print_buf(bd->ril, "(%s,%s,%s)",
lock, old_passwd, new_passwd);
if (g_ril_send(bd->ril, RIL_REQUEST_CHANGE_BARRING_PASSWORD, &rilp,
ril_call_barring_set_passwd_cb, cbd, g_free) > 0)
return;
g_free(cbd);
CALLBACK_WITH_FAILURE(cb, data);
}
static void ril_pin_send(struct ofono_sim *sim, const char *passwd,
ofono_sim_lock_unlock_cb_t cb, void *data)
{
/*
* TODO: This function is supposed to enter the pending password, which
* might be also PIN2. So we must check the pending PIN in the future.
*/
struct sim_data *sd = ofono_sim_get_data(sim);
struct cb_data *cbd = cb_data_new(cb, data, sim);
struct parcel rilp;
sd->passwd_type = OFONO_SIM_PASSWORD_SIM_PIN;
parcel_init(&rilp);
parcel_w_int32(&rilp, 2);
parcel_w_string(&rilp, passwd);
parcel_w_string(&rilp, sd->aid_str);
g_ril_append_print_buf(sd->ril, "(%s,aid=%s)", passwd, sd->aid_str);
if (g_ril_send(sd->ril, RIL_REQUEST_ENTER_SIM_PIN, &rilp,
ril_enter_sim_pin_cb, cbd, g_free) > 0)
return;
g_free(cbd);
CALLBACK_WITH_FAILURE(cb, data);
}
static void ril_call_barring_query(struct ofono_call_barring *cb,
const char *lock, int cls,
ofono_call_barring_query_cb_t callback,
void *data)
{
struct barring_data *bd = ofono_call_barring_get_data(cb);
struct cb_data *cbd = cb_data_new(callback, data, bd);
struct parcel rilp;
char svcs_str[4];
DBG("lock: %s, services to query: %d", lock, cls);
FIXUP_CLS();
parcel_init(&rilp);
parcel_w_int32(&rilp, 4); /* # of strings */
parcel_w_string(&rilp, lock);
parcel_w_string(&rilp, ""); /* Password is empty when not needed */
snprintf(svcs_str, sizeof(svcs_str), "%d", cls);
parcel_w_string(&rilp, svcs_str);
parcel_w_string(&rilp, NULL); /* AID (for FDN, not yet supported) */
g_ril_append_print_buf(bd->ril, "(%s,\"\",%s,(null))",
lock, svcs_str);
if (g_ril_send(bd->ril, RIL_REQUEST_QUERY_FACILITY_LOCK, &rilp,
ril_call_barring_query_cb, cbd, g_free) > 0)
return;
g_free(cbd);
CALLBACK_WITH_FAILURE(callback, -1, data);
}
static void ril_send_power(struct ril_data *rd, ofono_bool_t online,
GRilResponseFunc func,
gpointer user_data)
{
struct cb_data *cbd = user_data;
ofono_modem_online_cb_t cb;
GDestroyNotify notify = NULL;
struct parcel rilp;
if (cbd != NULL) {
notify = g_free;
cb = cbd->cb;
}
DBG("(online = 1, offline = 0)): %i", online);
parcel_init(&rilp);
parcel_w_int32(&rilp, 1);
parcel_w_int32(&rilp, online);
g_ril_append_print_buf(rd->ril, "(%d)", online);
if (g_ril_send(rd->ril, RIL_REQUEST_RADIO_POWER, &rilp,
func, cbd, notify) == 0 && cbd != NULL) {
CALLBACK_WITH_FAILURE(cb, cbd->data);
g_free(cbd);
}
}
static void ril_send_power(struct ril_data *ril, ofono_bool_t online,
GRilResponseFunc func,
gpointer user_data)
{
struct cb_data *cbd = user_data;
ofono_modem_online_cb_t cb;
GDestroyNotify notify = NULL;
struct parcel rilp;
if (cbd != NULL) {
notify = g_free;
cb = cbd->cb;
}
DBG("(online = 1, offline = 0)): %i", online);
g_ril_request_power(ril->modem, (const gboolean) online, &rilp);
if (g_ril_send(ril->modem, RIL_REQUEST_RADIO_POWER, &rilp,
func, cbd, notify) == 0 && cbd != NULL) {
CALLBACK_WITH_FAILURE(cb, cbd->data);
g_free(cbd);
}
}
static void ril_csca_set(struct ofono_sms *sms,
const struct ofono_phone_number *sca,
ofono_sms_sca_set_cb_t cb, void *user_data)
{
struct sms_data *data = ofono_sms_get_data(sms);
struct cb_data *cbd = cb_data_new(cb, user_data);
struct parcel rilp;
int ret = -1;
char number[OFONO_MAX_PHONE_NUMBER_LENGTH + 4];
if (sca->type == 129)
snprintf(number, sizeof(number), "\"%s\"", sca->number);
else
snprintf(number, sizeof(number), "\"+%s\"", sca->number);
DBG("Setting sca: %s", number);
parcel_init(&rilp);
parcel_w_string(&rilp, number);
/* Send request to RIL */
ret = g_ril_send(data->ril, RIL_REQUEST_SET_SMSC_ADDRESS, rilp.data,
rilp.size, ril_csca_set_cb, cbd, g_free);
parcel_free(&rilp);
/* In case of error free cbd and return the cb with failure */
if (ret <= 0) {
g_free(cbd);
CALLBACK_WITH_FAILURE(cb, user_data);
}
}
static void generic_cb(struct ril_msg *message, gpointer user_data)
{
struct change_state_req *req = user_data;
struct voicecall_data *vd = ofono_voicecall_get_data(req->vc);
struct ofono_error error;
if (message->error == RIL_E_SUCCESS) {
decode_ril_error(&error, "OK");
} else {
decode_ril_error(&error, "FAIL");
goto out;
}
if (req->affected_types) {
GSList *l;
struct ofono_call *call;
for (l = vd->calls; l; l = l->next) {
call = l->data;
if (req->affected_types & (1 << call->status))
vd->local_release |= (1 << call->id);
}
}
out:
g_ril_send(vd->ril, RIL_REQUEST_GET_CURRENT_CALLS, NULL,
0, clcc_poll_cb, req->vc, NULL);
/* We have to callback after we schedule a poll if required */
if (req->cb)
req->cb(&error, req->data);
}
static void ril_set_rat_mode(struct ofono_radio_settings *rs,
enum ofono_radio_access_mode mode,
ofono_radio_settings_rat_mode_set_cb_t cb,
void *data)
{
struct radio_data *rd = ofono_radio_settings_get_data(rs);
struct cb_data *cbd = cb_data_new(cb, data, rs);
struct parcel rilp;
int pref = PREF_NET_TYPE_GSM_WCDMA;
switch (mode) {
case OFONO_RADIO_ACCESS_MODE_ANY:
pref = PREF_NET_TYPE_LTE_GSM_WCDMA;
break;
case OFONO_RADIO_ACCESS_MODE_GSM:
pref = PREF_NET_TYPE_GSM_ONLY;
break;
case OFONO_RADIO_ACCESS_MODE_UMTS:
pref = PREF_NET_TYPE_GSM_WCDMA;
break;
case OFONO_RADIO_ACCESS_MODE_LTE:
pref = PREF_NET_TYPE_LTE_GSM_WCDMA;
break;
}
g_ril_request_set_preferred_network_type(rd->ril, pref, &rilp);
if (g_ril_send(rd->ril, RIL_REQUEST_SET_PREFERRED_NETWORK_TYPE,
&rilp, ril_set_rat_cb, cbd, g_free) == 0) {
ofono_error("%s: unable to set rat mode", __func__);
g_free(cbd);
CALLBACK_WITH_FAILURE(cb, data);
}
}
static void ril_pin_send(struct ofono_sim *sim, const char *passwd,
ofono_sim_lock_unlock_cb_t cb, void *data)
{
/*
* TODO: This function is supposed to enter the pending password, which
* might be also PIN2. So we must check the pending PIN in the future.
*/
struct sim_data *sd = ofono_sim_get_data(sim);
struct cb_data *cbd = cb_data_new(cb, data, sim);
struct parcel rilp;
sd->passwd_type = OFONO_SIM_PASSWORD_SIM_PIN;
g_ril_request_pin_send(sd->ril,
passwd,
sd->aid_str,
&rilp);
if (g_ril_send(sd->ril, RIL_REQUEST_ENTER_SIM_PIN, &rilp,
ril_pin_change_state_cb, cbd, g_free) == 0) {
g_free(cbd);
CALLBACK_WITH_FAILURE(cb, data);
}
}
