aboutsummaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/Makefile.am2
-rw-r--r--src/mm-iface-modem.c467
-rw-r--r--src/mm-iface-modem.h49
3 files changed, 518 insertions, 0 deletions
diff --git a/src/Makefile.am b/src/Makefile.am
index 951c675f..15aa2fd6 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -112,6 +112,8 @@ modem_manager_SOURCES = \
mm-plugin-manager.h \
mm-base-modem.h \
mm-base-modem.c \
+ mm-iface-modem.h \
+ mm-iface-modem.c \
mm-modem.c \
mm-modem.h \
mm-serial-parsers.c \
diff --git a/src/mm-iface-modem.c b/src/mm-iface-modem.c
new file mode 100644
index 00000000..5c1499d6
--- /dev/null
+++ b/src/mm-iface-modem.c
@@ -0,0 +1,467 @@
+/* -*- 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) 2011 Google, Inc.
+ */
+
+
+#include <ModemManager.h>
+
+#include <mm-gdbus-modem.h>
+#include <mm-errors-types.h>
+
+#include "mm-iface-modem.h"
+#include "mm-base-modem.h"
+#include "mm-log.h"
+
+typedef struct _InitializationContext InitializationContext;
+static void interface_initialization_step (InitializationContext *ctx);
+
+typedef enum {
+ INTERFACE_STATUS_SHUTDOWN,
+ INTERFACE_STATUS_INITIALIZING,
+ INTERFACE_STATUS_INITIALIZED
+} InterfaceStatus;
+
+static gboolean
+handle_create_bearer (MmGdbusModem *object,
+ GDBusMethodInvocation *invocation,
+ GVariant *arg_properties,
+ MMIfaceModem *self)
+{
+ return FALSE; /* Currently unhandled */
+}
+
+static gboolean
+handle_delete_bearer (MmGdbusModem *object,
+ GDBusMethodInvocation *invocation,
+ const gchar *arg_bearer,
+ MMIfaceModem *self)
+{
+ return FALSE; /* Currently unhandled */
+}
+
+static gboolean
+handle_list_bearers (MmGdbusModem *object,
+ GDBusMethodInvocation *invocation,
+ MMIfaceModem *self)
+{
+ return FALSE; /* Currently unhandled */
+}
+
+static gboolean
+handle_enable (MmGdbusModem *object,
+ GDBusMethodInvocation *invocation,
+ gboolean arg_enable,
+ MMIfaceModem *self)
+{
+ return FALSE; /* Currently unhandled */
+}
+
+static gboolean
+handle_reset (MmGdbusModem *object,
+ GDBusMethodInvocation *invocation,
+ MMIfaceModem *self)
+{
+ return FALSE; /* Currently unhandled */
+}
+
+static gboolean
+handle_factory_reset (MmGdbusModem *object,
+ GDBusMethodInvocation *invocation,
+ const gchar *arg_code,
+ MMIfaceModem *self)
+{
+ return FALSE; /* Currently unhandled */
+}
+
+static gboolean
+handle_set_allowed_bands (MmGdbusModem *object,
+ GDBusMethodInvocation *invocation,
+ guint64 arg_bands,
+ MMIfaceModem *self)
+{
+ return FALSE; /* Currently unhandled */
+}
+
+static gboolean
+handle_set_allowed_modes (MmGdbusModem *object,
+ GDBusMethodInvocation *invocation,
+ guint arg_modes,
+ guint arg_preferred,
+ MMIfaceModem *self)
+{
+ return FALSE; /* Currently unhandled */
+}
+
+/*****************************************************************************/
+
+typedef enum {
+ INITIALIZATION_STEP_FIRST,
+ INITIALIZATION_STEP_LAST
+} InitializationStep;
+
+struct _InitializationContext {
+ MMIfaceModem *self;
+ MMAtSerialPort *port;
+ InitializationStep step;
+ GSimpleAsyncResult *result;
+ MmGdbusModem *skeleton;
+};
+
+static InitializationContext *
+initialization_context_new (MMIfaceModem *self,
+ GAsyncReadyCallback callback,
+ gpointer user_data)
+{
+ InitializationContext *ctx;
+
+ ctx = g_new0 (InitializationContext, 1);
+ ctx->self = g_object_ref (self);
+ ctx->port = g_object_ref (mm_base_modem_get_port_primary (MM_BASE_MODEM (self)));
+ ctx->result = g_simple_async_result_new (G_OBJECT (self),
+ callback,
+ user_data,
+ initialization_context_new);
+ ctx->step = INITIALIZATION_STEP_FIRST;
+ g_object_get (ctx->self,
+ MM_IFACE_MODEM_DBUS_SKELETON, &ctx->skeleton,
+ NULL);
+ g_assert (ctx->skeleton != NULL);
+ return ctx;
+}
+
+static void
+initialization_context_free (InitializationContext *ctx)
+{
+ g_object_unref (ctx->self);
+ g_object_unref (ctx->port);
+ g_object_unref (ctx->result);
+ g_object_unref (ctx->skeleton);
+ g_free (ctx);
+}
+
+static gboolean
+interface_initialization_finish (MMIfaceModem *self,
+ GAsyncResult *res,
+ GError **error)
+{
+ return !g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (res), error);
+}
+
+static void
+interface_initialization_step (InitializationContext *ctx)
+{
+ switch (ctx->step) {
+ case INITIALIZATION_STEP_FIRST: {
+ break;
+ }
+ case INITIALIZATION_STEP_LAST:
+ /* We are done without errors! */
+ g_simple_async_result_set_op_res_gboolean (ctx->result, TRUE);
+ g_simple_async_result_complete_in_idle (ctx->result);
+ mm_serial_port_close (MM_SERIAL_PORT (ctx->port));
+ initialization_context_free (ctx);
+ return;
+ }
+
+ /* Go on to next step */
+ ctx->step++;
+ interface_initialization_step (ctx);
+}
+
+static void
+interface_initialization (MMIfaceModem *self,
+ GAsyncReadyCallback callback,
+ gpointer user_data)
+{
+ InitializationContext *ctx;
+ GError *error = NULL;
+
+ ctx = initialization_context_new (self, callback, user_data);
+
+ if (!mm_serial_port_open (MM_SERIAL_PORT (ctx->port), &error)) {
+ g_simple_async_result_take_error (ctx->result, error);
+ g_simple_async_result_complete_in_idle (ctx->result);
+ initialization_context_free (ctx);
+ return;
+ }
+
+ /* Try to disable echo */
+ mm_at_serial_port_queue_command (ctx->port, "E0", 3, NULL, NULL);
+ /* Try to get extended errors */
+ mm_at_serial_port_queue_command (ctx->port, "+CMEE=1", 2, NULL, NULL);
+
+ interface_initialization_step (ctx);
+}
+
+/*****************************************************************************/
+
+
+static InterfaceStatus
+get_status (MMIfaceModem *self)
+{
+ GObject *skeleton = NULL;
+
+ /* Are we already disabled? */
+ g_object_get (self,
+ MM_IFACE_MODEM_DBUS_SKELETON, &skeleton,
+ NULL);
+ if (!skeleton)
+ return INTERFACE_STATUS_SHUTDOWN;
+ g_object_unref (skeleton);
+
+ /* Are we being initialized? (interface not yet exported) */
+ skeleton = G_OBJECT (mm_gdbus_object_get_modem (MM_GDBUS_OBJECT (self)));
+ if (skeleton) {
+ g_object_unref (skeleton);
+ return INTERFACE_STATUS_INITIALIZED;
+ }
+
+ return INTERFACE_STATUS_INITIALIZING;
+}
+
+gboolean
+mm_iface_modem_initialize_finish (MMIfaceModem *self,
+ GAsyncResult *res,
+ GError **error)
+{
+ g_return_val_if_fail (MM_IS_IFACE_MODEM (self), FALSE);
+ g_return_val_if_fail (G_IS_ASYNC_RESULT (res), FALSE);
+
+ return !g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (res), error);
+}
+
+static void
+interface_initialization_ready (MMIfaceModem *self,
+ GAsyncResult *init_result,
+ GSimpleAsyncResult *op_result)
+{
+ GObject *skeleton = NULL;
+ GError *inner_error = NULL;
+
+ /* If initialization failed, remove the skeleton and return the error */
+ if (!interface_initialization_finish (self,
+ init_result,
+ &inner_error)) {
+ g_object_set (self,
+ MM_IFACE_MODEM_DBUS_SKELETON, NULL,
+ NULL);
+ g_simple_async_result_take_error (op_result, inner_error);
+ g_simple_async_result_complete (op_result);
+ g_object_unref (op_result);
+ return;
+ }
+
+ /* Finish current initialization by setting up the DBus skeleton */
+ g_object_get (self,
+ MM_IFACE_MODEM_DBUS_SKELETON, &skeleton,
+ NULL);
+ g_assert (skeleton != NULL);
+
+ /* Handle method invocations */
+ g_signal_connect (skeleton,
+ "handle-create-bearer",
+ G_CALLBACK (handle_create_bearer),
+ self);
+ g_signal_connect (skeleton,
+ "handle-delete-bearer",
+ G_CALLBACK (handle_delete_bearer),
+ self);
+ g_signal_connect (skeleton,
+ "handle-list-bearers",
+ G_CALLBACK (handle_list_bearers),
+ self);
+ g_signal_connect (skeleton,
+ "handle-enable",
+ G_CALLBACK (handle_enable),
+ self);
+ g_signal_connect (skeleton,
+ "handle-reset",
+ G_CALLBACK (handle_reset),
+ self);
+ g_signal_connect (skeleton,
+ "handle-factory-reset",
+ G_CALLBACK (handle_factory_reset),
+ self);
+ g_signal_connect (skeleton,
+ "handle-set-allowed-bands",
+ G_CALLBACK (handle_set_allowed_bands),
+ self);
+ g_signal_connect (skeleton,
+ "handle-set-allowed-modes",
+ G_CALLBACK (handle_set_allowed_modes),
+ self);
+
+ /* Finally, export the new interface */
+ mm_gdbus_object_skeleton_set_modem (MM_GDBUS_OBJECT_SKELETON (self),
+ MM_GDBUS_MODEM (skeleton));
+ g_simple_async_result_set_op_res_gboolean (op_result, TRUE);
+ g_simple_async_result_complete (op_result);
+ g_object_unref (op_result);
+}
+
+void
+mm_iface_modem_initialize (MMIfaceModem *self,
+ GAsyncReadyCallback callback,
+ gpointer user_data)
+{
+ GSimpleAsyncResult *result;
+
+ g_return_if_fail (MM_IS_IFACE_MODEM (self));
+
+ /* Setup asynchronous result */
+ result = g_simple_async_result_new (G_OBJECT (self),
+ callback,
+ user_data,
+ mm_iface_modem_initialize);
+
+ switch (get_status (self)) {
+ case INTERFACE_STATUS_INITIALIZED:
+ case INTERFACE_STATUS_SHUTDOWN: {
+ MmGdbusModem *skeleton = NULL;
+
+ /* Did we already create it? */
+ g_object_get (self,
+ MM_IFACE_MODEM_DBUS_SKELETON, &skeleton,
+ NULL);
+ if (!skeleton) {
+ skeleton = mm_gdbus_modem_skeleton_new ();
+
+ /* Set all initial property defaults */
+ mm_gdbus_modem_set_sim (skeleton, NULL);
+ mm_gdbus_modem_set_modem_capabilities (skeleton, MM_MODEM_CAPABILITY_NONE);
+ mm_gdbus_modem_set_current_capabilities (skeleton, MM_MODEM_CAPABILITY_NONE);
+ mm_gdbus_modem_set_max_bearers (skeleton, 0);
+ mm_gdbus_modem_set_max_active_bearers (skeleton, 0);
+ mm_gdbus_modem_set_manufacturer (skeleton, NULL);
+ mm_gdbus_modem_set_model (skeleton, NULL);
+ mm_gdbus_modem_set_revision (skeleton, NULL);
+ mm_gdbus_modem_set_device_identifier (skeleton, NULL);
+ mm_gdbus_modem_set_device (skeleton, NULL);
+ mm_gdbus_modem_set_driver (skeleton, NULL);
+ mm_gdbus_modem_set_plugin (skeleton, NULL);
+ mm_gdbus_modem_set_equipment_identifier (skeleton, NULL);
+ mm_gdbus_modem_set_unlock_required (skeleton, MM_MODEM_LOCK_UNKNOWN);
+ mm_gdbus_modem_set_unlock_retries (skeleton, 0);
+ mm_gdbus_modem_set_access_technology (skeleton, MM_MODEM_ACCESS_TECH_UNKNOWN);
+ mm_gdbus_modem_set_signal_quality (skeleton, g_variant_new ("(ub)", 0, FALSE));
+ mm_gdbus_modem_set_supported_modes (skeleton, MM_MODEM_MODE_NONE);
+ mm_gdbus_modem_set_allowed_modes (skeleton, MM_MODEM_MODE_ANY);
+ mm_gdbus_modem_set_preferred_mode (skeleton, MM_MODEM_MODE_NONE);
+ mm_gdbus_modem_set_supported_bands (skeleton, MM_MODEM_BAND_UNKNOWN);
+ mm_gdbus_modem_set_allowed_bands (skeleton, MM_MODEM_BAND_ANY);
+ mm_gdbus_modem_set_state (skeleton, MM_MODEM_STATE_UNKNOWN);
+
+ /* Keep a reference to it */
+ g_object_set (self,
+ MM_IFACE_MODEM_DBUS_SKELETON, skeleton,
+ NULL);
+ }
+
+ /* Perform async initialization here */
+ interface_initialization (self,
+ (GAsyncReadyCallback)interface_initialization_ready,
+ result);
+ g_object_unref (skeleton);
+ return;
+ }
+
+ case INTERFACE_STATUS_INITIALIZING:
+ g_simple_async_result_set_error (result,
+ MM_CORE_ERROR,
+ MM_CORE_ERROR_IN_PROGRESS,
+ "Interface is already being enabled");
+ g_simple_async_result_complete_in_idle (result);
+ g_object_unref (result);
+ return;
+ }
+
+ g_return_if_reached ();
+}
+
+gboolean
+mm_iface_modem_shutdown (MMIfaceModem *self,
+ GError **error)
+{
+ g_return_val_if_fail (MM_IS_IFACE_MODEM (self), FALSE);
+
+ switch (get_status (self)) {
+ case INTERFACE_STATUS_SHUTDOWN:
+ return TRUE;
+ case INTERFACE_STATUS_INITIALIZING:
+ g_set_error (error,
+ MM_CORE_ERROR,
+ MM_CORE_ERROR_IN_PROGRESS,
+ "Iinterface being currently initialized");
+ return FALSE;
+ case INTERFACE_STATUS_INITIALIZED:
+ /* Remove SIM object */
+ g_object_set (self,
+ MM_IFACE_MODEM_SIM, NULL,
+ NULL);
+ /* Unexport DBus interface and remove the skeleton */
+ mm_gdbus_object_skeleton_set_modem (MM_GDBUS_OBJECT_SKELETON (self), NULL);
+ g_object_set (self,
+ MM_IFACE_MODEM_DBUS_SKELETON, NULL,
+ NULL);
+ return TRUE;
+ }
+
+ g_return_val_if_reached (FALSE);
+}
+
+
+/*****************************************************************************/
+
+static void
+iface_modem_init (gpointer g_iface)
+{
+ static gboolean initialized = FALSE;
+
+ if (initialized)
+ return;
+
+ /* Properties */
+ g_object_interface_install_property
+ (g_iface,
+ g_param_spec_object (MM_IFACE_MODEM_DBUS_SKELETON,
+ "Modem DBus skeleton",
+ "DBus skeleton for the Modem interface",
+ MM_GDBUS_TYPE_MODEM_SKELETON,
+ G_PARAM_READWRITE));
+
+ initialized = TRUE;
+}
+
+GType
+mm_iface_modem_get_type (void)
+{
+ static GType iface_modem_type = 0;
+
+ if (!G_UNLIKELY (iface_modem_type)) {
+ static const GTypeInfo info = {
+ sizeof (MMIfaceModem), /* class_size */
+ iface_modem_init, /* base_init */
+ NULL, /* base_finalize */
+ };
+
+ iface_modem_type = g_type_register_static (G_TYPE_INTERFACE,
+ "MMIfaceModem",
+ &info,
+ 0);
+
+ g_type_interface_add_prerequisite (iface_modem_type, MM_TYPE_BASE_MODEM);
+ }
+
+ return iface_modem_type;
+}
diff --git a/src/mm-iface-modem.h b/src/mm-iface-modem.h
new file mode 100644
index 00000000..b621973c
--- /dev/null
+++ b/src/mm-iface-modem.h
@@ -0,0 +1,49 @@
+/* -*- 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) 2011 Google, Inc.
+ */
+
+#ifndef MM_IFACE_MODEM_H
+#define MM_IFACE_MODEM_H
+
+#include <glib-object.h>
+#include <gio/gio.h>
+
+#define MM_TYPE_IFACE_MODEM (mm_iface_modem_get_type ())
+#define MM_IFACE_MODEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MM_TYPE_IFACE_MODEM, MMIfaceModem))
+#define MM_IS_IFACE_MODEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MM_TYPE_IFACE_MODEM))
+#define MM_IFACE_MODEM_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), MM_TYPE_IFACE_MODEM, MMIfaceModem))
+
+#define MM_IFACE_MODEM_DBUS_SKELETON "iface-modem-dbus-skeleton"
+
+typedef struct _MMIfaceModem MMIfaceModem;
+
+struct _MMIfaceModem {
+ GTypeInterface g_iface;
+};
+
+GType mm_iface_modem_get_type (void);
+
+/* Initialize Modem interface (async) */
+void mm_iface_modem_initialize (MMIfaceModem *self,
+ GAsyncReadyCallback callback,
+ gpointer user_data);
+gboolean mm_iface_modem_initialize_finish (MMIfaceModem *self,
+ GAsyncResult *res,
+ GError **error);
+
+/* Shutdown Modem interface */
+gboolean mm_iface_modem_shutdown (MMIfaceModem *self,
+ GError **error);
+
+#endif /* MM_IFACE_MODEM_H */
generated by cgit v1.2.3-70-g09d2 (git 2.46.0) at 2025-06-14 23:39:35 +0000