proxmox-mirrors/fwupd
1
0
Fork 0
mirror of https://git.proxmox.com/git/fwupd synced 2025-05-19 19:55:54 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

vli: Rename FuVliUsbhubPdFirmware to FuVliPdFirmware

Browse Source 
This is used by non-usbhub devices too, albeit at offset 0x0.
This commit is contained in:
Richard Hughes 2019-12-17 11:11:30 +00:00
parent 617bd7025f
commit 8b5a560b1c
13 changed files with 119 additions and 105 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
plugins/vli/fu-plugin-vli.c
View File

@ -9,16 +9,16 @@
#include "fu-plugin-vfuncs.h"
#include "fu-hash.h"
#include "fu-vli-pd-firmware.h"
#include "fu-vli-usbhub-device.h"
#include "fu-vli-usbhub-firmware.h"
#include "fu-vli-usbhub-pd-firmware.h"
void
fu_plugin_init (FuPlugin *plugin)
{
fu_plugin_set_build_hash (plugin, FU_BUILD_HASH);
fu_plugin_add_firmware_gtype (plugin, "vli-usbhub", FU_TYPE_VLI_USBHUB_FIRMWARE);
fu_plugin_add_firmware_gtype (plugin, "vli-usbhub-pd", FU_TYPE_VLI_USBHUB_PD_FIRMWARE);
fu_plugin_add_firmware_gtype (plugin, "vli-pd", FU_TYPE_VLI_PD_FIRMWARE);
/* register the custom types */
g_type_ensure (FU_TYPE_VLI_USBHUB_DEVICE);

17
plugins/vli/fu-vli-common.c
View File

@ -113,3 +113,20 @@ fu_vli_common_device_kind_get_size (FuVliDeviceKind device_kind)
return 0x0;
}
guint32
fu_vli_common_device_kind_get_offset (FuVliDeviceKind device_kind)
{
if (device_kind == FU_VLI_DEVICE_KIND_VL100)
return 0x10000;
if (device_kind == FU_VLI_DEVICE_KIND_VL101)
return 0x10000;
if (device_kind == FU_VLI_DEVICE_KIND_VL102)
return 0x20000;
if (device_kind == FU_VLI_DEVICE_KIND_VL103)
return 0x20000;
if (device_kind == FU_VLI_DEVICE_KIND_VL104)
return 0x20000;
if (device_kind == FU_VLI_DEVICE_KIND_VL105)
return 0x20000;
return 0x0;
}

1
plugins/vli/fu-vli-common.h
View File

@ -39,6 +39,7 @@ typedef enum {
const gchar *fu_vli_common_device_kind_to_string (FuVliDeviceKind device_kind);
guint32 fu_vli_common_device_kind_get_size (FuVliDeviceKind device_kind);
guint32 fu_vli_common_device_kind_get_offset (FuVliDeviceKind device_kind);
guint8 fu_vli_common_crc8 (const guint8 *buf,
gsize bufsz);

22
plugins/vli/fu-vli-usbhub-pd-common.c → plugins/vli/fu-vli-pd-common.c
View File

@ -7,10 +7,10 @@
#include "config.h"
#include "fu-vli-usbhub-pd-common.h"
#include "fu-vli-pd-common.h"
FuVliDeviceKind
fu_vli_usbhub_pd_guess_device_kind (guint32 fwver)
fu_vli_pd_common_guess_device_kind (guint32 fwver)
{
guint32 tmp = (fwver & 0x0f000000) >> 24;
if (tmp == 0x01 || tmp == 0x02 || tmp == 0x03)
@ -27,21 +27,3 @@ fu_vli_usbhub_pd_guess_device_kind (guint32 fwver)
return FU_VLI_DEVICE_KIND_VL105;
return FU_VLI_DEVICE_KIND_UNKNOWN;
}
guint32
fu_vli_usbhub_pd_get_offset_for_device_kind (FuVliDeviceKind device_kind)
{
if (device_kind == FU_VLI_DEVICE_KIND_VL100)
return 0x10000;
if (device_kind == FU_VLI_DEVICE_KIND_VL101)
return 0x10000;
if (device_kind == FU_VLI_DEVICE_KIND_VL102)
return 0x20000;
if (device_kind == FU_VLI_DEVICE_KIND_VL103)
return 0x20000;
if (device_kind == FU_VLI_DEVICE_KIND_VL104)
return 0x20000;
if (device_kind == FU_VLI_DEVICE_KIND_VL105)
return 0x20000;
return 0x0;
}

20
plugins/vli/fu-vli-pd-common.h Normal file
View File

@ -0,0 +1,20 @@
/*
* Copyright (C) 2017-2019 VIA Corporation
* Copyright (C) 2019 Richard Hughes <richard@hughsie.com>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#pragma once
#include "fu-plugin.h"
#include "fu-vli-common.h"
typedef struct __attribute__ ((packed)) {
guint32 fwver; /* BE */
guint16 vid; /* LE */
guint16 pid; /* LE */
} FuVliPdHdr;
FuVliDeviceKind fu_vli_pd_common_guess_device_kind (guint32 fwver);

