proxmox-mirrors/fwupd
1
0
Fork 0
mirror of https://git.proxmox.com/git/fwupd synced 2025-05-28 04:47:52 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
d7bedc20af
fwupd/plugins/hailuck/fu-hailuck-bl-device.c
Richard Hughes 40cd18fa97 Allow using a per-device global percentage completion 
It's actually quite hard to build a front-end for fwupd at the moment
as you're never sure when the progress bar is going to zip back to 0%
and start all over again. Some plugins go 0..100% for write, others
go 0..100% for erase, then again for write, then *again* for verify.

By creating a helper object we can easily split up the progress of the
specific task, e.g. write_firmware().

We can encode at the plugin level "the erase takes 50% of the time, the
write takes 40% and the read takes 10%". This means we can have a
progressbar which goes up just once at a consistent speed.
2021-09-13 14:28:15 +01:00

327 lines
9.1 KiB
C
Raw Blame History

/*
* Copyright (C) 2020 Richard Hughes <richard@hughsie.com>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#include "config.h"
#include <fwupdplugin.h>
#include "fu-hailuck-bl-device.h"
#include "fu-hailuck-common.h"
#include "fu-hailuck-kbd-firmware.h"
struct _FuHailuckBlDevice {
FuHidDevice parent_instance;
};
G_DEFINE_TYPE(FuHailuckBlDevice, fu_hailuck_bl_device, FU_TYPE_HID_DEVICE)
static gboolean
fu_hailuck_bl_device_attach(FuDevice *device, FuProgress *progress, GError **error)
{
guint8 buf[6] = {
FU_HAILUCK_REPORT_ID_SHORT,
FU_HAILUCK_CMD_ATTACH,
};
if (!fu_hid_device_set_report(FU_HID_DEVICE(device),
buf[0],
buf,
sizeof(buf),
1000,
FU_HID_DEVICE_FLAG_IS_FEATURE,
error))
return FALSE;
if (!g_usb_device_reset(fu_usb_device_get_dev(FU_USB_DEVICE(device)), error))
return FALSE;
fu_device_add_flag(device, FWUPD_DEVICE_FLAG_WAIT_FOR_REPLUG);
return TRUE;
}
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;
}
static gboolean
fu_hailuck_bl_device_read_block_start(FuHailuckBlDevice *self, guint32 length, GError **error)
{
guint8 buf[6] = {
FU_HAILUCK_REPORT_ID_SHORT,
FU_HAILUCK_CMD_READ_BLOCK_START,
};
fu_common_write_uint16(buf + 4, length, G_LITTLE_ENDIAN);
return fu_hid_device_set_report(FU_HID_DEVICE(self),
buf[0],
buf,
sizeof(buf),
100,
FU_HID_DEVICE_FLAG_IS_FEATURE,
error);
}
static gboolean
fu_hailuck_bl_device_read_block(FuHailuckBlDevice *self,
guint8 *data,
gsize data_sz,
GError **error)
{
gsize bufsz = data_sz + 2;
g_autofree guint8 *buf = g_malloc0(bufsz);
buf[0] = FU_HAILUCK_REPORT_ID_LONG;
buf[1] = FU_HAILUCK_CMD_READ_BLOCK;
if (!fu_hid_device_get_report(FU_HID_DEVICE(self),
buf[0],
buf,
bufsz,
2000,
FU_HID_DEVICE_FLAG_IS_FEATURE,
error))
return FALSE;
if (!fu_memcpy_safe(data,
data_sz,
0x0, /* dst */
buf,
bufsz,
0x02, /* src */
data_sz,
error))
return FALSE;
/* success */
g_usleep(10000);
return TRUE;
}
static GBytes *
fu_hailuck_bl_device_dump_firmware(FuDevice *device, FuProgress *progress, GError **error)
{
FuHailuckBlDevice *self = FU_HAILUCK_BL_DEVICE(device);
gsize fwsz = fu_device_get_firmware_size_max(device);
g_autoptr(GByteArray) fwbuf = g_byte_array_new();
g_autoptr(GPtrArray) chunks = NULL;
/* tell device amount of data to send */
fu_progress_set_status(progress, FWUPD_STATUS_DEVICE_READ);
if (!fu_hailuck_bl_device_read_block_start(self, fwsz, error))
return NULL;
/* receive data back */
fu_byte_array_set_size(fwbuf, fwsz);
chunks = fu_chunk_array_mutable_new(fwbuf->data, fwbuf->len, 0x0, 0x0, 2048);
for (guint i = 0; i < chunks->len; i++) {
FuChunk *chk = g_ptr_array_index(chunks, i);
if (!fu_hailuck_bl_device_read_block(self,
fu_chunk_get_data_out(chk),
fu_chunk_get_data_sz(chk),
error))
return NULL;
fu_progress_set_percentage_full(progress, i + 1, chunks->len);
}
/* success */
return g_byte_array_free_to_bytes(g_steal_pointer(&fwbuf));
}
static gboolean
fu_hailuck_bl_device_erase(FuHailuckBlDevice *self, FuProgress *progress, GError **error)
{
guint8 buf[6] = {
FU_HAILUCK_REPORT_ID_SHORT,
FU_HAILUCK_CMD_ERASE,
};
if (!fu_hid_device_set_report(FU_HID_DEVICE(self),
buf[0],
buf,
sizeof(buf),
100,
FU_HID_DEVICE_FLAG_IS_FEATURE,
error))
return FALSE;
fu_progress_sleep(progress, 2000);
return TRUE;
}
static gboolean
fu_hailuck_bl_device_write_block_start(FuHailuckBlDevice *self, guint32 length, GError **error)
{
guint8 buf[6] = {
FU_HAILUCK_REPORT_ID_SHORT,
FU_HAILUCK_CMD_WRITE_BLOCK_START,
};
fu_common_write_uint16(buf + 4, length, G_LITTLE_ENDIAN);
return fu_hid_device_set_report(FU_HID_DEVICE(self),
buf[0],
buf,
sizeof(buf),
100,
FU_HID_DEVICE_FLAG_IS_FEATURE,
error);
}
static gboolean
fu_hailuck_bl_device_write_block(FuHailuckBlDevice *self,
const guint8 *data,
gsize data_sz,
GError **error)
{
gsize bufsz = data_sz + 2;
g_autofree guint8 *buf = g_malloc0(bufsz);
buf[0] = FU_HAILUCK_REPORT_ID_LONG;
buf[1] = FU_HAILUCK_CMD_WRITE_BLOCK;
if (!fu_memcpy_safe(buf,
bufsz,
0x02, /* dst */
data,
data_sz,
0x0, /* src */
data_sz,
error))
return FALSE;
if (!fu_hid_device_set_report(FU_HID_DEVICE(self),
buf[0],
buf,
bufsz,
2000,
FU_HID_DEVICE_FLAG_IS_FEATURE,
error))
return FALSE;
/* success */
g_usleep(10000);
return TRUE;
}
static FuFirmware *
fu_hailuck_bl_device_prepare_firmware(FuDevice *device,
GBytes *fw,
FwupdInstallFlags flags,
GError **error)
{
g_autoptr(FuFirmware) firmware = fu_hailuck_kbd_firmware_new();
if (!fu_firmware_parse(firmware, fw, flags, error))
return NULL;
return g_steal_pointer(&firmware);
}
static gboolean
fu_hailuck_bl_device_write_firmware(FuDevice *device,
FuFirmware *firmware,
FuProgress *progress,
FwupdInstallFlags flags,
GError **error)
{
FuHailuckBlDevice *self = FU_HAILUCK_BL_DEVICE(device);
FuChunk *chk0;
g_autoptr(GBytes) fw = NULL;
g_autoptr(GBytes) fw_new = NULL;
g_autoptr(GPtrArray) chunks = NULL;
g_autofree guint8 *chk0_data = NULL;
/* progress */
fu_progress_set_id(progress, G_STRLOC);
fu_progress_add_flag(progress, FU_PROGRESS_FLAG_GUESSED);
fu_progress_add_step(progress, FWUPD_STATUS_DEVICE_ERASE, 10);
fu_progress_add_step(progress, FWUPD_STATUS_DEVICE_WRITE, 80);
fu_progress_add_step(progress, FWUPD_STATUS_DEVICE_WRITE, 1); /* block 0 */
fu_progress_add_step(progress, FWUPD_STATUS_DEVICE_VERIFY, 9);
/* get default image */
fw = fu_firmware_get_bytes(firmware, error);
if (fw == NULL)
return FALSE;
/* erase all contents */
if (!fu_hailuck_bl_device_erase(self, fu_progress_get_child(progress), error))
return FALSE;
fu_progress_step_done(progress);
/* tell device amount of data to expect */
if (!fu_hailuck_bl_device_write_block_start(self, g_bytes_get_size(fw), error))
return FALSE;
/* build packets */
chunks = fu_chunk_array_new_from_bytes(fw, 0x0, 0x00, 2048);
/* intentionally corrupt first chunk so that CRC fails */
chk0 = g_ptr_array_index(chunks, 0);
chk0_data = fu_memdup_safe(fu_chunk_get_data(chk0), fu_chunk_get_data_sz(chk0), error);
if (chk0_data == NULL)
return FALSE;
chk0_data[0] = 0x00;
if (!fu_hailuck_bl_device_write_block(self, chk0_data, fu_chunk_get_data_sz(chk0), error))
return FALSE;
/* send the rest of the chunks */
for (guint i = 1; i < chunks->len; i++) {
FuChunk *chk = g_ptr_array_index(chunks, i);
if (!fu_hailuck_bl_device_write_block(self,
fu_chunk_get_data(chk),
fu_chunk_get_data_sz(chk),
error))
return FALSE;
fu_progress_set_percentage_full(fu_progress_get_child(progress),
i + 1,
chunks->len);
}
fu_progress_step_done(progress);
/* retry write of first block */
if (!fu_hailuck_bl_device_write_block_start(self, g_bytes_get_size(fw), error))
return FALSE;
if (!fu_hailuck_bl_device_write_block(self,
fu_chunk_get_data(chk0),
fu_chunk_get_data_sz(chk0),
error))
return FALSE;
fu_progress_step_done(progress);
/* verify */
fw_new = fu_hailuck_bl_device_dump_firmware(device, fu_progress_get_child(progress), error);
fu_progress_step_done(progress);
return fu_common_bytes_compare(fw, fw_new, error);
}
static void
fu_hailuck_bl_device_init(FuHailuckBlDevice *self)
{
fu_device_set_firmware_size(FU_DEVICE(self), 0x4000);
fu_device_add_protocol(FU_DEVICE(self), "com.hailuck.kbd");
fu_device_set_name(FU_DEVICE(self), "Keyboard [bootloader]");
fu_device_add_flag(FU_DEVICE(self), FWUPD_DEVICE_FLAG_IS_BOOTLOADER);
fu_device_add_flag(FU_DEVICE(self), FWUPD_DEVICE_FLAG_INTERNAL);
fu_device_add_flag(FU_DEVICE(self), FWUPD_DEVICE_FLAG_UPDATABLE);
fu_device_add_internal_flag(FU_DEVICE(self), FU_DEVICE_INTERNAL_FLAG_REPLUG_MATCH_GUID);
fu_device_add_icon(FU_DEVICE(self), "input-keyboard");
fu_hid_device_add_flag(FU_HID_DEVICE(self), FU_HID_DEVICE_FLAG_NO_KERNEL_REBIND);
fu_device_set_remove_delay(FU_DEVICE(self), FU_DEVICE_REMOVE_DELAY_RE_ENUMERATE);
}
static void
fu_hailuck_bl_device_class_init(FuHailuckBlDeviceClass *klass)
{
FuDeviceClass *klass_device = FU_DEVICE_CLASS(klass);
klass_device->dump_firmware = fu_hailuck_bl_device_dump_firmware;
klass_device->prepare_firmware = fu_hailuck_bl_device_prepare_firmware;
klass_device->write_firmware = fu_hailuck_bl_device_write_firmware;
klass_device->attach = fu_hailuck_bl_device_attach;
klass_device->probe = fu_hailuck_bl_device_probe;
}
Reference in New Issue View Git Blame Copy Permalink