static void
modem_load_supported_modes (MMIfaceModem *self,
GAsyncReadyCallback callback,
gpointer user_data)
{
GSimpleAsyncResult *result;
MMModemMode mode;
/* Nokia phones don't seem to like AT+WS46?, they just report 2G even if
* 3G is supported, so we'll just assume they actually do 3G. */
mode = (MM_MODEM_MODE_2G | MM_MODEM_MODE_3G);
/* Then, if the modem has LTE caps, it does 4G */
if (mm_iface_modem_is_3gpp_lte (MM_IFACE_MODEM (self)))
mode |= MM_MODEM_MODE_4G;
result = g_simple_async_result_new (G_OBJECT (self),
callback,
user_data,
modem_load_supported_modes);
g_simple_async_result_set_op_res_gpointer (result,
GUINT_TO_POINTER (mode),
NULL);
g_simple_async_result_complete_in_idle (result);
g_object_unref (result);
}
static void
load_supported_modes (MMIfaceModem *self,
GAsyncReadyCallback callback,
gpointer user_data)
{
/* Run parent's loading */
iface_modem_parent->load_supported_modes (
MM_IFACE_MODEM (self),
(GAsyncReadyCallback)parent_load_supported_modes_ready,
g_simple_async_result_new (G_OBJECT (self),
callback,
user_data,
load_supported_modes));
}
static void
option_3g_tech_changed (MMPortSerialAt *port,
GMatchInfo *match_info,
MMBroadbandModemOption *self)
{
MMModemAccessTechnology act = MM_MODEM_ACCESS_TECHNOLOGY_UNKNOWN;
gchar *str;
str = g_match_info_fetch (match_info, 1);
if (str && owcti_to_mm (str[0], &act))
mm_iface_modem_update_access_technologies (MM_IFACE_MODEM (self),
act,
MM_IFACE_MODEM_3GPP_ALL_ACCESS_TECHNOLOGIES_MASK);
g_free (str);
}
static void
option_ossys_tech_changed (MMPortSerialAt *port,
GMatchInfo *info,
MMBroadbandModemOption *self)
{
MMModemAccessTechnology act = MM_MODEM_ACCESS_TECHNOLOGY_UNKNOWN;
gchar *str;
str = g_match_info_fetch (info, 1);
if (str) {
ossys_to_mm (str[0], &act);
g_free (str);
}
mm_iface_modem_update_access_technologies (MM_IFACE_MODEM (self),
act,
MM_IFACE_MODEM_3GPP_ALL_ACCESS_TECHNOLOGIES_MASK);
/* _OSSYSI only indicates general 2G/3G mode, so queue up some explicit
* access technology requests.
*/
if (act == MM_MODEM_ACCESS_TECHNOLOGY_GPRS)
run_access_technology_loading_sequence (MM_IFACE_MODEM (self),
ACCESS_TECHNOLOGIES_STEP_OCTI,
TRUE, /* check 2g */
FALSE, /* check 3g */
NULL,
NULL);
else if (act == MM_MODEM_ACCESS_TECHNOLOGY_UMTS)
run_access_technology_loading_sequence (MM_IFACE_MODEM (self),
ACCESS_TECHNOLOGIES_STEP_OWCTI,
FALSE, /* check 2g */
TRUE, /* check 3g */
NULL,
NULL);
}
static void
erinfo_received (MMPortSerialAt *port,
GMatchInfo *info,
MMBroadbandModemMbm *self)
{
MMModemAccessTechnology act = MM_MODEM_ACCESS_TECHNOLOGY_UNKNOWN;
guint mode;
if (mm_get_uint_from_match_info (info, 2, &mode)) {
switch (mode) {
case 1:
act = MM_MODEM_ACCESS_TECHNOLOGY_GPRS;
break;
case 2:
act = MM_MODEM_ACCESS_TECHNOLOGY_EDGE;
break;
default:
break;
}
}
/* 3G modes take precedence */
if (mm_get_uint_from_match_info (info, 3, &mode)) {
switch (mode) {
case 1:
act = MM_MODEM_ACCESS_TECHNOLOGY_UMTS;
break;
case 2:
act = MM_MODEM_ACCESS_TECHNOLOGY_HSDPA;
break;
case 3:
act = MM_MODEM_ACCESS_TECHNOLOGY_HSPA;
break;
default:
break;
}
}
mm_iface_modem_update_access_technologies (MM_IFACE_MODEM (self),
act,
MM_IFACE_MODEM_3GPP_ALL_ACCESS_TECHNOLOGIES_MASK);
}
static void
nwrssi_ready (MMBaseModem *self,
GAsyncResult *res,
GSimpleAsyncResult *simple)
{
const gchar *response;
gint quality;
response = mm_base_modem_at_command_finish (self, res, NULL);
if (!response) {
/* Fallback to parent's method */
iface_modem_parent->load_signal_quality (
MM_IFACE_MODEM (self),
(GAsyncReadyCallback)parent_load_signal_quality_ready,
simple);
return;
}
/* Parse the signal quality */
quality = get_one_quality (response, "RX0=");
if (quality < 0)
quality = get_one_quality (response, "1x RSSI=");
if (quality < 0)
quality = get_one_quality (response, "RX1=");
if (quality < 0)
quality = get_one_quality (response, "HDR RSSI=");
if (quality >= 0)
g_simple_async_result_set_op_res_gpointer (simple,
GUINT_TO_POINTER ((guint)quality),
NULL);
else
g_simple_async_result_set_error (simple,
MM_CORE_ERROR,
MM_CORE_ERROR_FAILED,
"Couldn't parse $NWRSSI response: '%s'",
response);
g_simple_async_result_complete (simple);
g_object_unref (simple);
}
static void
option_signal_changed (MMPortSerialAt *port,
GMatchInfo *match_info,
MMBroadbandModemOption *self)
{
gchar *str;
gint quality = 0;
str = g_match_info_fetch (match_info, 1);
if (str) {
quality = atoi (str);
g_free (str);
}
if (quality == 99) {
/* 99 means unknown */
quality = 0;
} else {
/* Normalize the quality */
quality = CLAMP (quality, 0, 31) * 100 / 31;
}
mm_iface_modem_update_signal_quality (MM_IFACE_MODEM (self), (guint)quality);
}
static void
selrat_query_ready (MMBaseModem *self,
GAsyncResult *res,
GSimpleAsyncResult *simple)
{
LoadAllowedModesResult result;
const gchar *response;
GError *error = NULL;
GRegex *r = NULL;
GMatchInfo *match_info = NULL;
response = mm_base_modem_at_command_full_finish (MM_BASE_MODEM (self), res, &error);
if (!response) {
g_simple_async_result_take_error (simple, error);
g_simple_async_result_complete (simple);
g_object_unref (simple);
return;
}
/* Example response: !SELRAT: 03, UMTS 3G Preferred */
r = g_regex_new ("!SELRAT:\\s*(\\d+).*$", 0, 0, NULL);
g_assert (r != NULL);
if (g_regex_match_full (r, response, strlen (response), 0, 0, &match_info, &error)) {
guint mode;
if (mm_get_uint_from_match_info (match_info, 1, &mode) &&
mode >= 0 &&
mode <= 7) {
switch (mode) {
case 0:
result.allowed = MM_MODEM_MODE_ANY;
result.preferred = MM_MODEM_MODE_NONE;
break;
case 1:
result.allowed = MM_MODEM_MODE_3G;
result.preferred = MM_MODEM_MODE_NONE;
break;
case 2:
result.allowed = MM_MODEM_MODE_2G;
result.preferred = MM_MODEM_MODE_NONE;
break;
case 3:
/* in Sierra LTE devices, mode 3 is automatic, including LTE, no preference */
if (mm_iface_modem_is_3gpp_lte (MM_IFACE_MODEM (self))) {
result.allowed = MM_MODEM_MODE_ANY;
result.preferred = MM_MODEM_MODE_NONE;
} else {
result.allowed = (MM_MODEM_MODE_2G | MM_MODEM_MODE_3G);
result.preferred = MM_MODEM_MODE_3G;
}
break;
case 4:
/* in Sierra LTE devices, mode 4 is automatic, including LTE, no preference */
if (mm_iface_modem_is_3gpp_lte (MM_IFACE_MODEM (self))) {
result.allowed = MM_MODEM_MODE_ANY;
result.preferred = MM_MODEM_MODE_NONE;
} else {
result.allowed = (MM_MODEM_MODE_2G | MM_MODEM_MODE_3G);
result.preferred = MM_MODEM_MODE_2G;
}
break;
case 5:
result.allowed = (MM_MODEM_MODE_2G | MM_MODEM_MODE_3G);
result.preferred = MM_MODEM_MODE_NONE;
break;
case 6:
result.allowed = MM_MODEM_MODE_4G;
result.preferred = MM_MODEM_MODE_NONE;
break;
case 7:
result.allowed = (MM_MODEM_MODE_2G | MM_MODEM_MODE_3G | MM_MODEM_MODE_4G);
result.preferred = MM_MODEM_MODE_NONE;
break;
default:
g_assert_not_reached ();
break;
}
} else
error = g_error_new (MM_CORE_ERROR,
MM_CORE_ERROR_FAILED,
"Failed to parse the allowed mode response: '%s'",
response);
}
if (error)
g_simple_async_result_take_error (simple, error);
else
g_simple_async_result_set_op_res_gpointer (simple, &result, NULL);
g_simple_async_result_complete (simple);
g_object_unref (simple);
}
