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));
}
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 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;
}
void
mm_base_manager_start (MMBaseManager *manager,
gboolean manual_scan)
{
GList *devices, *iter;
g_return_if_fail (manager != NULL);
g_return_if_fail (MM_IS_BASE_MANAGER (manager));
if (!manager->priv->auto_scan && !manual_scan)
return;
mm_dbg ("Starting %s device scan...", manual_scan ? "manual" : "automatic");
devices = g_udev_client_query_by_subsystem (manager->priv->udev, "tty");
for (iter = devices; iter; iter = g_list_next (iter)) {
start_device_added (manager, G_UDEV_DEVICE (iter->data), manual_scan);
g_object_unref (G_OBJECT (iter->data));
}
g_list_free (devices);
devices = g_udev_client_query_by_subsystem (manager->priv->udev, "net");
for (iter = devices; iter; iter = g_list_next (iter)) {
start_device_added (manager, G_UDEV_DEVICE (iter->data), manual_scan);
g_object_unref (G_OBJECT (iter->data));
}
g_list_free (devices);
devices = g_udev_client_query_by_subsystem (manager->priv->udev, "usb");
for (iter = devices; iter; iter = g_list_next (iter)) {
const gchar *name;
name = g_udev_device_get_name (G_UDEV_DEVICE (iter->data));
if (name && g_str_has_prefix (name, "cdc-wdm"))
start_device_added (manager, G_UDEV_DEVICE (iter->data), manual_scan);
g_object_unref (G_OBJECT (iter->data));
}
g_list_free (devices);
/* Newer kernels report 'usbmisc' subsystem */
devices = g_udev_client_query_by_subsystem (manager->priv->udev, "usbmisc");
for (iter = devices; iter; iter = g_list_next (iter)) {
const gchar *name;
name = g_udev_device_get_name (G_UDEV_DEVICE (iter->data));
if (name && g_str_has_prefix (name, "cdc-wdm"))
start_device_added (manager, G_UDEV_DEVICE (iter->data), manual_scan);
g_object_unref (G_OBJECT (iter->data));
}
g_list_free (devices);
mm_dbg ("Finished device scan...");
}
void
mm_manager_start (MMManager *manager)
{
GList *devices, *iter;
g_return_if_fail (manager != NULL);
g_return_if_fail (MM_IS_MANAGER (manager));
mm_dbg ("Starting device scan...");
devices = g_udev_client_query_by_subsystem (manager->priv->udev, "tty");
for (iter = devices; iter; iter = g_list_next (iter)) {
device_added (manager, G_UDEV_DEVICE (iter->data), FALSE);
g_object_unref (G_OBJECT (iter->data));
}
g_list_free (devices);
devices = g_udev_client_query_by_subsystem (manager->priv->udev, "net");
for (iter = devices; iter; iter = g_list_next (iter)) {
device_added (manager, G_UDEV_DEVICE (iter->data), FALSE);
g_object_unref (G_OBJECT (iter->data));
}
g_list_free (devices);
devices = g_udev_client_query_by_subsystem (manager->priv->udev, "usb");
for (iter = devices; iter; iter = g_list_next (iter)) {
const gchar *name;
name = g_udev_device_get_name (G_UDEV_DEVICE (iter->data));
if (name && g_str_has_prefix (name, "cdc-wdm"))
device_added (manager, G_UDEV_DEVICE (iter->data), FALSE);
g_object_unref (G_OBJECT (iter->data));
}
g_list_free (devices);
/* Newer kernels report 'usbmisc' subsystem */
devices = g_udev_client_query_by_subsystem (manager->priv->udev, "usbmisc");
for (iter = devices; iter; iter = g_list_next (iter)) {
const gchar *name;
name = g_udev_device_get_name (G_UDEV_DEVICE (iter->data));
if (name && g_str_has_prefix (name, "cdc-wdm"))
device_added (manager, G_UDEV_DEVICE (iter->data), FALSE);
g_object_unref (G_OBJECT (iter->data));
}
g_list_free (devices);
mm_dbg ("Finished device scan...");
}
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);
}
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;
}
const gchar *
mm_port_probe_get_port_name (MMPortProbe *self)
{
g_return_val_if_fail (MM_IS_PORT_PROBE (self), NULL);
return g_udev_device_get_name (self->priv->port);
}
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 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 void
udev_device_added (SettingsPluginIfupdown *self, GUdevDevice *device)
{
SettingsPluginIfupdownPrivate *priv = SETTINGS_PLUGIN_IFUPDOWN_GET_PRIVATE (self);
const char *iface, *path;
NMIfupdownConnection *exported;
iface = g_udev_device_get_name (device);
path = g_udev_device_get_sysfs_path (device);
if (!iface || !path)
return;
nm_log_info (LOGD_SETTINGS, "devices added (path: %s, iface: %s)", path, iface);
/* if we have a configured connection for this particular iface
* we want to either unmanage the device or lock it
*/
exported = g_hash_table_lookup (priv->connections, iface);
if (!exported && !g_hash_table_lookup (priv->eni_ifaces, iface)) {
nm_log_info (LOGD_SETTINGS, "device added (path: %s, iface: %s): no ifupdown configuration found.",
path, iface);
return;
}
g_hash_table_insert (priv->kernel_ifaces, g_strdup (iface), g_object_ref (device));
if (exported)
bind_device_to_connection (self, device, exported);
if (ALWAYS_UNMANAGE || priv->unmanage_well_known)
g_signal_emit_by_name (G_OBJECT (self), NM_SETTINGS_PLUGIN_UNMANAGED_SPECS_CHANGED);
}
static void
storaged_linux_block_object_constructed (GObject *_object)
{
StoragedLinuxBlockObject *object = STORAGED_LINUX_BLOCK_OBJECT (_object);
GString *str;
object->mount_monitor = storaged_daemon_get_mount_monitor (object->daemon);
g_signal_connect (object->mount_monitor,
"mount-added",
G_CALLBACK (on_mount_monitor_mount_added),
object);
g_signal_connect (object->mount_monitor,
"mount-removed",
G_CALLBACK (on_mount_monitor_mount_removed),
object);
/* initial coldplug */
storaged_linux_block_object_uevent (object, "add", NULL);
/* compute the object path */
str = g_string_new ("/org/storaged/Storaged/block_devices/");
storaged_safe_append_to_object_path (str, g_udev_device_get_name (object->device->udev_device));
g_dbus_object_skeleton_set_object_path (G_DBUS_OBJECT_SKELETON (object), str->str);
g_string_free (str, TRUE);
if (G_OBJECT_CLASS (storaged_linux_block_object_parent_class)->constructed != NULL)
G_OBJECT_CLASS (storaged_linux_block_object_parent_class)->constructed (_object);
}
static gboolean
disk_is_partitioned_by_kernel (GUdevDevice *device)
{
gboolean ret = FALSE;
GDir *dir = NULL;
const gchar *name;
const gchar *device_name;
g_return_val_if_fail (g_strcmp0 (g_udev_device_get_devtype (device), "disk") == 0, FALSE);
dir = g_dir_open (g_udev_device_get_sysfs_path (device), 0 /* flags */, NULL /* GError */);
if (dir == NULL)
goto out;
device_name = g_udev_device_get_name (device);
while ((name = g_dir_read_name (dir)) != NULL)
{
/* TODO: could check that it's a block device - for now, just
* checking the name suffices
*/
if (g_str_has_prefix (name, device_name))
{
ret = TRUE;
goto out;
}
}
out:
if (dir != NULL)
g_dir_close (dir);
return ret;
}
static void
adsl_remove (NMAtmManager *self, GUdevDevice *device)
{
nm_log_dbg (LOGD_HW, "adsl_remove: Removing ATM Device");
g_signal_emit (self, signals[DEVICE_REMOVED], 0, g_udev_device_get_name (device));
}
static gboolean
iio_buffer_light_open (GUdevDevice *device,
ReadingsUpdateFunc callback_func,
gpointer user_data)
{
char *trigger_name;
drv_data = g_new0 (DrvData, 1);
/* Get the trigger name, and build the channels from that */
trigger_name = get_trigger_name (device);
if (!trigger_name) {
g_clear_pointer (&drv_data, g_free);
return FALSE;
}
drv_data->buffer_data = buffer_drv_data_new (device, trigger_name);
g_free (trigger_name);
if (!drv_data->buffer_data) {
g_clear_pointer (&drv_data, g_free);
return FALSE;
}
drv_data->dev = g_object_ref (device);
drv_data->dev_path = g_udev_device_get_device_file (device);
drv_data->name = g_udev_device_get_property (device, "NAME");
if (!drv_data->name)
drv_data->name = g_udev_device_get_name (device);
drv_data->callback_func = callback_func;
drv_data->user_data = user_data;
return TRUE;
}
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;
}
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 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
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);
}
static void
try_qcdm_probe (MMPluginBaseSupportsTask *task)
{
MMPluginBaseSupportsTaskPrivate *priv = MM_PLUGIN_BASE_SUPPORTS_TASK_GET_PRIVATE (task);
const char *name;
GError *error = NULL;
GByteArray *verinfo = NULL, *verinfo2;
gint len;
/* Close the AT port */
if (priv->probe_port) {
mm_serial_port_close (MM_SERIAL_PORT (priv->probe_port));
g_object_unref (priv->probe_port);
priv->probe_port = NULL;
}
/* Open the QCDM port */
name = g_udev_device_get_name (priv->port);
g_assert (name);
priv->qcdm_port = mm_qcdm_serial_port_new (name, MM_PORT_TYPE_PRIMARY);
if (priv->qcdm_port == NULL) {
g_warning ("(%s) failed to create new QCDM serial port.", name);
probe_complete (task);
return;
}
if (!mm_serial_port_open (MM_SERIAL_PORT (priv->qcdm_port), &error)) {
g_warning ("(%s) failed to open new QCDM serial port: (%d) %s.",
name,
error ? error->code : -1,
error && error->message ? error->message : "(unknown)");
g_clear_error (&error);
probe_complete (task);
return;
}
/* Build up the probe command */
verinfo = g_byte_array_sized_new (50);
len = qcdm_cmd_version_info_new ((char *) verinfo->data, 50, &error);
if (len <= 0) {
g_byte_array_free (verinfo, TRUE);
g_warning ("(%s) failed to create QCDM version info command: (%d) %s.",
name,
error ? error->code : -1,
error && error->message ? error->message : "(unknown)");
g_clear_error (&error);
probe_complete (task);
return;
}
verinfo->len = len;
/* Queuing the command takes ownership over it; copy it for the second try */
verinfo2 = g_byte_array_sized_new (verinfo->len);
g_byte_array_append (verinfo2, verinfo->data, verinfo->len);
/* Send the command twice; the ports often need to be woken up */
mm_qcdm_serial_port_queue_command (priv->qcdm_port, verinfo, 3, qcdm_verinfo_cb, NULL);
mm_qcdm_serial_port_queue_command (priv->qcdm_port, verinfo2, 3, qcdm_verinfo_cb, task);
}
static gboolean
dummy_loop_object_should_include_device (StoragedLinuxDevice *device)
{
const gchar *device_name;
device_name = g_udev_device_get_name (device->udev_device);
return g_str_has_prefix (device_name, "loop");
}
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 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;
}
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;
}
}
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;
}
}
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 gboolean
loop_check (UDisksLinuxBlockObject *object)
{
gboolean ret;
ret = FALSE;
if (g_str_has_prefix (g_udev_device_get_name (object->device->udev_device), "loop") &&
g_strcmp0 (g_udev_device_get_devtype (object->device->udev_device), "disk") == 0)
ret = TRUE;
return ret;
}
static void
rfkill_add (NMRfkillManager *self, GUdevDevice *device)
{
const char *name;
g_return_if_fail (device != NULL);
name = g_udev_device_get_name (device);
g_return_if_fail (name != NULL);
if (!killswitch_find_by_name (self, name))
add_one_killswitch (self, device);
}
gboolean
mm_plugin_base_get_cached_port_capabilities (MMPluginBase *self,
GUdevDevice *port,
guint32 *capabilities)
{
gpointer tmp = NULL;
gboolean found;
found = g_hash_table_lookup_extended (cached_caps, g_udev_device_get_name (port), NULL, tmp);
*capabilities = GPOINTER_TO_UINT (tmp);
return found;
}
static gboolean
loop_check (StoragedObject *object)
{
StoragedLinuxBlockObject *block_object = STORAGED_LINUX_BLOCK_OBJECT (object);
gboolean ret;
ret = FALSE;
if (g_str_has_prefix (g_udev_device_get_name (block_object->device->udev_device), "loop") &&
g_strcmp0 (g_udev_device_get_devtype (block_object->device->udev_device), "disk") == 0)
ret = TRUE;
return ret;
}
