asynchronous and deferred port detection

Allow plugins to perform asynchronous port detection, and to defer port detection
until later.  This moves the prober bits into MMPluginBase so that all plugins
can take adavantage of it only when needed; the probing is not done at udev time.
Furthermore, plugins like Novatel can flip the secondary ports over the AT mode
through	deferred detection, by deferring the secondary ports until the main port
has been detected and AT$NWDMAT	has been sent.

This commit also finishes the port of the rest of the plugins (except mbm) over
to the new port detection methods and plugin API.

1 files changed, 65 insertions, 176 deletions

diff --git a/plugins/mm-plugin-moto-c.c b/plugins/mm-plugin-moto-c.c
index 693dd61d..a77e65a8 100644
--- a/plugins/mm-plugin-moto-c.c
+++ b/plugins/mm-plugin-moto-c.c
@@ -22,255 +22,144 @@
 #include "mm-plugin-moto-c.h"
 #include "mm-modem-moto-c-gsm.h"
 
-static void plugin_init (MMPlugin *plugin_class);
-
-G_DEFINE_TYPE_EXTENDED (MMPluginMotoC, mm_plugin_moto_c, MM_TYPE_PLUGIN_BASE,
-                        0, G_IMPLEMENT_INTERFACE (MM_TYPE_PLUGIN, plugin_init))
+G_DEFINE_TYPE (MMPluginMotoC, mm_plugin_moto_c, MM_TYPE_PLUGIN_BASE)
 
 int mm_plugin_major_version = MM_PLUGIN_MAJOR_VERSION;
 int mm_plugin_minor_version = MM_PLUGIN_MINOR_VERSION;
 
-#define MM_PLUGIN_MOTO_C_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), MM_TYPE_PLUGIN_MOTO_C, MMPluginMotoCPrivate))
-
-typedef struct {
-    GUdevClient *client;
-} MMPluginMotoCPrivate;
-
-
 G_MODULE_EXPORT MMPlugin *
 mm_plugin_create (void)
 {
-    return MM_PLUGIN (g_object_new (MM_TYPE_PLUGIN_MOTO_C, NULL));
+    return MM_PLUGIN (g_object_new (MM_TYPE_PLUGIN_MOTO_C,
+                                    MM_PLUGIN_BASE_NAME, "MotoC",
+                                    NULL));
 }
 
 /*****************************************************************************/
 
-static char *
-get_driver_name (GUdevDevice *device)
-{
-    GUdevDevice *parent = NULL;
-    const char *driver;
-    char *ret;
-
-    driver = g_udev_device_get_driver (device);
-    if (!driver) {
-        parent = g_udev_device_get_parent (device);
-        if (parent)
-            driver = g_udev_device_get_driver (parent);
-    }
-
-    if (driver)
-        ret = g_strdup (driver);
-    if (parent)
-        g_object_unref (parent);
-
-    return ret;
-}
-
-static GUdevDevice *
-find_physical_device (GUdevDevice *child)
+static void
+probe_result (MMPluginBase *base,
+              MMPluginBaseSupportsTask *task,
+              guint32 capabilities,
+              gpointer user_data)
 {
-    GUdevDevice *iter, *old = NULL;
-    const char *bus, *type;
-
-    g_return_val_if_fail (child != NULL, NULL);
-
-    bus = g_udev_device_get_property (child, "ID_BUS");
-    if (!bus)
-        return NULL;
-
-    if (strcmp (bus, "usb"))
-        return NULL;
-
-    /* Walk the parents to find the 'usb_device' for this device. */
-    iter = g_object_ref (child);
-    while (iter) {
-        type = g_udev_device_get_devtype (iter);
-        if (type && !strcmp (type, "usb_device"))
-            return iter;
+    guint32 level = 0;
 
-        old = iter;
-        iter = g_udev_device_get_parent (old);
-        g_object_unref (old);
-    }
-    g_object_unref (child);
+    if (capabilities & MM_PLUGIN_BASE_PORT_CAP_GSM)
+        level = 10;
 
-    return NULL;
+    mm_plugin_base_supports_task_complete (task, level);
 }
 
