From: Sjur Brændeland <[email protected]>
This patch introduces auto discovery of ST-Ericsson modems.
ST-Ericsson modems (M57XX, M7XX, M74XX) are managed by a
Modem Init Daemon responsible for start, power cycles,
flashing etc. This STE plugin monitors the modem state exposed
from the Modem Init Damon's Dbus API. When the modem is in state
"on" the STE modem is created and registered. Muliple modem
instances, and reset handling is supported.
---
Changes:
- Adapted to new Dbus API, using GetModems method and PropertyChange signal
- Using Serial as modem id
- Review comments from last v3
Makefile.am | 4 +
plugins/stemgr.c | 345 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
2 files changed, 349 insertions(+), 0 deletions(-)
create mode 100644 plugins/stemgr.c
diff --git a/Makefile.am b/Makefile.am
index 8a8555d..6fc4c62 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -223,6 +223,10 @@ builtin_sources += drivers/atmodem/atutil.h \
drivers/ifxmodem/gprs-context.c \
drivers/ifxmodem/stk.c
+
+builtin_modules += stemgr
+builtin_sources += plugins/stemgr.c
+
builtin_modules += stemodem
builtin_sources += drivers/atmodem/atutil.h \
drivers/stemodem/stemodem.h \
diff --git a/plugins/stemgr.c b/plugins/stemgr.c
new file mode 100644
index 0000000..467d0f8
--- /dev/null
+++ b/plugins/stemgr.c
@@ -0,0 +1,345 @@
+/*
+ *
+ * oFono - Open Source Telephony
+ *
+ * Copyright (C) 2011 ST-Ericsson AB.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * 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.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <errno.h>
+#include <string.h>
+#include <net/if.h>
+
+#include <glib.h>
+#include <gdbus.h>
+
+#define OFONO_API_SUBJECT_TO_CHANGE
+#include <ofono/plugin.h>
+#include <ofono/log.h>
+#include <ofono/modem.h>
+#include <ofono/dbus.h>
+
+/*
+ * ST-Ericsson's Modem Init Daemon is used for controling the modem power
+ * cycles and provides a dbus API for modem state and properties.
+ */
+#define MGR_SERVICE "com.stericsson.modeminit"
+#define MGR_MGR_INTERFACE MGR_SERVICE ".Manager"
+#define MGR_GET_MODEMS "GetModems"
+#define GET_MODEMS_TIMEOUT 5000
+
+#define MGR_MODEM_INTERFACE MGR_SERVICE ".Modem"
+#define PROPERTY_CHANGED "PropertyChanged"
+
+enum ste_state {
+ STE_PENDING,
+ STE_REGISTERED,
+ STE_RESETTING
+};
+
+struct ste_modem {
+ struct ofono_modem *modem;
+ char *path;
+ enum ste_state state;
+ char *serial;
+ char *interface;
+};
+
+static GHashTable *modem_list;
+static guint mgr_api_watch;
+static guint mgr_state_watch;
+static DBusConnection *connection;
+static gboolean get_modems_call_pending;
+
+static inline gboolean is_ready(const char *action)
+{
+ return g_strcmp0(action, "ready") == 0;
+}
+
+static inline gboolean is_reset(const char *action)
+{
+ return g_strcmp0(action, "dumping") == 0;
+}
+
+static void state_change(struct ste_modem *stemodem, const char *action)
+{
+
+ switch (stemodem->state) {
+ case STE_PENDING:
+
+ if (!is_ready(action))
+ break;
+
+ stemodem->modem = ofono_modem_create(stemodem->serial,
+ "ste");
+ if (stemodem->modem == NULL) {
+ ofono_error("Could not create modem %s, %s",
+ stemodem->path, stemodem->serial);
+ return;
+ }
+
+ DBG("register modem %s, %s", stemodem->path, stemodem->serial);
+ ofono_modem_set_string(stemodem->modem, "Interface",
+ stemodem->interface);
+ ofono_modem_register(stemodem->modem);
+ stemodem->state = STE_REGISTERED;
+ break;
+ case STE_REGISTERED:
+
+ if (is_reset(action)) {
+ DBG("reset ongoing %s", stemodem->path);
+ /* Note: Consider to power off modem here? */
+ stemodem->state = STE_RESETTING;
+ } else if (!is_ready(action)) {
+ DBG("STE modem unregistering %s %s", stemodem->path,
+ action);
+ ofono_modem_remove(stemodem->modem);
+ stemodem->modem = NULL;
+ stemodem->state = STE_PENDING;
+ }
+
+ break;
+ case STE_RESETTING:
+
+ if (is_ready(action)) {
+ DBG("STE modem reset complete %s", stemodem->path);
+ if (ofono_modem_get_powered(stemodem->modem))
+ ofono_modem_reset(stemodem->modem);
+ stemodem->state = STE_REGISTERED;
+ } else if (!is_reset(action)) {
+ DBG("STE modem unregistering %s %s", stemodem->path,
+ action);
+ ofono_modem_remove(stemodem->modem);
+ stemodem->modem = NULL;
+ stemodem->state = STE_PENDING;
+ }
+
+ break;
+ }
+}
+
+static void update_property(struct ste_modem *stemodem, const char *prop,
+ DBusMessageIter *iter, const char **state)
+{
+ const char *value;
+
+ if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_STRING)
+ return;
+
+ dbus_message_iter_get_basic(iter, &value);
+
+ if (g_strcmp0(prop, "State") == 0)
+ *state = value;
+ else if (g_strcmp0(prop, "Interface") == 0) {
+ g_free(stemodem->interface);
+ stemodem->interface = g_strdup(value);
+ } else if (g_strcmp0(prop, "Serial") == 0) {
+ g_free(stemodem->serial);
+ stemodem->serial = g_strdup(value);
+ }
+}
+
+static void update_modem_properties(const char *path, DBusMessageIter *iter)
+{
+ const char *state = NULL;
+ struct ste_modem *stemodem = g_hash_table_lookup(modem_list, path);
+
+ if (stemodem == NULL) {
+ stemodem = g_try_new0(struct ste_modem, 1);
+ if (stemodem == NULL)
+ return;
+
+ stemodem->path = g_strdup(path);
+ stemodem->state = STE_PENDING;
+ g_hash_table_insert(modem_list, stemodem->path, stemodem);
+ }
+
+ while (dbus_message_iter_get_arg_type(iter) == DBUS_TYPE_DICT_ENTRY) {
+ DBusMessageIter entry, value;
+ const char *key, *str;
+
+ dbus_message_iter_recurse(iter, &entry);
+ dbus_message_iter_get_basic(&entry, &key);
+
+ dbus_message_iter_next(&entry);
+ dbus_message_iter_recurse(&entry, &value);
+
+ update_property(stemodem, key, &value, &state);
+
+ dbus_message_iter_next(iter);
+ }
+
+ if (state != NULL)
+ state_change(stemodem, state);
+}
+
+static void get_modems_reply(DBusPendingCall *call, void *user_data)
+{
+ DBusMessageIter iter, list;
+ DBusError err;
+ DBusMessage *reply = dbus_pending_call_steal_reply(call);
+
+ get_modems_call_pending = FALSE;
+ dbus_error_init(&err);
+
+ if (dbus_set_error_from_message(&err, reply)) {
+ ofono_error("%s: %s\n", err.name, err.message);
+ dbus_error_free(&err);
+ goto done;
+ }
+
+ if (!dbus_message_has_signature(reply, "a(oa{sv})"))
+ goto done;
+
+ if (!dbus_message_iter_init(reply, &iter))
+ goto done;
+
+ dbus_message_iter_recurse(&iter, &list);
+
+ while (dbus_message_iter_get_arg_type(&list) == DBUS_TYPE_STRUCT) {
+ DBusMessageIter entry, dict;
+ const char *path;
+
+ dbus_message_iter_recurse(&list, &entry);
+ dbus_message_iter_get_basic(&entry, &path);
+ dbus_message_iter_next(&entry);
+ dbus_message_iter_recurse(&entry, &dict);
+
+ update_modem_properties(path, &dict);
+
+ dbus_message_iter_next(&list);
+ }
+
+done:
+ dbus_message_unref(reply);
+}
+
+static void get_modems(const char *path)
+{
+ DBusMessage *message;
+ DBusPendingCall *call;
+
+ if (get_modems_call_pending)
+ return;
+
+ message = dbus_message_new_method_call(MGR_SERVICE, path,
+ MGR_MGR_INTERFACE, MGR_GET_MODEMS);
+ if (message == NULL) {
+ ofono_error("Unable to allocate new D-Bus message");
+ goto error;
+ }
+
+ dbus_message_set_auto_start(message, FALSE);
+
+ if (!dbus_connection_send_with_reply(connection, message, &call,
+ GET_MODEMS_TIMEOUT)) {
+ ofono_error("Sending D-Bus message failed");
+ goto error;
+ }
+
+ if (call == NULL) {
+ DBG("D-Bus connection not available");
+ goto error;
+ }
+
+ get_modems_call_pending = TRUE;
+ dbus_pending_call_set_notify(call, get_modems_reply, NULL, NULL);
+ dbus_pending_call_unref(call);
+
+error:
+ dbus_message_unref(message);
+}
+
+static gboolean property_changed(DBusConnection *connection,
+ DBusMessage *message, void *user_data)
+{
+ DBusMessageIter iter, value;
+ struct ste_modem *stemodem;
+ const char *key, *str;
+ const char *state = NULL;
+
+ stemodem = g_hash_table_lookup(modem_list,
+ dbus_message_get_path(message));
+
+ if (stemodem == NULL) {
+ get_modems("/");
+ return TRUE;
+ }
+
+ if (!dbus_message_iter_init(message, &iter))
+ return TRUE;
+
+ dbus_message_iter_get_basic(&iter, &key);
+ dbus_message_iter_next(&iter);
+
+ update_property(stemodem, key, &iter, &state);
+
+ if (state != NULL)
+ state_change(stemodem, state);
+
+ return TRUE;
+}
+
+static void mgr_connect(DBusConnection *connection, void *user_data)
+{
+ mgr_state_watch = g_dbus_add_signal_watch(connection, NULL, NULL,
+ MGR_MODEM_INTERFACE,
+ PROPERTY_CHANGED,
+ property_changed,
+ NULL, NULL);
+ get_modems("/");
+}
+
+static void mgr_disconnect(DBusConnection *connection, void *user_data)
+{
+ g_hash_table_remove_all(modem_list);
+ g_dbus_remove_watch(connection, mgr_state_watch);
+}
+
+static void destroy_stemodem(gpointer data)
+{
+ struct ste_modem *stemodem = data;
+
+ ofono_modem_remove(stemodem->modem);
+ g_free(stemodem->interface);
+ g_free(stemodem->path);
+ g_free(stemodem->serial);
+ g_free(stemodem);
+}
+
+static int stemgr_init()
+{
+ connection = ofono_dbus_get_connection();
+
+ modem_list = g_hash_table_new_full(g_str_hash, g_str_equal,
+ NULL, destroy_stemodem);
+ mgr_api_watch = g_dbus_add_service_watch(connection, MGR_SERVICE,
+ mgr_connect, mgr_disconnect, NULL, NULL);
+ return 0;
+}
+
+static void stemgr_exit()
+{
+ g_hash_table_destroy(modem_list);
+ g_dbus_remove_watch(connection, mgr_api_watch);
+}
+
+OFONO_PLUGIN_DEFINE(stemgr, "ST-Ericsson Modem Init Daemon detection", VERSION,
+ OFONO_PLUGIN_PRIORITY_DEFAULT, stemgr_init, stemgr_exit)
--
1.7.0.4
_______________________________________________
ofono mailing list
[email protected]
http://lists.ofono.org/listinfo/ofono
