mirror of
https://git.proxmox.com/git/fwupd
synced 2025-08-03 00:02:45 +00:00
Allow devices to build instance IDs more easily
Provide a device instance builder that allows plugins to easily create multiple instance IDs based on parent attributes. Also fix a lot of the instance ID orders, so that we add more generic IDs first, and more specific IDs after.
This commit is contained in:
parent
de14bc6f0e
commit
c4ca026294
@ -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);
|
||||
}
|
||||
}
|
||||
|
@ -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);
|
||||
}
|
||||
|
||||
/**
|
||||
|
@ -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);
|
||||
}
|
||||
|
@ -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, ...);
|
||||
|
@ -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);
|
||||
|
@ -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) {
|
||||
|
@ -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 */
|
||||
|
@ -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;
|
||||
|
@ -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,
|
||||
|
@ -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;
|
||||
|
@ -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;
|
||||
}
|
||||
|
||||
|
@ -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),
|
||||
|
@ -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) {
|
||||
|
@ -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) {
|
||||
|
@ -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");
|
||||
|
@ -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 *
|
||||
|
@ -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;
|
||||
|
@ -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 */
|
||||
|
@ -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
|
||||
|
@ -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))
|
||||
|
@ -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 {
|
||||
|
@ -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
|
||||
|
@ -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);
|
||||
|
@ -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
|
||||
|
@ -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,
|
||||
|
@ -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))
|
||||
|
@ -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
|
||||
|
@ -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,
|
||||
|
@ -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;
|
||||
}
|
||||
|
@ -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
|
||||
|
@ -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);
|
||||
|
@ -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");
|
||||
|
@ -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");
|
||||
|
@ -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))
|
||||
|
@ -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);
|
||||
|
@ -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));
|
||||
|
@ -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);
|
||||
|
@ -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);
|
||||
}
|
||||
|
@ -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);
|
||||
|
@ -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");
|
||||
|
@ -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);
|
||||
|
@ -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);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -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
|
||||
|
@ -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
|
||||
|
@ -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)
|
||||
|
@ -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
|
||||
|
@ -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
|
||||
|
Loading…
Reference in New Issue
Block a user