-#define PROP_GSM   "ID_MM_MODEM_GSM"
-
-static guint32
-supports_port (MMPlugin *plugin,
-               const char *subsys,
-               const char *name)
+static MMPluginSupportsResult
+supports_port (MMPluginBase *base,
+               MMModem *existing,
+               MMPluginBaseSupportsTask *task)
 {
-    MMPluginMotoCPrivate *priv = MM_PLUGIN_MOTO_C_GET_PRIVATE (plugin);
-    GUdevDevice *device, *physdev = NULL;
-    guint32 level = 0;
+    GUdevDevice *port;
     const char *tmp;
-
-    g_return_val_if_fail (plugin != NULL, 0);
-    g_return_val_if_fail (MM_IS_PLUGIN (plugin), 0);
-    g_return_val_if_fail (subsys != NULL, 0);
-    g_return_val_if_fail (name != NULL, 0);
+    guint32 cached = 0;
 
     /* Can't do anything with non-serial ports */
-    if (strcmp (subsys, "tty"))
-        return 0;
-
-    device = g_udev_client_query_by_subsystem_and_name (priv->client, subsys, name);
-    if (!device)
-        return 0;
+    port = mm_plugin_base_supports_task_get_port (task);
+    if (strcmp (g_udev_device_get_subsystem (port), "tty"))
+        return MM_PLUGIN_SUPPORTS_PORT_UNSUPPORTED;
 
-    tmp = g_udev_device_get_property (device, "ID_BUS");
+    tmp = g_udev_device_get_property (port, "ID_BUS");
     if (!tmp || strcmp (tmp, "usb"))
-        goto out;
+        return MM_PLUGIN_SUPPORTS_PORT_UNSUPPORTED;
 
-    tmp = g_udev_device_get_property (device, "ID_VENDOR_ID");
+    tmp = g_udev_device_get_property (port, "ID_VENDOR_ID");
     if (!tmp || strcmp (tmp, "22b8"))
-        goto out;
+        return MM_PLUGIN_SUPPORTS_PORT_UNSUPPORTED;
 
-    tmp = g_udev_device_get_property (device, "ID_MODEL_ID");
+    tmp = g_udev_device_get_property (port, "ID_MODEL_ID");
     if (!tmp || strcmp (tmp, "3802"))
-        goto out;
+        return MM_PLUGIN_SUPPORTS_PORT_UNSUPPORTED;
 
-    if (!g_udev_device_get_property_as_boolean (device, PROP_GSM))
-        goto out;
+    if (mm_plugin_base_get_cached_port_capabilities (base, port, &cached)) {
+        if (cached & MM_PLUGIN_BASE_PORT_CAP_GSM) {
+            mm_plugin_base_supports_task_complete (task, 10);
+            return MM_PLUGIN_SUPPORTS_PORT_IN_PROGRESS;
+        }
+        return MM_PLUGIN_SUPPORTS_PORT_UNSUPPORTED;
+    }
 
-    physdev = find_physical_device (device);
-    if (!physdev)
-        goto out;
-    g_object_unref (physdev);
-    level = 10;
+    /* Otherwise kick off a probe */
+    if (mm_plugin_base_probe_port (base, task, NULL))
+        return MM_PLUGIN_SUPPORTS_PORT_IN_PROGRESS;
 
-out:
-    g_object_unref (device);
-    return level;
+    return MM_PLUGIN_SUPPORTS_PORT_UNSUPPORTED;
 }
 
 static MMModem *
