void mm_port_probe_set_result_qmi (MMPortProbe *self, gboolean qmi) { self->priv->is_qmi = qmi; self->priv->flags |= MM_PORT_PROBE_QMI; if (self->priv->is_qmi) { mm_dbg ("(%s/%s) port is QMI-capable", g_udev_device_get_subsystem (self->priv->port), g_udev_device_get_name (self->priv->port)); /* Also set as not an AT/QCDM port */ self->priv->is_at = FALSE; self->priv->is_qcdm = FALSE; self->priv->vendor = NULL; self->priv->product = NULL; self->priv->flags |= (MM_PORT_PROBE_AT | MM_PORT_PROBE_AT_VENDOR | MM_PORT_PROBE_AT_PRODUCT | MM_PORT_PROBE_AT_ICERA | MM_PORT_PROBE_QCDM); } else mm_dbg ("(%s/%s) port is not QMI-capable", g_udev_device_get_subsystem (self->priv->port), g_udev_device_get_name (self->priv->port)); }
static char * get_bus (GUdevDevice *device) { const char *subsystem; char *bus_str; GUdevDevice *parent; bus_str = get_uinput_subsystem (device); if (bus_str) return bus_str; subsystem = g_udev_device_get_subsystem (device); parent = g_object_ref (device); while (parent && ((g_strcmp0 (subsystem, "input") == 0) || (g_strcmp0 (subsystem, "hid") == 0)) ){ GUdevDevice *old_parent = parent; parent = g_udev_device_get_parent (old_parent); if (parent) subsystem = g_udev_device_get_subsystem (parent); g_object_unref (old_parent); } if (parent) { if (g_strcmp0 (subsystem, "tty") == 0 || g_strcmp0 (subsystem, "serio") == 0) bus_str = g_strdup ("serial"); else bus_str = g_strdup (subsystem); g_object_unref (parent); } else bus_str = strdup("unknown"); return bus_str; }
void mm_port_probe_set_result_at (MMPortProbe *self, gboolean at) { self->priv->is_at = at; self->priv->flags |= MM_PORT_PROBE_AT; if (self->priv->is_at) { mm_dbg ("(%s/%s) port is AT-capable", g_udev_device_get_subsystem (self->priv->port), g_udev_device_get_name (self->priv->port)); /* Also set as not a QCDM/QMI port */ self->priv->is_qcdm = FALSE; self->priv->is_qmi = FALSE; self->priv->flags |= (MM_PORT_PROBE_QCDM | MM_PORT_PROBE_QMI); } else { mm_dbg ("(%s/%s) port is not AT-capable", g_udev_device_get_subsystem (self->priv->port), g_udev_device_get_name (self->priv->port)); self->priv->vendor = NULL; self->priv->product = NULL; self->priv->is_icera = FALSE; self->priv->flags |= (MM_PORT_PROBE_AT_VENDOR | MM_PORT_PROBE_AT_PRODUCT | MM_PORT_PROBE_AT_ICERA); } }
static void find_port_support_ready_cb (MMPluginManager *plugin_manager, GAsyncResult *result, FindPortSupportContext *ctx) { GError *error = NULL; MMPlugin *best_plugin; best_plugin = mm_plugin_manager_find_port_support_finish (plugin_manager, result, &error); if (!best_plugin) { MMBaseModem *existing; if (error) { mm_dbg ("(%s/%s): error checking support: '%s'", g_udev_device_get_subsystem (ctx->device), g_udev_device_get_name (ctx->device), error->message); g_error_free (error); } else { mm_dbg ("(%s/%s): not supported by any plugin", g_udev_device_get_subsystem (ctx->device), g_udev_device_get_name (ctx->device)); } /* So we couldn't get a plugin for this port, we should anyway check if * there is already an existing modem for the physical device, and if * so, check if it can already be exported. */ existing = find_modem_for_device ( ctx->manager, g_udev_device_get_sysfs_path (ctx->physical_device)); if (existing) check_export_modem (ctx->manager, existing); } else { mm_dbg ("(%s/%s): found plugin '%s' giving best support", g_udev_device_get_subsystem (ctx->device), g_udev_device_get_name (ctx->device), mm_plugin_get_name ((MMPlugin *)best_plugin)); grab_port (ctx->manager, best_plugin, ctx->device, ctx->physical_device); } find_port_support_context_free (ctx); }
static MMPluginSupportsResult supports_port (MMPluginBase *base, MMModem *existing, MMPluginBaseSupportsTask *task) { GUdevDevice *port; guint32 cached = 0, level; const char *driver; /* Can't do anything with non-serial ports */ port = mm_plugin_base_supports_task_get_port (task); if (strcmp (g_udev_device_get_subsystem (port), "tty")) return MM_PLUGIN_SUPPORTS_PORT_UNSUPPORTED; driver = mm_plugin_base_supports_task_get_driver (task); if (!driver || strcmp (driver, "sierra")) return MM_PLUGIN_SUPPORTS_PORT_UNSUPPORTED; if (mm_plugin_base_get_cached_port_capabilities (base, port, &cached)) { level = get_level_for_capabilities (cached); if (level) { mm_plugin_base_supports_task_complete (task, level); return MM_PLUGIN_SUPPORTS_PORT_IN_PROGRESS; } return MM_PLUGIN_SUPPORTS_PORT_UNSUPPORTED; } /* Otherwise kick off a probe */ if (mm_plugin_base_probe_port (base, task, NULL)) return MM_PLUGIN_SUPPORTS_PORT_IN_PROGRESS; return MM_PLUGIN_SUPPORTS_PORT_UNSUPPORTED; }
MMPortType mm_port_probe_get_port_type (MMPortProbe *self) { const gchar *subsys; const gchar *name; g_return_val_if_fail (MM_IS_PORT_PROBE (self), FALSE); subsys = g_udev_device_get_subsystem (self->priv->port); name = g_udev_device_get_name (self->priv->port); if (g_str_equal (subsys, "net")) return MM_PORT_TYPE_NET; #if defined WITH_QMI if (g_str_has_prefix (subsys, "usb") && g_str_has_prefix (name, "cdc-wdm") && self->priv->is_qmi) return MM_PORT_TYPE_QMI; #endif if (self->priv->flags & MM_PORT_PROBE_QCDM && self->priv->is_qcdm) return MM_PORT_TYPE_QCDM; if (self->priv->flags & MM_PORT_PROBE_AT && self->priv->is_at) return MM_PORT_TYPE_AT; return MM_PORT_TYPE_UNKNOWN; }
static char * get_driver_name (GUdevDevice *device) { GUdevDevice *parent = NULL; const char *driver, *subsys; char *ret = NULL; 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); /* Check for bluetooth; it's driver is a bunch of levels up so we * just check for the subsystem of the parent being bluetooth. */ if (!driver && parent) { subsys = g_udev_device_get_subsystem (parent); if (subsys && !strcmp (subsys, "bluetooth")) driver = "bluetooth"; } } if (driver) ret = g_strdup (driver); if (parent) g_object_unref (parent); return ret; }
void mm_plugin_base_supports_task_complete (MMPluginBaseSupportsTask *task, guint32 level) { MMPluginBaseSupportsTaskPrivate *priv; const char *subsys, *name; g_return_if_fail (task != NULL); g_return_if_fail (MM_IS_PLUGIN_BASE_SUPPORTS_TASK (task)); priv = MM_PLUGIN_BASE_SUPPORTS_TASK_GET_PRIVATE (task); g_return_if_fail (priv->callback != NULL); if (priv->full_id) { g_source_remove (priv->full_id); priv->full_id = 0; } subsys = g_udev_device_get_subsystem (priv->port); name = g_udev_device_get_name (priv->port); priv->callback (MM_PLUGIN (priv->plugin), subsys, name, level, priv->callback_data); /* Clear out the callback, it shouldn't be called more than once */ priv->callback = NULL; priv->callback_data = NULL; }
static gboolean udev_uevent_cb (GUdevClient *udev, const gchar *action, GUdevDevice *device, gpointer user_data) { FuPlugin *plugin = FU_PLUGIN(user_data); if (action == NULL) return TRUE; g_debug ("uevent for %s: (%s) %s", g_udev_device_get_name (device), g_udev_device_get_sysfs_path (device), action); /* thunderbolt device was turned on */ if (g_str_equal (g_udev_device_get_subsystem (device), "thunderbolt") && g_str_equal (action, "add")) { fu_plugin_thunderbolt_reset_timeout (plugin); /* intel-wmi-thunderbolt has been loaded/unloaded */ } else if (g_str_equal (action, "change")) { fu_plugin_thunderbolt_power_get_kernel_path (plugin); if (fu_plugin_thunderbolt_power_kernel_supported (plugin)) { fu_plugin_set_enabled (plugin, TRUE); fu_plugin_request_recoldplug (plugin); } else { fu_plugin_set_enabled (plugin, FALSE); } } return TRUE; }
static void _on_uevent(GUdevClient *client, gchar *action, GUdevDevice *device, gpointer user_data) { TcoreUdev *udev = user_data; GSList *cb = NULL; struct udev_callback_type *node; if (!udev) return; dbg("action = '%s'", action); for (cb = udev->callbacks; cb; cb = cb->next) { node = cb->data; if (!node) continue; if (node->action) if (g_strcmp0(node->action, action) != 0) continue; if (node->subsystem) if (g_strcmp0(node->subsystem, g_udev_device_get_subsystem(device)) != 0) continue; if (!node->func) continue; node->func(udev, device, node->user_data); } }
static void handle_uevent (GUdevClient *client, const char *action, GUdevDevice *device, gpointer user_data) { MMManager *self = MM_MANAGER (user_data); const char *subsys; g_return_if_fail (action != NULL); /* A bit paranoid */ subsys = g_udev_device_get_subsystem (device); g_return_if_fail (subsys != NULL); g_return_if_fail (!strcmp (subsys, "tty") || !strcmp (subsys, "net") || !strcmp (subsys, "usb")); /* We only care about tty/net devices when adding modem ports, * but for remove, also handle usb parent device remove events */ if ( (!strcmp (action, "add") || !strcmp (action, "move") || !strcmp (action, "change")) && (strcmp (subsys, "usb") != 0)) device_added (self, device); else if (!strcmp (action, "remove")) device_removed (self, device); }
static void handle_uevent (GUdevClient *client, const char *action, GUdevDevice *device, gpointer user_data) { MMBaseManager *self = MM_BASE_MANAGER (user_data); const gchar *subsys; const gchar *name; g_return_if_fail (action != NULL); /* A bit paranoid */ subsys = g_udev_device_get_subsystem (device); g_return_if_fail (subsys != NULL); g_return_if_fail (g_str_equal (subsys, "tty") || g_str_equal (subsys, "net") || g_str_has_prefix (subsys, "usb")); /* We only care about tty/net and usb/cdc-wdm devices when adding modem ports, * but for remove, also handle usb parent device remove events */ name = g_udev_device_get_name (device); if ( (g_str_equal (action, "add") || g_str_equal (action, "move") || g_str_equal (action, "change")) && (!g_str_has_prefix (subsys, "usb") || (name && g_str_has_prefix (name, "cdc-wdm")))) device_added (self, device, TRUE, FALSE); else if (g_str_equal (action, "remove")) device_removed (self, device); }
const gchar * mm_port_probe_get_port_subsys (MMPortProbe *self) { g_return_val_if_fail (MM_IS_PORT_PROBE (self), NULL); return g_udev_device_get_subsystem (self->priv->port); }
static void handle_uevent (GUdevClient *client, const char *action, GUdevDevice *device, gpointer user_data) { NMRfkillManager *self = NM_RFKILL_MANAGER (user_data); const char *subsys; g_return_if_fail (action != NULL); /* A bit paranoid */ subsys = g_udev_device_get_subsystem (device); g_return_if_fail (!g_strcmp0 (subsys, "rfkill")); nm_log_dbg (LOGD_HW, "udev rfkill event: action '%s' device '%s'", action, g_udev_device_get_name (device)); if (!strcmp (action, "add")) rfkill_add (self, device); else if (!strcmp (action, "remove")) rfkill_remove (self, device); recheck_killswitches (self); }
static gboolean serial_probe_at (MMPortProbe *self) { PortProbeRunTask *task = self->priv->task; task->source_id = 0; /* If already cancelled, do nothing else */ if (port_probe_run_is_cancelled (self)) return FALSE; /* If AT probing cancelled, end this partial probing */ if (g_cancellable_is_cancelled (task->at_probing_cancellable)) { mm_dbg ("(%s/%s) no need to launch probing for AT support", g_udev_device_get_subsystem (self->priv->port), g_udev_device_get_name (self->priv->port)); task->at_result_processor (self, NULL); serial_probe_schedule (self); return FALSE; } mm_at_serial_port_queue_command ( MM_AT_SERIAL_PORT (task->serial), task->at_commands->command, task->at_commands->timeout, FALSE, task->at_probing_cancellable, (MMAtSerialResponseFn)serial_probe_at_parse_response, self); return FALSE; }
/* Returns TRUE if the support check request was filtered out */ static gboolean apply_subsystem_filter (MMPlugin *self, GUdevDevice *port) { if (self->priv->subsystems) { const gchar *subsys; guint i; subsys = g_udev_device_get_subsystem (port); for (i = 0; self->priv->subsystems[i]; i++) { if (g_str_equal (subsys, self->priv->subsystems[i])) break; /* New kernels may report as 'usbmisc' the subsystem */ else if (g_str_equal (self->priv->subsystems[i], "usb") && g_str_equal (subsys, "usbmisc")) break; } /* If we didn't match any subsystem: unsupported */ if (!self->priv->subsystems[i]) return TRUE; } return FALSE; }
static gboolean wdm_probe_qmi (MMPortProbe *self) { PortProbeRunTask *task = self->priv->task; /* If already cancelled, do nothing else */ if (port_probe_run_is_cancelled (self)) return FALSE; #if defined WITH_QMI mm_dbg ("(%s/%s) probing QMI...", g_udev_device_get_subsystem (self->priv->port), g_udev_device_get_name (self->priv->port)); /* Create a port and try to open it */ task->qmi_port = mm_qmi_port_new (g_udev_device_get_name (self->priv->port)); mm_qmi_port_open (task->qmi_port, FALSE, NULL, (GAsyncReadyCallback)qmi_port_open_ready, self); #else /* If not compiled with QMI support, just assume we won't have any QMI port */ mm_port_probe_set_result_qmi (self, FALSE); port_probe_run_task_complete (task, TRUE, NULL); #endif /* WITH_QMI */ return FALSE; }
static void qmi_port_open_ready (MMQmiPort *qmi_port, GAsyncResult *res, MMPortProbe *self) { PortProbeRunTask *task = self->priv->task; GError *error = NULL; gboolean is_qmi; is_qmi = mm_qmi_port_open_finish (qmi_port, res, &error); if (!is_qmi) { mm_dbg ("(%s/%s) error checking QMI support: '%s'", g_udev_device_get_subsystem (self->priv->port), g_udev_device_get_name (self->priv->port), error ? error->message : "unknown error"); g_clear_error (&error); } /* Set probing result */ mm_port_probe_set_result_qmi (self, is_qmi); mm_qmi_port_close (qmi_port); /* All done! Finish asynchronously */ port_probe_run_task_complete (task, TRUE, NULL); }
static void grab_port (MMManager *manager, MMPlugin *plugin, GUdevDevice *device, GUdevDevice *physical_device) { GError *error = NULL; MMBaseModem *modem; MMBaseModem *existing; existing = g_hash_table_lookup (manager->priv->modems, g_udev_device_get_sysfs_path (physical_device)); /* While grabbing the first port, modem will get created */ modem = mm_plugin_grab_port (plugin, g_udev_device_get_subsystem (device), g_udev_device_get_name (device), existing, &error); if (!modem) { mm_warn ("plugin '%s' claimed to support %s/%s but couldn't: (%d) %s", mm_plugin_get_name (plugin), g_udev_device_get_subsystem (device), g_udev_device_get_name (device), error ? error->code : -1, (error && error->message) ? error->message : "(unknown)"); g_clear_error (&error); if (existing) check_export_modem (manager, existing); return; } mm_info ("(%s): modem %s claimed port %s", mm_plugin_get_name (plugin), mm_base_modem_get_device (modem), g_udev_device_get_name (device)); if (existing) { g_assert (existing == modem); check_export_modem (manager, modem); } else { /* If the modem was just created, store it */ add_modem (manager, modem, plugin); } }
static Killswitch * killswitch_new (GUdevDevice *device, RfKillType rtype) { Killswitch *ks; GUdevDevice *parent = NULL, *grandparent = NULL; const char *driver, *subsys, *parent_subsys = NULL; ks = g_malloc0 (sizeof (Killswitch)); ks->name = g_strdup (g_udev_device_get_name (device)); ks->seqnum = g_udev_device_get_seqnum (device); ks->path = g_strdup (g_udev_device_get_sysfs_path (device)); ks->rtype = rtype; driver = g_udev_device_get_property (device, "DRIVER"); subsys = g_udev_device_get_subsystem (device); /* Check parent for various attributes */ parent = g_udev_device_get_parent (device); if (parent) { parent_subsys = g_udev_device_get_subsystem (parent); if (!driver) driver = g_udev_device_get_property (parent, "DRIVER"); if (!driver) { /* Sigh; try the grandparent */ grandparent = g_udev_device_get_parent (parent); if (grandparent) driver = g_udev_device_get_property (grandparent, "DRIVER"); } } if (!driver) driver = "(unknown)"; ks->driver = g_strdup (driver); if ( g_strcmp0 (subsys, "platform") == 0 || g_strcmp0 (parent_subsys, "platform") == 0 || g_strcmp0 (subsys, "acpi") == 0 || g_strcmp0 (parent_subsys, "acpi") == 0) ks->platform = TRUE; if (grandparent) g_object_unref (grandparent); if (parent) g_object_unref (parent); return ks; }
void mm_port_probe_set_result_at_product (MMPortProbe *self, const gchar *at_product) { if (at_product) { mm_dbg ("(%s/%s) product probing finished", g_udev_device_get_subsystem (self->priv->port), g_udev_device_get_name (self->priv->port)); self->priv->product = g_utf8_casefold (at_product, -1); self->priv->flags |= MM_PORT_PROBE_AT_PRODUCT; } else { mm_dbg ("(%s/%s) couldn't probe for product string", g_udev_device_get_subsystem (self->priv->port), g_udev_device_get_name (self->priv->port)); self->priv->product = NULL; self->priv->flags |= MM_PORT_PROBE_AT_PRODUCT; } }
void mm_port_probe_set_result_at_icera (MMPortProbe *self, gboolean is_icera) { if (is_icera) { mm_dbg ("(%s/%s) Modem is Icera-based", g_udev_device_get_subsystem (self->priv->port), g_udev_device_get_name (self->priv->port)); self->priv->is_icera = TRUE; self->priv->flags |= MM_PORT_PROBE_AT_ICERA; } else { mm_dbg ("(%s/%s) Modem is NOT Icera-based", g_udev_device_get_subsystem (self->priv->port), g_udev_device_get_name (self->priv->port)); self->priv->is_icera = FALSE; self->priv->flags |= MM_PORT_PROBE_AT_ICERA; } }
static MMModem * grab_port (MMPluginBase *base, MMModem *existing, MMPluginBaseSupportsTask *task, GError **error) { GUdevDevice *port = NULL; MMModem *modem = NULL; const char *name, *subsys, *devfile, *sysfs_path; guint32 caps; MMPortType ptype = MM_PORT_TYPE_UNKNOWN; port = mm_plugin_base_supports_task_get_port (task); g_assert (port); devfile = g_udev_device_get_device_file (port); if (!devfile) { g_set_error (error, 0, 0, "Could not get port's sysfs file."); return NULL; } subsys = g_udev_device_get_subsystem (port); name = g_udev_device_get_name (port); /* Is it a GSM secondary port? */ if (g_object_get_data (G_OBJECT (task), TAG_SIERRA_SECONDARY_PORT)) ptype = MM_PORT_TYPE_SECONDARY; caps = mm_plugin_base_supports_task_get_probed_capabilities (task); sysfs_path = mm_plugin_base_supports_task_get_physdev_path (task); if (!existing) { if ((caps & MM_PLUGIN_BASE_PORT_CAP_GSM) || (ptype != MM_PORT_TYPE_UNKNOWN)) { modem = mm_modem_sierra_gsm_new (sysfs_path, mm_plugin_base_supports_task_get_driver (task), mm_plugin_get_name (MM_PLUGIN (base))); } else if (caps & CAP_CDMA) { modem = mm_modem_sierra_cdma_new (sysfs_path, mm_plugin_base_supports_task_get_driver (task), mm_plugin_get_name (MM_PLUGIN (base)), !!(caps & MM_PLUGIN_BASE_PORT_CAP_IS856), !!(caps & MM_PLUGIN_BASE_PORT_CAP_IS856_A)); } if (modem) { if (!mm_modem_grab_port (modem, subsys, name, ptype, NULL, error)) { g_object_unref (modem); return NULL; } } } else if (get_level_for_capabilities (caps) || (ptype != MM_PORT_TYPE_UNKNOWN)) { modem = existing; if (!mm_modem_grab_port (modem, subsys, name, ptype, NULL, error)) return NULL; } return modem; }
static void device_removed (MMBaseManager *self, GUdevDevice *udev_device) { MMDevice *device; const gchar *subsys; const gchar *name; g_return_if_fail (udev_device != NULL); subsys = g_udev_device_get_subsystem (udev_device); name = g_udev_device_get_name (udev_device); if (!g_str_has_prefix (subsys, "usb") || (name && g_str_has_prefix (name, "cdc-wdm"))) { /* Handle tty/net/wdm port removal */ device = find_device_by_port (self, udev_device); if (device) { mm_info ("(%s/%s): released by modem %s", subsys, name, g_udev_device_get_sysfs_path (mm_device_peek_udev_device (device))); mm_device_release_port (device, udev_device); /* If port probe list gets empty, remove the device object iself */ if (!mm_device_peek_port_probe_list (device)) { mm_dbg ("Removing empty device '%s'", mm_device_get_path (device)); if (mm_plugin_manager_device_support_check_cancel (self->priv->plugin_manager, device)) mm_dbg ("Device support check has been cancelled"); mm_device_remove_modem (device); g_hash_table_remove (self->priv->devices, mm_device_get_path (device)); } } return; } /* This case is designed to handle the case where, at least with kernel 2.6.31, unplugging * an in-use ttyACMx device results in udev generating remove events for the usb, but the * ttyACMx device (subsystem tty) is not removed, since it was in-use. So if we have not * found a modem for the port (above), we're going to look here to see if we have a modem * associated with the newly removed device. If so, we'll remove the modem, since the * device has been removed. That way, if the device is reinserted later, we'll go through * the process of exporting it. */ device = find_device_by_udev_device (self, udev_device); if (device) { mm_dbg ("Removing device '%s'", mm_device_get_path (device)); mm_device_remove_modem (device); g_hash_table_remove (self->priv->devices, mm_device_get_path (device)); return; } /* Maybe a plugin is checking whether or not the port is supported. * TODO: Cancel every possible supports check in this port. */ }
static MMPluginSupportsResult supports_port (MMPluginBase *base, MMModem *existing, MMPluginBaseSupportsTask *task) { GUdevDevice *port; const char *subsys, *name; guint16 vendor = 0; /* Can't do anything with non-serial ports */ port = mm_plugin_base_supports_task_get_port (task); if (strcmp (g_udev_device_get_subsystem (port), "tty")) return MM_PLUGIN_SUPPORTS_PORT_UNSUPPORTED; subsys = g_udev_device_get_subsystem (port); name = g_udev_device_get_name (port); if (!mm_plugin_base_get_device_ids (base, subsys, name, &vendor, NULL)) return MM_PLUGIN_SUPPORTS_PORT_UNSUPPORTED; /* Vendor: Wavecom */ if (vendor != 0x114f) return MM_PLUGIN_SUPPORTS_PORT_UNSUPPORTED; /* Check if a previous probing was already launched in this port */ if (mm_plugin_base_supports_task_propagate_cached (task)) { guint32 level; /* A previous probing was already done, use its results */ level = get_level_for_capabilities (mm_plugin_base_supports_task_get_probed_capabilities (task)); if (level) { mm_plugin_base_supports_task_complete (task, level); return MM_PLUGIN_SUPPORTS_PORT_IN_PROGRESS; } return MM_PLUGIN_SUPPORTS_PORT_UNSUPPORTED; } /* Otherwise kick off a probe */ if (mm_plugin_base_probe_port (base, task, 100000, NULL)) return MM_PLUGIN_SUPPORTS_PORT_IN_PROGRESS; return MM_PLUGIN_SUPPORTS_PORT_UNSUPPORTED; }
static gboolean iio_buffer_light_discover (GUdevDevice *device) { if (g_strcmp0 (g_udev_device_get_subsystem (device), "iio") != 0) return FALSE; if (g_strcmp0 ("als", g_udev_device_get_sysfs_attr (device, "name")) != 0) return FALSE; g_debug ("Found als at %s", g_udev_device_get_sysfs_path (device)); return TRUE; }
gboolean mm_port_probe_is_icera (MMPortProbe *self) { g_return_val_if_fail (MM_IS_PORT_PROBE (self), FALSE); if (g_str_equal (g_udev_device_get_subsystem (self->priv->port), "net")) return FALSE; return (self->priv->flags & MM_PORT_PROBE_AT_ICERA ? self->priv->is_icera : FALSE); }
static gboolean iio_poll_accel_discover (GUdevDevice *device) { if (g_strcmp0 (g_udev_device_get_subsystem (device), "iio") != 0) return FALSE; if (g_strcmp0 ("i2c-SMO8500:00", g_udev_device_get_sysfs_attr (device, "name")) != 0) return FALSE; g_debug ("Found polling accelerometer at %s", g_udev_device_get_sysfs_path (device)); return TRUE; }
static MMPluginSupportsResult supports_port (MMPluginBase *base, MMModem *existing, MMPluginBaseSupportsTask *task) { GUdevDevice *port; guint32 cached = 0, level; guint16 vendor = 0; const char *subsys, *name; /* Can't do anything with non-serial ports */ port = mm_plugin_base_supports_task_get_port (task); if (strcmp (g_udev_device_get_subsystem (port), "tty")) return MM_PLUGIN_SUPPORTS_PORT_UNSUPPORTED; subsys = g_udev_device_get_subsystem (port); name = g_udev_device_get_name (port); if (!mm_plugin_base_get_device_ids (base, subsys, name, &vendor, NULL)) return MM_PLUGIN_SUPPORTS_PORT_UNSUPPORTED; /* Longcheer and TAMobile */ if (vendor != 0x1c9e && vendor != 0x1bbb) return MM_PLUGIN_SUPPORTS_PORT_UNSUPPORTED; if (mm_plugin_base_get_cached_port_capabilities (base, port, &cached)) { level = get_level_for_capabilities (cached); if (level) { mm_plugin_base_supports_task_complete (task, level); return MM_PLUGIN_SUPPORTS_PORT_IN_PROGRESS; } return MM_PLUGIN_SUPPORTS_PORT_UNSUPPORTED; } /* Otherwise kick off a probe */ if (mm_plugin_base_probe_port (base, task, NULL)) return MM_PLUGIN_SUPPORTS_PORT_IN_PROGRESS; return MM_PLUGIN_SUPPORTS_PORT_UNSUPPORTED; }
static MMModem * grab_port (MMPluginBase *base, MMModem *existing, MMPluginBaseSupportsTask *task, GError **error) { GUdevDevice *port = NULL; MMModem *modem = NULL; const char *name, *subsys, *sysfs_path; guint32 caps; guint16 vendor = 0, product = 0; MMPortType ptype; port = mm_plugin_base_supports_task_get_port (task); g_assert (port); subsys = g_udev_device_get_subsystem (port); name = g_udev_device_get_name (port); if (!mm_plugin_base_get_device_ids (base, subsys, name, &vendor, &product)) { g_set_error (error, 0, 0, "Could not get modem product ID."); return NULL; } caps = mm_plugin_base_supports_task_get_probed_capabilities (task); ptype = mm_plugin_base_probed_capabilities_to_port_type (caps); sysfs_path = mm_plugin_base_supports_task_get_physdev_path (task); if (!existing) { if (caps & MM_PLUGIN_BASE_PORT_CAP_GSM) { modem = mm_modem_wavecom_gsm_new (sysfs_path, mm_plugin_base_supports_task_get_driver (task), mm_plugin_get_name (MM_PLUGIN (base)), vendor, product); } if (modem) { if (!mm_modem_grab_port (modem, subsys, name, ptype, MM_AT_PORT_FLAG_NONE, NULL, error)) { g_object_unref (modem); return NULL; } } } else if (get_level_for_capabilities (caps)) { modem = existing; if (!mm_modem_grab_port (modem, subsys, name, ptype, MM_AT_PORT_FLAG_NONE, NULL, error)) return NULL; } return modem; }