static void
gusb_main_device_open (GUsbDevice *device)
{
GError *error = NULL;
guint8 idx;
/* open */
if (!g_usb_device_open (device, &error)) {
g_print ("failed to open: %s\n", error->message);
g_error_free (error);
return;
}
/* print info we can only get whilst open */
idx = g_usb_device_get_product_index (device);
if (idx != 0x00) {
gchar *product = g_usb_device_get_string_descriptor (device, idx, &error);
if (product == NULL) {
g_print ("failed to get string desc: %s\n", error->message);
g_error_free (error);
return;
}
g_print ("product: %s\n", product);
}
}
static void
fu_provider_chug_get_firmware_version (FuProviderChugItem *item)
{
FuProviderChugPrivate *priv = GET_PRIVATE (item->provider_chug);
guint16 major;
guint16 micro;
guint16 minor;
guint8 idx;
g_autoptr(GError) error = NULL;
g_autofree gchar *version = NULL;
/* try to get the version without claiming interface */
if (!g_usb_device_open (item->usb_device, &error)) {
g_debug ("Failed to open, polling: %s", error->message);
return;
}
idx = g_usb_device_get_custom_index (item->usb_device,
G_USB_DEVICE_CLASS_VENDOR_SPECIFIC,
'F', 'W', NULL);
if (idx != 0x00) {
g_autofree gchar *tmp = NULL;
tmp = g_usb_device_get_string_descriptor (item->usb_device,
idx, NULL);
if (tmp != NULL) {
item->got_version = TRUE;
g_debug ("obtained fwver using extension '%s'", tmp);
fu_device_set_version (item->device, tmp);
goto out;
}
}
g_usb_device_close (item->usb_device, NULL);
/* attempt to open the device and get the serial number */
if (!ch_device_open (item->usb_device, &error)) {
g_debug ("Failed to claim interface, polling: %s", error->message);
return;
}
ch_device_queue_get_firmware_ver (priv->device_queue, item->usb_device,
&major, &minor, µ);
if (!ch_device_queue_process (priv->device_queue,
CH_DEVICE_QUEUE_PROCESS_FLAGS_NONE,
NULL, &error)) {
g_warning ("Failed to get serial: %s", error->message);
goto out;
}
/* got things the old fashioned way */
item->got_version = TRUE;
version = g_strdup_printf ("%i.%i.%i", major, minor, micro);
g_debug ("obtained fwver using API '%s'", version);
fu_device_set_version (item->device, version);
out:
/* we're done here */
g_clear_error (&error);
if (!g_usb_device_close (item->usb_device, &error))
g_debug ("Failed to close: %s", error->message);
}
/**
* dfu_target_setup:
* @target: a #DfuTarget
* @error: a #GError, or %NULL
*
* Opens a DFU-capable target.
*
* Return value: %TRUE for success
*
* Since: 0.5.4
**/
static gboolean
dfu_target_setup (DfuTarget *target, GError **error)
{
DfuTargetPrivate *priv = GET_PRIVATE (target);
g_autoptr(GError) error_local = NULL;
g_return_val_if_fail (DFU_IS_TARGET (target), FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
/* already done */
if (priv->done_setup)
return TRUE;
/* get string */
if (priv->alt_idx != 0x00) {
GUsbDevice *dev;
dev = dfu_device_get_usb_dev (priv->device);
priv->alt_name =
g_usb_device_get_string_descriptor (dev,
priv->alt_idx,
NULL);
}
/* parse the DfuSe format according to UM0424 */
if (!dfu_target_parse_sectors (target,
priv->alt_name,
error))
return FALSE;
/* add a dummy entry */
if (priv->sectors->len == 0) {
DfuSector *sector;
sector = dfu_sector_new (0x0, /* addr */
0x0, /* size */
0x0, /* size_left */
0x0, /* zone */
0x0, /* number */
DFU_SECTOR_CAP_READABLE |
DFU_SECTOR_CAP_WRITEABLE);
g_debug ("no UM0424 sector descripton in %s", priv->alt_name);
g_ptr_array_add (priv->sectors, sector);
}
priv->done_setup = TRUE;
return TRUE;
}
static gboolean
fu_altos_device_probe (FuDevice *device, GError **error)
{
FuAltosDevice *self = FU_ALTOS_DEVICE (device);
GUsbDevice *usb_device = fu_usb_device_get_dev (FU_USB_DEVICE (self));
/* bootloader uses tty */
if (self->kind == FU_ALTOS_DEVICE_KIND_BOOTLOADER)
return fu_altos_device_probe_bootloader (self, error);
/* get version */
if (self->kind == FU_ALTOS_DEVICE_KIND_CHAOSKEY) {
const gchar *version_prefix = "ChaosKey-hw-1.0-sw-";
guint8 version_idx;
g_autofree gchar *version = NULL;
g_autoptr(FuDeviceLocker) locker = NULL;
/* open */
locker = fu_device_locker_new (usb_device, error);
if (locker == NULL)
return FALSE;
/* get string */
version_idx = g_usb_device_get_product_index (usb_device);
version = g_usb_device_get_string_descriptor (usb_device,
version_idx,
error);
if (version == NULL)
return FALSE;
if (!g_str_has_prefix (version, version_prefix)) {
g_set_error (error,
FWUPD_ERROR,
FWUPD_ERROR_NOT_SUPPORTED,
"not a ChaosKey v1.0 device: %s",
version);
return FALSE;
}
fu_device_set_version (FU_DEVICE (self), version + 19);
}
/* success */
return TRUE;
}
static gboolean
moo_cb (GNode *node, gpointer data)
{
GUsbDevice *device = G_USB_DEVICE (node->data);
GNode *n;
guint i;
const gchar *tmp;
gchar *product = NULL;
gchar *vendor = NULL;
GString *str = NULL;
if (device == NULL) {
g_print ("Root Device\n");
return FALSE;
}
/* indent */
str = g_string_new ("");
for (n = node; n->data != NULL; n = n->parent)
g_string_append (str, " ");
/* add bus:address */
g_string_append_printf (str, "%02x:%02x [%04x:%04x]",
g_usb_device_get_bus (device),
g_usb_device_get_address (device),
g_usb_device_get_vid (device),
g_usb_device_get_pid (device));
/* pad */
for (i = str->len; i < 30; i++)
g_string_append (str, " ");
/* We don't error check these as not all devices have these
(and the device_open may have failed). */
g_usb_device_open (device, NULL);
vendor = g_usb_device_get_string_descriptor (device,
g_usb_device_get_manufacturer_index (device),
NULL);
product = g_usb_device_get_string_descriptor (device,
g_usb_device_get_product_index (device),
NULL);
/* lookup from usb.ids */
if (vendor == NULL) {
tmp = g_usb_device_get_vid_as_str (device);
if (tmp != NULL)
vendor = g_strdup (tmp);
}
if (product == NULL) {
tmp = g_usb_device_get_pid_as_str (device);
if (tmp != NULL)
product = g_strdup (tmp);
}
/* a hub */
if (g_usb_device_get_device_class (device) == 0x09 && product == NULL) {
product = g_strdup ("USB HUB");
}
/* fall back to the VID/PID */
if (product == NULL)
product = g_strdup ("Unknown");
if (vendor == NULL)
vendor = g_strdup ("Unknown");
/* add bus:address */
g_string_append_printf (str, "%s - %s", vendor, product);
g_free (product);
g_free (vendor);
g_print ("%s\n", str->str);
g_string_free (str, TRUE);
return FALSE;
}
static gboolean
fu_usb_device_open (FuDevice *device, GError **error)
{
FuUsbDevice *self = FU_USB_DEVICE (device);
FuUsbDevicePrivate *priv = GET_PRIVATE (self);
FuUsbDeviceClass *klass = FU_USB_DEVICE_GET_CLASS (device);
guint idx;
g_autoptr(FuDeviceLocker) locker = NULL;
g_return_val_if_fail (FU_IS_USB_DEVICE (self), FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
/* already open */
if (priv->usb_device_locker != NULL)
return TRUE;
/* open */
locker = fu_device_locker_new (priv->usb_device, error);
if (locker == NULL)
return FALSE;
/* get vendor */
if (fu_device_get_vendor (device) == NULL) {
idx = g_usb_device_get_manufacturer_index (priv->usb_device);
if (idx != 0x00) {
g_autofree gchar *tmp = NULL;
tmp = g_usb_device_get_string_descriptor (priv->usb_device,
idx, error);
if (tmp == NULL)
return FALSE;
fu_device_set_vendor (device, tmp);
}
}
/* get product */
if (fu_device_get_name (device) == NULL) {
idx = g_usb_device_get_product_index (priv->usb_device);
if (idx != 0x00) {
g_autofree gchar *tmp = NULL;
tmp = g_usb_device_get_string_descriptor (priv->usb_device,
idx, error);
if (tmp == NULL)
return FALSE;
fu_device_set_name (device, tmp);
}
}
/* get serial number */
if (fu_device_get_serial (device) == NULL) {
idx = g_usb_device_get_serial_number_index (priv->usb_device);
if (idx != 0x00) {
g_autofree gchar *tmp = NULL;
tmp = g_usb_device_get_string_descriptor (priv->usb_device,
idx, error);
if (tmp == NULL)
return FALSE;
fu_device_set_serial (device, tmp);
}
}
/* get version number, falling back to the USB device release */
idx = g_usb_device_get_custom_index (priv->usb_device,
G_USB_DEVICE_CLASS_VENDOR_SPECIFIC,
'F', 'W', NULL);
if (idx != 0x00) {
g_autofree gchar *tmp = NULL;
tmp = g_usb_device_get_string_descriptor (priv->usb_device, idx, NULL);
fu_device_set_version (device, tmp);
}
/* get GUID from the descriptor if set */
idx = g_usb_device_get_custom_index (priv->usb_device,
G_USB_DEVICE_CLASS_VENDOR_SPECIFIC,
'G', 'U', NULL);
if (idx != 0x00) {
g_autofree gchar *tmp = NULL;
tmp = g_usb_device_get_string_descriptor (priv->usb_device, idx, NULL);
fu_device_add_guid (device, tmp);
}
/* subclassed */
if (klass->open != NULL) {
if (!klass->open (self, error))
return FALSE;
}
/* success */
priv->usb_device_locker = g_steal_pointer (&locker);
return TRUE;
}
