diff options
Diffstat (limited to 'gusb/gusb-device.c')
| -rw-r--r-- | gusb/gusb-device.c | 1274 |
1 files changed, 624 insertions, 650 deletions
diff --git a/gusb/gusb-device.c b/gusb/gusb-device.c index beec181..576b148 100644 --- a/gusb/gusb-device.c +++ b/gusb/gusb-device.c @@ -16,47 +16,45 @@ #include "config.h" -#include <string.h> - #include <libusb.h> +#include <string.h> +#include "gusb-bos-descriptor-private.h" #include "gusb-context-private.h" -#include "gusb-util.h" #include "gusb-device-private.h" #include "gusb-interface-private.h" -#include "gusb-bos-descriptor-private.h" +#include "gusb-util.h" /** * GUsbDevicePrivate: * * Private #GUsbDevice data **/ -struct _GUsbDevicePrivate -{ - gchar *platform_id; - GUsbContext *context; - libusb_device *device; - libusb_device_handle *handle; +struct _GUsbDevicePrivate { + gchar *platform_id; + GUsbContext *context; + libusb_device *device; + libusb_device_handle *handle; struct libusb_device_descriptor desc; }; -enum { - PROP_0, - PROP_LIBUSB_DEVICE, - PROP_CONTEXT, - PROP_PLATFORM_ID, - N_PROPERTIES -}; +enum { PROP_0, PROP_LIBUSB_DEVICE, PROP_CONTEXT, PROP_PLATFORM_ID, N_PROPERTIES }; -static GParamSpec *pspecs[N_PROPERTIES] = { NULL, }; +static GParamSpec *pspecs[N_PROPERTIES] = { + NULL, +}; -static void g_usb_device_initable_iface_init (GInitableIface *iface); +static void +g_usb_device_initable_iface_init(GInitableIface *iface); -G_DEFINE_TYPE_WITH_CODE (GUsbDevice, g_usb_device, G_TYPE_OBJECT, - G_ADD_PRIVATE (GUsbDevice) - G_IMPLEMENT_INTERFACE (G_TYPE_INITABLE, - g_usb_device_initable_iface_init)) +G_DEFINE_TYPE_WITH_CODE(GUsbDevice, + g_usb_device, + G_TYPE_OBJECT, + G_ADD_PRIVATE(GUsbDevice) + G_IMPLEMENT_INTERFACE(G_TYPE_INITABLE, + g_usb_device_initable_iface_init)) +/* clang-format off */ /** * g_usb_device_error_quark: * @@ -65,90 +63,84 @@ G_DEFINE_TYPE_WITH_CODE (GUsbDevice, g_usb_device, G_TYPE_OBJECT, * Since: 0.1.0 **/ G_DEFINE_QUARK (g-usb-device-error-quark, g_usb_device_error) +/* clang-format on */ static void -g_usb_device_finalize (GObject *object) +g_usb_device_finalize(GObject *object) { - GUsbDevice *device = G_USB_DEVICE (object); + GUsbDevice *device = G_USB_DEVICE(object); GUsbDevicePrivate *priv = device->priv; - g_free (priv->platform_id); + g_free(priv->platform_id); - G_OBJECT_CLASS (g_usb_device_parent_class)->finalize (object); + G_OBJECT_CLASS(g_usb_device_parent_class)->finalize(object); } static void -g_usb_device_dispose (GObject *object) +g_usb_device_dispose(GObject *object) { - GUsbDevice *device = G_USB_DEVICE (object); + GUsbDevice *device = G_USB_DEVICE(object); GUsbDevicePrivate *priv = device->priv; - g_clear_pointer (&priv->device, libusb_unref_device); - g_clear_object (&priv->context); + g_clear_pointer(&priv->device, libusb_unref_device); + g_clear_object(&priv->context); - G_OBJECT_CLASS (g_usb_device_parent_class)->dispose (object); + G_OBJECT_CLASS(g_usb_device_parent_class)->dispose(object); } static void -g_usb_device_get_property (GObject *object, - guint prop_id, - GValue *value, - GParamSpec *pspec) +g_usb_device_get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) { - GUsbDevice *device = G_USB_DEVICE (object); + GUsbDevice *device = G_USB_DEVICE(object); GUsbDevicePrivate *priv = device->priv; switch (prop_id) { case PROP_LIBUSB_DEVICE: - g_value_set_pointer (value, priv->device); + g_value_set_pointer(value, priv->device); break; default: - G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec); break; } } static void -set_libusb_device (GUsbDevice *device, - struct libusb_device *dev) +set_libusb_device(GUsbDevice *device, struct libusb_device *dev) { GUsbDevicePrivate *priv = device->priv; - g_clear_pointer (&priv->device, libusb_unref_device); + g_clear_pointer(&priv->device, libusb_unref_device); if (dev != NULL) - priv->device = libusb_ref_device (dev); + priv->device = libusb_ref_device(dev); } static void -g_usb_device_set_property (GObject *object, - guint prop_id, - const GValue *value, - GParamSpec *pspec) +g_usb_device_set_property(GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { - GUsbDevice *device = G_USB_DEVICE (object); + GUsbDevice *device = G_USB_DEVICE(object); GUsbDevicePrivate *priv = device->priv; switch (prop_id) { case PROP_LIBUSB_DEVICE: - set_libusb_device (device, g_value_get_pointer (value)); + set_libusb_device(device, g_value_get_pointer(value)); break; case PROP_CONTEXT: - priv->context = g_value_dup_object (value); + priv->context = g_value_dup_object(value); break; case PROP_PLATFORM_ID: - priv->platform_id = g_value_dup_string (value); + priv->platform_id = g_value_dup_string(value); break; default: - G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec); break; } } static void -g_usb_device_constructed (GObject *object) +g_usb_device_constructed(GObject *object) { - GUsbDevice *device = G_USB_DEVICE (object); + GUsbDevice *device = G_USB_DEVICE(object); GUsbDevicePrivate *priv; gint rc; @@ -157,18 +149,17 @@ g_usb_device_constructed (GObject *object) if (!priv->device) g_error("constructed without a libusb_device"); - rc = libusb_get_device_descriptor (priv->device, &priv->desc); + rc = libusb_get_device_descriptor(priv->device, &priv->desc); if (rc != LIBUSB_SUCCESS) - g_warning ("Failed to get USB descriptor for device: %s", - g_usb_strerror (rc)); + g_warning("Failed to get USB descriptor for device: %s", g_usb_strerror(rc)); - G_OBJECT_CLASS (g_usb_device_parent_class)->constructed (object); + G_OBJECT_CLASS(g_usb_device_parent_class)->constructed(object); } static void -g_usb_device_class_init (GUsbDeviceClass *klass) +g_usb_device_class_init(GUsbDeviceClass *klass) { - GObjectClass *object_class = G_OBJECT_CLASS (klass); + GObjectClass *object_class = G_OBJECT_CLASS(klass); object_class->finalize = g_usb_device_finalize; object_class->dispose = g_usb_device_dispose; @@ -180,41 +171,42 @@ g_usb_device_class_init (GUsbDeviceClass *klass) * GUsbDevice:libusb_device: */ pspecs[PROP_LIBUSB_DEVICE] = - g_param_spec_pointer ("libusb-device", NULL, NULL, - G_PARAM_CONSTRUCT_ONLY| - G_PARAM_READWRITE); + g_param_spec_pointer("libusb-device", + NULL, + NULL, + G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE); /** * GUsbDevice:context: */ - pspecs[PROP_CONTEXT] = - g_param_spec_object ("context", NULL, NULL, - G_USB_TYPE_CONTEXT, - G_PARAM_CONSTRUCT_ONLY| - G_PARAM_WRITABLE); + pspecs[PROP_CONTEXT] = g_param_spec_object("context", + NULL, + NULL, + G_USB_TYPE_CONTEXT, + G_PARAM_CONSTRUCT_ONLY | G_PARAM_WRITABLE); /** * GUsbDevice:platform-id: */ - pspecs[PROP_PLATFORM_ID] = - g_param_spec_string ("platform-id", NULL, NULL, - NULL, - G_PARAM_CONSTRUCT_ONLY| - G_PARAM_WRITABLE); + pspecs[PROP_PLATFORM_ID] = g_param_spec_string("platform-id", + NULL, + NULL, + NULL, + G_PARAM_CONSTRUCT_ONLY | G_PARAM_WRITABLE); - g_object_class_install_properties (object_class, N_PROPERTIES, pspecs); + g_object_class_install_properties(object_class, N_PROPERTIES, pspecs); } static void -g_usb_device_init (GUsbDevice *device) +g_usb_device_init(GUsbDevice *device) { - device->priv = g_usb_device_get_instance_private (device); + device->priv = g_usb_device_get_instance_private(device); } /* not defined in FreeBSD */ #ifndef HAVE_LIBUSB_GET_PARENT static libusb_device * -libusb_get_parent (libusb_device *dev) +libusb_get_parent(libusb_device *dev) { return NULL; } @@ -223,67 +215,69 @@ libusb_get_parent (libusb_device *dev) /* not defined in DragonFlyBSD */ #ifndef HAVE_LIBUSB_GET_PORT_NUMBER static guint8 -libusb_get_port_number (libusb_device *dev) +libusb_get_port_number(libusb_device *dev) { return 0xff; } #endif static void -g_usb_device_build_parent_port_number (GString *str, libusb_device *dev) +g_usb_device_build_parent_port_number(GString *str, libusb_device *dev) { - libusb_device *parent = libusb_get_parent (dev); + libusb_device *parent = libusb_get_parent(dev); if (parent != NULL) - g_usb_device_build_parent_port_number (str, parent); - g_string_append_printf (str, "%02x:", libusb_get_port_number (dev)); + g_usb_device_build_parent_port_number(str, parent); + g_string_append_printf(str, "%02x:", libusb_get_port_number(dev)); } static gchar * -g_usb_device_build_platform_id (struct libusb_device *dev) +g_usb_device_build_platform_id(struct libusb_device *dev) { GString *platform_id; /* build a topology of the device */ - platform_id = g_string_new ("usb:"); - g_string_append_printf (platform_id, "%02x:", libusb_get_bus_number (dev)); - g_usb_device_build_parent_port_number (platform_id, dev); - g_string_truncate (platform_id, platform_id->len - 1); - return g_string_free (platform_id, FALSE); + platform_id = g_string_new("usb:"); + g_string_append_printf(platform_id, "%02x:", libusb_get_bus_number(dev)); + g_usb_device_build_parent_port_number(platform_id, dev); + g_string_truncate(platform_id, platform_id->len - 1); + return g_string_free(platform_id, FALSE); } static gboolean -g_usb_device_initable_init (GInitable *initable, - GCancellable *cancellable, - GError **error) +g_usb_device_initable_init(GInitable *initable, GCancellable *cancellable, GError **error) { - GUsbDevice *device = G_USB_DEVICE (initable); + GUsbDevice *device = G_USB_DEVICE(initable); GUsbDevicePrivate *priv; gint rc; priv = device->priv; if (priv->device == NULL) { - g_set_error_literal (error, G_USB_DEVICE_ERROR, G_USB_DEVICE_ERROR_INTERNAL, - "Constructed without a libusb_device"); + g_set_error_literal(error, + G_USB_DEVICE_ERROR, + G_USB_DEVICE_ERROR_INTERNAL, + "Constructed without a libusb_device"); return FALSE; } - rc = libusb_get_device_descriptor (priv->device, &priv->desc); + rc = libusb_get_device_descriptor(priv->device, &priv->desc); if (rc != LIBUSB_SUCCESS) { - g_set_error (error, G_USB_DEVICE_ERROR, G_USB_DEVICE_ERROR_INTERNAL, - "Failed to get USB descriptor for device: %s", - g_usb_strerror (rc)); + g_set_error(error, + G_USB_DEVICE_ERROR, + G_USB_DEVICE_ERROR_INTERNAL, + "Failed to get USB descriptor for device: %s", + g_usb_strerror(rc)); return FALSE; } /* this does not change on plug->unplug->plug */ - priv->platform_id = g_usb_device_build_platform_id (priv->device); + priv->platform_id = g_usb_device_build_platform_id(priv->device); return TRUE; } static void -g_usb_device_initable_iface_init (GInitableIface *iface) +g_usb_device_initable_iface_init(GInitableIface *iface) { iface->init = g_usb_device_initable_init; } @@ -296,15 +290,16 @@ g_usb_device_initable_iface_init (GInitableIface *iface) * Since: 0.1.0 **/ GUsbDevice * -_g_usb_device_new (GUsbContext *context, - libusb_device *device, - GError **error) +_g_usb_device_new(GUsbContext *context, libusb_device *device, GError **error) { - return g_initable_new (G_USB_TYPE_DEVICE, - NULL, error, - "context", context, - "libusb-device", device, - NULL); + return g_initable_new(G_USB_TYPE_DEVICE, + NULL, + error, + "context", + context, + "libusb-device", + device, + NULL); } /** @@ -316,15 +311,13 @@ _g_usb_device_new (GUsbContext *context, * Return value: The #libusb_device or %NULL. Do not unref this value. **/ libusb_device * -_g_usb_device_get_device (GUsbDevice *device) +_g_usb_device_get_device(GUsbDevice *device) { return device->priv->device; } static gboolean -g_usb_device_libusb_error_to_gerror (GUsbDevice *device, - gint rc, - GError **error) +g_usb_device_libusb_error_to_gerror(GUsbDevice *device, gint rc, GError **error) { gint error_code = G_USB_DEVICE_ERROR_INTERNAL; /* Put the rc in libusb's error enum so that gcc warns us if we're @@ -363,60 +356,65 @@ g_usb_device_libusb_error_to_gerror (GUsbDevice *device, break; } - g_set_error (error, G_USB_DEVICE_ERROR, error_code, - "USB error on device %04x:%04x : %s [%i]", - g_usb_device_get_vid (device), - g_usb_device_get_pid (device), - g_usb_strerror (rc), rc); + g_set_error(error, + G_USB_DEVICE_ERROR, + error_code, + "USB error on device %04x:%04x : %s [%i]", + g_usb_device_get_vid(device), + g_usb_device_get_pid(device), + g_usb_strerror(rc), + rc); return FALSE; } static gboolean -g_usb_device_not_open_error (GUsbDevice *device, - GError **error) -{ - g_set_error (error, - G_USB_DEVICE_ERROR, - G_USB_DEVICE_ERROR_NOT_OPEN, - "Device %04x:%04x has not been opened", - g_usb_device_get_vid (device), - g_usb_device_get_pid (device)); +g_usb_device_not_open_error(GUsbDevice *device, GError **error) +{ + g_set_error(error, + G_USB_DEVICE_ERROR, + G_USB_DEVICE_ERROR_NOT_OPEN, + "Device %04x:%04x has not been opened", + g_usb_device_get_vid(device), + g_usb_device_get_pid(device)); return FALSE; } static void -g_usb_device_async_not_open_error (GUsbDevice *device, - GAsyncReadyCallback callback, - gpointer user_data, - gpointer source_tag) -{ - g_task_report_new_error (device, callback, user_data, source_tag, - G_USB_DEVICE_ERROR, - G_USB_DEVICE_ERROR_NOT_OPEN, - "Device %04x:%04x has not been opened", - g_usb_device_get_vid (device), - g_usb_device_get_pid (device)); +g_usb_device_async_not_open_error(GUsbDevice *device, + GAsyncReadyCallback callback, + gpointer user_data, + gpointer source_tag) +{ + g_task_report_new_error(device, + callback, + user_data, + source_tag, + G_USB_DEVICE_ERROR, + G_USB_DEVICE_ERROR_NOT_OPEN, + "Device %04x:%04x has not been opened", + g_usb_device_get_vid(device), + g_usb_device_get_pid(device)); } gboolean -_g_usb_device_open_internal (GUsbDevice *device, GError **error) +_g_usb_device_open_internal(GUsbDevice *device, GError **error) { gint rc; if (device->priv->handle != NULL) { - g_set_error (error, - G_USB_DEVICE_ERROR, - G_USB_DEVICE_ERROR_ALREADY_OPEN, - "Device %04x:%04x is already open", - g_usb_device_get_vid (device), - g_usb_device_get_pid (device)); + g_set_error(error, + G_USB_DEVICE_ERROR, + G_USB_DEVICE_ERROR_ALREADY_OPEN, + "Device %04x:%04x is already open", + g_usb_device_get_vid(device), + g_usb_device_get_pid(device)); return FALSE; } /* open device */ - rc = libusb_open (device->priv->device, &device->priv->handle); - return g_usb_device_libusb_error_to_gerror (device, rc, error); + rc = libusb_open(device->priv->device, &device->priv->handle); + return g_usb_device_libusb_error_to_gerror(device, rc, error); } /** @@ -433,17 +431,17 @@ _g_usb_device_open_internal (GUsbDevice *device, GError **error) * Since: 0.1.0 **/ gboolean -g_usb_device_open (GUsbDevice *device, GError **error) +g_usb_device_open(GUsbDevice *device, GError **error) { - g_return_val_if_fail (G_USB_IS_DEVICE (device), FALSE); - g_return_val_if_fail (error == NULL || *error == NULL, FALSE); + g_return_val_if_fail(G_USB_IS_DEVICE(device), FALSE); + g_return_val_if_fail(error == NULL || *error == NULL, FALSE); /* ignore */ - if (g_usb_context_get_flags (device->priv->context) & G_USB_CONTEXT_FLAGS_AUTO_OPEN_DEVICES) + if (g_usb_context_get_flags(device->priv->context) & G_USB_CONTEXT_FLAGS_AUTO_OPEN_DEVICES) return TRUE; /* open */ - return _g_usb_device_open_internal (device, error); + return _g_usb_device_open_internal(device, error); } /** @@ -461,19 +459,19 @@ g_usb_device_open (GUsbDevice *device, GError **error) * Since: 0.2.5 **/ guint8 -g_usb_device_get_custom_index (GUsbDevice *device, - guint8 class_id, - guint8 subclass_id, - guint8 protocol_id, - GError **error) +g_usb_device_get_custom_index(GUsbDevice *device, + guint8 class_id, + guint8 subclass_id, + guint8 protocol_id, + GError **error) { const struct libusb_interface_descriptor *ifp; gint rc; guint8 idx = 0x00; struct libusb_config_descriptor *config; - rc = libusb_get_active_config_descriptor (device->priv->device, &config); - if (!g_usb_device_libusb_error_to_gerror (device, rc, error)) + rc = libusb_get_active_config_descriptor(device->priv->device, &config); + if (!g_usb_device_libusb_error_to_gerror(device, rc, error)) return 0x00; /* find the right data */ @@ -491,15 +489,17 @@ g_usb_device_get_custom_index (GUsbDevice *device, /* nothing matched */ if (idx == 0x00) { - g_set_error (error, - G_USB_DEVICE_ERROR, - G_USB_DEVICE_ERROR_NOT_SUPPORTED, - "no vendor descriptor for class 0x%02x, " - "subclass 0x%02x and protocol 0x%02x", - class_id, subclass_id, protocol_id); + g_set_error(error, + G_USB_DEVICE_ERROR, + G_USB_DEVICE_ERROR_NOT_SUPPORTED, + "no vendor descriptor for class 0x%02x, " + "subclass 0x%02x and protocol 0x%02x", + class_id, + subclass_id, + protocol_id); } - libusb_free_config_descriptor (config); + libusb_free_config_descriptor(config); return idx; } @@ -521,22 +521,22 @@ g_usb_device_get_custom_index (GUsbDevice *device, * Since: 0.2.8 **/ GUsbInterface * -g_usb_device_get_interface (GUsbDevice *device, - guint8 class_id, - guint8 subclass_id, - guint8 protocol_id, - GError **error) +g_usb_device_get_interface(GUsbDevice *device, + guint8 class_id, + guint8 subclass_id, + guint8 protocol_id, + GError **error) { const struct libusb_interface_descriptor *ifp; gint rc; GUsbInterface *interface = NULL; struct libusb_config_descriptor *config; - g_return_val_if_fail (G_USB_IS_DEVICE (device), NULL); - g_return_val_if_fail (error == NULL || *error == NULL, NULL); + g_return_val_if_fail(G_USB_IS_DEVICE(device), NULL); + g_return_val_if_fail(error == NULL || *error == NULL, NULL); - rc = libusb_get_active_config_descriptor (device->priv->device, &config); - if (!g_usb_device_libusb_error_to_gerror (device, rc, error)) + rc = libusb_get_active_config_descriptor(device->priv->device, &config); + if (!g_usb_device_libusb_error_to_gerror(device, rc, error)) return NULL; /* find the right data */ @@ -548,21 +548,23 @@ g_usb_device_get_interface (GUsbDevice *device, continue; if (ifp->bInterfaceProtocol != protocol_id) continue; - interface = _g_usb_interface_new (ifp); + interface = _g_usb_interface_new(ifp); break; } /* nothing matched */ if (interface == NULL) { - g_set_error (error, - G_USB_DEVICE_ERROR, - G_USB_DEVICE_ERROR_NOT_SUPPORTED, - "no interface for class 0x%02x, " - "subclass 0x%02x and protocol 0x%02x", - class_id, subclass_id, protocol_id); + g_set_error(error, + G_USB_DEVICE_ERROR, + G_USB_DEVICE_ERROR_NOT_SUPPORTED, + "no interface for class 0x%02x, " + "subclass 0x%02x and protocol 0x%02x", + class_id, + subclass_id, + protocol_id); } - libusb_free_config_descriptor (config); + libusb_free_config_descriptor(config); return interface; } @@ -573,37 +575,38 @@ g_usb_device_get_interface (GUsbDevice *device, * * Gets all the interfaces exported by the device. * - * Return value: (transfer container) (element-type GUsbInterface): an array of interfaces or %NULL for error + * Return value: (transfer container) (element-type GUsbInterface): an array of interfaces or %NULL + *for error * * Since: 0.2.8 **/ GPtrArray * -g_usb_device_get_interfaces (GUsbDevice *device, GError **error) +g_usb_device_get_interfaces(GUsbDevice *device, GError **error) { const struct libusb_interface_descriptor *ifp; gint rc; struct libusb_config_descriptor *config; GPtrArray *array = NULL; - g_return_val_if_fail (G_USB_IS_DEVICE (device), NULL); - g_return_val_if_fail (error == NULL || *error == NULL, NULL); + g_return_val_if_fail(G_USB_IS_DEVICE(device), NULL); + g_return_val_if_fail(error == NULL || *error == NULL, NULL); - rc = libusb_get_active_config_descriptor (device->priv->device, &config); - if (!g_usb_device_libusb_error_to_gerror (device, rc, error)) + rc = libusb_get_active_config_descriptor(device->priv->device, &config); + if (!g_usb_device_libusb_error_to_gerror(device, rc, error)) return NULL; /* get all interfaces */ - array = g_ptr_array_new_with_free_func ((GDestroyNotify) g_object_unref); + array = g_ptr_array_new_with_free_func((GDestroyNotify)g_object_unref); for (guint i = 0; i < config->bNumInterfaces; i++) { GUsbInterface *interface = NULL; - for (guint j = 0; j < (guint) config->interface[i].num_altsetting; j++) { + for (guint j = 0; j < (guint)config->interface[i].num_altsetting; j++) { ifp = &config->interface[i].altsetting[j]; - interface = _g_usb_interface_new (ifp); - g_ptr_array_add (array, interface); + interface = _g_usb_interface_new(ifp); + g_ptr_array_add(array, interface); } } - libusb_free_config_descriptor (config); + libusb_free_config_descriptor(config); return array; } @@ -622,23 +625,21 @@ g_usb_device_get_interfaces (GUsbDevice *device, GError **error) * Since: 0.4.0 **/ GUsbBosDescriptor * -g_usb_device_get_bos_descriptor (GUsbDevice *device, - guint8 capability, - GError **error) +g_usb_device_get_bos_descriptor(GUsbDevice *device, guint8 capability, GError **error) { gint rc; guint8 num_device_caps; GUsbBosDescriptor *bos_descriptor = NULL; struct libusb_bos_descriptor *bos = NULL; - g_return_val_if_fail (G_USB_IS_DEVICE (device), NULL); - g_return_val_if_fail (error == NULL || *error == NULL, NULL); + g_return_val_if_fail(G_USB_IS_DEVICE(device), NULL); + g_return_val_if_fail(error == NULL || *error == NULL, NULL); - rc = libusb_get_bos_descriptor (device->priv->handle, &bos); - if (!g_usb_device_libusb_error_to_gerror (device, rc, error)) + rc = libusb_get_bos_descriptor(device->priv->handle, &bos); + if (!g_usb_device_libusb_error_to_gerror(device, rc, error)) return NULL; - /* find the right data */ + /* find the right data */ #ifdef __FreeBSD__ num_device_caps = bos->bNumDeviceCapabilities; #else @@ -647,21 +648,21 @@ g_usb_device_get_bos_descriptor (GUsbDevice *device, for (guint i = 0; i < num_device_caps; i++) { struct libusb_bos_dev_capability_descriptor *bos_cap = bos->dev_capability[i]; if (bos_cap->bDevCapabilityType == capability) { - bos_descriptor = _g_usb_bos_descriptor_new (bos_cap); + bos_descriptor = _g_usb_bos_descriptor_new(bos_cap); break; } } /* nothing matched */ if (bos_descriptor == NULL) { - g_set_error (error, - G_USB_DEVICE_ERROR, - G_USB_DEVICE_ERROR_NOT_SUPPORTED, - "no BOS descriptor for capability 0x%02x", - capability); + g_set_error(error, + G_USB_DEVICE_ERROR, + G_USB_DEVICE_ERROR_NOT_SUPPORTED, + "no BOS descriptor for capability 0x%02x", + capability); } - libusb_free_bos_descriptor (bos); + libusb_free_bos_descriptor(bos); return bos_descriptor; } @@ -677,22 +678,22 @@ g_usb_device_get_bos_descriptor (GUsbDevice *device, * Since: 0.4.0 **/ GPtrArray * -g_usb_device_get_bos_descriptors (GUsbDevice *device, GError **error) +g_usb_device_get_bos_descriptors(GUsbDevice *device, GError **error) { gint rc; guint8 num_device_caps; struct libusb_bos_descriptor *bos = NULL; GPtrArray *array = NULL; - g_return_val_if_fail (G_USB_IS_DEVICE (device), NULL); - g_return_val_if_fail (error == NULL || *error == NULL, NULL); + g_return_val_if_fail(G_USB_IS_DEVICE(device), NULL); + g_return_val_if_fail(error == NULL || *error == NULL, NULL); - rc = libusb_get_bos_descriptor (device->priv->handle, &bos); - if (!g_usb_device_libusb_error_to_gerror (device, rc, error)) + rc = libusb_get_bos_descriptor(device->priv->handle, &bos); + if (!g_usb_device_libusb_error_to_gerror(device, rc, error)) return NULL; /* get all BOS descriptors */ - array = g_ptr_array_new_with_free_func ((GDestroyNotify) g_object_unref); + array = g_ptr_array_new_with_free_func((GDestroyNotify)g_object_unref); #ifdef __FreeBSD__ num_device_caps = bos->bNumDeviceCapabilities; #else @@ -701,11 +702,11 @@ g_usb_device_get_bos_descriptors (GUsbDevice *device, GError **error) for (guint i = 0; i < num_device_caps; i++) { GUsbBosDescriptor *bos_descriptor = NULL; struct libusb_bos_dev_capability_descriptor *bos_cap = bos->dev_capability[i]; - bos_descriptor = _g_usb_bos_descriptor_new (bos_cap); - g_ptr_array_add (array, bos_descriptor); + bos_descriptor = _g_usb_bos_descriptor_new(bos_cap); + g_ptr_array_add(array, bos_descriptor); } - libusb_free_bos_descriptor (bos); + libusb_free_bos_descriptor(bos); return array; } @@ -721,20 +722,19 @@ g_usb_device_get_bos_descriptors (GUsbDevice *device, GError **error) * Since: 0.1.0 **/ gboolean -g_usb_device_close (GUsbDevice *device, - GError **error) +g_usb_device_close(GUsbDevice *device, GError **error) { - g_return_val_if_fail (G_USB_IS_DEVICE (device), FALSE); - g_return_val_if_fail (error == NULL || *error == NULL, FALSE); + g_return_val_if_fail(G_USB_IS_DEVICE(device), FALSE); + g_return_val_if_fail(error == NULL || *error == NULL, FALSE); /* ignore */ - if (g_usb_context_get_flags (device->priv->context) & G_USB_CONTEXT_FLAGS_AUTO_OPEN_DEVICES) + if (g_usb_context_get_flags(device->priv->context) & G_USB_CONTEXT_FLAGS_AUTO_OPEN_DEVICES) return TRUE; if (device->priv->handle == NULL) - return g_usb_device_not_open_error (device, error); + return g_usb_device_not_open_error(device, error); - libusb_close (device->priv->handle); + libusb_close(device->priv->handle); device->priv->handle = NULL; return TRUE; } @@ -757,20 +757,19 @@ g_usb_device_close (GUsbDevice *device, * Since: 0.1.0 **/ gboolean -g_usb_device_reset (GUsbDevice *device, - GError **error) +g_usb_device_reset(GUsbDevice *device, GError **error) { gint rc; - g_return_val_if_fail (G_USB_IS_DEVICE (device), FALSE); - g_return_val_if_fail (error == NULL || *error == NULL, FALSE); + g_return_val_if_fail(G_USB_IS_DEVICE(device), FALSE); + g_return_val_if_fail(error == NULL || *error == NULL, FALSE); if (device->priv->handle == NULL) - return g_usb_device_not_open_error (device, error); + return g_usb_device_not_open_error(device, error); - rc = libusb_reset_device (device->priv->handle); + rc = libusb_reset_device(device->priv->handle); if (rc == LIBUSB_ERROR_NOT_FOUND) return TRUE; - return g_usb_device_libusb_error_to_gerror (device, rc, error); + return g_usb_device_libusb_error_to_gerror(device, rc, error); } /** @@ -787,23 +786,22 @@ g_usb_device_reset (GUsbDevice *device, * Since: 0.1.0 **/ gint -g_usb_device_get_configuration (GUsbDevice *device, - GError **error) +g_usb_device_get_configuration(GUsbDevice *device, GError **error) { gint rc; int config; - g_return_val_if_fail (G_USB_IS_DEVICE (device), -1); - g_return_val_if_fail (error == NULL || *error == NULL, -1); + g_return_val_if_fail(G_USB_IS_DEVICE(device), -1); + g_return_val_if_fail(error == NULL || *error == NULL, -1); if (device->priv->handle == NULL) { - g_usb_device_not_open_error (device, error); + g_usb_device_not_open_error(device, error); return -1; } - rc = libusb_get_configuration (device->priv->handle, &config); + rc = libusb_get_configuration(device->priv->handle, &config); if (rc != LIBUSB_SUCCESS) { - g_usb_device_libusb_error_to_gerror (device, rc, error); + g_usb_device_libusb_error_to_gerror(device, rc, error); return -1; } @@ -825,33 +823,28 @@ g_usb_device_get_configuration (GUsbDevice *device, * Since: 0.1.0 **/ gboolean -g_usb_device_set_configuration (GUsbDevice *device, - gint configuration, - GError **error) +g_usb_device_set_configuration(GUsbDevice *device, gint configuration, GError **error) { gint rc; gint config_tmp = 0; - g_return_val_if_fail (G_USB_IS_DEVICE (device), FALSE); - g_return_val_if_fail (error == NULL || *error == NULL, FALSE); + g_return_val_if_fail(G_USB_IS_DEVICE(device), FALSE); + g_return_val_if_fail(error == NULL || *error == NULL, FALSE); if (device->priv->handle == NULL) - return g_usb_device_not_open_error (device, error); + return g_usb_device_not_open_error(device, error); /* verify we've not already set the same configuration */ - rc = libusb_get_configuration (device->priv->handle, - &config_tmp); + rc = libusb_get_configuration(device->priv->handle, &config_tmp); if (rc != LIBUSB_SUCCESS) { - return g_usb_device_libusb_error_to_gerror (device, - rc, - error); + return g_usb_device_libusb_error_to_gerror(device, rc, error); } if (config_tmp == configuration) return TRUE; /* different, so change */ - rc = libusb_set_configuration (device->priv->handle, configuration); - return g_usb_device_libusb_error_to_gerror (device, rc, error); + rc = libusb_set_configuration(device->priv->handle, configuration); + return g_usb_device_libusb_error_to_gerror(device, rc, error); } /** @@ -868,32 +861,29 @@ g_usb_device_set_configuration (GUsbDevice *device, * Since: 0.1.0 **/ gboolean -g_usb_device_claim_interface (GUsbDevice *device, - gint interface, - GUsbDeviceClaimInterfaceFlags flags, - GError **error) +g_usb_device_claim_interface(GUsbDevice *device, + gint interface, + GUsbDeviceClaimInterfaceFlags flags, + GError **error) { gint rc; - g_return_val_if_fail (G_USB_IS_DEVICE (device), FALSE); - g_return_val_if_fail (error == NULL || *error == NULL, FALSE); + g_return_val_if_fail(G_USB_IS_DEVICE(device), FALSE); + g_return_val_if_fail(error == NULL || *error == NULL, FALSE); if (device->priv->handle == NULL) - return g_usb_device_not_open_error (device, error); + return g_usb_device_not_open_error(device, error); if (flags & G_USB_DEVICE_CLAIM_INTERFACE_BIND_KERNEL_DRIVER) { - rc = libusb_detach_kernel_driver (device->priv->handle, - interface); - if (rc != LIBUSB_SUCCESS && - rc != LIBUSB_ERROR_NOT_FOUND && /* No driver attached */ - rc != LIBUSB_ERROR_NOT_SUPPORTED && /* win32 */ + rc = libusb_detach_kernel_driver(device->priv->handle, interface); + if (rc != LIBUSB_SUCCESS && rc != LIBUSB_ERROR_NOT_FOUND && /* No driver attached */ + rc != LIBUSB_ERROR_NOT_SUPPORTED && /* win32 */ rc != LIBUSB_ERROR_BUSY /* driver rebound already */) - return g_usb_device_libusb_error_to_gerror (device, rc, - error); + return g_usb_device_libusb_error_to_gerror(device, rc, error); } - rc = libusb_claim_interface (device->priv->handle, interface); - return g_usb_device_libusb_error_to_gerror (device, rc, error); + rc = libusb_claim_interface(device->priv->handle, interface); + return g_usb_device_libusb_error_to_gerror(device, rc, error); } /** @@ -910,32 +900,29 @@ g_usb_device_claim_interface (GUsbDevice *device, * Since: 0.1.0 **/ gboolean -g_usb_device_release_interface (GUsbDevice *device, - gint interface, - GUsbDeviceClaimInterfaceFlags flags, - GError **error) +g_usb_device_release_interface(GUsbDevice *device, + gint interface, + GUsbDeviceClaimInterfaceFlags flags, + GError **error) { gint rc; - g_return_val_if_fail (G_USB_IS_DEVICE (device), FALSE); - g_return_val_if_fail (error == NULL || *error == NULL, FALSE); + g_return_val_if_fail(G_USB_IS_DEVICE(device), FALSE); + g_return_val_if_fail(error == NULL || *error == NULL, FALSE); if (device->priv->handle == NULL) - return g_usb_device_not_open_error (device, error); + return g_usb_device_not_open_error(device, error); - rc = libusb_release_interface (device->priv->handle, interface); + rc = libusb_release_interface(device->priv->handle, interface); if (rc != LIBUSB_SUCCESS) - return g_usb_device_libusb_error_to_gerror (device, rc, error); + return g_usb_device_libusb_error_to_gerror(device, rc, error); if (flags & G_USB_DEVICE_CLAIM_INTERFACE_BIND_KERNEL_DRIVER) { - rc = libusb_attach_kernel_driver (device->priv->handle, - interface); - if (rc != LIBUSB_SUCCESS && - rc != LIBUSB_ERROR_NOT_FOUND && /* No driver attached */ - rc != LIBUSB_ERROR_NOT_SUPPORTED && /* win32 */ + rc = libusb_attach_kernel_driver(device->priv->handle, interface); + if (rc != LIBUSB_SUCCESS && rc != LIBUSB_ERROR_NOT_FOUND && /* No driver attached */ + rc != LIBUSB_ERROR_NOT_SUPPORTED && /* win32 */ rc != LIBUSB_ERROR_BUSY /* driver rebound already */) - return g_usb_device_libusb_error_to_gerror (device, rc, - error); + return g_usb_device_libusb_error_to_gerror(device, rc, error); } return TRUE; @@ -955,20 +942,19 @@ g_usb_device_release_interface (GUsbDevice *device, * Since: 0.2.8 **/ gboolean -g_usb_device_set_interface_alt (GUsbDevice *device, gint interface, - guint8 alt, GError **error) +g_usb_device_set_interface_alt(GUsbDevice *device, gint interface, guint8 alt, GError **error) { gint rc; - g_return_val_if_fail (G_USB_IS_DEVICE (device), FALSE); - g_return_val_if_fail (error == NULL || *error == NULL, FALSE); + g_return_val_if_fail(G_USB_IS_DEVICE(device), FALSE); + g_return_val_if_fail(error == NULL || *error == NULL, FALSE); if (device->priv->handle == NULL) - return g_usb_device_not_open_error (device, error); + return g_usb_device_not_open_error(device, error); - rc = libusb_set_interface_alt_setting (device->priv->handle, interface, (gint) alt); + rc = libusb_set_interface_alt_setting(device->priv->handle, interface, (gint)alt); if (rc != LIBUSB_SUCCESS) - return g_usb_device_libusb_error_to_gerror (device, rc, error); + return g_usb_device_libusb_error_to_gerror(device, rc, error); return TRUE; } @@ -986,30 +972,27 @@ g_usb_device_set_interface_alt (GUsbDevice *device, gint interface, * Since: 0.1.0 **/ gchar * -g_usb_device_get_string_descriptor (GUsbDevice *device, - guint8 desc_index, - GError **error) +g_usb_device_get_string_descriptor(GUsbDevice *device, guint8 desc_index, GError **error) { gint rc; /* libusb_get_string_descriptor_ascii returns max 128 bytes */ unsigned char buf[128]; - g_return_val_if_fail (G_USB_IS_DEVICE (device), NULL); - g_return_val_if_fail (error == NULL || *error == NULL, NULL); + g_return_val_if_fail(G_USB_IS_DEVICE(device), NULL); + g_return_val_if_fail(error == NULL || *error == NULL, NULL); if (device->priv->handle == NULL) { - g_usb_device_not_open_error (device, error); + g_usb_device_not_open_error(device, error); return NULL; } - rc = libusb_get_string_descriptor_ascii (device->priv->handle, - desc_index, buf, sizeof(buf)); + rc = libusb_get_string_descriptor_ascii(device->priv->handle, desc_index, buf, sizeof(buf)); if (rc < 0) { - g_usb_device_libusb_error_to_gerror (device, rc, error); + g_usb_device_libusb_error_to_gerror(device, rc, error); return NULL; } - return g_strdup ((const gchar *)buf); + return g_strdup((const gchar *)buf); } /** @@ -1027,32 +1010,30 @@ g_usb_device_get_string_descriptor (GUsbDevice *device, * Since: 0.3.8 **/ GBytes * -g_usb_device_get_string_descriptor_bytes_full (GUsbDevice *device, - guint8 desc_index, - guint16 langid, - gsize length, - GError **error) +g_usb_device_get_string_descriptor_bytes_full(GUsbDevice *device, + guint8 desc_index, + guint16 langid, + gsize length, + GError **error) { gint rc; g_autofree guint8 *buf = g_malloc0(length); - g_return_val_if_fail (G_USB_IS_DEVICE (device), NULL); - g_return_val_if_fail (error == NULL || *error == NULL, NULL); + g_return_val_if_fail(G_USB_IS_DEVICE(device), NULL); + g_return_val_if_fail(error == NULL || *error == NULL, NULL); if (device->priv->handle == NULL) { - g_usb_device_not_open_error (device, error); + g_usb_device_not_open_error(device, error); return NULL; } - rc = libusb_get_string_descriptor (device->priv->handle, - desc_index, langid, - buf, length); + rc = libusb_get_string_descriptor(device->priv->handle, desc_index, langid, buf, length); if (rc < 0) { - g_usb_device_libusb_error_to_gerror (device, rc, error); + g_usb_device_libusb_error_to_gerror(device, rc, error); return NULL; } - return g_bytes_new (buf, rc); + return g_bytes_new(buf, rc); } /** @@ -1072,10 +1053,10 @@ g_usb_device_get_string_descriptor_bytes_full (GUsbDevice *device, * Since: 0.3.6 **/ GBytes * -g_usb_device_get_string_descriptor_bytes (GUsbDevice *device, - guint8 desc_index, - guint16 langid, - GError **error) +g_usb_device_get_string_descriptor_bytes(GUsbDevice *device, + guint8 desc_index, + guint16 langid, + GError **error) { return g_usb_device_get_string_descriptor_bytes_full(device, desc_index, @@ -1084,23 +1065,21 @@ g_usb_device_get_string_descriptor_bytes (GUsbDevice *device, error); } -typedef gssize (GUsbDeviceTransferFinishFunc) (GUsbDevice *device, GAsyncResult *res, GError **error); +typedef gssize(GUsbDeviceTransferFinishFunc)(GUsbDevice *device, GAsyncResult *res, GError **error); typedef struct { - GError **error; - GMainContext *context; - GMainLoop *loop; - GUsbDeviceTransferFinishFunc *finish_func; - gssize ret; + GError **error; + GMainContext *context; + GMainLoop *loop; + GUsbDeviceTransferFinishFunc *finish_func; + gssize ret; } GUsbSyncHelper; static void -g_usb_device_sync_transfer_cb (GUsbDevice *device, - GAsyncResult *res, - GUsbSyncHelper *helper) +g_usb_device_sync_transfer_cb(GUsbDevice *device, GAsyncResult *res, GUsbSyncHelper *helper) { - helper->ret = (*helper->finish_func) (device, res, helper->error); - g_main_loop_quit (helper->loop); + helper->ret = (*helper->finish_func)(device, res, helper->error); + g_main_loop_quit(helper->loop); } /** @@ -1129,46 +1108,46 @@ g_usb_device_sync_transfer_cb (GUsbDevice *device, * Since: 0.1.0 **/ gboolean -g_usb_device_control_transfer (GUsbDevice *device, - GUsbDeviceDirection direction, - GUsbDeviceRequestType request_type, - GUsbDeviceRecipient recipient, - guint8 request, - guint16 value, - guint16 idx, - guint8 *data, - gsize length, - gsize *actual_length, - guint timeout, - GCancellable *cancellable, - GError **error) +g_usb_device_control_transfer(GUsbDevice *device, + GUsbDeviceDirection direction, + GUsbDeviceRequestType request_type, + GUsbDeviceRecipient recipient, + guint8 request, + guint16 value, + guint16 idx, + guint8 *data, + gsize length, + gsize *actual_length, + guint timeout, + GCancellable *cancellable, + GError **error) { GUsbSyncHelper helper; helper.ret = -1; - helper.context = g_usb_context_get_main_context (device->priv->context); - helper.loop = g_main_loop_new (helper.context, FALSE); + helper.context = g_usb_context_get_main_context(device->priv->context); + helper.loop = g_main_loop_new(helper.context, FALSE); helper.error = error; helper.finish_func = g_usb_device_control_transfer_finish; - g_usb_device_control_transfer_async (device, - direction, - request_type, - recipient, - request, - value, - idx, - data, - length, - timeout, - cancellable, - (GAsyncReadyCallback) g_usb_device_sync_transfer_cb, - &helper); - g_main_loop_run (helper.loop); - g_main_loop_unref (helper.loop); + g_usb_device_control_transfer_async(device, + direction, + request_type, + recipient, + request, + value, + idx, + data, + length, + timeout, + cancellable, + (GAsyncReadyCallback)g_usb_device_sync_transfer_cb, + &helper); + g_main_loop_run(helper.loop); + g_main_loop_unref(helper.loop); if (actual_length != NULL) - *actual_length = (gsize) helper.ret; + *actual_length = (gsize)helper.ret; return helper.ret != -1; } @@ -1196,36 +1175,36 @@ g_usb_device_control_transfer (GUsbDevice *device, * Since: 0.1.0 **/ gboolean -g_usb_device_bulk_transfer (GUsbDevice *device, - guint8 endpoint, - guint8 *data, - gsize length, - gsize *actual_length, - guint timeout, - GCancellable *cancellable, - GError **error) +g_usb_device_bulk_transfer(GUsbDevice *device, + guint8 endpoint, + guint8 *data, + gsize length, + gsize *actual_length, + guint timeout, + GCancellable *cancellable, + GError **error) { GUsbSyncHelper helper; helper.ret = -1; - helper.context = g_usb_context_get_main_context (device->priv->context); - helper.loop = g_main_loop_new (helper.context, FALSE); + helper.context = g_usb_context_get_main_context(device->priv->context); + helper.loop = g_main_loop_new(helper.context, FALSE); helper.error = error; helper.finish_func = g_usb_device_bulk_transfer_finish; - g_usb_device_bulk_transfer_async (device, - endpoint, - data, - length, - timeout, - cancellable, - (GAsyncReadyCallback) g_usb_device_sync_transfer_cb, - &helper); - g_main_loop_run (helper.loop); - g_main_loop_unref (helper.loop); + g_usb_device_bulk_transfer_async(device, + endpoint, + data, + length, + timeout, + cancellable, + (GAsyncReadyCallback)g_usb_device_sync_transfer_cb, + &helper); + g_main_loop_run(helper.loop); + g_main_loop_unref(helper.loop); if (actual_length != NULL) - *actual_length = (gsize) helper.ret; + *actual_length = (gsize)helper.ret; return helper.ret != -1; } @@ -1253,33 +1232,33 @@ g_usb_device_bulk_transfer (GUsbDevice *device, * Since: 0.1.0 **/ gboolean -g_usb_device_interrupt_transfer (GUsbDevice *device, - guint8 endpoint, - guint8 *data, - gsize length, - gsize *actual_length, - guint timeout, - GCancellable *cancellable, - GError **error) +g_usb_device_interrupt_transfer(GUsbDevice *device, + guint8 endpoint, + guint8 *data, + gsize length, + gsize *actual_length, + guint timeout, + GCancellable *cancellable, + GError **error) { GUsbSyncHelper helper; helper.ret = -1; - helper.context = g_usb_context_get_main_context (device->priv->context); - helper.loop = g_main_loop_new (helper.context, FALSE); + helper.context = g_usb_context_get_main_context(device->priv->context); + helper.loop = g_main_loop_new(helper.context, FALSE); helper.error = error; helper.finish_func = g_usb_device_interrupt_transfer_finish; - g_usb_device_interrupt_transfer_async (device, - endpoint, - data, - length, - timeout, - cancellable, - (GAsyncReadyCallback) g_usb_device_sync_transfer_cb, - &helper); - g_main_loop_run (helper.loop); - g_main_loop_unref (helper.loop); + g_usb_device_interrupt_transfer_async(device, + endpoint, + data, + length, + timeout, + cancellable, + (GAsyncReadyCallback)g_usb_device_sync_transfer_cb, + &helper); + g_main_loop_run(helper.loop); + g_main_loop_unref(helper.loop); if (actual_length != NULL) *actual_length = helper.ret; @@ -1288,30 +1267,28 @@ g_usb_device_interrupt_transfer (GUsbDevice *device, } typedef struct { - GCancellable *cancellable; - gulong cancellable_id; - struct libusb_transfer *transfer; - guint8 *data; /* owned by the user */ - guint8 *data_raw; /* owned by the task */ + GCancellable *cancellable; + gulong cancellable_id; + struct libusb_transfer *transfer; + guint8 *data; /* owned by the user */ + guint8 *data_raw; /* owned by the task */ } GcmDeviceReq; static void -g_usb_device_req_free (GcmDeviceReq *req) +g_usb_device_req_free(GcmDeviceReq *req) { - g_free (req->data_raw); + g_free(req->data_raw); if (req->cancellable_id > 0) { - g_cancellable_disconnect (req->cancellable, - req->cancellable_id); - g_object_unref (req->cancellable); + g_cancellable_disconnect(req->cancellable, req->cancellable_id); + g_object_unref(req->cancellable); } - libusb_free_transfer (req->transfer); - g_slice_free (GcmDeviceReq, req); + libusb_free_transfer(req->transfer); + g_slice_free(GcmDeviceReq, req); } static gboolean -g_usb_device_libusb_status_to_gerror (gint status, - GError **error) +g_usb_device_libusb_status_to_gerror(gint status, GError **error) { gboolean ret = FALSE; @@ -1320,96 +1297,95 @@ g_usb_device_libusb_status_to_gerror (gint status, ret = TRUE; break; case LIBUSB_TRANSFER_ERROR: - g_set_error_literal (error, - G_USB_DEVICE_ERROR, - G_USB_DEVICE_ERROR_FAILED, - "transfer failed"); + g_set_error_literal(error, + G_USB_DEVICE_ERROR, + G_USB_DEVICE_ERROR_FAILED, + "transfer failed"); break; case LIBUSB_TRANSFER_TIMED_OUT: - g_set_error_literal (error, - G_USB_DEVICE_ERROR, - G_USB_DEVICE_ERROR_TIMED_OUT, - "transfer timed out"); + g_set_error_literal(error, + G_USB_DEVICE_ERROR, + G_USB_DEVICE_ERROR_TIMED_OUT, + "transfer timed out"); break; case LIBUSB_TRANSFER_CANCELLED: - g_set_error_literal (error, - G_USB_DEVICE_ERROR, - G_USB_DEVICE_ERROR_CANCELLED, - "transfer cancelled"); + g_set_error_literal(error, + G_USB_DEVICE_ERROR, + G_USB_DEVICE_ERROR_CANCELLED, + "transfer cancelled"); break; case LIBUSB_TRANSFER_STALL: - g_set_error_literal (error, - G_USB_DEVICE_ERROR, - G_USB_DEVICE_ERROR_NOT_SUPPORTED, - "endpoint stalled or request not supported"); + g_set_error_literal(error, + G_USB_DEVICE_ERROR, + G_USB_DEVICE_ERROR_NOT_SUPPORTED, + "endpoint stalled or request not supported"); break; case LIBUSB_TRANSFER_NO_DEVICE: - g_set_error_literal (error, - G_USB_DEVICE_ERROR, - G_USB_DEVICE_ERROR_NO_DEVICE, - "device was disconnected"); + g_set_error_literal(error, + G_USB_DEVICE_ERROR, + G_USB_DEVICE_ERROR_NO_DEVICE, + "device was disconnected"); break; case LIBUSB_TRANSFER_OVERFLOW: - g_set_error_literal (error, - G_USB_DEVICE_ERROR, - G_USB_DEVICE_ERROR_INTERNAL, - "device sent more data than requested"); + g_set_error_literal(error, + G_USB_DEVICE_ERROR, + G_USB_DEVICE_ERROR_INTERNAL, + "device sent more data than requested"); break; default: - g_set_error (error, - G_USB_DEVICE_ERROR, - G_USB_DEVICE_ERROR_INTERNAL, - "unknown status [%i]", status); + g_set_error(error, + G_USB_DEVICE_ERROR, + G_USB_DEVICE_ERROR_INTERNAL, + "unknown status [%i]", + status); } return ret; } static void -g_usb_device_async_transfer_cb (struct libusb_transfer *transfer) +g_usb_device_async_transfer_cb(struct libusb_transfer *transfer) { GTask *task = transfer->user_data; gboolean ret; GError *error = NULL; /* did request fail? */ - ret = g_usb_device_libusb_status_to_gerror (transfer->status, &error); + ret = g_usb_device_libusb_status_to_gerror(transfer->status, &error); if (!ret) { - g_task_return_error (task, error); + g_task_return_error(task, error); } else { - g_task_return_int (task, transfer->actual_length); + g_task_return_int(task, transfer->actual_length); } - g_object_unref (task); + g_object_unref(task); } static void -g_usb_device_cancelled_cb (GCancellable *cancellable, - GcmDeviceReq *req) +g_usb_device_cancelled_cb(GCancellable *cancellable, GcmDeviceReq *req) { - libusb_cancel_transfer (req->transfer); + libusb_cancel_transfer(req->transfer); } static void -g_usb_device_control_transfer_cb (struct libusb_transfer *transfer) +g_usb_device_control_transfer_cb(struct libusb_transfer *transfer) { GTask *task = transfer->user_data; - GcmDeviceReq *req = g_task_get_task_data (task); + GcmDeviceReq *req = g_task_get_task_data(task); gboolean ret; GError *error = NULL; /* did request fail? */ - ret = g_usb_device_libusb_status_to_gerror (transfer->status, - &error); + ret = g_usb_device_libusb_status_to_gerror(transfer->status, &error); if (!ret) { - g_task_return_error (task, error); + g_task_return_error(task, error); } else { - memmove (req->data, - transfer->buffer + LIBUSB_CONTROL_SETUP_SIZE, - (gsize) transfer->actual_length); - g_task_return_int (task, transfer->actual_length); + memmove(req->data, + transfer->buffer + LIBUSB_CONTROL_SETUP_SIZE, + (gsize)transfer->actual_length); + g_task_return_int(task, transfer->actual_length); } - g_object_unref (task); + g_object_unref(task); } /** @@ -1430,19 +1406,19 @@ g_usb_device_control_transfer_cb (struct libusb_transfer *transfer) * Since: 0.1.0 **/ void -g_usb_device_control_transfer_async (GUsbDevice *device, - GUsbDeviceDirection direction, - GUsbDeviceRequestType request_type, - GUsbDeviceRecipient recipient, - guint8 request, - guint16 value, - guint16 idx, - guint8 *data, - gsize length, - guint timeout, - GCancellable *cancellable, - GAsyncReadyCallback callback, - gpointer user_data) +g_usb_device_control_transfer_async(GUsbDevice *device, + GUsbDeviceDirection direction, + GUsbDeviceRequestType request_type, + GUsbDeviceRecipient recipient, + guint8 request, + guint16 value, + guint16 idx, + guint8 *data, + gsize length, + guint timeout, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) { GTask *task; GcmDeviceReq *req; @@ -1450,23 +1426,25 @@ g_usb_device_control_transfer_async (GUsbDevice *device, guint8 request_type_raw = 0; GError *error = NULL; - g_return_if_fail (G_USB_IS_DEVICE (device)); + g_return_if_fail(G_USB_IS_DEVICE(device)); if (device->priv->handle == NULL) { - g_usb_device_async_not_open_error (device, callback, user_data, - g_usb_device_control_transfer_async); + g_usb_device_async_not_open_error(device, + callback, + user_data, + g_usb_device_control_transfer_async); return; } - req = g_slice_new0 (GcmDeviceReq); - req->transfer = libusb_alloc_transfer (0); + req = g_slice_new0(GcmDeviceReq); + req->transfer = libusb_alloc_transfer(0); req->data = data; - task = g_task_new (device, cancellable, callback, user_data); - g_task_set_task_data (task, req, (GDestroyNotify)g_usb_device_req_free); + task = g_task_new(device, cancellable, callback, user_data); + g_task_set_task_data(task, req, (GDestroyNotify)g_usb_device_req_free); - if (g_task_return_error_if_cancelled (task)) { - g_object_unref (task); + if (g_task_return_error_if_cancelled(task)) { + g_object_unref(task); return; } @@ -1476,36 +1454,35 @@ g_usb_device_control_transfer_async (GUsbDevice *device, request_type_raw |= (request_type << 5); request_type_raw |= recipient; - req->data_raw = g_malloc0 (length + LIBUSB_CONTROL_SETUP_SIZE); - memmove (req->data_raw + LIBUSB_CONTROL_SETUP_SIZE, data, length); + req->data_raw = g_malloc0(length + LIBUSB_CONTROL_SETUP_SIZE); + memmove(req->data_raw + LIBUSB_CONTROL_SETUP_SIZE, data, length); /* fill in setup packet */ - libusb_fill_control_setup (req->data_raw, request_type_raw, - request, value, idx, length); + libusb_fill_control_setup(req->data_raw, request_type_raw, request, value, idx, length); /* fill in transfer details */ - libusb_fill_control_transfer (req->transfer, - device->priv->handle, - req->data_raw, - g_usb_device_control_transfer_cb, - task, - timeout); + libusb_fill_control_transfer(req->transfer, + device->priv->handle, + req->data_raw, + g_usb_device_control_transfer_cb, + task, + timeout); /* submit transfer */ - rc = libusb_submit_transfer (req->transfer); + rc = libusb_submit_transfer(req->transfer); if (rc < 0) { - g_usb_device_libusb_error_to_gerror (device, rc, &error); - g_task_return_error (task, error); - g_object_unref (task); + g_usb_device_libusb_error_to_gerror(device, rc, &error); + g_task_return_error(task, error); + g_object_unref(task); } /* setup cancellation after submission */ if (cancellable != NULL) { - req->cancellable = g_object_ref (cancellable); - req->cancellable_id = g_cancellable_connect (req->cancellable, - G_CALLBACK (g_usb_device_cancelled_cb), - req, - NULL); + req->cancellable = g_object_ref(cancellable); + req->cancellable_id = g_cancellable_connect(req->cancellable, + G_CALLBACK(g_usb_device_cancelled_cb), + req, + NULL); } } @@ -1522,15 +1499,13 @@ g_usb_device_control_transfer_async (GUsbDevice *device, * Since: 0.1.0 **/ gssize -g_usb_device_control_transfer_finish (GUsbDevice *device, - GAsyncResult *res, - GError **error) +g_usb_device_control_transfer_finish(GUsbDevice *device, GAsyncResult *res, GError **error) { - g_return_val_if_fail (G_USB_IS_DEVICE (device), -1); - g_return_val_if_fail (g_task_is_valid (res, device), -1); - g_return_val_if_fail (error == NULL || *error == NULL, -1); + g_return_val_if_fail(G_USB_IS_DEVICE(device), -1); + g_return_val_if_fail(g_task_is_valid(res, device), -1); + g_return_val_if_fail(error == NULL || *error == NULL, -1); - return g_task_propagate_int (G_TASK (res), error); + return g_task_propagate_int(G_TASK(res), error); } /** @@ -1552,64 +1527,66 @@ g_usb_device_control_transfer_finish (GUsbDevice *device, * Since: 0.1.0 **/ void -g_usb_device_bulk_transfer_async (GUsbDevice *device, - guint8 endpoint, - guint8 *data, - gsize length, - guint timeout, - GCancellable *cancellable, - GAsyncReadyCallback callback, - gpointer user_data) +g_usb_device_bulk_transfer_async(GUsbDevice *device, + guint8 endpoint, + guint8 *data, + gsize length, + guint timeout, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) { GTask *task; GcmDeviceReq *req; gint rc; GError *error = NULL; - g_return_if_fail (G_USB_IS_DEVICE (device)); + g_return_if_fail(G_USB_IS_DEVICE(device)); if (device->priv->handle == NULL) { - g_usb_device_async_not_open_error (device, callback, user_data, - g_usb_device_bulk_transfer_async); + g_usb_device_async_not_open_error(device, + callback, + user_data, + g_usb_device_bulk_transfer_async); return; } - req = g_slice_new0 (GcmDeviceReq); - req->transfer = libusb_alloc_transfer (0); + req = g_slice_new0(GcmDeviceReq); + req->transfer = libusb_alloc_transfer(0); - task = g_task_new (device, cancellable, callback, user_data); - g_task_set_task_data (task, req, (GDestroyNotify)g_usb_device_req_free); + task = g_task_new(device, cancellable, callback, user_data); + g_task_set_task_data(task, req, (GDestroyNotify)g_usb_device_req_free); - if (g_task_return_error_if_cancelled (task)) { - g_object_unref (task); + if (g_task_return_error_if_cancelled(task)) { + g_object_unref(task); return; } /* fill in transfer details */ - libusb_fill_bulk_transfer (req->transfer, - device->priv->handle, - endpoint, - data, - length, - g_usb_device_async_transfer_cb, - task, - timeout); + libusb_fill_bulk_transfer(req->transfer, + device->priv->handle, + endpoint, + data, + length, + g_usb_device_async_transfer_cb, + task, + timeout); /* submit transfer */ - rc = libusb_submit_transfer (req->transfer); + rc = libusb_submit_transfer(req->transfer); if (rc < 0) { - g_usb_device_libusb_error_to_gerror (device, rc, &error); - g_task_return_error (task, error); - g_object_unref (task); + g_usb_device_libusb_error_to_gerror(device, rc, &error); + g_task_return_error(task, error); + g_object_unref(task); } /* setup cancellation after submission */ if (cancellable != NULL) { - req->cancellable = g_object_ref (cancellable); - req->cancellable_id = g_cancellable_connect (req->cancellable, - G_CALLBACK (g_usb_device_cancelled_cb), - req, - NULL); + req->cancellable = g_object_ref(cancellable); + req->cancellable_id = g_cancellable_connect(req->cancellable, + G_CALLBACK(g_usb_device_cancelled_cb), + req, + NULL); } } @@ -1626,15 +1603,13 @@ g_usb_device_bulk_transfer_async (GUsbDevice *device, * Since: 0.1.0 **/ gssize -g_usb_device_bulk_transfer_finish (GUsbDevice *device, - GAsyncResult *res, - GError **error) +g_usb_device_bulk_transfer_finish(GUsbDevice *device, GAsyncResult *res, GError **error) { - g_return_val_if_fail (G_USB_IS_DEVICE (device), -1); - g_return_val_if_fail (g_task_is_valid (res, device), -1); - g_return_val_if_fail (error == NULL || *error == NULL, -1); + g_return_val_if_fail(G_USB_IS_DEVICE(device), -1); + g_return_val_if_fail(g_task_is_valid(res, device), -1); + g_return_val_if_fail(error == NULL || *error == NULL, -1); - return g_task_propagate_int (G_TASK (res), error); + return g_task_propagate_int(G_TASK(res), error); } /** @@ -1656,64 +1631,66 @@ g_usb_device_bulk_transfer_finish (GUsbDevice *device, * Since: 0.1.0 **/ void -g_usb_device_interrupt_transfer_async (GUsbDevice *device, - guint8 endpoint, - guint8 *data, - gsize length, - guint timeout, - GCancellable *cancellable, - GAsyncReadyCallback callback, - gpointer user_data) +g_usb_device_interrupt_transfer_async(GUsbDevice *device, + guint8 endpoint, + guint8 *data, + gsize length, + guint timeout, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) { GTask *task; GcmDeviceReq *req; GError *error = NULL; gint rc; - g_return_if_fail (G_USB_IS_DEVICE (device)); + g_return_if_fail(G_USB_IS_DEVICE(device)); if (device->priv->handle == NULL) { - g_usb_device_async_not_open_error (device, callback, user_data, - g_usb_device_interrupt_transfer_async); + g_usb_device_async_not_open_error(device, + callback, + user_data, + g_usb_device_interrupt_transfer_async); return; } - req = g_slice_new0 (GcmDeviceReq); - req->transfer = libusb_alloc_transfer (0); + req = g_slice_new0(GcmDeviceReq); + req->transfer = libusb_alloc_transfer(0); - task = g_task_new (device, cancellable, callback, user_data); - g_task_set_task_data (task, req, (GDestroyNotify)g_usb_device_req_free); + task = g_task_new(device, cancellable, callback, user_data); + g_task_set_task_data(task, req, (GDestroyNotify)g_usb_device_req_free); - if (g_task_return_error_if_cancelled (task)) { - g_object_unref (task); + if (g_task_return_error_if_cancelled(task)) { + g_object_unref(task); return; } /* fill in transfer details */ - libusb_fill_interrupt_transfer (req->transfer, - device->priv->handle, - endpoint, - data, - length, - g_usb_device_async_transfer_cb, - task, - timeout); + libusb_fill_interrupt_transfer(req->transfer, + device->priv->handle, + endpoint, + data, + length, + g_usb_device_async_transfer_cb, + task, + timeout); /* submit transfer */ - rc = libusb_submit_transfer (req->transfer); + rc = libusb_submit_transfer(req->transfer); if (rc < 0) { - g_usb_device_libusb_error_to_gerror (device, rc, &error); - g_task_return_error (task, error); - g_object_unref (task); + g_usb_device_libusb_error_to_gerror(device, rc, &error); + g_task_return_error(task, error); + g_object_unref(task); } /* setup cancellation after submission */ if (cancellable != NULL) { - req->cancellable = g_object_ref (cancellable); - req->cancellable_id = g_cancellable_connect (req->cancellable, - G_CALLBACK (g_usb_device_cancelled_cb), - req, - NULL); + req->cancellable = g_object_ref(cancellable); + req->cancellable_id = g_cancellable_connect(req->cancellable, + G_CALLBACK(g_usb_device_cancelled_cb), + req, + NULL); } } @@ -1730,15 +1707,13 @@ g_usb_device_interrupt_transfer_async (GUsbDevice *device, * Since: 0.1.0 **/ gssize -g_usb_device_interrupt_transfer_finish (GUsbDevice *device, - GAsyncResult *res, - GError **error) +g_usb_device_interrupt_transfer_finish(GUsbDevice *device, GAsyncResult *res, GError **error) { - g_return_val_if_fail (G_USB_IS_DEVICE (device), -1); - g_return_val_if_fail (g_task_is_valid (res, device), -1); - g_return_val_if_fail (error == NULL || *error == NULL, -1); + g_return_val_if_fail(G_USB_IS_DEVICE(device), -1); + g_return_val_if_fail(g_task_is_valid(res, device), -1); + g_return_val_if_fail(error == NULL || *error == NULL, -1); - return g_task_propagate_int (G_TASK (res), error); + return g_task_propagate_int(G_TASK(res), error); } /** @@ -1755,9 +1730,9 @@ g_usb_device_interrupt_transfer_finish (GUsbDevice *device, * Since: 0.1.1 **/ const gchar * -g_usb_device_get_platform_id (GUsbDevice *device) +g_usb_device_get_platform_id(GUsbDevice *device) { - g_return_val_if_fail (G_USB_IS_DEVICE (device), NULL); + g_return_val_if_fail(G_USB_IS_DEVICE(device), NULL); return device->priv->platform_id; } @@ -1773,19 +1748,19 @@ g_usb_device_get_platform_id (GUsbDevice *device) * Since: 0.2.4 **/ GUsbDevice * -g_usb_device_get_parent (GUsbDevice *device) +g_usb_device_get_parent(GUsbDevice *device) { GUsbDevicePrivate *priv = device->priv; libusb_device *parent; - parent = libusb_get_parent (priv->device); + parent = libusb_get_parent(priv->device); if (parent == NULL) return NULL; - return g_usb_context_find_by_bus_address (priv->context, - libusb_get_bus_number (parent), - libusb_get_device_address (parent), - NULL); + return g_usb_context_find_by_bus_address(priv->context, + libusb_get_bus_number(parent), + libusb_get_device_address(parent), + NULL); } /** @@ -1799,7 +1774,7 @@ g_usb_device_get_parent (GUsbDevice *device) * Since: 0.2.4 **/ GPtrArray * -g_usb_device_get_children (GUsbDevice *device) +g_usb_device_get_children(GUsbDevice *device) { GPtrArray *children; GUsbDevice *device_tmp; @@ -1807,12 +1782,12 @@ g_usb_device_get_children (GUsbDevice *device) g_autoptr(GPtrArray) devices = NULL; /* find any devices that have @device as a parent */ - children = g_ptr_array_new_with_free_func ((GDestroyNotify) g_object_unref); - devices = g_usb_context_get_devices (priv->context); + children = g_ptr_array_new_with_free_func((GDestroyNotify)g_object_unref); + devices = g_usb_context_get_devices(priv->context); for (guint i = 0; i < devices->len; i++) { - device_tmp = g_ptr_array_index (devices, i); - if (priv->device == libusb_get_parent (device_tmp->priv->device)) - g_ptr_array_add (children, g_object_ref (device_tmp)); + device_tmp = g_ptr_array_index(devices, i); + if (priv->device == libusb_get_parent(device_tmp->priv->device)) + g_ptr_array_add(children, g_object_ref(device_tmp)); } return children; @@ -1829,11 +1804,11 @@ g_usb_device_get_children (GUsbDevice *device) * Since: 0.1.0 **/ guint8 -g_usb_device_get_bus (GUsbDevice *device) +g_usb_device_get_bus(GUsbDevice *device) { - g_return_val_if_fail (G_USB_IS_DEVICE (device), 0); + g_return_val_if_fail(G_USB_IS_DEVICE(device), 0); - return libusb_get_bus_number (device->priv->device); + return libusb_get_bus_number(device->priv->device); } /** @@ -1847,11 +1822,11 @@ g_usb_device_get_bus (GUsbDevice *device) * Since: 0.1.0 **/ guint8 -g_usb_device_get_address (GUsbDevice *device) +g_usb_device_get_address(GUsbDevice *device) { - g_return_val_if_fail (G_USB_IS_DEVICE (device), 0); + g_return_val_if_fail(G_USB_IS_DEVICE(device), 0); - return libusb_get_device_address (device->priv->device); + return libusb_get_device_address(device->priv->device); } /** @@ -1865,10 +1840,10 @@ g_usb_device_get_address (GUsbDevice *device) * Since: 0.2.4 **/ guint8 -g_usb_device_get_port_number (GUsbDevice *device) +g_usb_device_get_port_number(GUsbDevice *device) { - g_return_val_if_fail (G_USB_IS_DEVICE (device), 0); - return libusb_get_port_number (device->priv->device); + g_return_val_if_fail(G_USB_IS_DEVICE(device), 0); + return libusb_get_port_number(device->priv->device); } /** @@ -1882,9 +1857,9 @@ g_usb_device_get_port_number (GUsbDevice *device) * Since: 0.1.0 **/ guint16 -g_usb_device_get_vid (GUsbDevice *device) +g_usb_device_get_vid(GUsbDevice *device) { - g_return_val_if_fail (G_USB_IS_DEVICE (device), 0); + g_return_val_if_fail(G_USB_IS_DEVICE(device), 0); return device->priv->desc.idVendor; } @@ -1900,9 +1875,9 @@ g_usb_device_get_vid (GUsbDevice *device) * Since: 0.1.0 **/ guint16 -g_usb_device_get_pid (GUsbDevice *device) +g_usb_device_get_pid(GUsbDevice *device) { - g_return_val_if_fail (G_USB_IS_DEVICE (device), 0); + g_return_val_if_fail(G_USB_IS_DEVICE(device), 0); return device->priv->desc.idProduct; } @@ -1918,9 +1893,9 @@ g_usb_device_get_pid (GUsbDevice *device) * Since: 0.2.8 **/ guint16 -g_usb_device_get_release (GUsbDevice *device) +g_usb_device_get_release(GUsbDevice *device) { - g_return_val_if_fail (G_USB_IS_DEVICE (device), 0); + g_return_val_if_fail(G_USB_IS_DEVICE(device), 0); return device->priv->desc.bcdDevice; } @@ -1937,9 +1912,9 @@ g_usb_device_get_release (GUsbDevice *device) * Since: 0.3.1 **/ guint16 -g_usb_device_get_spec (GUsbDevice *device) +g_usb_device_get_spec(GUsbDevice *device) { - g_return_val_if_fail (G_USB_IS_DEVICE (device), 0); + g_return_val_if_fail(G_USB_IS_DEVICE(device), 0); return device->priv->desc.bcdUSB; } @@ -1955,12 +1930,12 @@ g_usb_device_get_spec (GUsbDevice *device) * Since: 0.2.4 **/ const gchar * -g_usb_device_get_vid_as_str (GUsbDevice *device) +g_usb_device_get_vid_as_str(GUsbDevice *device) { - g_return_val_if_fail (G_USB_IS_DEVICE (device), NULL); - return _g_usb_context_lookup_vendor (device->priv->context, - device->priv->desc.idVendor, - NULL); + g_return_val_if_fail(G_USB_IS_DEVICE(device), NULL); + return _g_usb_context_lookup_vendor(device->priv->context, + device->priv->desc.idVendor, + NULL); } /** @@ -1974,13 +1949,13 @@ g_usb_device_get_vid_as_str (GUsbDevice *device) * Since: 0.2.4 **/ const gchar * -g_usb_device_get_pid_as_str (GUsbDevice *device) +g_usb_device_get_pid_as_str(GUsbDevice *device) { - g_return_val_if_fail (G_USB_IS_DEVICE (device), NULL); - return _g_usb_context_lookup_product (device->priv->context, - device->priv->desc.idVendor, - device->priv->desc.idProduct, - NULL); + g_return_val_if_fail(G_USB_IS_DEVICE(device), NULL); + return _g_usb_context_lookup_product(device->priv->context, + device->priv->desc.idVendor, + device->priv->desc.idProduct, + NULL); } /** @@ -1995,24 +1970,23 @@ g_usb_device_get_pid_as_str (GUsbDevice *device) * Since: 0.3.5 **/ guint8 -g_usb_device_get_configuration_index (GUsbDevice *device) +g_usb_device_get_configuration_index(GUsbDevice *device) { struct libusb_config_descriptor *config; gint rc; guint8 index; - g_return_val_if_fail (G_USB_IS_DEVICE (device), 0); + g_return_val_if_fail(G_USB_IS_DEVICE(device), 0); - rc = libusb_get_active_config_descriptor (device->priv->device, &config); - g_return_val_if_fail (rc == 0, 0); + rc = libusb_get_active_config_descriptor(device->priv->device, &config); + g_return_val_if_fail(rc == 0, 0); index = config->iConfiguration; - libusb_free_config_descriptor (config); + libusb_free_config_descriptor(config); return index; } - /** * g_usb_device_get_manufacturer_index: * @device: a #GUsbDevice @@ -2024,9 +1998,9 @@ g_usb_device_get_configuration_index (GUsbDevice *device) * Since: 0.1.0 **/ guint8 -g_usb_device_get_manufacturer_index (GUsbDevice *device) +g_usb_device_get_manufacturer_index(GUsbDevice *device) { - g_return_val_if_fail (G_USB_IS_DEVICE (device), 0); + g_return_val_if_fail(G_USB_IS_DEVICE(device), 0); return device->priv->desc.iManufacturer; } @@ -2042,9 +2016,9 @@ g_usb_device_get_manufacturer_index (GUsbDevice *device) * Since: 0.1.7 **/ guint8 -g_usb_device_get_device_class (GUsbDevice *device) +g_usb_device_get_device_class(GUsbDevice *device) { - g_return_val_if_fail (G_USB_IS_DEVICE (device), 0); + g_return_val_if_fail(G_USB_IS_DEVICE(device), 0); return device->priv->desc.bDeviceClass; } @@ -2061,9 +2035,9 @@ g_usb_device_get_device_class (GUsbDevice *device) * Since: 0.2.4 **/ guint8 -g_usb_device_get_device_subclass (GUsbDevice *device) +g_usb_device_get_device_subclass(GUsbDevice *device) { - g_return_val_if_fail (G_USB_IS_DEVICE (device), 0); + g_return_val_if_fail(G_USB_IS_DEVICE(device), 0); return device->priv->desc.bDeviceSubClass; } @@ -2080,9 +2054,9 @@ g_usb_device_get_device_subclass (GUsbDevice *device) * Since: 0.2.4 **/ guint8 -g_usb_device_get_device_protocol (GUsbDevice *device) +g_usb_device_get_device_protocol(GUsbDevice *device) { - g_return_val_if_fail (G_USB_IS_DEVICE (device), 0); + g_return_val_if_fail(G_USB_IS_DEVICE(device), 0); return device->priv->desc.bDeviceProtocol; } @@ -2098,9 +2072,9 @@ g_usb_device_get_device_protocol (GUsbDevice *device) * Since: 0.1.0 **/ guint8 -g_usb_device_get_product_index (GUsbDevice *device) +g_usb_device_get_product_index(GUsbDevice *device) { - g_return_val_if_fail (G_USB_IS_DEVICE (device), 0); + g_return_val_if_fail(G_USB_IS_DEVICE(device), 0); return device->priv->desc.iProduct; } @@ -2116,9 +2090,9 @@ g_usb_device_get_product_index (GUsbDevice *device) * Since: 0.1.0 **/ guint8 -g_usb_device_get_serial_number_index (GUsbDevice *device) +g_usb_device_get_serial_number_index(GUsbDevice *device) { - g_return_val_if_fail (G_USB_IS_DEVICE (device), 0); + g_return_val_if_fail(G_USB_IS_DEVICE(device), 0); return device->priv->desc.iSerialNumber; } |