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, sd); char *hex_path; struct parcel rilp; DBG("file %04x", fileid); hex_path = get_path(g_ril_vendor(sd->ril), sd->app_type, fileid, path, path_len); if (hex_path == NULL) { ofono_error("Couldn't build SIM read info request - NULL path"); goto error; } parcel_init(&rilp); parcel_w_int32(&rilp, CMD_READ_RECORD); parcel_w_int32(&rilp, fileid); parcel_w_string(&rilp, hex_path); 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) */ /* sessionId, specific to latest MTK modems (harmless for older ones) */ if (g_ril_vendor(sd->ril) == OFONO_RIL_VENDOR_MTK) parcel_w_int32(&rilp, 0); g_ril_append_print_buf(sd->ril, "(cmd=0x%.2X,efid=0x%.4X,path=%s," "%d,%d,%d,(null),pin2=(null),aid=%s)", CMD_READ_RECORD, fileid, hex_path, record, 4, length, sd->aid_str); g_free(hex_path); if (g_ril_send(sd->ril, RIL_REQUEST_SIM_IO, &rilp, ril_file_io_cb, cbd, g_free) > 0) return; error: g_free(cbd); CALLBACK_WITH_FAILURE(cb, NULL, 0, data); }
static void mtk_pin_retries_cb(struct ril_msg *message, gpointer user_data) { struct cb_data *cbd = user_data; ofono_sim_pin_retries_cb_t cb = cbd->cb; struct sim_data *sd = cbd->user; struct parcel rilp; char **strv; char *debug_str; int pin[MTK_EPINC_NUM_PASSWD]; int num_pin; 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); strv = parcel_r_strv(&rilp); if (strv == NULL) { ofono_error("%s: parse error", __func__); goto error; } debug_str = g_strjoinv(",", strv); g_ril_append_print_buf(sd->ril, "{%d,%s}", g_strv_length(strv), debug_str); g_free(debug_str); g_ril_print_response(sd->ril, message); num_pin = sscanf(strv[0], "+EPINC:%d,%d,%d,%d", &pin[0], &pin[1], &pin[2], &pin[3]); g_strfreev(strv); if (num_pin != MTK_EPINC_NUM_PASSWD) goto error; sd->retries[OFONO_SIM_PASSWORD_SIM_PIN] = pin[0]; sd->retries[OFONO_SIM_PASSWORD_SIM_PIN2] = pin[1]; sd->retries[OFONO_SIM_PASSWORD_SIM_PUK] = pin[2]; sd->retries[OFONO_SIM_PASSWORD_SIM_PUK2] = pin[3]; CALLBACK_WITH_SUCCESS(cb, sd->retries, cbd->data); return; error: CALLBACK_WITH_FAILURE(cb, NULL, cbd->data); }
static void ste_cgdcont_cb(gboolean ok, GAtResult *result, gpointer user_data) { struct cb_data *cbd = user_data; ofono_gprs_context_up_cb_t cb = cbd->cb; struct ofono_gprs_context *gc = cbd->user; struct gprs_context_data *gcd = ofono_gprs_context_get_data(gc); struct cb_data *ncbd = NULL; char buf[128]; struct conn_info *conn; GSList *l; if (!ok) { struct ofono_error error; gcd->active_context = 0; decode_at_error(&error, g_at_result_final_response(result)); cb(&error, NULL, 0, NULL, NULL, NULL, NULL, cbd->data); return; } ncbd = g_memdup(cbd, sizeof(struct cb_data)); l = g_slist_find_custom(g_caif_devices, GUINT_TO_POINTER(0), conn_compare_by_cid); if (!l) { DBG("at_cgdcont_cb, no more available devices"); goto error; } conn = l->data; conn->cid = gcd->active_context; snprintf(buf, sizeof(buf), "AT*EPPSD=1,%u,%u", conn->channel_id, conn->cid); if (g_at_chat_send(gcd->chat, buf, NULL, ste_eppsd_up_cb, ncbd, g_free) > 0) return; error: if (ncbd) g_free(ncbd); gcd->active_context = 0; CALLBACK_WITH_FAILURE(cb, NULL, 0, NULL, NULL, NULL, NULL, cbd->data); }
static void ril_rat_mode_cb(struct ril_msg *message, gpointer user_data) { DBG(""); struct cb_data *cbd = user_data; ofono_radio_settings_rat_mode_query_cb_t cb = cbd->cb; struct parcel rilp; int mode = OFONO_RADIO_ACCESS_MODE_ANY; int pref; if (message->error == RIL_E_SUCCESS) { ril_util_init_parcel(message, &rilp); /*first item in int[] is len so let's skip that*/ parcel_r_int32(&rilp); pref = parcel_r_int32(&rilp); switch (pref) { case PREF_NET_TYPE_LTE_ONLY: mode = OFONO_RADIO_ACCESS_MODE_LTE; case PREF_NET_TYPE_GSM_ONLY: mode = OFONO_RADIO_ACCESS_MODE_GSM; break; case PREF_NET_TYPE_GSM_WCDMA_AUTO:/* according to UI design */ if (!cb) ril_force_rat_mode(cbd->user, pref); case PREF_NET_TYPE_WCDMA: case PREF_NET_TYPE_GSM_WCDMA: /* according to UI design */ mode = OFONO_RADIO_ACCESS_MODE_UMTS; break; case PREF_NET_TYPE_LTE_CDMA_EVDO: case PREF_NET_TYPE_LTE_GSM_WCDMA: case PREF_NET_TYPE_LTE_CMDA_EVDO_GSM_WCDMA: if (!cb) ril_force_rat_mode(cbd->user, pref); break; case PREF_NET_TYPE_CDMA_EVDO_AUTO: case PREF_NET_TYPE_CDMA_ONLY: case PREF_NET_TYPE_EVDO_ONLY: case PREF_NET_TYPE_GSM_WCDMA_CDMA_EVDO_AUTO: default: break; } if (cb) CALLBACK_WITH_SUCCESS(cb, mode, cbd->data); } else { if (cb) CALLBACK_WITH_FAILURE(cb, -1, cbd->data); ofono_error("rat mode query failed"); } }
static void ste_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_settings_data *rsd = ofono_radio_settings_get_data(rs); struct cb_data *cbd = cb_data_new(cb, data); char buf[20]; enum ste_radio_mode value; if (!ofono_mode_to_ste_mode(mode, &value)) { CALLBACK_WITH_FAILURE(cb, data); g_free(cbd); return; } snprintf(buf, sizeof(buf), "AT+CFUN=%u", value); if (g_at_chat_send(rsd->chat, buf, none_prefix, rat_modify_cb, cbd, g_free) == 0) { CALLBACK_WITH_FAILURE(cb, data); g_free(cbd); } }
static void at_discover_apps(struct ofono_sim_auth *sa, ofono_sim_list_apps_cb_t cb, void *data) { struct sim_auth_data *sad = ofono_sim_auth_get_data(sa); struct cb_data *cbd = cb_data_new(cb, data); if (g_at_chat_send(sad->chat, "AT+CUAD", cuad_prefix, at_discover_apps_cb, cbd, g_free) > 0) return; g_free(cbd); CALLBACK_WITH_FAILURE(cb, NULL, 0, data); }
static void ril_clir_query(struct ofono_call_settings *cs, ofono_call_settings_clir_cb_t cb, void *data) { struct settings_data *sd = ofono_call_settings_get_data(cs); struct cb_data *cbd = cb_data_new(cb, data, cs); int ret; ret = g_ril_send(sd->ril, RIL_REQUEST_GET_CLIR, NULL, ril_clir_query_cb, cbd, g_free); if (ret <= 0) { g_free(cbd); CALLBACK_WITH_FAILURE(cb, -1, -1, data); } }
static void at_query_revision(struct ofono_devinfo *info, ofono_devinfo_query_cb_t cb, void *data) { struct cb_data *cbd = cb_data_new(cb, data); GAtChat *chat = ofono_devinfo_get_data(info); cbd->user = "******"; if (g_at_chat_send(chat, "AT+CGMR", NULL, attr_cb, cbd, g_free) > 0) return; g_free(cbd); CALLBACK_WITH_FAILURE(cb, NULL, data); }
static void ril_set_rat_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_rat_mode_set_cb_t cb = cbd->cb; if (message->error == RIL_E_SUCCESS) { g_ril_print_response_no_args(rd->ril, message); CALLBACK_WITH_SUCCESS(cb, cbd->data); } else { ofono_error("%s: rat mode setting failed", __func__); CALLBACK_WITH_FAILURE(cb, cbd->data); } }
static void ril_read_imsi(struct ofono_sim *sim, ofono_sim_imsi_cb_t cb, void *data) { struct sim_data *sd = ofono_sim_get_data(sim); struct cb_data *cbd = cb_data_new(cb, data, sd); struct parcel rilp; g_ril_request_read_imsi(sd->ril, sd->aid_str, &rilp); if (g_ril_send(sd->ril, RIL_REQUEST_GET_IMSI, &rilp, ril_imsi_cb, cbd, g_free) == 0) { g_free(cbd); CALLBACK_WITH_FAILURE(cb, NULL, data); } }
static void ril_ussd_cancel(struct ofono_ussd *ussd, ofono_ussd_cb_t cb, void *user_data) { struct ussd_data *ud = ofono_ussd_get_data(ussd); struct cb_data *cbd = cb_data_new(cb, user_data, ussd); int ret; ret = g_ril_send(ud->ril, RIL_REQUEST_CANCEL_USSD, NULL, ril_ussd_cancel_cb, cbd, g_free); if (ret <= 0) { g_free(cbd); CALLBACK_WITH_FAILURE(cb, user_data); } }
static void at_discover_apps_cb(gboolean ok, GAtResult *result, gpointer user_data) { struct cb_data *cbd = user_data; GAtResultIter iter; ofono_sim_list_apps_cb_t cb = cbd->cb; struct ofono_error error; const unsigned char *dataobj; gint linelen; unsigned char *buffer; int len; decode_at_error(&error, g_at_result_final_response(result)); if (!ok) { cb(&error, NULL, 0, cbd->data); return; } g_at_result_iter_init(&iter, result); len = 0; while (g_at_result_iter_next(&iter, "+CUAD:")) { if (!g_at_result_iter_next_hexstring(&iter, NULL, &linelen)) goto error; len += linelen; } g_at_result_iter_init(&iter, result); buffer = g_malloc(len); len = 0; while (g_at_result_iter_next(&iter, "+CUAD:")) { g_at_result_iter_next_hexstring(&iter, &dataobj, &linelen); memcpy(buffer + len, dataobj, linelen); len += linelen; } cb(&error, buffer, len, cbd->data); g_free(buffer); return; error: CALLBACK_WITH_FAILURE(cb, NULL, 0, cbd->data); }
static void ril_registration(struct ofono_call_forwarding *cf, int type, int cls, const struct ofono_phone_number *number, int time, ofono_call_forwarding_set_cb_t cb, void *data) { struct forw_data *fd = ofono_call_forwarding_get_data(cf); struct cb_data *cbd = cb_data_new(cb, data); struct parcel rilp; int ret = 0; ofono_info("cf registration"); parcel_init(&rilp); parcel_w_int32(&rilp, CF_ACTION_REGISTRATION); parcel_w_int32(&rilp, type); /* * Modem seems to respond with error to all queries * or settings made with bearer class * BEARER_CLASS_DEFAULT. Design decision: If given * class is BEARER_CLASS_DEFAULT let's map it to * SERVICE_CLASS_NONE as with it e.g. ./send-ussd '*21*<phone_number>#' * returns cls:53 i.e. 1+4+16+32 as service class. */ if (cls == BEARER_CLASS_DEFAULT) cls = SERVICE_CLASS_NONE; parcel_w_int32(&rilp, cls); parcel_w_int32(&rilp, number->type); parcel_w_string(&rilp, (char *) number->number); parcel_w_int32(&rilp, time); ret = g_ril_send(fd->ril, RIL_REQUEST_SET_CALL_FORWARD, rilp.data, rilp.size, ril_set_forward_cb, cbd, g_free); /* In case of error free cbd and return the cb with failure */ if (ret <= 0) { ofono_error("CF registration failed"); g_free(cbd); CALLBACK_WITH_FAILURE(cb, data); } }
static void cgact_disable_cb(gboolean ok, GAtResult *result, gpointer user_data) { struct ofono_gprs_context *gc = user_data; struct gprs_context_data *gcd = ofono_gprs_context_get_data(gc); DBG("ok %d", ok); if (!ok) { CALLBACK_WITH_FAILURE(gcd->cb, gcd->cb_data); return; } gcd->active_context = 0; CALLBACK_WITH_SUCCESS(gcd->cb, gcd->cb_data); }
static void hfp_signal_strength(struct ofono_netreg *netreg, ofono_netreg_strength_cb_t cb, void *data) { struct netreg_data *nd = ofono_netreg_get_data(netreg); struct cb_data *cbd = cb_data_new(cb, data); cbd->user = netreg; if (g_at_chat_send(nd->chat, "AT+CIND?", cind_prefix, signal_strength_cb, cbd, g_free) > 0) return; g_free(cbd); CALLBACK_WITH_FAILURE(cb, -1, data); }
static void qmi_signal_strength(struct ofono_netreg *netreg, ofono_netreg_strength_cb_t cb, void *user_data) { struct netreg_data *data = ofono_netreg_get_data(netreg); struct cb_data *cbd = cb_data_new(cb, user_data); DBG(""); if (qmi_service_send(data->nas, QMI_NAS_GET_RSSI, NULL, get_rssi_cb, cbd, g_free) > 0) return; CALLBACK_WITH_FAILURE(cb, -1, cbd->data); g_free(cbd); }
static void qmi_list_operators(struct ofono_netreg *netreg, ofono_netreg_operator_list_cb_t cb, void *user_data) { struct netreg_data *data = ofono_netreg_get_data(netreg); struct cb_data *cbd = cb_data_new(cb, user_data); DBG(""); if (qmi_service_send(data->nas, QMI_NAS_SCAN_NETS, NULL, scan_nets_cb, cbd, g_free) > 0) return; CALLBACK_WITH_FAILURE(cb, 0, NULL, cbd->data); g_free(cbd); }
static void enter_pin_done(const struct ofono_error *error, void *data) { struct change_state_cbd *csd = data; struct sim_data *sd = ofono_sim_get_data(csd->sim); if (error->type != OFONO_ERROR_TYPE_NO_ERROR) { ofono_error("%s: wrong password", __func__); sd->unlock_pending = FALSE; CALLBACK_WITH_FAILURE(csd->cb, csd->data); } else { ril_pin_change_state(csd->sim, csd->passwd_type, csd->enable, csd->passwd, csd->cb, csd->data); } g_free(csd); }
static void isi_sca_query(struct ofono_sms *sms, ofono_sms_sca_query_cb_t cb, void *data) { struct sms_data *sd = ofono_sms_get_data(sms); struct isi_cb_data *cbd = isi_cb_data_new(sms, cb, data); if (cbd == NULL || sd->sim == NULL) goto error; if (sca_sim_query(sd->sim, cbd, g_free)) return; error: CALLBACK_WITH_FAILURE(cb, NULL, data); g_free(cbd); }
static void ril_set_online_cb(struct ril_msg *message, gpointer user_data) { struct cb_data *cbd = user_data; struct ril_data *rd = cbd->user; ofono_modem_online_cb_t cb = cbd->cb; if (message->error == RIL_E_SUCCESS) { DBG("%s: set_online OK: rd->ofono_online: %d", __func__, rd->ofono_online); CALLBACK_WITH_SUCCESS(cb, cbd->data); } else { ofono_error("%s: set_online: %d failed", __func__, rd->ofono_online); CALLBACK_WITH_FAILURE(cb, cbd->data); } }
static void tc65_set_online(struct ofono_modem *modem, ofono_bool_t online, ofono_modem_online_cb_t cb, void *user_data) { GAtChat *chat = ofono_modem_get_data(modem); struct cb_data *cbd = cb_data_new(cb, user_data); char const *command = online ? "AT+CFUN=1" : "AT+CFUN=7"; DBG("modem %p %s", modem, online ? "online" : "offline"); if (g_at_chat_send(chat, command, NULL, set_online_cb, cbd, g_free)) return; g_free(cbd); CALLBACK_WITH_FAILURE(cb, cbd->data); }
static void qmi_read_imsi(struct ofono_sim *sim, ofono_sim_imsi_cb_t cb, void *user_data) { struct sim_data *data = ofono_sim_get_data(sim); struct cb_data *cbd = cb_data_new(cb, user_data); DBG(""); if (qmi_service_send(data->dms, QMI_DMS_GET_IMSI, NULL, get_imsi_cb, cbd, g_free) > 0) return; CALLBACK_WITH_FAILURE(cb, NULL, cbd->data); g_free(cbd); }
static void phonesim_ctm_query(struct ofono_ctm *ctm, ofono_ctm_query_cb_t cb, void *data) { GAtChat *chat = ofono_ctm_get_data(ctm); struct cb_data *cbd = cb_data_new(cb, data); DBG(""); if (g_at_chat_send(chat, "AT+PTTY?", ptty_prefix, ctm_query_cb, cbd, g_free) > 0) return; g_free(cbd); CALLBACK_WITH_FAILURE(cb, 0, data); }
static void qmi_read_file_info(struct ofono_sim *sim, int fileid, ofono_sim_file_info_cb_t cb, void *user_data) { unsigned char access[3] = { 0x0f, 0xff, 0xff }; DBG("file id 0x%04x", fileid); switch (fileid) { case SIM_EF_ICCID_FILEID: CALLBACK_WITH_SUCCESS(cb, 10, 0, 0, access, 1, user_data); break; default: CALLBACK_WITH_FAILURE(cb, -1, -1, -1, NULL, 0, user_data); break; } }
static void ril_clip_query(struct ofono_call_settings *cs, ofono_call_settings_status_cb_t cb, void *data) { struct settings_data *sd = ofono_call_settings_get_data(cs); struct cb_data *cbd = cb_data_new(cb, data, cs); int ret; ret = g_ril_send(sd->ril, RIL_REQUEST_QUERY_CLIP, NULL, ril_clip_query_cb, cbd, g_free); /* In case of error free cbd and return the cb with failure */ if (ret <= 0) { g_free(cbd); CALLBACK_WITH_FAILURE(cb, -1, 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); struct parcel rilp; int ret = 0; char cls_textual[RIL_MAX_SERVICE_LENGTH]; DBG("lock: %s, services to query: %i", lock, cls); /* * RIL modems do not support 7 as default bearer class. According to * the 22.030 Annex C: When service code is not given it corresponds to * "All tele and bearer services" */ if (cls == BEARER_CLASS_DEFAULT) cls = SERVICE_CLASS_NONE; sprintf(cls_textual, "%d", cls); /* * See 3GPP 27.007 7.4 for parameter descriptions. * According to ril.h password should be empty string "" when not * needed, but in reality we only need to give string length as 0 */ parcel_init(&rilp); parcel_w_int32(&rilp, RIL_QUERY_STRING_COUNT); /* Nbr of strings */ parcel_w_string(&rilp, (char *) lock); /* Facility code */ parcel_w_int32(&rilp, RIL_LENGTH_ZERO); /* Password length */ parcel_w_string(&rilp, (char *) cls_textual); parcel_w_string(&rilp, NULL); /* AID (for FDN, not yet supported) */ ret = g_ril_send(bd->ril, RIL_REQUEST_QUERY_FACILITY_LOCK, rilp.data, rilp.size, ril_call_barring_query_cb, cbd, g_free); parcel_free(&rilp); if (ret <= 0) { ofono_error("Sending Call Barring query failed, err: %i", ret); g_free(cbd); CALLBACK_WITH_FAILURE(callback, -1, data); } }
static void ril_registration(struct ofono_call_forwarding *cf, int type, int cls, const struct ofono_phone_number *number, int time, ofono_call_forwarding_set_cb_t cb, void *data) { struct forw_data *fd = ofono_call_forwarding_get_data(cf); struct cb_data *cbd = cb_data_new(cb, data); struct parcel rilp; int ret = 0; parcel_init(&rilp); parcel_w_int32(&rilp, CF_ACTION_REGISTRATION); parcel_w_int32(&rilp, type); /* Modem seems to respond with error to all queries * or settings made with bearer class * BEARER_CLASS_DEFAULT. Design decision: If given * class is BEARER_CLASS_DEFAULT let's map it to * SERVICE_CLASS_VOICE effectively making it the * default bearer. This in line with API which is * contains only voice anyways. TODO: Checkout * the behaviour with final modem */ if (cls == BEARER_CLASS_DEFAULT) cls = BEARER_CLASS_VOICE; parcel_w_int32(&rilp, cls); parcel_w_int32(&rilp, number->type); parcel_w_string(&rilp, (char *) number->number); parcel_w_int32(&rilp, time); ret = g_ril_send(fd->ril, RIL_REQUEST_SET_CALL_FORWARD, rilp.data, rilp.size, ril_set_forward_cb, cbd, g_free); /* 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 phonesim_activate_primary(struct ofono_gprs_context *gc, const struct ofono_gprs_primary_context *ctx, ofono_gprs_context_cb_t cb, void *data) { struct gprs_context_data *gcd = ofono_gprs_context_get_data(gc); struct cb_data *cbd = cb_data_new(cb, data); char buf[OFONO_GPRS_MAX_APN_LENGTH + 128]; int len = 0; cbd->user = gc; gcd->proto = ctx->proto; switch (ctx->proto) { case OFONO_GPRS_PROTO_IP: len = snprintf(buf, sizeof(buf), "AT+CGDCONT=%u,\"IP\"", ctx->cid); break; case OFONO_GPRS_PROTO_IPV6: len = snprintf(buf, sizeof(buf), "AT+CGDCONT=%u,\"IPV6\"", ctx->cid); break; case OFONO_GPRS_PROTO_IPV4V6: len = snprintf(buf, sizeof(buf), "AT+CGDCONT=%u,\"IPV4V6\"", ctx->cid); break; } if (ctx->apn) snprintf(buf + len, sizeof(buf) - len - 3, ",\"%s\"", ctx->apn); /* Assume always succeeds */ if (g_at_chat_send(gcd->chat, buf, none_prefix, NULL, NULL, NULL) == 0) goto error; sprintf(buf, "AT+CGACT=1,%u", ctx->cid); if (g_at_chat_send(gcd->chat, buf, none_prefix, at_cgact_up_cb, cbd, g_free) > 0) return; error: g_free(cbd); CALLBACK_WITH_FAILURE(cb, data); }
static void cops_cb(gboolean ok, GAtResult *result, gpointer user_data) { struct cb_data *cbd = user_data; ofono_netreg_operator_cb_t cb = cbd->cb; struct ofono_network_operator op; GAtResultIter iter; int format; const char *name; struct ofono_error error; decode_at_error(&error, g_at_result_final_response(result)); if (!ok) { cb(&error, NULL, cbd->data); return; } g_at_result_iter_init(&iter, result); if (!g_at_result_iter_next(&iter, "+COPS:")) goto error; g_at_result_iter_skip_next(&iter); ok = g_at_result_iter_next_number(&iter, &format); if (ok == FALSE || format != 0) goto error; if (g_at_result_iter_next_string(&iter, &name) == FALSE) goto error; strncpy(op.name, name, HFP_MAX_OPERATOR_NAME_LENGTH); op.name[HFP_MAX_OPERATOR_NAME_LENGTH] = '\0'; op.mcc[0] = '\0'; op.mnc[0] = '\0'; op.status = 2; op.tech = -1; cb(&error, &op, cbd->data); return; error: CALLBACK_WITH_FAILURE(cb, NULL, cbd->data); }
static void telit_portcfg_check_cb(gboolean ok, GAtResult *result, gpointer user_data) { struct cb_data *cbd = user_data; ofono_location_reporting_enable_cb_t cb = cbd->cb; struct ofono_location_reporting *lr = cbd->user; struct gps_data *gd = ofono_location_reporting_get_data(lr); struct ofono_error error; int requested_portcfg, current_portcfg; GAtResultIter iter; DBG("lr=%p ok=%d", lr, ok); decode_at_error(&error, g_at_result_final_response(result)); if (!ok) { cb(&error, -1, cbd->data); g_free(cbd); return; } g_at_result_iter_init(&iter, result); if (!g_at_result_iter_next(&iter, "#PORTCFG:")) goto fail; if (!g_at_result_iter_next_number(&iter, &requested_portcfg)) goto fail; if (!g_at_result_iter_next_number(&iter, ¤t_portcfg)) goto fail; if (current_portcfg != 8) { ofono_warn("Unable to start GPS, modem configuration invalid"); ofono_warn("Refer to doc/telit-modem.txt section HE910/GPS"); goto fail; } if (g_at_chat_send(gd->chat, "AT$GPSP=1", none_prefix, telit_gps_enable_cb, cbd, NULL) > 0) return; fail: CALLBACK_WITH_FAILURE(cb, -1, cbd->data); g_free(cbd); }