static void mtk_query_available_rats_cb(struct ril_msg *message,
gpointer user_data)
{
struct cb_data *cbd = user_data;
struct ofono_radio_settings *rs = cbd->user;
struct radio_data *rd = ofono_radio_settings_get_data(rs);
ofono_radio_settings_available_rats_query_cb_t cb = cbd->cb;
unsigned int available_rats = OFONO_RADIO_ACCESS_MODE_GSM;
int slot_3g, is_3g;
if (message->error != RIL_E_SUCCESS) {
ofono_error("%s: error %s", __func__,
ril_error_to_string(message->error));
CALLBACK_WITH_FAILURE(cb, 0, cbd->data);
return;
}
slot_3g = g_mtk_reply_parse_get_3g_capability(rd->ril, message);
if (slot_3g < 0) {
ofono_error("%s: parse error", __func__);
CALLBACK_WITH_FAILURE(cb, 0, cbd->data);
return;
}
is_3g = (g_ril_get_slot(rd->ril) == slot_3g);
if (is_3g) {
available_rats |= OFONO_RADIO_ACCESS_MODE_UMTS;
if (ofono_modem_get_boolean(rd->modem, MODEM_PROP_LTE_CAPABLE))
available_rats |= OFONO_RADIO_ACCESS_MODE_LTE;
}
CALLBACK_WITH_SUCCESS(cb, available_rats, cbd->data);
}
static void ril_connected(struct ril_msg *message, gpointer user_data)
{
struct ofono_modem *modem = (struct ofono_modem *) user_data;
struct ril_data *rd = ofono_modem_get_data(modem);
ofono_info("[%d,UNSOL]< %s", g_ril_get_slot(rd->ril),
g_ril_unsol_request_to_string(rd->ril, message->req));
/* TODO: need a disconnect function to restart things! */
rd->connected = TRUE;
DBG("calling set_powered(TRUE)");
ofono_modem_set_powered(modem, TRUE);
}
struct reply_sim_status *g_ril_reply_parse_sim_status(GRil *gril,
const struct ril_msg *message)
{
struct parcel rilp;
unsigned int i;
struct reply_sim_status *status;
g_ril_append_print_buf(gril, "[%d,%04d]< %s",
g_ril_get_slot(gril), message->serial_no,
ril_request_id_to_string(message->req));
g_ril_init_parcel(message, &rilp);
status = g_new0(struct reply_sim_status, 1);
status->card_state = parcel_r_int32(&rilp);
/*
* NOTE:
*
* The global pin_status is used for multi-application
* UICC cards. For example, there are SIM cards that
* can be used in both GSM and CDMA phones. Instead
* of managed PINs for both applications, a global PIN
* is set instead. It's not clear at this point if
* such SIM cards are supported by ofono or RILD.
*/
status->pin_state = parcel_r_int32(&rilp);
status->gsm_umts_index = parcel_r_int32(&rilp);
status->cdma_index = parcel_r_int32(&rilp);
status->ims_index = parcel_r_int32(&rilp);
status->num_apps = parcel_r_int32(&rilp);
if (rilp.malformed)
goto error;
g_ril_append_print_buf(gril,
"(card_state=%d,universal_pin_state=%d,"
"gsm_umts_index=%d,cdma_index=%d,"
"ims_index=%d, ",
status->card_state,
status->pin_state,
status->gsm_umts_index,
status->cdma_index,
status->ims_index);
if (status->card_state != RIL_CARDSTATE_PRESENT)
goto done;
if (status->num_apps > MAX_UICC_APPS) {
ofono_error("SIM error; too many apps: %d", status->num_apps);
status->num_apps = MAX_UICC_APPS;
}
for (i = 0; i < status->num_apps; i++) {
struct reply_sim_app *app;
DBG("processing app[%d]", i);
status->apps[i] = g_try_new0(struct reply_sim_app, 1);
app = status->apps[i];
if (app == NULL) {
ofono_error("Can't allocate app_data");
goto error;
}
app->app_type = parcel_r_int32(&rilp);
app->app_state = parcel_r_int32(&rilp);
app->perso_substate = parcel_r_int32(&rilp);
/*
* TODO: we need a way to instruct parcel to skip
* a string, without allocating memory...
*/
/* application ID (AID) */
app->aid_str = parcel_r_string(&rilp);
/* application label */
app->app_str = parcel_r_string(&rilp);
app->pin_replaced = parcel_r_int32(&rilp);
app->pin1_state = parcel_r_int32(&rilp);
app->pin2_state = parcel_r_int32(&rilp);
g_ril_append_print_buf(gril,
"%s[app_type=%d,app_state=%d,"
"perso_substate=%d,aid_ptr=%s,"
"app_label_ptr=%s,pin1_replaced=%d,"
"pin1=%d,pin2=%d],",
print_buf,
app->app_type,
app->app_state,
app->perso_substate,
app->aid_str ? app->aid_str : "NULL",
app->app_str ? app->app_str : "NULL",
app->pin_replaced,
app->pin1_state,
app->pin2_state);
}
if (rilp.malformed)
goto error;
done:
g_ril_append_print_buf(gril, "%s}", print_buf);
g_ril_print_response(gril, message);
return status;
error:
g_ril_reply_free_sim_status(status);
return NULL;
}
struct reply_sim_status *g_ril_reply_parse_sim_status(GRil *gril,
const struct ril_msg *message)
{
struct parcel rilp;
unsigned int i;
struct reply_sim_status *status;
g_ril_append_print_buf(gril, "[%d,%04d]< %s",
g_ril_get_slot(gril), message->serial_no,
ril_request_id_to_string(message->req));
g_ril_init_parcel(message, &rilp);
/*
* FIXME: Need to come up with a common scheme for verifying the
* size of RIL message and properly reacting to bad messages.
* This could be a runtime assertion, disconnect, drop/ignore
* the message, ...
*
* 20 is the min length of RIL_CardStatus_v6 as the AppState
* array can be 0-length.
*/
if (message->buf_len < 20) {
ofono_error("Size of SIM_STATUS reply too small: %d bytes",
(int) message->buf_len);
return NULL;
}
status = g_new0(struct reply_sim_status, 1);
status->card_state = parcel_r_int32(&rilp);
/*
* NOTE:
*
* The global pin_status is used for multi-application
* UICC cards. For example, there are SIM cards that
* can be used in both GSM and CDMA phones. Instead
* of managed PINs for both applications, a global PIN
* is set instead. It's not clear at this point if
* such SIM cards are supported by ofono or RILD.
*/
status->pin_state = parcel_r_int32(&rilp);
status->gsm_umts_index = parcel_r_int32(&rilp);
status->cdma_index = parcel_r_int32(&rilp);
status->ims_index = parcel_r_int32(&rilp);
status->num_apps = parcel_r_int32(&rilp);
/* TODO:
* How do we handle long (>80 chars) ril_append_print_buf strings?
* Using line wrapping ( via '\' ) introduces spaces in the output.
* Do we just make a style-guide exception for PrintBuf operations?
*/
g_ril_append_print_buf(gril,
"(card_state=%d,universal_pin_state=%d,"
"gsm_umts_index=%d,cdma_index=%d,"
"ims_index=%d, ",
status->card_state,
status->pin_state,
status->gsm_umts_index,
status->cdma_index,
status->ims_index);
if (status->card_state != RIL_CARDSTATE_PRESENT)
goto done;
if (status->num_apps > MAX_UICC_APPS) {
ofono_error("SIM error; too many apps: %d", status->num_apps);
status->num_apps = MAX_UICC_APPS;
}
for (i = 0; i < status->num_apps; i++) {
struct reply_sim_app *app;
DBG("processing app[%d]", i);
status->apps[i] = g_try_new0(struct reply_sim_app, 1);
app = status->apps[i];
if (app == NULL) {
ofono_error("Can't allocate app_data");
goto error;
}
app->app_type = parcel_r_int32(&rilp);
app->app_state = parcel_r_int32(&rilp);
app->perso_substate = parcel_r_int32(&rilp);
/* TODO: we need a way to instruct parcel to skip
* a string, without allocating memory...
*/
app->aid_str = parcel_r_string(&rilp); /* application ID (AID) */
app->app_str = parcel_r_string(&rilp); /* application label */
app->pin_replaced = parcel_r_int32(&rilp);
app->pin1_state = parcel_r_int32(&rilp);
app->pin2_state = parcel_r_int32(&rilp);
g_ril_append_print_buf(gril,
"%s[app_type=%d,app_state=%d,"
"perso_substate=%d,aid_ptr=%s,"
"app_label_ptr=%s,pin1_replaced=%d,"
"pin1=%d,pin2=%d],",
print_buf,
app->app_type,
app->app_state,
app->perso_substate,
app->aid_str,
app->app_str,
app->pin_replaced,
app->pin1_state,
app->pin2_state);
}
done:
g_ril_append_print_buf(gril, "%s}", print_buf);
g_ril_print_response(gril, message);
return status;
error:
g_ril_reply_free_sim_status(status);
return NULL;
}
static void sim_status_cb(struct ril_msg *message, gpointer user_data)
{
struct ofono_sim *sim = user_data;
struct sim_data *sd = ofono_sim_get_data(sim);
struct parcel rilp;
int card_state;
int universal_pin_state;
int gsm_umts_app_index;
int cdma_app_index;
int ims_app_index;
int num_apps;
int i;
int app_state;
int perso_substate;
DBG("");
g_ril_init_parcel(message, &rilp);
card_state = parcel_r_int32(&rilp);
/*
* NOTE:
*
* The global pin_status is used for multi-application
* UICC cards. For example, there are SIM cards that
* can be used in both GSM and CDMA phones. Instead
* of managed PINs for both applications, a global PIN
* is set instead. It's not clear at this point if
* such SIM cards are supported by ofono or RILD.
*/
universal_pin_state = parcel_r_int32(&rilp);
gsm_umts_app_index = parcel_r_int32(&rilp);
cdma_app_index = parcel_r_int32(&rilp);
ims_app_index = parcel_r_int32(&rilp);
num_apps = parcel_r_int32(&rilp);
if (rilp.malformed)
return;
if (gsm_umts_app_index >= num_apps)
return;
DBG("[%d,%04d]< %s: card_state=%d,universal_pin_state=%d,"
"gsm_umts_index=%d,cdma_index=%d,ims_index=%d,"
"num_apps=%d",
g_ril_get_slot(sd->ril),
message->serial_no,
"RIL_REQUEST_GET_SIM_STATUS",
card_state, universal_pin_state,
gsm_umts_app_index, cdma_app_index, ims_app_index,
num_apps);
switch (card_state) {
case RIL_CARDSTATE_PRESENT:
break;
case RIL_CARDSTATE_ABSENT:
ofono_sim_inserted_notify(sim, FALSE);
return;
default:
ofono_error("%s: bad SIM state (%u)", __func__, card_state);
return;
}
ofono_sim_inserted_notify(sim, TRUE);
for (i = 0; i != gsm_umts_app_index; i++) {
parcel_r_int32(&rilp); /* AppType */
parcel_r_int32(&rilp); /* AppState */
parcel_r_int32(&rilp); /* PersoSubstate */
parcel_skip_string(&rilp); /* AID */
parcel_skip_string(&rilp); /* App Label */
parcel_r_int32(&rilp); /* PIN1 Replaced */
parcel_r_int32(&rilp); /* PIN1 PinState */
parcel_r_int32(&rilp); /* PIN2 PinState */
if (rilp.malformed)
return;
}
/*
* We cache the current password state. Ideally this should be done
* by issuing a GET_SIM_STATUS request from ril_query_passwd_state,
* which is called by the core after sending a password, but
* unfortunately the response to GET_SIM_STATUS is not reliable in mako
* when sent just after sending the password. Some time is needed
* before the modem refreshes its internal state, and when it does it
* sends a SIM_STATUS_CHANGED event. In that moment we retrieve the
* status and this function is executed. We call
* __ofono_sim_recheck_pin as it is the only way to indicate the core
* to call query_passwd_state again. An option that can be explored in
* the future is wait before invoking core callback for send_passwd
* until we know the real password state.
*/
sd->app_type = parcel_r_int32(&rilp); /* AppType */
app_state = parcel_r_int32(&rilp); /* AppState */
perso_substate = parcel_r_int32(&rilp); /* PersoSubstate */
switch (app_state) {
case RIL_APPSTATE_PIN:
sd->passwd_state = OFONO_SIM_PASSWORD_SIM_PIN;
break;
case RIL_APPSTATE_PUK:
sd->passwd_state = OFONO_SIM_PASSWORD_SIM_PUK;
break;
case RIL_APPSTATE_SUBSCRIPTION_PERSO:
switch (perso_substate) {
case RIL_PERSOSUBSTATE_SIM_NETWORK:
sd->passwd_state = OFONO_SIM_PASSWORD_PHNET_PIN;
break;
case RIL_PERSOSUBSTATE_SIM_NETWORK_SUBSET:
sd->passwd_state = OFONO_SIM_PASSWORD_PHNETSUB_PIN;
break;
case RIL_PERSOSUBSTATE_SIM_CORPORATE:
sd->passwd_state = OFONO_SIM_PASSWORD_PHCORP_PIN;
break;
case RIL_PERSOSUBSTATE_SIM_SERVICE_PROVIDER:
sd->passwd_state = OFONO_SIM_PASSWORD_PHSP_PIN;
break;
case RIL_PERSOSUBSTATE_SIM_SIM:
sd->passwd_state = OFONO_SIM_PASSWORD_PHSIM_PIN;
break;
case RIL_PERSOSUBSTATE_SIM_NETWORK_PUK:
sd->passwd_state = OFONO_SIM_PASSWORD_PHNET_PUK;
break;
case RIL_PERSOSUBSTATE_SIM_NETWORK_SUBSET_PUK:
sd->passwd_state = OFONO_SIM_PASSWORD_PHNETSUB_PUK;
break;
case RIL_PERSOSUBSTATE_SIM_CORPORATE_PUK:
sd->passwd_state = OFONO_SIM_PASSWORD_PHCORP_PUK;
break;
case RIL_PERSOSUBSTATE_SIM_SERVICE_PROVIDER_PUK:
sd->passwd_state = OFONO_SIM_PASSWORD_PHSP_PUK;
break;
case RIL_PERSOSUBSTATE_SIM_SIM_PUK:
sd->passwd_state = OFONO_SIM_PASSWORD_PHFSIM_PUK;
break;
default:
sd->passwd_state = OFONO_SIM_PASSWORD_NONE;
break;
};
break;
case RIL_APPSTATE_READY:
sd->passwd_state = OFONO_SIM_PASSWORD_NONE;
break;
case RIL_APPSTATE_UNKNOWN:
case RIL_APPSTATE_DETECTED:
default:
sd->passwd_state = OFONO_SIM_PASSWORD_INVALID;
break;
}
g_free(sd->aid_str);
sd->aid_str = parcel_r_string(&rilp); /* AID */
DBG("[%d,%04d]< app_type: %d, passwd_state: %d, aid_str (AID): %s",
g_ril_get_slot(sd->ril), message->serial_no,
sd->app_type, sd->passwd_state, sd->aid_str);
/*
* Note: There doesn't seem to be any other way to force the core SIM
* code to recheck the PIN. This call causes the core to call this
* atom's query_passwd() function.
*/
__ofono_sim_recheck_pin(sim);
}