proxmox-mirrors/fwupd
1
0
Fork 0
mirror of https://git.proxmox.com/git/fwupd synced 2025-05-21 15:34:59 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
09770c60f0
fwupd/plugins/dfu/fu-dfu-device.c
Richard Hughes aaa77c6f51 Allow adding and removing custom flags on devices 
The CustomFlags feature is a bit of a hack where we just join the flags
and store in the device metadata section as a string. This makes it
inefficient to check if just one flag exists as we have to split the
string to a temporary array each time.

Rather than adding to the hack by splitting, appending (if not exists)
then joining again, store the flags in the plugin privdata directly.

This allows us to support negating custom properties (e.g. ~hint) and
also allows quirks to append custom values without duplicating them on
each GUID match, e.g.

[USB\VID_17EF&PID_307F]
Plugin = customflag1
[USB\VID_17EF&PID_307F&HUB_0002]
Flags = customflag2

...would result in customflag1,customflag2 which is the same as you'd
get from an enumerated device flag doing the same thing.
2021-06-23 07:59:15 +01:00

1969 lines
57 KiB
C
Raw Blame History

/*
* Copyright (C) 2015 Richard Hughes <richard@hughsie.com>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
/**
* FuDfuDevice:
*
* This object allows two things:
*
* - Downloading from the host to the device, optionally with
* verification using a DFU or DfuSe firmware file.
*
* - Uploading from the device to the host to a DFU or DfuSe firmware
* file. The file format is chosen automatically, with DfuSe being
* chosen if the device contains more than one target.
*
* See also: [class@FuDfuTarget], [class@FuDfuseFirmware]
*/
/**
* FU_QUIRKS_DFU_FORCE_VERSION:
* @key: the USB device ID, e.g. `USB\VID_0763&PID_2806`
* @value: the uint16_t DFU version, encoded in base 16, e.g. `0110`
*
* Forces a specific DFU version for the hardware device. This is required
* if the device does not set, or sets incorrectly, items in the DFU functional
* descriptor.
*
* Since: 1.0.1
*/
#define FU_QUIRKS_DFU_FORCE_VERSION "DfuForceVersion"
#define DFU_DEVICE_DNLOAD_TIMEOUT_DEFAULT 5 /* ms */
#include "config.h"
#include <fwupdplugin.h>
#include <string.h>
#include "fu-dfu-common.h"
#include "fu-dfu-device.h"
#include "fu-dfu-target-avr.h"
#include "fu-dfu-target-private.h" /* waive-pre-commit */
#include "fu-dfu-target-stm.h"
static void fu_dfu_device_finalize (GObject *object);
typedef struct {
FuDfuDeviceAttrs attributes;
FuDfuState state;
FuDfuStatus status;
GPtrArray *targets;
gboolean done_upload_or_download;
gboolean claimed_interface;
gchar *chip_id;
guint16 version;
guint16 force_version;
guint16 force_transfer_size;
guint16 runtime_pid;
guint16 runtime_vid;
guint16 runtime_release;
guint16 transfer_size;
guint8 iface_number;
guint dnload_timeout;
guint timeout_ms;
} FuDfuDevicePrivate;
G_DEFINE_TYPE_WITH_PRIVATE (FuDfuDevice, fu_dfu_device, FU_TYPE_USB_DEVICE)
#define GET_PRIVATE(o) (fu_dfu_device_get_instance_private (o))
static void fu_dfu_device_set_state (FuDfuDevice *self, FuDfuState state);
static void
fu_dfu_device_to_string (FuDevice *device, guint idt, GString *str)
{
FuDfuDevice *self = FU_DFU_DEVICE (device);
FuDfuDevicePrivate *priv = GET_PRIVATE (self);
fu_common_string_append_kv (str, idt, "State", fu_dfu_state_to_string (priv->state));
fu_common_string_append_kv (str, idt, "Status", fu_dfu_status_to_string (priv->status));
fu_common_string_append_kb (str, idt, "DoneUploadOrDownload", priv->done_upload_or_download);
fu_common_string_append_kb (str, idt, "ClaimedInterface", priv->claimed_interface);
if (priv->chip_id != NULL)
fu_common_string_append_kv (str, idt, "ChipId", priv->chip_id);
fu_common_string_append_kx (str, idt, "Version", priv->version);
fu_common_string_append_kx (str, idt, "ForceVersion", priv->force_version);
if (priv->force_transfer_size != 0x0) {
fu_common_string_append_kx (str, idt, "ForceTransferSize",
priv->force_transfer_size);
}
fu_common_string_append_kx (str, idt, "RuntimePid", priv->runtime_pid);
fu_common_string_append_kx (str, idt, "RuntimeVid", priv->runtime_vid);
fu_common_string_append_kx (str, idt, "RuntimeRelease", priv->runtime_release);
fu_common_string_append_kx (str, idt, "TransferSize", priv->transfer_size);
fu_common_string_append_kx (str, idt, "IfaceNumber", priv->iface_number);
fu_common_string_append_kx (str, idt, "DnloadTimeout", priv->dnload_timeout);
fu_common_string_append_kx (str, idt, "TimeoutMs", priv->timeout_ms);
for (guint i = 0; i < priv->targets->len; i++) {
FuDfuTarget *target = g_ptr_array_index (priv->targets, i);
fu_dfu_target_to_string (target, idt + 1, str);
}
}
/**
* fu_dfu_device_get_transfer_size:
* @device: a USB device
*
* Gets the transfer size in bytes.
*
* Returns: packet size, or 0 for unknown
**/
guint16
fu_dfu_device_get_transfer_size (FuDfuDevice *self)
{
FuDfuDevicePrivate *priv = GET_PRIVATE (self);
g_return_val_if_fail (FU_IS_DFU_DEVICE (self), 0xffff);
return priv->transfer_size;
}
/**
* fu_dfu_device_get_version:
* @self: a #FuDfuDevice
*
* Gets the DFU specification version supported by the device.
*
* Returns: integer, or 0 for unknown, e.g. %FU_DFU_FIRMARE_VERSION_DFU_1_1
**/
guint16
fu_dfu_device_get_version (FuDfuDevice *self)
{
FuDfuDevicePrivate *priv = GET_PRIVATE (self);
g_return_val_if_fail (FU_IS_DFU_DEVICE (self), 0xffff);
return priv->version;
}
/**
* fu_dfu_device_get_download_timeout:
* @self: a #FuDfuDevice
*
* Gets the download timeout in ms.
*
* Returns: delay, or 0 for unknown
**/
guint
fu_dfu_device_get_download_timeout (FuDfuDevice *self)
{
FuDfuDevicePrivate *priv = GET_PRIVATE (self);
g_return_val_if_fail (FU_IS_DFU_DEVICE (self), 0);
return priv->dnload_timeout;
}
/**
* fu_dfu_device_set_transfer_size:
* @self: a #FuDfuDevice
* @transfer_size: maximum packet size
*
* Sets the transfer size in bytes.
**/
void
fu_dfu_device_set_transfer_size (FuDfuDevice *self, guint16 transfer_size)
{
FuDfuDevicePrivate *priv = GET_PRIVATE (self);
g_return_if_fail (FU_IS_DFU_DEVICE (self));
priv->transfer_size = transfer_size;
}
typedef struct __attribute__((packed)) {
guint8 bLength;
guint8 bDescriptorType;
guint8 bmAttributes;
guint16 wDetachTimeOut;
guint16 wTransferSize;
guint16 bcdDFUVersion;
} DfuFuncDescriptor;
static gboolean
fu_dfu_device_parse_iface_data (FuDfuDevice *self, GBytes *iface_data, GError **error)
{
FuDfuDevicePrivate *priv = GET_PRIVATE (self);
DfuFuncDescriptor desc = { 0x0 };
const guint8 *buf;
gsize sz;
/* parse the functional descriptor */
buf = g_bytes_get_data (iface_data, &sz);
if (sz == sizeof(DfuFuncDescriptor)) {
memcpy (&desc, buf, sz);
} else if (sz > sizeof(DfuFuncDescriptor)) {
g_debug ("DFU interface with %" G_GSIZE_FORMAT " bytes vendor data",
sz - sizeof(DfuFuncDescriptor));
memcpy (&desc, buf, sizeof(DfuFuncDescriptor));
} else if (sz == sizeof(DfuFuncDescriptor) - 2) {
g_warning ("truncated DFU interface data, no bcdDFUVersion");
memcpy (&desc, buf, sz);
desc.bcdDFUVersion = FU_DFU_FIRMARE_VERSION_DFU_1_1;
} else {
g_autoptr(GString) bufstr = g_string_new (NULL);
for (gsize i = 0; i < sz; i++)
g_string_append_printf (bufstr, "%02x ", buf[i]);
if (bufstr->len > 0)
g_string_truncate (bufstr, bufstr->len - 1);
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_DATA,
"interface found, but not the correct length for "
"functional data: %" G_GSIZE_FORMAT " bytes: %s",
sz, bufstr->str);
return FALSE;
}
/* get transfer size and version */
priv->transfer_size = GUINT16_FROM_LE (desc.wTransferSize);
priv->version = GUINT16_FROM_LE (desc.bcdDFUVersion);
/* ST-specific */
if (priv->version == FU_DFU_FIRMARE_VERSION_DFUSE &&
desc.bmAttributes & FU_DFU_DEVICE_ATTR_CAN_ACCELERATE)
priv->transfer_size = 0x1000;
/* get attributes about the DFU operation */
priv->attributes = desc.bmAttributes;
return TRUE;
}
static void
fu_dfu_device_guess_state_from_iface (FuDfuDevice *self, GUsbInterface *iface)
{
/* some devices use the wrong interface */
if (fu_device_has_private_flag (FU_DEVICE (self), FU_DFU_DEVICE_FLAG_FORCE_DFU_MODE)) {
g_debug ("quirking device into DFU mode");
fu_dfu_device_set_state (self, FU_DFU_STATE_DFU_IDLE);
return;
}
/* runtime */
if (g_usb_interface_get_protocol (iface) == 0x01) {
fu_dfu_device_set_state (self, FU_DFU_STATE_APP_IDLE);
return;
}
/* DFU */
if (g_usb_interface_get_protocol (iface) == 0x02) {
fu_dfu_device_set_state (self, FU_DFU_STATE_DFU_IDLE);
return;
}
g_warning ("unable to guess initial device state from interface %u",
g_usb_interface_get_protocol (iface));
}
static gboolean
fu_dfu_device_add_targets (FuDfuDevice *self, GError **error)
{
FuDfuDevicePrivate *priv = GET_PRIVATE (self);
GUsbDevice *usb_device = fu_usb_device_get_dev (FU_USB_DEVICE (self));
g_autoptr(GPtrArray) ifaces = NULL;
/* add all DFU-capable targets */
ifaces = g_usb_device_get_interfaces (usb_device, error);
if (ifaces == NULL)
return FALSE;
g_ptr_array_set_size (priv->targets, 0);
for (guint i = 0; i < ifaces->len; i++) {
GBytes *iface_data = NULL;
FuDfuTarget *target;
g_autoptr(GError) error_local = NULL;
GUsbInterface *iface = g_ptr_array_index (ifaces, i);
/* some devices don't use the right class and subclass */
if (fu_device_has_private_flag (FU_DEVICE (self), FU_DFU_DEVICE_FLAG_USE_ANY_INTERFACE)) {
if (g_usb_interface_get_class (iface) != G_USB_DEVICE_CLASS_APPLICATION_SPECIFIC)
continue;
if (g_usb_interface_get_subclass (iface) != 0x01)
continue;
}
/* parse any interface data */
iface_data = g_usb_interface_get_extra (iface);
if (g_bytes_get_size (iface_data) > 0) {
if (!fu_dfu_device_parse_iface_data (self, iface_data, &error_local)) {
g_warning ("failed to parse interface data for %04x:%04x: %s",
g_usb_device_get_vid (usb_device),
g_usb_device_get_pid (usb_device),
error_local->message);
continue;
}
} else {
priv->attributes |= FU_DFU_DEVICE_ATTR_CAN_DOWNLOAD |
FU_DFU_DEVICE_ATTR_CAN_UPLOAD;
}
/* fix up the version */
if (priv->force_version > 0)
priv->version = priv->force_version;
if (priv->version == FU_DFU_FIRMARE_VERSION_DFU_1_0 ||
priv->version == FU_DFU_FIRMARE_VERSION_DFU_1_1) {
g_debug ("DFU v1.1");
} else if (priv->version == FU_DFU_FIRMARE_VERSION_ATMEL_AVR) {
g_debug ("AVR-DFU support");
priv->version = FU_DFU_FIRMARE_VERSION_ATMEL_AVR;
} else if (priv->version == FU_DFU_FIRMARE_VERSION_DFUSE) {
g_debug ("STM-DFU support");
} else if (priv->version == 0x0101) {
g_debug ("DFU v1.1 assumed");
priv->version = FU_DFU_FIRMARE_VERSION_DFU_1_1;
} else {
g_warning ("DFU version 0x%04x invalid, v1.1 assumed", priv->version);
priv->version = FU_DFU_FIRMARE_VERSION_DFU_1_1;
}
/* set expected protocol */
if (priv->version == FU_DFU_FIRMARE_VERSION_DFUSE) {
fu_device_add_protocol (FU_DEVICE (self), "com.st.dfuse");
} else {
fu_device_add_protocol (FU_DEVICE (self), "org.usb.dfu");
}
/* fix up the transfer size */
if (priv->force_transfer_size != 0x0) {
priv->transfer_size = priv->force_transfer_size;
g_debug ("forcing DFU transfer size 0x%04x bytes", priv->transfer_size);
} else if (priv->transfer_size == 0xffff) {
priv->transfer_size = 0x0400;
g_debug ("DFU transfer size unspecified, guessing");
} else if (priv->transfer_size == 0x0) {
g_warning ("DFU transfer size invalid, using default");
priv->transfer_size = 64;
} else {
g_debug ("using DFU transfer size 0x%04x bytes",
priv->transfer_size);
}
/* create a target of the required type */
switch (priv->version) {
case FU_DFU_FIRMARE_VERSION_DFUSE:
target = fu_dfu_target_stm_new ();
break;
case FU_DFU_FIRMARE_VERSION_ATMEL_AVR:
target = fu_dfu_target_avr_new ();
break;
default:
target = fu_dfu_target_new ();
break;
}
fu_dfu_target_set_device (target, self);
fu_dfu_target_set_alt_idx (target, g_usb_interface_get_index (iface));
fu_dfu_target_set_alt_setting (target, g_usb_interface_get_alternate (iface));
/* add target */
priv->iface_number = g_usb_interface_get_number (iface);
g_ptr_array_add (priv->targets, target);
fu_dfu_device_guess_state_from_iface (self, iface);
}
/* save for reset */
if (priv->state == FU_DFU_STATE_APP_IDLE ||
fu_device_has_private_flag (FU_DEVICE (self), FU_DFU_DEVICE_FLAG_NO_PID_CHANGE)) {
priv->runtime_vid = g_usb_device_get_vid (usb_device);
priv->runtime_pid = g_usb_device_get_pid (usb_device);
priv->runtime_release = g_usb_device_get_release (usb_device);
}
/* the device has no DFU runtime, so cheat */
if (priv->targets->len == 0 &&
fu_device_has_private_flag (FU_DEVICE (self), FU_DFU_DEVICE_FLAG_NO_DFU_RUNTIME)) {
g_debug ("no DFU runtime, so faking device");
fu_dfu_device_set_state (self, FU_DFU_STATE_APP_IDLE);
priv->iface_number = 0xff;
priv->runtime_vid = g_usb_device_get_vid (usb_device);
priv->runtime_pid = g_usb_device_get_pid (usb_device);
priv->runtime_release = g_usb_device_get_release (usb_device);
priv->attributes = FU_DFU_DEVICE_ATTR_CAN_DOWNLOAD |
FU_DFU_DEVICE_ATTR_CAN_UPLOAD;
return TRUE;
}
/* no targets */
if (priv->targets->len == 0) {
g_set_error_literal (error,
FWUPD_ERROR,
FWUPD_ERROR_NOT_SUPPORTED,
"no DFU interfaces");
return FALSE;
}
/* the device upload is broken */
if (fu_device_has_private_flag (FU_DEVICE (self), FU_DFU_DEVICE_FLAG_IGNORE_UPLOAD))
priv->attributes &= ~FU_DFU_DEVICE_ATTR_CAN_UPLOAD;
return TRUE;
}
/**
* fu_dfu_device_can_upload:
* @self: a #FuDfuDevice
*
* Gets if the device can upload.
*
* Returns: %TRUE if the device can upload from device to host
**/
gboolean
fu_dfu_device_can_upload (FuDfuDevice *self)
{
FuDfuDevicePrivate *priv = GET_PRIVATE (self);
g_return_val_if_fail (FU_IS_DFU_DEVICE (self), FALSE);
return (priv->attributes & FU_DFU_DEVICE_ATTR_CAN_UPLOAD) > 0;
}
/**
* fu_dfu_device_can_download:
* @self: a #FuDfuDevice
*
* Gets if the device can download.
*
* Returns: %TRUE if the device can download from host to device
**/
gboolean
fu_dfu_device_can_download (FuDfuDevice *self)
{
FuDfuDevicePrivate *priv = GET_PRIVATE (self);
g_return_val_if_fail (FU_IS_DFU_DEVICE (self), FALSE);
return (priv->attributes & FU_DFU_DEVICE_ATTR_CAN_DOWNLOAD) > 0;
}
/**
* fu_dfu_device_set_timeout:
* @self: a #FuDfuDevice
* @timeout_ms: the timeout in ms
*
* Sets the USB timeout to use when contacting the USB device.
**/
void
fu_dfu_device_set_timeout (FuDfuDevice *self, guint timeout_ms)
{
FuDfuDevicePrivate *priv = GET_PRIVATE (self);
g_return_if_fail (FU_IS_DFU_DEVICE (self));
priv->timeout_ms = timeout_ms;
}
/**
* fu_dfu_device_get_timeout:
* @device: a #FuDfuDevice
*
* Gets the device timeout.
*
* Returns: enumerated timeout in ms
**/
guint
fu_dfu_device_get_timeout (FuDfuDevice *self)
{
FuDfuDevicePrivate *priv = GET_PRIVATE (self);
g_return_val_if_fail (FU_IS_DFU_DEVICE (self), 0);
return priv->timeout_ms;
}
/**
* fu_dfu_device_get_state:
* @device: a #FuDfuDevice
*
* Gets the device state.
*
* Returns: enumerated state, e.g. %FU_DFU_STATE_DFU_UPLOAD_IDLE
**/
FuDfuState
fu_dfu_device_get_state (FuDfuDevice *self)
{
FuDfuDevicePrivate *priv = GET_PRIVATE (self);
g_return_val_if_fail (FU_IS_DFU_DEVICE (self), 0);
return priv->state;
}
/**
* fu_dfu_device_get_status:
* @device: a USB device
*
* Gets the device status.
*
* Returns: enumerated status, e.g. %FU_DFU_STATUS_ERR_ADDRESS
**/
FuDfuStatus
fu_dfu_device_get_status (FuDfuDevice *self)
{
FuDfuDevicePrivate *priv = GET_PRIVATE (self);
g_return_val_if_fail (FU_IS_DFU_DEVICE (self), 0);
return priv->status;
}
/**
* fu_dfu_device_has_attribute: (skip)
* @self: a #FuDfuDevice
* @attribute: a device attribute, e.g. %FU_DFU_DEVICE_ATTR_CAN_DOWNLOAD
*
* Returns if an attribute set for the device.
*
* Returns: %TRUE if the attribute is set
**/
gboolean
fu_dfu_device_has_attribute (FuDfuDevice *self, FuDfuDeviceAttrs attribute)
{
FuDfuDevicePrivate *priv = GET_PRIVATE (self);
g_return_val_if_fail (FU_IS_DFU_DEVICE (self), FALSE);
return (priv->attributes & attribute) > 0;
}
/**
* fu_dfu_device_remove_attribute: (skip)
* @self: a #FuDfuDevice
* @attribute: a device attribute, e.g. %FU_DFU_DEVICE_ATTR_CAN_DOWNLOAD
*
* Removes an attribute from the device.
**/
void
fu_dfu_device_remove_attribute (FuDfuDevice *self, FuDfuDeviceAttrs attribute)
{
FuDfuDevicePrivate *priv = GET_PRIVATE (self);
g_return_if_fail (FU_IS_DFU_DEVICE (self));
priv->attributes &= ~attribute;
}
/**
* fu_dfu_device_new:
*
* Creates a new DFU device object.
*
* Returns: a new #FuDfuDevice
**/
FuDfuDevice *
fu_dfu_device_new (GUsbDevice *usb_device)
{
FuDfuDevice *self;
self = g_object_new (FU_TYPE_DFU_DEVICE,
"usb-device", usb_device,
NULL);
return self;
}
/**
* fu_dfu_device_get_targets:
* @self: a #FuDfuDevice
*
* Gets all the targets for this device.
*
* Returns: (transfer none) (element-type FuDfuTarget): #FuDfuTarget, or %NULL
**/
GPtrArray *
fu_dfu_device_get_targets (FuDfuDevice *self)
{
FuDfuDevicePrivate *priv = GET_PRIVATE (self);
g_return_val_if_fail (FU_IS_DFU_DEVICE (self), NULL);
return priv->targets;
}
/**
* fu_dfu_device_get_target_by_alt_setting:
* @self: a #FuDfuDevice
* @alt_setting: the setting used to find
* @error: (nullable): optional return location for an error
*
* Gets a target with a specific alternative setting.
*
* Returns: (transfer full): a #FuDfuTarget, or %NULL
**/
FuDfuTarget *
fu_dfu_device_get_target_by_alt_setting (FuDfuDevice *self,
guint8 alt_setting,
GError **error)
{
FuDfuDevicePrivate *priv = GET_PRIVATE (self);
g_return_val_if_fail (FU_IS_DFU_DEVICE (self), NULL);
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
/* find by ID */
for (guint i = 0; i < priv->targets->len; i++) {
FuDfuTarget *target = g_ptr_array_index (priv->targets, i);
if (fu_dfu_target_get_alt_setting (target) == alt_setting)
return g_object_ref (target);
}
/* failed */
g_set_error (error,
FWUPD_ERROR,
FWUPD_ERROR_NOT_FOUND,
"No target with alt-setting %i",
alt_setting);
return NULL;
}
/**
* fu_dfu_device_get_target_by_alt_name:
* @self: a #FuDfuDevice
* @alt_name: the name used to find
* @error: (nullable): optional return location for an error
*
* Gets a target with a specific alternative name.
*
* Returns: (transfer full): a #FuDfuTarget, or %NULL
**/
FuDfuTarget *
fu_dfu_device_get_target_by_alt_name (FuDfuDevice *self,
const gchar *alt_name,
GError **error)
{
FuDfuDevicePrivate *priv = GET_PRIVATE (self);
g_return_val_if_fail (FU_IS_DFU_DEVICE (self), NULL);
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
/* find by ID */
for (guint i = 0; i < priv->targets->len; i++) {
FuDfuTarget *target = g_ptr_array_index (priv->targets, i);
if (g_strcmp0 (fu_dfu_target_get_alt_name (target, NULL), alt_name) == 0)
return g_object_ref (target);
}
/* failed */
g_set_error (error,
FWUPD_ERROR,
FWUPD_ERROR_NOT_FOUND,
"No target with alt-name %s",
alt_name);
return NULL;
}
/**
* fu_dfu_device_get_platform_id:
* @self: a #FuDfuDevice
*
* Gets the platform ID which normally corresponds to the port in some way.
*
* Returns: string or %NULL
**/
const gchar *
fu_dfu_device_get_platform_id (FuDfuDevice *self)
{
GUsbDevice *usb_device = fu_usb_device_get_dev (FU_USB_DEVICE (self));
g_return_val_if_fail (FU_IS_DFU_DEVICE (self), NULL);
return g_usb_device_get_platform_id (usb_device);
}
/**
* fu_dfu_device_get_runtime_vid:
* @self: a #FuDfuDevice
*
* Gets the runtime vendor ID.
*
* Returns: vendor ID, or 0xffff for unknown
**/
guint16
fu_dfu_device_get_runtime_vid (FuDfuDevice *self)
{
FuDfuDevicePrivate *priv = GET_PRIVATE (self);
g_return_val_if_fail (FU_IS_DFU_DEVICE (self), 0xffff);
return priv->runtime_vid;
}
/**
* fu_dfu_device_get_runtime_pid:
* @self: a #FuDfuDevice
*
* Gets the runtime product ID.
*
* Returns: product ID, or 0xffff for unknown
**/
guint16
fu_dfu_device_get_runtime_pid (FuDfuDevice *self)
{
FuDfuDevicePrivate *priv = GET_PRIVATE (self);
g_return_val_if_fail (FU_IS_DFU_DEVICE (self), 0xffff);
return priv->runtime_pid;
}
/**
* fu_dfu_device_get_runtime_release:
* @self: a #FuDfuDevice
*
* Gets the runtime release number in BCD format.
*
* Returns: release number, or 0xffff for unknown
**/
guint16
fu_dfu_device_get_runtime_release (FuDfuDevice *self)
{
FuDfuDevicePrivate *priv = GET_PRIVATE (self);
g_return_val_if_fail (FU_IS_DFU_DEVICE (self), 0xffff);
return priv->runtime_release;
}
const gchar *
fu_dfu_device_get_chip_id (FuDfuDevice *self)
{
FuDfuDevicePrivate *priv = GET_PRIVATE (self);
g_return_val_if_fail (FU_IS_DFU_DEVICE (self), NULL);
return priv->chip_id;
}
void
fu_dfu_device_set_chip_id (FuDfuDevice *self, const gchar *chip_id)
{
FuDfuDevicePrivate *priv = GET_PRIVATE (self);
g_return_if_fail (FU_IS_DFU_DEVICE (self));
g_debug ("chip ID set to: %s", chip_id);
priv->chip_id = g_strdup (chip_id);
}
static void
fu_dfu_device_set_state (FuDfuDevice *self, FuDfuState state)
{
FuDfuDevicePrivate *priv = GET_PRIVATE (self);
if (priv->state == state)
return;
priv->state = state;
/* set bootloader status */
if (state == FU_DFU_STATE_APP_IDLE ||
state == FU_DFU_STATE_APP_DETACH) {
fu_device_remove_flag (FU_DEVICE (self), FWUPD_DEVICE_FLAG_IS_BOOTLOADER);
} else {
fu_device_add_flag (FU_DEVICE (self), FWUPD_DEVICE_FLAG_IS_BOOTLOADER);
}
}
static void
fu_dfu_device_set_status (FuDfuDevice *self, FuDfuStatus status)
{
FuDfuDevicePrivate *priv = GET_PRIVATE (self);
if (priv->status == status)
return;
priv->status = status;
}
gboolean
fu_dfu_device_ensure_interface (FuDfuDevice *self, GError **error)
{
FuDfuDevicePrivate *priv = GET_PRIVATE (self);
GUsbDevice *usb_device = fu_usb_device_get_dev (FU_USB_DEVICE (self));
g_autoptr(GError) error_local = NULL;
/* already done */
if (priv->claimed_interface)
return TRUE;
/* nothing set */
if (priv->iface_number == 0xff)
return TRUE;
/* claim, without detaching kernel driver */
if (!g_usb_device_claim_interface (usb_device,
(gint) priv->iface_number,
G_USB_DEVICE_CLAIM_INTERFACE_BIND_KERNEL_DRIVER,
&error_local)) {
g_set_error (error,
FWUPD_ERROR,
FWUPD_ERROR_NOT_SUPPORTED,
"cannot claim interface %i: %s",
priv->iface_number, error_local->message);
return FALSE;
}
/* success */
priv->claimed_interface = TRUE;
return TRUE;
}
/**
* fu_dfu_device_refresh_and_clear:
* @self: a #FuDfuDevice
* @error: (nullable): optional return location for an error
*
* Refreshes the cached properties on the DFU device. If there are any transers
* in progress they are cancelled, and if there are any pending errors they are
* cancelled.
*
* Returns: %TRUE for success
**/
gboolean
fu_dfu_device_refresh_and_clear (FuDfuDevice *self, GError **error)
{
FuDfuDevicePrivate *priv = GET_PRIVATE (self);
if (!fu_dfu_device_refresh (self, error))
return FALSE;
switch (priv->state) {
case FU_DFU_STATE_DFU_UPLOAD_IDLE:
case FU_DFU_STATE_DFU_DNLOAD_IDLE:
case FU_DFU_STATE_DFU_DNLOAD_SYNC:
g_debug ("aborting transfer %s", fu_dfu_status_to_string (priv->status));
if (!fu_dfu_device_abort (self, error))
return FALSE;
break;
case FU_DFU_STATE_DFU_ERROR:
g_debug ("clearing error %s", fu_dfu_status_to_string (priv->status));
if (!fu_dfu_device_clear_status (self, error))
return FALSE;
break;
default:
break;
}
return TRUE;
}
/**
* fu_dfu_device_refresh:
* @self: a #FuDfuDevice
* @error: (nullable): optional return location for an error
*
* Refreshes the cached properties on the DFU device.
*
* Returns: %TRUE for success
**/
gboolean
fu_dfu_device_refresh (FuDfuDevice *self, GError **error)
{
FuDfuDevicePrivate *priv = GET_PRIVATE (self);
GUsbDevice *usb_device = fu_usb_device_get_dev (FU_USB_DEVICE (self));
gsize actual_length = 0;
guint8 buf[6];
g_autoptr(GError) error_local = NULL;
g_return_val_if_fail (FU_IS_DFU_DEVICE (self), FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
/* no backing USB device */
if (usb_device == NULL) {
g_set_error (error,
FWUPD_ERROR,
FWUPD_ERROR_INTERNAL,
"failed to refresh: no GUsbDevice for %s",
fu_dfu_device_get_platform_id (self));
return FALSE;
}
/* the device has no DFU runtime, so cheat */
if (priv->state == FU_DFU_STATE_APP_IDLE &&
fu_device_has_private_flag (FU_DEVICE (self), FU_DFU_DEVICE_FLAG_NO_DFU_RUNTIME))
return TRUE;
/* ensure interface is claimed */
if (!fu_dfu_device_ensure_interface (self, error))
return FALSE;
/* Device that cannot communicate via the USB after the
* Manifestation phase indicated this limitation to the
* host by clearing bmAttributes bit bitManifestationTolerant.
* so we assume the operation was successful */
if (priv->state == FU_DFU_STATE_DFU_MANIFEST &&
!(priv->attributes & FU_DFU_DEVICE_ATTR_MANIFEST_TOL))
return TRUE;
if (!g_usb_device_control_transfer (usb_device,
G_USB_DEVICE_DIRECTION_DEVICE_TO_HOST,
G_USB_DEVICE_REQUEST_TYPE_CLASS,
G_USB_DEVICE_RECIPIENT_INTERFACE,
FU_DFU_REQUEST_GETSTATUS,
0,
priv->iface_number,
buf, sizeof(buf), &actual_length,
priv->timeout_ms,
NULL, /* cancellable */
&error_local)) {
g_set_error (error,
FWUPD_ERROR,
FWUPD_ERROR_NOT_SUPPORTED,
"cannot get device state: %s",
error_local->message);
return FALSE;
}
if (actual_length != 6) {
g_set_error (error,
FWUPD_ERROR,
FWUPD_ERROR_INTERNAL,
"cannot get device status, invalid size: %04x",
(guint) actual_length);
return FALSE;
}
/* some devices use the wrong state value */
if (fu_device_has_private_flag (FU_DEVICE (self), FU_DFU_DEVICE_FLAG_FORCE_DFU_MODE) &&
fu_dfu_device_get_state (self) != FU_DFU_STATE_DFU_IDLE) {
g_debug ("quirking device into DFU mode");
fu_dfu_device_set_state (self, FU_DFU_STATE_DFU_IDLE);
} else {
fu_dfu_device_set_state (self, buf[4]);
}
/* status or state changed */
fu_dfu_device_set_status (self, buf[0]);
if (fu_device_has_private_flag (FU_DEVICE (self), FU_DFU_DEVICE_FLAG_IGNORE_POLLTIMEOUT)) {
priv->dnload_timeout = DFU_DEVICE_DNLOAD_TIMEOUT_DEFAULT;
} else {
priv->dnload_timeout = buf[1] +
(((guint32) buf[2]) << 8) +
(((guint32) buf[3]) << 16);
if (priv->dnload_timeout == 0) {
priv->dnload_timeout = DFU_DEVICE_DNLOAD_TIMEOUT_DEFAULT;
g_debug ("no dnload-timeout, using default of %ums",
priv->dnload_timeout);
}
}
g_debug ("refreshed status=%s and state=%s (dnload=%u)",
fu_dfu_status_to_string (priv->status),
fu_dfu_state_to_string (priv->state),
priv->dnload_timeout);
return TRUE;
}
static gboolean
fu_dfu_device_request_detach (FuDfuDevice *self, GError **error)
{
FuDfuDevicePrivate *priv = GET_PRIVATE (self);
GUsbDevice *usb_device = fu_usb_device_get_dev (FU_USB_DEVICE (self));
const guint16 timeout_reset_ms = 1000;
g_autoptr(GError) error_local = NULL;
if (!g_usb_device_control_transfer (usb_device,
G_USB_DEVICE_DIRECTION_HOST_TO_DEVICE,
G_USB_DEVICE_REQUEST_TYPE_CLASS,
G_USB_DEVICE_RECIPIENT_INTERFACE,
FU_DFU_REQUEST_DETACH,
timeout_reset_ms,
priv->iface_number,
NULL, 0, NULL,
priv->timeout_ms,
NULL, /* cancellable */
&error_local)) {
/* some devices just reboot and stall the endpoint :/ */
if (g_error_matches (error_local,
G_USB_DEVICE_ERROR,
G_USB_DEVICE_ERROR_NOT_SUPPORTED) ||
g_error_matches (error_local,
G_USB_DEVICE_ERROR,
G_USB_DEVICE_ERROR_FAILED)) {
g_debug ("ignoring while detaching: %s", error_local->message);
} else {
/* refresh the error code */
fu_dfu_device_error_fixup (self, &error_local);
g_set_error (error,
FWUPD_ERROR,
FWUPD_ERROR_NOT_SUPPORTED,
"cannot detach device: %s",
error_local->message);
return FALSE;
}
}
return TRUE;
}
static gboolean
fu_dfu_device_reload (FuDevice *device, GError **error)
{
FuDfuDevice *self = FU_DFU_DEVICE (device);
return fu_dfu_device_refresh_and_clear (self, error);
}
static gboolean
fu_dfu_device_detach (FuDevice *device, GError **error)
{
FuDfuDevice *self = FU_DFU_DEVICE (device);
FuDfuDevicePrivate *priv = GET_PRIVATE (self);
GUsbDevice *usb_device = fu_usb_device_get_dev (FU_USB_DEVICE (device));
g_return_val_if_fail (FU_IS_DFU_DEVICE (self), FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
/* already in DFU mode */
if (!fu_dfu_device_refresh_and_clear (self, error))
return FALSE;
if (fu_device_has_flag (device, FWUPD_DEVICE_FLAG_IS_BOOTLOADER))
return TRUE;
/* no backing USB device */
if (usb_device == NULL) {
g_set_error (error,
FWUPD_ERROR,
FWUPD_ERROR_INTERNAL,
"failed to detach: no GUsbDevice for %s",
fu_dfu_device_get_platform_id (self));
return FALSE;
}
/* the device has no DFU runtime, so cheat */
if (priv->state == FU_DFU_STATE_APP_IDLE &&
fu_device_has_private_flag (FU_DEVICE (self), FU_DFU_DEVICE_FLAG_NO_DFU_RUNTIME))
return TRUE;
/* ensure interface is claimed */
if (!fu_dfu_device_ensure_interface (self, error))
return FALSE;
/* inform UI there's going to be a detach:attach */
fu_device_set_status (device, FWUPD_STATUS_DEVICE_RESTART);
if (!fu_dfu_device_request_detach (self, error))
return FALSE;
/* do a host reset */
if ((priv->attributes & FU_DFU_DEVICE_ATTR_WILL_DETACH) == 0) {
g_debug ("doing device reset as host will not self-reset");
if (!fu_dfu_device_reset (self, error))
return FALSE;
}
/* success */
priv->force_version = 0x0;
fu_device_set_status (device, FWUPD_STATUS_IDLE);
fu_device_add_flag (device, FWUPD_DEVICE_FLAG_WAIT_FOR_REPLUG);
return TRUE;
}
/**
* fu_dfu_device_abort:
* @self: a #FuDfuDevice
* @error: (nullable): optional return location for an error
*
* Aborts any upload or download in progress.
*
* Returns: %TRUE for success
**/
gboolean
fu_dfu_device_abort (FuDfuDevice *self, GError **error)
{
FuDfuDevicePrivate *priv = GET_PRIVATE (self);
GUsbDevice *usb_device = fu_usb_device_get_dev (FU_USB_DEVICE (self));
g_autoptr(GError) error_local = NULL;
g_return_val_if_fail (FU_IS_DFU_DEVICE (self), FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
/* no backing USB device */
if (usb_device == NULL) {
g_set_error (error,
FWUPD_ERROR,
FWUPD_ERROR_INTERNAL,
"failed to abort: no GUsbDevice for %s",
fu_dfu_device_get_platform_id (self));
return FALSE;
}
/* the device has no DFU runtime, so cheat */
if (priv->state == FU_DFU_STATE_APP_IDLE &&
fu_device_has_private_flag (FU_DEVICE (self), FU_DFU_DEVICE_FLAG_NO_DFU_RUNTIME)) {
g_set_error_literal (error,
FWUPD_ERROR,
FWUPD_ERROR_NOT_SUPPORTED,
"not supported as no DFU runtime");
return FALSE;
}
/* ensure interface is claimed */
if (!fu_dfu_device_ensure_interface (self, error))
return FALSE;
if (!g_usb_device_control_transfer (usb_device,
G_USB_DEVICE_DIRECTION_HOST_TO_DEVICE,
G_USB_DEVICE_REQUEST_TYPE_CLASS,
G_USB_DEVICE_RECIPIENT_INTERFACE,
FU_DFU_REQUEST_ABORT,
0,
priv->iface_number,
NULL, 0, NULL,
priv->timeout_ms,
NULL, /* cancellable */
&error_local)) {
/* refresh the error code */
fu_dfu_device_error_fixup (self, &error_local);
g_set_error (error,
FWUPD_ERROR,
FWUPD_ERROR_NOT_SUPPORTED,
"cannot abort device: %s",
error_local->message);
return FALSE;
}
return TRUE;
}
/**
* fu_dfu_device_clear_status:
* @self: a #FuDfuDevice
* @error: (nullable): optional return location for an error
*
* Clears any error status on the DFU device.
*
* Returns: %TRUE for success
**/
gboolean
fu_dfu_device_clear_status (FuDfuDevice *self, GError **error)
{
FuDfuDevicePrivate *priv = GET_PRIVATE (self);
GUsbDevice *usb_device = fu_usb_device_get_dev (FU_USB_DEVICE (self));
g_autoptr(GError) error_local = NULL;
g_return_val_if_fail (FU_IS_DFU_DEVICE (self), FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
/* no backing USB device */
if (usb_device == NULL) {
g_set_error (error,
FWUPD_ERROR,
FWUPD_ERROR_INTERNAL,
"failed to clear status: no GUsbDevice for %s",
fu_dfu_device_get_platform_id (self));
return FALSE;
}
/* the device has no DFU runtime, so cheat */
if (priv->state == FU_DFU_STATE_APP_IDLE &&
fu_device_has_private_flag (FU_DEVICE (self), FU_DFU_DEVICE_FLAG_NO_DFU_RUNTIME)) {
g_set_error_literal (error,
FWUPD_ERROR,
FWUPD_ERROR_NOT_SUPPORTED,
"not supported as no DFU runtime");
return FALSE;
}
/* ensure interface is claimed */
if (!fu_dfu_device_ensure_interface (self, error))
return FALSE;
if (!g_usb_device_control_transfer (usb_device,
G_USB_DEVICE_DIRECTION_HOST_TO_DEVICE,
G_USB_DEVICE_REQUEST_TYPE_CLASS,
G_USB_DEVICE_RECIPIENT_INTERFACE,
FU_DFU_REQUEST_CLRSTATUS,
0,
priv->iface_number,
NULL, 0, NULL,
priv->timeout_ms,
NULL, /* cancellable */
&error_local)) {
/* refresh the error code */
fu_dfu_device_error_fixup (self, &error_local);
g_set_error (error,
FWUPD_ERROR,
FWUPD_ERROR_NOT_SUPPORTED,
"cannot clear status on the device: %s",
error_local->message);
return FALSE;
}
return TRUE;
}
/**
* fu_dfu_device_get_interface:
* @self: a #FuDfuDevice
*
* Gets the interface number.
**/
guint8
fu_dfu_device_get_interface (FuDfuDevice *self)
{
FuDfuDevicePrivate *priv = GET_PRIVATE (self);
g_return_val_if_fail (FU_IS_DFU_DEVICE (self), 0xff);
return priv->iface_number;
}
/**
* fu_dfu_device_open:
* @self: a #FuDfuDevice
* @error: (nullable): optional return location for an error
*
* Opens a DFU-capable device.
*
* Returns: %TRUE for success
**/
static gboolean
fu_dfu_device_open (FuDevice *device, GError **error)
{
FuDfuDevice *self = FU_DFU_DEVICE (device);
FuDfuDevicePrivate *priv = GET_PRIVATE (self);
GPtrArray *targets = fu_dfu_device_get_targets (self);
g_return_val_if_fail (FU_IS_DFU_DEVICE (device), FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
/* FuUsbDevice->open */
if (!FU_DEVICE_CLASS (fu_dfu_device_parent_class)->open (device, error))
return FALSE;
/* the device has no DFU runtime, so cheat */
if (priv->state == FU_DFU_STATE_APP_IDLE &&
fu_device_has_private_flag (FU_DEVICE (self), FU_DFU_DEVICE_FLAG_NO_DFU_RUNTIME)) {
fu_dfu_device_set_state (self, FU_DFU_STATE_APP_IDLE);
priv->status = FU_DFU_STATUS_OK;
}
/* GD32VF103 encodes the serial number in UTF-8 (rather than UTF-16)
* and also uses the first two bytes as the model identifier */
if (fu_device_has_private_flag (FU_DEVICE (self), FU_DFU_DEVICE_FLAG_GD32)) {
#if G_USB_CHECK_VERSION(0,3,6)
GUsbDevice *usb_device = fu_usb_device_get_dev (FU_USB_DEVICE (device));
const guint8 *buf;
gsize bufsz = 0;
guint16 langid = G_USB_DEVICE_LANGID_ENGLISH_UNITED_STATES;
guint8 idx = g_usb_device_get_serial_number_index (usb_device);
g_autofree gchar *chip_id = NULL;
g_autofree gchar *serial_str = NULL;
g_autoptr(GBytes) serial_blob = NULL;
serial_blob = g_usb_device_get_string_descriptor_bytes (usb_device,
idx,
langid,
error);
if (serial_blob == NULL)
return FALSE;
if (g_getenv ("FWUPD_DFU_VERBOSE") != NULL)
fu_common_dump_bytes (G_LOG_DOMAIN, "GD32 serial", serial_blob);
buf = g_bytes_get_data (serial_blob, &bufsz);
if (bufsz < 2) {
g_set_error_literal (error,
FWUPD_ERROR,
FWUPD_ERROR_NOT_SUPPORTED,
"GD32 serial number invalid");
return FALSE;
}
/* ID is first two bytes */
chip_id = g_strdup_printf ("%02x%02x", buf[0], buf[1]);
fu_dfu_device_set_chip_id (self, chip_id);
/* serial number follows */
serial_str = g_strndup ((const gchar *) buf + 2, bufsz - 2);
fu_device_set_serial (FU_DEVICE (device), serial_str);
#else
g_set_error (error,
FWUPD_ERROR,
FWUPD_ERROR_NOT_SUPPORTED,
"GUsb version %s too old to support GD32, "
"fwupd needs to be rebuilt against 0.3.6 or later",
g_usb_version_string ());
return FALSE;
#endif
}
/* set up target ready for use */
for (guint j = 0; j < targets->len; j++) {
FuDfuTarget *target = g_ptr_array_index (targets, j);
if (!fu_dfu_target_setup (target, error))
return FALSE;
}
/* success */
return TRUE;
}
/**
* fu_dfu_device_close:
* @self: a #FuDfuDevice
* @error: (nullable): optional return location for an error
*
* Closes a DFU device.
*
* Returns: %TRUE for success
**/
static gboolean
fu_dfu_device_close (FuDevice *device, GError **error)
{
FuDfuDevice *self = FU_DFU_DEVICE (device);
FuDfuDevicePrivate *priv = GET_PRIVATE (self);
GUsbDevice *usb_device = fu_usb_device_get_dev (FU_USB_DEVICE (device));
/* release interface */
if (priv->claimed_interface) {
g_autoptr(GError) error_local = NULL;
if (!g_usb_device_release_interface (usb_device,
(gint) priv->iface_number,
0, &error_local)) {
if (!g_error_matches (error_local,
G_USB_DEVICE_ERROR,
G_USB_DEVICE_ERROR_NO_DEVICE)) {
g_warning ("failed to release interface: %s",
error_local->message);
}
}
priv->claimed_interface = FALSE;
}
/* FuUsbDevice->close */
return FU_DEVICE_CLASS (fu_dfu_device_parent_class)->close (device, error);
}
static gboolean
fu_dfu_device_probe (FuDevice *device, GError **error)
{
FuDfuDevice *self = FU_DFU_DEVICE (device);
GUsbDevice *usb_device = fu_usb_device_get_dev (FU_USB_DEVICE (device));
/* FuUsbDevice->probe */
if (!FU_DEVICE_CLASS (fu_dfu_device_parent_class)->probe (device, error))
return FALSE;
/* add all the targets */
if (!fu_dfu_device_add_targets (self, error)) {
g_prefix_error (error, "%04x:%04x is not supported: ",
g_usb_device_get_vid (usb_device),
g_usb_device_get_pid (usb_device));
return FALSE;
}
/* check capabilities */
if (!fu_dfu_device_can_download (self)) {
g_warning ("%04x:%04x is missing download capability",
g_usb_device_get_vid (usb_device),
g_usb_device_get_pid (usb_device));
}
/* hardware from Jabra literally reboots if you try to retry a failed
* write -- there's no way to avoid blocking the daemon like this... */
if (fu_device_has_private_flag (FU_DEVICE (self), FU_DFU_DEVICE_FLAG_ATTACH_EXTRA_RESET))
fu_device_sleep_with_progress (device, 10); /* seconds */
/* success */
return TRUE;
}
/**
* fu_dfu_device_reset:
* @self: a #FuDfuDevice
* @error: (nullable): optional return location for an error
*
* Resets the USB device.
*
* Returns: %TRUE for success
**/
gboolean
fu_dfu_device_reset (FuDfuDevice *self, GError **error)
{
GUsbDevice *usb_device = fu_usb_device_get_dev (FU_USB_DEVICE (self));
g_autoptr(GError) error_local = NULL;
g_autoptr(GTimer) timer = g_timer_new ();
g_return_val_if_fail (FU_IS_DFU_DEVICE (self), FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
/* no backing USB device */
if (usb_device == NULL) {
g_set_error (error,
FWUPD_ERROR,
FWUPD_ERROR_INTERNAL,
"failed to reset: no GUsbDevice for %s",
fu_dfu_device_get_platform_id (self));
return FALSE;
}
if (!g_usb_device_reset (usb_device, &error_local)) {
g_set_error (error,
FWUPD_ERROR,
FWUPD_ERROR_NOT_SUPPORTED,
"cannot reset USB device: %s [%i]",
error_local->message,
error_local->code);
return FALSE;
}
g_debug ("reset took %.2lfms", g_timer_elapsed (timer, NULL) * 1000);
return TRUE;
}
static gboolean
fu_dfu_device_attach (FuDevice *device, GError **error)
{
FuDfuDevice *self = FU_DFU_DEVICE (device);
FuDfuDevicePrivate *priv = GET_PRIVATE (self);
g_autoptr(FuDfuTarget) target = NULL;
g_return_val_if_fail (FU_IS_DFU_DEVICE (device), FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
/* already in runtime mode */
if (!fu_dfu_device_refresh_and_clear (self, error))
return FALSE;
if (!fu_device_has_flag (device, FWUPD_DEVICE_FLAG_IS_BOOTLOADER))
return TRUE;
/* inform UI there's going to be a re-attach */
fu_device_set_status (device, FWUPD_STATUS_DEVICE_RESTART);
/* handle weirdness */
if (fu_device_has_private_flag (FU_DEVICE (self), FU_DFU_DEVICE_FLAG_DETACH_FOR_ATTACH)) {
if (!fu_dfu_device_request_detach (self, error))
return FALSE;
fu_device_set_status (device, FWUPD_STATUS_IDLE);
fu_device_add_flag (device, FWUPD_DEVICE_FLAG_WAIT_FOR_REPLUG);
return TRUE;
}
/* handle m-stack DFU bootloaders */
if (!priv->done_upload_or_download &&
fu_device_has_private_flag (FU_DEVICE (self), FU_DFU_DEVICE_FLAG_ATTACH_UPLOAD_DOWNLOAD)) {
g_autoptr(GBytes) chunk = NULL;
g_autoptr(FuDfuTarget) target_zero = NULL;
g_debug ("doing dummy upload to work around m-stack quirk");
target_zero = fu_dfu_device_get_target_by_alt_setting (self, 0, error);
if (target_zero == NULL)
return FALSE;
chunk = fu_dfu_target_upload_chunk (target_zero, 0, 0, error);
if (chunk == NULL)
return FALSE;
}
/* get default target */
target = fu_dfu_device_get_target_by_alt_setting (self, 0, error);
if (target == NULL)
return FALSE;
/* normal DFU mode just needs a bus reset */
if (fu_device_has_private_flag (FU_DEVICE (self), FU_DFU_DEVICE_FLAG_NO_BUS_RESET_ATTACH) &&
fu_dfu_device_has_attribute (self, FU_DFU_DEVICE_ATTR_WILL_DETACH))
g_debug ("Bus reset is not required. Device will reboot to normal");
else if (!fu_dfu_target_attach (target, error))
return FALSE;
/* success */
priv->force_version = 0x0;
fu_device_set_status (device, FWUPD_STATUS_IDLE);
fu_device_add_flag (device, FWUPD_DEVICE_FLAG_WAIT_FOR_REPLUG);
return TRUE;
}
static void
fu_dfu_device_percentage_cb (FuDfuTarget *target, guint percentage, FuDfuDevice *self)
{
fu_device_set_progress (FU_DEVICE (self), percentage);
}
static void
fu_dfu_device_action_cb (FuDfuTarget *target, FwupdStatus action, FuDfuDevice *self)
{
fu_device_set_status (FU_DEVICE (self), action);
}
/**
* fu_dfu_device_upload:
* @self: a #FuDfuDevice
* @flags: DFU target flags, e.g. %DFU_TARGET_TRANSFER_FLAG_VERIFY
* @error: (nullable): optional return location for an error
*
* Uploads firmware from the target to the host.
*
* Returns: (transfer full): the uploaded firmware, or %NULL for error
**/
FuFirmware *
fu_dfu_device_upload (FuDfuDevice *self,
FuDfuTargetTransferFlags flags,
GError **error)
{
FuDfuDevicePrivate *priv = GET_PRIVATE (self);
GUsbDevice *usb_device = fu_usb_device_get_dev (FU_USB_DEVICE (self));
g_autoptr(FuFirmware) firmware = NULL;
/* no backing USB device */
if (usb_device == NULL) {
g_set_error (error,
FWUPD_ERROR,
FWUPD_ERROR_INTERNAL,
"failed to upload: no GUsbDevice for %s",
fu_dfu_device_get_platform_id (self));
return NULL;
}
/* ensure interface is claimed */
if (!fu_dfu_device_ensure_interface (self, error))
return NULL;
/* choose the most appropriate type */
if (priv->targets->len > 1) {
firmware = fu_dfuse_firmware_new ();
g_debug ("switching to DefuSe automatically");
} else {
firmware = fu_dfu_firmware_new ();
}
fu_dfu_firmware_set_vid (FU_DFU_FIRMWARE (firmware), priv->runtime_vid);
fu_dfu_firmware_set_pid (FU_DFU_FIRMWARE (firmware), priv->runtime_pid);
fu_dfu_firmware_set_release (FU_DFU_FIRMWARE (firmware), 0xffff);
/* upload from each target */
for (guint i = 0; i < priv->targets->len; i++) {
FuDfuTarget *target;
const gchar *alt_name;
gulong id1;
gulong id2;
/* upload to target and proxy signals */
target = g_ptr_array_index (priv->targets, i);
/* ignore some target types */
alt_name = fu_dfu_target_get_alt_name_for_display (target, NULL);
if (g_strcmp0 (alt_name, "Option Bytes") == 0) {
g_debug ("ignoring target %s", alt_name);
continue;
}
id1 = g_signal_connect (target, "percentage-changed",
G_CALLBACK (fu_dfu_device_percentage_cb), self);
id2 = g_signal_connect (target, "action-changed",
G_CALLBACK (fu_dfu_device_action_cb), self);
if (!fu_dfu_target_upload (target,
firmware,
DFU_TARGET_TRANSFER_FLAG_NONE,
error))
return NULL;
g_signal_handler_disconnect (target, id1);
g_signal_handler_disconnect (target, id2);
}
/* do not do the dummy upload for quirked devices */
priv->done_upload_or_download = TRUE;
/* success */
fu_device_set_status (FU_DEVICE (self), FWUPD_STATUS_IDLE);
return g_object_ref (firmware);
}
static gboolean
fu_dfu_device_id_compatible (guint16 id_file, guint16 id_runtime, guint16 id_dev)
{
/* file doesn't specify */
if (id_file == 0xffff)
return TRUE;
/* runtime matches */
if (id_runtime != 0xffff && id_file == id_runtime)
return TRUE;
/* bootloader matches */
if (id_dev != 0xffff && id_file == id_dev)
return TRUE;
/* nothing */
return FALSE;
}
static gboolean
fu_dfu_device_download (FuDfuDevice *self,
FuFirmware *firmware,
FuDfuTargetTransferFlags flags,
GError **error)
{
FuDfuDevicePrivate *priv = GET_PRIVATE (self);
GUsbDevice *usb_device = fu_usb_device_get_dev (FU_USB_DEVICE (self));
gboolean ret;
g_autoptr(GPtrArray) images = NULL;
guint16 firmware_pid = 0xffff;
guint16 firmware_vid = 0xffff;
/* no backing USB device */
if (usb_device == NULL) {
g_set_error (error,
FWUPD_ERROR,
FWUPD_ERROR_INTERNAL,
"failed to download: no GUsbDevice for %s",
fu_dfu_device_get_platform_id (self));
return FALSE;
}
/* ensure interface is claimed */
if (!fu_dfu_device_ensure_interface (self, error))
return FALSE;
/* firmware supports footer? */
if (FU_IS_DFU_FIRMWARE (firmware)) {
firmware_vid = fu_dfu_firmware_get_vid (FU_DFU_FIRMWARE (firmware));
firmware_pid = fu_dfu_firmware_get_pid (FU_DFU_FIRMWARE (firmware));
} else {
flags |= DFU_TARGET_TRANSFER_FLAG_WILDCARD_VID;
flags |= DFU_TARGET_TRANSFER_FLAG_WILDCARD_PID;
}
/* do we allow wildcard VID:PID matches */
if ((flags & DFU_TARGET_TRANSFER_FLAG_WILDCARD_VID) == 0) {
if (firmware_vid == 0xffff) {
g_set_error (error,
FWUPD_ERROR,
FWUPD_ERROR_NOT_SUPPORTED,
"firmware vendor ID not specified");
return FALSE;
}
}
if ((flags & DFU_TARGET_TRANSFER_FLAG_WILDCARD_PID) == 0) {
if (firmware_pid == 0xffff) {
g_set_error (error,
FWUPD_ERROR,
FWUPD_ERROR_NOT_SUPPORTED,
"firmware product ID not specified");
return FALSE;
}
}
/* check vendor matches */
if (priv->runtime_vid != 0xffff) {
if (!fu_dfu_device_id_compatible (firmware_vid, priv->runtime_vid,
fu_usb_device_get_vid (FU_USB_DEVICE (self)))) {
g_set_error (error,
FWUPD_ERROR,
FWUPD_ERROR_NOT_SUPPORTED,
"vendor ID incorrect, expected 0x%04x "
"got 0x%04x and 0x%04x\n",
firmware_vid,
priv->runtime_vid,
fu_usb_device_get_vid (FU_USB_DEVICE (self)));
return FALSE;
}
}
/* check product matches */
if (priv->runtime_pid != 0xffff) {
if (!fu_dfu_device_id_compatible (firmware_pid, priv->runtime_pid,
fu_usb_device_get_pid (FU_USB_DEVICE (self)))) {
g_set_error (error,
FWUPD_ERROR,
FWUPD_ERROR_NOT_SUPPORTED,
"product ID incorrect, expected 0x%04x "
"got 0x%04x and 0x%04x",
firmware_pid,
priv->runtime_pid,
fu_usb_device_get_pid (FU_USB_DEVICE (self)));
return FALSE;
}
}
/* download each target */
images = fu_firmware_get_images (firmware);
if (images->len == 0)
g_ptr_array_add (images, g_object_ref (firmware));
for (guint i = 0; i < images->len; i++) {
FuFirmware *image = g_ptr_array_index (images, i);
FuDfuTargetTransferFlags flags_local = DFU_TARGET_TRANSFER_FLAG_NONE;
const gchar *alt_name;
guint8 alt;
gulong id1;
gulong id2;
g_autoptr(FuDfuTarget) target_tmp = NULL;
g_autoptr(GError) error_local = NULL;
alt = fu_firmware_get_idx (image);
target_tmp = fu_dfu_device_get_target_by_alt_setting (self, alt, error);
if (target_tmp == NULL)
return FALSE;
/* we don't actually need to print this */
alt_name = fu_dfu_target_get_alt_name (target_tmp, &error_local);
if (alt_name == NULL) {
if (g_error_matches (error_local, FWUPD_ERROR, FWUPD_ERROR_NOT_FOUND)) {
alt_name = "unknown";
} else {
g_propagate_error (error, g_steal_pointer (&error_local));
return FALSE;
}
}
g_debug ("downloading to target: %s", alt_name);
/* download onto target */
if (flags & DFU_TARGET_TRANSFER_FLAG_VERIFY)
flags_local = DFU_TARGET_TRANSFER_FLAG_VERIFY;
if (!FU_IS_DFU_FIRMWARE (firmware) ||
fu_dfu_firmware_get_version (FU_DFU_FIRMWARE (firmware)) == 0x0)
flags_local |= DFU_TARGET_TRANSFER_FLAG_ADDR_HEURISTIC;
id1 = g_signal_connect (target_tmp, "percentage-changed",
G_CALLBACK (fu_dfu_device_percentage_cb), self);
id2 = g_signal_connect (target_tmp, "action-changed",
G_CALLBACK (fu_dfu_device_action_cb), self);
ret = fu_dfu_target_download (target_tmp, image, flags_local, error);
g_signal_handler_disconnect (target_tmp, id1);
g_signal_handler_disconnect (target_tmp, id2);
if (!ret)
return FALSE;
}
/* do not do the dummy upload for quirked devices */
priv->done_upload_or_download = TRUE;
/* success */
fu_device_set_status (FU_DEVICE (self), FWUPD_STATUS_IDLE);
return TRUE;
}
void
fu_dfu_device_error_fixup (FuDfuDevice *self, GError **error)
{
FuDfuDevicePrivate *priv = GET_PRIVATE (self);
/* sad panda */
if (error == NULL)
return;
/* not the right error to query */
if (!g_error_matches (*error,
G_USB_DEVICE_ERROR,
G_USB_DEVICE_ERROR_NOT_SUPPORTED))
return;
/* get the status */
if (!fu_dfu_device_refresh (self, NULL))
return;
/* not in an error state */
if (priv->state != FU_DFU_STATE_DFU_ERROR)
return;
/* prefix the error */
switch (priv->status) {
case FU_DFU_STATUS_OK:
/* ignore */
break;
case FU_DFU_STATUS_ERR_VENDOR:
g_prefix_error (error, "read protection is active: ");
break;
default:
g_prefix_error (error, "[%s,%s]: ",
fu_dfu_state_to_string (priv->state),
fu_dfu_status_to_string (priv->status));
break;
}
}
static GBytes *
fu_dfu_device_dump_firmware (FuDevice *device, GError **error)
{
FuDfuDevice *self = FU_DFU_DEVICE (device);
g_autoptr(FuFirmware) firmware = NULL;
g_autoptr(FuDeviceLocker) locker = NULL;
/* require detach -> attach */
locker = fu_device_locker_new_full (device,
(FuDeviceLockerFunc) fu_device_detach,
(FuDeviceLockerFunc) fu_device_attach,
error);
if (locker == NULL)
return NULL;
/* get data from hardware */
g_debug ("uploading from device->host");
if (!fu_dfu_device_refresh_and_clear (self, error))
return NULL;
firmware = fu_dfu_device_upload (self, DFU_TARGET_TRANSFER_FLAG_NONE, error);
if (firmware == NULL)
return NULL;
/* get the checksum */
return fu_firmware_write (firmware, error);
}
static FuFirmware *
fu_dfu_device_prepare_firmware (FuDevice *device,
GBytes *fw,
FwupdInstallFlags flags,
GError **error)
{
return fu_firmware_new_from_gtypes (fw, flags, error,
FU_TYPE_DFUSE_FIRMWARE,
FU_TYPE_DFU_FIRMWARE,
FU_TYPE_FIRMWARE,
G_TYPE_INVALID);
}
static gboolean
fu_dfu_device_write_firmware (FuDevice *device,
FuFirmware *firmware,
FwupdInstallFlags flags,
GError **error)
{
FuDfuDevice *self = FU_DFU_DEVICE (device);
FuDfuTargetTransferFlags transfer_flags = DFU_TARGET_TRANSFER_FLAG_VERIFY;
/* open it */
if (!fu_dfu_device_refresh_and_clear (self, error))
return FALSE;
if (flags & FWUPD_INSTALL_FLAG_IGNORE_VID_PID) {
transfer_flags |= DFU_TARGET_TRANSFER_FLAG_WILDCARD_VID;
transfer_flags |= DFU_TARGET_TRANSFER_FLAG_WILDCARD_PID;
}
/* hit hardware */
return fu_dfu_device_download (self, firmware, transfer_flags, error);
}
static gboolean
fu_dfu_device_set_quirk_kv (FuDevice *device,
const gchar *key,
const gchar *value,
GError **error)
{
FuDfuDevice *self = FU_DFU_DEVICE (device);
FuDfuDevicePrivate *priv = GET_PRIVATE (self);
if (g_strcmp0 (key, FU_QUIRKS_DFU_FORCE_VERSION) == 0) {
if (value != NULL) {
gsize valuesz = strlen (value);
return fu_firmware_strparse_uint16_safe (value, valuesz, 0,
&priv->force_version,
error);
}
g_set_error_literal (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_DATA,
"invalid DFU version");
return FALSE;
}
if (g_strcmp0 (key, "DfuForceTimeout") == 0) {
guint64 tmp = fu_common_strtoull (value);
if (tmp < G_MAXUINT) {
priv->timeout_ms = tmp;
return TRUE;
}
g_set_error_literal (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_DATA,
"invalid DFU timeout");
return FALSE;
}
if (g_strcmp0 (key, "DfuForceTransferSize") == 0) {
guint64 tmp = fu_common_strtoull (value);
if (tmp < G_MAXUINT16) {
priv->force_transfer_size = tmp;
return TRUE;
}
g_set_error_literal (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_DATA,
"invalid DFU transfer size");
return FALSE;
}
if (g_strcmp0 (key, "DfuAltName") == 0) {
fu_dfu_device_set_chip_id (self, value);
return TRUE;
}
/* failed */
g_set_error_literal (error,
G_IO_ERROR,
G_IO_ERROR_NOT_SUPPORTED,
"quirk key not supported");
return FALSE;
}
/**
* fu_dfu_device_get_attributes_as_string: (skip)
* @self: a #FuDfuDevice
*
* Gets a string describing the attributes for a device.
*
* Returns: a string, possibly empty
**/
gchar *
fu_dfu_device_get_attributes_as_string (FuDfuDevice *self)
{
FuDfuDevicePrivate *priv = GET_PRIVATE (self);
GString *str;
/* just append to a string */
str = g_string_new ("");
if (priv->attributes & FU_DFU_DEVICE_ATTR_CAN_DOWNLOAD)
g_string_append_printf (str, "can-download|");
if (priv->attributes & FU_DFU_DEVICE_ATTR_CAN_UPLOAD)
g_string_append_printf (str, "can-upload|");
if (priv->attributes & FU_DFU_DEVICE_ATTR_MANIFEST_TOL)
g_string_append_printf (str, "manifest-tol|");
if (priv->attributes & FU_DFU_DEVICE_ATTR_WILL_DETACH)
g_string_append_printf (str, "will-detach|");
if (priv->attributes & FU_DFU_DEVICE_ATTR_CAN_ACCELERATE)
g_string_append_printf (str, "can-accelerate|");
/* remove trailing pipe */
g_string_truncate (str, str->len - 1);
return g_string_free (str, FALSE);
}
static void
fu_dfu_device_finalize (GObject *object)
{
FuDfuDevice *self = FU_DFU_DEVICE (object);
FuDfuDevicePrivate *priv = GET_PRIVATE (self);
g_free (priv->chip_id);
g_ptr_array_unref (priv->targets);
G_OBJECT_CLASS (fu_dfu_device_parent_class)->finalize (object);
}
static void
fu_dfu_device_class_init (FuDfuDeviceClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
FuDeviceClass *klass_device = FU_DEVICE_CLASS (klass);
klass_device->set_quirk_kv = fu_dfu_device_set_quirk_kv;
klass_device->to_string = fu_dfu_device_to_string;
klass_device->dump_firmware = fu_dfu_device_dump_firmware;
klass_device->write_firmware = fu_dfu_device_write_firmware;
klass_device->prepare_firmware = fu_dfu_device_prepare_firmware;
klass_device->attach = fu_dfu_device_attach;
klass_device->detach = fu_dfu_device_detach;
klass_device->reload = fu_dfu_device_reload;
klass_device->open = fu_dfu_device_open;
klass_device->close = fu_dfu_device_close;
klass_device->probe = fu_dfu_device_probe;
object_class->finalize = fu_dfu_device_finalize;
}
static void
fu_dfu_device_init (FuDfuDevice *self)
{
FuDfuDevicePrivate *priv = GET_PRIVATE (self);
priv->iface_number = 0xff;
priv->runtime_pid = 0xffff;
priv->runtime_vid = 0xffff;
priv->runtime_release = 0xffff;
priv->state = FU_DFU_STATE_APP_IDLE;
priv->status = FU_DFU_STATUS_OK;
priv->targets = g_ptr_array_new_with_free_func ((GDestroyNotify) g_object_unref);
priv->timeout_ms = 1500;
priv->transfer_size = 64;
fu_device_add_icon (FU_DEVICE (self), "drive-harddisk-usb");
fu_device_add_flag (FU_DEVICE (self), FWUPD_DEVICE_FLAG_UPDATABLE);
fu_device_add_flag (FU_DEVICE (self), FWUPD_DEVICE_FLAG_ADD_COUNTERPART_GUIDS);
fu_device_add_internal_flag (FU_DEVICE (self), FU_DEVICE_INTERNAL_FLAG_REPLUG_MATCH_GUID);
fu_device_set_remove_delay (FU_DEVICE (self), FU_DEVICE_REMOVE_DELAY_RE_ENUMERATE);
fu_device_register_private_flag (FU_DEVICE (self),
FU_DFU_DEVICE_FLAG_ATTACH_EXTRA_RESET,
"attach-extra-reset");
fu_device_register_private_flag (FU_DEVICE (self),
FU_DFU_DEVICE_FLAG_ATTACH_UPLOAD_DOWNLOAD,
"attach-upload-download");
fu_device_register_private_flag (FU_DEVICE (self),
FU_DFU_DEVICE_FLAG_FORCE_DFU_MODE,
"force-dfu-mode");
fu_device_register_private_flag (FU_DEVICE (self),
FU_DFU_DEVICE_FLAG_IGNORE_POLLTIMEOUT,
"ignore-polltimeout");
fu_device_register_private_flag (FU_DEVICE (self),
FU_DFU_DEVICE_FLAG_IGNORE_RUNTIME,
"ignore-runtime");
fu_device_register_private_flag (FU_DEVICE (self),
FU_DFU_DEVICE_FLAG_IGNORE_UPLOAD,
"ignore-upload");
fu_device_register_private_flag (FU_DEVICE (self),
FU_DFU_DEVICE_FLAG_NO_DFU_RUNTIME,
"no-dfu-runtime");
fu_device_register_private_flag (FU_DEVICE (self),
FU_DFU_DEVICE_FLAG_NO_GET_STATUS_UPLOAD,
"no-get-status-upload");
fu_device_register_private_flag (FU_DEVICE (self),
FU_DFU_DEVICE_FLAG_NO_PID_CHANGE,
"no-pid-change");
fu_device_register_private_flag (FU_DEVICE (self),
FU_DFU_DEVICE_FLAG_USE_ANY_INTERFACE,
"use-any-interface");
fu_device_register_private_flag (FU_DEVICE (self),
FU_DFU_DEVICE_FLAG_USE_ATMEL_AVR,
"use-atmel-avr");
fu_device_register_private_flag (FU_DEVICE (self),
FU_DFU_DEVICE_FLAG_USE_PROTOCOL_ZERO,
"use-protocol-zero");
fu_device_register_private_flag (FU_DEVICE (self),
FU_DFU_DEVICE_FLAG_LEGACY_PROTOCOL,
"legacy-protocol");
fu_device_register_private_flag (FU_DEVICE (self),
FU_DFU_DEVICE_FLAG_DETACH_FOR_ATTACH,
"detach-for-attach");
fu_device_register_private_flag (FU_DEVICE (self),
FU_DFU_DEVICE_FLAG_ABSENT_SECTOR_SIZE,
"absent-sector-size");
fu_device_register_private_flag (FU_DEVICE (self),
FU_DFU_DEVICE_FLAG_MANIFEST_POLL,
"manifest-poll");
fu_device_register_private_flag (FU_DEVICE (self),
FU_DFU_DEVICE_FLAG_NO_BUS_RESET_ATTACH,
"no-bus-reset-attach");
fu_device_register_private_flag (FU_DEVICE (self),
FU_DFU_DEVICE_FLAG_GD32,
"gd32");
}
Reference in New Issue View Git Blame Copy Permalink