/**
* gmw_probe_device_reset:
**/
static gboolean
gmw_probe_device_reset (GmwProbeDevice *dev, GError **error)
{
int fd;
const gchar *devnode;
/* just reset device */
devnode = g_udev_device_get_device_file (dev->udev_device);
g_debug ("Resetting %s", devnode);
fd = g_open (devnode, O_WRONLY | O_NONBLOCK);
if (fd < 0) {
g_set_error (error,
GMW_ERROR,
GMW_ERROR_FAILED,
"Failed to open %s", devnode);
return FALSE;
}
if (ioctl (fd, USBDEVFS_RESET) != 0) {
g_set_error (error,
GMW_ERROR,
GMW_ERROR_FAILED,
"Failed to reset device");
close (fd);
return FALSE;
}
close (fd);
return TRUE;
}
/**
* cd_sensor_client_add:
**/
static gboolean
cd_sensor_client_add (CdSensorClient *sensor_client,
GUdevDevice *device)
{
CdSensor *sensor = NULL;
const gchar *device_file;
const gchar *tmp;
gboolean ret = FALSE;
GError *error = NULL;
/* interesting device? */
tmp = g_udev_device_get_property (device, "COLORD_SENSOR_KIND");
if (tmp == NULL)
goto out;
tmp = g_udev_device_get_property (device, "COLORD_IGNORE");
if (tmp != NULL)
goto out;
/* actual device? */
device_file = g_udev_device_get_device_file (device);
if (device_file == NULL)
goto out;
/* get data */
g_debug ("adding color management device: %s [%s]",
g_udev_device_get_sysfs_path (device),
device_file);
sensor = cd_sensor_new ();
ret = cd_sensor_set_from_device (sensor, device, &error);
if (!ret) {
g_warning ("CdSensorClient: failed to set CM sensor: %s",
error->message);
g_error_free (error);
goto out;
}
/* set the index */
cd_sensor_set_index (sensor, sensor_client->priv->idx);
/* load the sensor */
ret = cd_sensor_load (sensor, &error);
if (!ret) {
/* not fatal, non-native devices are still useable */
g_debug ("CdSensorClient: failed to load native sensor: %s",
error->message);
g_clear_error (&error);
}
/* signal the addition */
g_debug ("emit: added");
g_signal_emit (sensor_client, signals[SIGNAL_SENSOR_ADDED], 0, sensor);
sensor_client->priv->idx++;
/* keep track so we can remove with the same device */
g_ptr_array_add (sensor_client->priv->array_sensors, g_object_ref (sensor));
out:
if (sensor != NULL)
g_object_unref (sensor);
return ret;
}
static gboolean
input_accel_open (GUdevDevice *device,
ReadingsUpdateFunc callback_func,
gpointer user_data)
{
const gchar * const subsystems[] = { "input", NULL };
const char *mount_matrix;
drv_data = g_new0 (DrvData, 1);
drv_data->dev = g_object_ref (device);
drv_data->parent = g_udev_device_get_parent (drv_data->dev);
drv_data->dev_path = g_udev_device_get_device_file (device);
drv_data->name = g_udev_device_get_property (device, "NAME");
drv_data->client = g_udev_client_new (subsystems);
mount_matrix = g_udev_device_get_property (device, "ACCEL_MOUNT_MATRIX");
if (!parse_mount_matrix (mount_matrix, &drv_data->mount_matrix)) {
g_warning ("Invalid mount-matrix ('%s'), falling back to identity",
mount_matrix);
parse_mount_matrix (NULL, &drv_data->mount_matrix);
}
drv_data->callback_func = callback_func;
drv_data->user_data = user_data;
g_signal_connect (drv_data->client, "uevent",
G_CALLBACK (uevent_received), NULL);
g_idle_add (first_values, NULL);
return TRUE;
}
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->callback_func = callback_func;
drv_data->user_data = user_data;
return TRUE;
}
/**
* udisks_daemon_util_block_get_size:
* @device: A #GUdevDevice for a top-level block device.
* @out_media_available: (out): Return location for whether media is available or %NULL.
* @out_media_change_detected: (out): Return location for whether media change is detected or %NULL.
*
* Gets the size of the @device top-level block device, checking for media in the process
*
* Returns: The size of @device or 0 if no media is available or if unknown.
*/
guint64
udisks_daemon_util_block_get_size (GUdevDevice *device,
gboolean *out_media_available,
gboolean *out_media_change_detected)
{
gboolean media_available = FALSE;
gboolean media_change_detected = TRUE;
guint64 size = 0;
/* figuring out if media is available is a bit tricky */
if (g_udev_device_get_sysfs_attr_as_boolean (device, "removable"))
{
/* never try to open optical drives (might cause the door to close) or
* floppy drives (makes noise)
*/
if (g_udev_device_get_property_as_boolean (device, "ID_DRIVE_FLOPPY"))
{
/* assume media available */
media_available = TRUE;
media_change_detected = FALSE;
}
else if (g_udev_device_get_property_as_boolean (device, "ID_CDROM"))
{
/* Rely on (careful) work already done by udev's cdrom_id prober */
if (g_udev_device_get_property_as_boolean (device, "ID_CDROM_MEDIA"))
media_available = TRUE;
}
else
{
gint fd;
/* For the general case, just rely on open(2) failing with
* ENOMEDIUM if no medium is inserted
*/
fd = open (g_udev_device_get_device_file (device), O_RDONLY);
if (fd >= 0)
{
media_available = TRUE;
close (fd);
}
}
}
else
{
/* not removable, so media is implicitly available */
media_available = TRUE;
}
if (media_available && size == 0 && media_change_detected)
size = g_udev_device_get_sysfs_attr_as_uint64 (device, "size") * 512;
if (out_media_available != NULL)
*out_media_available = media_available;
if (out_media_change_detected != NULL)
*out_media_change_detected = media_change_detected;
return size;
}
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 gboolean
bcache_block_check (UDisksObject *object)
{
UDisksLinuxDevice *device = NULL;
gboolean rval = FALSE;
g_return_val_if_fail (UDISKS_IS_LINUX_BLOCK_OBJECT (object), FALSE);
/* Check device name */
device = udisks_linux_block_object_get_device (UDISKS_LINUX_BLOCK_OBJECT (object));
rval = g_str_has_prefix (g_udev_device_get_device_file (device->udev_device),
"/dev/bcache");
g_object_unref(device);
return rval;
}
static gboolean
fu_altos_device_find_tty (FuAltosDevice *self, GError **error)
{
GUsbDevice *usb_device = fu_usb_device_get_dev (FU_USB_DEVICE (self));
g_autoptr(GList) devices = NULL;
g_autoptr(GUdevClient) gudev_client = g_udev_client_new (NULL);
/* find all tty devices */
devices = g_udev_client_query_by_subsystem (gudev_client, "tty");
for (GList *l = devices; l != NULL; l = l->next) {
GUdevDevice *dev = G_UDEV_DEVICE (l->data);
/* get the tty device */
const gchar *dev_file = g_udev_device_get_device_file (dev);
if (dev_file == NULL)
continue;
/* get grandparent */
dev = g_udev_device_get_parent (dev);
if (dev == NULL)
continue;
dev = g_udev_device_get_parent (dev);
if (dev == NULL)
continue;
/* check correct device */
if (g_udev_device_get_sysfs_attr_as_int (dev, "busnum") !=
g_usb_device_get_bus (usb_device))
continue;
if (g_udev_device_get_sysfs_attr_as_int (dev, "devnum") !=
g_usb_device_get_address (usb_device))
continue;
/* success */
self->tty = g_strdup (dev_file);
return TRUE;
}
/* failure */
g_set_error (error,
FWUPD_ERROR,
FWUPD_ERROR_NOT_SUPPORTED,
"failed to find tty for %u:%u",
g_usb_device_get_bus (usb_device),
g_usb_device_get_address (usb_device));
return FALSE;
}
static gboolean
input_accel_discover (GUdevDevice *device)
{
const char *path;
if (g_strcmp0 (g_udev_device_get_property (device, "IIO_SENSOR_PROXY_TYPE"), "input-accel") != 0)
return FALSE;
path = g_udev_device_get_device_file (device);
if (!path)
return FALSE;
if (strstr (path, "/event") == NULL)
return FALSE;
g_debug ("Found input accel at %s", g_udev_device_get_sysfs_path (device));
return TRUE;
}
static void dump_device_and_parent(GUdevDevice * device, guint indent)
{
const gchar *const *list;
const gchar *const *iter;
GUdevDevice *parent;
char propstr[500];
guint32 namelen = 0, i;
println(indent, "------------------------------------------------------");
println(indent, "%-20s %s", _("Name:"), g_udev_device_get_name(device));
println(indent, "%-20s %s", _("Type:"), g_udev_device_get_devtype(device));
println(indent, "%-20s %s", _("Subsystem:"), g_udev_device_get_subsystem(device));
println(indent, "%-20s %s", _("Number:"), g_udev_device_get_number(device));
println(indent, "%-20s %s", _("Path:"), g_udev_device_get_sysfs_path(device));
println(indent, "%-20s %s", _("Driver:"), g_udev_device_get_driver(device));
println(indent, "%-20s %lld", _("Sequential Number:"), (long long int)g_udev_device_get_seqnum(device));
println(indent, "%-20s %s", _("Device File:"), g_udev_device_get_device_file(device));
println(indent, " ");
println(indent, _("Properties:"));
/* Get longest property name length for alignment */
list = g_udev_device_get_property_keys(device);
for (iter = list; iter && *iter; iter++) {
if (strlen(*iter) > namelen)
namelen = strlen(*iter);
}
namelen++;
for (iter = list; iter && *iter; iter++) {
strcpy(propstr, *iter);
strcat(propstr, ":");
for (i = 0; i < namelen - strlen(*iter); i++)
strcat(propstr, " ");
strcat(propstr, g_udev_device_get_property(device, *iter));
println(indent + 2, "%s", propstr);
}
println(indent, " ");
parent = g_udev_device_get_parent(device);
if (parent) {
dump_device_and_parent(parent, indent + 4);
g_object_unref(parent);
}
}
static GMount *
find_mount_for_device (GUdevDevice *device)
{
GMount *mount = NULL;
const char *device_file;
GVolumeMonitor *volmon;
GList *mounts;
GList *i;
device_file = g_udev_device_get_device_file (device);
if (device_file == NULL) {
return NULL;
}
volmon = g_volume_monitor_get ();
mounts = g_volume_monitor_get_mounts (volmon);
g_object_unref (volmon);
for (i = mounts; i != NULL; i = i->next) {
GVolume *v;
v = g_mount_get_volume (G_MOUNT (i->data));
if (v != NULL) {
char *devname = NULL;
gboolean match;
devname = g_volume_get_identifier (v, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE);
g_object_unref (v);
if (devname == NULL)
continue;
match = g_str_equal (devname, device_file);
g_free (devname);
if (match) {
mount = G_MOUNT (i->data);
g_object_ref (G_OBJECT (mount));
break;
}
}
}
g_list_foreach (mounts, (GFunc)g_object_unref, NULL);
g_list_free (mounts);
return mount;
}
static gboolean
bcache_block_check (StoragedObject *object)
{
const gchar *devname = NULL;
StoragedLinuxDevice *device = NULL;
gboolean rval = FALSE;
g_return_val_if_fail (STORAGED_IS_LINUX_BLOCK_OBJECT (object), FALSE);
/* Check device name */
device = storaged_linux_block_object_get_device (STORAGED_LINUX_BLOCK_OBJECT (object));
devname = g_strdup (g_udev_device_get_device_file (device->udev_device));
rval = g_str_has_prefix (devname, "/dev/bcache");
g_free ((gpointer) devname);
return rval;
}
/**
* cd_sensor_client_remove:
**/
static void
cd_sensor_client_remove (CdSensorClient *sensor_client,
GUdevDevice *device)
{
CdSensor *sensor;
const gchar *device_file;
const gchar *device_path;
const gchar *tmp;
guint i;
/* interesting device? */
tmp = g_udev_device_get_property (device, "COLORD_SENSOR_KIND");
if (tmp == NULL)
goto out;
/* actual device? */
device_file = g_udev_device_get_device_file (device);
if (device_file == NULL)
goto out;
/* get data */
device_path = g_udev_device_get_sysfs_path (device);
g_debug ("removing color management device: %s [%s]",
device_path, device_file);
for (i = 0; i < sensor_client->priv->array_sensors->len; i++) {
sensor = g_ptr_array_index (sensor_client->priv->array_sensors, i);
if (g_strcmp0 (cd_sensor_get_device_path (sensor), device_path) == 0) {
g_debug ("emit: removed");
g_signal_emit (sensor_client, signals[SIGNAL_SENSOR_REMOVED], 0, sensor);
g_ptr_array_remove_index_fast (sensor_client->priv->array_sensors, i);
goto out;
}
}
/* nothing found */
g_warning ("removed CM sensor that was never added");
out:
return;
}
/**
* cd_plugin_get_scanner_id_for_udev_device:
**/
static gchar *
cd_plugin_get_scanner_id_for_udev_device (GUdevDevice *udev_device)
{
GString *string;
const gchar *tmp;
/* get id */
string = g_string_new ("sysfs");
tmp = g_udev_device_get_property (udev_device, "ID_VENDOR");
if (tmp != NULL)
g_string_append_printf (string, "-%s", tmp);
tmp = g_udev_device_get_property (udev_device, "ID_MODEL");
if (tmp != NULL)
g_string_append_printf (string, "-%s", tmp);
/* fallback */
if (string->len == 5) {
tmp = g_udev_device_get_device_file (udev_device);
g_string_append_printf (string, "-%s", tmp);
}
return g_string_free (string, FALSE);
}
/**
* storaged_linux_block_object_reread_partition_table:
* @object: A #StoragedLinuxBlockObject.
*
* Requests the kernel to re-read the partition table for @object.
*
* The events from any change this may cause will bubble up from the
* kernel through the udev stack and will eventually be received by
* the storaged daemon process itself. This method does not wait for the
* event to be received.
*/
void
storaged_linux_block_object_reread_partition_table (StoragedLinuxBlockObject *object)
{
const gchar *device_file;
gint fd;
g_return_if_fail (STORAGED_IS_LINUX_BLOCK_OBJECT (object));
device_file = g_udev_device_get_device_file (object->device->udev_device);
fd = open (device_file, O_RDONLY);
if (fd == -1)
{
storaged_warning ("Error opening %s: %m", device_file);
}
else
{
if (ioctl (fd, BLKRRPART) != 0)
{
storaged_warning ("Error issuing BLKRRPART to %s: %m", device_file);
}
close (fd);
}
}
static MMBaseModem *
grab_port (MMPluginBase *base,
MMBaseModem *existing,
MMPortProbe *probe,
GError **error)
{
MMBaseModem *modem = NULL;
GUdevDevice *port;
const gchar *name, *subsys, *devfile;
guint16 vendor = 0, product = 0;
/* The Linktop plugin cannot do anything with non-AT ports */
if (!mm_port_probe_is_at (probe)) {
g_set_error_literal (error,
MM_CORE_ERROR,
MM_CORE_ERROR_UNSUPPORTED,
"Ignoring non-AT port");
return NULL;
}
port = mm_port_probe_get_port (probe); /* transfer none */
/* TODO: Why do we check for device file? */
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 = mm_port_probe_get_port_subsys (probe);
name = mm_port_probe_get_port_name (probe);
if (!mm_plugin_base_get_device_ids (base, subsys, name, &vendor, &product)) {
g_set_error_literal (error,
MM_CORE_ERROR,
MM_CORE_ERROR_FAILED,
"Could not get modem product ID");
return NULL;
}
/* If this is the first port being grabbed, create a new modem object */
if (!existing)
modem = MM_BASE_MODEM (mm_broadband_modem_linktop_new (mm_port_probe_get_port_physdev (probe),
mm_port_probe_get_port_driver (probe),
mm_plugin_get_name (MM_PLUGIN (base)),
vendor,
product));
if (!mm_base_modem_grab_port (existing ? existing : modem,
subsys,
name,
MM_PORT_TYPE_AT, /* we only allow AT ports here */
MM_AT_PORT_FLAG_NONE,
error)) {
if (modem)
g_object_unref (modem);
return NULL;
}
return existing ? existing : modem;
}
static GstDevice *
gst_v4l2_device_provider_device_from_udev (GstV4l2DeviceProvider * provider,
GUdevDevice * udev_device)
{
GstV4l2Device *gstdev;
const gchar *device_path = g_udev_device_get_device_file (udev_device);
const gchar *device_name, *str;
GstStructure *props;
props = gst_structure_new ("v4l2deviceprovider", "udev-probed",
G_TYPE_BOOLEAN, TRUE, NULL);
str = g_udev_device_get_property (udev_device, "ID_PATH");
if (!(str && *str)) {
str = g_udev_device_get_sysfs_path (udev_device);
}
if (str && *str)
gst_structure_set (props, "device.bus_path", G_TYPE_STRING, str, NULL);
if ((str = g_udev_device_get_sysfs_path (udev_device)) && *str)
gst_structure_set (props, "sysfs.path", G_TYPE_STRING, str, NULL);
if ((str = g_udev_device_get_property (udev_device, "ID_ID")) && *str)
gst_structure_set (props, "udev.id", G_TYPE_STRING, str, NULL);
if ((str = g_udev_device_get_property (udev_device, "ID_BUS")) && *str)
gst_structure_set (props, "device.bus", G_TYPE_STRING, str, NULL);
if ((str = g_udev_device_get_property (udev_device, "SUBSYSTEM")) && *str)
gst_structure_set (props, "device.subsystem", G_TYPE_STRING, str, NULL);
if ((str = g_udev_device_get_property (udev_device, "ID_VENDOR_ID")) && *str)
gst_structure_set (props, "device.vendor.id", G_TYPE_STRING, str, NULL);
str = g_udev_device_get_property (udev_device, "ID_VENDOR_FROM_DATABASE");
if (!(str && *str)) {
str = g_udev_device_get_property (udev_device, "ID_VENDOR_ENC");
if (!(str && *str)) {
str = g_udev_device_get_property (udev_device, "ID_VENDOR");
}
}
if (str && *str)
gst_structure_set (props, "device.vendor.name", G_TYPE_STRING, str, NULL);
if ((str = g_udev_device_get_property (udev_device, "ID_MODEL_ID")) && *str)
gst_structure_set (props, "device.product.id", G_TYPE_STRING, str, NULL);
device_name = g_udev_device_get_property (udev_device, "ID_V4L_PRODUCT");
if (!(device_name && *device_name)) {
device_name =
g_udev_device_get_property (udev_device, "ID_MODEL_FROM_DATABASE");
if (!(device_name && *device_name)) {
device_name = g_udev_device_get_property (udev_device, "ID_MODEL_ENC");
if (!(device_name && *device_name)) {
device_name = g_udev_device_get_property (udev_device, "ID_MODEL");
}
}
}
if (device_name && *device_name)
gst_structure_set (props, "device.product.name", G_TYPE_STRING, device_name,
NULL);
if ((str = g_udev_device_get_property (udev_device, "ID_SERIAL")) && *str)
gst_structure_set (props, "device.serial", G_TYPE_STRING, str, NULL);
if ((str = g_udev_device_get_property (udev_device, "ID_V4L_CAPABILITIES"))
&& *str)
gst_structure_set (props, "device.capabilities", G_TYPE_STRING, str, NULL);
gstdev = gst_v4l2_device_provider_probe_device (provider, device_path,
device_name, props);
if (gstdev)
gstdev->syspath = g_strdup (g_udev_device_get_sysfs_path (udev_device));
return GST_DEVICE (gstdev);
}
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;
guint16 vendor = 0, product = 0;
MMPortType ptype;
int usbif;
MMAtPortFlags pflags = MM_AT_PORT_FLAG_NONE;
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);
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;
}
usbif = g_udev_device_get_property_as_int (port, "ID_USB_INTERFACE_NUM");
if (usbif < 0) {
g_set_error (error, 0, 0, "Could not get USB device interface number.");
return NULL;
}
caps = mm_plugin_base_supports_task_get_probed_capabilities (task);
ptype = mm_plugin_base_probed_capabilities_to_port_type (caps);
if (usbif + 1 == GPOINTER_TO_INT (g_object_get_data (G_OBJECT (base), TAG_HUAWEI_PCUI_PORT)))
pflags = MM_AT_PORT_FLAG_PRIMARY;
else if (usbif + 1 == GPOINTER_TO_INT (g_object_get_data (G_OBJECT (base), TAG_HUAWEI_MODEM_PORT)))
pflags = MM_AT_PORT_FLAG_PPP;
else if (!g_object_get_data (G_OBJECT (base), TAG_GETPORTMODE_SUPPORTED)) {
/* If GETPORTMODE is not supported, we assume usbif 0 is the modem port */
if ((usbif == 0) && (ptype == MM_PORT_TYPE_AT)) {
pflags = MM_AT_PORT_FLAG_PPP;
/* For CDMA modems we assume usbif0 is both primary and PPP, since
* they don't have problems with talking on secondary ports.
*/
if (caps & CAP_CDMA)
pflags |= MM_AT_PORT_FLAG_PRIMARY;
}
}
sysfs_path = mm_plugin_base_supports_task_get_physdev_path (task);
if (!existing) {
if (caps & MM_PLUGIN_BASE_PORT_CAP_GSM) {
modem = mm_modem_huawei_gsm_new (sysfs_path,
mm_plugin_base_supports_task_get_driver (task),
mm_plugin_get_name (MM_PLUGIN (base)),
vendor,
product);
} else if (caps & CAP_CDMA) {
modem = mm_modem_huawei_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),
vendor,
product);
}
if (modem) {
if (!mm_modem_grab_port (modem, subsys, name, ptype, pflags, NULL, error)) {
g_object_unref (modem);
return NULL;
}
}
} else {
modem = existing;
if (!mm_modem_grab_port (modem, subsys, name, ptype, pflags, NULL, error))
return NULL;
}
return modem;
}
static void
empathy_camera_device_monitor_added (EmpathyCameraDeviceMonitor *monitor,
GUdevDevice *udevice)
{
const char *device_file;
const char *product_name;
const char *vendor;
const char *product;
const char *bus;
gint vendor_id = 0;
gint product_id = 0;
gint v4l_version = 0;
const gchar *devpath = g_udev_device_get_property (udevice, "DEVPATH");
GST_INFO ("Checking udev device '%s'", devpath);
bus = g_udev_device_get_property (udevice, "ID_BUS");
if (g_strcmp0 (bus, "usb") == 0)
{
vendor = g_udev_device_get_property (udevice, "ID_VENDOR_ID");
if (vendor != NULL)
vendor_id = g_ascii_strtoll (vendor, NULL, 16);
product = g_udev_device_get_property (udevice, "ID_MODEL_ID");
if (product != NULL)
product_id = g_ascii_strtoll (product, NULL, 16);
if (vendor_id == 0 || product_id == 0)
{
GST_WARNING ("Error getting vendor and product id");
}
else
{
GST_INFO ("Found device %04x:%04x, getting capabilities...", vendor_id, product_id);
}
}
else
{
GST_INFO ("Not an usb device, skipping vendor and model id retrieval");
}
device_file = g_udev_device_get_device_file (udevice);
if (device_file == NULL)
{
GST_WARNING ("Error getting V4L device");
return;
}
/* vbi devices support capture capability too, but cannot be used,
* so detect them by device name */
if (strstr (device_file, "vbi"))
{
GST_INFO ("Skipping vbi device: %s", device_file);
return;
}
v4l_version = g_udev_device_get_property_as_int (udevice, "ID_V4L_VERSION");
if (v4l_version == 2 || v4l_version == 1)
{
const char *caps;
caps = g_udev_device_get_property (udevice, "ID_V4L_CAPABILITIES");
if (caps == NULL || strstr (caps, ":capture:") == NULL)
{
GST_WARNING ("Device %s seems to not have the capture capability, (radio tuner?)"
"Removing it from device list.", device_file);
return;
}
product_name = g_udev_device_get_property (udevice, "ID_V4L_PRODUCT");
}
else if (v4l_version == 0)
{
GST_ERROR ("Fix your udev installation to include v4l_id, ignoring %s", device_file);
return;
}
else
{
g_assert_not_reached ();
}
g_signal_emit (monitor, monitor_signals[ADDED], 0,
devpath,
device_file,
product_name,
v4l_version);
}