67
plugins/vli/fu-vli-usbhub-pd-firmware.c → plugins/vli/fu-vli-pd-firmware.c
View File

@ -7,65 +7,66 @@
#include "config.h"
#include "fu-vli-usbhub-pd-firmware.h"
#include "fu-vli-pd-common.h"
#include "fu-vli-pd-firmware.h"
struct _FuVliUsbhubPdFirmware {
struct _FuVliPdFirmware {
FuFirmwareClass parent_instance;
FuVliDeviceKind device_kind;
FuVliUsbhubPdHdr hdr;
FuVliPdHdr hdr;
GArray *offsets;
};
G_DEFINE_TYPE (FuVliUsbhubPdFirmware, fu_vli_usbhub_pd_firmware, FU_TYPE_FIRMWARE)
G_DEFINE_TYPE (FuVliPdFirmware, fu_vli_pd_firmware, FU_TYPE_FIRMWARE)
FuVliDeviceKind
fu_vli_usbhub_pd_firmware_get_kind (FuVliUsbhubPdFirmware *self)
fu_vli_pd_firmware_get_kind (FuVliPdFirmware *self)
{
g_return_val_if_fail (FU_IS_VLI_USBHUB_PD_FIRMWARE (self), 0);
g_return_val_if_fail (FU_IS_VLI_PD_FIRMWARE (self), 0);
return self->device_kind;
}
guint16
fu_vli_usbhub_pd_firmware_get_vid (FuVliUsbhubPdFirmware *self)
fu_vli_pd_firmware_get_vid (FuVliPdFirmware *self)
{
g_return_val_if_fail (FU_IS_VLI_USBHUB_PD_FIRMWARE (self), 0);
g_return_val_if_fail (FU_IS_VLI_PD_FIRMWARE (self), 0);
return GUINT16_FROM_LE (self->hdr.vid);
}
guint16
fu_vli_usbhub_pd_firmware_get_pid (FuVliUsbhubPdFirmware *self)
fu_vli_pd_firmware_get_pid (FuVliPdFirmware *self)
{
g_return_val_if_fail (FU_IS_VLI_USBHUB_PD_FIRMWARE (self), 0);
g_return_val_if_fail (FU_IS_VLI_PD_FIRMWARE (self), 0);
return GUINT16_FROM_LE (self->hdr.pid);
}
static void
fu_vli_usbhub_pd_firmware_to_string (FuFirmware *firmware, guint idt, GString *str)
fu_vli_pd_firmware_to_string (FuFirmware *firmware, guint idt, GString *str)
{
FuVliUsbhubPdFirmware *self = FU_VLI_USBHUB_PD_FIRMWARE (firmware);
FuVliPdFirmware *self = FU_VLI_PD_FIRMWARE (firmware);
fu_common_string_append_kv (str, idt, "DeviceKind",
fu_vli_common_device_kind_to_string (self->device_kind));
fu_common_string_append_kx (str, idt, "VID",
fu_vli_usbhub_pd_firmware_get_vid (self));
fu_vli_pd_firmware_get_vid (self));
fu_common_string_append_kx (str, idt, "PID",
fu_vli_usbhub_pd_firmware_get_pid (self));
fu_vli_pd_firmware_get_pid (self));
}
void
fu_vli_usbhub_pd_firmware_add_offset (FuVliUsbhubPdFirmware *self, gsize offset)
fu_vli_pd_firmware_add_offset (FuVliPdFirmware *self, gsize offset)
{
g_array_append_val (self->offsets, offset);
}
static gboolean
fu_vli_usbhub_pd_firmware_parse (FuFirmware *firmware,
GBytes *fw,
guint64 addr_start,
guint64 addr_end,
FwupdInstallFlags flags,
GError **error)
fu_vli_pd_firmware_parse (FuFirmware *firmware,
GBytes *fw,
guint64 addr_start,
guint64 addr_end,
FwupdInstallFlags flags,
GError **error)
{
FuVliUsbhubPdFirmware *self = FU_VLI_USBHUB_PD_FIRMWARE (firmware);
FuVliPdFirmware *self = FU_VLI_PD_FIRMWARE (firmware);
gsize bufsz = 0;
guint32 fwver;
const guint8 *buf = g_bytes_get_data (fw, &bufsz);
@ -96,7 +97,7 @@ fu_vli_usbhub_pd_firmware_parse (FuFirmware *firmware,
/* guess device kind from fwver */
fwver = GUINT32_FROM_BE (self->hdr.fwver);
self->device_kind = fu_vli_usbhub_pd_guess_device_kind (fwver);
self->device_kind = fu_vli_pd_common_guess_device_kind (fwver);
if (self->device_kind == FU_VLI_DEVICE_KIND_UNKNOWN) {
g_set_error (error,
FWUPD_ERROR,
@ -144,31 +145,31 @@ fu_vli_usbhub_pd_firmware_parse (FuFirmware *firmware,
}
static void
fu_vli_usbhub_pd_firmware_init (FuVliUsbhubPdFirmware *self)
fu_vli_pd_firmware_init (FuVliPdFirmware *self)
{
self->offsets = g_array_new (FALSE, FALSE, sizeof(gsize));
}
static void
fu_vli_usbhub_pd_firmware_finalize (GObject *object)
fu_vli_pd_firmware_finalize (GObject *object)
{
FuVliUsbhubPdFirmware *self = FU_VLI_USBHUB_PD_FIRMWARE (object);
FuVliPdFirmware *self = FU_VLI_PD_FIRMWARE (object);
g_array_unref (self->offsets);
G_OBJECT_CLASS (fu_vli_usbhub_pd_firmware_parent_class)->finalize (object);
G_OBJECT_CLASS (fu_vli_pd_firmware_parent_class)->finalize (object);
}
static void
fu_vli_usbhub_pd_firmware_class_init (FuVliUsbhubPdFirmwareClass *klass)
fu_vli_pd_firmware_class_init (FuVliPdFirmwareClass *klass)
{
FuFirmwareClass *klass_firmware = FU_FIRMWARE_CLASS (klass);
GObjectClass *object_class = G_OBJECT_CLASS (klass);
klass_firmware->parse = fu_vli_usbhub_pd_firmware_parse;
klass_firmware->to_string = fu_vli_usbhub_pd_firmware_to_string;
object_class->finalize = fu_vli_usbhub_pd_firmware_finalize;
klass_firmware->parse = fu_vli_pd_firmware_parse;
klass_firmware->to_string = fu_vli_pd_firmware_to_string;
object_class->finalize = fu_vli_pd_firmware_finalize;
}
FuFirmware *
fu_vli_usbhub_pd_firmware_new (void)
fu_vli_pd_firmware_new (void)
{
return FU_FIRMWARE (g_object_new (FU_TYPE_VLI_USBHUB_PD_FIRMWARE, NULL));
return FU_FIRMWARE (g_object_new (FU_TYPE_VLI_PD_FIRMWARE, NULL));
}

22
plugins/vli/fu-vli-pd-firmware.h Normal file
View File

@ -0,0 +1,22 @@
/*
* Copyright (C) 2017-2019 VIA Corporation
* Copyright (C) 2019 Richard Hughes <richard@hughsie.com>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#pragma once
#include "fu-firmware.h"
#include "fu-vli-common.h"
#define FU_TYPE_VLI_PD_FIRMWARE (fu_vli_pd_firmware_get_type ())
G_DECLARE_FINAL_TYPE (FuVliPdFirmware, fu_vli_pd_firmware, FU, VLI_PD_FIRMWARE, FuFirmware)
FuFirmware *fu_vli_pd_firmware_new (void);
FuVliDeviceKind fu_vli_pd_firmware_get_kind (FuVliPdFirmware *self);
guint16 fu_vli_pd_firmware_get_vid (FuVliPdFirmware *self);
guint16 fu_vli_pd_firmware_get_pid (FuVliPdFirmware *self);
void fu_vli_pd_firmware_add_offset (FuVliPdFirmware *self,
gsize offset);

2
plugins/vli/fu-vli-usbhub-device.c
View File

@ -778,7 +778,7 @@ fu_vli_usbhub_device_probe (FuDevice *device, GError **error)
static gboolean
fu_vli_usbhub_device_pd_setup (FuVliUsbhubDevice *self, GError **error)
{
FuVliUsbhubPdHdr hdr = { 0x0 };
FuVliPdHdr hdr = { 0x0 };
g_autoptr(FuDevice) dev = NULL;
g_autoptr(GError) error_local = NULL;

11
plugins/vli/fu-vli-usbhub-pd-common.h
View File

@ -9,16 +9,5 @@
#include "fu-plugin.h"
#include "fu-vli-common.h"
typedef struct __attribute__ ((packed)) {
guint32 fwver; /* BE */
guint16 vid; /* LE */
guint16 pid; /* LE */
} FuVliUsbhubPdHdr;
#define VLI_USBHUB_PD_FLASHMAP_ADDR_LEGACY 0x4000
#define VLI_USBHUB_PD_FLASHMAP_ADDR 0x1003
guint32 fu_vli_usbhub_pd_get_offset_for_device_kind (FuVliDeviceKind device_kind);
FuVliDeviceKind fu_vli_usbhub_pd_guess_device_kind (guint32 fwver);

28
plugins/vli/fu-vli-usbhub-pd-device.c
View File

@ -9,16 +9,18 @@
#include <string.h>
#include "fu-vli-pd-common.h"
#include "fu-vli-pd-firmware.h"
#include "fu-vli-usbhub-common.h"
#include "fu-vli-usbhub-device.h"
#include "fu-vli-usbhub-pd-common.h"
#include "fu-vli-usbhub-pd-device.h"
#include "fu-vli-usbhub-pd-firmware.h"
struct _FuVliUsbhubPdDevice
{
FuDevice parent_instance;
FuVliUsbhubPdHdr hdr;
FuVliPdHdr hdr;
FuVliDeviceKind device_kind;
};
@ -31,7 +33,7 @@ fu_vli_usbhub_pd_device_to_string (FuDevice *device, guint idt, GString *str)
fu_common_string_append_kv (str, idt, "DeviceKind",
fu_vli_common_device_kind_to_string (self->device_kind));
fu_common_string_append_kx (str, idt, "FwOffset",
fu_vli_usbhub_pd_get_offset_for_device_kind (self->device_kind));
fu_vli_common_device_kind_get_offset (self->device_kind));
fu_common_string_append_kx (str, idt, "FwSize",
fu_vli_common_device_kind_get_size (self->device_kind));
}
@ -47,7 +49,7 @@ fu_vli_usbhub_pd_device_probe (FuDevice *device, GError **error)
/* get version */
fwver = GUINT32_FROM_BE (self->hdr.fwver);
self->device_kind = fu_vli_usbhub_pd_guess_device_kind (fwver);
self->device_kind = fu_vli_pd_common_guess_device_kind (fwver);
if (self->device_kind == FU_VLI_DEVICE_KIND_UNKNOWN) {
g_set_error (error,
FWUPD_ERROR,
@ -68,7 +70,7 @@ fu_vli_usbhub_pd_device_probe (FuDevice *device, GError **error)
fu_device_add_instance_id (device, instance_id1);
/* these have a backup section */
if (fu_vli_usbhub_pd_get_offset_for_device_kind (self->device_kind) == VLI_USBHUB_FLASHMAP_ADDR_PD)
if (fu_vli_common_device_kind_get_offset (self->device_kind) == VLI_USBHUB_FLASHMAP_ADDR_PD)
fu_device_add_flag (FU_DEVICE (self), FWUPD_DEVICE_FLAG_SELF_RECOVERY);
/* success */
@ -83,11 +85,11 @@ fu_vli_usbhub_pd_device_prepare_firmware (FuDevice *device,
{
FuVliUsbhubPdDevice *self = FU_VLI_USBHUB_PD_DEVICE (device);
FuVliDeviceKind device_kind;
g_autoptr(FuFirmware) firmware = fu_vli_usbhub_pd_firmware_new ();
g_autoptr(FuFirmware) firmware = fu_vli_pd_firmware_new ();
/* add the two offset locations the header can be found */
fu_vli_usbhub_pd_firmware_add_offset (FU_VLI_USBHUB_PD_FIRMWARE (firmware), VLI_USBHUB_PD_FLASHMAP_ADDR_LEGACY);
fu_vli_usbhub_pd_firmware_add_offset (FU_VLI_USBHUB_PD_FIRMWARE (firmware), VLI_USBHUB_PD_FLASHMAP_ADDR);
fu_vli_pd_firmware_add_offset (FU_VLI_PD_FIRMWARE (firmware), VLI_USBHUB_PD_FLASHMAP_ADDR_LEGACY);
fu_vli_pd_firmware_add_offset (FU_VLI_PD_FIRMWARE (firmware), VLI_USBHUB_PD_FLASHMAP_ADDR);
/* check size */
if (g_bytes_get_size (fw) < fu_device_get_firmware_size_min (device)) {
@ -113,7 +115,7 @@ fu_vli_usbhub_pd_device_prepare_firmware (FuDevice *device,
fu_device_set_status (device, FWUPD_STATUS_DECOMPRESSING);
if (!fu_firmware_parse (firmware, fw, flags, error))
return NULL;
device_kind = fu_vli_usbhub_pd_firmware_get_kind (FU_VLI_USBHUB_PD_FIRMWARE (firmware));
device_kind = fu_vli_pd_firmware_get_kind (FU_VLI_PD_FIRMWARE (firmware));
if (self->device_kind != device_kind) {
g_set_error (error,
FWUPD_ERROR,
@ -145,7 +147,7 @@ fu_vli_usbhub_pd_device_read_firmware (FuDevice *device, GError **error)
/* read */
fu_device_set_status (FU_DEVICE (device), FWUPD_STATUS_DEVICE_VERIFY);
fw = fu_vli_usbhub_device_spi_read (parent,
fu_vli_usbhub_pd_get_offset_for_device_kind (self->device_kind),
fu_vli_common_device_kind_get_offset (self->device_kind),
fu_device_get_firmware_size_max (device),
error);
if (fw == NULL)
@ -180,7 +182,7 @@ fu_vli_usbhub_pd_device_write_firmware (FuDevice *device,
fu_device_set_status (device, FWUPD_STATUS_DEVICE_ERASE);
buf = g_bytes_get_data (fw, &bufsz);
if (!fu_vli_usbhub_device_spi_erase (parent,
fu_vli_usbhub_pd_get_offset_for_device_kind (self->device_kind),
fu_vli_common_device_kind_get_offset (self->device_kind),
bufsz,
error))
return FALSE;
@ -188,7 +190,7 @@ fu_vli_usbhub_pd_device_write_firmware (FuDevice *device,
/* write */
fu_device_set_status (device, FWUPD_STATUS_DEVICE_WRITE);
if (!fu_vli_usbhub_device_spi_write (parent,
fu_vli_usbhub_pd_get_offset_for_device_kind (self->device_kind),
fu_vli_common_device_kind_get_offset (self->device_kind),
buf,
bufsz,
error))
@ -221,7 +223,7 @@ fu_vli_usbhub_pd_device_class_init (FuVliUsbhubPdDeviceClass *klass)
}
FuDevice *
fu_vli_usbhub_pd_device_new (FuVliUsbhubPdHdr *hdr)
fu_vli_usbhub_pd_device_new (FuVliPdHdr *hdr)
{
FuVliUsbhubPdDevice *self = g_object_new (FU_TYPE_VLI_USBHUB_PD_DEVICE, NULL);
memcpy (&self->hdr, hdr, sizeof(self->hdr));

4
plugins/vli/fu-vli-usbhub-pd-device.h
View File

@ -8,6 +8,8 @@
#include "fu-plugin.h"
#include "fu-vli-pd-common.h"
#define FU_TYPE_VLI_USBHUB_PD_DEVICE (fu_vli_usbhub_pd_device_get_type ())
G_DECLARE_FINAL_TYPE (FuVliUsbhubPdDevice, fu_vli_usbhub_pd_device, FU, VLI_USBHUB_PD_DEVICE, FuDevice)
@ -16,4 +18,4 @@ struct _FuVliUsbhubPdDeviceClass
FuDeviceClass parent_class;
};
FuDevice *fu_vli_usbhub_pd_device_new (FuVliUsbhubPdHdr *hdr);
FuDevice *fu_vli_usbhub_pd_device_new (FuVliPdHdr *hdr);

22
plugins/vli/fu-vli-usbhub-pd-firmware.h
View File

@ -1,22 +0,0 @@
/*
* Copyright (C) 2017-2019 VIA Corporation
* Copyright (C) 2019 Richard Hughes <richard@hughsie.com>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#pragma once
#include "fu-firmware.h"
#include "fu-vli-usbhub-pd-common.h"
#define FU_TYPE_VLI_USBHUB_PD_FIRMWARE (fu_vli_usbhub_pd_firmware_get_type ())
G_DECLARE_FINAL_TYPE (FuVliUsbhubPdFirmware, fu_vli_usbhub_pd_firmware, FU, VLI_USBHUB_PD_FIRMWARE, FuFirmware)
FuFirmware *fu_vli_usbhub_pd_firmware_new (void);
FuVliDeviceKind fu_vli_usbhub_pd_firmware_get_kind (FuVliUsbhubPdFirmware *self);
guint16 fu_vli_usbhub_pd_firmware_get_vid (FuVliUsbhubPdFirmware *self);
guint16 fu_vli_usbhub_pd_firmware_get_pid (FuVliUsbhubPdFirmware *self);
void fu_vli_usbhub_pd_firmware_add_offset (FuVliUsbhubPdFirmware *self,
gsize offset);

4
plugins/vli/meson.build
View File

@ -13,14 +13,14 @@ shared_module('fu_plugin_vli',
'fu-plugin-vli.c',
'fu-vli-common.c',
'fu-vli-device.c',
'fu-vli-pd-common.c',
'fu-vli-pd-firmware.c',
'fu-vli-usbhub-common.c',
'fu-vli-usbhub-device.c',
'fu-vli-usbhub-firmware.c',
'fu-vli-usbhub-i2c-common.c',
'fu-vli-usbhub-i2c-device.c',
'fu-vli-usbhub-pd-common.c',
'fu-vli-usbhub-pd-device.c',
'fu-vli-usbhub-pd-firmware.c',
],
include_directories : [
root_incdir,