/* -*- 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) 2008 - 2009 Novell, Inc. * Copyright (C) 2009 - 2012 Red Hat, Inc. * Copyright (C) 2012 Aleksander Morgado */ #include #include #include #include #define _LIBMM_INSIDE_MM #include #include #include "mm-port-enums-types.h" #include "mm-log.h" #include "mm-plugin-common.h" #include "mm-broadband-modem-huawei.h" #include "mm-modem-helpers-huawei.h" #include "mm-huawei-enums-types.h" #if defined WITH_QMI #include "mm-broadband-modem-qmi.h" #endif #if defined WITH_MBIM #include "mm-broadband-modem-mbim.h" #endif #define MM_TYPE_PLUGIN_HUAWEI mm_plugin_huawei_get_type () MM_DEFINE_PLUGIN (HUAWEI, huawei, Huawei) /*****************************************************************************/ /* Custom init */ #define TAG_FIRST_INTERFACE_CONTEXT "first-interface-context" /* Maximum time to wait for the first interface 0 to appear and get probed. * If it doesn't appear in this time, we'll decide which will be considered the * first interface. */ #define MAX_WAIT_TIME 5 typedef struct { MMPortProbe *probe; gint first_usbif; guint timeout_id; gboolean custom_init_run; } FirstInterfaceContext; static void first_interface_context_free (FirstInterfaceContext *ctx) { if (ctx->timeout_id) g_source_remove (ctx->timeout_id); g_object_unref (ctx->probe); g_slice_free (FirstInterfaceContext, ctx); } #define TAG_GETPORTMODE_RESULT "getportmode-result" #define TAG_AT_PORT_FLAGS "at-port-flags" typedef struct { MMPortSerialAt *port; gboolean curc_done; guint curc_retries; gboolean getportmode_done; guint getportmode_retries; } HuaweiCustomInitContext; static void huawei_custom_init_context_free (HuaweiCustomInitContext *ctx) { g_object_unref (ctx->port); g_slice_free (HuaweiCustomInitContext, ctx); } static gboolean huawei_custom_init_finish (MMPortProbe *probe, GAsyncResult *result, GError **error) { return g_task_propagate_boolean (G_TASK (result), error); } static void huawei_custom_init_step (GTask *task); static void getportmode_ready (MMPortSerialAt *port, GAsyncResult *res, GTask *task) { MMDevice *device; MMPortProbe *probe; HuaweiCustomInitContext *ctx; g_autofree gchar *response = NULL; GArray *modes; g_autoptr(GError) error = NULL; probe = g_task_get_source_object (task); ctx = g_task_get_task_data (task); device = mm_port_probe_peek_device (probe); response = mm_port_serial_at_command_finish (port, res, &error); if (error) { mm_obj_dbg (probe, "couldn't get port mode: '%s'", error->message); /* If any error occurred that was not ERROR or COMMAND NOT SUPPORT then * retry the command. */ if (g_error_matches (error, MM_MOBILE_EQUIPMENT_ERROR, MM_MOBILE_EQUIPMENT_ERROR_UNKNOWN)) ctx->getportmode_done = TRUE; huawei_custom_init_step (task); return; } /* Mark port as being AT already */ mm_port_probe_set_result_at (probe, TRUE); /* Flag as GETPORTMODE already done */ ctx->getportmode_done = TRUE; modes = mm_huawei_parse_getportmode_response (response, probe, &error); if (!modes) mm_obj_warn (probe, "failed to parse ^GETPORTMODE response: %s", error->message); else g_object_set_data_full (G_OBJECT (device), TAG_GETPORTMODE_RESULT, modes, (GDestroyNotify) g_array_unref); huawei_custom_init_step (task); } static void curc_ready (MMPortSerialAt *port, GAsyncResult *res, GTask *task) { MMPortProbe *probe; HuaweiCustomInitContext *ctx; g_autoptr(GError) error = NULL; probe = g_task_get_source_object (task); ctx = g_task_get_task_data (task); mm_port_serial_at_command_finish (port, res, &error); if (error) { /* Retry if we get a timeout error */ if (g_error_matches (error, MM_SERIAL_ERROR, MM_SERIAL_ERROR_RESPONSE_TIMEOUT)) goto out; mm_obj_dbg (probe, "couldn't turn off unsolicited messages in secondary ports: %s", error->message); } mm_obj_dbg (probe, "unsolicited messages in secondary ports turned off"); ctx->curc_done = TRUE; out: huawei_custom_init_step (task); } static void try_next_usbif (MMPortProbe *probe, MMDevice *device) { FirstInterfaceContext *fi_ctx; GList *l; gint closest; fi_ctx = g_object_get_data (G_OBJECT (device), TAG_FIRST_INTERFACE_CONTEXT); g_assert (fi_ctx != NULL); /* Look for the next closest one among the list of interfaces in the device, * and enable that one as being first */ closest = G_MAXINT; for (l = mm_device_peek_port_probe_list (device); l; l = g_list_next (l)) { MMPortProbe *iter = MM_PORT_PROBE (l->data); /* Only expect ttys for next probing attempt */ if (g_str_equal (mm_port_probe_get_port_subsys (iter), "tty")) { gint usbif; usbif = mm_kernel_device_get_interface_number (mm_port_probe_peek_port (iter)); if (usbif == fi_ctx->first_usbif) { /* This is the one we just probed, which wasn't yet removed, so just skip it */ } else if (usbif > fi_ctx->first_usbif && usbif < closest) { closest = usbif; } } } if (closest == G_MAXINT) { /* No more ttys to try! Just return something */ closest = 0; mm_obj_dbg (probe, "no more ports to run initial probing"); } else mm_obj_dbg (probe, "will try initial probing with interface '%d' instead", closest); fi_ctx->first_usbif = closest; } static void huawei_custom_init_step (GTask *task) { MMPortProbe *probe; HuaweiCustomInitContext *ctx; FirstInterfaceContext *fi_ctx; MMKernelDevice *port; probe = g_task_get_source_object (task); ctx = g_task_get_task_data (task); /* If cancelled, end */ if (g_task_return_error_if_cancelled (task)) { mm_obj_dbg (probe, "no need to keep on running custom init"); g_object_unref (task); return; } if (!ctx->curc_done) { if (ctx->curc_retries == 0) { /* All retries consumed, probably not an AT port */ mm_port_probe_set_result_at (probe, FALSE); /* Try with next */ try_next_usbif (probe, mm_port_probe_peek_device (probe)); g_task_return_boolean (task, TRUE); g_object_unref (task); return; } ctx->curc_retries--; /* Turn off unsolicited messages on secondary ports until needed */ mm_port_serial_at_command ( ctx->port, "AT^CURC=0", 3, FALSE, /* raw */ FALSE, /* allow_cached */ g_task_get_cancellable (task), (GAsyncReadyCallback)curc_ready, task); return; } /* Try to get a port map from the modem */ 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_retries == 0) { g_task_return_boolean (task, TRUE); g_object_unref (task); return; } ctx->getportmode_retries--; mm_port_serial_at_command ( ctx->port, "AT^GETPORTMODE", 3, FALSE, /* raw */ FALSE, /* allow_cached */ g_task_get_cancellable (task), (GAsyncReadyCallback)getportmode_ready, task); return; } /* All done it seems */ fi_ctx = g_object_get_data (G_OBJECT (mm_port_probe_peek_device (probe)), TAG_FIRST_INTERFACE_CONTEXT); g_assert (fi_ctx != NULL); fi_ctx->custom_init_run = TRUE; g_task_return_boolean (task, TRUE); g_object_unref (task); } static gboolean first_interface_missing_timeout_cb (MMDevice *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... * which is anyway very unlikely as we got it by looking at the real probe list, but anyway... */ return G_SOURCE_CONTINUE; } static void huawei_custom_init (MMPortProbe *probe, MMPortSerialAt *port, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { MMDevice *device; FirstInterfaceContext *fi_ctx; HuaweiCustomInitContext *ctx; GTask *task; device = mm_port_probe_peek_device (probe); /* The primary port (called the "modem" port in the Windows drivers) is * always USB interface 0, and we need to detect that interface first for * two reasons: (1) to disable unsolicited messages on other ports that * may fill up the buffer and crash the device, and (2) to attempt to get * the port layout for hints about what the secondary port is (called the * "pcui" port in Windows). Thus we probe USB interface 0 first and defer * probing other interfaces until we've got if0, at which point we allow * the other ports to be probed too. */ fi_ctx = g_object_get_data (G_OBJECT (device), TAG_FIRST_INTERFACE_CONTEXT); if (!fi_ctx) { /* This is the first time we ask for the context. Set it up. */ fi_ctx = g_slice_new0 (FirstInterfaceContext); fi_ctx->probe = g_object_ref (probe); g_object_set_data_full (G_OBJECT (device), TAG_FIRST_INTERFACE_CONTEXT, fi_ctx, (GDestroyNotify)first_interface_context_free); /* The timeout is controlled in the data set in 'device', and therefore * it should be safe to assume that the timeout will not get fired after * having disposed 'device' */ fi_ctx->timeout_id = g_timeout_add_seconds (MAX_WAIT_TIME, (GSourceFunc)first_interface_missing_timeout_cb, device); /* By default, we'll ask the Huawei plugin to start probing usbif 0 */ fi_ctx->first_usbif = 0; /* Custom init of the Huawei plugin is to be run only in the first * interface. We'll control here whether we did run it already or not. */ fi_ctx->custom_init_run = FALSE; } ctx = g_slice_new (HuaweiCustomInitContext); ctx->port = g_object_ref (port); ctx->curc_done = FALSE; ctx->curc_retries = 3; ctx->getportmode_done = FALSE; ctx->getportmode_retries = 3; task = g_task_new (probe, cancellable, callback, user_data); g_task_set_task_data (task, ctx, (GDestroyNotify)huawei_custom_init_context_free); /* Custom init only to be run in the first interface */ if (mm_kernel_device_get_interface_number (mm_port_probe_peek_port (probe)) != fi_ctx->first_usbif) { if (fi_ctx->custom_init_run) /* If custom init was run already, we can consider this as successfully run */ g_task_return_boolean (task, TRUE); else /* Otherwise, we'll need to defer the probing a bit more */ g_task_return_new_error (task, MM_CORE_ERROR, MM_CORE_ERROR_RETRY, "Defer needed"); g_object_unref (task); return; } /* We can run custom init in the first interface! clear the timeout as it is no longer needed */ if (fi_ctx->timeout_id) { g_source_remove (fi_ctx->timeout_id); fi_ctx->timeout_id = 0; } huawei_custom_init_step (task); } /*****************************************************************************/ static gint probe_cmp_by_usbif (MMPortProbe *a, MMPortProbe *b) { return (mm_kernel_device_get_interface_number (mm_port_probe_peek_port (a)) - mm_kernel_device_get_interface_number (mm_port_probe_peek_port (b))); } static guint propagate_getportmode_hints (MMPlugin *self, GList *probes, gboolean *primary_flagged) { MMDevice *device; GArray *modes; GList *l; GList *tty_probes = NULL; guint n_ports_with_hints = 0; guint mode_i = 0; g_assert (probes != NULL); device = mm_port_probe_peek_device (MM_PORT_PROBE (probes->data)); modes = g_object_get_data (G_OBJECT (device), TAG_GETPORTMODE_RESULT); /* Nothing to do if GETPORTMODE is flagged as not supported */ if (!modes) return 0; /* Build a list of TTY port probes (AT and not-AT) sorted by interface number */ for (l = probes; l; l = g_list_next (l)) { MMPortProbe *probe; probe = MM_PORT_PROBE (l->data); if (g_str_equal (mm_port_probe_get_port_subsys (probe), "tty")) tty_probes = g_list_insert_sorted (tty_probes, probe, (GCompareFunc) probe_cmp_by_usbif); } /* Propagate the getportmode tags to the specific port probes */ for (l = tty_probes, mode_i = 0; l; l = g_list_next (l)) { MMPortProbe *probe; MMPortSerialAtFlag at_port_flags = MM_PORT_SERIAL_AT_FLAG_NONE; MMHuaweiPortMode port_mode; probe = MM_PORT_PROBE (l->data); /* Look for the next serial port mode applicable */ while (!MM_HUAWEI_PORT_MODE_IS_SERIAL (g_array_index (modes, MMHuaweiPortMode, mode_i)) && (mode_i < modes->len)) mode_i++; if (mode_i == modes->len) { mm_obj_dbg (probe, "missing port mode hint"); continue; } port_mode = g_array_index (modes, MMHuaweiPortMode, mode_i); if (!mm_port_probe_is_at (probe)) { mm_obj_dbg (probe, "port mode hint for non-AT port: %s", mm_huawei_port_mode_get_string (port_mode)); mode_i++; continue; } mm_obj_dbg (probe, "port mode hint for AT port: %s", mm_huawei_port_mode_get_string (port_mode)); if (port_mode == MM_HUAWEI_PORT_MODE_PCUI) at_port_flags = MM_PORT_SERIAL_AT_FLAG_PRIMARY; else if (port_mode == MM_HUAWEI_PORT_MODE_MODEM) at_port_flags = MM_PORT_SERIAL_AT_FLAG_PPP; if (at_port_flags != MM_PORT_SERIAL_AT_FLAG_NONE) { n_ports_with_hints++; g_object_set_data (G_OBJECT (probe), TAG_AT_PORT_FLAGS, GUINT_TO_POINTER (at_port_flags)); } mode_i++; } g_list_free (tty_probes); return n_ports_with_hints; } static guint propagate_description_hints (MMPlugin *self, GList *probes, gboolean *primary_flagged) { GList *l; guint n_ports_with_hints = 0; for (l = probes; l; l = g_list_next (l)) { MMPortProbe *probe; MMPortSerialAtFlag at_port_flags = MM_PORT_SERIAL_AT_FLAG_NONE; const gchar *description; g_autofree gchar *lower_description = NULL; probe = MM_PORT_PROBE (l->data); if (!mm_port_probe_is_at (probe)) continue; description = mm_kernel_device_get_interface_description (mm_port_probe_peek_port (probe)); if (!description) continue; mm_obj_dbg (probe, "%s interface description: %s", mm_port_probe_get_port_name (probe), description); lower_description = g_ascii_strdown (description, -1); if (strstr (lower_description, "modem")) at_port_flags = MM_PORT_SERIAL_AT_FLAG_PPP; else if (strstr (lower_description, "pcui")) { at_port_flags = MM_PORT_SERIAL_AT_FLAG_PRIMARY; *primary_flagged = TRUE; } if (at_port_flags != MM_PORT_SERIAL_AT_FLAG_NONE) { n_ports_with_hints++; g_object_set_data (G_OBJECT (probe), TAG_AT_PORT_FLAGS, GUINT_TO_POINTER (at_port_flags)); } } return n_ports_with_hints; } static guint propagate_generic_hints (MMPlugin *self, GList *probes, gboolean *primary_flagged) { GList *l; guint n_ports_with_hints = 0; for (l = probes; l; l = g_list_next (l)) { MMPortProbe *probe; MMKernelDevice *kernel_device; MMPortSerialAtFlag at_port_flags = MM_PORT_SERIAL_AT_FLAG_NONE; probe = MM_PORT_PROBE (l->data); if (!mm_port_probe_is_at (probe)) continue; kernel_device = mm_port_probe_peek_port (probe); if (mm_kernel_device_get_property_as_boolean (kernel_device, ID_MM_PORT_TYPE_AT_PRIMARY)) { at_port_flags = MM_PORT_SERIAL_AT_FLAG_PRIMARY; *primary_flagged = TRUE; } else if (mm_kernel_device_get_property_as_boolean (kernel_device, ID_MM_PORT_TYPE_AT_SECONDARY)) at_port_flags = MM_PORT_SERIAL_AT_FLAG_SECONDARY; else if (mm_kernel_device_get_property_as_boolean (kernel_device, ID_MM_PORT_TYPE_AT_PPP)) at_port_flags = MM_PORT_SERIAL_AT_FLAG_PPP; if (at_port_flags != MM_PORT_SERIAL_AT_FLAG_NONE) { n_ports_with_hints++; g_object_set_data (G_OBJECT (probe), TAG_AT_PORT_FLAGS, GUINT_TO_POINTER (at_port_flags)); } } return n_ports_with_hints; } static guint fallback_primary_cdcwdm (MMPlugin *self, GList *probes) { GList *l; for (l = probes; l; l = g_list_next (l)) { MMPortProbe *probe; probe = MM_PORT_PROBE (l->data); if (!mm_port_probe_is_at (probe)) continue; if (g_str_equal (mm_port_probe_get_port_subsys (probe), "usbmisc")) { mm_obj_dbg (self, "fallback port type hint applied to first cdc-wmd port found"); g_object_set_data (G_OBJECT (probe), TAG_AT_PORT_FLAGS, GUINT_TO_POINTER (MM_PORT_SERIAL_AT_FLAG_PRIMARY)); return 1; } } return 0; } static guint fallback_usbif0 (MMPlugin *self, GList *probes) { GList *l; for (l = probes; l; l = g_list_next (l)) { MMPortProbe *probe; guint usbif; probe = MM_PORT_PROBE (l->data); if (!mm_port_probe_is_at (probe)) continue; usbif = mm_kernel_device_get_property_as_int_hex (mm_port_probe_peek_port (probe), "ID_USB_INTERFACE_NUM"); if (usbif == 0) { mm_obj_dbg (self, "fallback port type hint applied to interface 0"); g_object_set_data (G_OBJECT (probe), TAG_AT_PORT_FLAGS, GUINT_TO_POINTER (MM_PORT_SERIAL_AT_FLAG_PPP)); return 1; } } return 0; } static void propagate_port_type_hints (MMPlugin *self, GList *probes) { gboolean primary_flagged = FALSE; guint n_ports_with_hints; g_assert (probes != NULL); if ((n_ports_with_hints = propagate_getportmode_hints (self, probes, &primary_flagged)) > 0) mm_obj_dbg (self, "port type hints set by GETPORTMODE"); else if ((n_ports_with_hints = propagate_description_hints (self, probes, &primary_flagged)) > 0) mm_obj_dbg (self, "port type hints set by interface descriptions"); else if ((n_ports_with_hints = propagate_generic_hints (self, probes, &primary_flagged)) > 0) mm_obj_dbg (self, "port type hints set by generic udev tags"); /* Fallback hint for the first cdc-wdm port if no other port has been flagged as primary */ if (!primary_flagged) n_ports_with_hints += fallback_primary_cdcwdm (self, probes); /* If not a single port type hint available (not plugin-provided and not generic) * then we'll assume usbif 0 is the modem port */ if (!n_ports_with_hints) n_ports_with_hints = fallback_usbif0 (self, probes); mm_obj_dbg (self, "%u port hints have been set", n_ports_with_hints); } static MMBaseModem * create_modem (MMPlugin *self, const gchar *uid, const gchar *physdev, const gchar **drivers, guint16 vendor, guint16 product, guint16 subsystem_vendor, GList *probes, GError **error) { propagate_port_type_hints (self, probes); #if defined WITH_QMI if (mm_port_probe_list_has_qmi_port (probes)) { mm_obj_dbg (self, "QMI-powered Huawei modem found..."); return MM_BASE_MODEM (mm_broadband_modem_qmi_new (uid, physdev, drivers, mm_plugin_get_name (self), vendor, product)); } #endif #if defined WITH_MBIM if (mm_port_probe_list_has_mbim_port (probes)) { mm_obj_dbg (self, "MBIM-powered Huawei modem found..."); return MM_BASE_MODEM (mm_broadband_modem_mbim_new (uid, physdev, drivers, mm_plugin_get_name (self), vendor, product)); } #endif return MM_BASE_MODEM (mm_broadband_modem_huawei_new (uid, physdev, drivers, mm_plugin_get_name (self), vendor, product)); } static gboolean grab_port (MMPlugin *self, MMBaseModem *modem, MMPortProbe *probe, GError **error) { MMPortSerialAtFlag pflags; MMKernelDevice *port; MMPortType port_type; port_type = mm_port_probe_get_port_type (probe); port = mm_port_probe_peek_port (probe); pflags = (MMPortSerialAtFlag) GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (probe), TAG_AT_PORT_FLAGS)); if (pflags != MM_PORT_SERIAL_AT_FLAG_NONE) { gchar *str; str = mm_port_serial_at_flag_build_string_from_mask (pflags); mm_obj_dbg (self, "(%s/%s) port will have AT flags '%s'", mm_port_probe_get_port_subsys (probe), mm_port_probe_get_port_name (probe), str); g_free (str); } else { /* The huawei plugin handles the generic udev tags itself, so explicitly request * to avoid processing them by the generic modem. */ pflags = MM_PORT_SERIAL_AT_FLAG_NONE_NO_GENERIC; } return mm_base_modem_grab_port (modem, port, port_type, pflags, error); } /*****************************************************************************/ MM_PLUGIN_NAMED_CREATOR_SCOPE MMPlugin * mm_plugin_create_huawei (void) { static const gchar *subsystems[] = { "tty", "net", "usbmisc", NULL }; static const guint16 vendor_ids[] = { 0x12d1, 0 }; static const MMAsyncMethod custom_init = { .async = G_CALLBACK (huawei_custom_init), .finish = G_CALLBACK (huawei_custom_init_finish), }; return MM_PLUGIN ( g_object_new (MM_TYPE_PLUGIN_HUAWEI, MM_PLUGIN_NAME, MM_MODULE_NAME, MM_PLUGIN_ALLOWED_SUBSYSTEMS, subsystems, MM_PLUGIN_ALLOWED_VENDOR_IDS, vendor_ids, MM_PLUGIN_ALLOWED_AT, TRUE, MM_PLUGIN_REQUIRED_QCDM, TRUE, MM_PLUGIN_ALLOWED_QMI, TRUE, MM_PLUGIN_ALLOWED_MBIM, TRUE, MM_PLUGIN_CUSTOM_INIT, &custom_init, NULL)); } static void mm_plugin_huawei_init (MMPluginHuawei *self) { } static void mm_plugin_huawei_class_init (MMPluginHuaweiClass *klass) { MMPluginClass *plugin_class = MM_PLUGIN_CLASS (klass); plugin_class->create_modem = create_modem; plugin_class->grab_port = grab_port; }