colin/ModemManager
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

huawei: port to use object logging

Browse Source
This commit is contained in:
Aleksander Morgado
2020-04-04 16:17:08 +02:00
parent 59e6e3b141
commit 1cb39536e9
7 changed files with 174 additions and 212 deletions
Download Patch File Download Diff File Expand all files Collapse all files

24
plugins/huawei/mm-broadband-bearer-huawei.c
View File

@@ -27,7 +27,7 @@
#include <ModemManager.h> #include <ModemManager.h>
#include "mm-base-modem-at.h" #include "mm-base-modem-at.h"
#include "mm-broadband-bearer-huawei.h" #include "mm-broadband-bearer-huawei.h"
#include "mm-log.h" #include "mm-log-object.h"
#include "mm-modem-helpers.h" #include "mm-modem-helpers.h"
#include "mm-modem-helpers-huawei.h" #include "mm-modem-helpers-huawei.h"
#include "mm-daemon-enums-types.h" #include "mm-daemon-enums-types.h"
@@ -175,7 +175,7 @@ connect_dhcp_check_ready (MMBaseModem *modem,
g_free (strarr[0]); g_free (strarr[0]);
g_free (strarr[1]); g_free (strarr[1]);
} else { } else {
mm_dbg ("Unexpected response to ^DHCP command: %s", error->message); mm_obj_dbg (self, "unexpected response to ^DHCP command: %s", error->message);
} }
} }
@@ -233,8 +233,8 @@ connect_ndisstatqry_check_ready (MMBaseModem *modem,
&ipv6_connected, &ipv6_connected,
&error)) { &error)) {
ctx->failed_ndisstatqry_count++; ctx->failed_ndisstatqry_count++;
mm_dbg ("Unexpected response to ^NDISSTATQRY command: %s (Attempts so far: %u)", mm_obj_dbg (self, "unexpected response to ^NDISSTATQRY command: %s (%u attempts so far)",
error->message, ctx->failed_ndisstatqry_count); error->message, ctx->failed_ndisstatqry_count);
g_error_free (error); g_error_free (error);
} }
@@ -358,8 +358,7 @@ connect_3gpp_context_step (GTask *task)
ip_family = mm_base_bearer_get_default_ip_family (MM_BASE_BEARER (self)); ip_family = mm_base_bearer_get_default_ip_family (MM_BASE_BEARER (self));
ip_family_str = mm_bearer_ip_family_build_string_from_mask (ip_family); ip_family_str = mm_bearer_ip_family_build_string_from_mask (ip_family);
mm_dbg ("No specific IP family requested, defaulting to %s", mm_obj_dbg (self, "no specific IP family requested, defaulting to %s", ip_family_str);
ip_family_str);
g_free (ip_family_str); g_free (ip_family_str);
} }
@@ -633,8 +632,8 @@ disconnect_ndisstatqry_check_ready (MMBaseModem *modem,
&ipv6_connected, &ipv6_connected,
&error)) { &error)) {
ctx->failed_ndisstatqry_count++; ctx->failed_ndisstatqry_count++;
mm_dbg ("Unexpected response to ^NDISSTATQRY command: %s (Attempts so far: %u)", mm_obj_dbg (self, "unexpected response to ^NDISSTATQRY command: %s (%u attempts so far)",
error->message, ctx->failed_ndisstatqry_count); error->message, ctx->failed_ndisstatqry_count);
g_error_free (error); g_error_free (error);
} }
@@ -808,8 +807,7 @@ disconnect_3gpp (MMBroadbandBearer *_self,
static gboolean static gboolean
network_disconnect_3gpp_delayed (MMBroadbandBearerHuawei *self) network_disconnect_3gpp_delayed (MMBroadbandBearerHuawei *self)
{ {
mm_dbg ("Disconnect bearer '%s' on network request.", mm_obj_dbg (self, "disconnect bearer on network request");
mm_base_bearer_get_path (MM_BASE_BEARER (self)));
self->priv->network_disconnect_pending_id = 0; self->priv->network_disconnect_pending_id = 0;
mm_base_bearer_report_connection_status (MM_BASE_BEARER (self), mm_base_bearer_report_connection_status (MM_BASE_BEARER (self),
@@ -833,8 +831,7 @@ report_connection_status (MMBaseBearer *bearer,
if (self->priv->connect_pending || self->priv->disconnect_pending) if (self->priv->connect_pending || self->priv->disconnect_pending)
return; return;
mm_dbg ("Received spontaneous ^NDISSTAT (%s)", mm_obj_dbg (self, "received spontaneous ^NDISSTAT (%s)", mm_bearer_connection_status_get_string (status));
mm_bearer_connection_status_get_string (status));
/* Ignore 'CONNECTED' */ /* Ignore 'CONNECTED' */
if (status == MM_BEARER_CONNECTION_STATUS_CONNECTED) if (status == MM_BEARER_CONNECTION_STATUS_CONNECTED)
@@ -848,8 +845,7 @@ report_connection_status (MMBaseBearer *bearer,
* bearer_report_connection_status for details. */ * bearer_report_connection_status for details. */
if (mm_base_bearer_get_status (bearer) == MM_BEARER_STATUS_CONNECTED && if (mm_base_bearer_get_status (bearer) == MM_BEARER_STATUS_CONNECTED &&
self->priv->network_disconnect_pending_id == 0) { self->priv->network_disconnect_pending_id == 0) {
mm_dbg ("Delay network-initiated disconnection of bearer '%s'", mm_obj_dbg (self, "delay network-initiated disconnection of bearer");
mm_base_bearer_get_path (MM_BASE_BEARER (self)));
self->priv->network_disconnect_pending_id = (g_timeout_add_seconds ( self->priv->network_disconnect_pending_id = (g_timeout_add_seconds (
4, 4,
(GSourceFunc) network_disconnect_3gpp_delayed, (GSourceFunc) network_disconnect_3gpp_delayed,

147
plugins/huawei/mm-broadband-modem-huawei.c
View File

@@ -31,7 +31,7 @@
#define _LIBMM_INSIDE_MM #define _LIBMM_INSIDE_MM
#include <libmm-glib.h> #include <libmm-glib.h>
#include "mm-log.h" #include "mm-log-object.h"
#include "mm-errors-types.h" #include "mm-errors-types.h"
#include "mm-modem-helpers.h" #include "mm-modem-helpers.h"
#include "mm-modem-helpers-huawei.h" #include "mm-modem-helpers-huawei.h"
@@ -245,7 +245,7 @@ run_sysinfo_ready (MMBaseModem *self,
response = mm_base_modem_at_command_finish (self, res, &error); response = mm_base_modem_at_command_finish (self, res, &error);
if (!response) { if (!response) {
mm_dbg ("^SYSINFO failed: %s", error->message); mm_obj_dbg (self, "^SYSINFO failed: %s", error->message);
g_task_return_error (task, error); g_task_return_error (task, error);
g_object_unref (task); g_object_unref (task);
return; return;
@@ -262,7 +262,7 @@ run_sysinfo_ready (MMBaseModem *self,
&result->sys_submode_valid, &result->sys_submode_valid,
&result->sys_submode, &result->sys_submode,
&error)) { &error)) {
mm_dbg ("^SYSINFO parsing failed: %s", error->message); mm_obj_dbg (self, "^SYSINFO parsing failed: %s", error->message);
g_task_return_error (task, error); g_task_return_error (task, error);
g_object_unref (task); g_object_unref (task);
g_free (result); g_free (result);
@@ -300,14 +300,14 @@ run_sysinfoex_ready (MMBaseModem *_self,
/* First time we try, we fallback to ^SYSINFO */ /* First time we try, we fallback to ^SYSINFO */
if (self->priv->sysinfoex_support == FEATURE_SUPPORT_UNKNOWN) { if (self->priv->sysinfoex_support == FEATURE_SUPPORT_UNKNOWN) {
self->priv->sysinfoex_support = FEATURE_NOT_SUPPORTED; self->priv->sysinfoex_support = FEATURE_NOT_SUPPORTED;
mm_dbg ("^SYSINFOEX failed: %s, assuming unsupported", error->message); mm_obj_dbg (self, "^SYSINFOEX failed: %s, assuming unsupported", error->message);
g_error_free (error); g_error_free (error);
run_sysinfo (self, task); run_sysinfo (self, task);
return; return;
} }
/* Otherwise, propagate error */ /* Otherwise, propagate error */
mm_dbg ("^SYSINFOEX failed: %s", error->message); mm_obj_dbg (self, "^SYSINFOEX failed: %s", error->message);
g_task_return_error (task, error); g_task_return_error (task, error);
g_object_unref (task); g_object_unref (task);
return; return;
@@ -326,7 +326,7 @@ run_sysinfoex_ready (MMBaseModem *_self,
&result->sys_mode, &result->sys_mode,
&result->sys_submode, &result->sys_submode,
&error)) { &error)) {
mm_dbg ("^SYSINFOEX parsing failed: %s", error->message); mm_obj_dbg (self, "^SYSINFOEX parsing failed: %s", error->message);
g_task_return_error (task, error); g_task_return_error (task, error);
g_object_unref (task); g_object_unref (task);
g_free (result); g_free (result);
@@ -571,7 +571,6 @@ load_access_technologies_finish (MMIfaceModem *self,
guint *mask, guint *mask,
GError **error) GError **error)
{ {
gchar *str;
MMModemAccessTechnology act = MM_MODEM_ACCESS_TECHNOLOGY_UNKNOWN; MMModemAccessTechnology act = MM_MODEM_ACCESS_TECHNOLOGY_UNKNOWN;
gboolean extended = FALSE; gboolean extended = FALSE;
guint srv_status = 0; guint srv_status = 0;
@@ -605,10 +604,6 @@ load_access_technologies_finish (MMIfaceModem *self,
huawei_sysinfo_mode_to_act (sys_mode)); huawei_sysinfo_mode_to_act (sys_mode));
} }
str = mm_modem_access_technology_build_string_from_mask (act);
mm_dbg ("Access Technology: '%s'", str);
g_free (str);
*access_technologies = act; *access_technologies = act;
*mask = MM_MODEM_ACCESS_TECHNOLOGY_ANY; *mask = MM_MODEM_ACCESS_TECHNOLOGY_ANY;
return TRUE; return TRUE;
@@ -619,7 +614,6 @@ load_access_technologies (MMIfaceModem *self,
GAsyncReadyCallback callback, GAsyncReadyCallback callback,
gpointer user_data) gpointer user_data)
{ {
mm_dbg ("loading access technology (huawei)...");
sysinfo (MM_BROADBAND_MODEM_HUAWEI (self), callback, user_data); sysinfo (MM_BROADBAND_MODEM_HUAWEI (self), callback, user_data);
} }
@@ -698,7 +692,6 @@ load_unlock_retries (MMIfaceModem *self,
GAsyncReadyCallback callback, GAsyncReadyCallback callback,
gpointer user_data) gpointer user_data)
{ {
mm_dbg ("loading unlock retries (huawei)...");
mm_base_modem_at_command (MM_BASE_MODEM (self), mm_base_modem_at_command (MM_BASE_MODEM (self),
"^CPIN?", "^CPIN?",
3, 3,
@@ -872,7 +865,6 @@ load_current_bands (MMIfaceModem *self,
GAsyncReadyCallback callback, GAsyncReadyCallback callback,
gpointer user_data) gpointer user_data)
{ {
mm_dbg ("loading current bands (huawei)...");
mm_base_modem_at_command (MM_BASE_MODEM (self), mm_base_modem_at_command (MM_BASE_MODEM (self),
"^SYSCFG?", "^SYSCFG?",
3, 3,
@@ -973,9 +965,9 @@ syscfg_test_ready (MMBroadbandModemHuawei *self,
* string to get parsed. Ugly, ugly, blame Huawei. * string to get parsed. Ugly, ugly, blame Huawei.
*/ */
if (response[0]) if (response[0])
self->priv->syscfg_supported_modes = mm_huawei_parse_syscfg_test (response, &error); self->priv->syscfg_supported_modes = mm_huawei_parse_syscfg_test (response, self, &error);
else { else {
self->priv->syscfg_supported_modes = mm_huawei_parse_syscfg_test (MM_HUAWEI_DEFAULT_SYSCFG_FMT, NULL); self->priv->syscfg_supported_modes = mm_huawei_parse_syscfg_test (MM_HUAWEI_DEFAULT_SYSCFG_FMT, self, NULL);
g_assert (self->priv->syscfg_supported_modes != NULL); g_assert (self->priv->syscfg_supported_modes != NULL);
} }
} }
@@ -1006,7 +998,7 @@ syscfg_test_ready (MMBroadbandModemHuawei *self,
combinations, combinations,
(GDestroyNotify)g_array_unref); (GDestroyNotify)g_array_unref);
} else { } else {
mm_dbg ("Error while checking ^SYSCFG format: %s", error->message); mm_obj_dbg (self, "error while checking ^SYSCFG format: %s", error->message);
/* If SIM-PIN error, don't mark as feature unsupported; we'll retry later */ /* If SIM-PIN error, don't mark as feature unsupported; we'll retry later */
if (!g_error_matches (error, if (!g_error_matches (error,
MM_MOBILE_EQUIPMENT_ERROR, MM_MOBILE_EQUIPMENT_ERROR,
@@ -1062,7 +1054,7 @@ syscfgex_test_ready (MMBroadbandModemHuawei *self,
/* If SIM-PIN error, don't mark as feature unsupported; we'll retry later */ /* If SIM-PIN error, don't mark as feature unsupported; we'll retry later */
if (error) { if (error) {
mm_dbg ("Error while checking ^SYSCFGEX format: %s", error->message); mm_obj_dbg (self, "error while checking ^SYSCFGEX format: %s", error->message);
if (g_error_matches (error, if (g_error_matches (error,
MM_MOBILE_EQUIPMENT_ERROR, MM_MOBILE_EQUIPMENT_ERROR,
MM_MOBILE_EQUIPMENT_ERROR_SIM_PIN)) { MM_MOBILE_EQUIPMENT_ERROR_SIM_PIN)) {
@@ -1094,7 +1086,7 @@ prefmode_test_ready (MMBroadbandModemHuawei *self,
response = mm_base_modem_at_command_finish (MM_BASE_MODEM (self), res, &error); response = mm_base_modem_at_command_finish (MM_BASE_MODEM (self), res, &error);
if (response) if (response)
self->priv->prefmode_supported_modes = mm_huawei_parse_prefmode_test (response, &error); self->priv->prefmode_supported_modes = mm_huawei_parse_prefmode_test (response, self, &error);
if (self->priv->prefmode_supported_modes) { if (self->priv->prefmode_supported_modes) {
MMModemModeCombination mode; MMModemModeCombination mode;
@@ -1122,7 +1114,7 @@ prefmode_test_ready (MMBroadbandModemHuawei *self,
combinations, combinations,
(GDestroyNotify)g_array_unref); (GDestroyNotify)g_array_unref);
} else { } else {
mm_dbg ("Error while checking ^PREFMODE format: %s", error->message); mm_obj_dbg (self, "error while checking ^PREFMODE format: %s", error->message);
/* If SIM-PIN error, don't mark as feature unsupported; we'll retry later */ /* If SIM-PIN error, don't mark as feature unsupported; we'll retry later */
if (!g_error_matches (error, if (!g_error_matches (error,
MM_MOBILE_EQUIPMENT_ERROR, MM_MOBILE_EQUIPMENT_ERROR,
@@ -1281,8 +1273,6 @@ load_current_modes (MMIfaceModem *_self,
MMBroadbandModemHuawei *self = MM_BROADBAND_MODEM_HUAWEI (_self); MMBroadbandModemHuawei *self = MM_BROADBAND_MODEM_HUAWEI (_self);
GTask *task; GTask *task;
mm_dbg ("loading current modes (huawei)...");
task = g_task_new (self, NULL, callback, user_data); task = g_task_new (self, NULL, callback, user_data);
if (self->priv->syscfgex_support == FEATURE_SUPPORTED) { if (self->priv->syscfgex_support == FEATURE_SUPPORTED) {
@@ -1498,8 +1488,6 @@ set_current_modes (MMIfaceModem *_self,
GTask *task; GTask *task;
GError *error = NULL; GError *error = NULL;
mm_dbg ("setting current modes (huawei)...");
task = g_task_new (self, NULL, callback, user_data); task = g_task_new (self, NULL, callback, user_data);
if (self->priv->syscfgex_support == FEATURE_SUPPORTED) if (self->priv->syscfgex_support == FEATURE_SUPPORTED)
@@ -1540,7 +1528,6 @@ huawei_signal_changed (MMPortSerialAt *port,
quality = MM_CLAMP_HIGH (quality, 31) * 100 / 31; quality = MM_CLAMP_HIGH (quality, 31) * 100 / 31;
} }
mm_dbg ("3GPP signal quality: %u", quality);
mm_iface_modem_update_signal_quality (MM_IFACE_MODEM (self), quality); mm_iface_modem_update_signal_quality (MM_IFACE_MODEM (self), quality);
} }
@@ -1571,7 +1558,7 @@ huawei_mode_changed (MMPortSerialAt *port,
(act < MM_MODEM_ACCESS_TECHNOLOGY_GSM || (act < MM_MODEM_ACCESS_TECHNOLOGY_GSM ||
act > MM_MODEM_ACCESS_TECHNOLOGY_EDGE)) { act > MM_MODEM_ACCESS_TECHNOLOGY_EDGE)) {
str = mm_modem_access_technology_build_string_from_mask (act); str = mm_modem_access_technology_build_string_from_mask (act);
mm_warn ("Unexpected access technology (%s) in GSM/GPRS mode", str); mm_obj_warn (self, "unexpected access technology (%s) in GSM/GPRS mode", str);
g_free (str); g_free (str);
act = MM_MODEM_ACCESS_TECHNOLOGY_UNKNOWN; act = MM_MODEM_ACCESS_TECHNOLOGY_UNKNOWN;
} }
@@ -1584,7 +1571,7 @@ huawei_mode_changed (MMPortSerialAt *port,
(act < MM_MODEM_ACCESS_TECHNOLOGY_UMTS || (act < MM_MODEM_ACCESS_TECHNOLOGY_UMTS ||
act > MM_MODEM_ACCESS_TECHNOLOGY_HSPA_PLUS)) { act > MM_MODEM_ACCESS_TECHNOLOGY_HSPA_PLUS)) {
str = mm_modem_access_technology_build_string_from_mask (act); str = mm_modem_access_technology_build_string_from_mask (act);
mm_warn ("Unexpected access technology (%s) in WCDMA mode", str); mm_obj_warn (self, "unexpected access technology (%s) in WCDMA mode", str);
g_free (str); g_free (str);
act = MM_MODEM_ACCESS_TECHNOLOGY_UNKNOWN; act = MM_MODEM_ACCESS_TECHNOLOGY_UNKNOWN;
} }
@@ -1596,7 +1583,7 @@ huawei_mode_changed (MMPortSerialAt *port,
if (act != MM_MODEM_ACCESS_TECHNOLOGY_UNKNOWN && if (act != MM_MODEM_ACCESS_TECHNOLOGY_UNKNOWN &&
act != MM_MODEM_ACCESS_TECHNOLOGY_1XRTT) { act != MM_MODEM_ACCESS_TECHNOLOGY_1XRTT) {
str = mm_modem_access_technology_build_string_from_mask (act); str = mm_modem_access_technology_build_string_from_mask (act);
mm_warn ("Unexpected access technology (%s) in CDMA mode", str); mm_obj_warn (self, "unexpected access technology (%s) in CDMA mode", str);
g_free (str); g_free (str);
act = MM_MODEM_ACCESS_TECHNOLOGY_UNKNOWN; act = MM_MODEM_ACCESS_TECHNOLOGY_UNKNOWN;
} }
@@ -1611,7 +1598,7 @@ huawei_mode_changed (MMPortSerialAt *port,
(act < MM_MODEM_ACCESS_TECHNOLOGY_EVDO0 || (act < MM_MODEM_ACCESS_TECHNOLOGY_EVDO0 ||
act > MM_MODEM_ACCESS_TECHNOLOGY_EVDOB)) { act > MM_MODEM_ACCESS_TECHNOLOGY_EVDOB)) {
str = mm_modem_access_technology_build_string_from_mask (act); str = mm_modem_access_technology_build_string_from_mask (act);
mm_warn ("Unexpected access technology (%s) in EVDO mode", str); mm_obj_warn (self, "unexpected access technology (%s) in EVDO mode", str);
g_free (str); g_free (str);
act = MM_MODEM_ACCESS_TECHNOLOGY_UNKNOWN; act = MM_MODEM_ACCESS_TECHNOLOGY_UNKNOWN;
} }
@@ -1625,14 +1612,10 @@ huawei_mode_changed (MMPortSerialAt *port,
break; break;
default: default:
mm_warn ("Unexpected mode change value reported: '%d'", a); mm_obj_warn (self, "unexpected mode change value reported: '%d'", a);
return; return;
} }
str = mm_modem_access_technology_build_string_from_mask (act);
mm_dbg ("Access Technology: '%s'", str);
g_free (str);
mm_iface_modem_update_access_technologies (MM_IFACE_MODEM (self), act, mask); mm_iface_modem_update_access_technologies (MM_IFACE_MODEM (self), act, mask);
} }
@@ -1645,10 +1628,9 @@ huawei_status_changed (MMPortSerialAt *port,
gint n1, n2, n3, n4, n5, n6, n7; gint n1, n2, n3, n4, n5, n6, n7;
str = g_match_info_fetch (match_info, 1); str = g_match_info_fetch (match_info, 1);
if (sscanf (str, "%x,%x,%x,%x,%x,%x,%x", &n1, &n2, &n3, &n4, &n5, &n6, &n7)) { if (sscanf (str, "%x,%x,%x,%x,%x,%x,%x", &n1, &n2, &n3, &n4, &n5, &n6, &n7))
mm_dbg ("Duration: %d Up: %d Kbps Down: %d Kbps Total: %d Total: %d\n", mm_obj_dbg (self, "duration: %d up: %d Kbps down: %d Kbps total: %d total: %d\n",
n1, n2 * 8 / 1000, n3 * 8 / 1000, n4 / 1024, n5 / 1024); n1, n2 * 8 / 1000, n3 * 8 / 1000, n4 / 1024, n5 / 1024);
}
g_free (str); g_free (str);
} }
@@ -1693,19 +1675,19 @@ huawei_ndisstat_changed (MMPortSerialAt *port,
&ndisstat_result.ipv6_available, &ndisstat_result.ipv6_available,
&ndisstat_result.ipv6_connected, &ndisstat_result.ipv6_connected,
&error)) { &error)) {
mm_dbg ("Ignore invalid ^NDISSTAT unsolicited message: '%s' (error %s)", mm_obj_dbg (self, "ignored invalid ^NDISSTAT unsolicited message '%s': %s",
str, error->message); str, error->message);
g_error_free (error); g_error_free (error);
g_free (str); g_free (str);
return; return;
} }
g_free (str); g_free (str);
mm_dbg ("NDIS status: IPv4 %s, IPv6 %s", mm_obj_dbg (self, "NDIS status: IPv4 %s, IPv6 %s",
ndisstat_result.ipv4_available ? ndisstat_result.ipv4_available ?
(ndisstat_result.ipv4_connected ? "connected" : "disconnected") : "not available", (ndisstat_result.ipv4_connected ? "connected" : "disconnected") : "not available",
ndisstat_result.ipv6_available ? ndisstat_result.ipv6_available ?
(ndisstat_result.ipv6_connected ? "connected" : "disconnected") : "not available"); (ndisstat_result.ipv6_connected ? "connected" : "disconnected") : "not available");
/* If empty bearer list, nothing else to do */ /* If empty bearer list, nothing else to do */
g_object_get (self, g_object_get (self,
@@ -1805,7 +1787,7 @@ huawei_hcsq_changed (MMPortSerialAt *port,
&value4, &value4,
&value5, &value5,
&error)) { &error)) {
mm_dbg ("Ignored invalid ^HCSQ message: %s (error %s)", str, error->message); mm_obj_dbg (self, "ignored invalid ^HCSQ message '%s': %s", str, error->message);
g_error_free (error); g_error_free (error);
g_free (str); g_free (str);
return; return;
@@ -2180,7 +2162,7 @@ create_bearer_for_net_port (GTask *task)
switch (self->priv->ndisdup_support) { switch (self->priv->ndisdup_support) {
case FEATURE_NOT_SUPPORTED: case FEATURE_NOT_SUPPORTED:
mm_dbg ("^NDISDUP not supported, creating default bearer..."); mm_obj_dbg (self, "^NDISDUP not supported, creating default bearer...");
mm_broadband_bearer_new (MM_BROADBAND_MODEM (self), mm_broadband_bearer_new (MM_BROADBAND_MODEM (self),
properties, properties,
NULL, /* cancellable */ NULL, /* cancellable */
@@ -2188,7 +2170,7 @@ create_bearer_for_net_port (GTask *task)
task); task);
return; return;
case FEATURE_SUPPORTED: case FEATURE_SUPPORTED:
mm_dbg ("^NDISDUP supported, creating huawei bearer..."); mm_obj_dbg (self, "^NDISDUP supported, creating huawei bearer...");
mm_broadband_bearer_huawei_new (MM_BROADBAND_MODEM_HUAWEI (self), mm_broadband_bearer_huawei_new (MM_BROADBAND_MODEM_HUAWEI (self),
properties, properties,
NULL, /* cancellable */ NULL, /* cancellable */
@@ -2212,7 +2194,7 @@ peek_port_at_for_data (MMBroadbandModemHuawei *self,
g_warn_if_fail (mm_port_get_subsys (port) == MM_PORT_SUBSYS_NET); g_warn_if_fail (mm_port_get_subsys (port) == MM_PORT_SUBSYS_NET);
net_port_parent_path = mm_kernel_device_get_interface_sysfs_path (mm_port_peek_kernel_device (port)); net_port_parent_path = mm_kernel_device_get_interface_sysfs_path (mm_port_peek_kernel_device (port));
if (!net_port_parent_path) { if (!net_port_parent_path) {
mm_warn ("(%s) no parent path for net port", mm_port_get_device (port)); mm_obj_warn (self, "no parent path for net port %s", mm_port_get_device (port));
return NULL; return NULL;
} }
@@ -2245,8 +2227,7 @@ mm_broadband_modem_huawei_peek_port_at_for_data (MMBroadbandModemHuawei *self,
found = peek_port_at_for_data (self, port); found = peek_port_at_for_data (self, port);
if (!found) if (!found)
mm_warn ("Couldn't find associated cdc-wdm port for 'net/%s'", mm_obj_warn (self, "couldn't find associated cdc-wdm port for %s", mm_port_get_device (port));
mm_port_get_device (port));
return found; return found;
} }
@@ -2261,22 +2242,21 @@ ensure_ndisdup_support_checked (MMBroadbandModemHuawei *self,
/* First, check for devices which support NDISDUP on any AT port. These /* First, check for devices which support NDISDUP on any AT port. These
* devices are tagged by udev */ * devices are tagged by udev */
if (mm_kernel_device_get_global_property_as_boolean (mm_port_peek_kernel_device (port), "ID_MM_HUAWEI_NDISDUP_SUPPORTED")) { if (mm_kernel_device_get_global_property_as_boolean (mm_port_peek_kernel_device (port), "ID_MM_HUAWEI_NDISDUP_SUPPORTED")) {
mm_dbg ("This device (%s) can support ndisdup feature", mm_port_get_device (port)); mm_obj_dbg (self, "^NDISDUP is supported");
self->priv->ndisdup_support = FEATURE_SUPPORTED; self->priv->ndisdup_support = FEATURE_SUPPORTED;
} }
/* Then, look for devices which have both a net port and a cdc-wdm /* Then, look for devices which have both a net port and a cdc-wdm
* AT-capable port. We assume that these devices allow NDISDUP only * AT-capable port. We assume that these devices allow NDISDUP only
* when issued in the cdc-wdm port. */ * when issued in the cdc-wdm port. */
else if (peek_port_at_for_data (self, port)) { else if (peek_port_at_for_data (self, port)) {
mm_dbg ("This device (%s) can support ndisdup feature on non-serial AT port", mm_obj_dbg (self, "^NDISDUP is supported on non-serial AT port");
mm_port_get_device (port));
self->priv->ndisdup_support = FEATURE_SUPPORTED; self->priv->ndisdup_support = FEATURE_SUPPORTED;
} }
if (self->priv->ndisdup_support != FEATURE_SUPPORT_UNKNOWN) if (self->priv->ndisdup_support != FEATURE_SUPPORT_UNKNOWN)
return; return;
mm_dbg ("This device (%s) can not support ndisdup feature", mm_port_get_device (port)); mm_obj_dbg (self, "^NDISDUP is not supported");
self->priv->ndisdup_support = FEATURE_NOT_SUPPORTED; self->priv->ndisdup_support = FEATURE_NOT_SUPPORTED;
} }
@@ -2299,7 +2279,7 @@ huawei_modem_create_bearer (MMIfaceModem *self,
return; return;
} }
mm_dbg ("Creating default bearer..."); mm_obj_dbg (self, "creating default bearer...");
mm_broadband_bearer_new (MM_BROADBAND_MODEM (self), mm_broadband_bearer_new (MM_BROADBAND_MODEM (self),
properties, properties,
NULL, /* cancellable */ NULL, /* cancellable */
@@ -2380,7 +2360,7 @@ huawei_1x_signal_changed (MMPortSerialAt *port,
return; return;
quality = MM_CLAMP_HIGH (quality, 100); quality = MM_CLAMP_HIGH (quality, 100);
mm_dbg ("1X signal quality: %u", quality); mm_obj_dbg (self, "1X signal quality: %u", quality);
mm_iface_modem_update_signal_quality (MM_IFACE_MODEM (self), quality); mm_iface_modem_update_signal_quality (MM_IFACE_MODEM (self), quality);
} }
@@ -2395,7 +2375,7 @@ huawei_evdo_signal_changed (MMPortSerialAt *port,
return; return;
quality = MM_CLAMP_HIGH (quality, 100); quality = MM_CLAMP_HIGH (quality, 100);
mm_dbg ("EVDO signal quality: %u", quality); mm_obj_dbg (self, "EVDO signal quality: %u", quality);
mm_iface_modem_update_signal_quality (MM_IFACE_MODEM (self), quality); mm_iface_modem_update_signal_quality (MM_IFACE_MODEM (self), quality);
} }
@@ -2487,7 +2467,6 @@ modem_load_signal_quality (MMIfaceModem *self,
MMModemCdmaRegistrationState evdo_state = MM_MODEM_CDMA_REGISTRATION_STATE_UNKNOWN; MMModemCdmaRegistrationState evdo_state = MM_MODEM_CDMA_REGISTRATION_STATE_UNKNOWN;
const char *command = "^CSQLVL"; const char *command = "^CSQLVL";
mm_dbg ("loading signal quality...");
task = g_task_new (self, NULL, callback, user_data); task = g_task_new (self, NULL, callback, user_data);
/* 3GPP modems can just run parent's signal quality loading */ /* 3GPP modems can just run parent's signal quality loading */
@@ -2838,7 +2817,7 @@ registration_state_sysinfo_ready (MMBroadbandModemHuawei *self,
if (!cdma1x && !evdo) { if (!cdma1x && !evdo) {
/* Say we're registered to something even though sysmode parsing failed */ /* Say we're registered to something even though sysmode parsing failed */
mm_dbg ("Assuming registered at least in CDMA1x"); mm_obj_dbg (self, "assuming registered at least in CDMA1x");
ctx->state.detailed_cdma1x_state = MM_MODEM_CDMA_REGISTRATION_STATE_REGISTERED; ctx->state.detailed_cdma1x_state = MM_MODEM_CDMA_REGISTRATION_STATE_REGISTERED;
} }
} }
@@ -2911,7 +2890,7 @@ cvoice_check_ready (MMBaseModem *_self,
&self->priv->audio_bits, &self->priv->audio_bits,
&error)) { &error)) {
self->priv->cvoice_support = FEATURE_NOT_SUPPORTED; self->priv->cvoice_support = FEATURE_NOT_SUPPORTED;
mm_dbg ("Huawei-specific CVOICE is unsupported: %s", error->message); mm_obj_dbg (self, "Huawei-specific CVOICE is unsupported: %s", error->message);
g_clear_error (&error); g_clear_error (&error);
/* Now check generic support */ /* Now check generic support */
@@ -2921,7 +2900,7 @@ cvoice_check_ready (MMBaseModem *_self,
return; return;
} }
mm_dbg ("Huawei-specific CVOICE is supported"); mm_obj_dbg (self, "Huawei-specific CVOICE is supported");
self->priv->cvoice_support = FEATURE_SUPPORTED; self->priv->cvoice_support = FEATURE_SUPPORTED;
g_task_return_boolean (task, TRUE); g_task_return_boolean (task, TRUE);
g_object_unref (task); g_object_unref (task);
@@ -3097,23 +3076,23 @@ orig_received (MMPortSerialAt *port,
guint aux = 0; guint aux = 0;
if (!mm_get_uint_from_match_info (match_info, 2, &aux)) { if (!mm_get_uint_from_match_info (match_info, 2, &aux)) {
mm_warn ("couldn't parse call type from ^ORIG"); mm_obj_warn (self, "couldn't parse call type from ^ORIG");
return; return;
} }
if (aux != HUAWEI_CALL_TYPE_VOICE && aux != HUAWEI_CALL_TYPE_EMERGENCY) { if (aux != HUAWEI_CALL_TYPE_VOICE && aux != HUAWEI_CALL_TYPE_EMERGENCY) {
mm_dbg ("ignored ^ORIG for non-voice call"); mm_obj_dbg (self, "ignored ^ORIG for non-voice call");
return; return;
} }
if (!mm_get_uint_from_match_info (match_info, 1, &aux)) { if (!mm_get_uint_from_match_info (match_info, 1, &aux)) {
mm_warn ("couldn't parse call index from ^ORIG"); mm_obj_warn (self, "couldn't parse call index from ^ORIG");
return; return;
} }
call_info.index = aux; call_info.index = aux;
call_info.state = MM_CALL_STATE_DIALING; call_info.state = MM_CALL_STATE_DIALING;
call_info.direction = MM_CALL_DIRECTION_OUTGOING; call_info.direction = MM_CALL_DIRECTION_OUTGOING;
mm_dbg ("call %u state updated: dialing", call_info.index); mm_obj_dbg (self, "call %u state updated: dialing", call_info.index);
mm_iface_modem_voice_report_call (MM_IFACE_MODEM_VOICE (self), &call_info); mm_iface_modem_voice_report_call (MM_IFACE_MODEM_VOICE (self), &call_info);
} }
@@ -3127,14 +3106,14 @@ conf_received (MMPortSerialAt *port,
guint aux = 0; guint aux = 0;
if (!mm_get_uint_from_match_info (match_info, 1, &aux)) { if (!mm_get_uint_from_match_info (match_info, 1, &aux)) {
mm_warn ("couldn't parse call index from ^CONF"); mm_obj_warn (self, "couldn't parse call index from ^CONF");
return; return;
} }
call_info.index = aux; call_info.index = aux;
call_info.state = MM_CALL_STATE_RINGING_OUT; call_info.state = MM_CALL_STATE_RINGING_OUT;
call_info.direction = MM_CALL_DIRECTION_OUTGOING; call_info.direction = MM_CALL_DIRECTION_OUTGOING;
mm_dbg ("call %u state updated: ringing-out", call_info.index); mm_obj_dbg (self, "call %u state updated: ringing-out", call_info.index);
mm_iface_modem_voice_report_call (MM_IFACE_MODEM_VOICE (self), &call_info); mm_iface_modem_voice_report_call (MM_IFACE_MODEM_VOICE (self), &call_info);
} }
@@ -3148,14 +3127,14 @@ conn_received (MMPortSerialAt *port,
guint aux = 0; guint aux = 0;
if (!mm_get_uint_from_match_info (match_info, 1, &aux)) { if (!mm_get_uint_from_match_info (match_info, 1, &aux)) {
mm_warn ("couldn't parse call index from ^CONN"); mm_obj_warn (self, "couldn't parse call index from ^CONN");
return; return;
} }
call_info.index = aux; call_info.index = aux;
call_info.state = MM_CALL_STATE_ACTIVE; call_info.state = MM_CALL_STATE_ACTIVE;
call_info.direction = MM_CALL_DIRECTION_UNKNOWN; call_info.direction = MM_CALL_DIRECTION_UNKNOWN;
mm_dbg ("call %u state updated: active", aux); mm_obj_dbg (self, "call %u state updated: active", aux);
mm_iface_modem_voice_report_call (MM_IFACE_MODEM_VOICE (self), &call_info); mm_iface_modem_voice_report_call (MM_IFACE_MODEM_VOICE (self), &call_info);
} }
@@ -3170,20 +3149,20 @@ cend_received (MMPortSerialAt *port,
/* only index is mandatory */ /* only index is mandatory */
if (!mm_get_uint_from_match_info (match_info, 1, &aux)) { if (!mm_get_uint_from_match_info (match_info, 1, &aux)) {
mm_warn ("couldn't parse call index from ^CEND"); mm_obj_warn (self, "couldn't parse call index from ^CEND");
return; return;
} }
call_info.index = aux; call_info.index = aux;
call_info.state = MM_CALL_STATE_TERMINATED; call_info.state = MM_CALL_STATE_TERMINATED;
call_info.direction = MM_CALL_DIRECTION_UNKNOWN; call_info.direction = MM_CALL_DIRECTION_UNKNOWN;
mm_dbg ("call %u state updated: terminated", call_info.index); mm_obj_dbg (self, "call %u state updated: terminated", call_info.index);
if (mm_get_uint_from_match_info (match_info, 2, &aux)) if (mm_get_uint_from_match_info (match_info, 2, &aux))
mm_dbg (" call duration: %u seconds", aux); mm_obj_dbg (self, " call duration: %u seconds", aux);
if (mm_get_uint_from_match_info (match_info, 3, &aux)) if (mm_get_uint_from_match_info (match_info, 3, &aux))
mm_dbg (" end status code: %u", aux); mm_obj_dbg (self, " end status code: %u", aux);
if (mm_get_uint_from_match_info (match_info, 4, &aux)) if (mm_get_uint_from_match_info (match_info, 4, &aux))
mm_dbg (" call control cause: %u", aux); mm_obj_dbg (self, " call control cause: %u", aux);
mm_iface_modem_voice_report_call (MM_IFACE_MODEM_VOICE (self), &call_info); mm_iface_modem_voice_report_call (MM_IFACE_MODEM_VOICE (self), &call_info);
} }
@@ -3196,7 +3175,7 @@ ddtmf_received (MMPortSerialAt *port,
gchar *dtmf; gchar *dtmf;
dtmf = g_match_info_fetch (match_info, 1); dtmf = g_match_info_fetch (match_info, 1);
mm_dbg ("received DTMF: %s", dtmf); mm_obj_dbg (self, "received DTMF: %s", dtmf);
/* call index unknown */ /* call index unknown */
mm_iface_modem_voice_received_dtmf (MM_IFACE_MODEM_VOICE (self), 0, dtmf); mm_iface_modem_voice_received_dtmf (MM_IFACE_MODEM_VOICE (self), 0, dtmf);
g_free (dtmf); g_free (dtmf);
@@ -3582,8 +3561,8 @@ enable_disable_unsolicited_rfswitch_event_handler (MMBroadbandModemHuawei *self,
ports = mm_broadband_modem_huawei_get_at_port_list (self); ports = mm_broadband_modem_huawei_get_at_port_list (self);
mm_dbg ("%s ^RFSWITCH unsolicited event handler", mm_obj_dbg (self, "%s ^RFSWITCH unsolicited event handler",
enable ? "Enable" : "Disable"); enable ? "enable" : "disable");
for (l = ports; l; l = g_list_next (l)) { for (l = ports; l; l = g_list_next (l)) {
MMPortSerialAt *port = MM_PORT_SERIAL_AT (l->data); MMPortSerialAt *port = MM_PORT_SERIAL_AT (l->data);
@@ -3639,17 +3618,17 @@ huawei_rfswitch_check_ready (MMBaseModem *_self,
response = mm_strip_tag (response, "^RFSWITCH:"); response = mm_strip_tag (response, "^RFSWITCH:");
if (sscanf (response, "%d", &sw_state) != 1 || if (sscanf (response, "%d", &sw_state) != 1 ||
(sw_state != 0 && sw_state != 1)) { (sw_state != 0 && sw_state != 1)) {
mm_warn ("Couldn't parse ^RFSWITCH response: '%s'", response); mm_obj_warn (self, "couldn't parse ^RFSWITCH response '%s'", response);
error = g_error_new (MM_CORE_ERROR, error = g_error_new (MM_CORE_ERROR,
MM_CORE_ERROR_FAILED, MM_CORE_ERROR_FAILED,
"Couldn't parse ^RFSWITCH response: '%s'", "Couldn't parse ^RFSWITCH response '%s'",
response); response);
} }
} }
if (self->priv->rfswitch_support == FEATURE_SUPPORT_UNKNOWN) { if (self->priv->rfswitch_support == FEATURE_SUPPORT_UNKNOWN) {
if (error) { if (error) {
mm_dbg ("The device does not support ^RFSWITCH"); mm_obj_dbg (self, "^RFSWITCH is not supported");
self->priv->rfswitch_support = FEATURE_NOT_SUPPORTED; self->priv->rfswitch_support = FEATURE_NOT_SUPPORTED;
g_error_free (error); g_error_free (error);
/* Fall back to parent's load_power_state */ /* Fall back to parent's load_power_state */
@@ -3659,7 +3638,7 @@ huawei_rfswitch_check_ready (MMBaseModem *_self,
return; return;
} }
mm_dbg ("The device supports ^RFSWITCH"); mm_obj_dbg (self, "^RFSWITCH is supported");
self->priv->rfswitch_support = FEATURE_SUPPORTED; self->priv->rfswitch_support = FEATURE_SUPPORTED;
} }
@@ -4304,7 +4283,7 @@ hcsq_get_ready (MMBaseModem *_self,
* be updated. * be updated.
*/ */
if (!mm_base_modem_at_command_finish (_self, res, &error)) { if (!mm_base_modem_at_command_finish (_self, res, &error)) {
mm_dbg ("^HCSQ failed: %s", error->message); mm_obj_dbg (self, "^HCSQ failed: %s", error->message);
g_task_return_error (task, error); g_task_return_error (task, error);
g_object_unref (task); g_object_unref (task);
return; return;
@@ -4330,8 +4309,6 @@ signal_load_values (MMIfaceModemSignal *_self,
MMBroadbandModemHuawei *self = MM_BROADBAND_MODEM_HUAWEI (_self); MMBroadbandModemHuawei *self = MM_BROADBAND_MODEM_HUAWEI (_self);
GTask *task; GTask *task;
mm_dbg ("loading extended signal information...");
task = g_task_new (self, cancellable, callback, user_data); task = g_task_new (self, cancellable, callback, user_data);
/* Clear any previous detailed signal values to get new ones */ /* Clear any previous detailed signal values to get new ones */

31
plugins/huawei/mm-modem-helpers-huawei.c
View File

@@ -22,7 +22,7 @@
#define _LIBMM_INSIDE_MM #define _LIBMM_INSIDE_MM
#include <libmm-glib.h> #include <libmm-glib.h>
#include "mm-log.h" #include "mm-log-object.h"
#include "mm-modem-helpers.h" #include "mm-modem-helpers.h"
#include "mm-modem-helpers-huawei.h" #include "mm-modem-helpers-huawei.h"
@@ -429,8 +429,9 @@ mode_from_prefmode (guint huawei_mode,
} }
GArray * GArray *
mm_huawei_parse_prefmode_test (const gchar *response, mm_huawei_parse_prefmode_test (const gchar *response,
GError **error) gpointer log_object,
GError **error)
{ {
gchar **split; gchar **split;
guint i; guint i;
@@ -461,12 +462,12 @@ mm_huawei_parse_prefmode_test (const gchar *response,
continue; continue;
if (!mm_get_uint_from_str (split[i], &val)) { if (!mm_get_uint_from_str (split[i], &val)) {
mm_dbg ("Error parsing ^PREFMODE value: %s", split[i]); mm_obj_dbg (log_object, "error parsing ^PREFMODE value '%s'", split[i]);
continue; continue;
} }
if (!mode_from_prefmode (val, &preferred, &inner_error)) { if (!mode_from_prefmode (val, &preferred, &inner_error)) {
mm_dbg ("Unhandled ^PREFMODE: %s", inner_error->message); mm_obj_dbg (log_object, "unhandled ^PREFMODE value: %s", inner_error->message);
g_error_free (inner_error); g_error_free (inner_error);
continue; continue;
} }
@@ -708,9 +709,10 @@ mode_from_syscfg (guint huawei_mode,
} }
static GArray * static GArray *
parse_syscfg_modes (const gchar *modes_str, parse_syscfg_modes (const gchar *modes_str,
const gchar *acqorder_str, const gchar *acqorder_str,
GError **error) gpointer log_object,
GError **error)
{ {
GArray *out; GArray *out;
gchar **split; gchar **split;
@@ -720,7 +722,7 @@ parse_syscfg_modes (const gchar *modes_str,
/* Start parsing acquisition order */ /* Start parsing acquisition order */
if (!sscanf (acqorder_str, "%d-%d", &min_acqorder, &max_acqorder)) if (!sscanf (acqorder_str, "%d-%d", &min_acqorder, &max_acqorder))
mm_dbg ("Error parsing ^SYSCFG acquisition order range (%s)", acqorder_str); mm_obj_dbg (log_object, "error parsing ^SYSCFG acquisition order range '%s'", acqorder_str);
/* Just in case, we default to supporting only auto */ /* Just in case, we default to supporting only auto */
if (max_acqorder < min_acqorder) { if (max_acqorder < min_acqorder) {
@@ -741,13 +743,13 @@ parse_syscfg_modes (const gchar *modes_str,
MMHuaweiSyscfgCombination combination; MMHuaweiSyscfgCombination combination;
if (!mm_get_uint_from_str (mm_strip_quotes (split[i]), &val)) { if (!mm_get_uint_from_str (mm_strip_quotes (split[i]), &val)) {
mm_dbg ("Error parsing ^SYSCFG mode value: %s", split[i]); mm_obj_dbg (log_object, "error parsing ^SYSCFG mode value: %s", split[i]);
continue; continue;
} }
if (!mode_from_syscfg (val, &allowed, &inner_error)) { if (!mode_from_syscfg (val, &allowed, &inner_error)) {
if (inner_error) { if (inner_error) {
mm_dbg ("Unhandled ^SYSCFG: %s", inner_error->message); mm_obj_dbg (log_object, "unhandled ^SYSCFG: %s", inner_error->message);
g_error_free (inner_error); g_error_free (inner_error);
} }
continue; continue;
@@ -808,8 +810,9 @@ parse_syscfg_modes (const gchar *modes_str,
} }
GArray * GArray *
mm_huawei_parse_syscfg_test (const gchar *response, mm_huawei_parse_syscfg_test (const gchar *response,
GError **error) gpointer log_object,
GError **error)
{ {
gchar **split; gchar **split;
GError *inner_error = NULL; GError *inner_error = NULL;
@@ -846,7 +849,7 @@ mm_huawei_parse_syscfg_test (const gchar *response,
} }
/* Parse supported mode combinations */ /* Parse supported mode combinations */
out = parse_syscfg_modes (split[0], split[1], &inner_error); out = parse_syscfg_modes (split[0], split[1], log_object, &inner_error);
g_strfreev (split); g_strfreev (split);

10
plugins/huawei/mm-modem-helpers-huawei.h
View File

@@ -70,8 +70,9 @@ typedef struct {
MMModemMode preferred; MMModemMode preferred;
} MMHuaweiPrefmodeCombination; } MMHuaweiPrefmodeCombination;
GArray *mm_huawei_parse_prefmode_test (const gchar *response, GArray *mm_huawei_parse_prefmode_test (const gchar *response,
GError **error); gpointer log_object,
GError **error);
/*****************************************************************************/ /*****************************************************************************/
/* ^PREFMODE response parser */ /* ^PREFMODE response parser */
@@ -94,8 +95,9 @@ typedef struct {
MMModemMode preferred; MMModemMode preferred;
} MMHuaweiSyscfgCombination; } MMHuaweiSyscfgCombination;
GArray *mm_huawei_parse_syscfg_test (const gchar *response, GArray *mm_huawei_parse_syscfg_test (const gchar *response,
GError **error); gpointer log_object,
GError **error);
/*****************************************************************************/ /*****************************************************************************/
/* ^SYSCFG response parser */ /* ^SYSCFG response parser */

119
plugins/huawei/mm-plugin-huawei.c
View File

@@ -52,9 +52,10 @@ MM_PLUGIN_DEFINE_MINOR_VERSION
#define MAX_WAIT_TIME 5 #define MAX_WAIT_TIME 5
typedef struct { typedef struct {
guint first_usbif; MMPortProbe *probe;
guint timeout_id; guint first_usbif;
gboolean custom_init_run; guint timeout_id;
gboolean custom_init_run;
} FirstInterfaceContext; } FirstInterfaceContext;
static void static void
@@ -62,6 +63,7 @@ first_interface_context_free (FirstInterfaceContext *ctx)
{ {
if (ctx->timeout_id) if (ctx->timeout_id)
g_source_remove (ctx->timeout_id); g_source_remove (ctx->timeout_id);
g_object_unref (ctx->probe);
g_slice_free (FirstInterfaceContext, ctx); g_slice_free (FirstInterfaceContext, ctx);
} }
@@ -73,19 +75,17 @@ first_interface_context_free (FirstInterfaceContext *ctx)
#define TAG_AT_PORT_FLAGS "at-port-flags" #define TAG_AT_PORT_FLAGS "at-port-flags"
typedef struct { typedef struct {
MMPortProbe *probe;
MMPortSerialAt *port; MMPortSerialAt *port;
gboolean curc_done; gboolean curc_done;
guint curc_retries; guint curc_retries;
gboolean getportmode_done; gboolean getportmode_done;
guint getportmode_retries; guint getportmode_retries;
} HuaweiCustomInitContext; } HuaweiCustomInitContext;
static void static void
huawei_custom_init_context_free (HuaweiCustomInitContext *ctx) huawei_custom_init_context_free (HuaweiCustomInitContext *ctx)
{ {
g_object_unref (ctx->port); g_object_unref (ctx->port);
g_object_unref (ctx->probe);
g_slice_free (HuaweiCustomInitContext, ctx); g_slice_free (HuaweiCustomInitContext, ctx);
} }
@@ -124,19 +124,20 @@ cache_port_mode (MMDevice *device,
static void static void
getportmode_ready (MMPortSerialAt *port, getportmode_ready (MMPortSerialAt *port,
GAsyncResult *res, GAsyncResult *res,
GTask *task) GTask *task)
{ {
MMPortProbe *probe;
HuaweiCustomInitContext *ctx; HuaweiCustomInitContext *ctx;
const gchar *response; const gchar *response;
GError *error = NULL; GError *error = NULL;
ctx = g_task_get_task_data (task); probe = g_task_get_source_object (task);
ctx = g_task_get_task_data (task);
response = mm_port_serial_at_command_finish (port, res, &error); response = mm_port_serial_at_command_finish (port, res, &error);
if (error) { if (error) {
mm_dbg ("(Huawei) couldn't get port mode: '%s'", mm_obj_dbg (probe, "couldn't get port mode: '%s'", error->message);
error->message);
/* If any error occurred that was not ERROR or COMMAND NOT SUPPORT then /* If any error occurred that was not ERROR or COMMAND NOT SUPPORT then
* retry the command. * retry the command.
@@ -151,10 +152,10 @@ getportmode_ready (MMPortSerialAt *port,
MMDevice *device; MMDevice *device;
guint n_cached_port_modes = 0; guint n_cached_port_modes = 0;
mm_dbg ("(Huawei) port mode layout retrieved"); mm_obj_dbg (probe, "(Huawei) port mode layout retrieved");
/* Results are cached in the parent device object */ /* Results are cached in the parent device object */
device = mm_port_probe_peek_device (ctx->probe); device = mm_port_probe_peek_device (probe);
n_cached_port_modes += cache_port_mode (device, response, "PCUI:", TAG_HUAWEI_PCUI_PORT); n_cached_port_modes += cache_port_mode (device, response, "PCUI:", TAG_HUAWEI_PCUI_PORT);
n_cached_port_modes += cache_port_mode (device, response, "MDM:", TAG_HUAWEI_MODEM_PORT); n_cached_port_modes += cache_port_mode (device, response, "MDM:", TAG_HUAWEI_MODEM_PORT);
n_cached_port_modes += cache_port_mode (device, response, "NDIS:", TAG_HUAWEI_NDIS_PORT); n_cached_port_modes += cache_port_mode (device, response, "NDIS:", TAG_HUAWEI_NDIS_PORT);
@@ -167,7 +168,7 @@ getportmode_ready (MMPortSerialAt *port,
g_object_set_data (G_OBJECT (device), TAG_GETPORTMODE_SUPPORTED, GUINT_TO_POINTER (TRUE)); g_object_set_data (G_OBJECT (device), TAG_GETPORTMODE_SUPPORTED, GUINT_TO_POINTER (TRUE));
/* Mark port as being AT already */ /* Mark port as being AT already */
mm_port_probe_set_result_at (ctx->probe, TRUE); mm_port_probe_set_result_at (probe, TRUE);
} }
ctx->getportmode_done = TRUE; ctx->getportmode_done = TRUE;
@@ -181,13 +182,15 @@ out:
static void static void
curc_ready (MMPortSerialAt *port, curc_ready (MMPortSerialAt *port,
GAsyncResult *res, GAsyncResult *res,
GTask *task) GTask *task)
{ {
MMPortProbe *probe;
HuaweiCustomInitContext *ctx; HuaweiCustomInitContext *ctx;
GError *error = NULL; g_autoptr(GError) error = NULL;
ctx = g_task_get_task_data (task); probe = g_task_get_source_object (task);
ctx = g_task_get_task_data (task);
mm_port_serial_at_command_finish (port, res, &error); mm_port_serial_at_command_finish (port, res, &error);
if (error) { if (error) {
@@ -197,23 +200,20 @@ curc_ready (MMPortSerialAt *port,
MM_SERIAL_ERROR_RESPONSE_TIMEOUT)) MM_SERIAL_ERROR_RESPONSE_TIMEOUT))
goto out; goto out;
mm_dbg ("(Huawei) couldn't turn off unsolicited messages in secondary ports: '%s'", mm_obj_dbg (probe, "(Huawei) couldn't turn off unsolicited messages in secondary ports: %s", error->message);
error->message);
} }
mm_dbg ("(Huawei) unsolicited messages in secondary ports turned off"); mm_obj_dbg (probe, "(Huawei) unsolicited messages in secondary ports turned off");
ctx->curc_done = TRUE; ctx->curc_done = TRUE;
out: out:
if (error)
g_error_free (error);
huawei_custom_init_step (task); huawei_custom_init_step (task);
} }
static void static void
try_next_usbif (MMDevice *device) try_next_usbif (MMPortProbe *probe,
MMDevice *device)
{ {
FirstInterfaceContext *fi_ctx; FirstInterfaceContext *fi_ctx;
GList *l; GList *l;
@@ -226,13 +226,13 @@ try_next_usbif (MMDevice *device)
* and enable that one as being first */ * and enable that one as being first */
closest = G_MAXUINT; closest = G_MAXUINT;
for (l = mm_device_peek_port_probe_list (device); l; l = g_list_next (l)) { for (l = mm_device_peek_port_probe_list (device); l; l = g_list_next (l)) {
MMPortProbe *probe = MM_PORT_PROBE (l->data); MMPortProbe *iter = MM_PORT_PROBE (l->data);
/* Only expect ttys for next probing attempt */ /* Only expect ttys for next probing attempt */
if (g_str_equal (mm_port_probe_get_port_subsys (probe), "tty")) { if (g_str_equal (mm_port_probe_get_port_subsys (iter), "tty")) {
guint usbif; guint usbif;
usbif = mm_kernel_device_get_property_as_int_hex (mm_port_probe_peek_port (probe), "ID_USB_INTERFACE_NUM"); usbif = mm_kernel_device_get_property_as_int_hex (mm_port_probe_peek_port (iter), "ID_USB_INTERFACE_NUM");
if (usbif == fi_ctx->first_usbif) { if (usbif == fi_ctx->first_usbif) {
/* This is the one we just probed, which wasn't yet removed, so just skip it */ /* This is the one we just probed, which wasn't yet removed, so just skip it */
} else if (usbif > fi_ctx->first_usbif && } else if (usbif > fi_ctx->first_usbif &&
@@ -245,10 +245,9 @@ try_next_usbif (MMDevice *device)
if (closest == G_MAXUINT) { if (closest == G_MAXUINT) {
/* No more ttys to try! Just return something */ /* No more ttys to try! Just return something */
closest = 0; closest = 0;
mm_dbg ("(Huawei) No more ports to run initial probing"); mm_obj_dbg (probe, "(Huawei) no more ports to run initial probing");
} else { } else
mm_dbg ("(Huawei) Will try initial probing with interface '%d' instead", closest); mm_obj_dbg (probe, "(Huawei) will try initial probing with interface '%d' instead", closest);
}
fi_ctx->first_usbif = closest; fi_ctx->first_usbif = closest;
} }
@@ -256,16 +255,17 @@ try_next_usbif (MMDevice *device)
static void static void
huawei_custom_init_step (GTask *task) huawei_custom_init_step (GTask *task)
{ {
MMPortProbe *probe;
HuaweiCustomInitContext *ctx; HuaweiCustomInitContext *ctx;
FirstInterfaceContext *fi_ctx; FirstInterfaceContext *fi_ctx;
MMKernelDevice *port; MMKernelDevice *port;
ctx = g_task_get_task_data (task); probe = g_task_get_source_object (task);
ctx = g_task_get_task_data (task);
/* If cancelled, end */ /* If cancelled, end */
if (g_task_return_error_if_cancelled (task)) { if (g_task_return_error_if_cancelled (task)) {
mm_dbg ("(Huawei) no need to keep on running custom init in (%s)", mm_obj_dbg (probe, "(Huawei) no need to keep on running custom init");
mm_port_get_device (MM_PORT (ctx->port)));
g_object_unref (task); g_object_unref (task);
return; return;
} }
@@ -273,9 +273,9 @@ huawei_custom_init_step (GTask *task)
if (!ctx->curc_done) { if (!ctx->curc_done) {
if (ctx->curc_retries == 0) { if (ctx->curc_retries == 0) {
/* All retries consumed, probably not an AT port */ /* All retries consumed, probably not an AT port */
mm_port_probe_set_result_at (ctx->probe, FALSE); mm_port_probe_set_result_at (probe, FALSE);
/* Try with next */ /* Try with next */
try_next_usbif (mm_port_probe_peek_device (ctx->probe)); try_next_usbif (probe, mm_port_probe_peek_device (probe));
g_task_return_boolean (task, TRUE); g_task_return_boolean (task, TRUE);
g_object_unref (task); g_object_unref (task);
return; return;
@@ -296,7 +296,7 @@ huawei_custom_init_step (GTask *task)
} }
/* Try to get a port map from the modem */ /* Try to get a port map from the modem */
port = mm_port_probe_peek_port (ctx->probe); port = mm_port_probe_peek_port (probe);
if (!ctx->getportmode_done && !mm_kernel_device_get_global_property_as_boolean (port, "ID_MM_HUAWEI_DISABLE_GETPORTMODE")) { if (!ctx->getportmode_done && !mm_kernel_device_get_global_property_as_boolean (port, "ID_MM_HUAWEI_DISABLE_GETPORTMODE")) {
if (ctx->getportmode_retries == 0) { if (ctx->getportmode_retries == 0) {
g_task_return_boolean (task, TRUE); g_task_return_boolean (task, TRUE);
@@ -318,7 +318,7 @@ huawei_custom_init_step (GTask *task)
} }
/* All done it seems */ /* All done it seems */
fi_ctx = g_object_get_data (G_OBJECT (mm_port_probe_peek_device (ctx->probe)), TAG_FIRST_INTERFACE_CONTEXT); fi_ctx = g_object_get_data (G_OBJECT (mm_port_probe_peek_device (probe)), TAG_FIRST_INTERFACE_CONTEXT);
g_assert (fi_ctx != NULL); g_assert (fi_ctx != NULL);
fi_ctx->custom_init_run = TRUE; fi_ctx->custom_init_run = TRUE;
@@ -329,7 +329,11 @@ huawei_custom_init_step (GTask *task)
static gboolean static gboolean
first_interface_missing_timeout_cb (MMDevice *device) first_interface_missing_timeout_cb (MMDevice *device)
{ {
try_next_usbif (device); FirstInterfaceContext *fi_ctx;
fi_ctx = g_object_get_data (G_OBJECT (device), TAG_FIRST_INTERFACE_CONTEXT);
g_assert (fi_ctx != NULL);
try_next_usbif (fi_ctx->probe, device);
/* Reload the timeout, just in case we end up not having the next interface to probe... /* Reload the timeout, just in case we end up not having the next interface to probe...
* which is anyway very unlikely as we got it by looking at the real probe list, but anyway... */ * which is anyway very unlikely as we got it by looking at the real probe list, but anyway... */
@@ -363,6 +367,7 @@ huawei_custom_init (MMPortProbe *probe,
if (!fi_ctx) { if (!fi_ctx) {
/* This is the first time we ask for the context. Set it up. */ /* This is the first time we ask for the context. Set it up. */
fi_ctx = g_slice_new0 (FirstInterfaceContext); fi_ctx = g_slice_new0 (FirstInterfaceContext);
fi_ctx->probe = g_object_ref (probe);
g_object_set_data_full (G_OBJECT (device), g_object_set_data_full (G_OBJECT (device),
TAG_FIRST_INTERFACE_CONTEXT, TAG_FIRST_INTERFACE_CONTEXT,
fi_ctx, fi_ctx,
@@ -383,7 +388,6 @@ huawei_custom_init (MMPortProbe *probe,
} }
ctx = g_slice_new (HuaweiCustomInitContext); ctx = g_slice_new (HuaweiCustomInitContext);
ctx->probe = g_object_ref (probe);
ctx->port = g_object_ref (port); ctx->port = g_object_ref (port);
ctx->curc_done = FALSE; ctx->curc_done = FALSE;
ctx->curc_retries = 3; ctx->curc_retries = 3;
@@ -423,7 +427,8 @@ huawei_custom_init (MMPortProbe *probe,
/*****************************************************************************/ /*****************************************************************************/
static void static void
propagate_port_mode_results (GList *probes) propagate_port_mode_results (MMPlugin *self,
GList *probes)
{ {
MMDevice *device; MMDevice *device;
GList *l; GList *l;
@@ -466,7 +471,7 @@ propagate_port_mode_results (GList *probes)
if (description) { if (description) {
gchar *lower_description; gchar *lower_description;
mm_dbg ("(Huawei) %s interface description: %s", mm_port_probe_get_port_name (probe), description); mm_obj_dbg (probe, "%s interface description: %s", mm_port_probe_get_port_name (probe), description);
lower_description = g_ascii_strdown (description, -1); lower_description = g_ascii_strdown (description, -1);
if (strstr (lower_description, "modem")) if (strstr (lower_description, "modem"))
@@ -517,11 +522,11 @@ create_modem (MMPlugin *self,
GList *probes, GList *probes,
GError **error) GError **error)
{ {
propagate_port_mode_results (probes); propagate_port_mode_results (self, probes);
#if defined WITH_QMI #if defined WITH_QMI
if (mm_port_probe_list_has_qmi_port (probes)) { if (mm_port_probe_list_has_qmi_port (probes)) {
mm_dbg ("QMI-powered Huawei modem found..."); mm_obj_dbg (self, "QMI-powered Huawei modem found...");
return MM_BASE_MODEM (mm_broadband_modem_qmi_new (uid, return MM_BASE_MODEM (mm_broadband_modem_qmi_new (uid,
drivers, drivers,
mm_plugin_get_name (self), mm_plugin_get_name (self),
@@ -532,7 +537,7 @@ create_modem (MMPlugin *self,
#if defined WITH_MBIM #if defined WITH_MBIM
if (mm_port_probe_list_has_mbim_port (probes)) { if (mm_port_probe_list_has_mbim_port (probes)) {
mm_dbg ("MBIM-powered Huawei modem found..."); mm_obj_dbg (self, "MBIM-powered Huawei modem found...");
return MM_BASE_MODEM (mm_broadband_modem_mbim_new (uid, return MM_BASE_MODEM (mm_broadband_modem_mbim_new (uid,
drivers, drivers,
mm_plugin_get_name (self), mm_plugin_get_name (self),
@@ -566,10 +571,10 @@ grab_port (MMPlugin *self,
gchar *str; gchar *str;
str = mm_port_serial_at_flag_build_string_from_mask (pflags); str = mm_port_serial_at_flag_build_string_from_mask (pflags);
mm_dbg ("(%s/%s) huawei port will have AT flags '%s'", mm_obj_dbg (self, "(%s/%s) huawei port will have AT flags '%s'",
mm_port_probe_get_port_subsys (probe), mm_port_probe_get_port_subsys (probe),
mm_port_probe_get_port_name (probe), mm_port_probe_get_port_name (probe),
str); str);
g_free (str); g_free (str);
} }

2
plugins/huawei/mm-sim-huawei.c
View File

@@ -25,7 +25,6 @@
#include <ModemManager.h> #include <ModemManager.h>
#define _LIBMM_INSIDE_MM #define _LIBMM_INSIDE_MM
#include <libmm-glib.h> #include <libmm-glib.h>
#include "mm-log.h"
#include "mm-modem-helpers.h" #include "mm-modem-helpers.h"
#include "mm-base-modem-at.h" #include "mm-base-modem-at.h"
@@ -105,7 +104,6 @@ load_sim_identifier (MMBaseSim *self,
MM_BASE_SIM_MODEM, &modem, MM_BASE_SIM_MODEM, &modem,
NULL); NULL);
mm_dbg ("loading (Huawei) SIM identifier...");
mm_base_modem_at_command ( mm_base_modem_at_command (
modem, modem,
"^ICCID?", "^ICCID?",

53
plugins/huawei/tests/test-modem-helpers-huawei.c
View File

@@ -22,7 +22,7 @@
#define _LIBMM_INSIDE_MM #define _LIBMM_INSIDE_MM
#include <libmm-glib.h> #include <libmm-glib.h>
#include "mm-log.h" #include "mm-log-object.h"
#include "mm-modem-helpers.h" #include "mm-modem-helpers.h"
#include "mm-modem-helpers-huawei.h" #include "mm-modem-helpers-huawei.h"
@@ -386,27 +386,21 @@ test_prefmode (void)
n_expected_combinations++; n_expected_combinations++;
} }
combinations = mm_huawei_parse_prefmode_test (prefmode_tests[i].str, &error); combinations = mm_huawei_parse_prefmode_test (prefmode_tests[i].str, NULL, &error);
g_assert_no_error (error); g_assert_no_error (error);
g_assert (combinations != NULL); g_assert (combinations != NULL);
g_assert_cmpuint (combinations->len, ==, n_expected_combinations); g_assert_cmpuint (combinations->len, ==, n_expected_combinations);
for (j = 0; j < combinations->len; j++) { for (j = 0; j < combinations->len; j++) {
MMHuaweiPrefmodeCombination *single; MMHuaweiPrefmodeCombination *single;
gchar *allowed_str; g_autofree gchar *allowed_str = NULL;
gchar *preferred_str; g_autofree gchar *preferred_str = NULL;
single = &g_array_index (combinations, MMHuaweiPrefmodeCombination, j); single = &g_array_index (combinations, MMHuaweiPrefmodeCombination, j);
allowed_str = mm_modem_mode_build_string_from_mask (single->allowed); allowed_str = mm_modem_mode_build_string_from_mask (single->allowed);
preferred_str = mm_modem_mode_build_string_from_mask (single->preferred); preferred_str = mm_modem_mode_build_string_from_mask (single->preferred);
mm_dbg ("Test[%u], Combination[%u]: %u, \"%s\", \"%s\"", mm_obj_dbg (NULL, "test[%u], combination[%u]: %u, \"%s\", \"%s\"",
i, i, j, single->prefmode, allowed_str, preferred_str);
j,
single->prefmode,
allowed_str,
preferred_str);
g_free (allowed_str);
g_free (preferred_str);
} }
for (j = 0; j < combinations->len; j++) { for (j = 0; j < combinations->len; j++) {
@@ -472,7 +466,7 @@ test_prefmode_response (void)
const MMHuaweiPrefmodeCombination *found; const MMHuaweiPrefmodeCombination *found;
GError *error = NULL; GError *error = NULL;
combinations = mm_huawei_parse_prefmode_test (prefmode_response_tests[i].format, NULL); combinations = mm_huawei_parse_prefmode_test (prefmode_response_tests[i].format, NULL, NULL);
g_assert (combinations != NULL); g_assert (combinations != NULL);
found = mm_huawei_parse_prefmode_response (prefmode_response_tests[i].str, found = mm_huawei_parse_prefmode_response (prefmode_response_tests[i].str,
@@ -622,28 +616,21 @@ test_syscfg (void)
n_expected_combinations++; n_expected_combinations++;
} }
combinations = mm_huawei_parse_syscfg_test (syscfg_tests[i].str, &error); combinations = mm_huawei_parse_syscfg_test (syscfg_tests[i].str, NULL, &error);
g_assert_no_error (error); g_assert_no_error (error);
g_assert (combinations != NULL); g_assert (combinations != NULL);
g_assert_cmpuint (combinations->len, ==, n_expected_combinations); g_assert_cmpuint (combinations->len, ==, n_expected_combinations);
for (j = 0; j < combinations->len; j++) { for (j = 0; j < combinations->len; j++) {
MMHuaweiSyscfgCombination *single; MMHuaweiSyscfgCombination *single;
gchar *allowed_str; g_autofree gchar *allowed_str = NULL;
gchar *preferred_str; g_autofree gchar *preferred_str = NULL;
single = &g_array_index (combinations, MMHuaweiSyscfgCombination, j); single = &g_array_index (combinations, MMHuaweiSyscfgCombination, j);
allowed_str = mm_modem_mode_build_string_from_mask (single->allowed); allowed_str = mm_modem_mode_build_string_from_mask (single->allowed);
preferred_str = mm_modem_mode_build_string_from_mask (single->preferred); preferred_str = mm_modem_mode_build_string_from_mask (single->preferred);
mm_dbg ("Test[%u], Combination[%u]: %u, %u, \"%s\", \"%s\"", mm_obj_dbg (NULL, "test[%u], combination[%u]: %u, %u, \"%s\", \"%s\"",
i, i, j, single->mode, single->acqorder, allowed_str, preferred_str);
j,
single->mode,
single->acqorder,
allowed_str,
preferred_str);
g_free (allowed_str);
g_free (preferred_str);
} }
for (j = 0; j < combinations->len; j++) { for (j = 0; j < combinations->len; j++) {
@@ -736,7 +723,7 @@ test_syscfg_response (void)
const MMHuaweiSyscfgCombination *found; const MMHuaweiSyscfgCombination *found;
GError *error = NULL; GError *error = NULL;
combinations = mm_huawei_parse_syscfg_test (syscfg_response_tests[i].format, NULL); combinations = mm_huawei_parse_syscfg_test (syscfg_response_tests[i].format, NULL, NULL);
g_assert (combinations != NULL); g_assert (combinations != NULL);
found = mm_huawei_parse_syscfg_response (syscfg_response_tests[i].str, found = mm_huawei_parse_syscfg_response (syscfg_response_tests[i].str,
@@ -896,20 +883,14 @@ test_syscfgex (void)
for (j = 0; j < combinations->len; j++) { for (j = 0; j < combinations->len; j++) {
MMHuaweiSyscfgexCombination *single; MMHuaweiSyscfgexCombination *single;
gchar *allowed_str; g_autofree gchar *allowed_str = NULL;
gchar *preferred_str; g_autofree gchar *preferred_str = NULL;
single = &g_array_index (combinations, MMHuaweiSyscfgexCombination, j); single = &g_array_index (combinations, MMHuaweiSyscfgexCombination, j);
allowed_str = mm_modem_mode_build_string_from_mask (single->allowed); allowed_str = mm_modem_mode_build_string_from_mask (single->allowed);
preferred_str = mm_modem_mode_build_string_from_mask (single->preferred); preferred_str = mm_modem_mode_build_string_from_mask (single->preferred);
mm_dbg ("Test[%u], Combination[%u]: \"%s\", \"%s\", \"%s\"", mm_obj_dbg (NULL, "test[%u], combination[%u]: \"%s\", \"%s\", \"%s\"",
i, i, j, single->mode_str, allowed_str, preferred_str);
j,
single->mode_str,
allowed_str,
preferred_str);
g_free (allowed_str);
g_free (preferred_str);
} }
for (j = 0; j < combinations->len; j++) { for (j = 0; j < combinations->len; j++) {