void g_ril_request_set_initial_attach_apn(GRil *gril, const char *apn,
int proto,
const char *user,
const char *passwd,
const char *mccmnc,
struct parcel *rilp)
{
const char *proto_str;
const int auth_type = RIL_AUTH_ANY;
parcel_init(rilp);
parcel_w_string(rilp, apn);
proto_str = ril_ofono_protocol_to_ril_string(proto);
parcel_w_string(rilp, proto_str);
parcel_w_int32(rilp, auth_type);
parcel_w_string(rilp, user);
parcel_w_string(rilp, passwd);
g_ril_append_print_buf(gril, "(%s,%s,%s,%s,%s", apn, proto_str,
ril_authtype_to_string(auth_type),
user, passwd);
if (g_ril_vendor(gril) == OFONO_RIL_VENDOR_MTK) {
parcel_w_string(rilp, mccmnc);
g_ril_append_print_buf(gril, "%s,%s)", print_buf, mccmnc);
} else {
g_ril_append_print_buf(gril, "%s)", print_buf);
}
}
struct parcel_str_array *g_ril_reply_oem_hook_strings(GRil *gril,
const struct ril_msg *message)
{
struct parcel rilp;
struct parcel_str_array *str_arr;
int i;
g_ril_init_parcel(message, &rilp);
str_arr = parcel_r_str_array(&rilp);
if (str_arr == NULL) {
ofono_error("%s: no strings", __func__);
goto out;
}
g_ril_append_print_buf(gril, "{");
for (i = 0; i < str_arr->num_str; ++i) {
if (i + 1 == str_arr->num_str)
g_ril_append_print_buf(gril, "%s%s}", print_buf,
str_arr->str[i]);
else
g_ril_append_print_buf(gril, "%s%s, ", print_buf,
str_arr->str[i]);
}
g_ril_print_response(gril, message);
out:
return str_arr;
}
static void set_data_reg_state(GRil *gril, struct reply_data_reg_state *reply,
int i, const char *str)
{
unsigned val;
char *endp;
if (str == NULL || *str == '\0')
goto no_val;
val = (unsigned) strtoul(str, &endp, 10);
if (*endp != '\0')
goto no_val;
switch (i) {
case RDST_IX_MAXDC:
/*
* MTK modem does not return max_cids, string for this index
* actually contains the maximum data bearer capability.
*/
if (g_ril_vendor(gril) == OFONO_RIL_VENDOR_MTK)
reply->max_cids = MTK_MODEM_MAX_CIDS;
else
reply->max_cids = val;
g_ril_append_print_buf(gril, "%s%u", print_buf, val);
break;
default:
goto no_val;
}
return;
no_val:
g_ril_append_print_buf(gril, "%s%s", print_buf, str ? str : "(null)");
}
static void ril_sim_read_record(struct ofono_sim *sim, int fileid,
int record, int length,
const unsigned char *path,
unsigned int path_len,
ofono_sim_read_cb_t cb, void *data)
{
struct sim_data *sd = ofono_sim_get_data(sim);
struct cb_data *cbd = cb_data_new(cb, data);
struct parcel rilp;
int request = RIL_REQUEST_SIM_IO;
guint ret;
cbd->user = sd;
parcel_init(&rilp);
parcel_w_int32(&rilp, CMD_READ_RECORD);
parcel_w_int32(&rilp, fileid);
g_ril_append_print_buf(sd->ril,
"(cmd=0x%.2X,efid=0x%.4X,",
CMD_GET_RESPONSE,
fileid);
set_path(sd, &rilp, fileid, path, path_len);
parcel_w_int32(&rilp, record); /* P1 */
parcel_w_int32(&rilp, 4); /* P2 */
parcel_w_int32(&rilp, length); /* P3 */
parcel_w_string(&rilp, NULL); /* data; only req'd for writes */
parcel_w_string(&rilp, NULL); /* pin2; only req'd for writes */
parcel_w_string(&rilp, sd->aid_str); /* AID (Application ID) */
ret = g_ril_send(sd->ril,
request,
rilp.data,
rilp.size,
ril_file_io_cb, cbd, g_free);
g_ril_append_print_buf(sd->ril,
"%s%d,%d,%d,(null),pin2=(null),aid=%s)",
print_buf,
record,
4,
length,
sd->aid_str);
g_ril_print_request(sd->ril, ret, request);
parcel_free(&rilp);
if (ret <= 0) {
g_free(cbd);
CALLBACK_WITH_FAILURE(cb, NULL, 0, data);
}
}
gboolean g_ril_request_sim_write_binary(GRil *gril,
const struct req_sim_write_binary *req,
struct parcel *rilp)
{
char *hex_data;
int p1, p2;
parcel_init(rilp);
parcel_w_int32(rilp, CMD_UPDATE_BINARY);
parcel_w_int32(rilp, req->fileid);
g_ril_append_print_buf(gril, "(cmd=0x%02X,efid=0x%04X,",
CMD_UPDATE_BINARY, req->fileid);
if (set_path(gril, req->app_type, rilp, req->fileid,
req->path, req->path_len) == FALSE)
goto error;
p1 = req->start >> 8;
p2 = req->start & 0xff;
hex_data = encode_hex(req->data, req->length, 0);
parcel_w_int32(rilp, p1); /* P1 */
parcel_w_int32(rilp, p2); /* P2 */
parcel_w_int32(rilp, req->length); /* P3 (Lc) */
parcel_w_string(rilp, hex_data); /* data */
parcel_w_string(rilp, NULL); /* pin2; only for FDN/BDN */
parcel_w_string(rilp, req->aid_str); /* AID (Application ID) */
/* sessionId, specific to latest MTK modems (harmless for older ones) */
if (g_ril_vendor(gril) == OFONO_RIL_VENDOR_MTK)
parcel_w_int32(rilp, 0);
g_ril_append_print_buf(gril,
"%s%d,%d,%d,%s,pin2=(null),aid=%s)",
print_buf,
p1,
p2,
req->length,
hex_data,
req->aid_str);
g_free(hex_data);
return TRUE;
error:
return FALSE;
}
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_enter_sim_puk_cb(struct ril_msg *message, gpointer user_data)
{
struct cb_data *cbd = user_data;
ofono_sim_lock_unlock_cb_t cb = cbd->cb;
struct ofono_sim *sim = cbd->user;
struct sim_data *sd = ofono_sim_get_data(sim);
struct parcel rilp;
g_ril_init_parcel(message, &rilp);
parcel_r_int32(&rilp);
if (message->error != RIL_E_SUCCESS) {
sd->retries[OFONO_SIM_PASSWORD_SIM_PUK] = parcel_r_int32(&rilp);
} else {
sd->retries[OFONO_SIM_PASSWORD_SIM_PIN] = -1;
sd->retries[OFONO_SIM_PASSWORD_SIM_PUK] = -1;
}
g_ril_append_print_buf(sd->ril, "{%d}",
sd->retries[OFONO_SIM_PASSWORD_SIM_PUK]);
g_ril_print_response(sd->ril, message);
if (message->error == RIL_E_SUCCESS) {
CALLBACK_WITH_SUCCESS(cb, cbd->data);
return;
}
CALLBACK_WITH_FAILURE(cb, cbd->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 gboolean parse_sim_io(GRil *ril, struct ril_msg *message,
int *sw1, int *sw2, char **hex_response)
{
struct parcel rilp;
/*
* Minimum length of SIM_IO_Response is 12:
* sw1 (int32)
* sw2 (int32)
* simResponse (string)
*/
if (message->buf_len < 12) {
ofono_error("Invalid SIM IO reply: size too small (< 12): %u",
message->buf_len);
return FALSE;
}
g_ril_init_parcel(message, &rilp);
*sw1 = parcel_r_int32(&rilp);
*sw2 = parcel_r_int32(&rilp);
*hex_response = parcel_r_string(&rilp);
g_ril_append_print_buf(ril, "(sw1=0x%.2X,sw2=0x%.2X,%s)",
*sw1, *sw2, *hex_response);
g_ril_print_response(ril, message);
if (rilp.malformed) {
g_free(*hex_response);
return FALSE;
}
return TRUE;
}
static void ril_radio_state_changed(struct ril_msg *message,
gpointer user_data)
{
struct ofono_modem *modem = user_data;
struct ril_data *rd = ofono_modem_get_data(modem);
struct parcel rilp;
int radio_state;
g_ril_init_parcel(message, &rilp);
radio_state = parcel_r_int32(&rilp);
if (rilp.malformed) {
ofono_error("%s: malformed parcel received", __func__);
ofono_modem_set_powered(modem, FALSE);
return;
}
g_ril_append_print_buf(rd->ril, "(state: %s)",
ril_radio_state_to_string(radio_state));
g_ril_print_unsol(rd->ril, message);
switch (radio_state) {
case RADIO_STATE_ON:
break;
case RADIO_STATE_UNAVAILABLE:
ofono_modem_set_powered(modem, FALSE);
break;
case RADIO_STATE_OFF:
break;
}
}
int g_ril_reply_parse_query_facility_lock(GRil *gril,
const struct ril_msg *message)
{
struct parcel rilp;
int status, numint;
g_ril_init_parcel(message, &rilp);
/* infineon returns two integers */
numint = parcel_r_int32(&rilp);
if (numint < 1) {
ofono_error("%s: wrong format", __func__);
goto error;
}
status = parcel_r_int32(&rilp);
if (rilp.malformed) {
ofono_error("%s: malformed parcel", __func__);
goto error;
}
g_ril_append_print_buf(gril, "{%d}", status);
g_ril_print_response(gril, message);
return status;
error:
return -1;
}
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);
}
int g_ril_unsol_parse_connected(GRil *gril, const struct ril_msg *message)
{
struct parcel rilp;
int size;
int version;
DBG("");
g_ril_init_parcel(message, &rilp);
size = parcel_r_int32(&rilp);
version = parcel_r_int32(&rilp);
/*
* For something that looks like a bug we get an extra int in mtk2
* modems. RIL version is the second integer in this case. This
* happens when we get duplicated connected events, which should
* not happen either. In these cases the first event has the right
* size, but not those appearing after.
*/
if (g_ril_vendor(gril) == OFONO_RIL_VENDOR_MTK2 && size > 1)
version = parcel_r_int32(&rilp);
if (rilp.malformed) {
ofono_error("%s: malformed parcel", __func__);
version = RIL_VERSION_UNSPECIFIED;
}
g_ril_append_print_buf(gril, "{size: %d, [%d]}", size, version);
g_ril_print_unsol(gril, message);
return version;
}
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_call_barring_query_cb(struct ril_msg *message,
gpointer user_data)
{
struct cb_data *cbd = user_data;
ofono_call_barring_query_cb_t cb = cbd->cb;
struct barring_data *bd = cbd->user;
struct parcel rilp;
int bearer_class;
if (message->error != RIL_E_SUCCESS)
goto error;
g_ril_init_parcel(message, &rilp);
/* TODO: infineon returns two integers, use a quirk here */
if (parcel_r_int32(&rilp) < 1)
goto error;
bearer_class = parcel_r_int32(&rilp);
if (bearer_class < 0 || rilp.malformed)
goto error;
g_ril_append_print_buf(bd->ril, "{%d}", bearer_class);
g_ril_print_response(bd->ril, message);
CALLBACK_WITH_SUCCESS(cb, bearer_class, cbd->data);
return;
error:
CALLBACK_WITH_FAILURE(cb, -1, cbd->data);
}
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_call_barring_set_cb(struct ril_msg *message, gpointer user_data)
{
struct cb_data *cbd = user_data;
ofono_call_barring_set_cb_t cb = cbd->cb;
struct barring_data *bd = cbd->user;
struct parcel rilp;
int retries = -1;
if (message->error != RIL_E_SUCCESS)
goto error;
g_ril_init_parcel(message, &rilp);
/* mako reply has no payload for call barring */
if (parcel_data_avail(&rilp) == 0)
goto done;
if (parcel_r_int32(&rilp) != 1)
goto error;
retries = parcel_r_int32(&rilp);
if (rilp.malformed)
goto error;
done:
g_ril_append_print_buf(bd->ril, "{%d}", retries);
g_ril_print_response(bd->ril, message);
CALLBACK_WITH_SUCCESS(cb, cbd->data);
return;
error:
CALLBACK_WITH_FAILURE(cb, cbd->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 void ril_query_facility_lock_cb(struct ril_msg *message,
gpointer user_data)
{
struct cb_data *cbd = user_data;
ofono_query_facility_lock_cb_t cb = cbd->cb;
struct sim_data *sd = cbd->user;
struct parcel rilp;
ofono_bool_t status;
int numparams;
if (message->error != RIL_E_SUCCESS)
goto error;
g_ril_init_parcel(message, &rilp);
numparams = parcel_r_int32(&rilp);
if (numparams < 1)
goto error;
status = (ofono_bool_t) parcel_r_int32(&rilp);
g_ril_append_print_buf(sd->ril, "{%d}", status);
g_ril_print_response(sd->ril, message);
CALLBACK_WITH_SUCCESS(cb, status, cbd->data);
return;
error:
CALLBACK_WITH_FAILURE(cb, 0, cbd->data);
}
int g_ril_reply_parse_sms_response(GRil *gril, const struct ril_msg *message)
{
struct parcel rilp;
int error, mr;
char *ack_pdu;
/* Set up Parcel struct for proper parsing */
g_ril_init_parcel(message, &rilp);
/*
* TP-Message-Reference for GSM/
* BearerData MessageId for CDMA
*/
mr = parcel_r_int32(&rilp);
ack_pdu = parcel_r_string(&rilp);
error = parcel_r_int32(&rilp);
g_ril_append_print_buf(gril, "{%d,%s,%d}",
mr, ack_pdu, error);
g_ril_print_response(gril, message);
g_free(ack_pdu);
return mr;
}
static void ril_imsi_cb(struct ril_msg *message, gpointer user_data)
{
struct cb_data *cbd = user_data;
ofono_sim_imsi_cb_t cb = cbd->cb;
struct sim_data *sd = cbd->user;
struct parcel rilp;
gchar *imsi;
DBG("");
if (message->error != RIL_E_SUCCESS) {
ofono_error("Reply failure: %s",
ril_error_to_string(message->error));
goto error;
}
g_ril_init_parcel(message, &rilp);
imsi = parcel_r_string(&rilp);
g_ril_append_print_buf(sd->ril, "{%s}", imsi ? imsi : "NULL");
g_ril_print_response(sd->ril, message);
if (imsi == NULL)
goto error;
CALLBACK_WITH_SUCCESS(cb, imsi, cbd->data);
g_free(imsi);
return;
error:
CALLBACK_WITH_FAILURE(cb, NULL, cbd->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);
}
}
int g_ril_reply_parse_set_facility_lock(GRil *gril,
const struct ril_msg *message)
{
struct parcel rilp;
int retries = -1, numint;
g_ril_init_parcel(message, &rilp);
/* mako reply has no payload for call barring */
if (parcel_data_avail(&rilp) == 0)
goto end;
numint = parcel_r_int32(&rilp);
if (numint != 1) {
ofono_error("%s: wrong format", __func__);
goto end;
}
retries = parcel_r_int32(&rilp);
if (rilp.malformed) {
ofono_error("%s: malformed parcel", __func__);
goto end;
}
end:
g_ril_append_print_buf(gril, "{%d}", retries);
g_ril_print_response(gril, message);
return retries;
}
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;
}
struct unsol_supp_svc_notif *g_ril_unsol_parse_supp_svc_notif(GRil *gril,
struct ril_msg *message)
{
struct parcel rilp;
char *tmp_number;
int type;
struct unsol_supp_svc_notif *unsol =
g_new0(struct unsol_supp_svc_notif, 1);
g_ril_init_parcel(message, &rilp);
unsol->notif_type = parcel_r_int32(&rilp);
unsol->code = parcel_r_int32(&rilp);
unsol->index = parcel_r_int32(&rilp);
type = parcel_r_int32(&rilp);
tmp_number = parcel_r_string(&rilp);
if (tmp_number != NULL) {
strncpy(unsol->number.number, tmp_number,
OFONO_MAX_PHONE_NUMBER_LENGTH);
unsol->number.type = type;
g_free(tmp_number);
}
g_ril_append_print_buf(gril, "{%d,%d,%d,%d,%s}",
unsol->notif_type, unsol->code, unsol->index,
type, tmp_number);
g_ril_print_unsol(gril, message);
return unsol;
}
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;
}
int g_ril_reply_parse_query_call_waiting(GRil *gril,
const struct ril_msg *message)
{
struct parcel rilp;
int numint, enabled, cls;
g_ril_init_parcel(message, &rilp);
numint = parcel_r_int32(&rilp);
if (numint < 1) {
ofono_error("%s Wrong format", __func__);
goto error;
}
enabled = parcel_r_int32(&rilp);
if (enabled > 0)
cls = parcel_r_int32(&rilp);
else
cls = 0;
g_ril_append_print_buf(gril, "{%d,0x%x}", enabled, cls);
g_ril_print_response(gril, message);
return cls;
error:
return -1;
}
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_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 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;
}
