static void fu_wac_module_constructed (GObject *object) { FuWacModule *self = FU_WAC_MODULE (object); FuWacModulePrivate *priv = GET_PRIVATE (self); g_autofree gchar *devid = NULL; g_autofree gchar *vendor_id = NULL; /* set vendor ID */ vendor_id = g_strdup_printf ("USB:0x%04X", g_usb_device_get_vid (priv->usb_device)); fu_device_set_vendor_id (FU_DEVICE (self), vendor_id); /* set USB physical and logical IDs */ fu_device_set_physical_id (FU_DEVICE (self), g_usb_device_get_platform_id (priv->usb_device)); fu_device_set_logical_id (FU_DEVICE (self), fu_wac_module_fw_type_to_string (priv->fw_type)); /* append the firmware kind to the generated GUID */ devid = g_strdup_printf ("USB\\VID_%04X&PID_%04X-%s", g_usb_device_get_vid (priv->usb_device), g_usb_device_get_pid (priv->usb_device), fu_wac_module_fw_type_to_string (priv->fw_type)); fu_device_add_instance_id (FU_DEVICE (self), devid); G_OBJECT_CLASS (fu_wac_module_parent_class)->constructed (object); }
/** * fu_usb_device_get_pid: * @self: A #FuUsbDevice * * Gets the device product code. * * Returns: integer, or 0x0 if unset or invalid * * Since: 1.1.2 **/ guint16 fu_usb_device_get_pid (FuUsbDevice *self) { FuUsbDevicePrivate *priv = GET_PRIVATE (self); g_return_val_if_fail (FU_IS_USB_DEVICE (self), 0x0000); return g_usb_device_get_pid (priv->usb_device); }
/** * g_usb_context_find_by_vid_pid: * @context: a #GUsbContext * @vid: a vendor ID * @pid: a product ID * @error: A #GError or %NULL * * Finds a device based on its bus and address values. * * Return value: (transfer full): a new #GUsbDevice, or %NULL if not found. * * Since: 0.2.2 **/ GUsbDevice * g_usb_context_find_by_vid_pid (GUsbContext *context, guint16 vid, guint16 pid, GError **error) { GUsbContextPrivate *priv; GUsbDevice *device = NULL; guint i; g_return_val_if_fail (G_USB_IS_CONTEXT (context), NULL); g_return_val_if_fail (error == NULL || *error == NULL, NULL); priv = context->priv; g_usb_context_enumerate (context); for (i = 0; i < priv->devices->len; i++) { GUsbDevice *curr = g_ptr_array_index (priv->devices, i); if (g_usb_device_get_vid (curr) == vid && g_usb_device_get_pid (curr) == pid) { device = g_object_ref (curr); break; } } if (device == NULL) { g_set_error (error, G_USB_DEVICE_ERROR, G_USB_DEVICE_ERROR_NO_DEVICE, "Failed to find device %04x:%04x", vid, pid); } return device; }
static gchar * dfu_context_get_device_id (DfuDevice *device) { GUsbDevice *dev; dev = dfu_device_get_usb_dev (device); if (dev == NULL) return g_strdup (dfu_device_get_platform_id (device)); return g_strdup_printf ("%04x:%04x [%s]", g_usb_device_get_vid (dev), g_usb_device_get_pid (dev), g_usb_device_get_platform_id (dev)); }
/** * dfu_context_get_device_by_vid_pid: * @context: a #DfuContext * @vid: a vendor ID * @pid: a product ID * @error: a #GError, or %NULL * * Finds a device in the context with a specific vendor:product ID. * An error is returned if more than one device matches. * * Return value: (transfer full): a #DfuDevice for success, or %NULL for an error * * Since: 0.5.4 **/ DfuDevice * dfu_context_get_device_by_vid_pid (DfuContext *context, guint16 vid, guint16 pid, GError **error) { DfuContextPrivate *priv = GET_PRIVATE (context); DfuContextItem *item; DfuDevice *device = NULL; GUsbDevice *dev; guint i; g_return_val_if_fail (DFU_IS_CONTEXT (context), NULL); g_return_val_if_fail (error == NULL || *error == NULL, NULL); /* search all devices */ for (i = 0; i < priv->devices->len; i++) { /* match */ item = g_ptr_array_index (priv->devices, i); dev = dfu_device_get_usb_dev (item->device); if (g_usb_device_get_vid (dev) == vid && g_usb_device_get_pid (dev) == pid) { if (device != NULL) { g_set_error (error, DFU_ERROR, DFU_ERROR_INVALID_DEVICE, "multiple device matches for %04x:%04x", vid, pid); return NULL; } device = item->device; continue; } } if (device == NULL) { g_set_error (error, DFU_ERROR, DFU_ERROR_NOT_FOUND, "no device matches for %04x:%04x", vid, pid); return NULL; } return g_object_ref (device); }
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; }
int main (int argc, char **argv) { gsize len; guint i; g_autofree guint8 *data = NULL; g_autoptr(EbitdoDevice) dev = NULL; g_autoptr(GBytes) fw = NULL; g_autoptr(GError) error = NULL; g_autoptr(GPtrArray) devices = NULL; g_autoptr(GUsbContext) usb_ctx = NULL; g_setenv ("G_MESSAGES_DEBUG", "all", TRUE); /* require filename */ if (argc != 2) { g_print ("USAGE: %s <filename>\n", argv[0]); return 1; } /* get the device */ usb_ctx = g_usb_context_new (&error); if (usb_ctx == NULL) { g_print ("Failed to open USB devices: %s\n", error->message); return 1; } g_usb_context_enumerate (usb_ctx); devices = g_usb_context_get_devices (usb_ctx); for (i = 0; i < devices->len; i++) { GUsbDevice *usb_dev_tmp = g_ptr_array_index (devices, i); g_autoptr(EbitdoDevice) dev_tmp = ebitdo_device_new (usb_dev_tmp); if (ebitdo_device_get_kind (dev_tmp) != EBITDO_DEVICE_KIND_UNKNOWN) { dev = g_object_ref (dev_tmp); break; } } /* nothing supported */ if (dev == NULL) { g_print ("No supported device plugged in!\n"); return 1; } g_debug ("found %s [%04x:%04x]", ebitdo_device_kind_to_string (ebitdo_device_get_kind (dev)), g_usb_device_get_vid (ebitdo_device_get_usb_device (dev)), g_usb_device_get_pid (ebitdo_device_get_usb_device (dev))); /* open device */ if (!ebitdo_device_open (dev, &error)) { g_print ("Failed to open USB device: %s\n", error->message); return 1; } g_print ("Device Firmware Ver: %s\n", ebitdo_device_get_version (dev)); g_print ("Device Verification ID:\n"); for (i = 0; i < 9; i++) g_print ("\t%u = 0x%08x\n", i, ebitdo_device_get_serial(dev)[i]); /* not in bootloader mode, so print what to do */ if (ebitdo_device_get_kind (dev) != EBITDO_DEVICE_KIND_BOOTLOADER) { g_print ("1. Disconnect the controller\n"); switch (ebitdo_device_get_kind (dev)) { case EBITDO_DEVICE_KIND_FC30: case EBITDO_DEVICE_KIND_NES30: case EBITDO_DEVICE_KIND_SFC30: case EBITDO_DEVICE_KIND_SNES30: g_print ("2. Hold down L+R+START for 3 seconds until " "both LED lights flashing.\n"); break; case EBITDO_DEVICE_KIND_FC30PRO: case EBITDO_DEVICE_KIND_NES30PRO: g_print ("2. Hold down RETURN+POWER for 3 seconds until " "both LED lights flashing.\n"); break; case EBITDO_DEVICE_KIND_FC30_ARCADE: g_print ("2. Hold down L1+R1+HOME for 3 seconds until " "both blue LED and green LED blink.\n"); break; default: g_print ("2. Do what it says in the manual.\n"); break; } g_print ("3. Connect controller\n"); return 1; } /* load firmware file */ if (!g_file_get_contents (argv[1], (gchar **) &data, &len, &error)) { g_print ("Failed to load file: %s\n", error->message); return 1; } /* update with data blob */ fw = g_bytes_new (data, len); if (!ebitdo_device_write_firmware (dev, fw, ebitdo_write_progress_cb, NULL, &error)) { g_print ("Failed to write firmware: %s\n", error->message); return 1; } /* close device */ if (!ebitdo_device_close (dev, &error)) { g_print ("Failed to close USB device: %s\n", error->message); return 1; } /* success */ g_print ("Now turn off the controller with the power button.\n"); return 0; }
static gboolean fu_usb_device_probe (FuDevice *device, GError **error) { FuUsbDevice *self = FU_USB_DEVICE (device); FuUsbDeviceClass *klass = FU_USB_DEVICE_GET_CLASS (device); FuUsbDevicePrivate *priv = GET_PRIVATE (self); guint16 release; g_autofree gchar *devid0 = NULL; g_autofree gchar *devid1 = NULL; g_autofree gchar *devid2 = NULL; g_autofree gchar *vendor_id = NULL; g_autoptr(GPtrArray) intfs = NULL; /* set vendor ID */ vendor_id = g_strdup_printf ("USB:0x%04X", g_usb_device_get_vid (priv->usb_device)); fu_device_set_vendor_id (device, vendor_id); /* set the version if the release has been set */ release = g_usb_device_get_release (priv->usb_device); if (release != 0x0) { g_autofree gchar *version = NULL; version = fu_common_version_from_uint16 (release, FU_VERSION_FORMAT_BCD); fu_device_set_version (device, version); } /* add GUIDs in order of priority */ devid2 = g_strdup_printf ("USB\\VID_%04X&PID_%04X&REV_%04X", g_usb_device_get_vid (priv->usb_device), g_usb_device_get_pid (priv->usb_device), release); fu_device_add_instance_id (device, devid2); devid1 = g_strdup_printf ("USB\\VID_%04X&PID_%04X", g_usb_device_get_vid (priv->usb_device), g_usb_device_get_pid (priv->usb_device)); fu_device_add_instance_id (device, devid1); devid0 = g_strdup_printf ("USB\\VID_%04X", g_usb_device_get_vid (priv->usb_device)); fu_device_add_instance_id (device, devid0); /* add the interface GUIDs */ intfs = g_usb_device_get_interfaces (priv->usb_device, error); if (intfs == NULL) return FALSE; for (guint i = 0; i < intfs->len; i++) { GUsbInterface *intf = g_ptr_array_index (intfs, i); g_autofree gchar *intid1 = NULL; g_autofree gchar *intid2 = NULL; g_autofree gchar *intid3 = NULL; intid1 = g_strdup_printf ("USB\\CLASS_%02X&SUBCLASS_%02X&PROT_%02X", g_usb_interface_get_class (intf), g_usb_interface_get_subclass (intf), g_usb_interface_get_protocol (intf)); fu_device_add_instance_id (device, intid1); intid2 = g_strdup_printf ("USB\\CLASS_%02X&SUBCLASS_%02X", g_usb_interface_get_class (intf), g_usb_interface_get_subclass (intf)); fu_device_add_instance_id (device, intid2); intid3 = g_strdup_printf ("USB\\CLASS_%02X", g_usb_interface_get_class (intf)); fu_device_add_instance_id (device, intid3); } /* subclassed */ if (klass->probe != NULL) { if (!klass->probe (self, error)) return FALSE; } /* success */ return TRUE; }