/* -*- 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 - 2011 Red Hat, Inc. * Copyright (C) 2011 Google, Inc. */ #include #include #include #include #include #include #include #include #include #include "mm-context.h" #include "mm-base-modem.h" #if defined WITH_QRTR #include "mm-kernel-device-qrtr.h" #endif #include "mm-log-object.h" #include "mm-port-enums-types.h" #include "mm-serial-parsers.h" #include "mm-modem-helpers.h" static void log_object_iface_init (MMLogObjectInterface *iface); G_DEFINE_ABSTRACT_TYPE_WITH_CODE (MMBaseModem, mm_base_modem, MM_GDBUS_TYPE_OBJECT_SKELETON, G_IMPLEMENT_INTERFACE (MM_TYPE_LOG_OBJECT, log_object_iface_init)) /* If we get 10 consecutive timeouts in a serial port, we consider the modem * invalid and we request re-probing. */ #define DEFAULT_MAX_TIMEOUTS 10 enum { PROP_0, PROP_VALID, PROP_MAX_TIMEOUTS, PROP_DEVICE, PROP_PHYSDEV, PROP_DRIVERS, PROP_PLUGIN, PROP_VENDOR_ID, PROP_PRODUCT_ID, PROP_SUBSYSTEM_VENDOR_ID, PROP_CONNECTION, PROP_REPROBE, PROP_DATA_NET_SUPPORTED, PROP_DATA_TTY_SUPPORTED, PROP_LAST }; enum { SIGNAL_LINK_PORT_GRABBED, SIGNAL_LINK_PORT_RELEASED, SIGNAL_LAST }; static GParamSpec *properties[PROP_LAST]; static guint signals[SIGNAL_LAST]; struct _MMBaseModemPrivate { /* The connection to the system bus */ GDBusConnection *connection; guint dbus_id; /* Modem-wide cancellable. If it ever gets cancelled, no further operations * should be done by the modem. */ GCancellable *cancellable; gulong invalid_if_cancelled; gchar *device; gchar *physdev; gchar **drivers; gchar *plugin; guint vendor_id; guint product_id; guint subsystem_vendor_id; gboolean hotplugged; gboolean valid; gboolean reprobe; guint max_timeouts; /* The authorization provider */ MMAuthProvider *authp; GCancellable *authp_cancellable; GHashTable *ports; MMPortSerialAt *primary; MMPortSerialAt *secondary; MMPortSerialQcdm *qcdm; GList *data; gboolean data_net_supported; gboolean data_tty_supported; /* GPS-enabled modems will have an AT port for control, and a raw serial * port to receive all GPS traces */ MMPortSerialAt *gps_control; MMPortSerialGps *gps; /* Some audio-capable devices will have a port for audio specifically */ MMPortSerial *audio; /* Support for parallel enable/disable operations */ GList *enable_tasks; GList *disable_tasks; #if defined WITH_QMI /* QMI ports */ GList *qmi; #endif #if defined WITH_MBIM /* MBIM ports */ GList *mbim; #endif /* Additional port links grabbed after having * organized ports */ GHashTable *link_ports; }; guint mm_base_modem_get_dbus_id (MMBaseModem *self) { return self->priv->dbus_id; } /******************************************************************************/ static void port_removed_cb (MMPort *port, MMBaseModem *self) { /* We have to do a full re-probe here because simply reopening the device * and restarting proxy would leave us without proper notifications. */ mm_obj_msg (self, "port '%s' no longer controllable, reprobing", mm_port_get_device (MM_PORT (port))); self->priv->reprobe = TRUE; g_cancellable_cancel (self->priv->cancellable); } static void port_timed_out_cb (MMPort *port, guint n_consecutive_timeouts, MMBaseModem *self) { /* If reached the maximum number of timeouts, invalidate modem */ if (n_consecutive_timeouts >= self->priv->max_timeouts) { mm_obj_err (self, "port %s timed out %u consecutive times, marking modem as invalid", mm_port_get_device (MM_PORT (port)), n_consecutive_timeouts); g_cancellable_cancel (self->priv->cancellable); return; } if (n_consecutive_timeouts > 1) mm_obj_warn (self, "port %s timed out %u consecutive times", mm_port_get_device (MM_PORT (port)), n_consecutive_timeouts); } static MMPort * base_modem_create_ignored_port (MMBaseModem *self, const gchar *name) { return MM_PORT (g_object_new (MM_TYPE_PORT, MM_PORT_DEVICE, name, MM_PORT_TYPE, MM_PORT_TYPE_IGNORED, NULL)); } static MMPort * base_modem_create_net_port (MMBaseModem *self, const gchar *name) { return MM_PORT (mm_port_net_new (name)); } static MMPort * base_modem_create_tty_port (MMBaseModem *self, const gchar *name, MMKernelDevice *kernel_device, MMPortType ptype) { MMPort *port = NULL; const gchar *flow_control_tag; if (ptype == MM_PORT_TYPE_QCDM) port = MM_PORT (mm_port_serial_qcdm_new (name, MM_PORT_SUBSYS_TTY)); else if (ptype == MM_PORT_TYPE_GPS) port = MM_PORT (mm_port_serial_gps_new (name)); else if (ptype == MM_PORT_TYPE_AUDIO) port = MM_PORT (mm_port_serial_new (name, ptype)); else if (ptype == MM_PORT_TYPE_AT) port = MM_PORT (mm_port_serial_at_new (name, MM_PORT_SUBSYS_TTY)); if (!port) return NULL; /* Optional user-provided baudrate */ if (mm_kernel_device_has_property (kernel_device, ID_MM_TTY_BAUDRATE)) g_object_set (port, MM_PORT_SERIAL_BAUD, mm_kernel_device_get_property_as_int (kernel_device, ID_MM_TTY_BAUDRATE), NULL); /* Optional user-provided flow control */ flow_control_tag = mm_kernel_device_get_property (kernel_device, ID_MM_TTY_FLOW_CONTROL); if (flow_control_tag) { MMFlowControl flow_control; g_autoptr(GError) inner_error = NULL; flow_control = mm_flow_control_from_string (flow_control_tag, &inner_error); if (flow_control != MM_FLOW_CONTROL_UNKNOWN) g_object_set (port, MM_PORT_SERIAL_FLOW_CONTROL, flow_control, NULL); else mm_obj_warn (self, "unsupported flow control settings in port %s: %s", name, inner_error->message); } return port; } static MMPort * base_modem_create_usbmisc_port (MMBaseModem *self, const gchar *name, MMPortType ptype) { #if defined WITH_QMI if (ptype == MM_PORT_TYPE_QMI) return MM_PORT (mm_port_qmi_new (name, MM_PORT_SUBSYS_USBMISC)); #endif #if defined WITH_MBIM if (ptype == MM_PORT_TYPE_MBIM) return MM_PORT (mm_port_mbim_new (name, MM_PORT_SUBSYS_USBMISC)); #endif if (ptype == MM_PORT_TYPE_AT) return MM_PORT (mm_port_serial_at_new (name, MM_PORT_SUBSYS_USBMISC)); return NULL; } static MMPort * base_modem_create_rpmsg_port (MMBaseModem *self, const gchar *name, MMPortType ptype) { #if defined WITH_QMI if (ptype == MM_PORT_TYPE_QMI) return MM_PORT (mm_port_qmi_new (name, MM_PORT_SUBSYS_RPMSG)); #endif if (ptype == MM_PORT_TYPE_AT) return MM_PORT (mm_port_serial_at_new (name, MM_PORT_SUBSYS_RPMSG)); return NULL; } #if defined WITH_QRTR static MMPort * base_modem_create_qrtr_port (MMBaseModem *self, const gchar *name, MMKernelDevice *kernel_device, MMPortType ptype) { if (ptype == MM_PORT_TYPE_QMI) { g_autoptr(QrtrNode) node = NULL; g_assert (MM_IS_KERNEL_DEVICE_QRTR (kernel_device)); node = mm_kernel_device_qrtr_get_node (MM_KERNEL_DEVICE_QRTR (kernel_device)); return MM_PORT (mm_port_qmi_new_from_node (name, node)); } return NULL; } #endif static MMPort * base_modem_create_wwan_port (MMBaseModem *self, const gchar *name, MMPortType ptype) { #if defined WITH_QMI if (ptype == MM_PORT_TYPE_QMI) return MM_PORT (mm_port_qmi_new (name, MM_PORT_SUBSYS_WWAN)); #endif #if defined WITH_MBIM if (ptype == MM_PORT_TYPE_MBIM) return MM_PORT (mm_port_mbim_new (name, MM_PORT_SUBSYS_WWAN)); #endif if (ptype == MM_PORT_TYPE_QCDM) return MM_PORT (mm_port_serial_qcdm_new (name, MM_PORT_SUBSYS_WWAN)); if (ptype == MM_PORT_TYPE_AT) return MM_PORT (mm_port_serial_at_new (name, MM_PORT_SUBSYS_WWAN)); return NULL; } static MMPort * base_modem_create_virtual_port (MMBaseModem *self, const gchar *name) { return MM_PORT (mm_port_serial_at_new (name, MM_PORT_SUBSYS_UNIX)); } static MMPort * base_modem_internal_grab_port (MMBaseModem *self, MMKernelDevice *kernel_device, gboolean link_port, MMPortType ptype, MMPortSerialAtFlag at_pflags, GError **error) { MMPort *port; const gchar *subsys; const gchar *name; g_autofree gchar *key = NULL; gboolean port_monitoring = FALSE; subsys = mm_kernel_device_get_subsystem (kernel_device); name = mm_kernel_device_get_name (kernel_device); if (!self->priv->ports || (link_port && !self->priv->link_ports)) { g_set_error (error, MM_CORE_ERROR, MM_CORE_ERROR_FAILED, "Cannot add port '%s/%s', no ports table", subsys, name); return NULL; } /* Check whether we already have it stored */ key = g_strdup_printf ("%s%s", subsys, name); port = g_hash_table_lookup (self->priv->ports, key); if (port) { g_set_error (error, MM_CORE_ERROR, MM_CORE_ERROR_UNSUPPORTED, "Cannot add port '%s/%s', already exists", subsys, name); return NULL; } /* Explicitly ignored ports, grab them but explicitly flag them as ignored * right away, all the same way (i.e. regardless of subsystem). */ if (ptype == MM_PORT_TYPE_IGNORED) port = base_modem_create_ignored_port (self, name); else if (g_str_equal (subsys, "net")) port = base_modem_create_net_port (self, name); else if (g_str_equal (subsys, "tty")) port = base_modem_create_tty_port (self, name, kernel_device, ptype); else if (g_str_equal (subsys, "usbmisc")) port = base_modem_create_usbmisc_port (self, name, ptype); else if (g_str_equal (subsys, "rpmsg")) port = base_modem_create_rpmsg_port (self, name, ptype); #if defined WITH_QRTR else if (g_str_equal (subsys, "qrtr")) port = base_modem_create_qrtr_port (self, name, kernel_device, ptype); #endif else if (g_str_equal (subsys, "virtual")) port = base_modem_create_virtual_port (self, name); else if (g_str_equal (subsys, "wwan")) port = base_modem_create_wwan_port (self, name, ptype); if (!port) { g_set_error (error, MM_CORE_ERROR, MM_CORE_ERROR_UNSUPPORTED, "Cannot add port '%s/%s', unhandled port type", subsys, name); return NULL; } /* Setup consecutive ports and removal watchers in all control ports */ if (MM_IS_PORT_SERIAL_AT (port)) { mm_obj_dbg (port, "port monitoring enabled in AT port"); port_monitoring = TRUE; } else if (MM_IS_PORT_SERIAL_QCDM (port)) { mm_obj_dbg (port, "port monitoring enabled in QCDM port"); port_monitoring = TRUE; } #if defined WITH_QMI else if (MM_IS_PORT_QMI (port)) { mm_obj_dbg (port, "port monitoring enabled in QMI port"); port_monitoring = TRUE; } #endif #if defined WITH_MBIM else if (MM_IS_PORT_MBIM (port)) { mm_obj_dbg (port, "port monitoring enabled in MBIM port"); port_monitoring = TRUE; } #endif if (port_monitoring) { if (self->priv->max_timeouts > 0) g_signal_connect (port, MM_PORT_SIGNAL_TIMED_OUT, G_CALLBACK (port_timed_out_cb), self); g_signal_connect (port, MM_PORT_SIGNAL_REMOVED, G_CALLBACK (port_removed_cb), self); } /* Store kernel device */ g_object_set (port, MM_PORT_KERNEL_DEVICE, kernel_device, NULL); /* Set owner ID */ mm_log_object_set_owner_id (MM_LOG_OBJECT (port), mm_log_object_get_id (MM_LOG_OBJECT (self))); /* Common setup for all AT ports from all subsystems */ if (MM_IS_PORT_SERIAL_AT (port)) { mm_port_serial_at_set_response_parser (MM_PORT_SERIAL_AT (port), mm_serial_parser_v1_parse, mm_serial_parser_v1_new (), mm_serial_parser_v1_destroy); /* Prefer plugin-provided flags to the generic ones */ if (at_pflags == MM_PORT_SERIAL_AT_FLAG_NONE) { if (mm_kernel_device_get_property_as_boolean (kernel_device, ID_MM_PORT_TYPE_AT_PRIMARY)) { mm_obj_dbg (port, "AT port flagged as primary"); at_pflags = MM_PORT_SERIAL_AT_FLAG_PRIMARY; } else if (mm_kernel_device_get_property_as_boolean (kernel_device, ID_MM_PORT_TYPE_AT_SECONDARY)) { mm_obj_dbg (port, "AT port flagged as secondary"); at_pflags = MM_PORT_SERIAL_AT_FLAG_SECONDARY; } else if (mm_kernel_device_get_property_as_boolean (kernel_device, ID_MM_PORT_TYPE_AT_PPP)) { mm_obj_dbg (port, "AT port flagged as PPP"); at_pflags = MM_PORT_SERIAL_AT_FLAG_PPP; } /* Additionally, the ports may also be flagged as GPS control explicitly, if there is * one specific port to be used for that purpose */ if (mm_kernel_device_get_property_as_boolean (kernel_device, ID_MM_PORT_TYPE_AT_GPS_CONTROL)) { mm_obj_dbg (port, "AT port flagged as GPS control"); at_pflags = MM_PORT_SERIAL_AT_FLAG_GPS_CONTROL; } } /* The plugin may specify NONE_NO_GENERIC to avoid the generic * port type hints from being applied. */ if (at_pflags == MM_PORT_SERIAL_AT_FLAG_NONE_NO_GENERIC) at_pflags = MM_PORT_SERIAL_AT_FLAG_NONE; mm_port_serial_at_set_flags (MM_PORT_SERIAL_AT (port), at_pflags); } /* Add it to the tracking HT. * Note: 'key' and 'port' now owned by the HT. */ if (link_port) g_hash_table_insert (self->priv->link_ports, g_steal_pointer (&key), port); else g_hash_table_insert (self->priv->ports, g_steal_pointer (&key), port); return port; } gboolean mm_base_modem_grab_port (MMBaseModem *self, MMKernelDevice *kernel_device, MMPortType ptype, MMPortSerialAtFlag at_pflags, GError **error) { g_autoptr(GError) inner_error = NULL; if (!base_modem_internal_grab_port (self, kernel_device, FALSE, ptype, at_pflags, &inner_error)) { /* If the port was REQUIRED via udev tags and we failed to grab it, we will report * a fatal error. */ if (mm_kernel_device_get_property_as_boolean (kernel_device, ID_MM_REQUIRED)) { mm_obj_err (self, "required port '%s/%s' failed to be grabbed", mm_kernel_device_get_subsystem (kernel_device), mm_kernel_device_get_name (kernel_device)); g_set_error (error, MM_CORE_ERROR, MM_CORE_ERROR_ABORTED, "Required port failed to be grabbed"); } else g_propagate_error (error, g_steal_pointer (&inner_error)); return FALSE; } mm_obj_dbg (self, "port '%s/%s' grabbed", mm_kernel_device_get_subsystem (kernel_device), mm_kernel_device_get_name (kernel_device)); return TRUE; } /******************************************************************************/ gboolean mm_base_modem_grab_link_port (MMBaseModem *self, MMKernelDevice *kernel_device, GError **error) { const gchar *subsystem; const gchar *name; MMPort *port; /* To simplify things, we only support NET link ports at this point */ subsystem = mm_kernel_device_get_subsystem (kernel_device); name = mm_kernel_device_get_name (kernel_device); if (!g_str_equal (subsystem, "net")) { g_set_error (error, MM_CORE_ERROR, MM_CORE_ERROR_UNSUPPORTED, "Cannot add port '%s/%s', unexpected link port subsystem", subsystem, name); return FALSE; } /* all the newly added link ports will NOT be 'organized'; i.e. they won't * be available as 'data ports' in the modem, but they can be looked up * by name */ port = base_modem_internal_grab_port (self, kernel_device, TRUE, MM_PORT_TYPE_NET, MM_PORT_SERIAL_AT_FLAG_NONE, error); if (!port) return FALSE; mm_obj_dbg (self, "link port '%s/%s' grabbed", subsystem, name); g_signal_emit (self, signals[SIGNAL_LINK_PORT_GRABBED], 0, port); return TRUE; } gboolean mm_base_modem_release_link_port (MMBaseModem *self, const gchar *subsystem, const gchar *name, GError **error) { g_autofree gchar *key = NULL; MMPort *port; if (!self->priv->link_ports) { g_set_error (error, MM_CORE_ERROR, MM_CORE_ERROR_FAILED, "Cannot release link port '%s/%s', no link ports table", subsystem, name); return FALSE; } key = g_strdup_printf ("%s%s", subsystem, name); port = g_hash_table_lookup (self->priv->link_ports, key); if (!port) { g_set_error (error, MM_CORE_ERROR, MM_CORE_ERROR_UNSUPPORTED, "Cannot release link port '%s/%s', not grabbed", subsystem, name); return FALSE; } /* make sure the port object is valid during the port release signal */ g_object_ref (port); g_hash_table_remove (self->priv->link_ports, key); mm_obj_dbg (self, "link port '%s/%s' released", subsystem, name); g_signal_emit (self, signals[SIGNAL_LINK_PORT_RELEASED], 0, port); g_object_unref (port); return TRUE; } /******************************************************************************/ typedef struct { gchar *name; gulong link_port_grabbed_id; guint timeout_id; } WaitLinkPortContext; static void wait_link_port_context_free (WaitLinkPortContext *ctx) { g_assert (!ctx->link_port_grabbed_id); g_assert (!ctx->timeout_id); g_free (ctx->name); g_slice_free (WaitLinkPortContext, ctx); } MMPort * mm_base_modem_wait_link_port_finish (MMBaseModem *self, GAsyncResult *res, GError **error) { return g_task_propagate_pointer (G_TASK (res), error); } static gboolean wait_link_port_timeout_cb (GTask *task) { WaitLinkPortContext *ctx; MMBaseModem *self; self = g_task_get_source_object (task); ctx = g_task_get_task_data (task); ctx->timeout_id = 0; g_signal_handler_disconnect (self, ctx->link_port_grabbed_id); ctx->link_port_grabbed_id = 0; g_task_return_new_error (task, MM_CORE_ERROR, MM_CORE_ERROR_NOT_FOUND, "Timed out waiting for link port 'net/%s'", ctx->name); g_object_unref (task); return G_SOURCE_REMOVE; } static void wait_link_port_grabbed_cb (MMBaseModem *self, MMPort *link_port, GTask *task) { WaitLinkPortContext *ctx; MMPortSubsys link_port_subsystem; const gchar *link_port_name; ctx = g_task_get_task_data (task); link_port_subsystem = mm_port_get_subsys (link_port); link_port_name = mm_port_get_device (link_port); if (link_port_subsystem != MM_PORT_SUBSYS_NET) { mm_obj_warn (self, "unexpected link port subsystem grabbed: %s/%s", mm_port_subsys_get_string (link_port_subsystem), link_port_name); return; } if (g_strcmp0 (link_port_name, ctx->name) != 0) return; /* we got it! */ g_source_remove (ctx->timeout_id); ctx->timeout_id = 0; g_signal_handler_disconnect (self, ctx->link_port_grabbed_id); ctx->link_port_grabbed_id = 0; g_task_return_pointer (task, g_object_ref (link_port), g_object_unref); g_object_unref (task); } void mm_base_modem_wait_link_port (MMBaseModem *self, const gchar *subsystem, const gchar *name, guint timeout_ms, GAsyncReadyCallback callback, gpointer user_data) { WaitLinkPortContext *ctx; GTask *task; g_autofree gchar *key = NULL; MMPort *port; task = g_task_new (self, NULL, callback, user_data); if (!g_str_equal (subsystem, "net")) { g_task_return_new_error (task, MM_CORE_ERROR, MM_CORE_ERROR_UNSUPPORTED, "Cannot wait for port '%s/%s', unexpected link port subsystem", subsystem, name); g_object_unref (task); return; } if (!self->priv->link_ports) { g_task_return_new_error (task, MM_CORE_ERROR, MM_CORE_ERROR_FAILED, "Cannot wait for port '%s/%s', no link ports table", subsystem, name); g_object_unref (task); return; } key = g_strdup_printf ("%s%s", subsystem, name); port = g_hash_table_lookup (self->priv->link_ports, key); if (port) { mm_obj_dbg (self, "no need to wait for port '%s/%s': already grabbed", subsystem, name); g_task_return_pointer (task, g_object_ref (port), g_object_unref); g_object_unref (task); return; } ctx = g_slice_new0 (WaitLinkPortContext); ctx->name = g_strdup (name); g_task_set_task_data (task, ctx, (GDestroyNotify)wait_link_port_context_free); /* task ownership shared between timeout and signal handler */ ctx->timeout_id = g_timeout_add (timeout_ms, (GSourceFunc) wait_link_port_timeout_cb, task); ctx->link_port_grabbed_id = g_signal_connect (self, MM_BASE_MODEM_SIGNAL_LINK_PORT_GRABBED, G_CALLBACK (wait_link_port_grabbed_cb), task); mm_obj_dbg (self, "waiting for port '%s/%s'...", subsystem, name); } /******************************************************************************/ #if defined WITH_SUSPEND_RESUME gboolean mm_base_modem_sync_finish (MMBaseModem *self, GAsyncResult *res, GError **error) { return g_task_propagate_boolean (G_TASK (res), error); } static void sync_ready (MMBaseModem *self, GAsyncResult *res, GTask *task) { GError *error = NULL; if (!MM_BASE_MODEM_GET_CLASS (self)->sync_finish (self, res, &error)) g_task_return_error (task, error); else g_task_return_boolean (task, TRUE); g_object_unref (task); } void mm_base_modem_sync (MMBaseModem *self, GAsyncReadyCallback callback, gpointer user_data) { GTask *task; task = g_task_new (self, NULL, callback, user_data); if (!MM_BASE_MODEM_GET_CLASS (self)->sync || !MM_BASE_MODEM_GET_CLASS (self)->sync_finish) { g_task_return_new_error (task, MM_CORE_ERROR, MM_CORE_ERROR_UNSUPPORTED, "Suspend/resume quick synchronization unsupported"); g_object_unref (task); return; } MM_BASE_MODEM_GET_CLASS (self)->sync (self, (GAsyncReadyCallback) sync_ready, task); } #endif /* WITH_SUSPEND_RESUME */ /******************************************************************************/ gboolean mm_base_modem_disable_finish (MMBaseModem *self, GAsyncResult *res, GError **error) { return g_task_propagate_boolean (G_TASK (res), error); } static void disable_ready (MMBaseModem *self, GAsyncResult *res) { GError *error = NULL; GList *l; GList *disable_tasks; g_assert (self->priv->disable_tasks); disable_tasks = self->priv->disable_tasks; self->priv->disable_tasks = NULL; MM_BASE_MODEM_GET_CLASS (self)->disable_finish (self, res, &error); for (l = disable_tasks; l; l = g_list_next (l)) { if (error) g_task_return_error (G_TASK (l->data), g_error_copy (error)); else g_task_return_boolean (G_TASK (l->data), TRUE); } g_clear_error (&error); g_list_free_full (disable_tasks, g_object_unref); } void mm_base_modem_disable (MMBaseModem *self, GAsyncReadyCallback callback, gpointer user_data) { GTask *task; gboolean run_disable; g_assert (MM_BASE_MODEM_GET_CLASS (self)->disable != NULL); g_assert (MM_BASE_MODEM_GET_CLASS (self)->disable_finish != NULL); /* If the list of disable tasks is empty, we need to run */ run_disable = !self->priv->disable_tasks; /* Store task */ task = g_task_new (self, self->priv->cancellable, callback, user_data); self->priv->disable_tasks = g_list_append (self->priv->disable_tasks, task); if (!run_disable) return; MM_BASE_MODEM_GET_CLASS (self)->disable ( self, self->priv->cancellable, (GAsyncReadyCallback) disable_ready, NULL); } gboolean mm_base_modem_enable_finish (MMBaseModem *self, GAsyncResult *res, GError **error) { return g_task_propagate_boolean (G_TASK (res), error); } static void enable_ready (MMBaseModem *self, GAsyncResult *res) { GError *error = NULL; GList *l; GList *enable_tasks; g_assert (self->priv->enable_tasks); enable_tasks = self->priv->enable_tasks; self->priv->enable_tasks = NULL; MM_BASE_MODEM_GET_CLASS (self)->enable_finish (self, res, &error); for (l = enable_tasks; l; l = g_list_next (l)) { if (error) g_task_return_error (G_TASK (l->data), g_error_copy (error)); else g_task_return_boolean (G_TASK (l->data), TRUE); } g_clear_error (&error); g_list_free_full (enable_tasks, g_object_unref); } void mm_base_modem_enable (MMBaseModem *self, GAsyncReadyCallback callback, gpointer user_data) { GTask *task; gboolean run_enable; g_assert (MM_BASE_MODEM_GET_CLASS (self)->enable != NULL); g_assert (MM_BASE_MODEM_GET_CLASS (self)->enable_finish != NULL); /* If the list of enable tasks is empty, we need to run */ run_enable = !self->priv->enable_tasks; /* Store task */ task = g_task_new (self, self->priv->cancellable, callback, user_data); self->priv->enable_tasks = g_list_append (self->priv->enable_tasks, task); if (!run_enable) return; MM_BASE_MODEM_GET_CLASS (self)->enable ( self, self->priv->cancellable, (GAsyncReadyCallback) enable_ready, NULL); } gboolean mm_base_modem_initialize_finish (MMBaseModem *self, GAsyncResult *res, GError **error) { return MM_BASE_MODEM_GET_CLASS (self)->initialize_finish (self, res, error); } void mm_base_modem_initialize (MMBaseModem *self, GAsyncReadyCallback callback, gpointer user_data) { g_assert (MM_BASE_MODEM_GET_CLASS (self)->initialize != NULL); g_assert (MM_BASE_MODEM_GET_CLASS (self)->initialize_finish != NULL); MM_BASE_MODEM_GET_CLASS (self)->initialize ( self, self->priv->cancellable, callback, user_data); } void mm_base_modem_set_hotplugged (MMBaseModem *self, gboolean hotplugged) { g_return_if_fail (MM_IS_BASE_MODEM (self)); self->priv->hotplugged = hotplugged; } gboolean mm_base_modem_get_hotplugged (MMBaseModem *self) { g_return_val_if_fail (MM_IS_BASE_MODEM (self), FALSE); return self->priv->hotplugged; } void mm_base_modem_set_valid (MMBaseModem *self, gboolean new_valid) { g_return_if_fail (MM_IS_BASE_MODEM (self)); /* If validity changed OR if both old and new were invalid, notify. This * last case is to cover failures during initialization. */ if (self->priv->valid != new_valid || !new_valid) { self->priv->valid = new_valid; g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_VALID]); } } void mm_base_modem_set_reprobe (MMBaseModem *self, gboolean reprobe) { g_return_if_fail (MM_IS_BASE_MODEM (self)); self->priv->reprobe = reprobe; } gboolean mm_base_modem_get_reprobe (MMBaseModem *self) { g_return_val_if_fail (MM_IS_BASE_MODEM (self), FALSE); return self->priv->reprobe; } gboolean mm_base_modem_get_valid (MMBaseModem *self) { g_return_val_if_fail (MM_IS_BASE_MODEM (self), FALSE); return self->priv->valid; } GCancellable * mm_base_modem_peek_cancellable (MMBaseModem *self) { g_return_val_if_fail (MM_IS_BASE_MODEM (self), NULL); return self->priv->cancellable; } MMPortSerialAt * mm_base_modem_get_port_primary (MMBaseModem *self) { g_return_val_if_fail (MM_IS_BASE_MODEM (self), NULL); return (self->priv->primary ? g_object_ref (self->priv->primary) : NULL); } MMPortSerialAt * mm_base_modem_peek_port_primary (MMBaseModem *self) { g_return_val_if_fail (MM_IS_BASE_MODEM (self), NULL); return self->priv->primary; } MMPortSerialAt * mm_base_modem_get_port_secondary (MMBaseModem *self) { g_return_val_if_fail (MM_IS_BASE_MODEM (self), NULL); return (self->priv->secondary ? g_object_ref (self->priv->secondary) : NULL); } MMPortSerialAt * mm_base_modem_peek_port_secondary (MMBaseModem *self) { g_return_val_if_fail (MM_IS_BASE_MODEM (self), NULL); return self->priv->secondary; } MMPortSerialQcdm * mm_base_modem_get_port_qcdm (MMBaseModem *self) { g_return_val_if_fail (MM_IS_BASE_MODEM (self), NULL); return (self->priv->qcdm ? g_object_ref (self->priv->qcdm) : NULL); } MMPortSerialQcdm * mm_base_modem_peek_port_qcdm (MMBaseModem *self) { g_return_val_if_fail (MM_IS_BASE_MODEM (self), NULL); return self->priv->qcdm; } MMPortSerialAt * mm_base_modem_get_port_gps_control (MMBaseModem *self) { g_return_val_if_fail (MM_IS_BASE_MODEM (self), NULL); return (self->priv->gps_control ? g_object_ref (self->priv->gps_control) : NULL); } MMPortSerialAt * mm_base_modem_peek_port_gps_control (MMBaseModem *self) { g_return_val_if_fail (MM_IS_BASE_MODEM (self), NULL); return self->priv->gps_control; } MMPortSerialGps * mm_base_modem_get_port_gps (MMBaseModem *self) { g_return_val_if_fail (MM_IS_BASE_MODEM (self), NULL); return (self->priv->gps ? g_object_ref (self->priv->gps) : NULL); } MMPortSerialGps * mm_base_modem_peek_port_gps (MMBaseModem *self) { g_return_val_if_fail (MM_IS_BASE_MODEM (self), NULL); return self->priv->gps; } MMPortSerial * mm_base_modem_get_port_audio (MMBaseModem *self) { g_return_val_if_fail (MM_IS_BASE_MODEM (self), NULL); return (self->priv->audio ? g_object_ref (self->priv->audio) : NULL); } MMPortSerial * mm_base_modem_peek_port_audio (MMBaseModem *self) { g_return_val_if_fail (MM_IS_BASE_MODEM (self), NULL); return self->priv->audio; } MMPort * mm_base_modem_get_best_data_port (MMBaseModem *self, MMPortType type) { MMPort *port; port = mm_base_modem_peek_best_data_port (self, type); return (port ? g_object_ref (port) : NULL); } MMPort * mm_base_modem_peek_best_data_port (MMBaseModem *self, MMPortType type) { GList *l; g_return_val_if_fail (MM_IS_BASE_MODEM (self), NULL); /* Return first not-connected data port */ for (l = self->priv->data; l; l = g_list_next (l)) { if (!mm_port_get_connected ((MMPort *)l->data) && (mm_port_get_port_type ((MMPort *)l->data) == type || type == MM_PORT_TYPE_UNKNOWN)) { return (MMPort *)l->data; } } return NULL; } GList * mm_base_modem_get_data_ports (MMBaseModem *self) { g_return_val_if_fail (MM_IS_BASE_MODEM (self), NULL); return g_list_copy_deep (self->priv->data, (GCopyFunc)g_object_ref, NULL); } GList * mm_base_modem_peek_data_ports (MMBaseModem *self) { g_return_val_if_fail (MM_IS_BASE_MODEM (self), NULL); return self->priv->data; } MMPortSerialAt * mm_base_modem_get_best_at_port (MMBaseModem *self, GError **error) { MMPortSerialAt *best; best = mm_base_modem_peek_best_at_port (self, error); return (best ? g_object_ref (best) : NULL); } MMPortSerialAt * mm_base_modem_peek_best_at_port (MMBaseModem *self, GError **error) { /* Decide which port to use */ if (self->priv->primary && !mm_port_get_connected (MM_PORT (self->priv->primary))) return self->priv->primary; /* If primary port is connected, check if we can get the secondary * port */ if (self->priv->secondary && !mm_port_get_connected (MM_PORT (self->priv->secondary))) return self->priv->secondary; /* Otherwise, we cannot get any port */ g_set_error (error, MM_CORE_ERROR, MM_CORE_ERROR_CONNECTED, "No AT port available to run command"); return NULL; } gboolean mm_base_modem_has_at_port (MMBaseModem *self) { GHashTableIter iter; gpointer value; gpointer key; if (!self->priv->ports) return FALSE; /* We'll iterate the ht of ports, looking for any port which is AT */ g_hash_table_iter_init (&iter, self->priv->ports); while (g_hash_table_iter_next (&iter, &key, &value)) { if (MM_IS_PORT_SERIAL_AT (value)) return TRUE; } return FALSE; } static gint port_info_cmp (const MMModemPortInfo *a, const MMModemPortInfo *b) { /* default to alphabetical sorting on the port name */ return g_strcmp0 (a->name, b->name); } MMModemPortInfo * mm_base_modem_get_port_infos (MMBaseModem *self, guint *n_port_infos) { GHashTableIter iter; GArray *port_infos; MMPort *port; if (!self->priv->ports) { *n_port_infos = 0; return NULL; } *n_port_infos = g_hash_table_size (self->priv->ports); port_infos = g_array_sized_new (FALSE, FALSE, sizeof (MMModemPortInfo), *n_port_infos); g_hash_table_iter_init (&iter, self->priv->ports); while (g_hash_table_iter_next (&iter, NULL, (gpointer)&port)) { MMModemPortInfo port_info; port_info.name = g_strdup (mm_port_get_device (port)); switch (mm_port_get_port_type (port)) { case MM_PORT_TYPE_NET: port_info.type = MM_MODEM_PORT_TYPE_NET; break; case MM_PORT_TYPE_AT: port_info.type = MM_MODEM_PORT_TYPE_AT; break; case MM_PORT_TYPE_QCDM: port_info.type = MM_MODEM_PORT_TYPE_QCDM; break; case MM_PORT_TYPE_GPS: port_info.type = MM_MODEM_PORT_TYPE_GPS; break; case MM_PORT_TYPE_AUDIO: port_info.type = MM_MODEM_PORT_TYPE_AUDIO; break; case MM_PORT_TYPE_QMI: port_info.type = MM_MODEM_PORT_TYPE_QMI; break; case MM_PORT_TYPE_MBIM: port_info.type = MM_MODEM_PORT_TYPE_MBIM; break; case MM_PORT_TYPE_IGNORED: port_info.type = MM_MODEM_PORT_TYPE_IGNORED; break; case MM_PORT_TYPE_UNKNOWN: default: port_info.type = MM_MODEM_PORT_TYPE_UNKNOWN; break; } g_array_append_val (port_infos, port_info); } g_assert (*n_port_infos == port_infos->len); g_array_sort (port_infos, (GCompareFunc) port_info_cmp); return (MMModemPortInfo *) g_array_free (port_infos, FALSE); } static gint port_cmp (MMPort *a, MMPort *b) { /* default to alphabetical sorting on the port name */ return g_strcmp0 (mm_port_get_device (a), mm_port_get_device (b)); } GList * mm_base_modem_find_ports (MMBaseModem *self, MMPortSubsys subsys, MMPortType type) { GList *out = NULL; GHashTableIter iter; gpointer value; gpointer key; if (!self->priv->ports) return NULL; g_hash_table_iter_init (&iter, self->priv->ports); while (g_hash_table_iter_next (&iter, &key, &value)) { MMPort *port = MM_PORT (value); if (subsys != MM_PORT_SUBSYS_UNKNOWN && mm_port_get_subsys (port) != subsys) continue; if (type != MM_PORT_TYPE_UNKNOWN && mm_port_get_port_type (port) != type) continue; out = g_list_append (out, g_object_ref (port)); } return g_list_sort (out, (GCompareFunc) port_cmp); } static MMPort * peek_port_in_ht (GHashTable *ht, const gchar *name) { GHashTableIter iter; gpointer value; gpointer key; if (!ht) return NULL; g_hash_table_iter_init (&iter, ht); while (g_hash_table_iter_next (&iter, &key, &value)) { MMPort *port = MM_PORT (value); if (g_str_equal (mm_port_get_device (port), name)) return port; } return NULL; } MMPort * mm_base_modem_peek_port (MMBaseModem *self, const gchar *name) { MMPort *found; found = peek_port_in_ht (self->priv->ports, name); if (!found) found = peek_port_in_ht (self->priv->link_ports, name); return found; } MMPort * mm_base_modem_get_port (MMBaseModem *self, const gchar *name) { MMPort *port; port = mm_base_modem_peek_port (self, name); return (port ? g_object_ref (port) : NULL); } static void initialize_ready (MMBaseModem *self, GAsyncResult *res) { g_autoptr(GError) error = NULL; if (!mm_base_modem_initialize_finish (self, res, &error)) { if (g_error_matches (error, MM_CORE_ERROR, MM_CORE_ERROR_ABORTED)) { /* FATAL error, won't even be exported in DBus */ mm_obj_err (self, "fatal error initializing: %s", error->message); } else { /* non-fatal error */ mm_obj_warn (self, "error initializing: %s", error->message); mm_base_modem_set_valid (self, TRUE); } } else { mm_obj_dbg (self, "modem initialized"); mm_base_modem_set_valid (self, TRUE); } } static inline void log_port (MMBaseModem *self, MMPort *port, const gchar *desc) { if (!port) return; mm_obj_info (self, "%s/%s: %s", mm_port_subsys_get_string (mm_port_get_subsys (port)), mm_port_get_device (port), desc); } gboolean mm_base_modem_organize_ports (MMBaseModem *self, GError **error) { GHashTableIter iter; MMPort *candidate; MMPortSerialAtFlag flags; MMPortSerialAt *backup_primary = NULL; MMPortSerialAt *primary = NULL; MMPortSerialAt *secondary = NULL; MMPortSerialAt *backup_secondary = NULL; MMPortSerialQcdm *qcdm = NULL; MMPortSerialAt *gps_control = NULL; MMPortSerialGps *gps = NULL; MMPortSerial *audio = NULL; MMPortSerialAt *data_at_primary = NULL; GList *l; /* These lists don't keep full references, so they should be * g_list_free()-ed on error exits */ g_autoptr(GList) data_at = NULL; g_autoptr(GList) data_net = NULL; #if defined WITH_QMI g_autoptr(GList) qmi = NULL; #endif #if defined WITH_MBIM g_autoptr(GList) mbim = NULL; #endif g_return_val_if_fail (MM_IS_BASE_MODEM (self), FALSE); /* If ports have already been organized, just return success */ if (self->priv->primary) return TRUE; /* Ports table is created on init and removed on dispose(), not on * finalize(), so there is a chance this may happen */ if (!self->priv->ports) { g_set_error_literal (error, MM_CORE_ERROR, MM_CORE_ERROR_FAILED, "No ports table"); return FALSE; } g_hash_table_iter_init (&iter, self->priv->ports); while (g_hash_table_iter_next (&iter, NULL, (gpointer *) &candidate)) { switch (mm_port_get_port_type (candidate)) { case MM_PORT_TYPE_AT: g_assert (MM_IS_PORT_SERIAL_AT (candidate)); flags = mm_port_serial_at_get_flags (MM_PORT_SERIAL_AT (candidate)); if (flags & MM_PORT_SERIAL_AT_FLAG_PRIMARY) { if (!primary) primary = MM_PORT_SERIAL_AT (candidate); else if (!backup_primary) { /* Just in case the plugin gave us more than one primary * and no secondaries, treat additional primary ports as * secondary. */ backup_primary = MM_PORT_SERIAL_AT (candidate); } } if (flags & MM_PORT_SERIAL_AT_FLAG_PPP) { if (!data_at_primary) data_at_primary = MM_PORT_SERIAL_AT (candidate); else data_at = g_list_append (data_at, candidate); } /* Explicitly flagged secondary ports trump NONE ports for secondary */ if (flags & MM_PORT_SERIAL_AT_FLAG_SECONDARY) { if (!secondary || !(mm_port_serial_at_get_flags (secondary) & MM_PORT_SERIAL_AT_FLAG_SECONDARY)) secondary = MM_PORT_SERIAL_AT (candidate); } if (flags & MM_PORT_SERIAL_AT_FLAG_GPS_CONTROL) { if (!gps_control) gps_control = MM_PORT_SERIAL_AT (candidate); } /* Fallback secondary */ if (flags == MM_PORT_SERIAL_AT_FLAG_NONE) { if (!secondary) secondary = MM_PORT_SERIAL_AT (candidate); else if (!backup_secondary) backup_secondary = MM_PORT_SERIAL_AT (candidate); } break; case MM_PORT_TYPE_QCDM: g_assert (MM_IS_PORT_SERIAL_QCDM (candidate)); if (!qcdm) qcdm = MM_PORT_SERIAL_QCDM (candidate); break; case MM_PORT_TYPE_NET: data_net = g_list_append (data_net, candidate); break; case MM_PORT_TYPE_GPS: g_assert (MM_IS_PORT_SERIAL_GPS (candidate)); if (!gps) gps = MM_PORT_SERIAL_GPS (candidate); break; case MM_PORT_TYPE_AUDIO: g_assert (MM_IS_PORT_SERIAL (candidate)); if (!audio) audio = MM_PORT_SERIAL (candidate); break; #if defined WITH_QMI case MM_PORT_TYPE_QMI: qmi = g_list_append (qmi, candidate); break; #endif #if defined WITH_MBIM case MM_PORT_TYPE_MBIM: mbim = g_list_append (mbim, candidate); break; #endif case MM_PORT_TYPE_UNKNOWN: case MM_PORT_TYPE_IGNORED: #if !defined WITH_MBIM case MM_PORT_TYPE_MBIM: #endif #if !defined WITH_QMI case MM_PORT_TYPE_QMI: #endif default: /* Ignore port */ break; } } if (!primary) { /* Fall back to a secondary port if we didn't find a primary port */ if (secondary) { primary = secondary; secondary = NULL; } /* Fallback to a data port if no primary or secondary */ else if (data_at_primary) { primary = data_at_primary; data_at_primary = NULL; } else { gboolean allow_modem_without_at_port = FALSE; #if defined WITH_QMI if (qmi) allow_modem_without_at_port = TRUE; #endif #if defined WITH_MBIM if (mbim) allow_modem_without_at_port = TRUE; #endif if (!allow_modem_without_at_port) { g_set_error_literal (error, MM_CORE_ERROR, MM_CORE_ERROR_FAILED, "Failed to find primary AT port"); return FALSE; } } } /* If the plugin didn't give us any secondary ports, use any additional * primary ports or backup secondary ports as secondary. */ if (!secondary) secondary = backup_primary ? backup_primary : backup_secondary; #if defined WITH_QMI /* On QMI-based modems, we need to have at least a net port */ if (qmi && !data_net) { g_set_error_literal (error, MM_CORE_ERROR, MM_CORE_ERROR_FAILED, "Failed to find a net port in the QMI modem"); return FALSE; } #endif #if defined WITH_MBIM /* On MBIM-based modems, we need to have at least a net port */ if (mbim && !data_net) { g_set_error_literal (error, MM_CORE_ERROR, MM_CORE_ERROR_FAILED, "Failed to find a net port in the MBIM modem"); return FALSE; } #endif /* Data port defaults to primary AT port */ if (primary && !data_at_primary) data_at_primary = primary; /* Reset flags on all ports; clear data port first since it might also * be the primary or secondary port. */ if (data_at_primary) mm_port_serial_at_set_flags (data_at_primary, MM_PORT_SERIAL_AT_FLAG_NONE); if (primary) mm_port_serial_at_set_flags (primary, MM_PORT_SERIAL_AT_FLAG_PRIMARY); if (secondary) mm_port_serial_at_set_flags (secondary, MM_PORT_SERIAL_AT_FLAG_SECONDARY); if (data_at_primary) { flags = mm_port_serial_at_get_flags (data_at_primary); mm_port_serial_at_set_flags (data_at_primary, flags | MM_PORT_SERIAL_AT_FLAG_PPP); } /* sort ports by name */ #if defined WITH_QMI qmi = g_list_sort (qmi, (GCompareFunc) port_cmp); #endif #if defined WITH_MBIM mbim = g_list_sort (mbim, (GCompareFunc) port_cmp); #endif data_net = g_list_sort (data_net, (GCompareFunc) port_cmp); data_at = g_list_sort (data_at, (GCompareFunc) port_cmp); log_port (self, MM_PORT (primary), "at (primary)"); log_port (self, MM_PORT (secondary), "at (secondary)"); log_port (self, MM_PORT (data_at_primary), "at (data primary)"); for (l = data_at; l; l = g_list_next (l)) log_port (self, MM_PORT (l->data), "at (data secondary)"); for (l = data_net; l; l = g_list_next (l)) log_port (self, MM_PORT (l->data), "net (data)"); log_port (self, MM_PORT (qcdm), "qcdm"); log_port (self, MM_PORT (gps_control), "gps (control)"); log_port (self, MM_PORT (gps), "gps (nmea)"); log_port (self, MM_PORT (audio), "audio"); #if defined WITH_QMI for (l = qmi; l; l = g_list_next (l)) log_port (self, MM_PORT (l->data), "qmi"); #endif #if defined WITH_MBIM for (l = mbim; l; l = g_list_next (l)) log_port (self, MM_PORT (l->data), "mbim"); #endif /* We keep new refs to the objects here */ self->priv->primary = (primary ? g_object_ref (primary) : NULL); self->priv->secondary = (secondary ? g_object_ref (secondary) : NULL); self->priv->qcdm = (qcdm ? g_object_ref (qcdm) : NULL); self->priv->gps_control = (gps_control ? g_object_ref (gps_control) : NULL); self->priv->gps = (gps ? g_object_ref (gps) : NULL); /* Append net ports to the final list of data ports, but only if the modem * supports them */ if (data_net) { if (self->priv->data_net_supported) { g_list_foreach (data_net, (GFunc)g_object_ref, NULL); self->priv->data = g_list_concat (self->priv->data, g_steal_pointer (&data_net)); } else mm_obj_dbg (self, "net ports available but ignored"); } /* Append tty ports to the final list of data ports, but only if the modem * supports them */ if (data_at_primary || data_at) { if (self->priv->data_tty_supported) { if (data_at_primary) self->priv->data = g_list_append (self->priv->data, g_object_ref (data_at_primary)); if (data_at) { g_list_foreach (data_at, (GFunc)g_object_ref, NULL); self->priv->data = g_list_concat (self->priv->data, g_steal_pointer (&data_at)); } } else mm_obj_dbg (self, "at data ports available but ignored"); } /* Fail if we haven't added any single data port; this is probably a plugin * misconfiguration */ if (!self->priv->data) { g_set_error_literal (error, MM_CORE_ERROR, MM_CORE_ERROR_FAILED, "Failed to find a data port in the modem"); return FALSE; } #if defined WITH_QMI if (qmi) { /* The first item in the data list must be a net port, because * QMI modems only expect net ports */ g_assert (MM_IS_PORT_NET (self->priv->data->data)); /* let the MMPortQmi know which net driver is being used, taken * from the first item in the net port list */ g_list_foreach (qmi, (GFunc)mm_port_qmi_set_net_driver, (gpointer) mm_kernel_device_get_driver ( mm_port_peek_kernel_device ( MM_PORT (self->priv->data->data)))); g_list_foreach (qmi, (GFunc)mm_port_qmi_set_net_sysfs_path, (gpointer) mm_kernel_device_get_sysfs_path ( mm_port_peek_kernel_device ( MM_PORT (self->priv->data->data)))); g_list_foreach (qmi, (GFunc)g_object_ref, NULL); self->priv->qmi = g_steal_pointer (&qmi); } #endif #if defined WITH_MBIM if (mbim) { g_list_foreach (mbim, (GFunc)g_object_ref, NULL); self->priv->mbim = g_steal_pointer (&mbim); } #endif /* As soon as we get the ports organized, we initialize the modem */ mm_base_modem_initialize (self, (GAsyncReadyCallback)initialize_ready, NULL); return TRUE; } /*****************************************************************************/ /* Authorization */ gboolean mm_base_modem_authorize_finish (MMBaseModem *self, GAsyncResult *res, GError **error) { return g_task_propagate_boolean (G_TASK (res), error); } static void authorize_ready (MMAuthProvider *authp, GAsyncResult *res, GTask *task) { GError *error = NULL; if (!mm_auth_provider_authorize_finish (authp, res, &error)) g_task_return_error (task, error); else g_task_return_boolean (task, TRUE); g_object_unref (task); } void mm_base_modem_authorize (MMBaseModem *self, GDBusMethodInvocation *invocation, const gchar *authorization, GAsyncReadyCallback callback, gpointer user_data) { GTask *task; task = g_task_new (self, self->priv->authp_cancellable, callback, user_data); /* When running in the session bus for tests, default to always allow */ if (mm_context_get_test_session ()) { g_task_return_boolean (task, TRUE); g_object_unref (task); return; } mm_auth_provider_authorize (self->priv->authp, invocation, authorization, self->priv->authp_cancellable, (GAsyncReadyCallback)authorize_ready, task); } /*****************************************************************************/ const gchar * mm_base_modem_get_device (MMBaseModem *self) { g_return_val_if_fail (MM_IS_BASE_MODEM (self), NULL); return self->priv->device; } const gchar * mm_base_modem_get_physdev (MMBaseModem *self) { g_return_val_if_fail (MM_IS_BASE_MODEM (self), NULL); return self->priv->physdev; } const gchar ** mm_base_modem_get_drivers (MMBaseModem *self) { g_return_val_if_fail (MM_IS_BASE_MODEM (self), NULL); return (const gchar **)self->priv->drivers; } const gchar * mm_base_modem_get_plugin (MMBaseModem *self) { g_return_val_if_fail (MM_IS_BASE_MODEM (self), NULL); return self->priv->plugin; } guint mm_base_modem_get_vendor_id (MMBaseModem *self) { g_return_val_if_fail (MM_IS_BASE_MODEM (self), 0); return self->priv->vendor_id; } guint mm_base_modem_get_product_id (MMBaseModem *self) { g_return_val_if_fail (MM_IS_BASE_MODEM (self), 0); return self->priv->product_id; } guint mm_base_modem_get_subsystem_vendor_id (MMBaseModem *self) { g_return_val_if_fail (MM_IS_BASE_MODEM (self), 0); return self->priv->subsystem_vendor_id; } /*****************************************************************************/ static gboolean base_modem_invalid_idle (MMBaseModem *self) { /* Ensure the modem is set invalid if we get the modem-wide cancellable * cancelled */ mm_base_modem_set_valid (self, FALSE); g_object_unref (self); return G_SOURCE_REMOVE; } static void base_modem_cancelled (GCancellable *cancellable, MMBaseModem *self) { /* NOTE: Don't call set_valid() directly here, do it in an idle, and ensure * that we pass a valid reference of the modem object as context. */ g_idle_add ((GSourceFunc)base_modem_invalid_idle, g_object_ref (self)); } /*****************************************************************************/ static void setup_ports_table (GHashTable **ht) { g_assert (ht && !*ht); *ht = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_object_unref); } static void cleanup_modem_port (MMBaseModem *self, MMPort *port) { mm_obj_dbg (self, "cleaning up port '%s/%s'...", mm_port_subsys_get_string (mm_port_get_subsys (MM_PORT (port))), mm_port_get_device (MM_PORT (port))); /* Cleanup on all control ports */ g_signal_handlers_disconnect_by_func (port, port_timed_out_cb, self); g_signal_handlers_disconnect_by_func (port, port_removed_cb, self); #if defined WITH_MBIM /* We need to close the MBIM port cleanly when disposing the modem object */ if (MM_IS_PORT_MBIM (port)) { mm_port_mbim_close (MM_PORT_MBIM (port), NULL, NULL); return; } #endif #if defined WITH_QMI /* We need to close the QMI port cleanly when disposing the modem object, * otherwise the allocated CIDs will be kept allocated, and if we end up * allocating too many newer allocations will fail with client-ids-exhausted * errors. */ if (MM_IS_PORT_QMI (port)) { mm_port_qmi_close (MM_PORT_QMI (port), NULL, NULL); return; } #endif } static void teardown_ports_table (MMBaseModem *self, GHashTable **ht) { GHashTableIter iter; gpointer value; gpointer key; if (!*ht) return; g_hash_table_iter_init (&iter, *ht); while (g_hash_table_iter_next (&iter, &key, &value)) cleanup_modem_port (self, MM_PORT (value)); g_hash_table_destroy (g_steal_pointer (ht)); } /*****************************************************************************/ static gchar * log_object_build_id (MMLogObject *_self) { MMBaseModem *self; self = MM_BASE_MODEM (_self); return g_strdup_printf ("modem%u", self->priv->dbus_id); } /*****************************************************************************/ static void mm_base_modem_init (MMBaseModem *self) { static guint id = 0; /* Initialize private data */ self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, MM_TYPE_BASE_MODEM, MMBaseModemPrivate); /* Each modem is given a unique id to build its own DBus path */ self->priv->dbus_id = id++; /* Setup authorization provider */ self->priv->authp = mm_auth_provider_get (); self->priv->authp_cancellable = g_cancellable_new (); /* Setup modem-wide cancellable */ self->priv->cancellable = g_cancellable_new (); self->priv->invalid_if_cancelled = g_cancellable_connect (self->priv->cancellable, G_CALLBACK (base_modem_cancelled), self, NULL); self->priv->max_timeouts = DEFAULT_MAX_TIMEOUTS; setup_ports_table (&self->priv->ports); setup_ports_table (&self->priv->link_ports); } static void set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { MMBaseModem *self = MM_BASE_MODEM (object); switch (prop_id) { case PROP_VALID: mm_base_modem_set_valid (self, g_value_get_boolean (value)); break; case PROP_REPROBE: mm_base_modem_set_reprobe (self, g_value_get_boolean (value)); break; case PROP_MAX_TIMEOUTS: self->priv->max_timeouts = g_value_get_uint (value); break; case PROP_DEVICE: g_free (self->priv->device); self->priv->device = g_value_dup_string (value); break; case PROP_PHYSDEV: g_free (self->priv->physdev); self->priv->physdev = g_value_dup_string (value); break; case PROP_DRIVERS: g_strfreev (self->priv->drivers); self->priv->drivers = g_value_dup_boxed (value); break; case PROP_PLUGIN: g_free (self->priv->plugin); self->priv->plugin = g_value_dup_string (value); break; case PROP_VENDOR_ID: self->priv->vendor_id = g_value_get_uint (value); break; case PROP_PRODUCT_ID: self->priv->product_id = g_value_get_uint (value); break; case PROP_SUBSYSTEM_VENDOR_ID: self->priv->subsystem_vendor_id = g_value_get_uint (value); break; case PROP_CONNECTION: g_clear_object (&self->priv->connection); self->priv->connection = g_value_dup_object (value); break; case PROP_DATA_NET_SUPPORTED: self->priv->data_net_supported = g_value_get_boolean (value); break; case PROP_DATA_TTY_SUPPORTED: self->priv->data_tty_supported = g_value_get_boolean (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } } static void get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) { MMBaseModem *self = MM_BASE_MODEM (object); switch (prop_id) { case PROP_VALID: g_value_set_boolean (value, self->priv->valid); break; case PROP_REPROBE: g_value_set_boolean (value, self->priv->reprobe); break; case PROP_MAX_TIMEOUTS: g_value_set_uint (value, self->priv->max_timeouts); break; case PROP_DEVICE: g_value_set_string (value, self->priv->device); break; case PROP_PHYSDEV: g_value_set_string (value, self->priv->physdev); break; case PROP_DRIVERS: g_value_set_boxed (value, self->priv->drivers); break; case PROP_PLUGIN: g_value_set_string (value, self->priv->plugin); break; case PROP_VENDOR_ID: g_value_set_uint (value, self->priv->vendor_id); break; case PROP_PRODUCT_ID: g_value_set_uint (value, self->priv->product_id); break; case PROP_SUBSYSTEM_VENDOR_ID: g_value_set_uint (value, self->priv->subsystem_vendor_id); break; case PROP_CONNECTION: g_value_set_object (value, self->priv->connection); break; case PROP_DATA_NET_SUPPORTED: g_value_set_boolean (value, self->priv->data_net_supported); break; case PROP_DATA_TTY_SUPPORTED: g_value_set_boolean (value, self->priv->data_tty_supported); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } } static void finalize (GObject *object) { MMBaseModem *self = MM_BASE_MODEM (object); /* TODO * mm_auth_provider_cancel_for_owner (self->priv->authp, object); */ g_assert (!self->priv->enable_tasks); g_assert (!self->priv->disable_tasks); mm_obj_dbg (self, "completely disposed"); g_free (self->priv->device); g_free (self->priv->physdev); g_strfreev (self->priv->drivers); g_free (self->priv->plugin); G_OBJECT_CLASS (mm_base_modem_parent_class)->finalize (object); } static void dispose (GObject *object) { MMBaseModem *self = MM_BASE_MODEM (object); /* Cancel all ongoing auth requests */ g_cancellable_cancel (self->priv->authp_cancellable); g_clear_object (&self->priv->authp_cancellable); /* note: authp is a singleton, we don't keep a full reference */ /* Ensure we cancel any ongoing operation, but before * disconnect our own signal handler, or we'll end up with * another reference of the modem object around. */ g_cancellable_disconnect (self->priv->cancellable, self->priv->invalid_if_cancelled); g_cancellable_cancel (self->priv->cancellable); g_clear_object (&self->priv->cancellable); g_clear_object (&self->priv->primary); g_clear_object (&self->priv->secondary); g_list_free_full (g_steal_pointer (&self->priv->data), g_object_unref); g_clear_object (&self->priv->qcdm); g_clear_object (&self->priv->gps_control); g_clear_object (&self->priv->gps); g_clear_object (&self->priv->audio); #if defined WITH_QMI g_list_free_full (g_steal_pointer (&self->priv->qmi), g_object_unref); #endif #if defined WITH_MBIM g_list_free_full (g_steal_pointer (&self->priv->mbim), g_object_unref); #endif teardown_ports_table (self, &self->priv->link_ports); teardown_ports_table (self, &self->priv->ports); g_clear_object (&self->priv->connection); G_OBJECT_CLASS (mm_base_modem_parent_class)->dispose (object); } static void log_object_iface_init (MMLogObjectInterface *iface) { iface->build_id = log_object_build_id; } static void mm_base_modem_class_init (MMBaseModemClass *klass) { GObjectClass *object_class = G_OBJECT_CLASS (klass); g_type_class_add_private (object_class, sizeof (MMBaseModemPrivate)); /* Virtual methods */ object_class->get_property = get_property; object_class->set_property = set_property; object_class->finalize = finalize; object_class->dispose = dispose; properties[PROP_MAX_TIMEOUTS] = g_param_spec_uint (MM_BASE_MODEM_MAX_TIMEOUTS, "Max timeouts", "Maximum number of consecutive timed out commands sent to " "the modem before disabling it. If 0, this feature is disabled.", 0, G_MAXUINT, DEFAULT_MAX_TIMEOUTS, G_PARAM_READWRITE); g_object_class_install_property (object_class, PROP_MAX_TIMEOUTS, properties[PROP_MAX_TIMEOUTS]); properties[PROP_VALID] = g_param_spec_boolean (MM_BASE_MODEM_VALID, "Valid", "Whether the modem is to be considered valid or not.", FALSE, G_PARAM_READWRITE); g_object_class_install_property (object_class, PROP_VALID, properties[PROP_VALID]); properties[PROP_DEVICE] = g_param_spec_string (MM_BASE_MODEM_DEVICE, "Device", "Main modem parent device of all the modem's ports", NULL, G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY); g_object_class_install_property (object_class, PROP_DEVICE, properties[PROP_DEVICE]); properties[PROP_PHYSDEV] = g_param_spec_string (MM_BASE_MODEM_PHYSDEV, "Physdev path", "Main modem parent physical device path", NULL, G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY); g_object_class_install_property (object_class, PROP_PHYSDEV, properties[PROP_PHYSDEV]); properties[PROP_DRIVERS] = g_param_spec_boxed (MM_BASE_MODEM_DRIVERS, "Drivers", "Kernel drivers", G_TYPE_STRV, G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY); g_object_class_install_property (object_class, PROP_DRIVERS, properties[PROP_DRIVERS]); properties[PROP_PLUGIN] = g_param_spec_string (MM_BASE_MODEM_PLUGIN, "Plugin", "Name of the plugin managing this modem", NULL, G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY); g_object_class_install_property (object_class, PROP_PLUGIN, properties[PROP_PLUGIN]); properties[PROP_VENDOR_ID] = g_param_spec_uint (MM_BASE_MODEM_VENDOR_ID, "Hardware vendor ID", "Hardware vendor ID. May be unknown for serial devices.", 0, G_MAXUINT, 0, G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY); g_object_class_install_property (object_class, PROP_VENDOR_ID, properties[PROP_VENDOR_ID]); properties[PROP_PRODUCT_ID] = g_param_spec_uint (MM_BASE_MODEM_PRODUCT_ID, "Hardware product ID", "Hardware product ID. May be unknown for serial devices.", 0, G_MAXUINT, 0, G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY); g_object_class_install_property (object_class, PROP_PRODUCT_ID, properties[PROP_PRODUCT_ID]); properties[PROP_SUBSYSTEM_VENDOR_ID] = g_param_spec_uint (MM_BASE_MODEM_SUBSYSTEM_VENDOR_ID, "Hardware subsystem vendor ID", "Hardware subsystem vendor ID. Available for pci devices.", 0, G_MAXUINT, 0, G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY); g_object_class_install_property (object_class, PROP_SUBSYSTEM_VENDOR_ID, properties[PROP_SUBSYSTEM_VENDOR_ID]); properties[PROP_CONNECTION] = g_param_spec_object (MM_BASE_MODEM_CONNECTION, "Connection", "GDBus connection to the system bus.", G_TYPE_DBUS_CONNECTION, G_PARAM_READWRITE); g_object_class_install_property (object_class, PROP_CONNECTION, properties[PROP_CONNECTION]); properties[PROP_REPROBE] = g_param_spec_boolean (MM_BASE_MODEM_REPROBE, "Reprobe", "Whether the modem needs to be reprobed or not.", FALSE, G_PARAM_READWRITE); g_object_class_install_property (object_class, PROP_REPROBE, properties[PROP_REPROBE]); properties[PROP_DATA_NET_SUPPORTED] = g_param_spec_boolean (MM_BASE_MODEM_DATA_NET_SUPPORTED, "Data NET supported", "Whether the modem supports connection via a NET port.", FALSE, G_PARAM_READWRITE); g_object_class_install_property (object_class, PROP_DATA_NET_SUPPORTED, properties[PROP_DATA_NET_SUPPORTED]); properties[PROP_DATA_TTY_SUPPORTED] = g_param_spec_boolean (MM_BASE_MODEM_DATA_TTY_SUPPORTED, "Data TTY supported", "Whether the modem supports connection via a TTY port.", FALSE, G_PARAM_READWRITE); g_object_class_install_property (object_class, PROP_DATA_TTY_SUPPORTED, properties[PROP_DATA_TTY_SUPPORTED]); signals[SIGNAL_LINK_PORT_GRABBED] = g_signal_new (MM_BASE_MODEM_SIGNAL_LINK_PORT_GRABBED, G_OBJECT_CLASS_TYPE (object_class), G_SIGNAL_RUN_FIRST, G_STRUCT_OFFSET (MMBaseModemClass, link_port_grabbed), NULL, NULL, g_cclosure_marshal_generic, G_TYPE_NONE, 1, MM_TYPE_PORT); signals[SIGNAL_LINK_PORT_RELEASED] = g_signal_new (MM_BASE_MODEM_SIGNAL_LINK_PORT_RELEASED, G_OBJECT_CLASS_TYPE (object_class), G_SIGNAL_RUN_FIRST, G_STRUCT_OFFSET (MMBaseModemClass, link_port_released), NULL, NULL, g_cclosure_marshal_generic, G_TYPE_NONE, 1, MM_TYPE_PORT); }