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); }