-grab_port (MMPlugin *plugin,
-           const char *subsys,
-           const char *name,
+grab_port (MMPluginBase *base,
+           MMModem *existing,
+           MMPluginBaseSupportsTask *task,
            GError **error)
 {
-    MMPluginMotoC *self = MM_PLUGIN_MOTO_C (plugin);
-    MMPluginMotoCPrivate *priv = MM_PLUGIN_MOTO_C_GET_PRIVATE (plugin);
-    GUdevDevice *device = NULL, *physdev = NULL;
-    const char *devfile, *sysfs_path;
-    char *driver = NULL;
+    GUdevDevice *port = NULL, *physdev = NULL;
     MMModem *modem = NULL;
+    const char *name, *subsys, *devfile, *sysfs_path;
 
-    g_return_val_if_fail (subsys != NULL, NULL);
-    g_return_val_if_fail (name != NULL, NULL);
-
-    /* Can't do anything with non-serial ports */
-    if (strcmp (subsys, "tty"))
-        return NULL;
-
-    device = g_udev_client_query_by_subsystem_and_name (priv->client, subsys, name);
-    if (!device) {
-        g_set_error (error, 0, 0, "Could not get port's udev device.");
-        return NULL;
-    }
-
-    if (!g_udev_device_get_property_as_boolean (device, PROP_GSM)) {
-        g_set_error (error, 0, 0, "Modem unsupported (not GSM).");
-        goto out;
-    }
-
-    physdev = find_physical_device (device);
-    if (!physdev) {
-        g_set_error (error, 0, 0, "Could not get ports's physical device.");
-        goto out;
-    }
-
-    devfile = g_udev_device_get_device_file (device);
+    devfile = g_udev_device_get_device_file (port);
     if (!devfile) {
         g_set_error (error, 0, 0, "Could not get port's sysfs file.");
-        goto out;
-    }
-
-    driver = get_driver_name (device);
-    if (!driver) {
-        g_set_error (error, 0, 0, "Could not get port's driver name.");
-        goto out;
+        return NULL;
     }
 
+    physdev = mm_plugin_base_supports_task_get_physdev (task);
+    g_assert (physdev);
     sysfs_path = g_udev_device_get_sysfs_path (physdev);
     if (!sysfs_path) {
         g_set_error (error, 0, 0, "Could not get port's physical device sysfs path.");
-        goto out;
+        return NULL;
     }
 
-    modem = mm_plugin_base_find_modem (MM_PLUGIN_BASE (self), sysfs_path);
-    if (!modem) {
+    subsys = g_udev_device_get_subsystem (port);
+    name = g_udev_device_get_name (port);
+
+    if (!existing) {
         modem = mm_modem_moto_c_gsm_new (sysfs_path,
-                                         driver,
-                                         mm_plugin_get_name (plugin));
+                                         mm_plugin_base_supports_task_get_driver (task),
+                                         mm_plugin_get_name (MM_PLUGIN (base)));
 
         if (modem) {
-            if (!mm_modem_grab_port (modem, subsys, name, error)) {
+            if (!mm_modem_grab_port (modem, subsys, name, NULL, error)) {
                 g_object_unref (modem);
-                modem = NULL;
+                return NULL;
             }
         }
-
-        if (modem)
-            mm_plugin_base_add_modem (MM_PLUGIN_BASE (self), modem);
     } else {
-        if (!mm_modem_grab_port (modem, subsys, name, error))
-            modem = NULL;
+        modem = existing;
+        if (!mm_modem_grab_port (modem, subsys, name, NULL, error))
+            return NULL;
     }
 
-out:
-    g_free (driver);
-    g_object_unref (device);
-    g_object_unref (physdev);
     return modem;
 }
 
-static const char *
-get_name (MMPlugin *plugin)
-{
-    return "MotoC";
-}
-
 /*****************************************************************************/
 
 static void
-plugin_init (MMPlugin *plugin_class)
-{
-    /* interface implementation */
-    plugin_class->get_name = get_name;
-    plugin_class->supports_port = supports_port;
-    plugin_class->grab_port = grab_port;
-}
-
-static void
 mm_plugin_moto_c_init (MMPluginMotoC *self)
 {
-    MMPluginMotoCPrivate *priv = MM_PLUGIN_MOTO_C_GET_PRIVATE (self);
-    const char *subsys[2] = { "tty", NULL };
-
-    priv->client = g_udev_client_new (subsys);
+    g_signal_connect (self, "probe-result", G_CALLBACK (probe_result), NULL);
 }
 
 static void
 dispose (GObject *object)
 {
-    MMPluginMotoCPrivate *priv = MM_PLUGIN_MOTO_C_GET_PRIVATE (object);
-
-    g_object_unref (priv->client);
 }
 
 static void
 mm_plugin_moto_c_class_init (MMPluginMotoCClass *klass)
 {
     GObjectClass *object_class = G_OBJECT_CLASS (klass);
-
-    g_type_class_add_private (object_class, sizeof (MMPluginMotoCPrivate));
+    MMPluginBaseClass *pb_class = MM_PLUGIN_BASE_CLASS (klass);
 
     object_class->dispose = dispose;
+
+    pb_class->supports_port = supports_port;
+    pb_class->grab_port = grab_port;
 }