diff --git a/libfwupdplugin/fu-bluez-device.c b/libfwupdplugin/fu-bluez-device.c index 3cd741c4f..4dc0f3ce9 100644 --- a/libfwupdplugin/fu-bluez-device.c +++ b/libfwupdplugin/fu-bluez-device.c @@ -171,24 +171,19 @@ fu_bluez_device_set_modalias(FuBluezDevice *self, const gchar *modalias) fu_firmware_strparse_uint16_safe(modalias, modaliaslen, 21, &rev, NULL); } - if (vid != 0x0 && pid != 0x0 && rev != 0x0) { - g_autofree gchar *devid = NULL; - devid = g_strdup_printf("BLUETOOTH\\VID_%04X&PID_%04X&REV_%04X", vid, pid, rev); - fu_device_add_instance_id(FU_DEVICE(self), devid); - } - if (vid != 0x0 && pid != 0x0) { - g_autofree gchar *devid = NULL; - devid = g_strdup_printf("BLUETOOTH\\VID_%04X&PID_%04X", vid, pid); - fu_device_add_instance_id(FU_DEVICE(self), devid); - } + /* add generated IDs */ + if (vid != 0x0) + fu_device_add_instance_u16(FU_DEVICE(self), "VID", vid); + if (pid != 0x0) + fu_device_add_instance_u16(FU_DEVICE(self), "PID", pid); + fu_device_add_instance_u16(FU_DEVICE(self), "REV", rev); + fu_device_build_instance_id_quirk(FU_DEVICE(self), NULL, "BLUETOOTH", "VID", NULL); + fu_device_build_instance_id(FU_DEVICE(self), NULL, "BLUETOOTH", "VID", "PID", NULL); + fu_device_build_instance_id(FU_DEVICE(self), NULL, "BLUETOOTH", "VID", "PID", "REV", NULL); + + /* set vendor ID */ if (vid != 0x0) { - g_autofree gchar *devid = NULL; - g_autofree gchar *vendor_id = NULL; - devid = g_strdup_printf("BLUETOOTH\\VID_%04X", vid); - fu_device_add_instance_id_full(FU_DEVICE(self), - devid, - FU_DEVICE_INSTANCE_FLAG_ONLY_QUIRKS); - vendor_id = g_strdup_printf("BLUETOOTH:%04X", vid); + g_autofree gchar *vendor_id = g_strdup_printf("BLUETOOTH:%04X", vid); fu_device_add_vendor_id(FU_DEVICE(self), vendor_id); } } diff --git a/libfwupdplugin/fu-cfi-device.c b/libfwupdplugin/fu-cfi-device.c index 566452eae..8b80d5e60 100644 --- a/libfwupdplugin/fu-cfi-device.c +++ b/libfwupdplugin/fu-cfi-device.c @@ -184,31 +184,19 @@ fu_cfi_device_probe(FuDevice *device, GError **error) { FuCfiDevice *self = FU_CFI_DEVICE(device); FuCfiDevicePrivate *priv = GET_PRIVATE(self); + g_autofree gchar *flash_id_jedec = NULL; - /* load the parameters from quirks */ - if (priv->flash_id != NULL) { - g_autofree gchar *flash_id_jedec = NULL; - g_autofree gchar *instance_id0 = NULL; - g_autofree gchar *instance_id1 = NULL; - - /* least specific so adding first */ - flash_id_jedec = fu_cfi_device_get_flash_id_jedec(self); - if (flash_id_jedec != NULL) { - instance_id1 = g_strdup_printf("CFI\\FLASHID_%s", flash_id_jedec); - fu_device_add_instance_id_full(FU_DEVICE(self), - instance_id1, - FU_DEVICE_INSTANCE_FLAG_ONLY_QUIRKS); - } - - /* this is most specific and can override keys of instance_id1 */ - instance_id0 = g_strdup_printf("CFI\\FLASHID_%s", priv->flash_id); - fu_device_add_instance_id_full(FU_DEVICE(self), - instance_id0, - FU_DEVICE_INSTANCE_FLAG_ONLY_QUIRKS); + /* least specific so adding first */ + flash_id_jedec = fu_cfi_device_get_flash_id_jedec(self); + if (flash_id_jedec != NULL) { + fu_device_add_instance_str(device, "FLASHID", flash_id_jedec); + if (!fu_device_build_instance_id_quirk(device, error, "CFI", "FLASHID", NULL)) + return FALSE; } - /* success */ - return TRUE; + /* this is most specific and can override */ + fu_device_add_instance_str(device, "FLASHID", priv->flash_id); + return fu_device_build_instance_id_quirk(device, error, "CFI", "FLASHID", NULL); } /** diff --git a/libfwupdplugin/fu-device.c b/libfwupdplugin/fu-device.c index 3fd6978ec..7aac664ec 100644 --- a/libfwupdplugin/fu-device.c +++ b/libfwupdplugin/fu-device.c @@ -76,6 +76,7 @@ typedef struct { GPtrArray *private_flag_items; /* (nullable) */ gchar *custom_flags; gulong notify_flags_handler_id; + GHashTable *instance_hash; } FuDevicePrivate; typedef struct { @@ -4355,6 +4356,9 @@ fu_device_setup(FuDevice *self, GError **error) return FALSE; } + /* no longer needed */ + g_hash_table_remove_all(priv->instance_hash); + priv->done_setup = TRUE; return TRUE; } @@ -4735,6 +4739,269 @@ fu_device_flags_notify_cb(FuDevice *self, GParamSpec *pspec, gpointer user_data) fu_device_ensure_inhibits(self); } +/** + * fu_device_add_instance_str: + * @self: a #FuDevice + * @key: (not nullable): string + * @value: (nullable): value + * + * Assign a value for the @key. + * + * Since: 1.7.7 + **/ +void +fu_device_add_instance_str(FuDevice *self, const gchar *key, const gchar *value) +{ + FuDevicePrivate *priv = GET_PRIVATE(self); + g_return_if_fail(FU_IS_DEVICE(self)); + g_return_if_fail(key != NULL); + g_return_if_fail(!priv->done_setup); + g_hash_table_insert(priv->instance_hash, g_strdup(key), g_strdup(value)); +} + +/** + * fu_device_add_instance_strsafe: + * @self: a #FuDevice + * @key: (not nullable): string + * @value: (nullable): value + * + * Assign a sanitized value for the @key. + * + * Since: 1.7.7 + **/ +void +fu_device_add_instance_strsafe(FuDevice *self, const gchar *key, const gchar *value) +{ + FuDevicePrivate *priv = GET_PRIVATE(self); + g_return_if_fail(FU_IS_DEVICE(self)); + g_return_if_fail(key != NULL); + g_return_if_fail(!priv->done_setup); + g_hash_table_insert(priv->instance_hash, + g_strdup(key), + fu_common_instance_id_strsafe(value)); +} + +/** + * fu_device_add_instance_strup: + * @self: a #FuDevice + * @key: (not nullable): string + * @value: (nullable): value + * + * Assign a uppercase value for the @key. + * + * Since: 1.7.7 + **/ +void +fu_device_add_instance_strup(FuDevice *self, const gchar *key, const gchar *value) +{ + FuDevicePrivate *priv = GET_PRIVATE(self); + g_return_if_fail(FU_IS_DEVICE(self)); + g_return_if_fail(key != NULL); + g_return_if_fail(!priv->done_setup); + g_hash_table_insert(priv->instance_hash, + g_strdup(key), + value != NULL ? g_utf8_strup(value, -1) : NULL); +} + +/** + * fu_device_add_instance_u4: + * @self: a #FuDevice + * @key: (not nullable): string + * @value: value + * + * Assign a value to the @key, which is padded as %1X. + * + * Since: 1.7.7 + **/ +void +fu_device_add_instance_u4(FuDevice *self, const gchar *key, guint8 value) +{ + FuDevicePrivate *priv = GET_PRIVATE(self); + g_return_if_fail(FU_IS_DEVICE(self)); + g_return_if_fail(key != NULL); + g_return_if_fail(!priv->done_setup); + g_hash_table_insert(priv->instance_hash, g_strdup(key), g_strdup_printf("%01X", value)); +} + +/** + * fu_device_add_instance_u8: + * @self: a #FuDevice + * @key: (not nullable): string + * @value: value + * + * Assign a value to the @key, which is padded as %2X. + * + * Since: 1.7.7 + **/ +void +fu_device_add_instance_u8(FuDevice *self, const gchar *key, guint8 value) +{ + FuDevicePrivate *priv = GET_PRIVATE(self); + g_return_if_fail(FU_IS_DEVICE(self)); + g_return_if_fail(key != NULL); + g_return_if_fail(!priv->done_setup); + g_hash_table_insert(priv->instance_hash, g_strdup(key), g_strdup_printf("%02X", value)); +} + +/** + * fu_device_add_instance_u16: + * @self: a #FuDevice + * @key: (not nullable): string + * @value: value + * + * Assign a value to the @key, which is padded as %4X. + * + * Since: 1.7.7 + **/ +void +fu_device_add_instance_u16(FuDevice *self, const gchar *key, guint16 value) +{ + FuDevicePrivate *priv = GET_PRIVATE(self); + g_return_if_fail(FU_IS_DEVICE(self)); + g_return_if_fail(key != NULL); + g_return_if_fail(!priv->done_setup); + g_hash_table_insert(priv->instance_hash, g_strdup(key), g_strdup_printf("%04X", value)); +} + +/** + * fu_device_add_instance_u32: + * @self: a #FuDevice + * @key: (not nullable): string + * @value: value + * + * Assign a value to the @key, which is padded as %8X. + * + * Since: 1.7.7 + **/ +void +fu_device_add_instance_u32(FuDevice *self, const gchar *key, guint32 value) +{ + FuDevicePrivate *priv = GET_PRIVATE(self); + g_return_if_fail(FU_IS_DEVICE(self)); + g_return_if_fail(key != NULL); + g_return_if_fail(!priv->done_setup); + g_hash_table_insert(priv->instance_hash, g_strdup(key), g_strdup_printf("%08X", value)); +} + +static const gchar * +fu_device_instance_lookup(FuDevice *self, const gchar *key) +{ + FuDevicePrivate *priv = GET_PRIVATE(self); + return g_hash_table_lookup(priv->instance_hash, key); +} + +/** + * fu_device_build_instance_id: + * @self: a #FuDevice + * @error: (nullable): optional return location for an error + * @subsystem: (not nullable): subsystem, e.g. `NVME` + * @...: pairs of string key values, ending with %NULL + * + * Creates an instance ID from a prefix and some key values. + * If the key value cannot be found, the parent and then proxy is also queried. + * + * If any of the key values remain unset then no instance ID is added. + * + * fu_device_add_instance_str(dev, "VID", "1234"); + * fu_device_add_instance_u16(dev, "PID", 5678); + * if (!fu_device_build_instance_id(dev, &error, "NVME", "VID", "PID", NULL)) + * g_warning("failed to add ID: %s", error->message); + * + * Returns: %TRUE if the instance ID was added. + * + * Since: 1.7.7 + **/ +gboolean +fu_device_build_instance_id(FuDevice *self, GError **error, const gchar *subsystem, ...) +{ + FuDevice *parent = fu_device_get_parent(self); + FuDevicePrivate *priv = GET_PRIVATE(self); + va_list args; + g_autoptr(GString) str = g_string_new(subsystem); + + g_return_val_if_fail(FU_IS_DEVICE(self), FALSE); + g_return_val_if_fail(subsystem != NULL, FALSE); + g_return_val_if_fail(!priv->done_setup, FALSE); + + va_start(args, subsystem); + for (guint i = 0;; i++) { + const gchar *key = va_arg(args, const gchar *); + const gchar *value; + if (key == NULL) + break; + value = fu_device_instance_lookup(self, key); + if (value == NULL && parent != NULL) + value = fu_device_instance_lookup(parent, key); + if (value == NULL && priv->proxy != NULL) + value = fu_device_instance_lookup(priv->proxy, key); + if (value == NULL) { + g_set_error(error, + G_IO_ERROR, + G_IO_ERROR_INVALID_DATA, + "no value for %s", + key); + return FALSE; + } + g_string_append(str, i == 0 ? "\\" : "&"); + g_string_append_printf(str, "%s_%s", key, value); + } + va_end(args); + + /* success */ + fu_device_add_instance_id(self, str->str); + return TRUE; +} + +/** + * fu_device_build_instance_id_quirk: + * @self: a #FuDevice + * @error: (nullable): optional return location for an error + * @subsystem: (not nullable): subsystem, e.g. `NVME` + * @...: pairs of string key values, ending with %NULL + * + * Creates an quirk-only instance ID from a prefix and some key values. If any of the key values + * are unset then no instance ID is added. + * + * Returns: %TRUE if the instance ID was added. + * + * Since: 1.7.7 + **/ +gboolean +fu_device_build_instance_id_quirk(FuDevice *self, GError **error, const gchar *subsystem, ...) +{ + FuDevicePrivate *priv = GET_PRIVATE(self); + va_list args; + g_autoptr(GString) str = g_string_new(subsystem); + + g_return_val_if_fail(FU_IS_DEVICE(self), FALSE); + g_return_val_if_fail(subsystem != NULL, FALSE); + g_return_val_if_fail(!priv->done_setup, FALSE); + + va_start(args, subsystem); + for (guint i = 0;; i++) { + const gchar *key = va_arg(args, const gchar *); + const gchar *value; + if (key == NULL) + break; + value = g_hash_table_lookup(priv->instance_hash, key); + if (value == NULL) { + g_set_error(error, + G_IO_ERROR, + G_IO_ERROR_INVALID_DATA, + "no value for %s", + key); + return FALSE; + } + g_string_append(str, i == 0 ? "\\" : "&"); + g_string_append_printf(str, "%s_%s", key, value); + } + va_end(args); + + /* success */ + fu_device_add_instance_id_full(self, str->str, FU_DEVICE_INSTANCE_FLAG_ONLY_QUIRKS); + return TRUE; +} + static void fu_device_class_init(FuDeviceClass *klass) { @@ -4929,6 +5196,7 @@ fu_device_init(FuDevice *self) priv->parent_guids = g_ptr_array_new_with_free_func(g_free); priv->possible_plugins = g_ptr_array_new_with_free_func(g_free); priv->retry_recs = g_ptr_array_new_with_free_func(g_free); + priv->instance_hash = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free); g_rw_lock_init(&priv->parent_guids_mutex); g_rw_lock_init(&priv->metadata_mutex); priv->notify_flags_handler_id = g_signal_connect(FWUPD_DEVICE(self), @@ -4972,6 +5240,7 @@ fu_device_finalize(GObject *object) g_free(priv->backend_id); g_free(priv->proxy_guid); g_free(priv->custom_flags); + g_hash_table_unref(priv->instance_hash); G_OBJECT_CLASS(fu_device_parent_class)->finalize(object); } diff --git a/libfwupdplugin/fu-device.h b/libfwupdplugin/fu-device.h index 4e4621862..805980f42 100644 --- a/libfwupdplugin/fu-device.h +++ b/libfwupdplugin/fu-device.h @@ -699,3 +699,22 @@ gboolean fu_device_has_private_flag(FuDevice *self, guint64 flag); void fu_device_emit_request(FuDevice *self, FwupdRequest *request); + +void +fu_device_add_instance_str(FuDevice *self, const gchar *key, const gchar *value); +void +fu_device_add_instance_strsafe(FuDevice *self, const gchar *key, const gchar *value); +void +fu_device_add_instance_strup(FuDevice *self, const gchar *key, const gchar *value); +void +fu_device_add_instance_u4(FuDevice *self, const gchar *key, guint8 value); +void +fu_device_add_instance_u8(FuDevice *self, const gchar *key, guint8 value); +void +fu_device_add_instance_u16(FuDevice *self, const gchar *key, guint16 value); +void +fu_device_add_instance_u32(FuDevice *self, const gchar *key, guint32 value); +gboolean +fu_device_build_instance_id(FuDevice *self, GError **error, const gchar *subsystem, ...); +gboolean +fu_device_build_instance_id_quirk(FuDevice *self, GError **error, const gchar *subsystem, ...); diff --git a/libfwupdplugin/fu-i2c-device.c b/libfwupdplugin/fu-i2c-device.c index 06b841e7d..43e0dc72d 100644 --- a/libfwupdplugin/fu-i2c-device.c +++ b/libfwupdplugin/fu-i2c-device.c @@ -128,13 +128,9 @@ fu_i2c_device_probe(FuDevice *device, GError **error) #ifdef HAVE_GUDEV /* i2c devices all expose a name */ tmp = g_udev_device_get_sysfs_attr(udev_device, "name"); - if (tmp != NULL) { - g_autofree gchar *name_safe = fu_common_instance_id_strsafe(tmp); - if (name_safe != NULL) { - g_autofree gchar *devid = g_strdup_printf("I2C\\NAME_%s", name_safe); - fu_device_add_instance_id(FU_DEVICE(self), devid); - } - } + fu_device_add_instance_strsafe(device, "NAME", tmp); + if (!fu_device_build_instance_id(device, error, "I2C", "NAME", NULL)) + return FALSE; /* get bus number out of sysfs path */ regex = g_regex_new("/i2c-([0-9]+)/", 0, 0, error); diff --git a/libfwupdplugin/fu-udev-device.c b/libfwupdplugin/fu-udev-device.c index 20d3f9100..8ce8fb3fb 100644 --- a/libfwupdplugin/fu-udev-device.c +++ b/libfwupdplugin/fu-udev-device.c @@ -300,15 +300,12 @@ fu_udev_device_probe_serio(FuUdevDevice *self, GError **error) /* firmware ID */ tmp = g_udev_device_get_property(priv->udev_device, "SERIO_FIRMWARE_ID"); if (tmp != NULL) { - g_autofree gchar *id_safe = NULL; /* this prefix is not useful */ if (g_str_has_prefix(tmp, "PNP: ")) tmp += 5; - id_safe = fu_common_instance_id_strsafe(tmp); - if (id_safe != NULL) { - g_autofree gchar *devid = g_strdup_printf("SERIO\\FWID_%s", id_safe); - fu_device_add_instance_id(FU_DEVICE(self), devid); - } + fu_device_add_instance_strsafe(FU_DEVICE(self), "FWID", tmp); + if (!fu_device_build_instance_id(FU_DEVICE(self), error, "SERIO", "FWID", NULL)) + return FALSE; } return TRUE; } @@ -459,71 +456,37 @@ fu_udev_device_probe(FuDevice *device, GError **error) } /* add GUIDs in order of priority */ - if (priv->vendor != 0x0000 && priv->model != 0x0000 && priv->subsystem_vendor != 0x0000 && - priv->subsystem_model != 0x0000) { - g_autofree gchar *devid1 = NULL; - g_autofree gchar *devid2 = NULL; - devid1 = g_strdup_printf("%s\\VEN_%04X&DEV_%04X&SUBSYS_%04X%04X&REV_%02X", - subsystem, - priv->vendor, - priv->model, - priv->subsystem_vendor, - priv->subsystem_model, - priv->revision); - fu_device_add_instance_id(device, devid1); - devid2 = g_strdup_printf("%s\\VEN_%04X&DEV_%04X&SUBSYS_%04X%04X", - subsystem, - priv->vendor, - priv->model, - priv->subsystem_vendor, - priv->subsystem_model); - fu_device_add_instance_id(device, devid2); - } - if (priv->vendor != 0x0000 && priv->model != 0x0000) { - g_autofree gchar *devid = NULL; - devid = g_strdup_printf("%s\\VEN_%04X&DEV_%04X&REV_%02X", - subsystem, - priv->vendor, - priv->model, - priv->revision); - fu_device_add_instance_id(device, devid); - } - if (priv->vendor != 0x0000 && priv->model != 0x0000) { - g_autofree gchar *devid = NULL; - devid = - g_strdup_printf("%s\\VEN_%04X&DEV_%04X", subsystem, priv->vendor, priv->model); - fu_device_add_instance_id(device, devid); - } - if (priv->vendor != 0x0000) { - g_autofree gchar *devid = NULL; - devid = g_strdup_printf("%s\\VEN_%04X", subsystem, priv->vendor); - fu_device_add_instance_id_full(device, devid, FU_DEVICE_INSTANCE_FLAG_ONLY_QUIRKS); + if (priv->vendor != 0x0000) + fu_device_add_instance_u16(device, "VEN", priv->vendor); + if (priv->model != 0x0000) + fu_device_add_instance_u16(device, "DEV", priv->model); + if (priv->subsystem_vendor != 0x0000 && priv->subsystem_model != 0x0000) { + g_autofree gchar *subsys = + g_strdup_printf("%04X%04X", priv->subsystem_vendor, priv->subsystem_model); + fu_device_add_instance_str(device, "SUBSYS", subsys); } + fu_device_add_instance_u8(device, "REV", priv->revision); + + fu_device_build_instance_id_quirk(device, NULL, subsystem, "VEN", NULL); + fu_device_build_instance_id(device, NULL, subsystem, "VEN", "DEV", NULL); + fu_device_build_instance_id(device, NULL, subsystem, "VEN", "DEV", "REV", NULL); + fu_device_build_instance_id(device, NULL, subsystem, "VEN", "DEV", "SUBSYS", NULL); + fu_device_build_instance_id(device, NULL, subsystem, "VEN", "DEV", "SUBSYS", "REV", NULL); /* add device class */ tmp = g_udev_device_get_sysfs_attr(priv->udev_device, "class"); - if (tmp != NULL && g_str_has_prefix(tmp, "0x")) { - g_autofree gchar *class_id = g_utf8_strup(tmp + 2, -1); - g_autofree gchar *devid = NULL; - devid = g_strdup_printf("%s\\VEN_%04X&CLASS_%s", subsystem, priv->vendor, class_id); - fu_device_add_instance_id_full(device, devid, FU_DEVICE_INSTANCE_FLAG_ONLY_QUIRKS); - } + if (tmp != NULL && g_str_has_prefix(tmp, "0x")) + tmp += 2; + fu_device_add_instance_strup(device, "CLASS", tmp); + fu_device_build_instance_id_quirk(device, NULL, subsystem, "VEN", "CLASS", NULL); /* add devtype */ - tmp = g_udev_device_get_devtype(priv->udev_device); - if (tmp != NULL) { - g_autofree gchar *devtype = g_utf8_strup(tmp, -1); - g_autofree gchar *devid = NULL; - devid = g_strdup_printf("%s\\TYPE_%s", subsystem, devtype); - fu_device_add_instance_id_full(device, devid, FU_DEVICE_INSTANCE_FLAG_ONLY_QUIRKS); - } + fu_device_add_instance_strup(device, "TYPE", g_udev_device_get_devtype(priv->udev_device)); + fu_device_build_instance_id_quirk(device, NULL, subsystem, "TYPE", NULL); /* add the driver */ - if (priv->driver != NULL) { - g_autofree gchar *devid = NULL; - devid = g_strdup_printf("%s\\DRIVER_%s", subsystem, priv->driver); - fu_device_add_instance_id_full(device, devid, FU_DEVICE_INSTANCE_FLAG_ONLY_QUIRKS); - } + fu_device_add_instance_str(device, "DRIVER", priv->driver); + fu_device_build_instance_id_quirk(device, NULL, subsystem, "DRIVER", NULL); /* add subsystem to match in plugins */ if (subsystem != NULL) { diff --git a/libfwupdplugin/fu-usb-device.c b/libfwupdplugin/fu-usb-device.c index 493563f9b..a389869b9 100644 --- a/libfwupdplugin/fu-usb-device.c +++ b/libfwupdplugin/fu-usb-device.c @@ -174,7 +174,6 @@ fu_usb_device_query_hub(FuUsbDevice *self, GError **error) gsize sz = 0; guint16 value = 0x29; guint8 data[0x0c] = {0x0}; - g_autofree gchar *devid = NULL; /* longer descriptor for SuperSpeed */ if (fu_usb_device_get_spec(self) >= 0x0300) @@ -200,20 +199,12 @@ fu_usb_device_query_hub(FuUsbDevice *self, GError **error) /* see http://www.usblyzer.com/usb-hub-class-decoder.htm */ if (sz == 0x09) { - devid = g_strdup_printf("USB\\VID_%04X&PID_%04X&HUB_%02X", - g_usb_device_get_vid(priv->usb_device), - g_usb_device_get_pid(priv->usb_device), - data[7]); - fu_device_add_instance_id(FU_DEVICE(self), devid); + fu_device_add_instance_u8(FU_DEVICE(self), "HUB", data[7]); } else if (sz == 0x0c) { - devid = g_strdup_printf("USB\\VID_%04X&PID_%04X&HUB_%02X%02X", - g_usb_device_get_vid(priv->usb_device), - g_usb_device_get_pid(priv->usb_device), - data[11], - data[10]); - fu_device_add_instance_id(FU_DEVICE(self), devid); + g_autofree gchar *hub = g_strdup_printf("%02X%02X", data[11], data[10]); + fu_device_add_instance_str(FU_DEVICE(self), "HUB", hub); } - return TRUE; + return fu_device_build_instance_id(FU_DEVICE(self), error, "VID", "PID", "HUB", NULL); } #endif @@ -395,9 +386,6 @@ fu_usb_device_probe(FuDevice *device, GError **error) FuUsbDevice *self = FU_USB_DEVICE(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 *platform_id = NULL; g_autofree gchar *vendor_id = NULL; g_autoptr(GPtrArray) intfs = NULL; @@ -417,17 +405,12 @@ fu_usb_device_probe(FuDevice *device, GError **error) } /* 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_full(device, devid0, FU_DEVICE_INSTANCE_FLAG_ONLY_QUIRKS); + fu_device_add_instance_u16(device, "VID", g_usb_device_get_vid(priv->usb_device)); + fu_device_add_instance_u16(device, "PID", g_usb_device_get_pid(priv->usb_device)); + fu_device_add_instance_u16(device, "REV", release); + fu_device_build_instance_id_quirk(device, NULL, "USB", "VID", NULL); + fu_device_build_instance_id(device, NULL, "USB", "VID", "PID", NULL); + fu_device_build_instance_id(device, NULL, "USB", "VID", "PID", "REV", NULL); /* add the interface GUIDs */ intfs = g_usb_device_get_interfaces(priv->usb_device, error); @@ -435,20 +418,18 @@ fu_usb_device_probe(FuDevice *device, GError **error) 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_full(device, intid1, FU_DEVICE_INSTANCE_FLAG_ONLY_QUIRKS); - 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_full(device, intid2, FU_DEVICE_INSTANCE_FLAG_ONLY_QUIRKS); - intid3 = g_strdup_printf("USB\\CLASS_%02X", g_usb_interface_get_class(intf)); - fu_device_add_instance_id_full(device, intid3, FU_DEVICE_INSTANCE_FLAG_ONLY_QUIRKS); + fu_device_add_instance_u8(device, "CLASS", g_usb_interface_get_class(intf)); + fu_device_add_instance_u8(device, "SUBCLASS", g_usb_interface_get_subclass(intf)); + fu_device_add_instance_u8(device, "PROT", g_usb_interface_get_protocol(intf)); + fu_device_build_instance_id_quirk(device, NULL, "USB", "CLASS", NULL); + fu_device_build_instance_id_quirk(device, NULL, "USB", "CLASS", "SUBCLASS", NULL); + fu_device_build_instance_id_quirk(device, + NULL, + "USB", + "CLASS", + "SUBCLASS", + "PROT", + NULL); } /* add 2 levels of parent IDs */ diff --git a/libfwupdplugin/fwupdplugin.map b/libfwupdplugin/fwupdplugin.map index a3e65c486..473681992 100644 --- a/libfwupdplugin/fwupdplugin.map +++ b/libfwupdplugin/fwupdplugin.map @@ -1003,3 +1003,17 @@ LIBFWUPDPLUGIN_1.7.6 { fu_udev_device_get_parent_with_subsystem; local: *; } LIBFWUPDPLUGIN_1.7.4; + +LIBFWUPDPLUGIN_1.7.7 { + global: + fu_device_add_instance_str; + fu_device_add_instance_strsafe; + fu_device_add_instance_strup; + fu_device_add_instance_u16; + fu_device_add_instance_u32; + fu_device_add_instance_u4; + fu_device_add_instance_u8; + fu_device_build_instance_id; + fu_device_build_instance_id_quirk; + local: *; +} LIBFWUPDPLUGIN_1.7.6; diff --git a/plugins/ccgx/fu-ccgx-hpi-device.c b/plugins/ccgx/fu-ccgx-hpi-device.c index c575ec298..be7d86d31 100644 --- a/plugins/ccgx/fu-ccgx-hpi-device.c +++ b/plugins/ccgx/fu-ccgx-hpi-device.c @@ -1335,7 +1335,6 @@ static gboolean fu_ccgx_hpi_device_ensure_silicon_id(FuCcgxHpiDevice *self, GError **error) { guint8 buf[2] = {0x0}; - g_autofree gchar *instance_id = NULL; if (!fu_ccgx_hpi_device_reg_read(self, CY_PD_SILICON_ID, buf, sizeof(buf), error)) { g_prefix_error(error, "get silicon id error: "); @@ -1350,10 +1349,9 @@ fu_ccgx_hpi_device_ensure_silicon_id(FuCcgxHpiDevice *self, GError **error) return FALSE; /* add quirks */ - instance_id = g_strdup_printf("CCGX\\SID_%04X", self->silicon_id); - fu_device_add_instance_id_full(FU_DEVICE(self), - instance_id, - FU_DEVICE_INSTANCE_FLAG_ONLY_QUIRKS); + if (self->silicon_id != 0x0) + fu_device_add_instance_u16(FU_DEVICE(self), "SID", self->silicon_id); + fu_device_build_instance_id_quirk(FU_DEVICE(self), NULL, "CCGX", "SID", NULL); /* sanity check */ if (self->flash_row_size == 0x0 || self->flash_size == 0x0 || @@ -1361,8 +1359,7 @@ fu_ccgx_hpi_device_ensure_silicon_id(FuCcgxHpiDevice *self, GError **error) g_set_error(error, FWUPD_ERROR, FWUPD_ERROR_NOT_SUPPORTED, - "invalid row size for Instance ID %s: 0x%x/0x%x", - instance_id, + "invalid row size for: 0x%x/0x%x", self->flash_row_size, self->flash_size); return FALSE; @@ -1380,36 +1377,6 @@ fu_ccgx_hpi_device_set_version_raw(FuCcgxHpiDevice *self, guint32 version_raw) fu_device_set_version_raw(FU_DEVICE(self), version_raw); } -static void -fu_ccgx_hpi_device_setup_with_fw_mode(FuCcgxHpiDevice *self) -{ - fu_device_set_logical_id(FU_DEVICE(self), fu_ccgx_fw_mode_to_string(self->fw_mode)); -} - -static void -fu_ccgx_hpi_device_setup_with_app_type(FuCcgxHpiDevice *self) -{ - if (self->silicon_id != 0x0 && self->fw_app_type != 0x0) { - g_autofree gchar *instance_id1 = NULL; - g_autofree gchar *instance_id2 = NULL; - - /* we get fw_image_type from the quirk */ - instance_id1 = g_strdup_printf("USB\\VID_%04X&PID_%04X&SID_%04X&APP_%04X", - fu_usb_device_get_vid(FU_USB_DEVICE(self)), - fu_usb_device_get_pid(FU_USB_DEVICE(self)), - self->silicon_id, - self->fw_app_type); - fu_device_add_instance_id(FU_DEVICE(self), instance_id1); - instance_id2 = g_strdup_printf("USB\\VID_%04X&PID_%04X&SID_%04X&APP_%04X&MODE_%s", - fu_usb_device_get_vid(FU_USB_DEVICE(self)), - fu_usb_device_get_pid(FU_USB_DEVICE(self)), - self->silicon_id, - self->fw_app_type, - fu_ccgx_fw_mode_to_string(self->fw_mode)); - fu_device_add_instance_id(FU_DEVICE(self), instance_id2); - } -} - static gboolean fu_ccgx_hpi_device_setup(FuDevice *device, GError **error) { @@ -1442,7 +1409,8 @@ fu_ccgx_hpi_device_setup(FuDevice *device, GError **error) self->hpi_addrsz = mode & 0x80 ? 2 : 1; self->num_ports = (mode >> 2) & 0x03 ? 2 : 1; self->fw_mode = (FWMode)(mode & 0x03); - fu_ccgx_hpi_device_setup_with_fw_mode(self); + fu_device_set_logical_id(device, fu_ccgx_fw_mode_to_string(self->fw_mode)); + fu_device_add_instance_str(device, "MODE", fu_device_get_logical_id(device)); /* get silicon ID */ if (!fu_ccgx_hpi_device_ensure_silicon_id(self, error)) @@ -1481,7 +1449,8 @@ fu_ccgx_hpi_device_setup(FuDevice *device, GError **error) /* add GUIDs that are specific to the firmware app type */ self->fw_app_type = versions[self->fw_mode] & 0xffff; - fu_ccgx_hpi_device_setup_with_app_type(self); + if (self->fw_app_type != 0x0) + fu_device_add_instance_u16(device, "APP", self->fw_app_type); /* if running in bootloader force an upgrade to any version */ if (fu_device_has_flag(device, FWUPD_DEVICE_FLAG_IS_BOOTLOADER)) { @@ -1498,6 +1467,18 @@ fu_ccgx_hpi_device_setup(FuDevice *device, GError **error) fu_device_uninhibit(device, "device-in-boot-mode"); } + /* add extra instance IDs */ + fu_device_build_instance_id_quirk(device, NULL, "USB", "VID", "PID", "SID", "APP", NULL); + fu_device_build_instance_id_quirk(device, + NULL, + "USB", + "VID", + "PID", + "SID", + "APP", + "MODE", + NULL); + /* if we are coming back from reset, wait for hardware to settle */ if (!fu_ccgx_hpi_device_get_event(self, HPI_REG_SECTION_DEV, diff --git a/plugins/cfu/fu-cfu-module.c b/plugins/cfu/fu-cfu-module.c index a98b45422..b8dae20c8 100644 --- a/plugins/cfu/fu-cfu-module.c +++ b/plugins/cfu/fu-cfu-module.c @@ -41,12 +41,10 @@ fu_cfu_module_get_bank(FuCfuModule *self) gboolean fu_cfu_module_setup(FuCfuModule *self, const guint8 *buf, gsize bufsz, gsize offset, GError **error) { - FuDevice *parent = fu_device_get_proxy(FU_DEVICE(self)); + FuDevice *device = FU_DEVICE(self); + FuDevice *parent = fu_device_get_proxy(device); guint32 version_raw = 0; guint8 tmp = 0; - g_autofree gchar *instance_id0 = NULL; - g_autofree gchar *instance_id1 = NULL; - g_autofree gchar *instance_id2 = NULL; g_autofree gchar *logical_id = NULL; g_autofree gchar *version = NULL; @@ -55,48 +53,47 @@ fu_cfu_module_setup(FuCfuModule *self, const guint8 *buf, gsize bufsz, gsize off return FALSE; /* these GUIDs may cause the name or version-format to be overwritten */ - instance_id0 = g_strdup_printf("HIDRAW\\VEN_%04X&DEV_%04X", - fu_udev_device_get_vendor(FU_UDEV_DEVICE(parent)), - fu_udev_device_get_model(FU_UDEV_DEVICE(parent))); - fu_device_add_instance_id(FU_DEVICE(self), instance_id0); - instance_id1 = g_strdup_printf("HIDRAW\\VEN_%04X&DEV_%04X&CID_%02X", - fu_udev_device_get_vendor(FU_UDEV_DEVICE(parent)), - fu_udev_device_get_model(FU_UDEV_DEVICE(parent)), - self->component_id); - fu_device_add_instance_id(FU_DEVICE(self), instance_id1); + fu_device_add_instance_u8(device, "CID", self->component_id); + if (!fu_device_build_instance_id(device, error, "HIDRAW", "VEN", "DEV", NULL)) + return FALSE; + if (!fu_device_build_instance_id(device, error, "HIDRAW", "VEN", "DEV", "CID", NULL)) + return FALSE; /* bank */ if (!fu_common_read_uint8_safe(buf, bufsz, offset + 0x4, &tmp, error)) return FALSE; self->bank = tmp & 0b11; - instance_id2 = g_strdup_printf("HIDRAW\\VEN_%04X&DEV_%04X&CID_%02X&BANK_%01X", - fu_udev_device_get_vendor(FU_UDEV_DEVICE(parent)), - fu_udev_device_get_model(FU_UDEV_DEVICE(parent)), - self->component_id, - self->bank); - fu_device_add_instance_id(FU_DEVICE(self), instance_id2); + fu_device_add_instance_u4(device, "BANK", self->bank); + if (!fu_device_build_instance_id(device, + error, + "HIDRAW", + "VEN", + "DEV", + "CID", + "BANK", + NULL)) + return FALSE; /* set name, if not already set using a quirk */ - if (fu_device_get_name(FU_DEVICE(self)) == NULL) { + if (fu_device_get_name(device) == NULL) { g_autofree gchar *name = NULL; name = g_strdup_printf("%s (0x%02X:0x%02x)", fu_device_get_name(parent), self->component_id, self->bank); - fu_device_set_name(FU_DEVICE(self), name); + fu_device_set_name(device, name); } /* version */ if (!fu_common_read_uint32_safe(buf, bufsz, offset, &version_raw, G_LITTLE_ENDIAN, error)) return FALSE; - fu_device_set_version_raw(FU_DEVICE(self), version_raw); - version = fu_common_version_from_uint32(version_raw, - fu_device_get_version_format(FU_DEVICE(self))); - fu_device_set_version(FU_DEVICE(self), version); + fu_device_set_version_raw(device, version_raw); + version = fu_common_version_from_uint32(version_raw, fu_device_get_version_format(device)); + fu_device_set_version(device, version); /* logical ID */ logical_id = g_strdup_printf("CID:0x%02x,BANK:0x%02x", self->component_id, self->bank); - fu_device_set_logical_id(FU_DEVICE(self), logical_id); + fu_device_set_logical_id(device, logical_id); /* success */ return TRUE; diff --git a/plugins/cpu/fu-cpu-device.c b/plugins/cpu/fu-cpu-device.c index 53ab36205..f98362a6a 100644 --- a/plugins/cpu/fu-cpu-device.c +++ b/plugins/cpu/fu-cpu-device.c @@ -121,9 +121,6 @@ fu_cpu_device_add_instance_ids(FuDevice *device, GError **error) guint32 model_id_ext; guint32 processor_id; guint32 stepping_id; - g_autofree gchar *devid1 = NULL; - g_autofree gchar *devid2 = NULL; - g_autofree gchar *devid3 = NULL; /* decode according to https://en.wikipedia.org/wiki/CPUID */ if (!fu_common_cpuid(0x1, &eax, NULL, NULL, NULL, error)) @@ -141,17 +138,16 @@ fu_cpu_device_add_instance_ids(FuDevice *device, GError **error) if (family_id == 15) family_id += family_id_ext; - devid1 = g_strdup_printf("CPUID\\PRO_%01X&FAM_%02X", processor_id, family_id); - fu_device_add_instance_id(device, devid1); - devid2 = - g_strdup_printf("CPUID\\PRO_%01X&FAM_%02X&MOD_%02X", processor_id, family_id, model_id); - fu_device_add_instance_id(device, devid2); - devid3 = g_strdup_printf("CPUID\\PRO_%01X&FAM_%02X&MOD_%02X&STP_%01X", - processor_id, - family_id, - model_id, - stepping_id); - fu_device_add_instance_id(device, devid3); + /* add GUIDs */ + fu_device_add_instance_u4(device, "PRO", processor_id); + fu_device_add_instance_u8(device, "FAM", family_id); + fu_device_add_instance_u8(device, "MOD", model_id); + fu_device_add_instance_u4(device, "STP", stepping_id); + fu_device_build_instance_id(device, NULL, "CPUID", "PRO", "FAM", NULL); + fu_device_build_instance_id(device, NULL, "CPUID", "PRO", "FAM", "MOD", NULL); + fu_device_build_instance_id(device, NULL, "CPUID", "PRO", "FAM", "MOD", "STP", NULL); + + /* success */ return TRUE; } diff --git a/plugins/dfu/fu-dfu-target-avr.c b/plugins/dfu/fu-dfu-target-avr.c index 7fe4fcd30..378babdad 100644 --- a/plugins/dfu/fu-dfu-target-avr.c +++ b/plugins/dfu/fu-dfu-target-avr.c @@ -531,10 +531,11 @@ fu_dfu_target_avr_setup(FuDfuTarget *target, GError **error) } memcpy(&device_id_be, buf, 4); priv->device_id = GINT32_FROM_BE(device_id_be); + if (buf[0] == ATMEL_MANUFACTURER_CODE1) { - chip_id_guid = g_strdup_printf("DFU_AVR\\CID_0x%08x", (guint)priv->device_id); + chip_id_guid = g_strdup_printf("0x%08x", (guint)priv->device_id); } else if (buf[0] == ATMEL_MANUFACTURER_CODE2) { - chip_id_guid = g_strdup_printf("DFU_AVR\\CID_0x%06x", (guint)priv->device_id >> 8); + chip_id_guid = g_strdup_printf("0x%06x", (guint)priv->device_id >> 8); } else { g_set_error(error, FWUPD_ERROR, @@ -549,7 +550,9 @@ fu_dfu_target_avr_setup(FuDfuTarget *target, GError **error) /* set the alt-name using the chip ID via a quirk */ device = fu_dfu_target_get_device(target); - fu_device_add_instance_id(FU_DEVICE(device), chip_id_guid); + fu_device_add_instance_str(FU_DEVICE(device), "CID", chip_id_guid); + if (!fu_device_build_instance_id(FU_DEVICE(device), error, "DFU_AVR", "CID", NULL)) + return FALSE; chip_id = fu_dfu_device_get_chip_id(device); if (chip_id == NULL) { fu_dfu_device_remove_attribute(fu_dfu_target_get_device(target), diff --git a/plugins/elantp/fu-elantp-hid-device.c b/plugins/elantp/fu-elantp-hid-device.c index f56ceb052..0da53ba12 100644 --- a/plugins/elantp/fu-elantp-hid-device.c +++ b/plugins/elantp/fu-elantp-hid-device.c @@ -161,9 +161,6 @@ fu_elantp_hid_device_setup(FuDevice *device, GError **error) guint16 tmp; guint8 buf[2] = {0x0}; guint8 ic_type; - g_autofree gchar *instance_id1 = NULL; - g_autofree gchar *instance_id2 = NULL; - g_autofree gchar *instance_id_ic_type = NULL; g_autofree gchar *version_bl = NULL; g_autofree gchar *version = NULL; @@ -212,11 +209,11 @@ fu_elantp_hid_device_setup(FuDevice *device, GError **error) self->module_id = fu_common_read_uint16(buf, G_LITTLE_ENDIAN); /* define the extra instance IDs */ - instance_id1 = g_strdup_printf("HIDRAW\\VEN_%04X&DEV_%04X&MOD_%04X", - fu_udev_device_get_vendor(udev_device), - fu_udev_device_get_model(udev_device), - self->module_id); - fu_device_add_instance_id(device, instance_id1); + fu_device_add_instance_u16(device, "VEN", fu_udev_device_get_vendor(udev_device)); + fu_device_add_instance_u16(device, "DEV", fu_udev_device_get_model(udev_device)); + fu_device_add_instance_u16(device, "MOD", self->module_id); + if (!fu_device_build_instance_id(device, error, "HIDRAW", "VEN", "DEV", "MOD", NULL)) + return FALSE; /* get OSM version */ if (!fu_elantp_hid_device_read_cmd(self, @@ -241,12 +238,11 @@ fu_elantp_hid_device_setup(FuDevice *device, GError **error) } else { ic_type = (tmp >> 8) & 0xFF; } - instance_id_ic_type = g_strdup_printf("ELANTP\\ICTYPE_%02X", ic_type); - fu_device_add_instance_id(device, instance_id_ic_type); /* define the extra instance IDs (ic_type + module_id) */ - instance_id2 = g_strdup_printf("ELANTP\\ICTYPE_%02X&MOD_%04X", ic_type, self->module_id); - fu_device_add_instance_id(device, instance_id2); + fu_device_add_instance_u8(device, "ICTYPE", ic_type); + fu_device_build_instance_id(device, NULL, "ELANTP", "ICTYPE", NULL); + fu_device_build_instance_id(device, NULL, "ELANTP", "ICTYPE", "MOD", NULL); /* no quirk entry */ if (self->ic_page_count == 0x0) { diff --git a/plugins/elantp/fu-elantp-i2c-device.c b/plugins/elantp/fu-elantp-i2c-device.c index 26a0d3b01..dde4335bd 100644 --- a/plugins/elantp/fu-elantp-i2c-device.c +++ b/plugins/elantp/fu-elantp-i2c-device.c @@ -150,9 +150,6 @@ fu_elantp_i2c_device_setup(FuDevice *device, GError **error) guint16 vid; guint8 buf[30] = {0x0}; guint8 ic_type; - g_autofree gchar *instance_id1 = NULL; - g_autofree gchar *instance_id2 = NULL; - g_autofree gchar *instance_id_ic_type = NULL; g_autofree gchar *version_bl = NULL; g_autofree gchar *version = NULL; @@ -178,11 +175,10 @@ fu_elantp_i2c_device_setup(FuDevice *device, GError **error) } /* add GUIDs in order of priority */ - if (vid != 0x0 && pid != 0x0) { - g_autofree gchar *devid = NULL; - devid = g_strdup_printf("HIDRAW\\VID_%04X&PID_%04X", vid, pid); - fu_device_add_instance_id(device, devid); - } + fu_device_add_instance_u16(device, "VID", vid); + fu_device_add_instance_u16(device, "PID", pid); + if (!fu_device_build_instance_id(device, error, "HIDRAW", "VID", "PID", NULL)) + return FALSE; /* get pattern */ if (!fu_elantp_i2c_device_read_cmd(self, ETP_CMD_I2C_GET_HID_ID, buf, sizeof(buf), error)) { @@ -241,11 +237,14 @@ fu_elantp_i2c_device_setup(FuDevice *device, GError **error) G_LITTLE_ENDIAN, error)) return FALSE; + fu_device_add_instance_u16(device, "MOD", self->module_id); /* define the extra instance IDs */ - instance_id1 = - g_strdup_printf("HIDRAW\\VEN_%04X&DEV_%04X&MOD_%04X", vid, pid, self->module_id); - fu_device_add_instance_id(device, instance_id1); + fu_device_add_instance_u16(device, "VEN", vid); + fu_device_add_instance_u16(device, "DEV", pid); + fu_device_add_instance_u16(device, "MOD", self->module_id); + if (!fu_device_build_instance_id(device, error, "HIDRAW", "VEN", "DEV", "MOD", NULL)) + return FALSE; /* get OSM version */ if (!fu_elantp_i2c_device_read_cmd(self, @@ -278,12 +277,11 @@ fu_elantp_i2c_device_setup(FuDevice *device, GError **error) } else { ic_type = (tmp >> 8) & 0xFF; } - instance_id_ic_type = g_strdup_printf("ELANTP\\ICTYPE_%02X", ic_type); - fu_device_add_instance_id(device, instance_id_ic_type); /* define the extra instance IDs (ic_type + module_id) */ - instance_id2 = g_strdup_printf("ELANTP\\ICTYPE_%02X&MOD_%04X", ic_type, self->module_id); - fu_device_add_instance_id(device, instance_id2); + fu_device_add_instance_u8(device, "ICTYPE", ic_type); + fu_device_build_instance_id(device, NULL, "ELANTP", "ICTYPE", NULL); + fu_device_build_instance_id(device, NULL, "ELANTP", "ICTYPE", "MOD", NULL); /* no quirk entry */ if (self->ic_page_count == 0x0) { diff --git a/plugins/emmc/fu-emmc-device.c b/plugins/emmc/fu-emmc-device.c index 14a352028..7cc0687ab 100644 --- a/plugins/emmc/fu-emmc-device.c +++ b/plugins/emmc/fu-emmc-device.c @@ -139,9 +139,6 @@ fu_emmc_device_probe(FuDevice *device, GError **error) guint64 manfid = 0; const gchar *tmp; g_autoptr(GUdevDevice) udev_parent = NULL; - g_autofree gchar *name_only = NULL; - g_autofree gchar *man_oem = NULL; - g_autofree gchar *man_oem_name = NULL; g_autofree gchar *vendor_id = NULL; g_autoptr(GRegex) dev_regex = NULL; @@ -206,23 +203,19 @@ fu_emmc_device_probe(FuDevice *device, GError **error) fu_device_get_name(device)); return FALSE; } + fu_device_add_instance_strsafe(device, "NAME", tmp); + fu_device_build_instance_id(device, NULL, "EMMC", "NAME", NULL); fu_device_set_name(device, tmp); - name_only = g_strdup_printf("EMMC\\NAME_%s", fu_device_get_name(device)); - fu_device_add_instance_id(device, name_only); /* manfid + oemid, manfid + oemid + name */ if (!fu_emmc_device_get_sysattr_guint64(udev_parent, "manfid", &manfid, error)) return FALSE; if (!fu_emmc_device_get_sysattr_guint64(udev_parent, "oemid", &oemid, error)) return FALSE; - man_oem = - g_strdup_printf("EMMC\\%04" G_GUINT64_FORMAT "&%04" G_GUINT64_FORMAT, manfid, oemid); - fu_device_add_instance_id(device, man_oem); - man_oem_name = g_strdup_printf("EMMC\\MAN_%04X&OEM_%04X&NAME_%s", - (guint)manfid, - (guint)oemid, - fu_device_get_name(device)); - fu_device_add_instance_id(device, man_oem_name); + fu_device_add_instance_u16(device, "MAN", manfid); + fu_device_add_instance_u16(device, "OEM", oemid); + fu_device_build_instance_id(device, NULL, "EMMC", "MAN", "OEM", NULL); + fu_device_build_instance_id(device, NULL, "EMMC", "MAN", "OEM", "NAME", NULL); /* set the vendor */ tmp = g_udev_device_get_sysfs_attr(udev_parent, "manfid"); diff --git a/plugins/fresco-pd/fu-fresco-pd-device.c b/plugins/fresco-pd/fu-fresco-pd-device.c index 5cd61dd9c..7655ef41c 100644 --- a/plugins/fresco-pd/fu-fresco-pd-device.c +++ b/plugins/fresco-pd/fu-fresco-pd-device.c @@ -164,9 +164,7 @@ static gboolean fu_fresco_pd_device_setup(FuDevice *device, GError **error) { FuFrescoPdDevice *self = FU_FRESCO_PD_DEVICE(device); - FuUsbDevice *usb_device = FU_USB_DEVICE(device); guint8 ver[4] = {0x0}; - g_autofree gchar *instance_id = NULL; g_autofree gchar *version = NULL; /* FuUsbDevice->setup */ @@ -185,14 +183,10 @@ fu_fresco_pd_device_setup(FuDevice *device, GError **error) /* get customer ID */ self->customer_id = ver[1]; - instance_id = g_strdup_printf("USB\\VID_%04X&PID_%04X&CID_%02X", - fu_usb_device_get_vid(usb_device), - fu_usb_device_get_pid(usb_device), - self->customer_id); - fu_device_add_instance_id(device, instance_id); - /* success */ - return TRUE; + /* add extra instance ID */ + fu_device_add_instance_u8(device, "CID", self->customer_id); + return fu_device_build_instance_id(device, error, "USB", "VID", "PID", "CID", NULL); } static FuFirmware * diff --git a/plugins/genesys/fu-genesys-scaler-device.c b/plugins/genesys/fu-genesys-scaler-device.c index a1d79c3df..e34a11b97 100644 --- a/plugins/genesys/fu-genesys-scaler-device.c +++ b/plugins/genesys/fu-genesys-scaler-device.c @@ -1402,8 +1402,6 @@ fu_genesys_scaler_device_probe(FuDevice *device, GError **error) FuGenesysScalerDevice *self = FU_GENESYS_SCALER_DEVICE(device); guint8 buf[7 + 1] = {0}; g_autofree gchar *guid = NULL; - g_autofree gchar *guid_upper = NULL; - g_autofree gchar *instance_id = NULL; g_autofree gchar *version = NULL; if (!fu_genesys_scaler_device_get_level(self, &self->level, error)) @@ -1425,9 +1423,12 @@ fu_genesys_scaler_device_probe(FuDevice *device, GError **error) fu_device_set_version(device, version); fu_device_set_version_format(device, FWUPD_VERSION_FORMAT_PLAIN); fu_device_set_logical_id(device, "scaler"); - guid_upper = g_ascii_strup(guid, -1); - instance_id = g_strdup_printf("GENESYS_SCALER\\MSTAR_TSUM_G&PUBKEY_%s", guid_upper); - fu_device_add_instance_id(device, instance_id); + + /* add instance ID */ + fu_device_add_instance_str(device, "MSTAR", "TSUM_G"); + fu_device_add_instance_strup(device, "PUBKEY", guid); + fu_device_build_instance_id(device, NULL, "GENESYS_SCALER", "MSTAR", "PUBKEY", NULL); + fu_device_add_flag(device, FWUPD_DEVICE_FLAG_UPDATABLE); self->vc.req_read = GENESYS_SCALER_MSTAR_READ; diff --git a/plugins/gpio/fu-gpio-device.c b/plugins/gpio/fu-gpio-device.c index 0aa5dc3e9..22797f5d1 100644 --- a/plugins/gpio/fu-gpio-device.c +++ b/plugins/gpio/fu-gpio-device.c @@ -68,10 +68,12 @@ fu_gpio_device_setup(FuDevice *device, GError **error) /* label is optional, but name is always set */ if (info.label[0] != '\0') { g_autofree gchar *logical_id = fu_common_strsafe(info.label, sizeof(info.label)); - g_autofree gchar *instance_id = NULL; fu_device_set_logical_id(device, logical_id); - instance_id = g_strdup_printf("GPIO\\ID_%s", logical_id); - fu_device_add_instance_id(device, instance_id); + + /* add instance ID */ + fu_device_add_instance_strsafe(device, "ID", logical_id); + if (!fu_device_build_instance_id(device, error, "GPIO", "ID", NULL)) + return FALSE; } /* success */ diff --git a/plugins/hailuck/fu-hailuck-bl-device.c b/plugins/hailuck/fu-hailuck-bl-device.c index 197a4f6cd..b4f24293f 100644 --- a/plugins/hailuck/fu-hailuck-bl-device.c +++ b/plugins/hailuck/fu-hailuck-bl-device.c @@ -42,20 +42,13 @@ fu_hailuck_bl_device_attach(FuDevice *device, FuProgress *progress, GError **err static gboolean fu_hailuck_bl_device_probe(FuDevice *device, GError **error) { - g_autofree gchar *devid = NULL; - /* FuUsbDevice->probe */ if (!FU_DEVICE_CLASS(fu_hailuck_bl_device_parent_class)->probe(device, error)) return FALSE; - /* add extra keyboard-specific GUID */ - devid = g_strdup_printf("USB\\VID_%04X&PID_%04X&MODE_KBD", - fu_usb_device_get_vid(FU_USB_DEVICE(device)), - fu_usb_device_get_pid(FU_USB_DEVICE(device))); - fu_device_add_instance_id(device, devid); - - /* success */ - return TRUE; + /* add instance ID */ + fu_device_add_instance_str(device, "MODE", "KBD"); + return fu_device_build_instance_id(device, error, "USB", "VID", "PID", "MODE", NULL); } static gboolean diff --git a/plugins/hailuck/fu-hailuck-kbd-device.c b/plugins/hailuck/fu-hailuck-kbd-device.c index 265027533..dd2d99811 100644 --- a/plugins/hailuck/fu-hailuck-kbd-device.c +++ b/plugins/hailuck/fu-hailuck-kbd-device.c @@ -35,7 +35,6 @@ fu_hailuck_kbd_device_detach(FuDevice *device, FuProgress *progress, GError **er static gboolean fu_hailuck_kbd_device_probe(FuDevice *device, GError **error) { - g_autofree gchar *devid = NULL; g_autoptr(FuHailuckTpDevice) tp_device = fu_hailuck_tp_device_new(FU_DEVICE(device)); /* FuUsbDevice->probe */ @@ -43,10 +42,9 @@ fu_hailuck_kbd_device_probe(FuDevice *device, GError **error) return FALSE; /* add extra keyboard-specific GUID */ - devid = g_strdup_printf("USB\\VID_%04X&PID_%04X&MODE_KBD", - fu_usb_device_get_vid(FU_USB_DEVICE(device)), - fu_usb_device_get_pid(FU_USB_DEVICE(device))); - fu_device_add_instance_id(device, devid); + fu_device_add_instance_str(device, "MODE", "KBD"); + if (!fu_device_build_instance_id(device, error, "USB", "VID", "PID", "MODE", NULL)) + return FALSE; /* add touchpad */ if (!fu_device_probe(FU_DEVICE(tp_device), error)) diff --git a/plugins/hailuck/fu-hailuck-tp-device.c b/plugins/hailuck/fu-hailuck-tp-device.c index 4c49c9c66..769258a64 100644 --- a/plugins/hailuck/fu-hailuck-tp-device.c +++ b/plugins/hailuck/fu-hailuck-tp-device.c @@ -20,20 +20,9 @@ G_DEFINE_TYPE(FuHailuckTpDevice, fu_hailuck_tp_device, FU_TYPE_DEVICE) static gboolean fu_hailuck_tp_device_probe(FuDevice *device, GError **error) { - FuDevice *parent = fu_device_get_parent(device); - g_autofree gchar *devid1 = NULL; - g_autofree gchar *devid2 = NULL; - - devid1 = g_strdup_printf("USB\\VID_%04X&PID_%04X", - fu_usb_device_get_vid(FU_USB_DEVICE(parent)), - fu_usb_device_get_pid(FU_USB_DEVICE(parent))); - fu_device_add_instance_id(device, devid1); - devid2 = g_strdup_printf("USB\\VID_%04X&PID_%04X&MODE_TP", - fu_usb_device_get_vid(FU_USB_DEVICE(parent)), - fu_usb_device_get_pid(FU_USB_DEVICE(parent))); - fu_device_add_instance_id(device, devid2); - - return TRUE; + /* add extra touchpad-specific GUID */ + fu_device_add_instance_str(device, "MODE", "TP"); + return fu_device_build_instance_id(device, error, "USB", "VID", "PID", "MODE", NULL); } typedef struct { diff --git a/plugins/intel-spi/fu-ifd-device.c b/plugins/intel-spi/fu-ifd-device.c index ba1a12a92..22b26ba3b 100644 --- a/plugins/intel-spi/fu-ifd-device.c +++ b/plugins/intel-spi/fu-ifd-device.c @@ -27,14 +27,14 @@ fu_ifd_device_set_region(FuIfdDevice *self, FuIfdRegion region) FuIfdDevicePrivate *priv = GET_PRIVATE(self); const gchar *region_str = fu_ifd_region_to_string(region); g_autofree gchar *instance_id = NULL; - g_autofree gchar *region_str_up = NULL; priv->region = region; fu_device_set_name(FU_DEVICE(self), fu_ifd_region_to_name(region)); fu_device_set_logical_id(FU_DEVICE(self), region_str); - region_str_up = g_ascii_strup(region_str, -1); - instance_id = g_strdup_printf("IFD\\NAME_%s", region_str_up); - fu_device_add_instance_id(FU_DEVICE(self), instance_id); + + /* add instance ID */ + fu_device_add_instance_strup(FU_DEVICE(self), "NAME", region_str); + fu_device_build_instance_id(FU_DEVICE(self), NULL, "IFD", "NAME", NULL); } static void diff --git a/plugins/intel-spi/fu-intel-spi-device.c b/plugins/intel-spi/fu-intel-spi-device.c index c58e05e92..c7e61e9a0 100644 --- a/plugins/intel-spi/fu-intel-spi-device.c +++ b/plugins/intel-spi/fu-intel-spi-device.c @@ -477,8 +477,6 @@ fu_intel_spi_device_set_quirk_kv(FuDevice *device, return TRUE; } if (g_strcmp0(key, "IntelSpiKind") == 0) { - g_autofree gchar *instance_id = NULL; - g_autofree gchar *kind_up = NULL; /* validate */ self->kind = fu_intel_spi_kind_from_string(value); @@ -492,10 +490,8 @@ fu_intel_spi_device_set_quirk_kv(FuDevice *device, } /* get things like SPIBAR */ - kind_up = g_ascii_strup(value, -1); - instance_id = g_strdup_printf("INTEL_SPI_CHIPSET\\ID_%s", kind_up); - fu_device_add_instance_id(device, instance_id); - return TRUE; + fu_device_add_instance_strup(device, "ID", value); + return fu_device_build_instance_id(device, error, "INTEL_SPI_CHIPSET", "ID", NULL); } if (g_strcmp0(key, "IntelSpiBarProxy") == 0) { self->spibar_proxy = g_strdup(value); diff --git a/plugins/logitech-hidpp/fu-logitech-hidpp-device.c b/plugins/logitech-hidpp/fu-logitech-hidpp-device.c index ddac4e074..262524f5b 100644 --- a/plugins/logitech-hidpp/fu-logitech-hidpp-device.c +++ b/plugins/logitech-hidpp/fu-logitech-hidpp-device.c @@ -487,7 +487,6 @@ fu_logitech_hidpp_device_fetch_model_id(FuLogitechHidPpDevice *self, GError **er { FuLogitechHidPpDevicePrivate *priv = GET_PRIVATE(self); guint8 idx; - g_autofree gchar *devid = NULL; g_autoptr(FuLogitechHidPpHidppMsg) msg = fu_logitech_hidpp_msg_new(); g_autoptr(GString) str = g_string_new(NULL); @@ -512,11 +511,9 @@ fu_logitech_hidpp_device_fetch_model_id(FuLogitechHidPpDevice *self, GError **er fu_logitech_hidpp_device_set_model_id(self, str->str); /* add one more instance ID */ - devid = g_strdup_printf("HIDRAW\\VEN_%04X&MOD_%s", - (guint)FU_UNIFYING_DEVICE_VID, - priv->model_id); - fu_device_add_instance_id(FU_DEVICE(self), devid); - return TRUE; + fu_device_add_instance_u16(FU_DEVICE(self), "VEN", FU_UNIFYING_DEVICE_VID); + fu_device_add_instance_str(FU_DEVICE(self), "MOD", priv->model_id); + return fu_device_build_instance_id(FU_DEVICE(self), error, "HIDRAW", "VEN", "MOD", NULL); } static gboolean diff --git a/plugins/logitech-hidpp/fu-logitech-hidpp-runtime-bolt.c b/plugins/logitech-hidpp/fu-logitech-hidpp-runtime-bolt.c index 150d9c00e..4c715a3b5 100644 --- a/plugins/logitech-hidpp/fu-logitech-hidpp-runtime-bolt.c +++ b/plugins/logitech-hidpp/fu-logitech-hidpp-runtime-bolt.c @@ -359,7 +359,6 @@ fu_logitech_hidpp_runtime_bolt_setup_internal(FuDevice *device, GError **error) guint16 version_raw = 0; g_autofree gchar *version = NULL; g_autoptr(FuLogitechHidPpRadio) radio = NULL; - g_autofree gchar *instance_id = NULL; g_autoptr(GString) radio_version = NULL; msg->report_id = HIDPP_REPORT_ID_SHORT; @@ -374,6 +373,7 @@ fu_logitech_hidpp_runtime_bolt_setup_internal(FuDevice *device, GError **error) g_prefix_error(error, "failed to read device config: "); return FALSE; } + switch (msg->data[0]) { case 0: /* main application */ @@ -409,15 +409,26 @@ fu_logitech_hidpp_runtime_bolt_setup_internal(FuDevice *device, GError **error) /* SoftDevice */ radio_version = g_string_new(NULL); radio = fu_logitech_hidpp_radio_new(ctx, i); + fu_device_add_instance_u16( + FU_DEVICE(radio), + "VEN", + fu_udev_device_get_vendor(FU_UDEV_DEVICE(device))); + fu_device_add_instance_u16( + FU_DEVICE(radio), + "DEV", + fu_udev_device_get_model(FU_UDEV_DEVICE(device))); + fu_device_add_instance_u8(FU_DEVICE(radio), "ENT", msg->data[0]); fu_device_set_physical_id(FU_DEVICE(radio), fu_device_get_physical_id(device)); fu_device_set_logical_id(FU_DEVICE(radio), "Receiver_SoftDevice"); - - instance_id = - g_strdup_printf("HIDRAW\\VEN_%04X&DEV_%04X&ENT_05", - fu_udev_device_get_vendor(FU_UDEV_DEVICE(device)), - fu_udev_device_get_model(FU_UDEV_DEVICE(device))); - fu_device_add_guid(FU_DEVICE(radio), instance_id); + if (!fu_device_build_instance_id(FU_DEVICE(radio), + error, + "HIDRAW", + "VEN", + "DEV", + "ENT", + NULL)) + return FALSE; if (!fu_common_read_uint16_safe(msg->data, sizeof(msg->data), 0x03, diff --git a/plugins/mtd/fu-mtd-device.c b/plugins/mtd/fu-mtd-device.c index 2bd23cf82..58e88fc8b 100644 --- a/plugins/mtd/fu-mtd-device.c +++ b/plugins/mtd/fu-mtd-device.c @@ -69,13 +69,9 @@ fu_mtd_device_probe(FuDevice *device, GError **error) FuContext *ctx = fu_device_get_context(device); FuMtdDevice *self = FU_MTD_DEVICE(device); const gchar *name; - const gchar *product; const gchar *vendor; guint64 flags = 0; guint64 size = 0; - g_autofree gchar *name_safe = NULL; - g_autofree gchar *product_safe = NULL; - g_autofree gchar *vendor_safe = NULL; /* FuUdevDevice->probe */ if (!FU_DEVICE_CLASS(fu_mtd_device_parent_class)->probe(device, error)) @@ -87,44 +83,25 @@ fu_mtd_device_probe(FuDevice *device, GError **error) /* get name */ name = fu_udev_device_get_sysfs_attr(FU_UDEV_DEVICE(device), "name", NULL); - if (name != NULL) { - name_safe = fu_common_instance_id_strsafe(name); - if (name_safe != NULL) { - g_autofree gchar *devid = g_strdup_printf("MTD\\NAME_%s", name_safe); - fu_device_add_instance_id(FU_DEVICE(self), devid); - } + if (name != NULL) fu_device_set_name(FU_DEVICE(self), name); - } /* set vendor ID as the BIOS vendor */ vendor = fu_context_get_hwid_value(ctx, FU_HWIDS_KEY_MANUFACTURER); if (vendor != NULL) { g_autofree gchar *vendor_id = g_strdup_printf("DMI:%s", vendor); fu_device_add_vendor_id(device, vendor_id); - vendor_safe = fu_common_instance_id_strsafe(vendor); } /* use vendor and product as an optional instance ID prefix */ - product = fu_context_get_hwid_value(ctx, FU_HWIDS_KEY_PRODUCT_NAME); - if (product != NULL) - product_safe = fu_common_instance_id_strsafe(product); - if (vendor_safe != NULL && product_safe != NULL && name_safe != NULL) { - g_autofree gchar *devid = NULL; - devid = g_strdup_printf("MTD\\VENDOR_%s&PRODUCT_%s&NAME_%s", - vendor_safe, - product_safe, - name_safe); - fu_device_add_instance_id(device, devid); - } - if (vendor_safe != NULL && name_safe != NULL) { - g_autofree gchar *devid = NULL; - devid = g_strdup_printf("MTD\\VENDOR_%s&NAME_%s", vendor_safe, name_safe); - fu_device_add_instance_id(device, devid); - } - if (name_safe != NULL) { - g_autofree gchar *devid = g_strdup_printf("MTD\\NAME_%s", name_safe); - fu_device_add_instance_id(FU_DEVICE(self), devid); - } + fu_device_add_instance_strsafe(device, "NAME", name); + fu_device_add_instance_strsafe(device, "VENDOR", vendor); + fu_device_add_instance_strsafe(device, + "PRODUCT", + fu_context_get_hwid_value(ctx, FU_HWIDS_KEY_PRODUCT_NAME)); + fu_device_build_instance_id(device, NULL, "MTD", "NAME", NULL); + fu_device_build_instance_id(device, NULL, "MTD", "VENDOR", "NAME", NULL); + fu_device_build_instance_id(device, NULL, "MTD", "VENDOR", "PRODUCT", "NAME", NULL); /* get properties about the device */ if (!fu_udev_device_get_sysfs_attr_uint64(FU_UDEV_DEVICE(device), "size", &size, error)) diff --git a/plugins/nordic-hid/fu-nordic-hid-cfg-channel.c b/plugins/nordic-hid/fu-nordic-hid-cfg-channel.c index d1b701e24..ac8070c50 100644 --- a/plugins/nordic-hid/fu-nordic-hid-cfg-channel.c +++ b/plugins/nordic-hid/fu-nordic-hid-cfg-channel.c @@ -936,7 +936,6 @@ static gboolean fu_nordic_hid_cfg_channel_setup(FuDevice *device, GError **error) { FuNordicHidCfgChannel *self = FU_NORDIC_HID_CFG_CHANNEL(device); - g_autofree gchar *target_id = NULL; /* get the board name */ if (!fu_nordic_hid_cfg_channel_get_board_name(self, error)) @@ -965,15 +964,17 @@ fu_nordic_hid_cfg_channel_setup(FuDevice *device, GError **error) fu_device_set_name(device, physical_id); } - /* additional GUID based on VID/PID and target area to flash - * needed to distinguish images aimed to different bootloaders */ - target_id = g_strdup_printf("HIDRAW\\VEN_%04X&DEV_%04X&BOARD_%s&BL_%s", - fu_udev_device_get_vendor(FU_UDEV_DEVICE(device)), - fu_udev_device_get_model(FU_UDEV_DEVICE(device)), - self->board_name, - self->bl_name); - fu_device_add_guid(device, target_id); - return TRUE; + /* generate IDs */ + fu_device_add_instance_strsafe(device, "BOARD", self->board_name); + fu_device_add_instance_strsafe(device, "BL", self->bl_name); + return fu_device_build_instance_id(device, + error, + "HIDRAW", + "VEN", + "DEV", + "BOARD", + "BL", + NULL); } static void diff --git a/plugins/parade-lspcon/fu-parade-lspcon-device.c b/plugins/parade-lspcon/fu-parade-lspcon-device.c index 772dedac6..abf1b7338 100644 --- a/plugins/parade-lspcon/fu-parade-lspcon-device.c +++ b/plugins/parade-lspcon/fu-parade-lspcon-device.c @@ -121,19 +121,6 @@ fu_parade_lspcon_device_probe(FuDevice *device, GError **error) FuContext *context = fu_device_get_context(device); FuUdevDevice *udev_device = FU_UDEV_DEVICE(device); const gchar *device_name; - g_autofree gchar *instance_id_hwid = NULL; - g_autofree gchar *instance_id = NULL; - - /* custom instance IDs to get device quirks */ - instance_id = g_strdup_printf("PARADE-LSPCON\\NAME_%s", - fu_udev_device_get_sysfs_attr(udev_device, "name", NULL)); - fu_device_add_instance_id(device, instance_id); - instance_id_hwid = g_strdup_printf("%s&FAMILY_%s", - instance_id, - fu_context_get_hwid_value(context, FU_HWIDS_KEY_FAMILY)); - fu_device_add_instance_id_full(device, - instance_id_hwid, - FU_DEVICE_INSTANCE_FLAG_ONLY_QUIRKS); device_name = fu_device_get_name(device); if (g_strcmp0(device_name, "PS175") != 0) { @@ -145,6 +132,17 @@ fu_parade_lspcon_device_probe(FuDevice *device, GError **error) return FALSE; } + /* custom instance IDs to get device quirks */ + fu_device_add_instance_str(device, + "NAME", + fu_udev_device_get_sysfs_attr(udev_device, "name", NULL)); + fu_device_add_instance_str(device, + "FAMILY", + fu_context_get_hwid_value(context, FU_HWIDS_KEY_FAMILY)); + if (!fu_device_build_instance_id(device, error, "PARADE-LSPCON", "NAME", NULL)) + return FALSE; + fu_device_build_instance_id_quirk(device, NULL, "PARADE-LSPCON", "NAME", "FAMILY", NULL); + /* should know which aux device over which we read DPCD version */ if (self->aux_device_name == NULL) { g_set_error_literal(error, diff --git a/plugins/pixart-rf/fu-pxi-ble-device.c b/plugins/pixart-rf/fu-pxi-ble-device.c index 3f3281e4a..46136e89e 100644 --- a/plugins/pixart-rf/fu-pxi-ble-device.c +++ b/plugins/pixart-rf/fu-pxi-ble-device.c @@ -812,35 +812,32 @@ static gboolean fu_pxi_ble_device_setup_guid(FuPxiBleDevice *self, GError **error) { #ifdef HAVE_HIDRAW_H + FuDevice *device = FU_DEVICE(self); struct hidraw_devinfo hid_raw_info = {0x0}; - g_autofree gchar *devid = NULL; g_autoptr(GString) dev_name = NULL; + g_autoptr(GString) model_name = NULL; /* extra GUID with device name */ if (!fu_pxi_ble_device_get_raw_info(self, &hid_raw_info, error)) return FALSE; - dev_name = g_string_new(fu_device_get_name(FU_DEVICE(self))); + dev_name = g_string_new(fu_device_get_name(device)); g_string_ascii_up(dev_name); fu_common_string_replace(dev_name, " ", "_"); - devid = g_strdup_printf("HIDRAW\\VEN_%04X&DEV_%04X&NAME_%s", - (guint)hid_raw_info.vendor, - (guint)hid_raw_info.product, - dev_name->str); - fu_device_add_instance_id(FU_DEVICE(self), devid); /* extra GUID with model name*/ - if (self->model_name != NULL) { - g_autofree gchar *devid2 = NULL; - g_autoptr(GString) model_name = NULL; - model_name = g_string_new(self->model_name); - g_string_ascii_up(model_name); - fu_common_string_replace(model_name, " ", "_"); - devid2 = g_strdup_printf("HIDRAW\\VEN_%04X&DEV_%04X&MODEL_%s", - (guint)hid_raw_info.vendor, - (guint)hid_raw_info.product, - model_name->str); - fu_device_add_instance_id(FU_DEVICE(self), devid2); - } + model_name = g_string_new(self->model_name); + g_string_ascii_up(model_name); + fu_common_string_replace(model_name, " ", "_"); + + /* generate IDs */ + fu_device_add_instance_u16(device, "VEN", hid_raw_info.vendor); + fu_device_add_instance_u16(device, "DEV", hid_raw_info.product); + fu_device_add_instance_str(device, "NAME", dev_name->str); + fu_device_add_instance_str(device, "MODEL", model_name->str); + if (!fu_device_build_instance_id(device, error, "HIDRAW", "VEN", "DEV", "NAME", NULL)) + return FALSE; + if (!fu_device_build_instance_id(device, error, "HIDRAW", "VEN", "DEV", "MODEL", NULL)) + return FALSE; #endif return TRUE; } diff --git a/plugins/pixart-rf/fu-pxi-receiver-device.c b/plugins/pixart-rf/fu-pxi-receiver-device.c index cc6205dfc..e448699f2 100644 --- a/plugins/pixart-rf/fu-pxi-receiver-device.c +++ b/plugins/pixart-rf/fu-pxi-receiver-device.c @@ -725,7 +725,6 @@ fu_pxi_receiver_device_add_peripherals(FuPxiReceiverDevice *device, guint idx, G { #ifdef HAVE_HIDRAW_H struct ota_fw_dev_model model = {0x0}; - g_autofree gchar *instance_id = NULL; g_autofree gchar *model_name = NULL; g_autofree gchar *model_version = NULL; @@ -734,21 +733,38 @@ fu_pxi_receiver_device_add_peripherals(FuPxiReceiverDevice *device, guint idx, G return FALSE; model_version = g_strndup((gchar *)model.version, 5); model_name = g_strndup((gchar *)model.name, FU_PXI_DEVICE_MODEL_NAME_LEN); - instance_id = g_strdup_printf("HIDRAW\\VEN_%04X&DEV_%04X&MODEL_%s", - device->vendor, - device->product, - model_name); + if (model.type == OTA_WIRELESS_MODULE_TYPE_RECEIVER) { fu_device_set_version(FU_DEVICE(device), model_version); - fu_device_add_instance_id(FU_DEVICE(device), instance_id); + fu_device_add_instance_u16(FU_DEVICE(device), "VEN", device->vendor); + fu_device_add_instance_u16(FU_DEVICE(device), "DEV", device->product); + fu_device_add_instance_str(FU_DEVICE(device), "MODEL", model_name); + if (!fu_device_build_instance_id(FU_DEVICE(device), + error, + "HIDRAW", + "VEN", + "DEV", + "MODEL", + NULL)) + return FALSE; } else { - g_autoptr(FuPxiWirelessDevice) wireless_device = fu_pxi_wireless_device_new(&model); + g_autoptr(FuPxiWirelessDevice) child = fu_pxi_wireless_device_new(&model); g_autofree gchar *logical_id = g_strdup_printf("IDX:0x%02x", idx); - fu_device_add_instance_id(FU_DEVICE(wireless_device), instance_id); - fu_device_set_name(FU_DEVICE(wireless_device), model_name); - fu_device_set_version(FU_DEVICE(wireless_device), model_version); - fu_device_set_logical_id(FU_DEVICE(wireless_device), logical_id); - fu_device_add_child(FU_DEVICE(device), FU_DEVICE(wireless_device)); + fu_device_add_instance_u16(FU_DEVICE(child), "VEN", device->vendor); + fu_device_add_instance_u16(FU_DEVICE(child), "DEV", device->product); + fu_device_add_instance_str(FU_DEVICE(child), "MODEL", model_name); + if (!fu_device_build_instance_id(FU_DEVICE(child), + error, + "HIDRAW", + "VEN", + "DEV", + "MODEL", + NULL)) + return FALSE; + fu_device_set_name(FU_DEVICE(child), model_name); + fu_device_set_version(FU_DEVICE(child), model_version); + fu_device_set_logical_id(FU_DEVICE(child), logical_id); + fu_device_add_child(FU_DEVICE(device), FU_DEVICE(child)); } return TRUE; #else diff --git a/plugins/realtek-mst/fu-realtek-mst-device.c b/plugins/realtek-mst/fu-realtek-mst-device.c index 5c4185eac..434871596 100644 --- a/plugins/realtek-mst/fu-realtek-mst-device.c +++ b/plugins/realtek-mst/fu-realtek-mst-device.c @@ -383,22 +383,20 @@ fu_realtek_mst_device_probe(FuDevice *device, GError **error) { FuRealtekMstDevice *self = FU_REALTEK_MST_DEVICE(device); FuContext *context = fu_device_get_context(device); - const gchar *hardware_family = NULL; const gchar *quirk_name = NULL; - g_autofree gchar *family_instance_id = NULL; - g_autofree gchar *instance_id = NULL; /* set custom instance ID and load matching quirks */ - instance_id = - g_strdup_printf("REALTEK-MST\\NAME_%s", - fu_udev_device_get_sysfs_attr(FU_UDEV_DEVICE(device), "name", NULL)); - fu_device_add_instance_id(device, instance_id); + fu_device_add_instance_str( + device, + "NAME", + fu_udev_device_get_sysfs_attr(FU_UDEV_DEVICE(device), "name", NULL)); + if (!fu_device_build_instance_id(device, error, "REALTEK-MST", "NAME", NULL)) + return FALSE; - hardware_family = fu_context_get_hwid_value(context, FU_HWIDS_KEY_FAMILY); - family_instance_id = g_strdup_printf("%s&FAMILY_%s", instance_id, hardware_family); - fu_device_add_instance_id_full(device, - family_instance_id, - FU_DEVICE_INSTANCE_FLAG_ONLY_QUIRKS); + fu_device_add_instance_str(device, + "FAMILY", + fu_context_get_hwid_value(context, FU_HWIDS_KEY_FAMILY)); + fu_device_build_instance_id_quirk(device, NULL, "REALTEK-MST", "NAME", "FAMILY", NULL); /* having loaded quirks, check this device is supported */ quirk_name = fu_device_get_name(device); diff --git a/plugins/redfish/fu-redfish-device.c b/plugins/redfish/fu-redfish-device.c index 563e765ea..f5d4c7ca1 100644 --- a/plugins/redfish/fu-redfish-device.c +++ b/plugins/redfish/fu-redfish-device.c @@ -66,7 +66,6 @@ fu_redfish_device_probe_related_pcie_item(FuRedfishDevice *self, const gchar *ur { FuRedfishDevicePrivate *priv = GET_PRIVATE(self); JsonObject *json_obj; - const gchar *subsystem = "PCI"; guint64 vendor_id = 0x0; guint64 model_id = 0x0; guint64 subsystem_vendor_id = 0x0; @@ -133,25 +132,19 @@ fu_redfish_device_probe_related_pcie_item(FuRedfishDevice *self, const gchar *ur } /* add more instance IDs if possible */ - if (vendor_id != 0x0 && model_id != 0x0) { - g_autofree gchar *devid1 = NULL; - devid1 = g_strdup_printf("%s\\VEN_%04X&DEV_%04X", - subsystem, - (guint)vendor_id, - (guint)model_id); - fu_device_add_instance_id(FU_DEVICE(self), devid1); - } - if (vendor_id != 0x0 && model_id != 0x0 && subsystem_vendor_id != 0x0 && - subsystem_model_id != 0x0) { - g_autofree gchar *devid2 = NULL; - devid2 = g_strdup_printf("%s\\VEN_%04X&DEV_%04X&SUBSYS_%04X%04X", - subsystem, - (guint)vendor_id, - (guint)model_id, + if (vendor_id != 0x0) + fu_device_add_instance_u16(FU_DEVICE(self), "VEN", vendor_id); + if (model_id != 0x0) + fu_device_add_instance_u16(FU_DEVICE(self), "DEV", model_id); + if (subsystem_vendor_id != 0x0 && subsystem_model_id != 0x0) { + g_autofree gchar *subsys = NULL; + subsys = g_strdup_printf("%04X%04X", (guint)subsystem_vendor_id, (guint)subsystem_model_id); - fu_device_add_instance_id(FU_DEVICE(self), devid2); + fu_device_add_instance_str(FU_DEVICE(self), "SUBSYS", subsys); } + fu_device_build_instance_id(FU_DEVICE(self), NULL, "PCI", "VEN", "DEV", NULL); + fu_device_build_instance_id(FU_DEVICE(self), NULL, "PCI", "VEN", "DEV", "SUBSYS", NULL); /* success */ return TRUE; @@ -449,31 +442,31 @@ fu_redfish_device_probe(FuDevice *dev, GError **error) } } + /* add IDs */ + fu_device_add_instance_strsafe(dev, "VENDOR", fu_device_get_vendor(dev)); + fu_device_add_instance_str(dev, "SOFTWAREID", guid); + fu_device_add_instance_str(dev, "ID", fu_device_get_backend_id(dev)); + /* some vendors use a GUID, others use an ID like BMC-AFBT-10 */ guid_lower = g_ascii_strdown(guid, -1); if (fwupd_guid_is_valid(guid_lower)) { fu_device_add_guid(dev, guid_lower); - } else if (fu_device_get_vendor(dev) != NULL) { - const gchar *instance_id_suffix = ""; - g_autofree gchar *instance_id = NULL; + } else { if (fu_device_has_private_flag(dev, FU_REDFISH_DEVICE_FLAG_UNSIGNED_BUILD)) - instance_id_suffix = "&TYPE_UNSIGNED"; - instance_id = g_strdup_printf("REDFISH\\VENDOR_%s&SOFTWAREID_%s%s", - fu_device_get_vendor(dev), - guid, - instance_id_suffix); - g_strdelimit(instance_id, " ", '_'); - fu_device_add_instance_id(dev, instance_id); + fu_device_add_instance_str(dev, "TYPE", "UNSIGNED"); + + fu_device_build_instance_id(dev, + NULL, + "REDFISH", + "VENDOR", + "SOFTWAREID", + "TYPE", + NULL); + fu_device_build_instance_id(dev, NULL, "REDFISH", "VENDOR", "SOFTWAREID", NULL); } /* used for quirking and parenting */ - if (fu_device_get_vendor(dev) != NULL && fu_device_get_backend_id(dev) != NULL) { - g_autofree gchar *instance_id = NULL; - instance_id = g_strdup_printf("REDFISH\\VENDOR_%s&ID_%s", - fu_device_get_vendor(dev), - fu_device_get_backend_id(dev)); - fu_device_add_instance_id(dev, instance_id); - } + fu_device_build_instance_id(dev, NULL, "REDFISH", "VENDOR", "ID", NULL); if (json_object_has_member(member, "Name")) { const gchar *tmp = json_object_get_string_member(member, "Name"); diff --git a/plugins/scsi/fu-scsi-device.c b/plugins/scsi/fu-scsi-device.c index bd360ea2c..277d07975 100644 --- a/plugins/scsi/fu-scsi-device.c +++ b/plugins/scsi/fu-scsi-device.c @@ -20,10 +20,7 @@ fu_scsi_device_probe(FuDevice *device, GError **error) const gchar *name; const gchar *vendor; const gchar *version; - g_autofree gchar *name_safe = NULL; - g_autofree gchar *subsystem = NULL; - g_autofree gchar *vendor_safe = NULL; - g_autofree gchar *version_safe = NULL; + g_autofree gchar *vendor_id = NULL; g_autoptr(GPtrArray) block_devs = NULL; /* ignore */ @@ -37,8 +34,7 @@ fu_scsi_device_probe(FuDevice *device, GError **error) /* vendor */ vendor = fu_udev_device_get_sysfs_attr(FU_UDEV_DEVICE(device), "vendor", NULL); - vendor_safe = fu_common_instance_id_strsafe(vendor); - if (vendor_safe == NULL || g_strcmp0(vendor_safe, "ATA") == 0) { + if (vendor == NULL || g_strcmp0(vendor, "ATA") == 0) { g_set_error_literal(error, FWUPD_ERROR, FWUPD_ERROR_NOT_SUPPORTED, @@ -46,57 +42,27 @@ fu_scsi_device_probe(FuDevice *device, GError **error) return FALSE; } fu_device_set_vendor(device, vendor); + vendor_id = g_strdup_printf("SCSI:%s", vendor); + fu_device_add_vendor_id(device, vendor_id); /* name */ name = fu_udev_device_get_sysfs_attr(FU_UDEV_DEVICE(device), "model", NULL); - name_safe = fu_common_instance_id_strsafe(name); - if (name_safe == NULL) { - g_set_error_literal(error, - FWUPD_ERROR, - FWUPD_ERROR_NOT_SUPPORTED, - "no assigned name"); - return FALSE; - } fu_device_set_name(device, name); /* version */ version = fu_udev_device_get_sysfs_attr(FU_UDEV_DEVICE(device), "rev", NULL); - version_safe = fu_common_instance_id_strsafe(version); - if (version_safe == NULL) { - g_set_error_literal(error, - FWUPD_ERROR, - FWUPD_ERROR_NOT_SUPPORTED, - "no assigned version"); - return FALSE; - } fu_device_set_version(device, version); /* add GUIDs */ - subsystem = g_utf8_strup(fu_udev_device_get_subsystem(FU_UDEV_DEVICE(device)), -1); - if (subsystem != NULL && vendor_safe != NULL && name_safe != NULL && version_safe != NULL) { - g_autofree gchar *devid = NULL; - devid = g_strdup_printf("%s\\VEN_%s&DEV_%s&REV_%s", - subsystem, - vendor_safe, - name_safe, - version_safe); - fu_device_add_instance_id(device, devid); - } - if (subsystem != NULL && vendor_safe != NULL && name_safe != NULL) { - g_autofree gchar *devid = NULL; - devid = g_strdup_printf("%s\\VEN_%s&DEV_%s", subsystem, vendor_safe, name_safe); - fu_device_add_instance_id(device, devid); - } - if (subsystem != NULL && vendor_safe != NULL) { - g_autofree gchar *devid = NULL; - devid = g_strdup_printf("%s\\VEN_%s", subsystem, vendor_safe); - fu_device_add_instance_id_full(device, devid, FU_DEVICE_INSTANCE_FLAG_ONLY_QUIRKS); - } - if (vendor_safe != NULL) { - g_autofree gchar *vendor_id = NULL; - vendor_id = g_strdup_printf("SCSI:%s", vendor_safe); - fu_device_add_vendor_id(device, vendor_id); - } + fu_device_add_instance_strsafe(device, "VEN", vendor); + fu_device_add_instance_strsafe(device, "DEV", name); + fu_device_add_instance_strsafe(device, "REV", version); + if (!fu_device_build_instance_id_quirk(device, NULL, "SCSI", "VEN", NULL)) + return FALSE; + if (!fu_device_build_instance_id(device, NULL, "SCSI", "VEN", "DEV", NULL)) + return FALSE; + if (!fu_device_build_instance_id(device, NULL, "SCSI", "VEN", "DEV", "REV", NULL)) + return FALSE; /* check all block devices, although there should only be one */ block_devs = fu_udev_device_get_children_with_subsystem(FU_UDEV_DEVICE(device), "block"); diff --git a/plugins/superio/fu-plugin-superio.c b/plugins/superio/fu-plugin-superio.c index 5fb18ba66..02197c586 100644 --- a/plugins/superio/fu-plugin-superio.c +++ b/plugins/superio/fu-plugin-superio.c @@ -22,7 +22,6 @@ fu_plugin_superio_coldplug_chipset(FuPlugin *plugin, const gchar *guid, GError * const gchar *dmi_vendor; const gchar *chipset; GType custom_gtype; - g_autofree gchar *devid = NULL; g_autoptr(FuSuperioDevice) dev = NULL; g_autoptr(FuDeviceLocker) locker = NULL; @@ -51,8 +50,9 @@ fu_plugin_superio_coldplug_chipset(FuPlugin *plugin, const gchar *guid, GError * NULL); /* add this so we can attach all the other quirks */ - devid = g_strdup_printf("SUPERIO\\GUID_%s", guid); - fu_device_add_instance_id(FU_DEVICE(dev), devid); + fu_device_add_instance_str(FU_DEVICE(dev), "GUID", guid); + if (!fu_device_build_instance_id(FU_DEVICE(dev), error, "SUPERIO", "GUID", NULL)) + return FALSE; /* set ID and ports via quirks */ if (!fu_device_probe(FU_DEVICE(dev), error)) diff --git a/plugins/synaptics-cxaudio/fu-synaptics-cxaudio-device.c b/plugins/synaptics-cxaudio/fu-synaptics-cxaudio-device.c index 39aa9ae3a..0db6285d4 100644 --- a/plugins/synaptics-cxaudio/fu-synaptics-cxaudio-device.c +++ b/plugins/synaptics-cxaudio/fu-synaptics-cxaudio-device.c @@ -412,8 +412,12 @@ fu_synaptics_cxaudio_device_setup(FuDevice *device, GError **error) return FALSE; } self->chip_id = self->chip_id_base + chip_id_offset; - chip_id = g_strdup_printf("SYNAPTICS_CXAUDIO\\ID_CX%u", self->chip_id); - fu_device_add_instance_id_full(device, chip_id, FU_DEVICE_INSTANCE_FLAG_ONLY_QUIRKS); + + /* add instance ID */ + chip_id = g_strdup_printf("CX%u", self->chip_id); + fu_device_add_instance_str(device, "ID", chip_id); + if (!fu_device_build_instance_id_quirk(device, error, "SYNAPTICS_CXAUDIO", "ID", NULL)) + return FALSE; /* set summary */ summary = g_strdup_printf("CX%u USB audio device", self->chip_id); diff --git a/plugins/synaptics-prometheus/fu-synaprom-config.c b/plugins/synaptics-prometheus/fu-synaprom-config.c index 19fd3fb4b..b810560f2 100644 --- a/plugins/synaptics-prometheus/fu-synaprom-config.c +++ b/plugins/synaptics-prometheus/fu-synaprom-config.c @@ -73,11 +73,12 @@ fu_synaprom_config_setup(FuDevice *device, GError **error) FuSynapromCmdIotaFind cmd = {0x0}; FuSynapromIotaConfigVersion cfg; FuSynapromReplyIotaFindHdr hdr; + g_autofree gchar *configid1_str = NULL; + g_autofree gchar *configid2_str = NULL; g_autofree gchar *version = NULL; g_autoptr(GByteArray) reply = NULL; g_autoptr(GByteArray) request = NULL; g_autoptr(FuProgress) progress = fu_progress_new(G_STRLOC); - g_autofree gchar *devid = NULL; /* get IOTA */ cmd.itype = GUINT16_TO_LE((guint16)FU_SYNAPROM_IOTA_ITYPE_CONFIG_VERSION); @@ -125,13 +126,15 @@ fu_synaprom_config_setup(FuDevice *device, GError **error) self->configid2, GUINT16_FROM_LE(cfg.version)); + /* we should have made these a %08% uint32_t... */ + configid1_str = g_strdup_printf("%u", self->configid1); + configid2_str = g_strdup_printf("%u", self->configid2); + /* append the configid to the generated GUID */ - devid = g_strdup_printf("USB\\VID_%04X&PID_%04X&CFG1_%u&CFG2_%u", - fu_usb_device_get_vid(FU_USB_DEVICE(parent)), - fu_usb_device_get_pid(FU_USB_DEVICE(parent)), - self->configid1, - self->configid2); - fu_device_add_instance_id(FU_DEVICE(self), devid); + fu_device_add_instance_str(device, "CFG1", configid1_str); + fu_device_add_instance_str(device, "CFG2", configid2_str); + if (!fu_device_build_instance_id(device, error, "USB", "VID", "PID", "CFG1", "CFG2", NULL)) + return FALSE; /* no downgrades are allowed */ version = g_strdup_printf("%04u", GUINT16_FROM_LE(cfg.version)); diff --git a/plugins/tpm/fu-tpm-v2-device.c b/plugins/tpm/fu-tpm-v2-device.c index a59a9bdf2..9fb16b449 100644 --- a/plugins/tpm/fu-tpm-v2-device.c +++ b/plugins/tpm/fu-tpm-v2-device.c @@ -236,10 +236,6 @@ fu_tpm_v2_device_setup(FuDevice *device, GError **error) guint32 version1 = 0; guint32 version2 = 0; guint64 version_raw; - g_autofree gchar *id1 = NULL; - g_autofree gchar *id2 = NULL; - g_autofree gchar *id3 = NULL; - g_autofree gchar *id4 = NULL; g_autofree gchar *manufacturer = NULL; g_autofree gchar *model1 = NULL; g_autofree gchar *model2 = NULL; @@ -302,14 +298,14 @@ fu_tpm_v2_device_setup(FuDevice *device, GError **error) model = g_strjoin("", model1, model2, model3, model4, NULL); /* add GUIDs to daemon */ - id1 = g_strdup_printf("TPM\\VEN_%s&DEV_%04X", manufacturer, tpm_type); - fu_device_add_instance_id(device, id1); - id2 = g_strdup_printf("TPM\\VEN_%s&MOD_%s", manufacturer, model); - fu_device_add_instance_id(device, id2); - id3 = g_strdup_printf("TPM\\VEN_%s&DEV_%04X&VER_%s", manufacturer, tpm_type, family); - fu_device_add_instance_id(device, id3); - id4 = g_strdup_printf("TPM\\VEN_%s&MOD_%s&VER_%s", manufacturer, model, family); - fu_device_add_instance_id(device, id4); + fu_device_add_instance_str(device, "VEN", manufacturer); + fu_device_add_instance_u16(device, "DEV", tpm_type); + fu_device_add_instance_str(device, "MOD", model); + fu_device_add_instance_str(device, "VER", family); + fu_device_build_instance_id(device, NULL, "TPM", "VEN", "DEV", NULL); + fu_device_build_instance_id(device, NULL, "TPM", "VEN", "MOD", NULL); + fu_device_build_instance_id(device, NULL, "TPM", "VEN", "DEV", "VER", NULL); + fu_device_build_instance_id(device, NULL, "TPM", "VEN", "MOD", "VER", NULL); /* enforce vendors can only ship updates for their own hardware */ vendor_id = g_strdup_printf("TPM:%s", manufacturer); diff --git a/plugins/uefi-dbx/fu-uefi-dbx-device.c b/plugins/uefi-dbx/fu-uefi-dbx-device.c index 696466b28..6482424e0 100644 --- a/plugins/uefi-dbx/fu-uefi-dbx-device.c +++ b/plugins/uefi-dbx/fu-uefi-dbx-device.c @@ -97,7 +97,6 @@ fu_uefi_dbx_prepare_firmware(FuDevice *device, GBytes *fw, FwupdInstallFlags fla static gboolean fu_uefi_dbx_device_probe(FuDevice *device, GError **error) { - g_autofree gchar *arch_up = NULL; g_autoptr(FuFirmware) kek = fu_efi_signature_list_new(); g_autoptr(GBytes) kek_blob = NULL; g_autoptr(GPtrArray) sigs = NULL; @@ -108,23 +107,19 @@ fu_uefi_dbx_device_probe(FuDevice *device, GError **error) return FALSE; if (!fu_firmware_parse(kek, kek_blob, FWUPD_INSTALL_FLAG_NO_SEARCH, error)) return FALSE; - arch_up = g_utf8_strup(EFI_MACHINE_TYPE_NAME, -1); + fu_device_add_instance_strup(device, "ARCH", EFI_MACHINE_TYPE_NAME); + sigs = fu_firmware_get_images(kek); for (guint j = 0; j < sigs->len; j++) { FuEfiSignature *sig = g_ptr_array_index(sigs, j); g_autofree gchar *checksum = NULL; - g_autofree gchar *checksum_up = NULL; - g_autofree gchar *devid1 = NULL; - g_autofree gchar *devid2 = NULL; checksum = fu_firmware_get_checksum(FU_FIRMWARE(sig), G_CHECKSUM_SHA256, error); if (checksum == NULL) return FALSE; - checksum_up = g_utf8_strup(checksum, -1); - devid1 = g_strdup_printf("UEFI\\CRT_%s", checksum_up); - fu_device_add_instance_id(device, devid1); - devid2 = g_strdup_printf("UEFI\\CRT_%s&ARCH_%s", checksum_up, arch_up); - fu_device_add_instance_id(device, devid2); + fu_device_add_instance_strup(device, "CRT", checksum); + fu_device_build_instance_id(device, NULL, "UEFI", "CRT", NULL); + fu_device_build_instance_id(device, NULL, "UEFI", "CRT", "ARCH", NULL); } return fu_uefi_dbx_device_set_version_number(device, error); } diff --git a/plugins/uf2/fu-uf2-device.c b/plugins/uf2/fu-uf2-device.c index 8605f3bef..dd75fd84a 100644 --- a/plugins/uf2/fu-uf2-device.c +++ b/plugins/uf2/fu-uf2-device.c @@ -62,10 +62,11 @@ fu_uf2_device_probe_current_fw(FuDevice *device, GBytes *fw, GError **error) /* add instance ID for quirks */ if (fu_firmware_get_idx(firmware) != 0x0) { - g_autofree gchar *id0 = NULL; - id0 = g_strdup_printf("UF2\\FAMILY_%08X", (guint32)fu_firmware_get_idx(firmware)); - fu_device_add_instance_id_full(device, id0, FU_DEVICE_INSTANCE_FLAG_ONLY_QUIRKS); + fu_device_add_instance_u32(device, + "FAMILY", + (guint32)fu_firmware_get_idx(firmware)); } + fu_device_build_instance_id_quirk(device, NULL, "UF2", "FAMILY", NULL); /* add device checksum */ fw_raw = fu_firmware_get_bytes(firmware, error); @@ -289,11 +290,10 @@ fu_uf2_device_setup(FuDevice *device, GError **error) if (g_str_has_prefix(lines[i], "Model: ")) { fu_device_set_name(device, lines[i] + 7); } else if (g_str_has_prefix(lines[i], "Board-ID: ")) { - g_autofree gchar *devid = NULL; - devid = g_strdup_printf("UF2\\BOARD_%s", lines[i] + 10); - fu_device_add_instance_id(device, devid); + fu_device_add_instance_strsafe(device, "BOARD", lines[i] + 10); } } + fu_device_build_instance_id(device, NULL, "UF2", "BOARD", NULL); /* this might exist */ fn2 = fu_block_device_get_full_path(self, "CURRENT.UF2", error); @@ -314,7 +314,6 @@ fu_uf2_device_probe(FuDevice *device, GError **error) { GUdevDevice *udev_device = fu_udev_device_get_dev(FU_UDEV_DEVICE(device)); const gchar *tmp; - const gchar *uuid; guint64 vid = 0; guint64 pid = 0; @@ -350,20 +349,23 @@ fu_uf2_device_probe(FuDevice *device, GError **error) tmp = g_udev_device_get_property(udev_device, "ID_VENDOR_ID"); if (tmp != NULL) vid = g_ascii_strtoull(tmp, NULL, 16); + if (vid != 0x0) + fu_device_add_instance_u16(device, "VID", vid); tmp = g_udev_device_get_property(udev_device, "ID_MODEL_ID"); if (tmp != NULL) pid = g_ascii_strtoull(tmp, NULL, 16); - uuid = g_udev_device_get_property(udev_device, "ID_FS_UUID"); - if (uuid != NULL && vid != 0x0 && pid != 0x0) { - g_autofree gchar *devid = - g_strdup_printf("USB\\VID_%04X&PID_%04X&UUID_%s", (guint)vid, (guint)pid, uuid); - fu_device_add_instance_id(device, devid); - } - if (vid != 0x0 && pid != 0x0) { - g_autofree gchar *devid = - g_strdup_printf("USB\\VID_%04X&PID_%04X", (guint)vid, (guint)pid); - fu_device_add_instance_id(device, devid); - } + if (pid != 0x0) + fu_device_add_instance_u16(device, "PID", pid); + tmp = g_udev_device_get_property(udev_device, "ID_FS_UUID"); + fu_device_add_instance_str(device, "UUID", tmp); + if (!fu_device_build_instance_id_quirk(device, error, "USB", "VID", NULL)) + return FALSE; + if (!fu_device_build_instance_id(device, error, "USB", "VID", "PID", NULL)) + return FALSE; + if (!fu_device_build_instance_id(device, error, "USB", "VID", "PID", "UUID", NULL)) + return FALSE; + + /* vendor-id */ if (vid != 0x0) { g_autofree gchar *vendor_id = g_strdup_printf("USB:0x%04X", (guint)vid); fu_device_add_vendor_id(device, vendor_id); diff --git a/plugins/usi-dock/fu-usi-dock-dmc-device.c b/plugins/usi-dock/fu-usi-dock-dmc-device.c index e1a5b8a3e..4d4c4470e 100644 --- a/plugins/usi-dock/fu-usi-dock-dmc-device.c +++ b/plugins/usi-dock/fu-usi-dock-dmc-device.c @@ -19,7 +19,7 @@ fu_usi_dock_dmc_device_parent_notify_cb(FuDevice *device, GParamSpec *pspec, gpo { FuDevice *parent = fu_device_get_parent(device); if (parent != NULL) { - g_autofree gchar *instance_id = NULL; + g_autoptr(GError) error = NULL; /* slightly odd: the MCU device uses the DMC version number */ g_debug("absorbing DMC version into MCU"); @@ -28,11 +28,9 @@ fu_usi_dock_dmc_device_parent_notify_cb(FuDevice *device, GParamSpec *pspec, gpo fu_device_set_serial(parent, fu_device_get_serial(device)); /* allow matching firmware */ - instance_id = g_strdup_printf("USB\\VID_%04X&PID_%04X&CID_%s", - fu_usb_device_get_vid(FU_USB_DEVICE(parent)), - fu_usb_device_get_pid(FU_USB_DEVICE(parent)), - fu_device_get_name(device)); - fu_device_add_instance_id(parent, instance_id); + fu_device_add_instance_str(parent, "CID", fu_device_get_name(device)); + if (!fu_device_build_instance_id(parent, &error, "USB", "VID", "PID", "CID", NULL)) + g_warning("failed to build ID: %s", error->message); /* don't allow firmware updates on this */ fu_device_set_name(device, "Dock Management Controller Information"); diff --git a/plugins/usi-dock/fu-usi-dock-mcu-device.c b/plugins/usi-dock/fu-usi-dock-mcu-device.c index 436cbdfed..9d421183c 100644 --- a/plugins/usi-dock/fu-usi-dock-mcu-device.c +++ b/plugins/usi-dock/fu-usi-dock-mcu-device.c @@ -194,7 +194,6 @@ fu_usi_dock_mcu_device_enumerate_children(FuUsiDockMcuDevice *self, GError **err for (guint i = 0; components[i].name != NULL; i++) { const guint8 *val = outbuf + components[i].offset; g_autofree gchar *version = NULL; - g_autofree gchar *instance_id = NULL; g_autoptr(FuDevice) child = NULL; child = fu_usi_dock_child_new(fu_device_get_context(FU_DEVICE(self))); @@ -361,11 +360,15 @@ fu_usi_dock_mcu_device_enumerate_children(FuUsiDockMcuDevice *self, GError **err } /* add virtual device */ - instance_id = g_strdup_printf("USB\\VID_%04X&PID_%04X&CID_%s", - fu_usb_device_get_vid(FU_USB_DEVICE(self)), - fu_usb_device_get_pid(FU_USB_DEVICE(self)), - components[i].name); - fu_device_add_instance_id(child, instance_id); + fu_device_add_instance_u16(child, + "VID", + fu_usb_device_get_vid(FU_USB_DEVICE(self))); + fu_device_add_instance_u16(child, + "PID", + fu_usb_device_get_pid(FU_USB_DEVICE(self))); + fu_device_add_instance_str(child, "CID", components[i].name); + if (!fu_device_build_instance_id(child, error, "USB", "VID", "PID", "CID", NULL)) + return FALSE; if (fu_device_get_name(child) == NULL) fu_device_set_name(child, components[i].name); fu_device_set_logical_id(child, components[i].name); diff --git a/plugins/vli/fu-vli-device.c b/plugins/vli/fu-vli-device.c index c684b9416..bcef23605 100644 --- a/plugins/vli/fu-vli-device.c +++ b/plugins/vli/fu-vli-device.c @@ -480,15 +480,10 @@ fu_vli_device_set_kind(FuVliDevice *self, FuVliDeviceKind device_kind) fu_device_set_firmware_size_max(FU_DEVICE(self), sz); /* add extra DEV GUID too */ - if (priv->kind != FU_VLI_DEVICE_KIND_UNKNOWN) { - GUsbDevice *usb_device = fu_usb_device_get_dev(FU_USB_DEVICE(self)); - g_autofree gchar *devid1 = NULL; - devid1 = g_strdup_printf("USB\\VID_%04X&PID_%04X&DEV_%s", - g_usb_device_get_vid(usb_device), - g_usb_device_get_pid(usb_device), - fu_vli_common_device_kind_to_string(priv->kind)); - fu_device_add_instance_id(FU_DEVICE(self), devid1); - } + fu_device_add_instance_str(FU_DEVICE(self), + "DEV", + fu_vli_common_device_kind_to_string(priv->kind)); + fu_device_build_instance_id(FU_DEVICE(self), NULL, "USB", "VID", "PID", "DEV", NULL); } void @@ -597,14 +592,11 @@ fu_vli_device_setup(FuDevice *device, GError **error) /* get the flash chip attached */ if (priv->spi_auto_detect) { - GUsbDevice *usb_device = fu_usb_device_get_dev(FU_USB_DEVICE(self)); if (!fu_vli_device_spi_read_flash_id(self, error)) { g_prefix_error(error, "failed to read SPI chip ID: "); return FALSE; } if (priv->flash_id != 0x0) { - g_autofree gchar *devid1 = NULL; - g_autofree gchar *devid2 = NULL; g_autofree gchar *flash_id = fu_vli_device_get_flash_id_str(self); /* use the correct flash device */ @@ -613,17 +605,23 @@ fu_vli_device_setup(FuDevice *device, GError **error) return FALSE; /* add extra instance IDs to include the SPI variant */ - devid2 = g_strdup_printf("USB\\VID_%04X&PID_%04X&SPI_%s&REV_%04X", - g_usb_device_get_vid(usb_device), - g_usb_device_get_pid(usb_device), - flash_id, - g_usb_device_get_release(usb_device)); - fu_device_add_instance_id(device, devid2); - devid1 = g_strdup_printf("USB\\VID_%04X&PID_%04X&SPI_%s", - g_usb_device_get_vid(usb_device), - g_usb_device_get_pid(usb_device), - flash_id); - fu_device_add_instance_id(device, devid1); + fu_device_add_instance_str(device, "SPI", flash_id); + if (!fu_device_build_instance_id(device, + error, + "USB", + "VID", + "PID", + "SPI", + NULL)) + return FALSE; + fu_device_build_instance_id(device, + NULL, + "USB", + "VID", + "PID", + "SPI", + "REV", + NULL); } } diff --git a/plugins/vli/fu-vli-pd-parade-device.c b/plugins/vli/fu-vli-pd-parade-device.c index 5e745476f..edb5ecedb 100644 --- a/plugins/vli/fu-vli-pd-parade-device.c +++ b/plugins/vli/fu-vli-pd-parade-device.c @@ -665,23 +665,17 @@ fu_vli_pd_parade_device_dump_firmware(FuDevice *device, FuProgress *progress, GE static gboolean fu_vli_pd_parade_device_probe(FuDevice *device, GError **error) { - FuVliPdDevice *parent = FU_VLI_PD_DEVICE(fu_device_get_parent(device)); FuVliPdParadeDevice *self = FU_VLI_PD_PARADE_DEVICE(device); - g_autofree gchar *instance_id1 = NULL; /* get version */ if (!fu_vli_pd_parade_device_read_fw_ver(self, error)) return FALSE; /* use header to populate device info */ - instance_id1 = g_strdup_printf("USB\\VID_%04X&PID_%04X&I2C_%s", - fu_usb_device_get_vid(FU_USB_DEVICE(parent)), - fu_usb_device_get_pid(FU_USB_DEVICE(parent)), - fu_vli_common_device_kind_to_string(self->device_kind)); - fu_device_add_instance_id(device, instance_id1); - - /* success */ - return TRUE; + fu_device_add_instance_str(device, + "I2C", + fu_vli_common_device_kind_to_string(self->device_kind)); + return fu_device_build_instance_id(device, error, "USB", "VID", "PID", "I2C", NULL); } static void diff --git a/plugins/vli/fu-vli-usbhub-msp430-device.c b/plugins/vli/fu-vli-usbhub-msp430-device.c index e4d49491b..0e9cd2ca4 100644 --- a/plugins/vli/fu-vli-usbhub-msp430-device.c +++ b/plugins/vli/fu-vli-usbhub-msp430-device.c @@ -292,19 +292,13 @@ fu_vli_usbhub_msp430_device_probe(FuDevice *device, GError **error) { FuVliDeviceKind device_kind = FU_VLI_DEVICE_KIND_MSP430; FuVliUsbhubDevice *parent = FU_VLI_USBHUB_DEVICE(fu_device_get_parent(device)); - g_autofree gchar *instance_id = NULL; fu_device_set_name(device, fu_vli_common_device_kind_to_string(device_kind)); fu_device_set_physical_id(device, fu_device_get_physical_id(FU_DEVICE(parent))); /* add instance ID */ - instance_id = g_strdup_printf("USB\\VID_%04X&PID_%04X&I2C_%s", - fu_usb_device_get_vid(FU_USB_DEVICE(parent)), - fu_usb_device_get_pid(FU_USB_DEVICE(parent)), - fu_vli_common_device_kind_to_string(device_kind)); - fu_device_add_instance_id(device, instance_id); - - return TRUE; + fu_device_add_instance_str(device, "I2C", fu_vli_common_device_kind_to_string(device_kind)); + return fu_device_build_instance_id(device, error, "USB", "VID", "PID", NULL); } static void diff --git a/plugins/vli/fu-vli-usbhub-pd-device.c b/plugins/vli/fu-vli-usbhub-pd-device.c index 28b9326c2..495b2b8e2 100644 --- a/plugins/vli/fu-vli-usbhub-pd-device.c +++ b/plugins/vli/fu-vli-usbhub-pd-device.c @@ -46,12 +46,9 @@ fu_vli_usbhub_pd_device_setup(FuDevice *device, GError **error) FuVliPdHdr hdr = {0x0}; FuVliUsbhubPdDevice *self = FU_VLI_USBHUB_PD_DEVICE(device); FuVliUsbhubDevice *parent = FU_VLI_USBHUB_DEVICE(fu_device_get_parent(device)); + const gchar *name; guint32 fwver; g_autofree gchar *fwver_str = NULL; - g_autofree gchar *instance_id0 = NULL; - g_autofree gchar *instance_id1 = NULL; - g_autofree gchar *instance_id2 = NULL; - g_autofree gchar *instance_id3 = NULL; /* legacy location */ if (!fu_vli_device_spi_read_block(FU_VLI_DEVICE(parent), @@ -95,30 +92,27 @@ fu_vli_usbhub_pd_device_setup(FuDevice *device, GError **error) fwver); return FALSE; } - fu_device_set_name(device, fu_vli_common_device_kind_to_string(self->device_kind)); + name = fu_vli_common_device_kind_to_string(self->device_kind); + fu_device_set_name(device, name); /* use header to populate device info */ fu_device_set_version_raw(device, fwver); fwver_str = fu_common_version_from_uint32(fwver, FWUPD_VERSION_FORMAT_QUAD); fu_device_set_version(device, fwver_str); - instance_id0 = g_strdup_printf("USB\\VID_%04X&PID_%04X&APP_%02X", - GUINT16_FROM_LE(hdr.vid), - GUINT16_FROM_LE(hdr.pid), - fwver & 0xff); - fu_device_add_instance_id(device, instance_id0); - instance_id1 = g_strdup_printf("USB\\VID_%04X&PID_%04X&DEV_%s", - GUINT16_FROM_LE(hdr.vid), - GUINT16_FROM_LE(hdr.pid), - fu_vli_common_device_kind_to_string(self->device_kind)); - fu_device_add_instance_id(device, instance_id1); /* add standard GUIDs in order of priority */ - instance_id2 = g_strdup_printf("USB\\VID_%04X&PID_%04X", - GUINT16_FROM_LE(hdr.vid), - GUINT16_FROM_LE(hdr.pid)); - fu_device_add_instance_id(device, instance_id2); - instance_id3 = g_strdup_printf("USB\\VID_%04X", GUINT16_FROM_LE(hdr.vid)); - fu_device_add_instance_id_full(device, instance_id3, FU_DEVICE_INSTANCE_FLAG_ONLY_QUIRKS); + fu_device_add_instance_u16(device, "VID", GUINT16_FROM_LE(hdr.vid)); + fu_device_add_instance_u16(device, "PID", GUINT16_FROM_LE(hdr.pid)); + fu_device_add_instance_u8(device, "APP", fwver & 0xff); + fu_device_add_instance_str(device, "DEV", name); + if (!fu_device_build_instance_id_quirk(device, error, "USB", "VID", NULL)) + return FALSE; + if (!fu_device_build_instance_id(device, error, "USB", "VID", "PID", NULL)) + return FALSE; + if (!fu_device_build_instance_id(device, error, "USB", "VID", "PID", "DEV", NULL)) + return FALSE; + if (!fu_device_build_instance_id(device, error, "USB", "VID", "PID", "APP", NULL)) + return FALSE; /* these have a backup section */ if (fu_vli_common_device_kind_get_offset(self->device_kind) == VLI_USBHUB_FLASHMAP_ADDR_PD) diff --git a/plugins/vli/fu-vli-usbhub-rtd21xx-device.c b/plugins/vli/fu-vli-usbhub-rtd21xx-device.c index 2d0cabbfa..2a663caac 100644 --- a/plugins/vli/fu-vli-usbhub-rtd21xx-device.c +++ b/plugins/vli/fu-vli-usbhub-rtd21xx-device.c @@ -511,18 +511,13 @@ fu_vli_usbhub_rtd21xx_device_probe(FuDevice *device, GError **error) { FuVliDeviceKind device_kind = FU_VLI_DEVICE_KIND_RTD21XX; FuVliUsbhubDevice *parent = FU_VLI_USBHUB_DEVICE(fu_device_get_parent(device)); - g_autofree gchar *instance_id = NULL; fu_device_set_name(device, fu_vli_common_device_kind_to_string(device_kind)); fu_device_set_physical_id(device, fu_device_get_physical_id(FU_DEVICE(parent))); /* add instance ID */ - instance_id = g_strdup_printf("USB\\VID_%04X&PID_%04X&I2C_%s", - fu_usb_device_get_vid(FU_USB_DEVICE(parent)), - fu_usb_device_get_pid(FU_USB_DEVICE(parent)), - fu_vli_common_device_kind_to_string(device_kind)); - fu_device_add_instance_id(device, instance_id); - return TRUE; + fu_device_add_instance_str(device, "I2C", fu_vli_common_device_kind_to_string(device_kind)); + return fu_device_build_instance_id(device, error, "USB", "VID", "PID", "I2C", NULL); } static void diff --git a/plugins/wacom-raw/fu-wacom-aes-device.c b/plugins/wacom-raw/fu-wacom-aes-device.c index a9bcd9d02..ee746e681 100644 --- a/plugins/wacom-raw/fu-wacom-aes-device.c +++ b/plugins/wacom-raw/fu-wacom-aes-device.c @@ -41,8 +41,6 @@ fu_wacom_aes_add_recovery_hwid(FuDevice *device, GError **error) FuWacomRawVerifyResponse rsp = {.report_id = FU_WACOM_RAW_BL_REPORT_ID_GET, .size8 = 0x00, .data = {0x00}}; - g_autofree gchar *devid1 = NULL; - g_autofree gchar *devid2 = NULL; guint16 pid; if (!fu_wacom_device_set_feature(FU_WACOM_DEVICE(device), @@ -77,12 +75,13 @@ fu_wacom_aes_add_recovery_hwid(FuDevice *device, GError **error) return FALSE; } - devid1 = g_strdup_printf("HIDRAW\\VEN_2D1F&DEV_%04X", pid); - devid2 = g_strdup_printf("HIDRAW\\VEN_056A&DEV_%04X", pid); - fu_device_add_instance_id(device, devid1); - fu_device_add_instance_id(device, devid2); - - return TRUE; + /* add recovery IDs */ + fu_device_add_instance_u16(device, "VEN", 0x2D1F); + fu_device_add_instance_u16(device, "DEV", pid); + if (!fu_device_build_instance_id(device, error, "HIDRAW", "VID", "PID", NULL)) + return FALSE; + fu_device_add_instance_u16(device, "VEN", 0x056A); + return fu_device_build_instance_id(device, error, "HIDRAW", "VID", "PID", NULL); } static gboolean