static void xsimstate_query(gboolean ok, GAtResult *result, gpointer user_data)
{
struct ofono_modem *modem = user_data;
struct ifx_data *data = ofono_modem_get_data(modem);
GAtResultIter iter;
int mode;
int state;
DBG("");
if (!ok)
return;
g_at_result_iter_init(&iter, result);
if (!g_at_result_iter_next(&iter, "+XSIMSTATE:"))
return;
if (!g_at_result_iter_next_number(&iter, &mode))
return;
if (!g_at_result_iter_next_number(&iter, &state))
return;
ifx_set_sim_state(data, state);
}
static int option_parse_tech(GAtResult *result)
{
GAtResultIter iter;
int s, octi, ouwcti;
int tech;
g_at_result_iter_init(&iter, result);
if (!g_at_result_iter_next(&iter, "_OCTI:"))
return -1;
if (!g_at_result_iter_next_number(&iter, &s))
return -1;
if (!g_at_result_iter_next_number(&iter, &octi))
return -1;
if (!g_at_result_iter_next(&iter, "_OUWCTI:"))
return -1;
if (!g_at_result_iter_next_number(&iter, &s))
return -1;
if (!g_at_result_iter_next_number(&iter, &ouwcti))
return -1;
switch (octi) {
case 1: /* GSM */
tech = ACCESS_TECHNOLOGY_GSM;
break;
case 2: /* GPRS */
tech = ACCESS_TECHNOLOGY_GSM;
break;
case 3: /* EDGE */
tech = ACCESS_TECHNOLOGY_GSM_EGPRS;
break;
default:
tech = -1;
break;
}
switch (ouwcti) {
case 1: /* UMTS */
tech = ACCESS_TECHNOLOGY_UTRAN;
break;
case 2: /* HSDPA */
tech = ACCESS_TECHNOLOGY_UTRAN_HSDPA;
break;
case 3: /* HSUPA */
tech = ACCESS_TECHNOLOGY_UTRAN_HSUPA;
break;
case 4: /* HSPA */
tech = ACCESS_TECHNOLOGY_UTRAN_HSDPA_HSUPA;
break;
}
DBG("octi %d ouwcti %d tech %d", octi, ouwcti, tech);
return tech;
}
static void ste_cgact_read_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);
gint cid, state;
GAtResultIter iter;
if (!ok)
return;
g_at_result_iter_init(&iter, result);
while (g_at_result_iter_next(&iter, "+CGACT:")) {
if (!g_at_result_iter_next_number(&iter, &cid))
continue;
if ((unsigned int) cid != gcd->active_context)
continue;
if (!g_at_result_iter_next_number(&iter, &state))
continue;
if (state == 1)
continue;
ofono_gprs_context_deactivated(gc, gcd->active_context);
gcd->active_context = 0;
break;
}
}
static void ciev_notify(GAtResult *result, gpointer user_data)
{
struct ofono_netreg *netreg = user_data;
struct netreg_data *nd = ofono_netreg_get_data(netreg);
int strength, ind;
GAtResultIter iter;
g_at_result_iter_init(&iter, result);
if (!g_at_result_iter_next(&iter, "+CIEV:"))
return;
if (!g_at_result_iter_next_number(&iter, &ind))
return;
if (ind != nd->signal_index)
return;
if (!g_at_result_iter_next_number(&iter, &strength))
return;
if (strength == nd->signal_invalid)
strength = -1;
else
strength = (strength * 100) / (nd->signal_max - nd->signal_min);
ofono_netreg_strength_notify(netreg, strength);
}
static void cops_cb(gboolean ok, GAtResult *result, gpointer user_data)
{
struct cb_data *cbd = user_data;
struct netreg_data *nd = ofono_netreg_get_data(cbd->user);
ofono_netreg_operator_cb_t cb = cbd->cb;
struct ofono_network_operator op;
GAtResultIter iter;
int format, tech;
const char *name;
struct ofono_error error;
decode_at_error(&error, g_at_result_final_response(result));
if (!ok)
goto error;
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;
/* Default to GSM */
if (g_at_result_iter_next_number(&iter, &tech) == FALSE)
tech = ACCESS_TECHNOLOGY_GSM;
strncpy(op.name, name, OFONO_MAX_OPERATOR_NAME_LENGTH);
op.name[OFONO_MAX_OPERATOR_NAME_LENGTH] = '\0';
strncpy(op.mcc, nd->mcc, OFONO_MAX_MCC_LENGTH);
op.mcc[OFONO_MAX_MCC_LENGTH] = '\0';
strncpy(op.mnc, nd->mnc, OFONO_MAX_MNC_LENGTH);
op.mnc[OFONO_MAX_MNC_LENGTH] = '\0';
/* Set to current */
op.status = 2;
op.tech = tech;
DBG("cops_cb: %s, %s %s %d", name, nd->mcc, nd->mnc, tech);
cb(&error, &op, cbd->data);
g_free(cbd);
return;
error:
cb(&error, NULL, cbd->data);
g_free(cbd);
}
static void cbc_notify(GAtResult *result, gpointer user_data)
{
struct ofono_modem *modem = user_data;
struct phonesim_data *data = ofono_modem_get_data(modem);
GAtResultIter iter;
int status;
int level;
g_at_result_iter_init(&iter, result);
if (!g_at_result_iter_next(&iter, "+CBC:"))
return;
if (!g_at_result_iter_next_number(&iter, &status))
return;
if (!g_at_result_iter_next_number(&iter, &level))
return;
data->batt_level = level;
__ofono_modem_foreach_registered_atom(modem,
OFONO_ATOM_TYPE_EMULATOR_HFP,
emulator_battery_cb,
GUINT_TO_POINTER(level));
}
static void at_cmgl_notify(GAtResult *result, gpointer user_data)
{
struct ofono_sms *sms = user_data;
struct sms_data *data = ofono_sms_get_data(sms);
GAtResultIter iter;
const char *hexpdu;
unsigned char pdu[176];
long pdu_len;
int tpdu_len;
int index;
int status;
char buf[16];
DBG("");
g_at_result_iter_init(&iter, result);
while (g_at_result_iter_next(&iter, "+CMGL:")) {
if (!g_at_result_iter_next_number(&iter, &index))
goto err;
if (!g_at_result_iter_next_number(&iter, &status))
goto err;
if (!g_at_result_iter_skip_next(&iter))
goto err;
if (!g_at_result_iter_next_number(&iter, &tpdu_len))
goto err;
/* Only MT messages */
if (status != 0 && status != 1)
continue;
hexpdu = g_at_result_pdu(result);
DBG("Found an old SMS PDU: %s, with len: %d",
hexpdu, tpdu_len);
if (strlen(hexpdu) > sizeof(pdu) * 2)
continue;
decode_hex_own_buf(hexpdu, -1, &pdu_len, 0, pdu);
ofono_sms_deliver_notify(sms, pdu, pdu_len, tpdu_len);
/* We don't buffer SMS on the SIM/ME, send along a CMGD */
snprintf(buf, sizeof(buf), "AT+CMGD=%d", index);
g_at_chat_send(data->chat, buf, none_prefix,
at_cmgd_cb, NULL, NULL);
}
return;
err:
ofono_error("Unable to parse CMGL response");
}
static gboolean parse_sysinfo(GAtResult *result, gint *status)
{
GAtResultIter iter;
gint srv_status;
gint srv_domain;
gint roaming_status;
g_at_result_iter_init(&iter, result);
if (!g_at_result_iter_next(&iter, "^SYSINFO:"))
return FALSE;
if (!g_at_result_iter_next_number(&iter, &srv_status))
return FALSE;
if (!g_at_result_iter_next_number(&iter, &srv_domain))
return FALSE;
if (!g_at_result_iter_next_number(&iter, &roaming_status))
return FALSE;
DBG("%d, %d, %d", srv_status, srv_domain, roaming_status);
switch (srv_status) {
case 1: /* Restricted service */
case 2: /* Service valid */
case 3: /* Restricted region service */
if (roaming_status)
*status = CDMA_NETWORK_REGISTRATION_STATUS_ROAMING;
else
*status = CDMA_NETWORK_REGISTRATION_STATUS_REGISTERED;
break;
case 0: /* No service */
case 4: /* Not registered */
default:
*status = CDMA_NETWORK_REGISTRATION_STATUS_NOT_REGISTERED;
break;
}
switch (srv_domain) {
case 0: /* No service */
*status = CDMA_NETWORK_REGISTRATION_STATUS_NOT_REGISTERED;
break;
case 1: /* Only CS */
case 2: /* Only PS */
case 3: /* CS PS */
case 4: /* CS registered, PS in searching state */
case 255: /* CDMA not supported */
break;
}
return TRUE;
}
static void at_csms_status_cb(gboolean ok, GAtResult *result,
gpointer user_data)
{
struct ofono_sms *sms = user_data;
struct sms_data *data = ofono_sms_get_data(sms);
gboolean supported = FALSE;
if (ok) {
GAtResultIter iter;
int service;
int mt;
int mo;
g_at_result_iter_init(&iter, result);
if (!g_at_result_iter_next(&iter, "+CSMS:"))
goto out;
switch (data->vendor) {
case OFONO_VENDOR_HUAWEI:
case OFONO_VENDOR_NOVATEL:
g_at_result_iter_skip_next(&iter);
service = 0;
break;
default:
if (!g_at_result_iter_next_number(&iter, &service))
goto out;
break;
}
if (!g_at_result_iter_next_number(&iter, &mt))
goto out;
if (!g_at_result_iter_next_number(&iter, &mo))
goto out;
if (service == 1)
data->cnma_enabled = TRUE;
if (mt == 1 && mo == 1)
supported = TRUE;
}
out:
if (!supported)
return at_sms_not_supported(sms);
/* Now query supported text format */
g_at_chat_send(data->chat, "AT+CMGF=?", cmgf_prefix,
at_cmgf_query_cb, sms, NULL);
}
static gboolean at_util_parse_reg(GAtResult *result, const char *prefix,
int *mode, int *status,
int *lac, int *ci, int *tech)
{
GAtResultIter iter;
int m, s;
int l = -1, c = -1, t = -1;
const char *str;
g_at_result_iter_init(&iter, result);
while (g_at_result_iter_next(&iter, prefix)) {
g_at_result_iter_next_number(&iter, &m);
/* Sometimes we get an unsolicited CREG/CGREG here, skip it */
if (g_at_result_iter_next_number(&iter, &s) == FALSE)
continue;
if (g_at_result_iter_next_string(&iter, &str) == TRUE)
l = strtol(str, NULL, 16);
else
goto out;
if (g_at_result_iter_next_string(&iter, &str) == TRUE)
c = strtol(str, NULL, 16);
else
goto out;
g_at_result_iter_next_number(&iter, &t);
out:
if (mode)
*mode = m;
if (status)
*status = s;
if (lac)
*lac = l;
if (ci)
*ci = c;
if (tech)
*tech = t;
return TRUE;
}
return FALSE;
}
static void mbm_erinfo_notify(GAtResult *result, gpointer user_data)
{
struct ofono_netreg *netreg = user_data;
struct netreg_data *nd = ofono_netreg_get_data(netreg);
GAtResultIter iter;
int mode, gsm, umts;
g_at_result_iter_init(&iter, result);
if (g_at_result_iter_next(&iter, "*ERINFO:") == FALSE)
return;
if (g_at_result_iter_next_number(&iter, &mode) == FALSE)
return;
if (g_at_result_iter_next_number(&iter, &gsm) == FALSE)
return;
/*
* According to MBM the ERINFO unsolicited response does not contain
* the mode parameter, however at least the MD300 does report it. So
* we handle both 2 and 3 argument versions
*/
if (g_at_result_iter_next_number(&iter, &umts) == FALSE) {
gsm = mode;
umts = gsm;
}
ofono_info("network capability: GSM %d UMTS %d", gsm, umts);
/* Convert to tech values from 27.007 */
switch (gsm) {
case 1: /* GSM */
nd->tech = ACCESS_TECHNOLOGY_GSM;
break;
case 2: /* EDGE */
nd->tech = ACCESS_TECHNOLOGY_GSM_EGPRS;
break;
default:
nd->tech = -1;
}
switch (umts) {
case 1: /* UMTS */
nd->tech = ACCESS_TECHNOLOGY_UTRAN;
break;
case 2: /* UMTS + HSDPA */
nd->tech = ACCESS_TECHNOLOGY_UTRAN_HSDPA;
break;
}
}
static void xrat_query_cb(gboolean ok, GAtResult *result, gpointer user_data)
{
struct cb_data *cbd = user_data;
ofono_radio_settings_rat_mode_query_cb_t cb = cbd->cb;
enum ofono_radio_access_mode mode;
struct ofono_error error;
GAtResultIter iter;
int value, preferred;
decode_at_error(&error, g_at_result_final_response(result));
if (!ok) {
cb(&error, -1, cbd->data);
return;
}
g_at_result_iter_init(&iter, result);
if (g_at_result_iter_next(&iter, "+XRAT:") == FALSE)
goto error;
if (g_at_result_iter_next_number(&iter, &value) == FALSE)
goto error;
if (g_at_result_iter_next_number(&iter, &preferred) == FALSE)
goto error;
switch (value) {
case 0:
mode = OFONO_RADIO_ACCESS_MODE_GSM;
break;
case 1:
mode = OFONO_RADIO_ACCESS_MODE_ANY;
break;
case 2:
mode = OFONO_RADIO_ACCESS_MODE_UMTS;
break;
default:
CALLBACK_WITH_FAILURE(cb, -1, cbd->data);
return;
}
cb(&error, mode, cbd->data);
return;
error:
CALLBACK_WITH_FAILURE(cb, -1, cbd->data);
}
static void ublox_ureg_notify(GAtResult *result, gpointer user_data)
{
struct ofono_gprs *gprs = user_data;
GAtResultIter iter;
gint state, bearer;
g_at_result_iter_init(&iter, result);
if (!g_at_result_iter_next(&iter, "+UREG:"))
return;
if (!g_at_result_iter_next_number(&iter, &state))
return;
switch (state) {
case 4:
bearer = 5;
break;
case 5:
bearer = 4;
break;
case 8:
bearer = 1;
break;
case 9:
bearer = 2;
break;
default:
bearer = state;
}
ofono_gprs_bearer_notify(gprs, bearer);
}
static void ctm_query_cb(gboolean ok, GAtResult *result, gpointer user_data)
{
struct cb_data *cbd = user_data;
struct ofono_error error;
GAtResultIter iter;
ofono_ctm_query_cb_t cb = cbd->cb;
int value;
decode_at_error(&error, g_at_result_final_response(result));
if (!ok) {
cb(&error, -1, cbd->data);
return;
}
g_at_result_iter_init(&iter, result);
if (g_at_result_iter_next(&iter, "+PTTY:") == FALSE)
goto error;
if (g_at_result_iter_next_number(&iter, &value) == FALSE)
goto error;
cb(&error, value, cbd->data);
return;
error:
CALLBACK_WITH_FAILURE(cb, -1, cbd->data);
}
static void ifx_ctzdst_notify(GAtResult *result, gpointer user_data)
{
struct ofono_netreg *netreg = user_data;
struct netreg_data *nd = ofono_netreg_get_data(netreg);
int dst;
GAtResultIter iter;
g_at_result_iter_init(&iter, result);
if (!g_at_result_iter_next(&iter, "+CTZDST:"))
return;
if (!g_at_result_iter_next_number(&iter, &dst))
return;
DBG("dst %d", dst);
nd->time.dst = dst;
if (nd->nitz_timeout > 0) {
g_source_remove(nd->nitz_timeout);
nd->nitz_timeout = 0;
}
ofono_netreg_time_notify(netreg, &nd->time);
}
static void xctms_query_cb(gboolean ok, GAtResult *result, gpointer user_data)
{
struct cb_data *cbd = user_data;
ofono_ctm_query_cb_t cb = cbd->cb;
struct ofono_error error;
GAtResultIter iter;
int value;
ofono_bool_t enable;
decode_at_error(&error, g_at_result_final_response(result));
if (!ok) {
cb(&error, -1, cbd->data);
return;
}
g_at_result_iter_init(&iter, result);
if (g_at_result_iter_next(&iter, "+XCTMS:") == FALSE)
goto error;
if (g_at_result_iter_next_number(&iter, &value) == FALSE)
goto error;
/* FULL TTY mode status only sent to oFono */
enable = (value == 1) ? TRUE : FALSE;
cb(&error, enable, cbd->data);
return;
error:
CALLBACK_WITH_FAILURE(cb, -1, cbd->data);
}
static void cgev_notify(GAtResult *result, gpointer user_data)
{
struct ofono_gprs_context *gc = user_data;
struct gprs_context_data *gcd = ofono_gprs_context_get_data(gc);
const char *event;
int cid;
GAtResultIter iter;
g_at_result_iter_init(&iter, result);
if (!g_at_result_iter_next(&iter, "+CGEV:"))
return;
if (!g_at_result_iter_next_unquoted_string(&iter, &event))
return;
if (g_str_has_prefix(event, "NW DEACT") == FALSE)
return;
if (!g_at_result_iter_skip_next(&iter))
return;
if (!g_at_result_iter_next_number(&iter, &cid))
return;
DBG("cid %d", cid);
if ((unsigned int) cid != gcd->active_context)
return;
if (gcd->state != STATE_IDLE && gcd->ppp)
g_at_ppp_shutdown(gcd->ppp);
}
static void csq_cb(gboolean ok, GAtResult *result, gpointer user_data)
{
struct cb_data *cbd = user_data;
ofono_netreg_strength_cb_t cb = cbd->cb;
int strength;
GAtResultIter iter;
struct ofono_error error;
decode_at_error(&error, g_at_result_final_response(result));
if (!ok) {
cb(&error, -1, cbd->data);
return;
}
g_at_result_iter_init(&iter, result);
if (!g_at_result_iter_next(&iter, "+CSQ:")) {
CALLBACK_WITH_FAILURE(cb, -1, cbd->data);
return;
}
g_at_result_iter_next_number(&iter, &strength);
DBG("csq_cb: %d", strength);
if (strength == 99)
strength = -1;
else
strength = (strength * 100) / 31;
cb(&error, strength, cbd->data);
}
static void at_cgsms_query_cb(gboolean ok, GAtResult *result,
gpointer user_data)
{
struct cb_data *cbd = user_data;
ofono_sms_bearer_query_cb_t cb = cbd->cb;
struct ofono_error error;
GAtResultIter iter;
int bearer;
decode_at_error(&error, g_at_result_final_response(result));
if (!ok) {
cb(&error, -1, cbd->data);
return;
}
g_at_result_iter_init(&iter, result);
if (!g_at_result_iter_next(&iter, "+CGSMS:"))
goto err;
g_at_result_iter_next_number(&iter, &bearer);
cb(&error, bearer, cbd->data);
return;
err:
CALLBACK_WITH_FAILURE(cb, -1, cbd->data);
}
static void at_cmgs_cb(gboolean ok, GAtResult *result, gpointer user_data)
{
struct cb_data *cbd = user_data;
GAtResultIter iter;
ofono_sms_submit_cb_t cb = cbd->cb;
struct ofono_error error;
int mr;
decode_at_error(&error, g_at_result_final_response(result));
if (!ok) {
cb(&error, -1, cbd->data);
return;
}
g_at_result_iter_init(&iter, result);
if (!g_at_result_iter_next(&iter, "+CMGS:"))
goto err;
if (!g_at_result_iter_next_number(&iter, &mr))
goto err;
DBG("Got MR: %d", mr);
cb(&error, mr, cbd->data);
return;
err:
CALLBACK_WITH_FAILURE(cb, -1, cbd->data);
}
static void at_cmgf_query_cb(gboolean ok, GAtResult *result,
gpointer user_data)
{
struct ofono_sms *sms = user_data;
struct sms_data *data = ofono_sms_get_data(sms);
gboolean supported = FALSE;
if (ok) {
GAtResultIter iter;
int mode;
g_at_result_iter_init(&iter, result);
if (!g_at_result_iter_next(&iter, "+CMGF:"))
goto out;
if (!g_at_result_iter_open_list(&iter))
goto out;
/* Look for mode 0 (PDU mode) */
while (g_at_result_iter_next_number(&iter, &mode))
if (mode == 0)
supported = TRUE;
}
out:
if (!supported)
return at_sms_not_supported(sms);
g_at_chat_send(data->chat, "AT+CPMS=?", cpms_prefix,
at_cpms_query_cb, sms, NULL);
}
static void bcs_notify(GAtResult *result, gpointer user_data)
{
struct hfp *hfp = user_data;
struct hfp_slc_info *info = &hfp->info;
GAtResultIter iter;
char str[32];
int value;
g_at_result_iter_init(&iter, result);
if (!g_at_result_iter_next(&iter, "+BCS:"))
return;
if (!g_at_result_iter_next_number(&iter, &value))
return;
if (ofono_handsfree_card_set_codec(hfp->card, value) == FALSE) {
/* Unsupported codec, re-send our codecs */
if (ofono_handsfree_audio_has_wideband())
sprintf(str, "AT+BAC=%d,%d", HFP_CODEC_CVSD,
HFP_CODEC_MSBC);
else
sprintf(str, "AT+BAC=%d", HFP_CODEC_CVSD);
goto done;
}
/* Confirm the codec */
sprintf(str, "AT+BCS=%d", value);
done:
g_at_chat_send(info->chat, str, none_prefix, NULL, NULL, NULL);
}
static void rat_query_cb(gboolean ok, GAtResult *result, gpointer user_data)
{
struct cb_data *cbd = user_data;
ofono_radio_settings_rat_mode_query_cb_t cb = cbd->cb;
enum ofono_radio_access_mode mode;
struct ofono_error error;
GAtResultIter iter;
int value;
decode_at_error(&error, g_at_result_final_response(result));
if (!ok) {
cb(&error, -1, cbd->data);
return;
}
g_at_result_iter_init(&iter, result);
if (!g_at_result_iter_next(&iter, "+CFUN:"))
goto err;
if (!g_at_result_iter_next_number(&iter, &value))
goto err;
if (!ste_mode_to_ofono_mode(value, &mode))
goto err;
CALLBACK_WITH_SUCCESS(cb, mode, cbd->data);
return;
err:
CALLBACK_WITH_FAILURE(cb, -1, 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);
}
static void at_crsm_read_cb(gboolean ok, GAtResult *result,
gpointer user_data)
{
struct cb_data *cbd = user_data;
GAtResultIter iter;
ofono_sim_read_cb_t cb = cbd->cb;
struct ofono_error error;
const guint8 *response;
gint sw1, sw2, 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);
if (!g_at_result_iter_next(&iter, "+CRSM:")) {
CALLBACK_WITH_FAILURE(cb, NULL, 0, cbd->data);
return;
}
g_at_result_iter_next_number(&iter, &sw1);
g_at_result_iter_next_number(&iter, &sw2);
if ((sw1 != 0x90 && sw1 != 0x91 && sw1 != 0x92 && sw1 != 0x9f) ||
(sw1 == 0x90 && sw2 != 0x00)) {
memset(&error, 0, sizeof(error));
error.type = OFONO_ERROR_TYPE_SIM;
error.error = (sw1 << 8) | sw2;
cb(&error, NULL, 0, cbd->data);
return;
}
if (!g_at_result_iter_next_hexstring(&iter, &response, &len)) {
CALLBACK_WITH_FAILURE(cb, NULL, 0, cbd->data);
return;
}
DBG("crsm_read_cb: %02x, %02x, %d", sw1, sw2, len);
cb(&error, response, len, cbd->data);
}
static void huawei_mode_notify(GAtResult *result, gpointer user_data)
{
struct ofono_gprs *gprs = user_data;
GAtResultIter iter;
int mode, submode;
gint bearer;
g_at_result_iter_init(&iter, result);
if (!g_at_result_iter_next(&iter, "^MODE:"))
return;
if (!g_at_result_iter_next_number(&iter, &mode))
return;
if (!g_at_result_iter_next_number(&iter, &submode))
return;
switch (submode) {
case 1:
case 2:
bearer = 1; /* GPRS */
break;
case 3:
bearer = 2; /* EDGE */
break;
case 4:
bearer = 3; /* UMTS */
break;
case 5:
bearer = 5; /* HSDPA */
break;
case 6:
bearer = 4; /* HSUPA */
break;
case 7:
case 9:
bearer = 6; /* HSUPA + HSDPA */
break;
default:
bearer = 0;
break;
}
ofono_gprs_bearer_notify(gprs, bearer);
}
static void telit_qss_cb(gboolean ok, GAtResult *result, gpointer user_data)
{
struct ofono_modem *modem = user_data;
int mode;
int status;
GAtResultIter iter;
g_at_result_iter_init(&iter, result);
DBG("%p", modem);
if (!g_at_result_iter_next(&iter, "#QSS:"))
return;
g_at_result_iter_next_number(&iter, &mode);
g_at_result_iter_next_number(&iter, &status);
switch_sim_state_status(modem, status);
}
static gboolean at_util_parse_reg_unsolicited(GAtResult *result,
const char *prefix, int *status,
int *lac, int *ci, int *tech)
{
GAtResultIter iter;
int s;
int l = -1, c = -1, t = -1;
const char *str;
g_at_result_iter_init(&iter, result);
if (g_at_result_iter_next(&iter, prefix) == FALSE)
return FALSE;
if (g_at_result_iter_next_number(&iter, &s) == FALSE)
return FALSE;
if (g_at_result_iter_next_string(&iter, &str) == TRUE)
l = strtol(str, NULL, 16);
else
goto out;
if (g_at_result_iter_next_string(&iter, &str) == TRUE)
c = strtol(str, NULL, 16);
else
goto out;
g_at_result_iter_next_number(&iter, &t);
out:
if (status)
*status = s;
if (lac)
*lac = l;
if (ci)
*ci = c;
if (tech)
*tech = t;
return TRUE;
}
static void ciev_notify(GAtResult *result, gpointer user_data)
{
struct ofono_netreg *netreg = user_data;
struct netreg_data *nd = ofono_netreg_get_data(netreg);
GAtResultIter iter;
int index, value, status;
g_at_result_iter_init(&iter, result);
if (!g_at_result_iter_next(&iter, "+CIEV:"))
return;
if (!g_at_result_iter_next_number(&iter, &index))
return;
if (!g_at_result_iter_next_number(&iter, &value))
return;
if (index == nd->cind_pos[HFP_INDICATOR_SERVICE]) {
nd->cind_val[HFP_INDICATOR_SERVICE] = value;
if (value)
status = NETWORK_REGISTRATION_STATUS_REGISTERED;
else
status = NETWORK_REGISTRATION_STATUS_NOT_REGISTERED;
ofono_netreg_status_notify(netreg, status, -1, -1, -1);
} else if (index == nd->cind_pos[HFP_INDICATOR_ROAM]) {
nd->cind_val[HFP_INDICATOR_ROAM] = value;
if (value)
status = NETWORK_REGISTRATION_STATUS_ROAMING;
else if (nd->cind_val[HFP_INDICATOR_SERVICE])
status = NETWORK_REGISTRATION_STATUS_REGISTERED;
else
status = NETWORK_REGISTRATION_STATUS_NOT_REGISTERED;
ofono_netreg_status_notify(netreg, status, -1, -1, -1);
} else if (index == nd->cind_pos[HFP_INDICATOR_SIGNAL]) {
nd->cind_val[HFP_INDICATOR_SIGNAL] = value;
ofono_netreg_strength_notify(netreg, value * 20);
}
return;
}
static void cssi_notify(GAtResult *result, gpointer user_data)
{
struct ofono_ssn *ssn = user_data;
GAtResultIter iter;
int code1, index;
g_at_result_iter_init(&iter, result);
if (!g_at_result_iter_next(&iter, "+CSSI:"))
return;
if (!g_at_result_iter_next_number(&iter, &code1))
return;
if (!g_at_result_iter_next_number(&iter, &index))
index = 0;
ofono_ssn_cssi_notify(ssn, code1, index);
}
