colin/ModemManager
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
fefbf4d3029ce8e1f2ed9db2bc8288e13989b05a
ModemManager/plugins/ublox/mm-modem-helpers-ublox.c
Aleksander Morgado ccf16e00a7 ublox,helpers: avoid cast-align errors 
We can safely cast the data in a GArray to gpointer first, and then
to the pointer type we require.

  ublox/mm-modem-helpers-ublox.c: In function 'parse_bands_from_string':
  ublox/mm-modem-helpers-ublox.c:1612:48: error: cast increases required alignment of target type [-Werror=cast-align]
           tmpstr = mm_common_build_bands_string ((MMModemBand *)(bands->data), bands->len);
                                                  ^
2020-05-19 13:44:23 +02:00

2064 lines
74 KiB
C
Raw Blame History

/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details:
*
* Copyright (C) 2016 Aleksander Morgado <aleksander@aleksander.es>
*/
#include <glib.h>
#include <string.h>
#include "mm-log.h"
#include "mm-modem-helpers.h"
#include "mm-modem-helpers-ublox.h"
/*****************************************************************************/
/* +UPINCNT response parser */
gboolean
mm_ublox_parse_upincnt_response (const gchar *response,
guint *out_pin_attempts,
guint *out_pin2_attempts,
guint *out_puk_attempts,
guint *out_puk2_attempts,
GError **error)
{
GRegex *r;
GMatchInfo *match_info;
GError *inner_error = NULL;
guint pin_attempts = 0;
guint pin2_attempts = 0;
guint puk_attempts = 0;
guint puk2_attempts = 0;
gboolean success = TRUE;
g_assert (out_pin_attempts);
g_assert (out_pin2_attempts);
g_assert (out_puk_attempts);
g_assert (out_puk2_attempts);
/* Response may be e.g.:
* +UPINCNT: 3,3,10,10
*/
r = g_regex_new ("\\+UPINCNT: (\\d+),(\\d+),(\\d+),(\\d+)(?:\\r\\n)?", 0, 0, NULL);
g_assert (r != NULL);
g_regex_match_full (r, response, strlen (response), 0, 0, &match_info, &inner_error);
if (!inner_error && g_match_info_matches (match_info)) {
if (!mm_get_uint_from_match_info (match_info, 1, &pin_attempts)) {
inner_error = g_error_new (MM_CORE_ERROR, MM_CORE_ERROR_UNSUPPORTED,
"Couldn't parse PIN attempts");
goto out;
}
if (!mm_get_uint_from_match_info (match_info, 2, &pin2_attempts)) {
inner_error = g_error_new (MM_CORE_ERROR, MM_CORE_ERROR_UNSUPPORTED,
"Couldn't parse PIN2 attempts");
goto out;
}
if (!mm_get_uint_from_match_info (match_info, 3, &puk_attempts)) {
inner_error = g_error_new (MM_CORE_ERROR, MM_CORE_ERROR_UNSUPPORTED,
"Couldn't parse PUK attempts");
goto out;
}
if (!mm_get_uint_from_match_info (match_info, 4, &puk2_attempts)) {
inner_error = g_error_new (MM_CORE_ERROR, MM_CORE_ERROR_UNSUPPORTED,
"Couldn't parse PUK2 attempts");
goto out;
}
success = TRUE;
}
out:
g_match_info_free (match_info);
g_regex_unref (r);
if (inner_error) {
g_propagate_error (error, inner_error);
return FALSE;
}
if (!success) {
g_set_error (error, MM_CORE_ERROR, MM_CORE_ERROR_FAILED,
"Couldn't parse +UPINCNT response: '%s'", response);
return FALSE;
}
*out_pin_attempts = pin_attempts;
*out_pin2_attempts = pin2_attempts;
*out_puk_attempts = puk_attempts;
*out_puk2_attempts = puk2_attempts;
return TRUE;
}
/*****************************************************************************/
/* UUSBCONF? response parser */
gboolean
mm_ublox_parse_uusbconf_response (const gchar *response,
MMUbloxUsbProfile *out_profile,
GError **error)
{
GRegex *r;
GMatchInfo *match_info;
GError *inner_error = NULL;
MMUbloxUsbProfile profile = MM_UBLOX_USB_PROFILE_UNKNOWN;
g_assert (out_profile != NULL);
/* Response may be e.g.:
* +UUSBCONF: 3,"RNDIS",,"0x1146"
* +UUSBCONF: 2,"ECM",,"0x1143"
* +UUSBCONF: 0,"",,"0x1141"
*
* Note: we don't rely on the PID; assuming future new modules will
* have a different PID but they may keep the profile names.
*/
r = g_regex_new ("\\+UUSBCONF: (\\d+),([^,]*),([^,]*),([^,]*)(?:\\r\\n)?", 0, 0, NULL);
g_assert (r != NULL);
g_regex_match_full (r, response, strlen (response), 0, 0, &match_info, &inner_error);
if (!inner_error && g_match_info_matches (match_info)) {
gchar *profile_name;
profile_name = mm_get_string_unquoted_from_match_info (match_info, 2);
if (profile_name && profile_name[0]) {
if (g_str_equal (profile_name, "RNDIS"))
profile = MM_UBLOX_USB_PROFILE_RNDIS;
else if (g_str_equal (profile_name, "ECM"))
profile = MM_UBLOX_USB_PROFILE_ECM;
else
inner_error = g_error_new (MM_CORE_ERROR, MM_CORE_ERROR_UNSUPPORTED,
"Unknown USB profile: '%s'", profile_name);
} else
profile = MM_UBLOX_USB_PROFILE_BACK_COMPATIBLE;
g_free (profile_name);
}
g_match_info_free (match_info);
g_regex_unref (r);
if (inner_error) {
g_propagate_error (error, inner_error);
return FALSE;
}
if (profile == MM_UBLOX_USB_PROFILE_UNKNOWN) {
g_set_error (error, MM_CORE_ERROR, MM_CORE_ERROR_FAILED,
"Couldn't parse profile response");
return FALSE;
}
*out_profile = profile;
return TRUE;
}
/*****************************************************************************/
/* UBMCONF? response parser */
gboolean
mm_ublox_parse_ubmconf_response (const gchar *response,
MMUbloxNetworkingMode *out_mode,
GError **error)
{
GRegex *r;
GMatchInfo *match_info;
GError *inner_error = NULL;
MMUbloxNetworkingMode mode = MM_UBLOX_NETWORKING_MODE_UNKNOWN;
g_assert (out_mode != NULL);
/* Response may be e.g.:
* +UBMCONF: 1
* +UBMCONF: 2
*/
r = g_regex_new ("\\+UBMCONF: (\\d+)(?:\\r\\n)?", 0, 0, NULL);
g_assert (r != NULL);
g_regex_match_full (r, response, strlen (response), 0, 0, &match_info, &inner_error);
if (!inner_error && g_match_info_matches (match_info)) {
guint mode_id = 0;
if (mm_get_uint_from_match_info (match_info, 1, &mode_id)) {
switch (mode_id) {
case 1:
mode = MM_UBLOX_NETWORKING_MODE_ROUTER;
break;
case 2:
mode = MM_UBLOX_NETWORKING_MODE_BRIDGE;
break;
default:
inner_error = g_error_new (MM_CORE_ERROR, MM_CORE_ERROR_UNSUPPORTED,
"Unknown mode id: '%u'", mode_id);
break;
}
}
}
g_match_info_free (match_info);
g_regex_unref (r);
if (inner_error) {
g_propagate_error (error, inner_error);
return FALSE;
}
if (mode == MM_UBLOX_NETWORKING_MODE_UNKNOWN) {
g_set_error (error, MM_CORE_ERROR, MM_CORE_ERROR_FAILED,
"Couldn't parse networking mode response");
return FALSE;
}
*out_mode = mode;
return TRUE;
}
/*****************************************************************************/
/* UIPADDR=N response parser */
gboolean
mm_ublox_parse_uipaddr_response (const gchar *response,
guint *out_cid,
gchar **out_if_name,
gchar **out_ipv4_address,
gchar **out_ipv4_subnet,
gchar **out_ipv6_global_address,
gchar **out_ipv6_link_local_address,
GError **error)
{
GRegex *r;
GMatchInfo *match_info;
GError *inner_error = NULL;
guint cid = 0;
gchar *if_name = NULL;
gchar *ipv4_address = NULL;
gchar *ipv4_subnet = NULL;
gchar *ipv6_global_address = NULL;
gchar *ipv6_link_local_address = NULL;
/* Response may be e.g.:
* +UIPADDR: 1,"ccinet0","5.168.120.13","255.255.255.0","",""
* +UIPADDR: 2,"ccinet1","","","2001::2:200:FF:FE00:0/64","FE80::200:FF:FE00:0/64"
* +UIPADDR: 3,"ccinet2","5.10.100.2","255.255.255.0","2001::1:200:FF:FE00:0/64","FE80::200:FF:FE00:0/64"
*
* We assume only ONE line is returned; because we request +UIPADDR with a specific N CID.
*/
r = g_regex_new ("\\+UIPADDR: (\\d+),([^,]*),([^,]*),([^,]*),([^,]*),([^,]*)(?:\\r\\n)?", 0, 0, NULL);
g_assert (r != NULL);
g_regex_match_full (r, response, strlen (response), 0, 0, &match_info, &inner_error);
if (inner_error)
goto out;
if (!g_match_info_matches (match_info)) {
inner_error = g_error_new (MM_CORE_ERROR, MM_CORE_ERROR_INVALID_ARGS, "Couldn't match +UIPADDR response");
goto out;
}
if (out_cid && !mm_get_uint_from_match_info (match_info, 1, &cid)) {
inner_error = g_error_new (MM_CORE_ERROR, MM_CORE_ERROR_FAILED, "Error parsing cid");
goto out;
}
if (out_if_name && !(if_name = mm_get_string_unquoted_from_match_info (match_info, 2))) {
inner_error = g_error_new (MM_CORE_ERROR, MM_CORE_ERROR_FAILED, "Error parsing interface name");
goto out;
}
/* Remaining strings are optional */
if (out_ipv4_address)
ipv4_address = mm_get_string_unquoted_from_match_info (match_info, 3);
if (out_ipv4_subnet)
ipv4_subnet = mm_get_string_unquoted_from_match_info (match_info, 4);
if (out_ipv6_global_address)
ipv6_global_address = mm_get_string_unquoted_from_match_info (match_info, 5);
if (out_ipv6_link_local_address)
ipv6_link_local_address = mm_get_string_unquoted_from_match_info (match_info, 6);
out:
g_match_info_free (match_info);
g_regex_unref (r);
if (inner_error) {
g_free (if_name);
g_free (ipv4_address);
g_free (ipv4_subnet);
g_free (ipv6_global_address);
g_free (ipv6_link_local_address);
g_propagate_error (error, inner_error);
return FALSE;
}
if (out_cid)
*out_cid = cid;
if (out_if_name)
*out_if_name = if_name;
if (out_ipv4_address)
*out_ipv4_address = ipv4_address;
if (out_ipv4_subnet)
*out_ipv4_subnet = ipv4_subnet;
if (out_ipv6_global_address)
*out_ipv6_global_address = ipv6_global_address;
if (out_ipv6_link_local_address)
*out_ipv6_link_local_address = ipv6_link_local_address;
return TRUE;
}
/*****************************************************************************/
/* CFUN? response parser */
gboolean
mm_ublox_parse_cfun_response (const gchar *response,
MMModemPowerState *out_state,
GError **error)
{
guint state;
if (!mm_3gpp_parse_cfun_query_response (response, &state, error))
return FALSE;
switch (state) {
case 1:
*out_state = MM_MODEM_POWER_STATE_ON;
return TRUE;
case 0:
/* minimum functionality */
case 4:
/* airplane mode */
case 19:
/* minimum functionality with SIM deactivated */
*out_state = MM_MODEM_POWER_STATE_LOW;
return TRUE;
default:
g_set_error (error, MM_CORE_ERROR, MM_CORE_ERROR_FAILED,
"Unknown +CFUN state: %u", state);
return FALSE;
}
}
/*****************************************************************************/
/* URAT=? response parser */
/* Index of the array is the ublox-specific value */
static const MMModemMode ublox_combinations[] = {
( MM_MODEM_MODE_2G ),
( MM_MODEM_MODE_2G | MM_MODEM_MODE_3G ),
( MM_MODEM_MODE_3G ),
( MM_MODEM_MODE_4G ),
( MM_MODEM_MODE_2G | MM_MODEM_MODE_3G | MM_MODEM_MODE_4G ),
( MM_MODEM_MODE_2G | MM_MODEM_MODE_4G ),
( MM_MODEM_MODE_3G | MM_MODEM_MODE_4G ),
};
GArray *
mm_ublox_parse_urat_test_response (const gchar *response,
gpointer log_object,
GError **error)
{
GArray *combinations = NULL;
GArray *selected = NULL;
GArray *preferred = NULL;
gchar **split;
guint split_len;
GError *inner_error = NULL;
guint i;
/*
* E.g.:
* AT+URAT=?
* +URAT: (0-6),(0,2,3)
*/
response = mm_strip_tag (response, "+URAT:");
split = mm_split_string_groups (response);
split_len = g_strv_length (split);
if (split_len > 2 || split_len < 1) {
inner_error = g_error_new (MM_CORE_ERROR, MM_CORE_ERROR_FAILED,
"Unexpected number of groups in +URAT=? response: %u", g_strv_length (split));
goto out;
}
/* The selected list must have values */
selected = mm_parse_uint_list (split[0], &inner_error);
if (inner_error)
goto out;
if (!selected) {
inner_error = g_error_new (MM_CORE_ERROR, MM_CORE_ERROR_FAILED,
"No selected RAT values given in +URAT=? response");
goto out;
}
/* For our purposes, the preferred list may be empty */
preferred = mm_parse_uint_list (split[1], &inner_error);
if (inner_error)
goto out;
/* Build array of combinations */
combinations = g_array_new (FALSE, FALSE, sizeof (MMModemModeCombination));
for (i = 0; i < selected->len; i++) {
guint selected_value;
MMModemModeCombination combination;
guint j;
selected_value = g_array_index (selected, guint, i);
if (selected_value >= G_N_ELEMENTS (ublox_combinations)) {
mm_obj_warn (log_object, "unexpected AcT value: %u", selected_value);
continue;
}
/* Combination without any preferred */
combination.allowed = ublox_combinations[selected_value];
combination.preferred = MM_MODEM_MODE_NONE;
g_array_append_val (combinations, combination);
if (mm_count_bits_set (combination.allowed) == 1)
continue;
if (!preferred)
continue;
for (j = 0; j < preferred->len; j++) {
guint preferred_value;
preferred_value = g_array_index (preferred, guint, j);
if (preferred_value >= G_N_ELEMENTS (ublox_combinations)) {
mm_obj_warn (log_object, "unexpected AcT preferred value: %u", preferred_value);
continue;
}
combination.preferred = ublox_combinations[preferred_value];
if (mm_count_bits_set (combination.preferred) != 1) {
mm_obj_warn (log_object, "AcT preferred value should be a single AcT: %u", preferred_value);
continue;
}
if (!(combination.allowed & combination.preferred))
continue;
g_array_append_val (combinations, combination);
}
}
if (combinations->len == 0) {
inner_error = g_error_new (MM_CORE_ERROR, MM_CORE_ERROR_FAILED,
"No combinations built from +URAT=? response");
goto out;
}
out:
g_strfreev (split);
if (selected)
g_array_unref (selected);
if (preferred)
g_array_unref (preferred);
if (inner_error) {
if (combinations)
g_array_unref (combinations);
g_propagate_error (error, inner_error);
return NULL;
}
return combinations;
}
typedef struct {
const gchar *model;
SettingsUpdateMethod method;
FeatureSupport uact;
FeatureSupport ubandsel;
MMModemMode mode;
MMModemBand bands_2g[4];
MMModemBand bands_3g[6];
MMModemBand bands_4g[12];
} BandConfiguration;
static const BandConfiguration band_configuration[] = {
{
.model = "SARA-G300",
.method = SETTINGS_UPDATE_METHOD_COPS,
.uact = FEATURE_UNSUPPORTED,
.ubandsel = FEATURE_SUPPORTED,
.mode = MM_MODEM_MODE_2G,
.bands_2g = { MM_MODEM_BAND_EGSM, MM_MODEM_BAND_DCS }
},
{
.model = "SARA-G310",
.method = SETTINGS_UPDATE_METHOD_COPS,
.uact = FEATURE_UNSUPPORTED,
.ubandsel = FEATURE_SUPPORTED,
.mode = MM_MODEM_MODE_2G,
.bands_2g = { MM_MODEM_BAND_G850, MM_MODEM_BAND_EGSM, MM_MODEM_BAND_DCS, MM_MODEM_BAND_PCS }
},
{
.model = "SARA-G340",
.method = SETTINGS_UPDATE_METHOD_COPS,
.uact = FEATURE_UNSUPPORTED,
.ubandsel = FEATURE_SUPPORTED,
.mode = MM_MODEM_MODE_2G,
.bands_2g = { MM_MODEM_BAND_EGSM, MM_MODEM_BAND_DCS }
},
{
.model = "SARA-G350",
.method = SETTINGS_UPDATE_METHOD_COPS,
.uact = FEATURE_UNSUPPORTED,
.ubandsel = FEATURE_SUPPORTED,
.mode = MM_MODEM_MODE_2G,
.bands_2g = { MM_MODEM_BAND_G850, MM_MODEM_BAND_EGSM, MM_MODEM_BAND_DCS, MM_MODEM_BAND_PCS }
},
{
.model = "SARA-G450",
.method = SETTINGS_UPDATE_METHOD_COPS,
.uact = FEATURE_UNSUPPORTED,
.ubandsel = FEATURE_SUPPORTED,
.mode = MM_MODEM_MODE_2G,
.bands_2g = { MM_MODEM_BAND_G850, MM_MODEM_BAND_EGSM, MM_MODEM_BAND_DCS, MM_MODEM_BAND_PCS }
},
{
.model = "LISA-U200",
.method = SETTINGS_UPDATE_METHOD_COPS,
.uact = FEATURE_UNSUPPORTED,
.ubandsel = FEATURE_SUPPORTED,
.mode = MM_MODEM_MODE_2G | MM_MODEM_MODE_3G,
.bands_2g = { MM_MODEM_BAND_G850, MM_MODEM_BAND_EGSM, MM_MODEM_BAND_DCS, MM_MODEM_BAND_PCS },
.bands_3g = { MM_MODEM_BAND_UTRAN_6, MM_MODEM_BAND_UTRAN_5, MM_MODEM_BAND_UTRAN_8,
MM_MODEM_BAND_UTRAN_4, MM_MODEM_BAND_UTRAN_2, MM_MODEM_BAND_UTRAN_1 }
},
{
.model = "LISA-U201",
.method = SETTINGS_UPDATE_METHOD_COPS,
.uact = FEATURE_UNSUPPORTED,
.ubandsel = FEATURE_SUPPORTED,
.mode = MM_MODEM_MODE_2G | MM_MODEM_MODE_3G,
.bands_2g = { MM_MODEM_BAND_G850, MM_MODEM_BAND_EGSM, MM_MODEM_BAND_DCS, MM_MODEM_BAND_PCS },
.bands_3g = { MM_MODEM_BAND_UTRAN_6, MM_MODEM_BAND_UTRAN_5, MM_MODEM_BAND_UTRAN_8,
MM_MODEM_BAND_UTRAN_2, MM_MODEM_BAND_UTRAN_1 }
},
{
.model = "LISA-U230",
.method = SETTINGS_UPDATE_METHOD_COPS,
.uact = FEATURE_UNSUPPORTED,
.ubandsel = FEATURE_SUPPORTED,
.mode = MM_MODEM_MODE_2G | MM_MODEM_MODE_3G,
.bands_2g = { MM_MODEM_BAND_G850, MM_MODEM_BAND_EGSM, MM_MODEM_BAND_DCS, MM_MODEM_BAND_PCS },
.bands_3g = { MM_MODEM_BAND_UTRAN_6, MM_MODEM_BAND_UTRAN_5, MM_MODEM_BAND_UTRAN_8,
MM_MODEM_BAND_UTRAN_4, MM_MODEM_BAND_UTRAN_2, MM_MODEM_BAND_UTRAN_1 }
},
{
.model = "LISA-U260",
.method = SETTINGS_UPDATE_METHOD_COPS,
.uact = FEATURE_UNSUPPORTED,
.ubandsel = FEATURE_SUPPORTED,
.mode = MM_MODEM_MODE_2G | MM_MODEM_MODE_3G,
.bands_2g = { MM_MODEM_BAND_G850, MM_MODEM_BAND_EGSM, MM_MODEM_BAND_DCS, MM_MODEM_BAND_PCS },
.bands_3g = { MM_MODEM_BAND_UTRAN_5, MM_MODEM_BAND_UTRAN_2 }
},
{
.model = "LISA-U270",
.method = SETTINGS_UPDATE_METHOD_COPS,
.uact = FEATURE_UNSUPPORTED,
.ubandsel = FEATURE_SUPPORTED,
.mode = MM_MODEM_MODE_2G | MM_MODEM_MODE_3G,
.bands_2g = { MM_MODEM_BAND_G850, MM_MODEM_BAND_EGSM, MM_MODEM_BAND_DCS, MM_MODEM_BAND_PCS },
.bands_3g = { MM_MODEM_BAND_UTRAN_8, MM_MODEM_BAND_UTRAN_1 }
},
{
.model = "SARA-U201",
.method = SETTINGS_UPDATE_METHOD_COPS,
.uact = FEATURE_UNSUPPORTED,
.ubandsel = FEATURE_SUPPORTED,
.mode = MM_MODEM_MODE_2G | MM_MODEM_MODE_3G,
.bands_2g = { MM_MODEM_BAND_G850, MM_MODEM_BAND_EGSM, MM_MODEM_BAND_DCS, MM_MODEM_BAND_PCS },
.bands_3g = { MM_MODEM_BAND_UTRAN_6, MM_MODEM_BAND_UTRAN_5, MM_MODEM_BAND_UTRAN_8,
MM_MODEM_BAND_UTRAN_2, MM_MODEM_BAND_UTRAN_1 }
},
{
.model = "SARA-U260",
.method = SETTINGS_UPDATE_METHOD_COPS,
.uact = FEATURE_UNSUPPORTED,
.ubandsel = FEATURE_SUPPORTED,
.mode = MM_MODEM_MODE_2G | MM_MODEM_MODE_3G,
.bands_2g = { MM_MODEM_BAND_G850, MM_MODEM_BAND_PCS },
.bands_3g = { MM_MODEM_BAND_UTRAN_5, MM_MODEM_BAND_UTRAN_2 }
},
{
.model = "SARA-U270",
.method = SETTINGS_UPDATE_METHOD_COPS,
.uact = FEATURE_UNSUPPORTED,
.ubandsel = FEATURE_SUPPORTED,
.mode = MM_MODEM_MODE_2G | MM_MODEM_MODE_3G,
.bands_2g = { MM_MODEM_BAND_EGSM, MM_MODEM_BAND_DCS },
.bands_3g = { MM_MODEM_BAND_UTRAN_8, MM_MODEM_BAND_UTRAN_1 }
},
{
.model = "SARA-U280",
.method = SETTINGS_UPDATE_METHOD_COPS,
.uact = FEATURE_UNSUPPORTED,
.ubandsel = FEATURE_SUPPORTED,
.mode = MM_MODEM_MODE_3G,
.bands_3g = { MM_MODEM_BAND_UTRAN_5, MM_MODEM_BAND_UTRAN_2 }
},
{
.model = "MPCI-L201",
.method = SETTINGS_UPDATE_METHOD_CFUN,
.uact = FEATURE_UNSUPPORTED,
.ubandsel = FEATURE_SUPPORTED,
.mode = MM_MODEM_MODE_3G | MM_MODEM_MODE_4G,
.bands_3g = { MM_MODEM_BAND_UTRAN_5, MM_MODEM_BAND_UTRAN_2 },
.bands_4g = { MM_MODEM_BAND_EUTRAN_2, MM_MODEM_BAND_EUTRAN_4, MM_MODEM_BAND_EUTRAN_5,
MM_MODEM_BAND_EUTRAN_13, MM_MODEM_BAND_EUTRAN_17 }
},
{
.model = "MPCI-L200",
.method = SETTINGS_UPDATE_METHOD_CFUN,
.uact = FEATURE_UNSUPPORTED,
.ubandsel = FEATURE_SUPPORTED,
.mode = MM_MODEM_MODE_2G | MM_MODEM_MODE_3G | MM_MODEM_MODE_4G,
.bands_2g = { MM_MODEM_BAND_G850, MM_MODEM_BAND_EGSM, MM_MODEM_BAND_DCS, MM_MODEM_BAND_PCS },
.bands_3g = { MM_MODEM_BAND_UTRAN_5, MM_MODEM_BAND_UTRAN_8, MM_MODEM_BAND_UTRAN_4,
MM_MODEM_BAND_UTRAN_2, MM_MODEM_BAND_UTRAN_1 },
.bands_4g = { MM_MODEM_BAND_EUTRAN_2, MM_MODEM_BAND_EUTRAN_4, MM_MODEM_BAND_EUTRAN_5,
MM_MODEM_BAND_EUTRAN_7, MM_MODEM_BAND_EUTRAN_17 }
},
{
.model = "MPCI-L210",
.method = SETTINGS_UPDATE_METHOD_CFUN,
.uact = FEATURE_UNSUPPORTED,
.ubandsel = FEATURE_SUPPORTED,
.mode = MM_MODEM_MODE_2G | MM_MODEM_MODE_3G | MM_MODEM_MODE_4G,
.bands_2g = { MM_MODEM_BAND_G850, MM_MODEM_BAND_EGSM, MM_MODEM_BAND_DCS, MM_MODEM_BAND_PCS },
.bands_3g = { MM_MODEM_BAND_UTRAN_5, MM_MODEM_BAND_UTRAN_8, MM_MODEM_BAND_UTRAN_2,
MM_MODEM_BAND_UTRAN_1 },
.bands_4g = { MM_MODEM_BAND_EUTRAN_1, MM_MODEM_BAND_EUTRAN_3, MM_MODEM_BAND_EUTRAN_5,
MM_MODEM_BAND_EUTRAN_7, MM_MODEM_BAND_EUTRAN_8, MM_MODEM_BAND_EUTRAN_20 }
},
{
.model = "MPCI-L220",
.method = SETTINGS_UPDATE_METHOD_CFUN,
.uact = FEATURE_UNSUPPORTED,
.ubandsel = FEATURE_SUPPORTED,
.mode = MM_MODEM_MODE_3G | MM_MODEM_MODE_4G,
.bands_3g = { MM_MODEM_BAND_UTRAN_5, MM_MODEM_BAND_UTRAN_8, MM_MODEM_BAND_UTRAN_1 },
.bands_4g = { MM_MODEM_BAND_EUTRAN_1, MM_MODEM_BAND_EUTRAN_3, MM_MODEM_BAND_EUTRAN_5,
MM_MODEM_BAND_EUTRAN_8, MM_MODEM_BAND_EUTRAN_19 }
},
{
.model = "MPCI-L280",
.method = SETTINGS_UPDATE_METHOD_CFUN,
.uact = FEATURE_UNSUPPORTED,
.ubandsel = FEATURE_SUPPORTED,
.mode = MM_MODEM_MODE_2G | MM_MODEM_MODE_3G | MM_MODEM_MODE_4G,
.bands_2g = { MM_MODEM_BAND_G850, MM_MODEM_BAND_EGSM, MM_MODEM_BAND_DCS, MM_MODEM_BAND_PCS },
.bands_3g = { MM_MODEM_BAND_UTRAN_5, MM_MODEM_BAND_UTRAN_8, MM_MODEM_BAND_UTRAN_2,
MM_MODEM_BAND_UTRAN_1 },
.bands_4g = { MM_MODEM_BAND_EUTRAN_1, MM_MODEM_BAND_EUTRAN_3, MM_MODEM_BAND_EUTRAN_5,
MM_MODEM_BAND_EUTRAN_7, MM_MODEM_BAND_EUTRAN_8, MM_MODEM_BAND_EUTRAN_28 }
},
{
.model = "TOBY-L200",
.method = SETTINGS_UPDATE_METHOD_CFUN,
.uact = FEATURE_UNSUPPORTED,
.ubandsel = FEATURE_SUPPORTED,
.mode = MM_MODEM_MODE_2G | MM_MODEM_MODE_3G | MM_MODEM_MODE_4G,
.bands_2g = { MM_MODEM_BAND_G850, MM_MODEM_BAND_EGSM, MM_MODEM_BAND_DCS, MM_MODEM_BAND_PCS },
.bands_3g = { MM_MODEM_BAND_UTRAN_5, MM_MODEM_BAND_UTRAN_8, MM_MODEM_BAND_UTRAN_4,
MM_MODEM_BAND_UTRAN_2, MM_MODEM_BAND_UTRAN_1 },
.bands_4g = { MM_MODEM_BAND_EUTRAN_2, MM_MODEM_BAND_EUTRAN_4, MM_MODEM_BAND_EUTRAN_5,
MM_MODEM_BAND_EUTRAN_7, MM_MODEM_BAND_EUTRAN_17 }
},
{
.model = "TOBY-L201",
.method = SETTINGS_UPDATE_METHOD_CFUN,
.uact = FEATURE_UNSUPPORTED,
.ubandsel = FEATURE_SUPPORTED,
.mode = MM_MODEM_MODE_3G | MM_MODEM_MODE_4G,
.bands_3g = { MM_MODEM_BAND_UTRAN_5, MM_MODEM_BAND_UTRAN_2 },
.bands_4g = { MM_MODEM_BAND_EUTRAN_2, MM_MODEM_BAND_EUTRAN_4, MM_MODEM_BAND_EUTRAN_5,
MM_MODEM_BAND_EUTRAN_13, MM_MODEM_BAND_EUTRAN_17 }
},
{
.model = "TOBY-L210",
.method = SETTINGS_UPDATE_METHOD_CFUN,
.uact = FEATURE_UNSUPPORTED,
.ubandsel = FEATURE_SUPPORTED,
.mode = MM_MODEM_MODE_2G | MM_MODEM_MODE_3G | MM_MODEM_MODE_4G,
.bands_2g = { MM_MODEM_BAND_G850, MM_MODEM_BAND_EGSM, MM_MODEM_BAND_DCS, MM_MODEM_BAND_PCS },
.bands_3g = { MM_MODEM_BAND_UTRAN_5, MM_MODEM_BAND_UTRAN_8, MM_MODEM_BAND_UTRAN_2,
MM_MODEM_BAND_UTRAN_1 },
.bands_4g = { MM_MODEM_BAND_EUTRAN_1, MM_MODEM_BAND_EUTRAN_3, MM_MODEM_BAND_EUTRAN_5,
MM_MODEM_BAND_EUTRAN_7, MM_MODEM_BAND_EUTRAN_8, MM_MODEM_BAND_EUTRAN_20 }
},
{
.model = "TOBY-L220",
.method = SETTINGS_UPDATE_METHOD_CFUN,
.uact = FEATURE_UNSUPPORTED,
.ubandsel = FEATURE_SUPPORTED,
.mode = MM_MODEM_MODE_3G | MM_MODEM_MODE_4G,
.bands_3g = { MM_MODEM_BAND_UTRAN_5, MM_MODEM_BAND_UTRAN_8, MM_MODEM_BAND_UTRAN_2,
MM_MODEM_BAND_UTRAN_1 },
.bands_4g = { MM_MODEM_BAND_EUTRAN_1, MM_MODEM_BAND_EUTRAN_3, MM_MODEM_BAND_EUTRAN_5,
MM_MODEM_BAND_EUTRAN_8, MM_MODEM_BAND_EUTRAN_19 }
},
{
.model = "TOBY-L280",
.method = SETTINGS_UPDATE_METHOD_CFUN,
.uact = FEATURE_UNSUPPORTED,
.ubandsel = FEATURE_SUPPORTED,
.mode = MM_MODEM_MODE_2G | MM_MODEM_MODE_3G | MM_MODEM_MODE_4G,
.bands_2g = { MM_MODEM_BAND_G850, MM_MODEM_BAND_EGSM, MM_MODEM_BAND_DCS, MM_MODEM_BAND_PCS },
.bands_3g = { MM_MODEM_BAND_UTRAN_5, MM_MODEM_BAND_UTRAN_8, MM_MODEM_BAND_UTRAN_2,
MM_MODEM_BAND_UTRAN_1 },
.bands_4g = { MM_MODEM_BAND_EUTRAN_1, MM_MODEM_BAND_EUTRAN_3, MM_MODEM_BAND_EUTRAN_5,
MM_MODEM_BAND_EUTRAN_7, MM_MODEM_BAND_EUTRAN_8, MM_MODEM_BAND_EUTRAN_28 }
},
{
.model = "TOBY-L4006",
.method = SETTINGS_UPDATE_METHOD_CFUN,
.uact = FEATURE_SUPPORTED,
.ubandsel = FEATURE_UNSUPPORTED,
.mode = MM_MODEM_MODE_2G | MM_MODEM_MODE_3G | MM_MODEM_MODE_4G,
.bands_2g = { MM_MODEM_BAND_G850, MM_MODEM_BAND_PCS },
.bands_3g = { MM_MODEM_BAND_UTRAN_5, MM_MODEM_BAND_UTRAN_4, MM_MODEM_BAND_UTRAN_2 },
.bands_4g = { MM_MODEM_BAND_EUTRAN_2, MM_MODEM_BAND_EUTRAN_4, MM_MODEM_BAND_EUTRAN_5,
MM_MODEM_BAND_EUTRAN_7, MM_MODEM_BAND_EUTRAN_12, MM_MODEM_BAND_EUTRAN_13,
MM_MODEM_BAND_EUTRAN_29 }
},
{
.model = "TOBY-L4106",
.method = SETTINGS_UPDATE_METHOD_CFUN,
.uact = FEATURE_SUPPORTED,
.ubandsel = FEATURE_UNSUPPORTED,
.mode = MM_MODEM_MODE_2G | MM_MODEM_MODE_3G | MM_MODEM_MODE_4G,
.bands_2g = { MM_MODEM_BAND_EGSM, MM_MODEM_BAND_DCS },
.bands_3g = { MM_MODEM_BAND_UTRAN_8, MM_MODEM_BAND_UTRAN_1 },
.bands_4g = { MM_MODEM_BAND_EUTRAN_1, MM_MODEM_BAND_EUTRAN_3, MM_MODEM_BAND_EUTRAN_7,
MM_MODEM_BAND_EUTRAN_8, MM_MODEM_BAND_EUTRAN_20, MM_MODEM_BAND_EUTRAN_38 }
},
{
.model = "TOBY-L4206",
.method = SETTINGS_UPDATE_METHOD_CFUN,
.uact = FEATURE_SUPPORTED,
.ubandsel = FEATURE_UNSUPPORTED,
.mode = MM_MODEM_MODE_2G | MM_MODEM_MODE_3G | MM_MODEM_MODE_4G,
.bands_2g = { MM_MODEM_BAND_G850, MM_MODEM_BAND_EGSM, MM_MODEM_BAND_DCS, MM_MODEM_BAND_PCS },
.bands_3g = { MM_MODEM_BAND_UTRAN_5, MM_MODEM_BAND_UTRAN_8, MM_MODEM_BAND_UTRAN_1 },
.bands_4g = { MM_MODEM_BAND_EUTRAN_1, MM_MODEM_BAND_EUTRAN_3, MM_MODEM_BAND_EUTRAN_5,
MM_MODEM_BAND_EUTRAN_7, MM_MODEM_BAND_EUTRAN_8, MM_MODEM_BAND_EUTRAN_9,
MM_MODEM_BAND_EUTRAN_19, MM_MODEM_BAND_EUTRAN_28 }
},
{
.model = "TOBY-L4906",
.method = SETTINGS_UPDATE_METHOD_CFUN,
.uact = FEATURE_SUPPORTED,
.ubandsel = FEATURE_UNSUPPORTED,
.mode = MM_MODEM_MODE_2G | MM_MODEM_MODE_3G | MM_MODEM_MODE_4G,
.bands_2g = { MM_MODEM_BAND_EGSM, MM_MODEM_BAND_DCS },
.bands_3g = { MM_MODEM_BAND_UTRAN_8, MM_MODEM_BAND_UTRAN_1 },
.bands_4g = { MM_MODEM_BAND_EUTRAN_1, MM_MODEM_BAND_EUTRAN_3, MM_MODEM_BAND_EUTRAN_39,
MM_MODEM_BAND_EUTRAN_40, MM_MODEM_BAND_EUTRAN_41 }
},
{
.model = "TOBY-R200",
.method = SETTINGS_UPDATE_METHOD_COPS,
.uact = FEATURE_UNSUPPORTED,
.ubandsel = FEATURE_SUPPORTED,
.mode = MM_MODEM_MODE_2G | MM_MODEM_MODE_3G | MM_MODEM_MODE_4G,
.bands_2g = { MM_MODEM_BAND_G850, MM_MODEM_BAND_EGSM, MM_MODEM_BAND_DCS, MM_MODEM_BAND_PCS },
.bands_3g = { MM_MODEM_BAND_UTRAN_5, MM_MODEM_BAND_UTRAN_8, MM_MODEM_BAND_UTRAN_2,
MM_MODEM_BAND_UTRAN_1 },
.bands_4g = { MM_MODEM_BAND_EUTRAN_2, MM_MODEM_BAND_EUTRAN_4, MM_MODEM_BAND_EUTRAN_5,
MM_MODEM_BAND_EUTRAN_12 }
},
{
.model = "TOBY-R202",
.method = SETTINGS_UPDATE_METHOD_COPS,
.uact = FEATURE_UNSUPPORTED,
.ubandsel = FEATURE_SUPPORTED,
.mode = MM_MODEM_MODE_3G | MM_MODEM_MODE_4G,
.bands_3g = { MM_MODEM_BAND_UTRAN_5, MM_MODEM_BAND_UTRAN_2 },
.bands_4g = { MM_MODEM_BAND_EUTRAN_2, MM_MODEM_BAND_EUTRAN_4, MM_MODEM_BAND_EUTRAN_5,
MM_MODEM_BAND_EUTRAN_12 }
},
{
.model = "LARA-R202",
.method = SETTINGS_UPDATE_METHOD_COPS,
.uact = FEATURE_UNSUPPORTED,
.ubandsel = FEATURE_SUPPORTED,
.mode = MM_MODEM_MODE_3G | MM_MODEM_MODE_4G,
.bands_3g = { MM_MODEM_BAND_UTRAN_5, MM_MODEM_BAND_UTRAN_2 },
.bands_4g = { MM_MODEM_BAND_EUTRAN_2, MM_MODEM_BAND_EUTRAN_4, MM_MODEM_BAND_EUTRAN_5,
MM_MODEM_BAND_EUTRAN_12 }
},
{
.model = "LARA-R203",
.method = SETTINGS_UPDATE_METHOD_COPS,
.uact = FEATURE_UNSUPPORTED,
.ubandsel = FEATURE_SUPPORTED,
.mode = MM_MODEM_MODE_4G,
.bands_4g = { MM_MODEM_BAND_EUTRAN_2, MM_MODEM_BAND_EUTRAN_4, MM_MODEM_BAND_EUTRAN_12 }
},
{
.model = "LARA-R204",
.method = SETTINGS_UPDATE_METHOD_COPS,
.uact = FEATURE_UNSUPPORTED,
.ubandsel = FEATURE_SUPPORTED,
.mode = MM_MODEM_MODE_4G,
.bands_4g = { MM_MODEM_BAND_EUTRAN_4, MM_MODEM_BAND_EUTRAN_13 }
},
{
.model = "LARA-R211",
.method = SETTINGS_UPDATE_METHOD_COPS,
.uact = FEATURE_UNSUPPORTED,
.ubandsel = FEATURE_SUPPORTED,
.mode = MM_MODEM_MODE_2G | MM_MODEM_MODE_4G,
.bands_2g = { MM_MODEM_BAND_EGSM, MM_MODEM_BAND_DCS },
.bands_4g = { MM_MODEM_BAND_EUTRAN_3, MM_MODEM_BAND_EUTRAN_7, MM_MODEM_BAND_EUTRAN_20 }
},
{
.model = "LARA-R280",
.method = SETTINGS_UPDATE_METHOD_COPS,
.uact = FEATURE_UNSUPPORTED,
.ubandsel = FEATURE_SUPPORTED,
.mode = MM_MODEM_MODE_3G | MM_MODEM_MODE_4G,
.bands_3g = { MM_MODEM_BAND_UTRAN_1 },
.bands_4g = { MM_MODEM_BAND_EUTRAN_3, MM_MODEM_BAND_EUTRAN_8, MM_MODEM_BAND_EUTRAN_28 }
},
{
.model = "LARA-R3121",
.method = SETTINGS_UPDATE_METHOD_COPS,
.uact = FEATURE_UNSUPPORTED,
.ubandsel = FEATURE_SUPPORTED,
.mode = MM_MODEM_MODE_4G,
.bands_4g = { MM_MODEM_BAND_EUTRAN_3, MM_MODEM_BAND_EUTRAN_7, MM_MODEM_BAND_EUTRAN_20 }
},
{
.model = "SARA-N200",
.method = SETTINGS_UPDATE_METHOD_COPS,
.uact = FEATURE_UNSUPPORTED,
.ubandsel = FEATURE_SUPPORTED,
.mode = MM_MODEM_MODE_4G,
.bands_4g = { MM_MODEM_BAND_EUTRAN_8 }
},
{
.model = "SARA-N201",
.method = SETTINGS_UPDATE_METHOD_COPS,
.uact = FEATURE_UNSUPPORTED,
.ubandsel = FEATURE_SUPPORTED,
.mode = MM_MODEM_MODE_4G,
.bands_4g = { MM_MODEM_BAND_EUTRAN_5 }
},
{
.model = "SARA-N210",
.method = SETTINGS_UPDATE_METHOD_COPS,
.uact = FEATURE_UNSUPPORTED,
.ubandsel = FEATURE_SUPPORTED,
.mode = MM_MODEM_MODE_4G,
.bands_4g = { MM_MODEM_BAND_EUTRAN_20 }
},
{
.model = "SARA-N211",
.method = SETTINGS_UPDATE_METHOD_COPS,
.uact = FEATURE_UNSUPPORTED,
.ubandsel = FEATURE_SUPPORTED,
.mode = MM_MODEM_MODE_4G,
.bands_4g = { MM_MODEM_BAND_EUTRAN_8, MM_MODEM_BAND_EUTRAN_20 }
},
{
.model = "SARA-N280",
.method = SETTINGS_UPDATE_METHOD_COPS,
.uact = FEATURE_UNSUPPORTED,
.ubandsel = FEATURE_SUPPORTED,
.mode = MM_MODEM_MODE_4G,
.bands_4g = { MM_MODEM_BAND_EUTRAN_28 }
},
{
.model = "SARA-R410M-52B",
.method = SETTINGS_UPDATE_METHOD_COPS,
.uact = FEATURE_UNSUPPORTED,
.ubandsel = FEATURE_SUPPORTED,
.mode = MM_MODEM_MODE_4G,
.bands_4g = { MM_MODEM_BAND_EUTRAN_2, MM_MODEM_BAND_EUTRAN_4, MM_MODEM_BAND_EUTRAN_5,
MM_MODEM_BAND_EUTRAN_12, MM_MODEM_BAND_EUTRAN_13 }
},
{
.model = "SARA-R410M-02B",
.method = SETTINGS_UPDATE_METHOD_COPS,
.uact = FEATURE_UNSUPPORTED,
.ubandsel = FEATURE_SUPPORTED,
.mode = MM_MODEM_MODE_4G,
.bands_4g = { MM_MODEM_BAND_EUTRAN_1, MM_MODEM_BAND_EUTRAN_2, MM_MODEM_BAND_EUTRAN_3,
MM_MODEM_BAND_EUTRAN_4, MM_MODEM_BAND_EUTRAN_5, MM_MODEM_BAND_EUTRAN_8,
MM_MODEM_BAND_EUTRAN_12, MM_MODEM_BAND_EUTRAN_13, MM_MODEM_BAND_EUTRAN_19,
MM_MODEM_BAND_EUTRAN_20, MM_MODEM_BAND_EUTRAN_28, MM_MODEM_BAND_EUTRAN_39 }
},
{
.model = "SARA-R412M-02B",
.method = SETTINGS_UPDATE_METHOD_COPS,
.uact = FEATURE_UNSUPPORTED,
.ubandsel = FEATURE_SUPPORTED,
.mode = MM_MODEM_MODE_2G | MM_MODEM_MODE_4G,
.bands_2g = { MM_MODEM_BAND_G850, MM_MODEM_BAND_EGSM, MM_MODEM_BAND_DCS, MM_MODEM_BAND_PCS },
.bands_4g = { MM_MODEM_BAND_EUTRAN_1, MM_MODEM_BAND_EUTRAN_2, MM_MODEM_BAND_EUTRAN_3,
MM_MODEM_BAND_EUTRAN_4, MM_MODEM_BAND_EUTRAN_5, MM_MODEM_BAND_EUTRAN_8,
MM_MODEM_BAND_EUTRAN_12, MM_MODEM_BAND_EUTRAN_13, MM_MODEM_BAND_EUTRAN_19,
MM_MODEM_BAND_EUTRAN_20, MM_MODEM_BAND_EUTRAN_28, MM_MODEM_BAND_EUTRAN_39 }
},
{
.model = "SARA-N410-02B",
.method = SETTINGS_UPDATE_METHOD_COPS,
.uact = FEATURE_UNSUPPORTED,
.ubandsel = FEATURE_SUPPORTED,
.mode = MM_MODEM_MODE_4G,
.bands_4g = { MM_MODEM_BAND_EUTRAN_1, MM_MODEM_BAND_EUTRAN_2, MM_MODEM_BAND_EUTRAN_3,
MM_MODEM_BAND_EUTRAN_4, MM_MODEM_BAND_EUTRAN_5, MM_MODEM_BAND_EUTRAN_8,
MM_MODEM_BAND_EUTRAN_12, MM_MODEM_BAND_EUTRAN_13, MM_MODEM_BAND_EUTRAN_19,
MM_MODEM_BAND_EUTRAN_20, MM_MODEM_BAND_EUTRAN_28 }
},
};
gboolean
mm_ublox_get_support_config (const gchar *model,
UbloxSupportConfig *config,
GError **error)
{
guint i;
if (!model) {
g_set_error (error, MM_CORE_ERROR, MM_CORE_ERROR_FAILED,
"Support configuration unknown for unknown model");
return FALSE;
}
for (i = 0; i < G_N_ELEMENTS (band_configuration); i++) {
/* NOTE: matching by prefix! */
if (g_str_has_prefix (model, band_configuration[i].model)) {
config->loaded = TRUE;
config->method = band_configuration[i].method;
config->uact = band_configuration[i].uact;
config->ubandsel = band_configuration[i].ubandsel;
return TRUE;
}
}
g_set_error (error, MM_CORE_ERROR, MM_CORE_ERROR_FAILED,
"No support configuration found for modem: %s", model);
return FALSE;
}
/*****************************************************************************/
/* Supported modes loading */
static MMModemMode
supported_modes_per_model (const gchar *model)
{
MMModemMode mode;
guint i;
mode = MM_MODEM_MODE_2G | MM_MODEM_MODE_3G | MM_MODEM_MODE_4G;
if (model) {
for (i = 0; i < G_N_ELEMENTS (band_configuration); i++)
if (g_str_has_prefix (model, band_configuration[i].model)) {
mode = band_configuration[i].mode;
return mode;;
}
}
return mode;
}
GArray *
mm_ublox_filter_supported_modes (const gchar *model,
GArray *combinations,
gpointer logger,
GError **error)
{
MMModemModeCombination mode;
GArray *all;
GArray *filtered;
/* Model not specified? */
if (!model)
return combinations;
/* AT+URAT=? lies; we need an extra per-device filtering, thanks u-blox.
* Don't know all PIDs for all devices, so model string based filtering... */
mode.allowed = supported_modes_per_model (model);
mode.preferred = MM_MODEM_MODE_NONE;
/* Nothing filtered? */
if (mode.allowed == supported_modes_per_model (NULL))
return combinations;
all = g_array_sized_new (FALSE, FALSE, sizeof (MMModemModeCombination), 1);
g_array_append_val (all, mode);
filtered = mm_filter_supported_modes (all, combinations, logger);
g_array_unref (all);
g_array_unref (combinations);
/* Error if nothing left */
if (filtered->len == 0) {
g_set_error (error, MM_CORE_ERROR, MM_CORE_ERROR_FAILED,
"No valid mode combinations built after filtering (model %s)", model);
g_array_unref (filtered);
return NULL;
}
return filtered;
}
/*****************************************************************************/
/* Supported bands loading */
GArray *
mm_ublox_get_supported_bands (const gchar *model,
gpointer log_object,
GError **error)
{
MMModemMode mode;
GArray *bands;
guint i, j;
mode = supported_modes_per_model (model);
bands = g_array_new (FALSE, FALSE, sizeof (MMModemBand));
for (i = 0; i < G_N_ELEMENTS (band_configuration); i++) {
if (g_str_has_prefix (model, band_configuration[i].model)) {
mm_obj_dbg (log_object, "known supported bands found for model: %s", band_configuration[i].model);
break;
}
}
if (i == G_N_ELEMENTS (band_configuration)) {
mm_obj_warn (log_object, "unknown model name given when looking for supported bands: %s", model);
return NULL;
}
mode = band_configuration[i].mode;
if (mode & MM_MODEM_MODE_2G) {
for (j = 0; j < G_N_ELEMENTS (band_configuration[i].bands_2g) && band_configuration[i].bands_2g[j]; j++) {
bands = g_array_append_val (bands, band_configuration[i].bands_2g[j]);
}
}
if (mode & MM_MODEM_MODE_3G) {
for (j = 0; j < G_N_ELEMENTS (band_configuration[i].bands_3g) && band_configuration[i].bands_3g[j]; j++) {
bands = g_array_append_val (bands, band_configuration[i].bands_3g[j]);
}
}
if (mode & MM_MODEM_MODE_4G) {
for (j = 0; j < G_N_ELEMENTS (band_configuration[i].bands_4g) && band_configuration[i].bands_4g[j]; j++) {
bands = g_array_append_val (bands, band_configuration[i].bands_4g[j]);
}
}
if (bands->len == 0) {
g_array_unref (bands);
g_set_error (error, MM_CORE_ERROR, MM_CORE_ERROR_FAILED,
"No valid supported bands loaded");
return NULL;
}
return bands;
}
typedef struct {
guint num;
MMModemBand band[4];
} NumToBand;
/* 2G GSM Band Frequencies */
static const NumToBand num_bands_2g [] = {
{ .num = 850, .band = { MM_MODEM_BAND_G850 } },
{ .num = 900, .band = { MM_MODEM_BAND_EGSM } },
{ .num = 1900, .band = { MM_MODEM_BAND_PCS } },
{ .num = 1800, .band = { MM_MODEM_BAND_DCS } },
};
/* 3G UMTS Band Frequencies */
static const NumToBand num_bands_3g [] = {
{ .num = 800, .band = { MM_MODEM_BAND_UTRAN_6 } },
{ .num = 850, .band = { MM_MODEM_BAND_UTRAN_5 } },
{ .num = 900, .band = { MM_MODEM_BAND_UTRAN_8 } },
{ .num = 1700, .band = { MM_MODEM_BAND_UTRAN_4 } },
{ .num = 1900, .band = { MM_MODEM_BAND_UTRAN_2 } },
{ .num = 2100, .band = { MM_MODEM_BAND_UTRAN_1 } },
};
/* 4G LTE Band Frequencies */
static const NumToBand num_bands_4g [] = {
{ .num = 700, .band = { MM_MODEM_BAND_EUTRAN_12, MM_MODEM_BAND_EUTRAN_13, MM_MODEM_BAND_EUTRAN_17 } },
{ .num = 800, .band = { MM_MODEM_BAND_EUTRAN_20, MM_MODEM_BAND_EUTRAN_27 } },
{ .num = 850, .band = { MM_MODEM_BAND_EUTRAN_5, MM_MODEM_BAND_EUTRAN_18, MM_MODEM_BAND_EUTRAN_19, MM_MODEM_BAND_EUTRAN_26 } },
{ .num = 900, .band = { MM_MODEM_BAND_EUTRAN_8 } },
{ .num = 1700, .band = { MM_MODEM_BAND_EUTRAN_4, MM_MODEM_BAND_EUTRAN_10 } },
{ .num = 1800, .band = { MM_MODEM_BAND_EUTRAN_3 } },
{ .num = 1900, .band = { MM_MODEM_BAND_EUTRAN_2, MM_MODEM_BAND_EUTRAN_39 } },
{ .num = 2100, .band = { MM_MODEM_BAND_EUTRAN_1 } },
{ .num = 2300, .band = { MM_MODEM_BAND_EUTRAN_40 } },
{ .num = 2500, .band = { MM_MODEM_BAND_EUTRAN_41 } },
{ .num = 2600, .band = { MM_MODEM_BAND_EUTRAN_7, MM_MODEM_BAND_EUTRAN_38 } },
};
/*****************************************************************************/
/* +UBANDSEL? response parser */
static MMModemBand
num_to_band_2g (guint num)
{
guint i;
for (i = 0; i < G_N_ELEMENTS (num_bands_2g); i++) {
if (num == num_bands_2g[i].num)
return num_bands_2g[i].band[0];
}
return MM_MODEM_BAND_UNKNOWN;
}
static MMModemBand
num_to_band_3g (guint num)
{
guint i;
for (i = 0; i < G_N_ELEMENTS (num_bands_3g); i++) {
if (num == num_bands_3g[i].num)
return num_bands_3g[i].band[0];
}
return MM_MODEM_BAND_UNKNOWN;
}
static guint
band_to_num (MMModemBand band)
{
guint i, j;
/* Search 2G list */
for (i = 0; i < G_N_ELEMENTS (num_bands_2g); i++) {
for (j = 0; j < G_N_ELEMENTS (num_bands_2g[i].band) && num_bands_2g[i].band[j]; j++) {
if (band == num_bands_2g[i].band[j])
return num_bands_2g[i].num;
}
}
/* Search 3G list */
for (i = 0; i < G_N_ELEMENTS (num_bands_3g); i++) {
for (j = 0; j < G_N_ELEMENTS (num_bands_3g[i].band) && num_bands_3g[i].band[j]; j++) {
if (band == num_bands_3g[i].band[j])
return num_bands_3g[i].num;
}
}
/* Search 4G list */
for (i = 0; i < G_N_ELEMENTS (num_bands_4g); i++) {
for (j = 0; j < G_N_ELEMENTS (num_bands_4g[i].band) && num_bands_4g[i].band[j]; j++) {
if (band == num_bands_4g[i].band[j])
return num_bands_4g[i].num;
}
}
/* Should never happen */
return 0;
}
static void
append_bands (GArray *bands,
guint ubandsel_value,
MMModemMode mode,
const gchar *model,
gpointer log_object)
{
guint i, j, k, x;
MMModemBand band;
/* Find Modem Model Index in band_configuration */
for (i = 0; i < G_N_ELEMENTS (band_configuration); i++) {
if (g_str_has_prefix (model, band_configuration[i].model)) {
mm_obj_dbg (log_object, "known bands found for model: %s", band_configuration[i].model);
break;
}
}
if (i == G_N_ELEMENTS (band_configuration)) {
mm_obj_warn (log_object, "unknown model name given when looking for bands: %s", model);
return;
}
if (mode & MM_MODEM_MODE_2G) {
band = num_to_band_2g (ubandsel_value);
if (band != MM_MODEM_BAND_UNKNOWN) {
for (x = 0; x < G_N_ELEMENTS (band_configuration[i].bands_2g); x++) {
if (band_configuration[i].bands_2g[x] == band) {
g_array_append_val (bands, band);
break;
}
}
}
}
if (mode & MM_MODEM_MODE_3G) {
band = num_to_band_3g (ubandsel_value);
if (band != MM_MODEM_BAND_UNKNOWN) {
for (x = 0; x < G_N_ELEMENTS (band_configuration[i].bands_3g); x++) {
if (band_configuration[i].bands_3g[x] == band) {
g_array_append_val (bands, band);
break;
}
}
}
}
/* Note: The weird code segment below is to separate out specific LTE bands since
* UBANDSEL? reports back the frequency of the band and not the band itself.
*/
if (mode & MM_MODEM_MODE_4G) {
for (j = 0; j < G_N_ELEMENTS (num_bands_4g); j++) {
if (ubandsel_value == num_bands_4g[j].num) {
for (k = 0; k < G_N_ELEMENTS (num_bands_4g[j].band); k++) {
band = num_bands_4g[j].band[k];
if (band != MM_MODEM_BAND_UNKNOWN) {
for (x = 0; x < G_N_ELEMENTS (band_configuration[i].bands_4g); x++) {
if (band_configuration[i].bands_4g[x] == band) {
g_array_append_val (bands, band);
break;
}
}
}
}
break;
}
}
}
}
GArray *
mm_ublox_parse_ubandsel_response (const gchar *response,
const gchar *model,
gpointer log_object,
GError **error)
{
GArray *array_values = NULL;
GArray *array = NULL;
gchar *dupstr = NULL;
GError *inner_error = NULL;
guint i;
MMModemMode mode;
if (!g_str_has_prefix (response, "+UBANDSEL")) {
inner_error = g_error_new (MM_CORE_ERROR, MM_CORE_ERROR_FAILED,
"Couldn't parse +UBANDSEL response: '%s'", response);
goto out;
}
/* Response may be e.g.:
* +UBANDSEL: 850,900,1800,1900
*/
dupstr = g_strchomp (g_strdup (mm_strip_tag (response, "+UBANDSEL:")));
array_values = mm_parse_uint_list (dupstr, &inner_error);
if (!array_values)
goto out;
/* Convert list of ubandsel numbers to MMModemBand values */
mode = supported_modes_per_model (model);
array = g_array_new (FALSE, FALSE, sizeof (MMModemBand));
for (i = 0; i < array_values->len; i++)
append_bands (array, g_array_index (array_values, guint, i), mode, model, log_object);
if (!array->len) {
inner_error = g_error_new (MM_CORE_ERROR, MM_CORE_ERROR_FAILED,
"No known band selection values matched in +UBANDSEL response: '%s'", response);
goto out;
}
out:
if (inner_error) {
g_propagate_error (error, inner_error);
g_clear_pointer (&array, g_array_unref);
}
g_clear_pointer (&array_values, g_array_unref);
g_free (dupstr);
return array;
}
/*****************************************************************************/
/* UBANDSEL=X command builder */
static gint
ubandsel_num_cmp (const guint *a, const guint *b)
{
return (*a - *b);
}
gchar *
mm_ublox_build_ubandsel_set_command (GArray *bands,
const gchar *model,
GError **error)
{
GString *command = NULL;
GArray *ubandsel_nums;
guint num;
guint i, j, k;
if (bands->len == 1 && g_array_index (bands, MMModemBand, 0) == MM_MODEM_BAND_ANY)
return g_strdup ("+UBANDSEL=0");
for (i = 0; i < G_N_ELEMENTS (band_configuration); i++) {
if (g_str_has_prefix (model, band_configuration[i].model))
break;
}
if (i == G_N_ELEMENTS (band_configuration)) {
g_set_error (error, MM_CORE_ERROR, MM_CORE_ERROR_FAILED,
"Unknown modem model %s", model);
return NULL;
}
ubandsel_nums = g_array_sized_new (FALSE, FALSE, sizeof (guint), bands->len);
for (j = 0; j < bands->len; j++) {
MMModemBand band;
gboolean found = FALSE;
band = g_array_index (bands, MMModemBand, j);
/* Check to see if band is supported by the model */
for (k = 0; !found && k < G_N_ELEMENTS (band_configuration[i].bands_2g) && band_configuration[i].bands_2g[k]; k++) {
if (band == band_configuration[i].bands_2g[k])
found = TRUE;
}
for (k = 0; !found && k < G_N_ELEMENTS (band_configuration[i].bands_3g) && band_configuration[i].bands_3g[k]; k++) {
if (band == band_configuration[i].bands_3g[k])
found = TRUE;
}
for (k = 0; !found && k < G_N_ELEMENTS (band_configuration[i].bands_4g) && band_configuration[i].bands_4g[k]; k++) {
if (band == band_configuration[i].bands_4g[k])
found = TRUE;
}
if (found) {
num = band_to_num (band);
g_assert (num != 0);
g_array_append_val (ubandsel_nums, num);
}
}
if (ubandsel_nums->len == 0) {
g_set_error (error, MM_CORE_ERROR, MM_CORE_ERROR_UNSUPPORTED,
"Given band combination is unsupported");
g_array_unref (ubandsel_nums);
return NULL;
}
if (ubandsel_nums->len > 1)
g_array_sort (ubandsel_nums, (GCompareFunc) ubandsel_num_cmp);
/* Build command */
command = g_string_new ("+UBANDSEL=");
for (i = 0; i < ubandsel_nums->len; i++)
g_string_append_printf (command, "%s%u", i == 0 ? "" : ",", g_array_index (ubandsel_nums, guint, i));
return g_string_free (command, FALSE);
}
/*****************************************************************************/
/* Get mode to apply when ANY */
MMModemMode
mm_ublox_get_modem_mode_any (const GArray *combinations)
{
guint i;
MMModemMode any = MM_MODEM_MODE_NONE;
guint any_bits_set = 0;
for (i = 0; i < combinations->len; i++) {
MMModemModeCombination *combination;
guint bits_set;
combination = &g_array_index (combinations, MMModemModeCombination, i);
if (combination->preferred != MM_MODEM_MODE_NONE)
continue;
bits_set = mm_count_bits_set (combination->allowed);
if (bits_set > any_bits_set) {
any_bits_set = bits_set;
any = combination->allowed;
}
}
/* If combinations were processed via mm_ublox_parse_urat_test_response(),
* we're sure that there will be at least one combination with preferred
* 'none', so there must be some valid combination as result */
g_assert (any != MM_MODEM_MODE_NONE);
return any;
}
/*****************************************************************************/
/* UACT common config */
typedef struct {
guint num;
MMModemBand band;
} UactBandConfig;
static const UactBandConfig uact_band_config[] = {
/* GSM bands */
{ .num = 900, .band = MM_MODEM_BAND_EGSM },
{ .num = 1800, .band = MM_MODEM_BAND_DCS },
{ .num = 1900, .band = MM_MODEM_BAND_PCS },
{ .num = 850, .band = MM_MODEM_BAND_G850 },
{ .num = 450, .band = MM_MODEM_BAND_G450 },
{ .num = 480, .band = MM_MODEM_BAND_G480 },
{ .num = 750, .band = MM_MODEM_BAND_G750 },
{ .num = 380, .band = MM_MODEM_BAND_G380 },
{ .num = 410, .band = MM_MODEM_BAND_G410 },
{ .num = 710, .band = MM_MODEM_BAND_G710 },
{ .num = 810, .band = MM_MODEM_BAND_G810 },
/* UMTS bands */
{ .num = 1, .band = MM_MODEM_BAND_UTRAN_1 },
{ .num = 2, .band = MM_MODEM_BAND_UTRAN_2 },
{ .num = 3, .band = MM_MODEM_BAND_UTRAN_3 },
{ .num = 4, .band = MM_MODEM_BAND_UTRAN_4 },
{ .num = 5, .band = MM_MODEM_BAND_UTRAN_5 },
{ .num = 6, .band = MM_MODEM_BAND_UTRAN_6 },
{ .num = 7, .band = MM_MODEM_BAND_UTRAN_7 },
{ .num = 8, .band = MM_MODEM_BAND_UTRAN_8 },
{ .num = 9, .band = MM_MODEM_BAND_UTRAN_9 },
{ .num = 10, .band = MM_MODEM_BAND_UTRAN_10 },
{ .num = 11, .band = MM_MODEM_BAND_UTRAN_11 },
{ .num = 12, .band = MM_MODEM_BAND_UTRAN_12 },
{ .num = 13, .band = MM_MODEM_BAND_UTRAN_13 },
{ .num = 14, .band = MM_MODEM_BAND_UTRAN_14 },
{ .num = 19, .band = MM_MODEM_BAND_UTRAN_19 },
{ .num = 20, .band = MM_MODEM_BAND_UTRAN_20 },
{ .num = 21, .band = MM_MODEM_BAND_UTRAN_21 },
{ .num = 22, .band = MM_MODEM_BAND_UTRAN_22 },
{ .num = 25, .band = MM_MODEM_BAND_UTRAN_25 },
/* LTE bands */
{ .num = 101, .band = MM_MODEM_BAND_EUTRAN_1 },
{ .num = 102, .band = MM_MODEM_BAND_EUTRAN_2 },
{ .num = 103, .band = MM_MODEM_BAND_EUTRAN_3 },
{ .num = 104, .band = MM_MODEM_BAND_EUTRAN_4 },
{ .num = 105, .band = MM_MODEM_BAND_EUTRAN_5 },
{ .num = 106, .band = MM_MODEM_BAND_EUTRAN_6 },
{ .num = 107, .band = MM_MODEM_BAND_EUTRAN_7 },
{ .num = 108, .band = MM_MODEM_BAND_EUTRAN_8 },
{ .num = 109, .band = MM_MODEM_BAND_EUTRAN_9 },
{ .num = 110, .band = MM_MODEM_BAND_EUTRAN_10 },
{ .num = 111, .band = MM_MODEM_BAND_EUTRAN_11 },
{ .num = 112, .band = MM_MODEM_BAND_EUTRAN_12 },
{ .num = 113, .band = MM_MODEM_BAND_EUTRAN_13 },
{ .num = 114, .band = MM_MODEM_BAND_EUTRAN_14 },
{ .num = 117, .band = MM_MODEM_BAND_EUTRAN_17 },
{ .num = 118, .band = MM_MODEM_BAND_EUTRAN_18 },
{ .num = 119, .band = MM_MODEM_BAND_EUTRAN_19 },
{ .num = 120, .band = MM_MODEM_BAND_EUTRAN_20 },
{ .num = 121, .band = MM_MODEM_BAND_EUTRAN_21 },
{ .num = 122, .band = MM_MODEM_BAND_EUTRAN_22 },
{ .num = 123, .band = MM_MODEM_BAND_EUTRAN_23 },
{ .num = 124, .band = MM_MODEM_BAND_EUTRAN_24 },
{ .num = 125, .band = MM_MODEM_BAND_EUTRAN_25 },
{ .num = 126, .band = MM_MODEM_BAND_EUTRAN_26 },
{ .num = 127, .band = MM_MODEM_BAND_EUTRAN_27 },
{ .num = 128, .band = MM_MODEM_BAND_EUTRAN_28 },
{ .num = 129, .band = MM_MODEM_BAND_EUTRAN_29 },
{ .num = 130, .band = MM_MODEM_BAND_EUTRAN_30 },
{ .num = 131, .band = MM_MODEM_BAND_EUTRAN_31 },
{ .num = 132, .band = MM_MODEM_BAND_EUTRAN_32 },
{ .num = 133, .band = MM_MODEM_BAND_EUTRAN_33 },
{ .num = 134, .band = MM_MODEM_BAND_EUTRAN_34 },
{ .num = 135, .band = MM_MODEM_BAND_EUTRAN_35 },
{ .num = 136, .band = MM_MODEM_BAND_EUTRAN_36 },
{ .num = 137, .band = MM_MODEM_BAND_EUTRAN_37 },
{ .num = 138, .band = MM_MODEM_BAND_EUTRAN_38 },
{ .num = 139, .band = MM_MODEM_BAND_EUTRAN_39 },
{ .num = 140, .band = MM_MODEM_BAND_EUTRAN_40 },
{ .num = 141, .band = MM_MODEM_BAND_EUTRAN_41 },
{ .num = 142, .band = MM_MODEM_BAND_EUTRAN_42 },
{ .num = 143, .band = MM_MODEM_BAND_EUTRAN_43 },
{ .num = 144, .band = MM_MODEM_BAND_EUTRAN_44 },
{ .num = 145, .band = MM_MODEM_BAND_EUTRAN_45 },
{ .num = 146, .band = MM_MODEM_BAND_EUTRAN_46 },
{ .num = 147, .band = MM_MODEM_BAND_EUTRAN_47 },
{ .num = 148, .band = MM_MODEM_BAND_EUTRAN_48 },
};
static MMModemBand
uact_num_to_band (guint num)
{
guint i;
for (i = 0; i < G_N_ELEMENTS (uact_band_config); i++) {
if (num == uact_band_config[i].num)
return uact_band_config[i].band;
}
return MM_MODEM_BAND_UNKNOWN;
}
static guint
uact_band_to_num (MMModemBand band)
{
guint i;
for (i = 0; i < G_N_ELEMENTS (uact_band_config); i++) {
if (band == uact_band_config[i].band)
return uact_band_config[i].num;
}
return 0;
}
/*****************************************************************************/
/* UACT? response parser */
static GArray *
uact_num_array_to_band_array (GArray *nums)
{
GArray *bands = NULL;
guint i;
if (!nums)
return NULL;
bands = g_array_sized_new (FALSE, FALSE, sizeof (MMModemBand), nums->len);
for (i = 0; i < nums->len; i++) {
MMModemBand band;
band = uact_num_to_band (g_array_index (nums, guint, i));
g_array_append_val (bands, band);
}
return bands;
}
GArray *
mm_ublox_parse_uact_response (const gchar *response,
GError **error)
{
GRegex *r;
GMatchInfo *match_info;
GError *inner_error = NULL;
GArray *nums = NULL;
GArray *bands = NULL;
/*
* AT+UACT?
* +UACT: ,,,900,1800,1,8,101,103,107,108,120,138
*/
r = g_regex_new ("\\+UACT: ([^,]*),([^,]*),([^,]*),(.*)(?:\\r\\n)?",
G_REGEX_DOLLAR_ENDONLY | G_REGEX_RAW, 0, NULL);
g_assert (r != NULL);
g_regex_match_full (r, response, strlen (response), 0, 0, &match_info, &inner_error);
if (!inner_error && g_match_info_matches (match_info)) {
gchar *bandstr;
bandstr = mm_get_string_unquoted_from_match_info (match_info, 4);
nums = mm_parse_uint_list (bandstr, &inner_error);
g_free (bandstr);
}
g_match_info_free (match_info);
g_regex_unref (r);
if (inner_error) {
g_propagate_error (error, inner_error);
return NULL;
}
/* Convert to MMModemBand values */
if (nums) {
bands = uact_num_array_to_band_array (nums);
g_array_unref (nums);
}
if (!bands)
g_set_error (error, MM_CORE_ERROR, MM_CORE_ERROR_FAILED,
"No known band selection values matched in +UACT response: '%s'", response);
return bands;
}
/*****************************************************************************/
/* UACT=? response parser */
static GArray *
parse_bands_from_string (const gchar *str,
const gchar *group,
gpointer log_object)
{
GArray *bands = NULL;
GError *inner_error = NULL;
GArray *nums;
nums = mm_parse_uint_list (str, &inner_error);
if (nums) {
gchar *tmpstr;
bands = uact_num_array_to_band_array (nums);
tmpstr = mm_common_build_bands_string ((MMModemBand *)(gpointer)(bands->data), bands->len);
mm_obj_dbg (log_object, "modem reports support for %s bands: %s", group, tmpstr);
g_free (tmpstr);
g_array_unref (nums);
} else if (inner_error) {
mm_obj_warn (log_object, "couldn't parse list of supported %s bands: %s", group, inner_error->message);
g_clear_error (&inner_error);
}
return bands;
}
gboolean
mm_ublox_parse_uact_test (const gchar *response,
gpointer log_object,
GArray **bands2g_out,
GArray **bands3g_out,
GArray **bands4g_out,
GError **error)
{
GRegex *r;
GMatchInfo *match_info;
GError *inner_error = NULL;
const gchar *bands2g_str = NULL;
const gchar *bands3g_str = NULL;
const gchar *bands4g_str = NULL;
GArray *bands2g = NULL;
GArray *bands3g = NULL;
GArray *bands4g = NULL;
gchar **split = NULL;
g_assert (bands2g_out && bands3g_out && bands4g_out);
/*
* AT+UACT=?
* +UACT: ,,,(900,1800),(1,8),(101,103,107,108,120),(138)
*/
r = g_regex_new ("\\+UACT: ([^,]*),([^,]*),([^,]*),(.*)(?:\\r\\n)?",
G_REGEX_DOLLAR_ENDONLY | G_REGEX_RAW, 0, NULL);
g_assert (r != NULL);
g_regex_match_full (r, response, strlen (response), 0, 0, &match_info, &inner_error);
if (inner_error)
goto out;
if (g_match_info_matches (match_info)) {
gchar *aux;
guint n_groups;
aux = mm_get_string_unquoted_from_match_info (match_info, 4);
split = mm_split_string_groups (aux);
n_groups = g_strv_length (split);
if (n_groups >= 1)
bands2g_str = split[0];
if (n_groups >= 2)
bands3g_str = split[1];
if (n_groups >= 3)
bands4g_str = split[2];
g_free (aux);
}
if (!bands2g_str && !bands3g_str && !bands4g_str) {
inner_error = g_error_new (MM_CORE_ERROR, MM_CORE_ERROR_FAILED,
"frequency groups not found: %s", response);
goto out;
}
bands2g = parse_bands_from_string (bands2g_str, "2G", log_object);
bands3g = parse_bands_from_string (bands3g_str, "3G", log_object);
bands4g = parse_bands_from_string (bands4g_str, "4G", log_object);
if (!bands2g->len && !bands3g->len && !bands4g->len) {
inner_error = g_error_new (MM_CORE_ERROR, MM_CORE_ERROR_FAILED,
"no supported frequencies reported: %s", response);
goto out;
}
/* success */
out:
g_strfreev (split);
g_match_info_free (match_info);
g_regex_unref (r);
if (inner_error) {
if (bands2g)
g_array_unref (bands2g);
if (bands3g)
g_array_unref (bands3g);
if (bands4g)
g_array_unref (bands4g);
g_propagate_error (error, inner_error);
return FALSE;
}
*bands2g_out = bands2g;
*bands3g_out = bands3g;
*bands4g_out = bands4g;
return TRUE;
}
/*****************************************************************************/
/* UACT=X command builder */
gchar *
mm_ublox_build_uact_set_command (GArray *bands,
GError **error)
{
GString *command;
/* Build command */
command = g_string_new ("+UACT=,,,");
if (bands->len == 1 && g_array_index (bands, MMModemBand, 0) == MM_MODEM_BAND_ANY)
g_string_append (command, "0");
else {
guint i;
for (i = 0; i < bands->len; i++) {
MMModemBand band;
guint num;
band = g_array_index (bands, MMModemBand, i);
num = uact_band_to_num (band);
if (!num) {
g_set_error (error, MM_CORE_ERROR, MM_CORE_ERROR_UNSUPPORTED,
"Band unsupported by this plugin: %s", mm_modem_band_get_string (band));
g_string_free (command, TRUE);
return NULL;
}
g_string_append_printf (command, "%s%u", i == 0 ? "" : ",", num);
}
}
return g_string_free (command, FALSE);
}
/*****************************************************************************/
/* URAT? response parser */
gboolean
mm_ublox_parse_urat_read_response (const gchar *response,
gpointer log_object,
MMModemMode *out_allowed,
MMModemMode *out_preferred,
GError **error)
{
GRegex *r;
GMatchInfo *match_info;
GError *inner_error = NULL;
MMModemMode allowed = MM_MODEM_MODE_NONE;
MMModemMode preferred = MM_MODEM_MODE_NONE;
gchar *allowed_str = NULL;
gchar *preferred_str = NULL;
g_assert (out_allowed != NULL && out_preferred != NULL);
/* Response may be e.g.:
* +URAT: 1,2
* +URAT: 1
*/
r = g_regex_new ("\\+URAT: (\\d+)(?:,(\\d+))?(?:\\r\\n)?", 0, 0, NULL);
g_assert (r != NULL);
g_regex_match_full (r, response, strlen (response), 0, 0, &match_info, &inner_error);
if (!inner_error && g_match_info_matches (match_info)) {
guint value = 0;
/* Selected item is mandatory */
if (!mm_get_uint_from_match_info (match_info, 1, &value)) {
inner_error = g_error_new (MM_CORE_ERROR, MM_CORE_ERROR_FAILED,
"Couldn't read AcT selected value");
goto out;
}
if (value >= G_N_ELEMENTS (ublox_combinations)) {
inner_error = g_error_new (MM_CORE_ERROR, MM_CORE_ERROR_FAILED,
"Unexpected AcT selected value: %u", value);
goto out;
}
allowed = ublox_combinations[value];
allowed_str = mm_modem_mode_build_string_from_mask (allowed);
mm_obj_dbg (log_object, "current allowed modes retrieved: %s", allowed_str);
/* Preferred item is optional */
if (mm_get_uint_from_match_info (match_info, 2, &value)) {
if (value >= G_N_ELEMENTS (ublox_combinations)) {
inner_error = g_error_new (MM_CORE_ERROR, MM_CORE_ERROR_FAILED,
"Unexpected AcT preferred value: %u", value);
goto out;
}
preferred = ublox_combinations[value];
preferred_str = mm_modem_mode_build_string_from_mask (preferred);
mm_obj_dbg (log_object, "current preferred modes retrieved: %s", preferred_str);
if (mm_count_bits_set (preferred) != 1) {
inner_error = g_error_new (MM_CORE_ERROR, MM_CORE_ERROR_FAILED,
"AcT preferred value should be a single AcT: %s", preferred_str);
goto out;
}
if (!(allowed & preferred)) {
inner_error = g_error_new (MM_CORE_ERROR, MM_CORE_ERROR_FAILED,
"AcT preferred value (%s) not a subset of the allowed value (%s)",
preferred_str, allowed_str);
goto out;
}
}
}
out:
g_free (allowed_str);
g_free (preferred_str);
g_match_info_free (match_info);
g_regex_unref (r);
if (inner_error) {
g_propagate_error (error, inner_error);
return FALSE;
}
if (allowed == MM_MODEM_MODE_NONE) {
inner_error = g_error_new (MM_CORE_ERROR, MM_CORE_ERROR_FAILED,
"Couldn't parse +URAT response: %s", response);
return FALSE;
}
*out_allowed = allowed;
*out_preferred = preferred;
return TRUE;
}
/*****************************************************************************/
/* URAT=X command builder */
static gboolean
append_rat_value (GString *str,
MMModemMode mode,
GError **error)
{
guint i;
for (i = 0; i < G_N_ELEMENTS (ublox_combinations); i++) {
if (ublox_combinations[i] == mode) {
g_string_append_printf (str, "%u", i);
return TRUE;
}
}
g_set_error (error, MM_CORE_ERROR, MM_CORE_ERROR_FAILED,
"No AcT value matches requested mode");
return FALSE;
}
gchar *
mm_ublox_build_urat_set_command (MMModemMode allowed,
MMModemMode preferred,
GError **error)
{
GString *command;
command = g_string_new ("+URAT=");
if (!append_rat_value (command, allowed, error)) {
g_string_free (command, TRUE);
return NULL;
}
if (preferred != MM_MODEM_MODE_NONE) {
g_string_append (command, ",");
if (!append_rat_value (command, preferred, error)) {
g_string_free (command, TRUE);
return NULL;
}
}
return g_string_free (command, FALSE);
}
/*****************************************************************************/
/* +UAUTHREQ=? test parser */
MMUbloxBearerAllowedAuth
mm_ublox_parse_uauthreq_test (const char *response,
gpointer log_object,
GError **error)
{
MMUbloxBearerAllowedAuth mask = MM_UBLOX_BEARER_ALLOWED_AUTH_UNKNOWN;
GError *inner_error = NULL;
GArray *allowed_auths = NULL;
gchar **split;
guint split_len;
/*
* Response may be like:
* AT+UAUTHREQ=?
* +UAUTHREQ: (1-4),(0-2),,
*/
response = mm_strip_tag (response, "+UAUTHREQ:");
split = mm_split_string_groups (response);
split_len = g_strv_length (split);
if (split_len < 2) {
inner_error = g_error_new (MM_CORE_ERROR, MM_CORE_ERROR_FAILED,
"Unexpected number of groups in +UAUTHREQ=? response: %u", g_strv_length (split));
goto out;
}
allowed_auths = mm_parse_uint_list (split[1], &inner_error);
if (inner_error)
goto out;
if (allowed_auths) {
guint i;
for (i = 0; i < allowed_auths->len; i++) {
guint val;
val = g_array_index (allowed_auths, guint, i);
switch (val) {
case 0:
mask |= MM_UBLOX_BEARER_ALLOWED_AUTH_NONE;
break;
case 1:
mask |= MM_UBLOX_BEARER_ALLOWED_AUTH_PAP;
break;
case 2:
mask |= MM_UBLOX_BEARER_ALLOWED_AUTH_CHAP;
break;
case 3:
mask |= MM_UBLOX_BEARER_ALLOWED_AUTH_AUTO;
break;
default:
mm_obj_warn (log_object, "unexpected +UAUTHREQ value: %u", val);
break;
}
}
}
if (!mask) {
inner_error = g_error_new (MM_CORE_ERROR, MM_CORE_ERROR_FAILED,
"No supported authentication methods in +UAUTHREQ=? response");
goto out;
}
out:
g_strfreev (split);
if (allowed_auths)
g_array_unref (allowed_auths);
if (inner_error) {
g_propagate_error (error, inner_error);
return MM_UBLOX_BEARER_ALLOWED_AUTH_UNKNOWN;
}
return mask;
}
/*****************************************************************************/
/* +UGCNTRD response parser */
gboolean
mm_ublox_parse_ugcntrd_response_for_cid (const gchar *response,
guint in_cid,
guint64 *out_session_tx_bytes,
guint64 *out_session_rx_bytes,
guint64 *out_total_tx_bytes,
guint64 *out_total_rx_bytes,
GError **error)
{
GRegex *r;
GMatchInfo *match_info = NULL;
GError *inner_error = NULL;
guint64 session_tx_bytes = 0;
guint64 session_rx_bytes = 0;
guint64 total_tx_bytes = 0;
guint64 total_rx_bytes = 0;
gboolean matched = FALSE;
/* Response may be e.g.:
* +UGCNTRD: 31,2704,1819,2724,1839
* We assume only ONE line is returned.
*/
r = g_regex_new ("\\+UGCNTRD:\\s*(\\d+),\\s*(\\d+),\\s*(\\d+),\\s*(\\d+),\\s*(\\d+)",
G_REGEX_DOLLAR_ENDONLY | G_REGEX_RAW, 0, NULL);
g_assert (r != NULL);
/* Report invalid CID given */
if (!in_cid) {
inner_error = g_error_new (MM_CORE_ERROR, MM_CORE_ERROR_FAILED, "Invalid CID given");
goto out;
}
g_regex_match_full (r, response, strlen (response), 0, 0, &match_info, &inner_error);
while (!inner_error && g_match_info_matches (match_info)) {
guint cid = 0;
/* Matched CID? */
if (!mm_get_uint_from_match_info (match_info, 1, &cid) || cid != in_cid) {
g_match_info_next (match_info, &inner_error);
continue;
}
if (out_session_tx_bytes && !mm_get_u64_from_match_info (match_info, 2, &session_tx_bytes)) {
inner_error = g_error_new (MM_CORE_ERROR, MM_CORE_ERROR_FAILED, "Error parsing session TX bytes");
goto out;
}
if (out_session_rx_bytes && !mm_get_u64_from_match_info (match_info, 3, &session_rx_bytes)) {
inner_error = g_error_new (MM_CORE_ERROR, MM_CORE_ERROR_FAILED, "Error parsing session RX bytes");
goto out;
}
if (out_total_tx_bytes && !mm_get_u64_from_match_info (match_info, 4, &total_tx_bytes)) {
inner_error = g_error_new (MM_CORE_ERROR, MM_CORE_ERROR_FAILED, "Error parsing total TX bytes");
goto out;
}
if (out_total_rx_bytes && !mm_get_u64_from_match_info (match_info, 5, &total_rx_bytes)) {
inner_error = g_error_new (MM_CORE_ERROR, MM_CORE_ERROR_FAILED, "Error parsing total RX bytes");
goto out;
}
matched = TRUE;
break;
}
if (!matched) {
inner_error = g_error_new (MM_CORE_ERROR, MM_CORE_ERROR_FAILED, "No statistics found for CID %u", in_cid);
goto out;
}
out:
g_match_info_free (match_info);
g_regex_unref (r);
if (inner_error) {
g_propagate_error (error, inner_error);
return FALSE;
}
if (out_session_tx_bytes)
*out_session_tx_bytes = session_tx_bytes;
if (out_session_rx_bytes)
*out_session_rx_bytes = session_rx_bytes;
if (out_total_tx_bytes)
*out_total_tx_bytes = total_tx_bytes;
if (out_total_rx_bytes)
*out_total_rx_bytes = total_rx_bytes;
return TRUE;
}
Reference in New Issue View Git Blame Copy Permalink