proxmox-mirrors/fwupd
1
0
Fork 0
mirror of https://git.proxmox.com/git/fwupd synced 2025-08-13 21:09:47 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Build many more plugins as builtin

Browse Source 
This reduces the plugin directory size by 2.2Mb
This commit is contained in:
Richard Hughes 2022-09-23 15:59:11 +01:00
parent 439c364f46
commit 99002a7a18
322 changed files with 5446 additions and 5077 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

106
contrib/fwupd.spec.in
View File

@ -427,115 +427,9 @@ done
%{_libdir}/fwupd-%{fwupdplugin_version}/libfwupdpluginbuiltin.so
%{_libdir}/fwupd-%{fwupdplugin_version}/libfwupdplugin.so
%{_libdir}/fwupd-%{fwupdplugin_version}/libfwupdutil.so
%ifarch i686 x86_64
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_acpi_facp.so
%endif
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_acpi_phat.so
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_amt.so
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_analogix.so
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_android_boot.so
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_ata.so
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_bcm57xx.so
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_cfu.so
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_ccgx.so
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_ch341a.so
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_corsair.so
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_cros_ec.so
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_cpu.so
%if 0%{?have_dell}
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_dell.so
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_dell_esrt.so
%endif
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_dell_dock.so
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_dfu.so
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_dfu_csr.so
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_ebitdo.so
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_elantp.so
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_elanfp.so
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_emmc.so
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_ep963x.so
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_fastboot.so
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_focalfp.so
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_fpc.so
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_fresco_pd.so
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_genesys.so
%if 0%{?have_gpio}
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_gpio.so
%endif
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_hailuck.so
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_intel_usb4.so
%ifarch i686 x86_64
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_iommu.so
%endif
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_jabra.so
%if 0%{?have_uefi}
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_lenovo_thinklmi.so
%endif
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_linux_lockdown.so
%ifarch i686 x86_64
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_linux_sleep.so
%endif
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_linux_swap.so
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_linux_tainted.so
%if 0%{?have_msr}
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_acpi_dmar.so
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_acpi_ivrs.so
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_msr.so
%endif
%ifarch i686 x86_64
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_amd_pmc.so
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_pci_psp.so
%endif
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_mtd.so
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_nitrokey.so
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_nordic_hid.so
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_nvme.so
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_optionrom.so
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_parade_lspcon.so
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_pci_bcr.so
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_pci_mei.so
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_pixart_rf.so
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_realtek_mst.so
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_redfish.so
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_rts54hid.so
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_rts54hub.so
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_scsi.so
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_steelseries.so
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_superio.so
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_synaptics_mst.so
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_synaptics_cape.so
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_synaptics_cxaudio.so
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_synaptics_prometheus.so
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_synaptics_rmi.so
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_system76_launch.so
%if 0%{?enable_dummy}
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_test.so
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_test_ble.so
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_invalid.so
%endif
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_thelio_io.so
%if 0%{?have_thunderbolt}
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_thunderbolt.so
%endif
%if 0%{?have_uefi}
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_tpm.so
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_bios.so
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_uefi_capsule.so
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_uefi_dbx.so
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_uefi_pk.so
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_uefi_recovery.so
%endif
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_usi_dock.so
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_vbe.so
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_logind.so
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_logitech_bulkcontroller.so
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_logitech_hidpp.so
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_uf2.so
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_upower.so
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_vli.so
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_wacom_raw.so
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_wacom_usb.so
%{_libdir}/fwupd-%{fwupdplugin_version}/libfu_plugin_goodixmoc.so
%ghost %{_localstatedir}/lib/fwupd/gnupg
%if 0%{?have_modem_manager}

150
docs/tutorial.md
View File

@ -4,7 +4,7 @@ title: Plugin Tutorial
## Introduction
At the heart of fwupd is a plugin loader that gets run at startup, when devices
At the heart of fwupd are plugins that gets run at startup, when devices
get hotplugged and when updates are done.
The idea is we have lots of small plugins that each do one thing, and are
ordered by dependencies against each other at runtime.
@ -16,51 +16,48 @@ There are broadly 3 types of plugin methods:
- **Mechanism**: Upload binary data into a specific hardware device.
- **Policy**: Control the system when updates are happening, e.g. preventing the
user from powering-off.
- **Helpers**: Providing more metadata about devices, for instance handling
- device quirks.
In general, building things out-of-tree isn't something that we think is a very
good idea; the API and ABI *internal* to fwupd is still changing and there's a
huge benefit to getting plugins upstream where they can undergo review and be
ported as the API adapts.
For this reason we don't install the plugin headers onto the system, although
you can of course just install the `.so` binary file manually.
- **Helpers**: Providing more metadata about devices, for instance handling device quirks.
A plugin only needs to define the vfuncs that are required, and the plugin name
is taken automatically from the suffix of the `.so` file.
is taken automatically from the GType.
/*
* Copyright (C) 2017 Richard Hughes <richard@hughsie.com>
/* fu-foo-plugin.h
*
* Copyright (C) 2022 Richard Hughes <richard@hughsie.com>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#pragma once
#include <fwupdplugin.h>
struct FuPluginData {
G_DECLARE_FINAL_TYPE(FuFooPlugin, fu_foo_plugin, FU, FOO_PLUGIN, FuPlugin)
/* fu-foo-plugin.c
*
* Copyright (C) Richard Hughes <richard@hughsie.com>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#include "config.h"
#include "fu-foo-plugin.h"
struct _FuFooPlugin {
FuPlugin parent_instance;
gpointer proxy;
};
static void
fu_plugin_foo_init(FuPlugin *plugin)
{
fu_plugin_add_rule(plugin, FU_PLUGIN_RULE_RUN_BEFORE, "dfu");
fu_plugin_alloc_data(plugin, sizeof(FuPluginData));
}
static void
fu_plugin_foo_destroy(FuPlugin *plugin)
{
FuPluginData *data = fu_plugin_get_data(plugin);
destroy_proxy(data->proxy);
}
G_DEFINE_TYPE(FuFooPlugin, fu_foo_plugin, FU_TYPE_PLUGIN)
static gboolean
fu_plugin_foo_startup(FuPlugin *plugin, FuProgress *progress, GError **error)
fu_foo_plugin_startup(FuPlugin *plugin, FuProgress *progress, GError **error)
{
FuPluginData *data = fu_plugin_get_data(plugin);
data->proxy = create_proxy();
if(data->proxy == NULL) {
self->proxy = create_proxy();
if(self->proxy == NULL) {
g_set_error(error, FWUPD_ERROR, FWUPD_ERROR_NOT_SUPPORTED,
"failed to create proxy");
return FALSE;
@ -68,13 +65,36 @@ is taken automatically from the suffix of the `.so` file.
return TRUE;
}
void
fu_plugin_init_vfuncs(FuPluginVfuncs *vfuncs)
static void
fu_foo_plugin_init(FuFooPlugin *self)
{
vfuncs->build_hash = FU_BUILD_HASH;
vfuncs->init = fu_plugin_foo_init;
vfuncs->destroy = fu_plugin_foo_destroy;
vfuncs->startup = fu_plugin_foo_startup;
}
static void
fu_foo_constructed(GObject *obj)
{
FuPlugin *plugin = FU_PLUGIN(obj);
FuContext *ctx = fu_plugin_get_context(plugin);
fu_plugin_add_rule(plugin, FU_PLUGIN_RULE_RUN_BEFORE, "dfu");
}
static void
fu_foo_finalize(GObject *obj)
{
FuFooPlugin *self = FU_FOO_PLUGIN(obj);
destroy_proxy(self->proxy);
G_OBJECT_CLASS(fu_foo_plugin_parent_class)->finalize(obj);
}
static void
fu_foo_plugin_class_init(FuFooPluginClass *klass)
{
FuPluginClass *plugin_class = FU_PLUGIN_CLASS(klass);
GObjectClass *object_class = G_OBJECT_CLASS(klass);
object_class->constructed = fu_foo_constructed;
object_class->finalize = fu_foo_finalize;
plugin_class->startup = fu_foo_plugin_startup;
}
We have to define when our plugin is run in reference to other plugins, in this
@ -92,7 +112,7 @@ derive the details about the `FuDevice` from the hardware, for example reading
data from `sysfs` or `/dev`.
static gboolean
fu_plugin_foo_coldplug(FuPlugin *plugin, FuProgress *progress, GError **error)
fu_foo_plugin_coldplug(FuPlugin *plugin, FuProgress *progress, GError **error)
{
g_autoptr(FuDevice) dev = NULL;
fu_device_set_id(dev, "dummy-1:2:3");
@ -106,11 +126,11 @@ data from `sysfs` or `/dev`.
return TRUE;
}
void
fu_plugin_init_vfuncs(FuPluginVfuncs *vfuncs)
static void
fu_foo_plugin_class_init(FuFooPluginClass *klass)
{
…
vfuncs->coldplug = fu_plugin_foo_coldplug;
plugin_class->coldplug = fu_foo_plugin_coldplug;
…
}
@ -161,7 +181,7 @@ When this is done the daemon checks the update for compatibility with the device
and then calls the vfuncs to update the device.
static gboolean
fu_plugin_foo_write_firmware(FuPlugin *plugin,
fu_foo_plugin_write_firmware(FuPlugin *plugin,
FuDevice *dev,
GBytes *blob_fw,
FuProgress *progress,
@ -174,11 +194,11 @@ and then calls the vfuncs to update the device.
return TRUE;
}
void
fu_plugin_init_vfuncs(FuPluginVfuncs *vfuncs)
static void
fu_foo_plugin_class_init(FuFooPluginClass *klass)
{
…
vfuncs->write_firmware = fu_plugin_foo_write_firmware;
plugin_class->write_firmware = fu_foo_plugin_write_firmware;
…
}
@ -198,7 +218,7 @@ certain threshold, or it could be as complicated as ensuring a vendor-specific
GPIO is asserted when specific types of hardware are updated.
static gboolean
fu_plugin_foo_prepare(FuPlugin *plugin, FuDevice *device, GError **error)
fu_foo_plugin_prepare(FuPlugin *plugin, FuDevice *device, GError **error)
{
if (fu_device_has_flag(device, FWUPD_DEVICE_FLAG_REQUIRE_AC && !on_ac_power()) {
g_set_error_literal(error,
@ -212,18 +232,18 @@ GPIO is asserted when specific types of hardware are updated.
}
static gboolean
fu_plugin_foo_cleanup(FuPlugin *plugin, FuDevice *device, GError **error)
fu_foo_plugin_cleanup(FuPlugin *plugin, FuDevice *device, GError **error)
{
return g_file_set_contents("/var/lib/fwupd/something",
fu_device_get_id(device), -1, error);
}
void
fu_plugin_init_vfuncs(FuPluginVfuncs *vfuncs)
static void
fu_foo_plugin_class_init(FuFooPluginClass *klass)
{
…
vfuncs->prepare = fu_plugin_foo_prepare;
vfuncs->cleanup = fu_plugin_foo_cleanup;
plugin_class->prepare = fu_foo_plugin_prepare;
plugin_class->cleanup = fu_foo_plugin_cleanup;
…
}
@ -247,7 +267,7 @@ handle the device ID, although the registered plugin can change during the
attach and detach phases.
static gboolean
fu_plugin_foo_detach(FuPlugin *plugin, FuDevice *device, FuProgress *progress, GError **error)
fu_foo_plugin_detach(FuPlugin *plugin, FuDevice *device, FuProgress *progress, GError **error)
{
if (hardware_in_bootloader)
return TRUE;
@ -255,7 +275,7 @@ attach and detach phases.
}
static gboolean
fu_plugin_foo_attach(FuPlugin *plugin, FuDevice *device, FuProgress *progress, GError **error)
fu_foo_plugin_attach(FuPlugin *plugin, FuDevice *device, FuProgress *progress, GError **error)
{
if (!hardware_in_bootloader)
return TRUE;
@ -263,7 +283,7 @@ attach and detach phases.
}
static gboolean
fu_plugin_foo_reload(FuPlugin *plugin, FuDevice *device, GError **error)
fu_foo_plugin_reload(FuPlugin *plugin, FuDevice *device, GError **error)
{
g_autofree gchar *version = _get_version(plugin, device, error);
if (version == NULL)
@ -272,13 +292,13 @@ attach and detach phases.
return TRUE;
}
void
fu_plugin_init_vfuncs(FuPluginVfuncs *vfuncs)
static void
fu_foo_plugin_class_init(FuFooPluginClass *klass)
{
…
vfuncs->detach = fu_plugin_foo_detach;
vfuncs->attach = fu_plugin_foo_attach;
vfuncs->reload = fu_plugin_foo_reload;
plugin_class->detach = fu_foo_plugin_detach;
plugin_class->attach = fu_foo_plugin_attach;
plugin_class->reload = fu_foo_plugin_reload;
…
}
@ -438,24 +458,24 @@ backend (USB or BlueZ).
### Creating a new plugin
The bare minimum a plugin should have is a `fu_plugin_init` function that
The bare minimum a plugin should have is a `constructed` function that
defines the plugin characteristics such as the device type and firmware
type handled by it, the build hash and any plugin-specific quirk keys
that can be used for the plugin.
void
fu_plugin_steelseries_init(FuPlugin *plugin)
static void
fu_foo_plugin_constructed(GObject *obj)
{
FuPlugin *plugin = FU_PLUGIN(obj);
FuContext *ctx = fu_plugin_get_context(plugin);
fu_plugin_add_device_gtype(plugin, FU_TYPE_STEELSERIES_MOUSE);
fu_plugin_add_device_gtype(plugin, FU_TYPE_STEELSERIES_GAMEPAD);
}
void
fu_plugin_init_vfuncs(FuPluginVfuncs *vfuncs)
static void
fu_foo_plugin_class_init(FuFooPluginClass *klass)
{
vfuncs->build_hash = FU_BUILD_HASH;
vfuncs->init = fu_plugin_steelseries_init;
plugin_class->init = fu_foo_plugin_constructed;
}
### Creating a new device type

2
libfwupdplugin/fu-plugin-private.h
View File

@ -26,8 +26,6 @@ guint
fu_plugin_get_priority(FuPlugin *self);
void
fu_plugin_set_priority(FuPlugin *self, guint priority);
void
fu_plugin_set_name(FuPlugin *self, const gchar *name);
gchar *
fu_plugin_to_string(FuPlugin *self);
void

2
libfwupdplugin/fu-plugin.h
View File

@ -424,6 +424,8 @@ typedef struct FuPluginData FuPluginData;
/* for plugins to use */
const gchar *
fu_plugin_get_name(FuPlugin *self);
void
fu_plugin_set_name(FuPlugin *self, const gchar *name);
FuPluginData *
fu_plugin_get_data(FuPlugin *self);
FuPluginData *

24
plugins/acpi-dmar/fu-plugin-acpi-dmar.c → plugins/acpi-dmar/fu-acpi-dmar-plugin.c
View File

@ -6,12 +6,17 @@
#include "config.h"
#include <fwupdplugin.h>
#include "fu-acpi-dmar-plugin.h"
#include "fu-acpi-dmar.h"
struct _FuAcpiDmarPlugin {
FuPlugin parent_instance;
};
G_DEFINE_TYPE(FuAcpiDmarPlugin, fu_acpi_dmar_plugin, FU_TYPE_PLUGIN)
static void
fu_plugin_acpi_dmar_add_security_attrs(FuPlugin *plugin, FuSecurityAttrs *attrs)
fu_acpi_dmar_plugin_add_security_attrs(FuPlugin *plugin, FuSecurityAttrs *attrs)
{
g_autofree gchar *fn = NULL;
g_autofree gchar *path = NULL;
@ -55,9 +60,14 @@ fu_plugin_acpi_dmar_add_security_attrs(FuPlugin *plugin, FuSecurityAttrs *attrs)
fwupd_security_attr_add_flag(attr, FWUPD_SECURITY_ATTR_FLAG_SUCCESS);
}
void
fu_plugin_init_vfuncs(FuPluginVfuncs *vfuncs)
static void
fu_acpi_dmar_plugin_init(FuAcpiDmarPlugin *self)
{
vfuncs->build_hash = FU_BUILD_HASH;
vfuncs->add_security_attrs = fu_plugin_acpi_dmar_add_security_attrs;
}
static void
fu_acpi_dmar_plugin_class_init(FuAcpiDmarPluginClass *klass)
{
FuPluginClass *plugin_class = FU_PLUGIN_CLASS(klass);
plugin_class->add_security_attrs = fu_acpi_dmar_plugin_add_security_attrs;
}

11
plugins/acpi-dmar/fu-acpi-dmar-plugin.h Normal file
View File

@ -0,0 +1,11 @@
/*
* Copyright (C) 2022 Richard Hughes <richard@hughsie.com>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#pragma once
#include <fwupdplugin.h>
G_DECLARE_FINAL_TYPE(FuAcpiDmarPlugin, fu_acpi_dmar_plugin, FU, ACPI_DMAR_PLUGIN, FuPlugin)

39
plugins/acpi-dmar/meson.build
View File

@ -1,28 +1,17 @@
if hsi and (host_cpu == 'x86' or host_cpu == 'x86_64')
cargs = ['-DG_LOG_DOMAIN="FuPluginAcpiDmar"']
shared_module('fu_plugin_acpi_dmar',
fu_hash,
plugin_builtin_acpi_dmar = static_library('fu_plugin_acpi_dmar',
sources: [
'fu-plugin-acpi-dmar.c',
'fu-acpi-dmar-plugin.c',
'fu-acpi-dmar.c',
],
include_directories: [
root_incdir,
fwupd_incdir,
fwupdplugin_incdir,
],
install: true,
install_dir: plugin_dir,
link_with: [
fwupd,
fwupdplugin,
],
include_directories: plugin_incdirs,
link_with: plugin_libs,
c_args: cargs,
dependencies: [
plugin_deps,
],
dependencies: plugin_deps,
)
plugin_builtins += plugin_builtin_acpi_dmar
if get_option('tests')
env = environment()
@ -30,22 +19,14 @@ if get_option('tests')
env.set('G_TEST_BUILDDIR', meson.current_build_dir())
e = executable(
'acpi-dmar-self-test',
fu_hash,
sources: [
'fu-self-test.c',
'fu-acpi-dmar.c',
],
include_directories: [
root_incdir,
fwupd_incdir,
fwupdplugin_incdir,
],
dependencies: [
plugin_deps,
],
include_directories: plugin_incdirs,
dependencies: plugin_deps,
link_with: [
fwupd,
fwupdplugin,
plugin_libs,
plugin_builtin_acpi_dmar,
],
install: true,
install_rpath: plugin_dir,

24
plugins/acpi-facp/fu-plugin-acpi-facp.c → plugins/acpi-facp/fu-acpi-facp-plugin.c
View File

@ -6,12 +6,17 @@
#include "config.h"
#include <fwupdplugin.h>
#include "fu-acpi-facp-plugin.h"
#include "fu-acpi-facp.h"
struct _FuAcpiFacpPlugin {
FuPlugin parent_instance;
};
G_DEFINE_TYPE(FuAcpiFacpPlugin, fu_acpi_facp_plugin, FU_TYPE_PLUGIN)
static void
fu_plugin_acpi_facp_add_security_attrs(FuPlugin *plugin, FuSecurityAttrs *attrs)
fu_acpi_facp_plugin_add_security_attrs(FuPlugin *plugin, FuSecurityAttrs *attrs)
{
g_autofree gchar *fn = NULL;
g_autofree gchar *path = NULL;
@ -55,9 +60,14 @@ fu_plugin_acpi_facp_add_security_attrs(FuPlugin *plugin, FuSecurityAttrs *attrs)
fwupd_security_attr_add_flag(attr, FWUPD_SECURITY_ATTR_FLAG_SUCCESS);
}
void
fu_plugin_init_vfuncs(FuPluginVfuncs *vfuncs)
static void
fu_acpi_facp_plugin_init(FuAcpiFacpPlugin *self)
{
vfuncs->build_hash = FU_BUILD_HASH;
vfuncs->add_security_attrs = fu_plugin_acpi_facp_add_security_attrs;
}
static void
fu_acpi_facp_plugin_class_init(FuAcpiFacpPluginClass *klass)
{
FuPluginClass *plugin_class = FU_PLUGIN_CLASS(klass);
plugin_class->add_security_attrs = fu_acpi_facp_plugin_add_security_attrs;
}

11
plugins/acpi-facp/fu-acpi-facp-plugin.h Normal file
View File

@ -0,0 +1,11 @@
/*
* Copyright (C) 2022 Richard Hughes <richard@hughsie.com>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#pragma once
#include <fwupdplugin.h>
G_DECLARE_FINAL_TYPE(FuAcpiFacpPlugin, fu_acpi_facp_plugin, FU, ACPI_FACP_PLUGIN, FuPlugin)

39
plugins/acpi-facp/meson.build
View File

@ -1,28 +1,17 @@
if hsi and (host_cpu == 'x86' or host_cpu == 'x86_64')
cargs = ['-DG_LOG_DOMAIN="FuPluginAcpiFacp"']
shared_module('fu_plugin_acpi_facp',
fu_hash,
plugin_builtin_acpi_facp = static_library('fu_plugin_acpi_facp',
sources: [
'fu-plugin-acpi-facp.c',
'fu-acpi-facp-plugin.c',
'fu-acpi-facp.c',
],
include_directories: [
root_incdir,
fwupd_incdir,
fwupdplugin_incdir,
],
install: true,
install_dir: plugin_dir,
link_with: [
fwupd,
fwupdplugin,
],
include_directories: plugin_incdirs,
link_with: plugin_libs,
c_args: cargs,
dependencies: [
plugin_deps,
],
dependencies: plugin_deps,
)
plugin_builtins += plugin_builtin_acpi_facp
if get_option('tests')
env = environment()
@ -30,22 +19,14 @@ if get_option('tests')
env.set('G_TEST_BUILDDIR', meson.current_build_dir())
e = executable(
'acpi-facp-self-test',
fu_hash,
sources: [
'fu-self-test.c',
'fu-acpi-facp.c',
],
include_directories: [
root_incdir,
fwupd_incdir,
fwupdplugin_incdir,
],
dependencies: [
plugin_deps,
],
include_directories: plugin_incdirs,
dependencies: plugin_deps,
link_with: [
fwupd,
fwupdplugin,
plugin_libs,
plugin_builtin_acpi_facp,
],
install: true,
install_rpath: plugin_dir,

24
plugins/acpi-ivrs/fu-plugin-acpi-ivrs.c → plugins/acpi-ivrs/fu-acpi-ivrs-plugin.c
View File

@ -7,12 +7,17 @@
#include "config.h"
#include <fwupdplugin.h>
#include "fu-acpi-ivrs-plugin.h"
#include "fu-acpi-ivrs.h"
struct _FuAcpiIvrsPlugin {
FuPlugin parent_instance;
};
G_DEFINE_TYPE(FuAcpiIvrsPlugin, fu_acpi_ivrs_plugin, FU_TYPE_PLUGIN)
static void
fu_plugin_acpi_ivrs_add_security_attrs(FuPlugin *plugin, FuSecurityAttrs *attrs)
fu_acpi_ivrs_plugin_add_security_attrs(FuPlugin *plugin, FuSecurityAttrs *attrs)
{
g_autofree gchar *fn = NULL;
g_autofree gchar *path = NULL;
@ -56,9 +61,14 @@ fu_plugin_acpi_ivrs_add_security_attrs(FuPlugin *plugin, FuSecurityAttrs *attrs)
fwupd_security_attr_add_flag(attr, FWUPD_SECURITY_ATTR_FLAG_SUCCESS);
}
void
fu_plugin_init_vfuncs(FuPluginVfuncs *vfuncs)
static void
fu_acpi_ivrs_plugin_init(FuAcpiIvrsPlugin *self)
{
vfuncs->build_hash = FU_BUILD_HASH;
vfuncs->add_security_attrs = fu_plugin_acpi_ivrs_add_security_attrs;
}
static void
fu_acpi_ivrs_plugin_class_init(FuAcpiIvrsPluginClass *klass)
{
FuPluginClass *plugin_class = FU_PLUGIN_CLASS(klass);
plugin_class->add_security_attrs = fu_acpi_ivrs_plugin_add_security_attrs;
}

11
plugins/acpi-ivrs/fu-acpi-ivrs-plugin.h Normal file
View File

@ -0,0 +1,11 @@
/*
* Copyright (C) 2022 Richard Hughes <richard@hughsie.com>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#pragma once
#include <fwupdplugin.h>
G_DECLARE_FINAL_TYPE(FuAcpiIvrsPlugin, fu_acpi_ivrs_plugin, FU, ACPI_IVRS_PLUGIN, FuPlugin)

39
plugins/acpi-ivrs/meson.build
View File

@ -1,28 +1,17 @@
if hsi and (host_cpu == 'x86' or host_cpu == 'x86_64')
cargs = ['-DG_LOG_DOMAIN="FuPluginAcpiIvrs"']
shared_module('fu_plugin_acpi_ivrs',
fu_hash,
plugin_builtin_acpi_ivrs = static_library('fu_plugin_acpi_ivrs',
sources: [
'fu-plugin-acpi-ivrs.c',
'fu-acpi-ivrs-plugin.c',
'fu-acpi-ivrs.c',
],
include_directories: [
root_incdir,
fwupd_incdir,
fwupdplugin_incdir,
],
install: true,
install_dir: plugin_dir,
link_with: [
fwupd,
fwupdplugin,
],
include_directories: plugin_incdirs,
link_with: plugin_libs,
c_args: cargs,
dependencies: [
plugin_deps,
],
dependencies: plugin_deps,
)
plugin_builtins += plugin_builtin_acpi_ivrs
if get_option('tests')
env = environment()
@ -30,22 +19,14 @@ if get_option('tests')
env.set('G_TEST_BUILDDIR', meson.current_build_dir())
e = executable(
'acpi-ivrs-self-test',
fu_hash,
sources: [
'fu-self-test.c',
'fu-acpi-ivrs.c',
],
include_directories: [
root_incdir,
fwupd_incdir,
fwupdplugin_incdir,
],
dependencies: [
plugin_deps,
],
include_directories: plugin_incdirs,
dependencies: plugin_deps,
link_with: [
fwupd,
fwupdplugin,
plugin_libs,
plugin_builtin_acpi_ivrs,
],
install: true,
install_rpath: plugin_dir,

45
plugins/acpi-phat/fu-plugin-acpi-phat.c → plugins/acpi-phat/fu-acpi-phat-plugin.c
View File

@ -6,24 +6,20 @@
#include "config.h"
#include <fwupdplugin.h>
#include "fu-acpi-phat-health-record.h"
#include "fu-acpi-phat-plugin.h"
#include "fu-acpi-phat-version-element.h"
#include "fu-acpi-phat-version-record.h"
#include "fu-acpi-phat.h"
static void
fu_plugin_acpi_phat_init(FuPlugin *plugin)
{
fu_plugin_add_firmware_gtype(plugin, NULL, FU_TYPE_ACPI_PHAT);
fu_plugin_add_firmware_gtype(plugin, NULL, FU_TYPE_ACPI_PHAT_HEALTH_RECORD);
fu_plugin_add_firmware_gtype(plugin, NULL, FU_TYPE_ACPI_PHAT_VERSION_ELEMENT);
fu_plugin_add_firmware_gtype(plugin, NULL, FU_TYPE_ACPI_PHAT_VERSION_RECORD);
}
struct _FuAcpiPhatPlugin {
FuPlugin parent_instance;
};
G_DEFINE_TYPE(FuAcpiPhatPlugin, fu_acpi_phat_plugin, FU_TYPE_PLUGIN)
static gboolean
fu_plugin_acpi_phat_coldplug(FuPlugin *plugin, FuProgress *progress, GError **error)
fu_acpi_phat_plugin_coldplug(FuPlugin *plugin, FuProgress *progress, GError **error)
{
g_autofree gchar *path = NULL;
g_autofree gchar *fn = NULL;
@ -43,10 +39,27 @@ fu_plugin_acpi_phat_coldplug(FuPlugin *plugin, FuProgress *progress, GError **er
return TRUE;
}
void
fu_plugin_init_vfuncs(FuPluginVfuncs *vfuncs)
static void
fu_acpi_phat_plugin_init(FuAcpiPhatPlugin *self)
{
vfuncs->build_hash = FU_BUILD_HASH;
vfuncs->init = fu_plugin_acpi_phat_init;
vfuncs->coldplug = fu_plugin_acpi_phat_coldplug;
}
static void
fu_acpi_phat_plugin_constructed(GObject *obj)
{
FuPlugin *plugin = FU_PLUGIN(obj);
fu_plugin_add_firmware_gtype(plugin, NULL, FU_TYPE_ACPI_PHAT);
fu_plugin_add_firmware_gtype(plugin, NULL, FU_TYPE_ACPI_PHAT_HEALTH_RECORD);
fu_plugin_add_firmware_gtype(plugin, NULL, FU_TYPE_ACPI_PHAT_VERSION_ELEMENT);
fu_plugin_add_firmware_gtype(plugin, NULL, FU_TYPE_ACPI_PHAT_VERSION_RECORD);
}
static void
fu_acpi_phat_plugin_class_init(FuAcpiPhatPluginClass *klass)
{
FuPluginClass *plugin_class = FU_PLUGIN_CLASS(klass);
GObjectClass *object_class = G_OBJECT_CLASS(klass);
object_class->constructed = fu_acpi_phat_plugin_constructed;
plugin_class->coldplug = fu_acpi_phat_plugin_coldplug;
}

11
plugins/acpi-phat/fu-acpi-phat-plugin.h Normal file
View File

@ -0,0 +1,11 @@
/*
* Copyright (C) 2022 Richard Hughes <richard@hughsie.com>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#pragma once
#include <fwupdplugin.h>
G_DECLARE_FINAL_TYPE(FuAcpiPhatPlugin, fu_acpi_phat_plugin, FU, ACPI_PHAT_PLUGIN, FuPlugin)

42
plugins/acpi-phat/meson.build
View File

@ -1,31 +1,20 @@
if get_option('plugin_acpi_phat').disable_auto_if(host_machine.system() != 'linux').allowed()
cargs = ['-DG_LOG_DOMAIN="FuPluginAcpiPhat"']
shared_module('fu_plugin_acpi_phat',
fu_hash,
plugin_builtin_acpi_phat = static_library('fu_plugin_acpi_phat',
sources: [
'fu-plugin-acpi-phat.c',
'fu-acpi-phat-plugin.c',
'fu-acpi-phat.c', # fuzzing
'fu-acpi-phat-health-record.c', # fuzzing
'fu-acpi-phat-version-element.c', # fuzzing
'fu-acpi-phat-version-record.c', # fuzzing
],
include_directories: [
root_incdir,
fwupd_incdir,
fwupdplugin_incdir,
],
install: true,
install_dir: plugin_dir,
link_with: [
fwupd,
fwupdplugin,
],
include_directories: plugin_incdirs,
link_with: plugin_libs,
c_args: cargs,
dependencies: [
plugin_deps,
],
dependencies: plugin_deps,
)
plugin_builtins += plugin_builtin_acpi_phat
if get_option('tests')
env = environment()
@ -33,25 +22,14 @@ if get_option('tests')
env.set('G_TEST_BUILDDIR', meson.current_build_dir())
e = executable(
'acpi-phat-self-test',
fu_hash,
sources: [
'fu-self-test.c',
'fu-acpi-phat.c',
'fu-acpi-phat-health-record.c',
'fu-acpi-phat-version-element.c',
'fu-acpi-phat-version-record.c',
],
include_directories: [
root_incdir,
fwupd_incdir,
fwupdplugin_incdir,
],
dependencies: [
plugin_deps,
],
include_directories: plugin_incdirs,
dependencies: plugin_deps,
link_with: [
fwupd,
fwupdplugin,
plugin_libs,
plugin_builtin_acpi_phat,
],
install: true,
install_rpath: plugin_dir,

36
plugins/amd-pmc/fu-amd-pmc-plugin.c Normal file
View File

@ -0,0 +1,36 @@
/*
* Copyright (C) 2022 Advanced Micro Devices Inc.
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#include "config.h"
#include "fu-amd-pmc-device.h"
#include "fu-amd-pmc-plugin.h"
struct _FuAmdPmcPlugin {
FuPlugin parent_instance;
};
G_DEFINE_TYPE(FuAmdPmcPlugin, fu_amd_pmc_plugin, FU_TYPE_PLUGIN)
static void
fu_amd_pmc_plugin_init(FuAmdPmcPlugin *self)
{
}
static void
fu_amd_pmc_plugin_constructed(GObject *obj)
{
FuPlugin *plugin = FU_PLUGIN(obj);
fu_plugin_add_udev_subsystem(plugin, "platform");
fu_plugin_add_device_gtype(plugin, FU_TYPE_AMD_PMC_DEVICE);
}
static void
fu_amd_pmc_plugin_class_init(FuAmdPmcPluginClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS(klass);
object_class->constructed = fu_amd_pmc_plugin_constructed;
}

11
plugins/amd-pmc/fu-amd-pmc-plugin.h Normal file
View File

@ -0,0 +1,11 @@
/*
* Copyright (C) 2022 Richard Hughes <richard@hughsie.com>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#pragma once
#include <fwupdplugin.h>
G_DECLARE_FINAL_TYPE(FuAmdPmcPlugin, fu_amd_pmc_plugin, FU, AMD_PMC_PLUGIN, FuPlugin)

25
plugins/amd-pmc/fu-plugin-amd-pmc.c
View File

@ -1,25 +0,0 @@
/*
* Copyright (C) 2022 Advanced Micro Devices Inc.
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#include "config.h"
#include <fwupdplugin.h>
#include "fu-amd-pmc-device.h"
static void
fu_plugin_amd_pmc_init(FuPlugin *plugin)
{
fu_plugin_add_udev_subsystem(plugin, "platform");
fu_plugin_add_device_gtype(plugin, FU_TYPE_AMD_PMC_DEVICE);
}
void
fu_plugin_init_vfuncs(FuPluginVfuncs *vfuncs)
{
vfuncs->build_hash = FU_BUILD_HASH;
vfuncs->init = fu_plugin_amd_pmc_init;
}

23
plugins/amd-pmc/meson.build
View File

@ -2,27 +2,14 @@ if gudev.found() and (host_cpu == 'x86' or host_cpu == 'x86_64')
cargs = ['-DG_LOG_DOMAIN="FuPluginAmdPmc"']
plugin_quirks += files('amd-pmc.quirk')
shared_module('fu_plugin_amd_pmc',
fu_hash,
plugin_builtins += static_library('fu_plugin_amd_pmc',
sources: [
'fu-plugin-amd-pmc.c',
'fu-amd-pmc-plugin.c',
'fu-amd-pmc-device.c',
],
include_directories: [
root_incdir,
fwupd_incdir,
fwupdplugin_incdir,
],
install: true,
install_dir: plugin_dir,
link_with: [
fwupd,
fwupdplugin,
],
include_directories: plugin_incdirs,
link_with: plugin_libs,
c_args: cargs,
dependencies: [
plugin_deps,
],
dependencies: plugin_deps,
)
endif

36
plugins/amt/fu-amt-plugin.c Normal file
View File

@ -0,0 +1,36 @@
/*
* Copyright (C) 2022 Richard Hughes <richard@hughsie.com>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#include "config.h"
#include "fu-amt-device.h"
#include "fu-amt-plugin.h"
struct _FuAmtPlugin {
FuPlugin parent_instance;
};
G_DEFINE_TYPE(FuAmtPlugin, fu_amt_plugin, FU_TYPE_PLUGIN)
static void
fu_amt_plugin_init(FuAmtPlugin *self)
{
}
static void
fu_amt_plugin_constructed(GObject *obj)
{
FuPlugin *plugin = FU_PLUGIN(obj);
fu_plugin_add_udev_subsystem(plugin, "mei");
fu_plugin_add_device_gtype(plugin, FU_TYPE_AMT_DEVICE);
}
static void
fu_amt_plugin_class_init(FuAmtPluginClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS(klass);
object_class->constructed = fu_amt_plugin_constructed;
}

11
plugins/amt/fu-amt-plugin.h Normal file
View File

@ -0,0 +1,11 @@
/*
* Copyright (C) 2022 Richard Hughes <richard@hughsie.com>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#pragma once
#include <fwupdplugin.h>
G_DECLARE_FINAL_TYPE(FuAmtPlugin, fu_amt_plugin, FU, AMT_PLUGIN, FuPlugin)

25
plugins/amt/fu-plugin-amt.c
View File

@ -1,25 +0,0 @@
/*
* Copyright (C) 2022 Richard Hughes <richard@hughsie.com>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#include "config.h"
#include <fwupdplugin.h>
#include "fu-amt-device.h"
static void
fu_plugin_init(FuPlugin *plugin)
{
fu_plugin_add_udev_subsystem(plugin, "mei");
fu_plugin_add_device_gtype(plugin, FU_TYPE_AMT_DEVICE);
}
void
fu_plugin_init_vfuncs(FuPluginVfuncs *vfuncs)
{
vfuncs->init = fu_plugin_init;
vfuncs->build_hash = FU_BUILD_HASH;
}

23
plugins/amt/meson.build
View File

@ -2,27 +2,14 @@ if get_option('plugin_amt').disable_auto_if(host_machine.system() != 'linux').al
cargs = ['-DG_LOG_DOMAIN="FuPluginAmt"']
plugin_quirks += files('amt.quirk')
shared_module('fu_plugin_amt',
fu_hash,
plugin_builtins += static_library('fu_plugin_amt',
sources: [
'fu-plugin-amt.c',
'fu-amt-plugin.c',
'fu-amt-device.c',
],
include_directories: [
root_incdir,
fwupd_incdir,
fwupdplugin_incdir,
],
install: true,
install_dir: plugin_dir,
link_with: [
fwupd,
fwupdplugin,
],
include_directories: plugin_incdirs,
link_with: plugin_libs,
c_args: cargs,
dependencies: [
plugin_deps,
],
dependencies: plugin_deps,
)
endif

37
plugins/analogix/fu-analogix-plugin.c Normal file
View File

@ -0,0 +1,37 @@
/*
* Copyright (C) 2021 Xiaotian Cui <xtcui@analogixsemi.com>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#include "config.h"
#include "fu-analogix-device.h"
#include "fu-analogix-firmware.h"
#include "fu-analogix-plugin.h"
struct _FuAnalogixPlugin {
FuPlugin parent_instance;
};
G_DEFINE_TYPE(FuAnalogixPlugin, fu_analogix_plugin, FU_TYPE_PLUGIN)
static void
fu_analogix_plugin_init(FuAnalogixPlugin *self)
{
}
static void
fu_analogix_plugin_constructed(GObject *obj)
{
FuPlugin *plugin = FU_PLUGIN(obj);
fu_plugin_add_device_gtype(plugin, FU_TYPE_ANALOGIX_DEVICE);
fu_plugin_add_firmware_gtype(plugin, NULL, FU_TYPE_ANALOGIX_FIRMWARE);
}
static void
fu_analogix_plugin_class_init(FuAnalogixPluginClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS(klass);
object_class->constructed = fu_analogix_plugin_constructed;
}

11
plugins/analogix/fu-analogix-plugin.h Normal file
View File

@ -0,0 +1,11 @@
/*
* Copyright (C) 2022 Richard Hughes <richard@hughsie.com>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#pragma once
#include <fwupdplugin.h>
G_DECLARE_FINAL_TYPE(FuAnalogixPlugin, fu_analogix_plugin, FU, ANALOGIX_PLUGIN, FuPlugin)

26
plugins/analogix/fu-plugin-analogix.c
View File

@ -1,26 +0,0 @@
/*
* Copyright (C) 2021 Xiaotian Cui <xtcui@analogixsemi.com>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#include "config.h"
#include <fwupdplugin.h>
#include "fu-analogix-device.h"
#include "fu-analogix-firmware.h"
static void
fu_plugin_analogix_init(FuPlugin *plugin)
{
fu_plugin_add_device_gtype(plugin, FU_TYPE_ANALOGIX_DEVICE);
fu_plugin_add_firmware_gtype(plugin, NULL, FU_TYPE_ANALOGIX_FIRMWARE);
}
void
fu_plugin_init_vfuncs(FuPluginVfuncs *vfuncs)
{
vfuncs->build_hash = FU_BUILD_HASH;
vfuncs->init = fu_plugin_analogix_init;
}

23
plugins/analogix/meson.build
View File

@ -2,29 +2,16 @@ if gusb.found()
cargs = ['-DG_LOG_DOMAIN="FuPluginAnalogix"']
plugin_quirks += files('analogix.quirk')
shared_module('fu_plugin_analogix',
fu_hash,
plugin_builtins += static_library('fu_plugin_analogix',
sources: [
'fu-plugin-analogix.c',
'fu-analogix-plugin.c',
'fu-analogix-device.c',
'fu-analogix-common.c',
'fu-analogix-firmware.c',
],
include_directories: [
root_incdir,
fwupd_incdir,
fwupdplugin_incdir,
],
install: true,
install_dir: plugin_dir,
link_with: [
fwupd,
fwupdplugin,
],
include_directories: plugin_incdirs,
link_with: plugin_libs,
c_args: cargs,
dependencies: [
plugin_deps,
],
dependencies: plugin_deps,
)
endif

36
plugins/android-boot/fu-android-boot-plugin.c Normal file
View File

@ -0,0 +1,36 @@
/*
* Copyright (C) 2022 Dylan Van Assche <me@dylanvanassche.be>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#include "config.h"
#include "fu-android-boot-device.h"
#include "fu-android-boot-plugin.h"
struct _FuAndroidBootPlugin {
FuPlugin parent_instance;
};
G_DEFINE_TYPE(FuAndroidBootPlugin, fu_android_boot_plugin, FU_TYPE_PLUGIN)
static void
fu_android_boot_plugin_init(FuAndroidBootPlugin *self)
{
}
static void
fu_android_boot_plugin_constructed(GObject *obj)
{
FuPlugin *plugin = FU_PLUGIN(obj);
fu_plugin_add_device_gtype(plugin, FU_TYPE_ANDROID_BOOT_DEVICE);
fu_plugin_add_udev_subsystem(plugin, "block");
}
static void
fu_android_boot_plugin_class_init(FuAndroidBootPluginClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS(klass);
object_class->constructed = fu_android_boot_plugin_constructed;
}

11
plugins/android-boot/fu-android-boot-plugin.h Normal file
View File

@ -0,0 +1,11 @@
/*
* Copyright (C) 2022 Richard Hughes <richard@hughsie.com>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#pragma once
#include <fwupdplugin.h>
G_DECLARE_FINAL_TYPE(FuAndroidBootPlugin, fu_android_boot_plugin, FU, ANDROID_BOOT_PLUGIN, FuPlugin)

25
plugins/android-boot/fu-plugin-android-boot.c
View File

@ -1,25 +0,0 @@
/*
* Copyright (C) 2022 Dylan Van Assche <me@dylanvanassche.be>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#include "config.h"
#include <fwupdplugin.h>
#include "fu-android-boot-device.h"
static void
fu_plugin_android_boot_init(FuPlugin *plugin)
{
fu_plugin_add_device_gtype(plugin, FU_TYPE_ANDROID_BOOT_DEVICE);
fu_plugin_add_udev_subsystem(plugin, "block");
}
void
fu_plugin_init_vfuncs(FuPluginVfuncs *vfuncs)
{
vfuncs->build_hash = FU_BUILD_HASH;
vfuncs->init = fu_plugin_android_boot_init;
}

23
plugins/android-boot/meson.build
View File

@ -3,27 +3,14 @@ if get_option('plugin_android_boot').require(gudev.found(),
cargs = ['-DG_LOG_DOMAIN="FuPluginAndroidBoot"']
plugin_quirks += files('android-boot.quirk')
shared_module('fu_plugin_android_boot',
fu_hash,
plugin_builtins += static_library('fu_plugin_android_boot',
sources: [
'fu-plugin-android-boot.c',
'fu-android-boot-plugin.c',
'fu-android-boot-device.c',
],
include_directories : [
root_incdir,
fwupd_incdir,
fwupdplugin_incdir,
],
install : true,
install_dir: plugin_dir,
link_with : [
fwupd,
fwupdplugin,
],
include_directories: plugin_incdirs,
link_with: plugin_libs,
c_args: cargs,
dependencies : [
plugin_deps,
],
dependencies: plugin_deps,
)
endif

36
plugins/ata/fu-ata-plugin.c Normal file
View File

@ -0,0 +1,36 @@
/*
* Copyright (C) 2019 Richard Hughes <richard@hughsie.com>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#include "config.h"
#include "fu-ata-device.h"
#include "fu-ata-plugin.h"
struct _FuAtaPlugin {
FuPlugin parent_instance;
};
G_DEFINE_TYPE(FuAtaPlugin, fu_ata_plugin, FU_TYPE_PLUGIN)
static void
fu_ata_plugin_init(FuAtaPlugin *self)
{
}
static void
fu_ata_plugin_constructed(GObject *obj)
{
FuPlugin *plugin = FU_PLUGIN(obj);
fu_plugin_add_udev_subsystem(plugin, "block");
fu_plugin_add_device_gtype(plugin, FU_TYPE_ATA_DEVICE);
}
static void
fu_ata_plugin_class_init(FuAtaPluginClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS(klass);
object_class->constructed = fu_ata_plugin_constructed;
}

11
plugins/ata/fu-ata-plugin.h Normal file
View File

@ -0,0 +1,11 @@
/*
* Copyright (C) 2022 Richard Hughes <richard@hughsie.com>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#pragma once
#include <fwupdplugin.h>
G_DECLARE_FINAL_TYPE(FuAtaPlugin, fu_ata_plugin, FU, ATA_PLUGIN, FuPlugin)

25
plugins/ata/fu-plugin-ata.c
View File

@ -1,25 +0,0 @@
/*
* Copyright (C) 2019 Richard Hughes <richard@hughsie.com>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#include "config.h"
#include <fwupdplugin.h>
#include "fu-ata-device.h"
static void
fu_plugin_ata_init(FuPlugin *plugin)
{
fu_plugin_add_udev_subsystem(plugin, "block");
fu_plugin_add_device_gtype(plugin, FU_TYPE_ATA_DEVICE);
}
void
fu_plugin_init_vfuncs(FuPluginVfuncs *vfuncs)
{
vfuncs->build_hash = FU_BUILD_HASH;
vfuncs->init = fu_plugin_ata_init;
}

40
plugins/ata/meson.build
View File

@ -2,32 +2,20 @@ if gudev.found()
cargs = ['-DG_LOG_DOMAIN="FuPluginAta"']
plugin_quirks += files('ata.quirk')
shared_module('fu_plugin_ata',
fu_hash,
plugin_builtin_ata = static_library('fu_plugin_ata',
sources: [
'fu-plugin-ata.c',
'fu-ata-plugin.c',
'fu-ata-device.c',
],
include_directories: [
root_incdir,
fwupd_incdir,
fwupdplugin_incdir,
],
install: true,
install_dir: plugin_dir,
include_directories: plugin_incdirs,
c_args: [
cargs,
'-DLOCALSTATEDIR="' + localstatedir + '"',
],
link_with: [
fwupd,
fwupdplugin,
],
dependencies: [
plugin_deps,
],
link_with: plugin_libs,
dependencies: plugin_deps,
)
plugin_builtins += plugin_builtin_ata
if get_option('tests')
env = environment()
@ -36,22 +24,14 @@ if get_option('tests')
env.set('FWUPD_DATADIR_QUIRKS', meson.current_source_dir())
e = executable(
'ata-self-test',
fu_hash,
sources: [
'fu-self-test.c',
'fu-ata-device.c',
],
include_directories: [
root_incdir,
fwupd_incdir,
fwupdplugin_incdir,
],
dependencies: [
plugin_deps,
],
include_directories: plugin_incdirs,
dependencies: plugin_deps,
link_with: [
fwupd,
fwupdplugin,
plugin_libs,
plugin_builtin_ata,
],
install: true,
install_rpath: plugin_dir,

25
plugins/bcm57xx/fu-plugin-bcm57xx.c → plugins/bcm57xx/fu-bcm57xx-plugin.c
View File

@ -6,17 +6,28 @@
#include "config.h"
#include <fwupdplugin.h>
#include "fu-bcm57xx-device.h"
#include "fu-bcm57xx-dict-image.h"
#include "fu-bcm57xx-firmware.h"
#include "fu-bcm57xx-plugin.h"
#include "fu-bcm57xx-stage1-image.h"
#include "fu-bcm57xx-stage2-image.h"
struct _FuBcm57XxPlugin {
FuPlugin parent_instance;
};
G_DEFINE_TYPE(FuBcm57XxPlugin, fu_bcm57xx_plugin, FU_TYPE_PLUGIN)
static void
fu_plugin_bcm57xx_init(FuPlugin *plugin)
fu_bcm57xx_plugin_init(FuBcm57XxPlugin *self)
{
}
static void
fu_bcm57xx_plugin_constructed(GObject *obj)
{
FuPlugin *plugin = FU_PLUGIN(obj);
fu_plugin_add_udev_subsystem(plugin, "pci");
fu_plugin_add_device_gtype(plugin, FU_TYPE_BCM57XX_DEVICE);
fu_plugin_add_firmware_gtype(plugin, NULL, FU_TYPE_BCM57XX_FIRMWARE);
@ -26,9 +37,9 @@ fu_plugin_bcm57xx_init(FuPlugin *plugin)
fu_plugin_add_rule(plugin, FU_PLUGIN_RULE_BETTER_THAN, "optionrom");
}
void
fu_plugin_init_vfuncs(FuPluginVfuncs *vfuncs)
static void
fu_bcm57xx_plugin_class_init(FuBcm57XxPluginClass *klass)
{
vfuncs->build_hash = FU_BUILD_HASH;
vfuncs->init = fu_plugin_bcm57xx_init;
GObjectClass *object_class = G_OBJECT_CLASS(klass);
object_class->constructed = fu_bcm57xx_plugin_constructed;
}

11
plugins/bcm57xx/fu-bcm57xx-plugin.h Normal file
View File

@ -0,0 +1,11 @@
/*
* Copyright (C) 2022 Richard Hughes <richard@hughsie.com>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#pragma once
#include <fwupdplugin.h>
G_DECLARE_FINAL_TYPE(FuBcm57XxPlugin, fu_bcm57xx_plugin, FU, BCM57XX_PLUGIN, FuPlugin)

40
plugins/bcm57xx/meson.build
View File

@ -3,11 +3,9 @@ if get_option('plugin_bcm57xx').require(gudev.found(),
cargs = ['-DG_LOG_DOMAIN="FuPluginBcm57xx"']
plugin_quirks += files('bcm57xx.quirk')
shared_module('fu_plugin_bcm57xx',
fu_hash,
plugin_builtin_bcm57xx = static_library('fu_plugin_bcm57xx',
sources: [
'fu-plugin-bcm57xx.c',
'fu-bcm57xx-plugin.c',
'fu-bcm57xx-common.c', # fuzzing
'fu-bcm57xx-device.c',
'fu-bcm57xx-dict-image.c', # fuzzing
@ -16,23 +14,15 @@ shared_module('fu_plugin_bcm57xx',
'fu-bcm57xx-stage1-image.c', # fuzzing
'fu-bcm57xx-stage2-image.c', # fuzzing
],
include_directories: [
root_incdir,
fwupd_incdir,
fwupdplugin_incdir,
],
install: true,
install_dir: plugin_dir,
link_with: [
fwupd,
fwupdplugin,
],
include_directories: plugin_incdirs,
link_with: plugin_libs,
c_args: cargs,
dependencies: [
plugin_deps,
valgrind,
],
)
plugin_builtins += plugin_builtin_bcm57xx
if get_option('tests')
install_data(['tests/bcm57xx.builder.xml'],
@ -42,26 +32,14 @@ if get_option('tests')
env.set('G_TEST_BUILDDIR', meson.current_build_dir())
e = executable(
'bcm57xx-self-test',
fu_hash,
sources: [
'fu-self-test.c',
'fu-bcm57xx-common.c',
'fu-bcm57xx-dict-image.c',
'fu-bcm57xx-firmware.c',
'fu-bcm57xx-stage1-image.c',
'fu-bcm57xx-stage2-image.c',
],
include_directories: [
root_incdir,
fwupd_incdir,
fwupdplugin_incdir,
],
dependencies: [
plugin_deps,
],
include_directories: plugin_incdirs,
dependencies: plugin_deps,
link_with: [
fwupd,
fwupdplugin,
plugin_libs,
plugin_builtin_bcm57xx,
],
install: true,
install_rpath: plugin_dir,

31
plugins/bios/fu-plugin-bios.c → plugins/bios/fu-bios-plugin.c
View File

@ -6,10 +6,16 @@
#include "config.h"
#include <fwupdplugin.h>
#include "fu-bios-plugin.h"
struct _FuBiosPlugin {
FuPlugin parent_instance;
};
G_DEFINE_TYPE(FuBiosPlugin, fu_bios_plugin, FU_TYPE_PLUGIN)
static gboolean
fu_plugin_bios_startup(FuPlugin *plugin, FuProgress *progress, GError **error)
fu_bios_plugin_startup(FuPlugin *plugin, FuProgress *progress, GError **error)
{
FuContext *ctx = fu_plugin_get_context(plugin);
const gchar *vendor;
@ -24,7 +30,7 @@ fu_plugin_bios_startup(FuPlugin *plugin, FuProgress *progress, GError **error)
}
static gboolean
fu_plugin_bios_coldplug(FuPlugin *plugin, FuProgress *progress, GError **error)
fu_bios_plugin_coldplug(FuPlugin *plugin, FuProgress *progress, GError **error)
{
g_autofree gchar *sysfsfwdir = NULL;
g_autofree gchar *esrt_path = NULL;
@ -54,7 +60,7 @@ fu_plugin_bios_coldplug(FuPlugin *plugin, FuProgress *progress, GError **error)
}
static void
fu_plugin_bios_add_security_attrs(FuPlugin *plugin, FuSecurityAttrs *attrs)
fu_bios_plugin_add_security_attrs(FuPlugin *plugin, FuSecurityAttrs *attrs)
{
g_autoptr(FwupdSecurityAttr) attr = NULL;
@ -70,11 +76,16 @@ fu_plugin_bios_add_security_attrs(FuPlugin *plugin, FuSecurityAttrs *attrs)
fwupd_security_attr_set_result(attr, FWUPD_SECURITY_ATTR_RESULT_NOT_ENABLED);
}
void
fu_plugin_init_vfuncs(FuPluginVfuncs *vfuncs)
static void
fu_bios_plugin_init(FuBiosPlugin *self)
{
vfuncs->build_hash = FU_BUILD_HASH;
vfuncs->startup = fu_plugin_bios_startup;
vfuncs->coldplug = fu_plugin_bios_coldplug;
vfuncs->add_security_attrs = fu_plugin_bios_add_security_attrs;
}
static void
fu_bios_plugin_class_init(FuBiosPluginClass *klass)
{
FuPluginClass *plugin_class = FU_PLUGIN_CLASS(klass);
plugin_class->startup = fu_bios_plugin_startup;
plugin_class->coldplug = fu_bios_plugin_coldplug;
plugin_class->add_security_attrs = fu_bios_plugin_add_security_attrs;
}

11
plugins/bios/fu-bios-plugin.h Normal file
View File

@ -0,0 +1,11 @@
/*
* Copyright (C) 2022 Richard Hughes <richard@hughsie.com>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#pragma once
#include <fwupdplugin.h>
G_DECLARE_FINAL_TYPE(FuBiosPlugin, fu_bios_plugin, FU, BIOS_PLUGIN, FuPlugin)

22
plugins/bios/meson.build
View File

@ -1,25 +1,13 @@
if get_option('plugin_uefi_capsule').disable_auto_if(host_machine.system() != 'linux').allowed()
cargs = ['-DG_LOG_DOMAIN="FuPluginBios"']
shared_module('fu_plugin_bios',
fu_hash,
plugin_builtins += static_library('fu_plugin_bios',
sources: [
'fu-plugin-bios.c',
],
include_directories: [
root_incdir,
fwupd_incdir,
fwupdplugin_incdir,
],
install: true,
install_dir: plugin_dir,
link_with: [
fwupd,
fwupdplugin,
'fu-bios-plugin.c',
],
include_directories: plugin_incdirs,
link_with: plugin_libs,
c_args: cargs,
dependencies: [
plugin_deps,
],
dependencies: plugin_deps,
)
endif

38
plugins/ccgx/fu-plugin-ccgx.c → plugins/ccgx/fu-ccgx-plugin.c
View File

@ -6,17 +6,33 @@
#include "config.h"
#include <fwupdplugin.h>
#include "fu-ccgx-dmc-device.h"
#include "fu-ccgx-dmc-firmware.h"
#include "fu-ccgx-firmware.h"
#include "fu-ccgx-hid-device.h"
#include "fu-ccgx-hpi-device.h"
#include "fu-ccgx-plugin.h"
struct _FuCcgxPlugin {
FuPlugin parent_instance;
};
G_DEFINE_TYPE(FuCcgxPlugin, fu_ccgx_plugin, FU_TYPE_PLUGIN)
static void
fu_plugin_ccgx_init(FuPlugin *plugin)
fu_ccgx_plugin_init(FuCcgxPlugin *self)
{
}
static void
fu_ccgx_plugin_constructed(GObject *obj)
{
FuPlugin *plugin = FU_PLUGIN(obj);
FuContext *ctx = fu_plugin_get_context(plugin);
fu_context_add_quirk_key(ctx, "CcgxFlashRowSize");
fu_context_add_quirk_key(ctx, "CcgxFlashSize");
fu_context_add_quirk_key(ctx, "CcgxImageKind");
fu_context_add_quirk_key(ctx, "CcgxDmcTriggerCode");
fu_plugin_add_firmware_gtype(plugin, NULL, FU_TYPE_CCGX_FIRMWARE);
fu_plugin_add_firmware_gtype(plugin, NULL, FU_TYPE_CCGX_DMC_FIRMWARE);
fu_plugin_add_device_gtype(plugin, FU_TYPE_CCGX_HID_DEVICE);
@ -25,18 +41,8 @@ fu_plugin_ccgx_init(FuPlugin *plugin)
}
static void
fu_plugin_ccgx_load(FuContext *ctx)
fu_ccgx_plugin_class_init(FuCcgxPluginClass *klass)
{
fu_context_add_quirk_key(ctx, "CcgxFlashRowSize");
fu_context_add_quirk_key(ctx, "CcgxFlashSize");
fu_context_add_quirk_key(ctx, "CcgxImageKind");
fu_context_add_quirk_key(ctx, "CcgxDmcTriggerCode");
}
void
fu_plugin_init_vfuncs(FuPluginVfuncs *vfuncs)
{
vfuncs->build_hash = FU_BUILD_HASH;
vfuncs->load = fu_plugin_ccgx_load;
vfuncs->init = fu_plugin_ccgx_init;
GObjectClass *object_class = G_OBJECT_CLASS(klass);
object_class->constructed = fu_ccgx_plugin_constructed;
}

11
plugins/ccgx/fu-ccgx-plugin.h Normal file
View File

@ -0,0 +1,11 @@
/*
* Copyright (C) 2022 Richard Hughes <richard@hughsie.com>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#pragma once
#include <fwupdplugin.h>
G_DECLARE_FINAL_TYPE(FuCcgxPlugin, fu_ccgx_plugin, FU, CCGX_PLUGIN, FuPlugin)

39
plugins/ccgx/meson.build
View File

@ -5,11 +5,9 @@ plugin_quirks += files([
'ccgx-ids.quirk',
'ccgx.quirk',
])
shared_module('fu_plugin_ccgx',
fu_hash,
plugin_builtin_ccgx = static_library('fu_plugin_ccgx',
sources: [
'fu-plugin-ccgx.c',
'fu-ccgx-plugin.c',
'fu-ccgx-common.c', # fuzzing
'fu-ccgx-firmware.c', # fuzzing
'fu-ccgx-hid-device.c',
@ -19,23 +17,15 @@ shared_module('fu_plugin_ccgx',
'fu-ccgx-dmc-firmware.c', # fuzzing
'fu-ccgx-dmc-common.c', # fuzzing
],
include_directories: [
root_incdir,
fwupd_incdir,
fwupdplugin_incdir,
],
install: true,
install_dir: plugin_dir,
link_with: [
fwupd,
fwupdplugin,
],
include_directories: plugin_incdirs,
link_with: plugin_libs,
c_args: cargs,
dependencies: [
plugin_deps,
gudev,
],
)
plugin_builtins += plugin_builtin_ccgx
endif
if get_option('tests')
@ -46,25 +36,14 @@ if get_option('tests')
env.set('G_TEST_BUILDDIR', meson.current_build_dir())
e = executable(
'ccgx-self-test',
fu_hash,
sources: [
'fu-self-test.c',
'fu-ccgx-common.c',
'fu-ccgx-firmware.c',
'fu-ccgx-dmc-common.c',
'fu-ccgx-dmc-firmware.c',
],
include_directories: [
root_incdir,
fwupd_incdir,
fwupdplugin_incdir,
],
dependencies: [
plugin_deps,
],
include_directories: plugin_incdirs,
dependencies: plugin_deps,
link_with: [
fwupd,
fwupdplugin,
plugin_libs,
plugin_builtin_ccgx,
],
install: true,
install_rpath: plugin_dir,

35
plugins/cfu/fu-cfu-plugin.c Normal file
View File

@ -0,0 +1,35 @@
/*
* Copyright (C) 2021 Richard Hughes <richard@hughsie.com>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#include "config.h"
#include "fu-cfu-device.h"
#include "fu-cfu-plugin.h"
struct _FuCfuPlugin {
FuPlugin parent_instance;
};
G_DEFINE_TYPE(FuCfuPlugin, fu_cfu_plugin, FU_TYPE_PLUGIN)
static void
fu_cfu_plugin_init(FuCfuPlugin *self)
{
}
static void
fu_cfu_plugin_constructed(GObject *obj)
{
FuPlugin *plugin = FU_PLUGIN(obj);
fu_plugin_add_device_gtype(plugin, FU_TYPE_CFU_DEVICE);
}
static void
fu_cfu_plugin_class_init(FuCfuPluginClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS(klass);
object_class->constructed = fu_cfu_plugin_constructed;
}

11
plugins/cfu/fu-cfu-plugin.h Normal file
View File

@ -0,0 +1,11 @@
/*
* Copyright (C) 2022 Richard Hughes <richard@hughsie.com>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#pragma once
#include <fwupdplugin.h>
G_DECLARE_FINAL_TYPE(FuCfuPlugin, fu_cfu_plugin, FU, CFU_PLUGIN, FuPlugin)

24
plugins/cfu/fu-plugin-cfu.c
View File

@ -1,24 +0,0 @@
/*
* Copyright (C) 2021 Richard Hughes <richard@hughsie.com>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#include "config.h"
#include <fwupdplugin.h>
#include "fu-cfu-device.h"
static void
fu_plugin_cfu_init(FuPlugin *plugin)
{
fu_plugin_add_device_gtype(plugin, FU_TYPE_CFU_DEVICE);
}
void
fu_plugin_init_vfuncs(FuPluginVfuncs *vfuncs)
{
vfuncs->build_hash = FU_BUILD_HASH;
vfuncs->init = fu_plugin_cfu_init;
}

23
plugins/cfu/meson.build
View File

@ -3,28 +3,15 @@ if get_option('plugin_cfu').require(gudev.found(),
cargs = ['-DG_LOG_DOMAIN="FuPluginCfu"']
plugin_quirks += files('cfu.quirk')
shared_module('fu_plugin_cfu',
fu_hash,
plugin_builtins += static_library('fu_plugin_cfu',
sources: [
'fu-cfu-device.c',
'fu-cfu-module.c',
'fu-plugin-cfu.c',
],
include_directories: [
root_incdir,
fwupd_incdir,
fwupdplugin_incdir,
],
install: true,
install_dir: plugin_dir,
link_with: [
fwupd,
fwupdplugin,
'fu-cfu-plugin.c',
],
include_directories: plugin_incdirs,
link_with: plugin_libs,
c_args: cargs,
dependencies: [
plugin_deps,
],
dependencies: plugin_deps,
)
endif

35
plugins/ch341a/fu-ch341a-plugin.c Normal file
View File

@ -0,0 +1,35 @@
/*
* Copyright (C) 2022 Richard Hughes <richard@hughsie.com>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#include "config.h"
#include "fu-ch341a-device.h"
#include "fu-ch341a-plugin.h"
struct _FuCh341APlugin {
FuPlugin parent_instance;
};
G_DEFINE_TYPE(FuCh341APlugin, fu_ch341a_plugin, FU_TYPE_PLUGIN)
static void
fu_ch341a_plugin_init(FuCh341APlugin *self)
{
}
static void
fu_ch341a_plugin_constructed(GObject *obj)
{
FuPlugin *plugin = FU_PLUGIN(obj);
fu_plugin_add_device_gtype(plugin, FU_TYPE_CH341A_DEVICE);
}
static void
fu_ch341a_plugin_class_init(FuCh341APluginClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS(klass);
object_class->constructed = fu_ch341a_plugin_constructed;
}

11
plugins/ch341a/fu-ch341a-plugin.h Normal file
View File

@ -0,0 +1,11 @@
/*
* Copyright (C) 2022 Richard Hughes <richard@hughsie.com>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#pragma once
#include <fwupdplugin.h>
G_DECLARE_FINAL_TYPE(FuCh341APlugin, fu_ch341a_plugin, FU, CH341A_PLUGIN, FuPlugin)

24
plugins/ch341a/fu-plugin-ch341a.c
View File

@ -1,24 +0,0 @@
/*
* Copyright (C) 2022 Richard Hughes <richard@hughsie.com>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#include "config.h"
#include <fwupdplugin.h>
#include "fu-ch341a-device.h"
static void
fu_plugin_ch341a_init(FuPlugin *plugin)
{
fu_plugin_add_device_gtype(plugin, FU_TYPE_CH341A_DEVICE);
}
void
fu_plugin_init_vfuncs(FuPluginVfuncs *vfuncs)
{
vfuncs->build_hash = FU_BUILD_HASH;
vfuncs->init = fu_plugin_ch341a_init;
}

23
plugins/ch341a/meson.build
View File

@ -2,28 +2,15 @@ if gusb.found()
cargs = ['-DG_LOG_DOMAIN="FuPluginCh341a"']
plugin_quirks += files('ch341a.quirk')
shared_module('fu_plugin_ch341a',
fu_hash,
plugin_builtins += static_library('fu_plugin_ch341a',
sources: [
'fu-ch341a-cfi-device.c',
'fu-ch341a-device.c',
'fu-plugin-ch341a.c',
],
include_directories: [
root_incdir,
fwupd_incdir,
fwupdplugin_incdir,
],
install: true,
install_dir: plugin_dir,
link_with: [
fwupd,
fwupdplugin,
'fu-ch341a-plugin.c',
],
include_directories: plugin_incdirs,
link_with: plugin_libs,
c_args: cargs,
dependencies: [
plugin_deps,
],
dependencies: plugin_deps,
)
endif

4
plugins/corsair/fu-corsair-bp.c
View File

@ -61,7 +61,7 @@ fu_corsair_bp_command(FuCorsairBp *self,
data[CORSAIR_OFFSET_CMD_DESTINATION] = self->destination;
fu_dump_raw(G_LOG_DOMAIN, "corsair: command", data, self->cmd_write_size);
fu_dump_raw("FuPluginCorsair", "command", data, self->cmd_write_size);
ret = g_usb_device_interrupt_transfer(usb_device,
self->epout,
@ -110,7 +110,7 @@ fu_corsair_bp_command(FuCorsairBp *self,
return FALSE;
}
fu_dump_raw(G_LOG_DOMAIN, "corsair: response", data, self->cmd_write_size);
fu_dump_raw("FuPluginCorsair", "response", data, self->cmd_write_size);
if (data[CORSAIR_OFFSET_CMD_STATUS] != 0) {
g_set_error(error,

40
plugins/corsair/fu-corsair-plugin.c Normal file
View File

@ -0,0 +1,40 @@
/*
* Copyright (C) 2022 Andrii Dushko <andrii.dushko@developex.net>
* Copyright (C) 2022 Richard Hughes <richard@hughsie.com>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#include "config.h"
#include "fu-corsair-device.h"
#include "fu-corsair-plugin.h"
struct _FuCorsairPlugin {
FuPlugin parent_instance;
};
G_DEFINE_TYPE(FuCorsairPlugin, fu_corsair_plugin, FU_TYPE_PLUGIN)
static void
fu_corsair_plugin_init(FuCorsairPlugin *self)
{
}
static void
fu_corsair_plugin_constructed(GObject *obj)
{
FuPlugin *plugin = FU_PLUGIN(obj);
FuContext *ctx = fu_plugin_get_context(plugin);
fu_context_add_quirk_key(ctx, "CorsairDeviceKind");
fu_context_add_quirk_key(ctx, "CorsairVendorInterfaceId");
fu_context_add_quirk_key(ctx, "CorsairSubdeviceId");
fu_plugin_add_device_gtype(plugin, FU_TYPE_CORSAIR_DEVICE);
}
static void
fu_corsair_plugin_class_init(FuCorsairPluginClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS(klass);
object_class->constructed = fu_corsair_plugin_constructed;
}

11
plugins/corsair/fu-corsair-plugin.h Normal file
View File

@ -0,0 +1,11 @@
/*
* Copyright (C) 2022 Richard Hughes <richard@hughsie.com>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#pragma once
#include <fwupdplugin.h>
G_DECLARE_FINAL_TYPE(FuCorsairPlugin, fu_corsair_plugin, FU, CORSAIR_PLUGIN, FuPlugin)

33
plugins/corsair/fu-plugin-corsair.c
View File

@ -1,33 +0,0 @@
/*
* Copyright (C) 2022 Andrii Dushko <andrii.dushko@developex.net>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#include "config.h"
#include <fwupdplugin.h>
#include "fu-corsair-device.h"
static void
fu_plugin_corsair_init(FuPlugin *plugin)
{
fu_plugin_add_device_gtype(plugin, FU_TYPE_CORSAIR_DEVICE);
}
static void
fu_plugin_corsair_load(FuContext *ctx)
{
fu_context_add_quirk_key(ctx, "CorsairDeviceKind");
fu_context_add_quirk_key(ctx, "CorsairVendorInterfaceId");
fu_context_add_quirk_key(ctx, "CorsairSubdeviceId");
}
void
fu_plugin_init_vfuncs(FuPluginVfuncs *vfuncs)
{
vfuncs->build_hash = FU_BUILD_HASH;
vfuncs->load = fu_plugin_corsair_load;
vfuncs->init = fu_plugin_corsair_init;
}

25
plugins/corsair/meson.build
View File

@ -1,30 +1,17 @@
if gusb.found()
cargs = ['-DG_LOG_DOMAIN="FuPluginCorsair"']
plugin_quirks += files('corsair.quirk')
shared_module('fu_plugin_corsair',
fu_hash,
plugin_quirks += join_paths(meson.current_source_dir(), 'corsair.quirk')
plugin_builtins += static_library('fu_plugin_corsair',
sources: [
'fu-plugin-corsair.c',
'fu-corsair-plugin.c',
'fu-corsair-common.c',
'fu-corsair-device.c',
'fu-corsair-bp.c',
],
include_directories: [
root_incdir,
fwupd_incdir,
fwupdplugin_incdir,
],
install: true,
install_dir: plugin_dir,
link_with: [
fwupd,
fwupdplugin,
],
include_directories: plugin_incdirs,
link_with: plugin_libs,
c_args: cargs,
dependencies: [
plugin_deps,
],
dependencies: plugin_deps,
)
endif

38
plugins/cpu/fu-plugin-cpu.c → plugins/cpu/fu-cpu-plugin.c
View File

@ -6,18 +6,17 @@
#include "config.h"
#include <fwupdplugin.h>
#include "fu-cpu-device.h"
#include "fu-cpu-plugin.h"
static void
fu_plugin_cpu_init(FuPlugin *plugin)
{
fu_plugin_add_rule(plugin, FU_PLUGIN_RULE_RUN_BEFORE, "msr");
}
struct _FuCpuPlugin {
FuPlugin parent_instance;
};
G_DEFINE_TYPE(FuCpuPlugin, fu_cpu_plugin, FU_TYPE_PLUGIN)
static gboolean
fu_plugin_cpu_coldplug(FuPlugin *plugin, FuProgress *progress, GError **error)
fu_cpu_plugin_coldplug(FuPlugin *plugin, FuProgress *progress, GError **error)
{
FuContext *ctx = fu_plugin_get_context(plugin);
g_autoptr(FuCpuDevice) dev = fu_cpu_device_new(ctx);
@ -40,10 +39,23 @@ fu_plugin_cpu_coldplug(FuPlugin *plugin, FuProgress *progress, GError **error)
return TRUE;
}
void
fu_plugin_init_vfuncs(FuPluginVfuncs *vfuncs)
static void
fu_cpu_plugin_init(FuCpuPlugin *self)
{
vfuncs->build_hash = FU_BUILD_HASH;
vfuncs->init = fu_plugin_cpu_init;
vfuncs->coldplug = fu_plugin_cpu_coldplug;
}
static void
fu_cpu_plugin_constructed(GObject *obj)
{
FuPlugin *plugin = FU_PLUGIN(obj);
fu_plugin_add_rule(plugin, FU_PLUGIN_RULE_RUN_BEFORE, "msr");
}
static void
fu_cpu_plugin_class_init(FuCpuPluginClass *klass)
{
FuPluginClass *plugin_class = FU_PLUGIN_CLASS(klass);
GObjectClass *object_class = G_OBJECT_CLASS(klass);
object_class->constructed = fu_cpu_plugin_constructed;
plugin_class->coldplug = fu_cpu_plugin_coldplug;
}

11
plugins/cpu/fu-cpu-plugin.h Normal file
View File

@ -0,0 +1,11 @@
/*
* Copyright (C) 2022 Richard Hughes <richard@hughsie.com>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#pragma once
#include <fwupdplugin.h>
G_DECLARE_FINAL_TYPE(FuCpuPlugin, fu_cpu_plugin, FU, CPU_PLUGIN, FuPlugin)

23
plugins/cpu/meson.build
View File

@ -3,28 +3,15 @@ if get_option('plugin_cpu').disable_auto_if(host_machine.system() != 'linux').re
cargs = ['-DG_LOG_DOMAIN="FuPluginCpu"']
plugin_quirks += files('cpu.quirk')
shared_module('fu_plugin_cpu',
fu_hash,
plugin_builtins += static_library('fu_plugin_cpu',
sources: [
'fu-plugin-cpu.c',
'fu-cpu-plugin.c',
'fu-cpu-device.c',
],
include_directories: [
root_incdir,
fwupd_incdir,
fwupdplugin_incdir,
],
install: true,
install_dir: plugin_dir,
link_with: [
fwupd,
fwupdplugin,
],
include_directories: plugin_incdirs,
link_with: plugin_libs,
c_args: cargs,
dependencies: [
plugin_deps,
],
dependencies: plugin_deps,
)
code = '''

37
plugins/cros-ec/fu-cros-ec-plugin.c Normal file
View File

@ -0,0 +1,37 @@
/*
* Copyright (C) 2020 Benson Leung <bleung@chromium.org>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#include "config.h"
#include "fu-cros-ec-firmware.h"
#include "fu-cros-ec-plugin.h"
#include "fu-cros-ec-usb-device.h"
struct _FuCrosEcPlugin {
FuPlugin parent_instance;
};
G_DEFINE_TYPE(FuCrosEcPlugin, fu_cros_ec_plugin, FU_TYPE_PLUGIN)
static void
fu_cros_ec_plugin_init(FuCrosEcPlugin *self)
{
}
static void
fu_cros_ec_plugin_constructed(GObject *obj)
{
FuPlugin *plugin = FU_PLUGIN(obj);
fu_plugin_add_device_gtype(plugin, FU_TYPE_CROS_EC_USB_DEVICE);
fu_plugin_add_firmware_gtype(plugin, NULL, FU_TYPE_CROS_EC_FIRMWARE);
}
static void
fu_cros_ec_plugin_class_init(FuCrosEcPluginClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS(klass);
object_class->constructed = fu_cros_ec_plugin_constructed;
}

11
plugins/cros-ec/fu-cros-ec-plugin.h Normal file
View File

@ -0,0 +1,11 @@
/*
* Copyright (C) 2022 Richard Hughes <richard@hughsie.com>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#pragma once
#include <fwupdplugin.h>
G_DECLARE_FINAL_TYPE(FuCrosEcPlugin, fu_cros_ec_plugin, FU, CROS_EC_PLUGIN, FuPlugin)

26
plugins/cros-ec/fu-plugin-cros-ec.c
View File

@ -1,26 +0,0 @@
/*
* Copyright (C) 2020 Benson Leung <bleung@chromium.org>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#include "config.h"
#include <fwupdplugin.h>
#include "fu-cros-ec-firmware.h"
#include "fu-cros-ec-usb-device.h"
static void
fu_plugin_cros_ec_init(FuPlugin *plugin)
{
fu_plugin_add_device_gtype(plugin, FU_TYPE_CROS_EC_USB_DEVICE);
fu_plugin_add_firmware_gtype(plugin, NULL, FU_TYPE_CROS_EC_FIRMWARE);
}
void
fu_plugin_init_vfuncs(FuPluginVfuncs *vfuncs)
{
vfuncs->build_hash = FU_BUILD_HASH;
vfuncs->init = fu_plugin_cros_ec_init;
}

23
plugins/cros-ec/meson.build
View File

@ -2,29 +2,16 @@ if gusb.found()
cargs = ['-DG_LOG_DOMAIN="FuPluginCrosEc"']
plugin_quirks += files('cros-ec.quirk')
shared_module('fu_plugin_cros_ec',
fu_hash,
plugin_builtins += static_library('fu_plugin_cros_ec',
sources: [
'fu-plugin-cros-ec.c',
'fu-cros-ec-plugin.c',
'fu-cros-ec-usb-device.c',
'fu-cros-ec-common.c', # fuzzing
'fu-cros-ec-firmware.c', # fuzzing
],
include_directories: [
root_incdir,
fwupd_incdir,
fwupdplugin_incdir,
],
install: true,
install_dir: plugin_dir,
link_with: [
fwupd,
fwupdplugin,
],
include_directories: plugin_incdirs,
link_with: plugin_libs,
c_args: cargs,
dependencies: [
plugin_deps,
],
dependencies: plugin_deps,
)
endif

120
plugins/dell-dock/fu-plugin-dell-dock.c → plugins/dell-dock/fu-dell-dock-plugin.c
View File

@ -15,39 +15,17 @@
#include "config.h"
#include <fwupdplugin.h>
#include "fu-dell-dock-common.h"
#include "fu-dell-dock-plugin.h"
static void
fu_plugin_dell_dock_load(FuContext *ctx)
{
fu_context_add_quirk_key(ctx, "DellDockBlobBuildOffset");
fu_context_add_quirk_key(ctx, "DellDockBlobMajorOffset");
fu_context_add_quirk_key(ctx, "DellDockBlobMinorOffset");
fu_context_add_quirk_key(ctx, "DellDockBlobVersionOffset");
fu_context_add_quirk_key(ctx, "DellDockBoardMin");
fu_context_add_quirk_key(ctx, "DellDockHubVersionLowest");
fu_context_add_quirk_key(ctx, "DellDockInstallDurationI2C");
fu_context_add_quirk_key(ctx, "DellDockUnlockTarget");
fu_context_add_quirk_key(ctx, "DellDockVersionLowest");
}
struct _FuDellDockPlugin {
FuPlugin parent_instance;
};
static void
fu_plugin_dell_dock_init(FuPlugin *plugin)
{
/* allow these to be built by quirks */
fu_plugin_add_device_gtype(plugin, FU_TYPE_DELL_DOCK_STATUS);
fu_plugin_add_device_gtype(plugin, FU_TYPE_DELL_DOCK_MST);
#ifndef _WIN32
/* currently slower performance, but more reliable in corner cases */
fu_plugin_add_rule(plugin, FU_PLUGIN_RULE_BETTER_THAN, "synaptics_mst");
#endif
}
G_DEFINE_TYPE(FuDellDockPlugin, fu_dell_dock_plugin, FU_TYPE_PLUGIN)
static gboolean
fu_plugin_dell_dock_create_node(FuPlugin *plugin, FuDevice *device, GError **error)
fu_dell_dock_plugin_create_node(FuPlugin *plugin, FuDevice *device, GError **error)
{
g_autoptr(FuDeviceLocker) locker = NULL;
@ -61,7 +39,7 @@ fu_plugin_dell_dock_create_node(FuPlugin *plugin, FuDevice *device, GError **err
}
static gboolean
fu_plugin_dell_dock_probe(FuPlugin *plugin, FuDevice *proxy, GError **error)
fu_dell_dock_plugin_probe(FuPlugin *plugin, FuDevice *proxy, GError **error)
{
const gchar *instance_id_mst;
const gchar *instance_id_status;
@ -74,7 +52,7 @@ fu_plugin_dell_dock_probe(FuPlugin *plugin, FuDevice *proxy, GError **error)
/* create ec endpoint */
ec_device = fu_dell_dock_ec_new(proxy);
if (!fu_plugin_dell_dock_create_node(plugin, FU_DEVICE(ec_device), error))
if (!fu_dell_dock_plugin_create_node(plugin, FU_DEVICE(ec_device), error))
return FALSE;
/* create mst endpoint */
@ -89,7 +67,7 @@ fu_plugin_dell_dock_probe(FuPlugin *plugin, FuDevice *proxy, GError **error)
if (!fu_device_probe(FU_DEVICE(mst_device), error))
return FALSE;
fu_device_add_child(FU_DEVICE(ec_device), FU_DEVICE(mst_device));
if (!fu_plugin_dell_dock_create_node(plugin, FU_DEVICE(mst_device), error))
if (!fu_dell_dock_plugin_create_node(plugin, FU_DEVICE(mst_device), error))
return FALSE;
/* create package version endpoint */
@ -104,7 +82,7 @@ fu_plugin_dell_dock_probe(FuPlugin *plugin, FuDevice *proxy, GError **error)
fu_device_add_guid(FU_DEVICE(status_device), fwupd_guid_hash_string(instance_guid_status));
fu_device_add_child(FU_DEVICE(ec_device), FU_DEVICE(status_device));
fu_device_add_instance_id(FU_DEVICE(status_device), instance_id_status);
if (!fu_plugin_dell_dock_create_node(plugin, FU_DEVICE(status_device), error))
if (!fu_dell_dock_plugin_create_node(plugin, FU_DEVICE(status_device), error))
return FALSE;
/* create TBT endpoint if Thunderbolt SKU and Thunderbolt link inactive */
@ -114,7 +92,7 @@ fu_plugin_dell_dock_probe(FuPlugin *plugin, FuDevice *proxy, GError **error)
fwupd_guid_hash_string(DELL_DOCK_TBT_INSTANCE_ID);
fu_device_add_guid(FU_DEVICE(tbt_device), instance_guid_tbt);
fu_device_add_child(FU_DEVICE(ec_device), FU_DEVICE(tbt_device));
if (!fu_plugin_dell_dock_create_node(plugin, FU_DEVICE(tbt_device), error))
if (!fu_dell_dock_plugin_create_node(plugin, FU_DEVICE(tbt_device), error))
return FALSE;
}
@ -123,7 +101,7 @@ fu_plugin_dell_dock_probe(FuPlugin *plugin, FuDevice *proxy, GError **error)
/* prefer to use EC if in the transaction and parent if it is not */
static FuDevice *
fu_plugin_dell_dock_get_ec(GPtrArray *devices)
fu_dell_dock_plugin_get_ec(GPtrArray *devices)
{
FuDevice *ec_parent = NULL;
for (gint i = devices->len - 1; i >= 0; i--) {
@ -140,7 +118,7 @@ fu_plugin_dell_dock_get_ec(GPtrArray *devices)
}
static gboolean
fu_plugin_dell_dock_backend_device_added(FuPlugin *plugin, FuDevice *device, GError **error)
fu_dell_dock_plugin_backend_device_added(FuPlugin *plugin, FuDevice *device, GError **error)
{
g_autoptr(FuDeviceLocker) locker = NULL;
g_autoptr(FuDellDockHub) hub = NULL;
@ -161,13 +139,13 @@ fu_plugin_dell_dock_backend_device_added(FuPlugin *plugin, FuDevice *device, GEr
/* probe extend devices under Usb3.1 Gen 2 Hub */
if (fu_device_has_private_flag(FU_DEVICE(hub), FU_DELL_DOCK_HUB_FLAG_HAS_BRIDGE)) {
if (!fu_plugin_dell_dock_probe(plugin, FU_DEVICE(hub), error))
if (!fu_dell_dock_plugin_probe(plugin, FU_DEVICE(hub), error))
return FALSE;
}
/* process hub devices if ec device is added */
devices = fu_plugin_get_devices(plugin);
ec_device = fu_plugin_dell_dock_get_ec(devices);
ec_device = fu_dell_dock_plugin_get_ec(devices);
if (ec_device == NULL) {
fu_plugin_cache_add(plugin, hub_cache_key, FU_DEVICE(hub));
return TRUE;
@ -196,7 +174,7 @@ fu_plugin_dell_dock_backend_device_added(FuPlugin *plugin, FuDevice *device, GEr
}
static void
fu_plugin_dell_dock_separate_activation(FuPlugin *plugin)
fu_dell_dock_plugin_separate_activation(FuPlugin *plugin)
{
FuDevice *device_ec = fu_plugin_cache_lookup(plugin, "ec");
FuDevice *device_usb4 = fu_plugin_cache_lookup(plugin, "usb4");
@ -215,7 +193,7 @@ fu_plugin_dell_dock_separate_activation(FuPlugin *plugin)
}
static void
fu_plugin_dell_dock_device_registered(FuPlugin *plugin, FuDevice *device)
fu_dell_dock_plugin_device_registered(FuPlugin *plugin, FuDevice *device)
{
/* dell dock delays the activation so skips device restart */
if (fu_device_has_guid(device, DELL_DOCK_TBT_INSTANCE_ID)) {
@ -240,11 +218,11 @@ fu_plugin_dell_dock_device_registered(FuPlugin *plugin, FuDevice *device)
}
/* online activation is mutually exclusive between usb4 and ec */
fu_plugin_dell_dock_separate_activation(plugin);
fu_dell_dock_plugin_separate_activation(plugin);
}
static gboolean
fu_plugin_dell_dock_backend_device_removed(FuPlugin *plugin, FuDevice *device, GError **error)
fu_dell_dock_plugin_backend_device_removed(FuPlugin *plugin, FuDevice *device, GError **error)
{
const gchar *device_key = fu_device_get_id(device);
FuDevice *dev;
@ -267,9 +245,9 @@ fu_plugin_dell_dock_backend_device_removed(FuPlugin *plugin, FuDevice *device, G
}
static gboolean
fu_plugin_dell_dock_composite_prepare(FuPlugin *plugin, GPtrArray *devices, GError **error)
fu_dell_dock_plugin_composite_prepare(FuPlugin *plugin, GPtrArray *devices, GError **error)
{
FuDevice *parent = fu_plugin_dell_dock_get_ec(devices);
FuDevice *parent = fu_dell_dock_plugin_get_ec(devices);
const gchar *sku;
if (parent == NULL)
return TRUE;
@ -281,9 +259,9 @@ fu_plugin_dell_dock_composite_prepare(FuPlugin *plugin, GPtrArray *devices, GErr
}
static gboolean
fu_plugin_dell_dock_composite_cleanup(FuPlugin *plugin, GPtrArray *devices, GError **error)
fu_dell_dock_plugin_composite_cleanup(FuPlugin *plugin, GPtrArray *devices, GError **error)
{
FuDevice *parent = fu_plugin_dell_dock_get_ec(devices);
FuDevice *parent = fu_dell_dock_plugin_get_ec(devices);
FuDevice *dev = NULL;
g_autoptr(FuDeviceLocker) locker = NULL;
gboolean needs_activation = FALSE;
@ -309,7 +287,7 @@ fu_plugin_dell_dock_composite_cleanup(FuPlugin *plugin, GPtrArray *devices, GErr
}
}
/* separate activation flag between usb4 and ec device */
fu_plugin_dell_dock_separate_activation(plugin);
fu_dell_dock_plugin_separate_activation(plugin);
locker = fu_device_locker_new(parent, error);
if (locker == NULL)
@ -331,15 +309,45 @@ fu_plugin_dell_dock_composite_cleanup(FuPlugin *plugin, GPtrArray *devices, GErr
return TRUE;
}
void
fu_plugin_init_vfuncs(FuPluginVfuncs *vfuncs)
static void
fu_dell_dock_plugin_init(FuDellDockPlugin *self)
{
vfuncs->build_hash = FU_BUILD_HASH;
vfuncs->load = fu_plugin_dell_dock_load;
vfuncs->init = fu_plugin_dell_dock_init;
vfuncs->device_registered = fu_plugin_dell_dock_device_registered;
vfuncs->backend_device_added = fu_plugin_dell_dock_backend_device_added;
vfuncs->backend_device_removed = fu_plugin_dell_dock_backend_device_removed;
vfuncs->composite_cleanup = fu_plugin_dell_dock_composite_cleanup;
vfuncs->composite_prepare = fu_plugin_dell_dock_composite_prepare;
}
static void
fu_dell_dock_plugin_constructed(GObject *obj)
{
FuPlugin *plugin = FU_PLUGIN(obj);
FuContext *ctx = fu_plugin_get_context(plugin);
fu_context_add_quirk_key(ctx, "DellDockBlobBuildOffset");
fu_context_add_quirk_key(ctx, "DellDockBlobMajorOffset");
fu_context_add_quirk_key(ctx, "DellDockBlobMinorOffset");
fu_context_add_quirk_key(ctx, "DellDockBlobVersionOffset");
fu_context_add_quirk_key(ctx, "DellDockBoardMin");
fu_context_add_quirk_key(ctx, "DellDockHubVersionLowest");
fu_context_add_quirk_key(ctx, "DellDockInstallDurationI2C");
fu_context_add_quirk_key(ctx, "DellDockUnlockTarget");
fu_context_add_quirk_key(ctx, "DellDockVersionLowest");
/* allow these to be built by quirks */
fu_plugin_add_device_gtype(plugin, FU_TYPE_DELL_DOCK_STATUS);
fu_plugin_add_device_gtype(plugin, FU_TYPE_DELL_DOCK_MST);
#ifndef _WIN32
/* currently slower performance, but more reliable in corner cases */
fu_plugin_add_rule(plugin, FU_PLUGIN_RULE_BETTER_THAN, "synaptics_mst");
#endif
}
static void
fu_dell_dock_plugin_class_init(FuDellDockPluginClass *klass)
{
FuPluginClass *plugin_class = FU_PLUGIN_CLASS(klass);
GObjectClass *object_class = G_OBJECT_CLASS(klass);
object_class->constructed = fu_dell_dock_plugin_constructed;
plugin_class->device_registered = fu_dell_dock_plugin_device_registered;
plugin_class->backend_device_added = fu_dell_dock_plugin_backend_device_added;
plugin_class->backend_device_removed = fu_dell_dock_plugin_backend_device_removed;
plugin_class->composite_cleanup = fu_dell_dock_plugin_composite_cleanup;
plugin_class->composite_prepare = fu_dell_dock_plugin_composite_prepare;
}

11
plugins/dell-dock/fu-dell-dock-plugin.h Normal file
View File

@ -0,0 +1,11 @@
/*
* Copyright (C) 2022 Richard Hughes <richard@hughsie.com>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#pragma once
#include <fwupdplugin.h>
G_DECLARE_FINAL_TYPE(FuDellDockPlugin, fu_dell_dock_plugin, FU, DELL_DOCK_PLUGIN, FuPlugin)

19
plugins/dell-dock/meson.build
View File

@ -2,11 +2,9 @@ if gusb.found()
cargs = ['-DG_LOG_DOMAIN="FuPluginDellDock"']
plugin_quirks += files('dell-dock.quirk')
shared_module('fu_plugin_dell_dock',
fu_hash,
plugin_builtins += static_library('fu_plugin_dell_dock',
sources: [
'fu-plugin-dell-dock.c',
'fu-dell-dock-plugin.c',
'fu-dell-dock-common.c',
'fu-dell-dock-hid.c',
'fu-dell-dock-status.c',
@ -15,17 +13,8 @@ shared_module('fu_plugin_dell_dock',
'fu-dell-dock-i2c-tbt.c',
'fu-dell-dock-i2c-mst.c',
],
include_directories: [
root_incdir,
fwupd_incdir,
fwupdplugin_incdir,
],
install: true,
install_dir: plugin_dir,
link_with: [
fwupd,
fwupdplugin,
],
include_directories: plugin_incdirs,
link_with: plugin_libs,
c_args: cargs,
dependencies: [
plugin_deps,

57
plugins/dell-esrt/fu-plugin-dell-esrt.c → plugins/dell-esrt/fu-dell-esrt-plugin.c
View File

@ -7,14 +7,20 @@
#include "config.h"
#include <fwupdplugin.h>
#include <fcntl.h>
#include <smbios_c/smi.h>
#include <smbios_c/token.h>
#include <sys/stat.h>
#include <sys/types.h>
#include "fu-dell-esrt-plugin.h"
struct _FuDellEsrtPlugin {
FuPlugin parent_instance;
};
G_DEFINE_TYPE(FuDellEsrtPlugin, fu_dell_esrt_plugin, FU_TYPE_PLUGIN)
/* allowed smbios class/select commands */
#define CLASS_ADMIN_PROP 10
#define SELECT_ADMIN_PROP 3
@ -28,7 +34,7 @@
#define DELL_ADMIN_INSTALLED 0
static gboolean
fu_plugin_dell_esrt_query_token(guint16 token, gboolean *value, GError **error)
fu_dell_esrt_plugin_query_token(guint16 token, gboolean *value, GError **error)
{
if (!token_is_bool(token)) {
g_set_error(error,
@ -45,7 +51,7 @@ fu_plugin_dell_esrt_query_token(guint16 token, gboolean *value, GError **error)
}
static gboolean
fu_plugin_dell_esrt_activate_token(guint16 token, GError **error)
fu_dell_esrt_plugin_activate_token(guint16 token, GError **error)
{
token_activate(token);
if (token_is_active(token) < 0) {
@ -61,7 +67,7 @@ fu_plugin_dell_esrt_activate_token(guint16 token, GError **error)
}
static gboolean
fu_plugin_dell_esrt_admin_password_present(gboolean *password_present, GError **error)
fu_dell_esrt_plugin_admin_password_present(gboolean *password_present, GError **error)
{
guint32 args[4] =
{
@ -87,14 +93,8 @@ fu_plugin_dell_esrt_admin_password_present(gboolean *password_present, GError **
return TRUE;
}
static void
fu_plugin_dell_esrt_init(FuPlugin *plugin)
{
fu_plugin_add_rule(plugin, FU_PLUGIN_RULE_BETTER_THAN, "bios");
}
static gboolean
fu_plugin_dell_esrt_startup(FuPlugin *plugin, FuProgress *progress, GError **error)
fu_dell_esrt_plugin_startup(FuPlugin *plugin, FuProgress *progress, GError **error)
{
gboolean capsule_disable = FALSE;
g_autofree gchar *sysfsfwdir = NULL;
@ -112,11 +112,11 @@ fu_plugin_dell_esrt_startup(FuPlugin *plugin, FuProgress *progress, GError **err
}
/* is the capsule functionality disabled */
if (!fu_plugin_dell_esrt_query_token(CAPSULE_DIS_TOKEN, &capsule_disable, error))
if (!fu_dell_esrt_plugin_query_token(CAPSULE_DIS_TOKEN, &capsule_disable, error))
return FALSE;
if (!capsule_disable) {
gboolean capsule_enable = FALSE;
if (!fu_plugin_dell_esrt_query_token(CAPSULE_EN_TOKEN, &capsule_enable, error))
if (!fu_dell_esrt_plugin_query_token(CAPSULE_EN_TOKEN, &capsule_enable, error))
return FALSE;
if (capsule_enable) {
g_set_error_literal(error,
@ -131,11 +131,11 @@ fu_plugin_dell_esrt_startup(FuPlugin *plugin, FuProgress *progress, GError **err
}
static gboolean
fu_plugin_dell_esrt_unlock(FuPlugin *plugin, FuDevice *device, GError **error)
fu_dell_esrt_plugin_unlock(FuPlugin *plugin, FuDevice *device, GError **error)
{
gboolean password_present = FALSE;
/* check the admin password isn't set */
if (!fu_plugin_dell_esrt_admin_password_present(&password_present, error))
if (!fu_dell_esrt_plugin_admin_password_present(&password_present, error))
return FALSE;
if (password_present) {
const gchar *err_string = "Cannot be unlocked automatically as admin password set";
@ -145,9 +145,9 @@ fu_plugin_dell_esrt_unlock(FuPlugin *plugin, FuDevice *device, GError **error)
}
/* disabled in BIOS, but supported to be enabled via tool */
if (!fu_plugin_dell_esrt_query_token(CAPSULE_EN_TOKEN, NULL, error))
if (!fu_dell_esrt_plugin_query_token(CAPSULE_EN_TOKEN, NULL, error))
return FALSE;
if (!fu_plugin_dell_esrt_activate_token(CAPSULE_EN_TOKEN, error))
if (!fu_dell_esrt_plugin_activate_token(CAPSULE_EN_TOKEN, error))
return FALSE;
fu_device_set_update_error(device, NULL);
@ -155,7 +155,7 @@ fu_plugin_dell_esrt_unlock(FuPlugin *plugin, FuDevice *device, GError **error)
}
static gboolean
fu_plugin_dell_esrt_coldplug(FuPlugin *plugin, FuProgress *progress, GError **error)
fu_dell_esrt_plugin_coldplug(FuPlugin *plugin, FuProgress *progress, GError **error)
{
g_autoptr(FuDevice) dev = fu_device_new(NULL);
@ -179,12 +179,17 @@ fu_plugin_dell_esrt_coldplug(FuPlugin *plugin, FuProgress *progress, GError **er
return TRUE;
}
void
fu_plugin_init_vfuncs(FuPluginVfuncs *vfuncs)
static void
fu_dell_esrt_plugin_init(FuDellEsrtPlugin *self)
{
vfuncs->build_hash = FU_BUILD_HASH;
vfuncs->init = fu_plugin_dell_esrt_init;
vfuncs->startup = fu_plugin_dell_esrt_startup;
vfuncs->coldplug = fu_plugin_dell_esrt_coldplug;
vfuncs->unlock = fu_plugin_dell_esrt_unlock;
fu_plugin_add_rule(FU_PLUGIN(self), FU_PLUGIN_RULE_BETTER_THAN, "bios");
}
static void
fu_dell_esrt_plugin_class_init(FuDellEsrtPluginClass *klass)
{
FuPluginClass *plugin_class = FU_PLUGIN_CLASS(klass);
plugin_class->startup = fu_dell_esrt_plugin_startup;
plugin_class->coldplug = fu_dell_esrt_plugin_coldplug;
plugin_class->unlock = fu_dell_esrt_plugin_unlock;
}

11
plugins/dell-esrt/fu-dell-esrt-plugin.h Normal file
View File

@ -0,0 +1,11 @@
/*
* Copyright (C) 2022 Richard Hughes <richard@hughsie.com>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#pragma once
#include <fwupdplugin.h>
G_DECLARE_FINAL_TYPE(FuDellEsrtPlugin, fu_dell_esrt_plugin, FU, DELL_ESRT_PLUGIN, FuPlugin)

19
plugins/dell-esrt/meson.build
View File

@ -4,26 +4,15 @@ cargs = ['-DG_LOG_DOMAIN="FuPluginDellEsrt"']
install_data(['metadata.xml'],
install_dir: join_paths(datadir, 'fwupd', 'remotes.d', 'dell-esrt')
)
shared_module('fu_plugin_dell_esrt',
fu_hash,
plugin_builtins += static_library('fu_plugin_dell_esrt',
sources: [
'fu-plugin-dell-esrt.c',
'fu-dell-esrt-plugin.c',
],
include_directories: [
root_incdir,
fwupd_incdir,
fwupdplugin_incdir,
],
install: true,
install_dir: plugin_dir,
include_directories: plugin_incdirs,
c_args: [
cargs,
],
link_with: [
fwupd,
fwupdplugin,
],
link_with: plugin_libs,
dependencies: [
plugin_deps,
libsmbios_c,

242
plugins/dell/fu-plugin-dell.c → plugins/dell/fu-dell-plugin.c
View File

@ -7,8 +7,6 @@
#include "config.h"
#include <fwupdplugin.h>
#include <fcntl.h>
#include <glib/gstdio.h>
#include <smbios_c/system_info.h>
@ -16,8 +14,20 @@
#include <tss2/tss2_esys.h>
#include <unistd.h>
#include "fu-dell-plugin.h"
#include "fu-plugin-dell.h"
struct _FuDellPlugin {
FuPlugin parent_instance;
FuDellSmiObj *smi_obj;
guint16 fake_vid;
guint16 fake_pid;
gboolean can_switch_modes;
gboolean capsule_supported;
};
G_DEFINE_TYPE(FuDellPlugin, fu_dell_plugin, FU_TYPE_PLUGIN)
/* These are used to indicate the status of a previous DELL flash */
#define DELL_SUCCESS 0x0000
#define DELL_CONSISTENCY_FAIL 0x0001
@ -112,14 +122,14 @@ static guint8 enclosure_allowlist[] = {0x03, /* desktop */
static guint16
fu_dell_get_system_id(FuPlugin *plugin)
{
FuDellPlugin *self = FU_DELL_PLUGIN(plugin);
FuContext *ctx = fu_plugin_get_context(plugin);
FuPluginData *priv = fu_plugin_get_data(plugin);
const gchar *system_id_str = NULL;
guint16 system_id = 0;
gchar *endptr = NULL;
/* don't care for test suite */
if (priv->smi_obj->fake_smbios)
if (self->smi_obj->fake_smbios)
return 0;
system_id_str = fu_context_get_hwid_value(ctx, FU_HWIDS_KEY_PRODUCT_SKU);
@ -179,7 +189,7 @@ fu_dell_supported(FuPlugin *plugin)
}
static gboolean
fu_plugin_dell_match_dock_component(const gchar *query_str,
fu_dell_plugin_match_dock_component(const gchar *query_str,
const gchar **guid_out,
const gchar **name_out)
{
@ -207,31 +217,29 @@ fu_plugin_dell_match_dock_component(const gchar *query_str,
}
void
fu_plugin_dell_inject_fake_data(FuPlugin *plugin,
fu_dell_plugin_inject_fake_data(FuPlugin *plugin,
guint32 *output,
guint16 vid,
guint16 pid,
guint8 *buf,
gboolean can_switch_modes)
{
FuPluginData *priv = fu_plugin_get_data(plugin);
if (!priv->smi_obj->fake_smbios)
FuDellPlugin *self = FU_DELL_PLUGIN(plugin);
if (!self->smi_obj->fake_smbios)
return;
for (guint i = 0; i < 4; i++)
priv->smi_obj->output[i] = output[i];
priv->fake_vid = vid;
priv->fake_pid = pid;
priv->smi_obj->fake_buffer = buf;
priv->can_switch_modes = TRUE;
self->smi_obj->output[i] = output[i];
self->fake_vid = vid;
self->fake_pid = pid;
self->smi_obj->fake_buffer = buf;
self->can_switch_modes = TRUE;
}
static gboolean
fu_plugin_dell_capsule_supported(FuPlugin *plugin)
fu_dell_plugin_capsule_supported(FuPlugin *plugin)
{
FuPluginData *priv = fu_plugin_get_data(plugin);
return priv->smi_obj->fake_smbios || priv->capsule_supported;
FuDellPlugin *self = FU_DELL_PLUGIN(plugin);
return self->smi_obj->fake_smbios || self->capsule_supported;
}
static gboolean
@ -278,7 +286,7 @@ fu_plugin_dock_node(FuPlugin *plugin,
fu_device_set_version_format(dev, version_format);
if (version != NULL) {
fu_device_set_version(dev, version);
if (fu_plugin_dell_capsule_supported(plugin)) {
if (fu_dell_plugin_capsule_supported(plugin)) {
fu_device_add_flag(dev, FWUPD_DEVICE_FLAG_UPDATABLE);
fu_device_add_flag(dev, FWUPD_DEVICE_FLAG_NEEDS_REBOOT);
}
@ -289,9 +297,9 @@ fu_plugin_dock_node(FuPlugin *plugin,
}
gboolean
fu_plugin_dell_backend_device_added(FuPlugin *plugin, FuDevice *device, GError **error)
fu_dell_plugin_backend_device_added(FuPlugin *plugin, FuDevice *device, GError **error)
{
FuPluginData *priv = fu_plugin_get_data(plugin);
FuDellPlugin *self = FU_DELL_PLUGIN(plugin);
FwupdVersionFormat version_format = FWUPD_VERSION_FORMAT_DELL_BIOS;
guint16 pid;
guint16 vid;
@ -315,13 +323,13 @@ fu_plugin_dell_backend_device_added(FuPlugin *plugin, FuDevice *device, GError *
/* don't look up immediately if a dock is connected as that would
mean a SMI on every USB device that showed up on the system */
if (!priv->smi_obj->fake_smbios) {
if (!self->smi_obj->fake_smbios) {
vid = fu_usb_device_get_vid(FU_USB_DEVICE(device));
pid = fu_usb_device_get_pid(FU_USB_DEVICE(device));
platform = fu_device_get_physical_id(FU_DEVICE(device));
} else {
vid = priv->fake_vid;
pid = priv->fake_pid;
vid = self->fake_vid;
pid = self->fake_pid;
platform = "fake";
}
@ -337,7 +345,7 @@ fu_plugin_dell_backend_device_added(FuPlugin *plugin, FuDevice *device, GError *
}
buf.buf = NULL;
if (!fu_dell_query_dock(priv->smi_obj, &buf)) {
if (!fu_dell_query_dock(self->smi_obj, &buf)) {
g_debug("no dock detected");
return TRUE;
}
@ -382,7 +390,7 @@ fu_plugin_dell_backend_device_added(FuPlugin *plugin, FuDevice *device, GError *
"invalid dock component request");
return FALSE;
}
if (!fu_plugin_dell_match_dock_component(query_str + 6,
if (!fu_dell_plugin_match_dock_component(query_str + 6,
&component_guid,
&component_name)) {
g_set_error(error,
@ -451,7 +459,7 @@ fu_plugin_dell_backend_device_added(FuPlugin *plugin, FuDevice *device, GError *
}
static gboolean
fu_plugin_dell_get_results(FuPlugin *plugin, FuDevice *device, GError **error)
fu_dell_plugin_get_results(FuPlugin *plugin, FuDevice *device, GError **error)
{
FuContext *ctx = fu_plugin_get_context(plugin);
g_autoptr(GBytes) de_table = NULL;
@ -545,7 +553,7 @@ Esys_Finalize_autoptr_cleanup(ESYS_CONTEXT *esys_context)
G_DEFINE_AUTOPTR_CLEANUP_FUNC(ESYS_CONTEXT, Esys_Finalize_autoptr_cleanup)
static gchar *
fu_plugin_dell_get_tpm_capability(ESYS_CONTEXT *ctx, guint32 query)
fu_dell_plugin_get_tpm_capability(ESYS_CONTEXT *ctx, guint32 query)
{
TSS2_RC rc;
guint32 val;
@ -588,7 +596,7 @@ fu_plugin_dell_get_tpm_capability(ESYS_CONTEXT *ctx, guint32 query)
}
static gboolean
fu_plugin_dell_add_tpm_model(FuDevice *dev, GError **error)
fu_dell_plugin_add_tpm_model(FuDevice *dev, GError **error)
{
TSS2_RC rc;
const gchar *base = "DELL-TPM";
@ -622,7 +630,7 @@ fu_plugin_dell_add_tpm_model(FuDevice *dev, GError **error)
}
/* lookup guaranteed details from TPM */
family = fu_plugin_dell_get_tpm_capability(ctx, TPM2_PT_FAMILY_INDICATOR);
family = fu_dell_plugin_get_tpm_capability(ctx, TPM2_PT_FAMILY_INDICATOR);
if (family == NULL) {
g_set_error_literal(error,
G_IO_ERROR,
@ -630,7 +638,7 @@ fu_plugin_dell_add_tpm_model(FuDevice *dev, GError **error)
"failed to read TPM family");
return FALSE;
}
manufacturer = fu_plugin_dell_get_tpm_capability(ctx, TPM2_PT_MANUFACTURER);
manufacturer = fu_dell_plugin_get_tpm_capability(ctx, TPM2_PT_MANUFACTURER);
if (manufacturer == NULL) {
g_set_error_literal(error,
G_IO_ERROR,
@ -638,7 +646,7 @@ fu_plugin_dell_add_tpm_model(FuDevice *dev, GError **error)
"failed to read TPM manufacturer");
return FALSE;
}
vendor1 = fu_plugin_dell_get_tpm_capability(ctx, TPM2_PT_VENDOR_STRING_1);
vendor1 = fu_dell_plugin_get_tpm_capability(ctx, TPM2_PT_VENDOR_STRING_1);
if (vendor1 == NULL) {
g_set_error_literal(error,
G_IO_ERROR,
@ -649,9 +657,9 @@ fu_plugin_dell_add_tpm_model(FuDevice *dev, GError **error)
fu_device_set_metadata(dev, "TpmFamily", family);
/* these are not guaranteed by spec and may be NULL */
vendor2 = fu_plugin_dell_get_tpm_capability(ctx, TPM2_PT_VENDOR_STRING_2);
vendor3 = fu_plugin_dell_get_tpm_capability(ctx, TPM2_PT_VENDOR_STRING_3);
vendor4 = fu_plugin_dell_get_tpm_capability(ctx, TPM2_PT_VENDOR_STRING_4);
vendor2 = fu_dell_plugin_get_tpm_capability(ctx, TPM2_PT_VENDOR_STRING_2);
vendor3 = fu_dell_plugin_get_tpm_capability(ctx, TPM2_PT_VENDOR_STRING_3);
vendor4 = fu_dell_plugin_get_tpm_capability(ctx, TPM2_PT_VENDOR_STRING_4);
/* add GUIDs to daemon */
v1 = g_strjoin("-", base, family, manufacturer, vendor1, NULL);
@ -667,10 +675,10 @@ fu_plugin_dell_add_tpm_model(FuDevice *dev, GError **error)
}
gboolean
fu_plugin_dell_detect_tpm(FuPlugin *plugin, GError **error)
fu_dell_plugin_detect_tpm(FuPlugin *plugin, GError **error)
{
FuDellPlugin *self = FU_DELL_PLUGIN(plugin);
FuContext *ctx = fu_plugin_get_context(plugin);
FuPluginData *priv = fu_plugin_get_data(plugin);
const gchar *tpm_mode;
const gchar *tpm_mode_alt;
guint16 system_id = 0;
@ -688,12 +696,12 @@ fu_plugin_dell_detect_tpm(FuPlugin *plugin, GError **error)
g_autoptr(FuDevice) dev = NULL;
g_autoptr(GError) error_tss = NULL;
fu_dell_clear_smi(priv->smi_obj);
out = (struct tpm_status *)priv->smi_obj->output;
fu_dell_clear_smi(self->smi_obj);
out = (struct tpm_status *)self->smi_obj->output;
/* execute TPM Status Query */
priv->smi_obj->input[0] = DACI_FLASH_ARG_TPM;
if (!fu_dell_execute_simple_smi(priv->smi_obj,
self->smi_obj->input[0] = DACI_FLASH_ARG_TPM;
if (!fu_dell_execute_simple_smi(self->smi_obj,
DACI_FLASH_INTERFACE_CLASS,
DACI_FLASH_INTERFACE_SELECT))
return FALSE;
@ -707,7 +715,7 @@ fu_plugin_dell_detect_tpm(FuPlugin *plugin, GError **error)
/* HW version is output in second /input/ arg
* it may be relevant as next gen TPM is enabled
*/
g_debug("TPM HW version: 0x%x", priv->smi_obj->input[1]);
g_debug("TPM HW version: 0x%x", self->smi_obj->input[1]);
g_debug("TPM Status: 0x%x", out->status);
/* test TPM enabled (Bit 0) */
@ -729,8 +737,8 @@ fu_plugin_dell_detect_tpm(FuPlugin *plugin, GError **error)
}
system_id = fu_dell_get_system_id(plugin);
if (priv->smi_obj->fake_smbios)
can_switch_modes = priv->can_switch_modes;
if (self->smi_obj->fake_smbios)
can_switch_modes = self->can_switch_modes;
else if (system_id == 0)
return FALSE;
@ -773,7 +781,7 @@ fu_plugin_dell_detect_tpm(FuPlugin *plugin, GError **error)
fu_device_add_icon(dev, "computer");
fu_device_set_metadata(dev, FU_DEVICE_METADATA_UEFI_DEVICE_KIND, "dell-tpm-firmware");
if ((out->status & TPM_OWN_MASK) == 0 && out->flashes_left > 0) {
if (fu_plugin_dell_capsule_supported(plugin)) {
if (fu_dell_plugin_capsule_supported(plugin)) {
fu_device_add_flag(dev, FWUPD_DEVICE_FLAG_UPDATABLE);
fu_device_add_flag(dev, FWUPD_DEVICE_FLAG_NEEDS_REBOOT);
}
@ -782,7 +790,7 @@ fu_plugin_dell_detect_tpm(FuPlugin *plugin, GError **error)
fu_device_set_update_error(dev, "Updating disabled due to TPM ownership");
}
/* build GUIDs from TSS strings */
if (!fu_plugin_dell_add_tpm_model(dev, &error_tss))
if (!fu_dell_plugin_add_tpm_model(dev, &error_tss))
g_debug("could not build instances: %s", error_tss->message);
if (!fu_device_setup(dev, error))
@ -832,7 +840,7 @@ fu_plugin_dell_detect_tpm(FuPlugin *plugin, GError **error)
}
static void
fu_plugin_dell_device_registered(FuPlugin *plugin, FuDevice *device)
fu_dell_plugin_device_registered(FuPlugin *plugin, FuDevice *device)
{
/* thunderbolt plugin */
if (g_strcmp0(fu_device_get_plugin(device), "thunderbolt") == 0 &&
@ -857,65 +865,21 @@ fu_plugin_dell_device_registered(FuPlugin *plugin, FuDevice *device)
}
static void
fu_plugin_dell_load(FuContext *ctx)
fu_dell_plugin_to_string(FuPlugin *plugin, guint idt, GString *str)
{
g_autofree gchar *tmp = NULL;
tmp = g_strdup_printf("%d.%d",
smbios_get_library_version_major(),
smbios_get_library_version_minor());
fu_context_add_runtime_version(ctx, "com.dell.libsmbios", tmp);
g_debug("Using libsmbios %s", tmp);
}
static void
fu_plugin_dell_init(FuPlugin *plugin)
{
FuPluginData *priv = fu_plugin_alloc_data(plugin, sizeof(FuPluginData));
priv->smi_obj = g_malloc0(sizeof(FuDellSmiObj));
if (g_getenv("FWUPD_DELL_VERBOSE") != NULL)
(void)g_setenv("LIBSMBIOS_C_DEBUG_OUTPUT_ALL", "1", TRUE);
else
(void)g_setenv("TSS2_LOG", "esys+none,tcti+none", FALSE);
if (fu_dell_supported(plugin))
priv->smi_obj->smi = dell_smi_factory(DELL_SMI_DEFAULTS);
priv->smi_obj->fake_smbios = FALSE;
if (g_getenv("FWUPD_DELL_FAKE_SMBIOS") != NULL)
priv->smi_obj->fake_smbios = TRUE;
/* make sure that UEFI plugin is ready to receive devices */
fu_plugin_add_rule(plugin, FU_PLUGIN_RULE_RUN_AFTER, "uefi_capsule");
/* our TPM device is upgradable! */
fu_plugin_add_rule(plugin, FU_PLUGIN_RULE_BETTER_THAN, "tpm");
}
static void
fu_plugin_dell_to_string(FuPlugin *plugin, guint idt, GString *str)
{
FuPluginData *priv = fu_plugin_get_data(plugin);
fu_string_append_kb(str, idt, "CanSwitchModes", priv->can_switch_modes);
fu_string_append_kb(str, idt, "CapsuleSupported", priv->capsule_supported);
}
static void
fu_plugin_dell_destroy(FuPlugin *plugin)
{
FuPluginData *priv = fu_plugin_get_data(plugin);
if (priv->smi_obj->smi)
dell_smi_obj_free(priv->smi_obj->smi);
g_free(priv->smi_obj);
FuDellPlugin *self = FU_DELL_PLUGIN(plugin);
fu_string_append_kb(str, idt, "CanSwitchModes", self->can_switch_modes);
fu_string_append_kb(str, idt, "CapsuleSupported", self->capsule_supported);
}
static gboolean
fu_plugin_dell_startup(FuPlugin *plugin, FuProgress *progress, GError **error)
fu_dell_plugin_startup(FuPlugin *plugin, FuProgress *progress, GError **error)
{
FuPluginData *priv = fu_plugin_get_data(plugin);
FuDellPlugin *self = FU_DELL_PLUGIN(plugin);
g_autofree gchar *sysfsfwdir = NULL;
g_autofree gchar *esrtdir = NULL;
if (priv->smi_obj->fake_smbios) {
if (self->smi_obj->fake_smbios) {
g_debug("Called with fake SMBIOS implementation. "
"We're ignoring test for SBMIOS table and ESRT. "
"Individual calls will need to be properly staged.");
@ -930,7 +894,7 @@ fu_plugin_dell_startup(FuPlugin *plugin, FuProgress *progress, GError **error)
return FALSE;
}
if (priv->smi_obj->smi == NULL) {
if (self->smi_obj->smi == NULL) {
g_set_error(error,
FWUPD_ERROR,
FWUPD_ERROR_INTERNAL,
@ -946,10 +910,10 @@ fu_plugin_dell_startup(FuPlugin *plugin, FuProgress *progress, GError **error)
sysfsfwdir = fu_path_from_kind(FU_PATH_KIND_SYSFSDIR_FW);
esrtdir = g_build_filename(sysfsfwdir, "efi", "esrt", NULL);
if (g_file_test(esrtdir, G_FILE_TEST_EXISTS))
priv->capsule_supported = TRUE;
self->capsule_supported = TRUE;
/* capsules not supported */
if (!fu_plugin_dell_capsule_supported(plugin)) {
if (!fu_dell_plugin_capsule_supported(plugin)) {
fu_plugin_add_flag(plugin, FWUPD_PLUGIN_FLAG_USER_WARNING);
fu_plugin_add_flag(plugin, FWUPD_PLUGIN_FLAG_CLEAR_UPDATABLE);
fu_plugin_add_flag(plugin, FWUPD_PLUGIN_FLAG_CAPSULES_UNSUPPORTED);
@ -959,25 +923,73 @@ fu_plugin_dell_startup(FuPlugin *plugin, FuProgress *progress, GError **error)
}
static gboolean
fu_plugin_dell_coldplug(FuPlugin *plugin, FuProgress *progress, GError **error)
fu_dell_plugin_coldplug(FuPlugin *plugin, FuProgress *progress, GError **error)
{
/* look for switchable TPM */
if (!fu_plugin_dell_detect_tpm(plugin, error))
if (!fu_dell_plugin_detect_tpm(plugin, error))
g_debug("No switchable TPM detected");
return TRUE;
}
void
fu_plugin_init_vfuncs(FuPluginVfuncs *vfuncs)
static void
fu_dell_plugin_init(FuDellPlugin *self)
{
vfuncs->build_hash = FU_BUILD_HASH;
vfuncs->load = fu_plugin_dell_load;
vfuncs->init = fu_plugin_dell_init;
vfuncs->destroy = fu_plugin_dell_destroy;
vfuncs->to_string = fu_plugin_dell_to_string;
vfuncs->startup = fu_plugin_dell_startup;
vfuncs->coldplug = fu_plugin_dell_coldplug;
vfuncs->backend_device_added = fu_plugin_dell_backend_device_added;
vfuncs->device_registered = fu_plugin_dell_device_registered;
vfuncs->get_results = fu_plugin_dell_get_results;
self->smi_obj = g_malloc0(sizeof(FuDellSmiObj));
if (g_getenv("FWUPD_DELL_VERBOSE") != NULL)
(void)g_setenv("LIBSMBIOS_C_DEBUG_OUTPUT_ALL", "1", TRUE);
else
(void)g_setenv("TSS2_LOG", "esys+none,tcti+none", FALSE);
}
static void
fu_dell_plugin_constructed(GObject *obj)
{
FuPlugin *plugin = FU_PLUGIN(obj);
FuContext *ctx = fu_plugin_get_context(plugin);
FuDellPlugin *self = FU_DELL_PLUGIN(plugin);
g_autofree gchar *tmp = NULL;
tmp = g_strdup_printf("%d.%d",
smbios_get_library_version_major(),
smbios_get_library_version_minor());
fu_context_add_runtime_version(ctx, "com.dell.libsmbios", tmp);
g_debug("Using libsmbios %s", tmp);
if (fu_dell_supported(plugin))
self->smi_obj->smi = dell_smi_factory(DELL_SMI_DEFAULTS);
self->smi_obj->fake_smbios = FALSE;
if (g_getenv("FWUPD_DELL_FAKE_SMBIOS") != NULL)
self->smi_obj->fake_smbios = TRUE;
/* make sure that UEFI plugin is ready to receive devices */
fu_plugin_add_rule(plugin, FU_PLUGIN_RULE_RUN_AFTER, "uefi_capsule");
/* our TPM device is upgradable! */
fu_plugin_add_rule(plugin, FU_PLUGIN_RULE_BETTER_THAN, "tpm");
}
static void
fu_dell_finalize(GObject *obj)
{
FuDellPlugin *self = FU_DELL_PLUGIN(obj);
if (self->smi_obj->smi)
dell_smi_obj_free(self->smi_obj->smi);
g_free(self->smi_obj);
G_OBJECT_CLASS(fu_dell_plugin_parent_class)->finalize(obj);
}
static void
fu_dell_plugin_class_init(FuDellPluginClass *klass)
{
FuPluginClass *plugin_class = FU_PLUGIN_CLASS(klass);
GObjectClass *object_class = G_OBJECT_CLASS(klass);
object_class->constructed = fu_dell_plugin_constructed;
object_class->finalize = fu_dell_finalize;
plugin_class->to_string = fu_dell_plugin_to_string;
plugin_class->startup = fu_dell_plugin_startup;
plugin_class->coldplug = fu_dell_plugin_coldplug;
plugin_class->backend_device_added = fu_dell_plugin_backend_device_added;
plugin_class->device_registered = fu_dell_plugin_device_registered;
plugin_class->get_results = fu_dell_plugin_get_results;
}

11
plugins/dell/fu-dell-plugin.h Normal file
View File

@ -0,0 +1,11 @@
/*
* Copyright (C) 2022 Richard Hughes <richard@hughsie.com>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#pragma once
#include <fwupdplugin.h>
G_DECLARE_FINAL_TYPE(FuDellPlugin, fu_dell_plugin, FU, DELL_PLUGIN, FuPlugin)

14
plugins/dell/fu-plugin-dell.h
View File

@ -10,16 +10,8 @@
#include "fu-dell-smi.h"
struct FuPluginData {
FuDellSmiObj *smi_obj;
guint16 fake_vid;
guint16 fake_pid;
gboolean can_switch_modes;
gboolean capsule_supported;
};
void
fu_plugin_dell_inject_fake_data(FuPlugin *plugin,
fu_dell_plugin_inject_fake_data(FuPlugin *plugin,
guint32 *output,
guint16 vid,
guint16 pid,
@ -27,9 +19,9 @@ fu_plugin_dell_inject_fake_data(FuPlugin *plugin,
gboolean can_switch_modes);
gboolean
fu_plugin_dell_detect_tpm(FuPlugin *plugin, GError **error);
fu_dell_plugin_detect_tpm(FuPlugin *plugin, GError **error);
gboolean
fu_plugin_dell_backend_device_added(FuPlugin *plugin, FuDevice *device, GError **error);
fu_dell_plugin_backend_device_added(FuPlugin *plugin, FuDevice *device, GError **error);
/* These are nodes that will indicate information about
* the TPM status

78
plugins/dell/fu-self-test.c
View File

@ -11,7 +11,9 @@
#include <glib/gstdio.h>
#include <stdlib.h>
#include "../uefi-capsule/fu-uefi-capsule-plugin.h"
#include "fu-context-private.h"
#include "fu-dell-plugin.h"
#include "fu-device-private.h"
#include "fu-plugin-dell.h"
#include "fu-plugin-private.h"
@ -66,7 +68,7 @@ fu_engine_plugin_device_register_cb(FuPlugin *plugin_dell, FuDevice *device, gpo
}
static void
fu_plugin_dell_tpm_func(gconstpointer user_data)
fu_dell_plugin_tpm_func(gconstpointer user_data)
{
FuTest *self = (FuTest *)user_data;
FuDevice *device_v12;
@ -108,8 +110,8 @@ fu_plugin_dell_tpm_func(gconstpointer user_data)
/* inject fake data (no TPM) */
tpm_out.ret = -2;
fu_plugin_dell_inject_fake_data(self->plugin_dell, (guint32 *)&tpm_out, 0, 0, NULL, FALSE);
ret = fu_plugin_dell_detect_tpm(self->plugin_dell, &error);
fu_dell_plugin_inject_fake_data(self->plugin_dell, (guint32 *)&tpm_out, 0, 0, NULL, FALSE);
ret = fu_dell_plugin_detect_tpm(self->plugin_dell, &error);
g_assert_no_error(error);
g_assert_false(ret);
g_assert_cmpint(devices->len, ==, 0);
@ -124,8 +126,8 @@ fu_plugin_dell_tpm_func(gconstpointer user_data)
tpm_out.fw_version = 0;
tpm_out.status = TPM_EN_MASK | (TPM_1_2_MODE << 8);
tpm_out.flashes_left = 0;
fu_plugin_dell_inject_fake_data(self->plugin_dell, (guint32 *)&tpm_out, 0, 0, NULL, TRUE);
ret = fu_plugin_dell_detect_tpm(self->plugin_dell, &error);
fu_dell_plugin_inject_fake_data(self->plugin_dell, (guint32 *)&tpm_out, 0, 0, NULL, TRUE);
ret = fu_dell_plugin_detect_tpm(self->plugin_dell, &error);
g_assert_true(ret);
g_assert_cmpint(devices->len, ==, 2);
@ -156,8 +158,8 @@ fu_plugin_dell_tpm_func(gconstpointer user_data)
*/
tpm_out.status = TPM_EN_MASK | TPM_OWN_MASK | (TPM_1_2_MODE << 8);
tpm_out.flashes_left = 125;
fu_plugin_dell_inject_fake_data(self->plugin_dell, (guint32 *)&tpm_out, 0, 0, NULL, TRUE);
ret = fu_plugin_dell_detect_tpm(self->plugin_dell, &error);
fu_dell_plugin_inject_fake_data(self->plugin_dell, (guint32 *)&tpm_out, 0, 0, NULL, TRUE);
ret = fu_dell_plugin_detect_tpm(self->plugin_dell, &error);
g_assert_no_error(error);
g_assert_true(ret);
@ -185,8 +187,8 @@ fu_plugin_dell_tpm_func(gconstpointer user_data)
*/
tpm_out.status = TPM_EN_MASK | (TPM_1_2_MODE << 8);
tpm_out.flashes_left = 125;
fu_plugin_dell_inject_fake_data(self->plugin_dell, (guint32 *)&tpm_out, 0, 0, NULL, TRUE);
ret = fu_plugin_dell_detect_tpm(self->plugin_dell, &error);
fu_dell_plugin_inject_fake_data(self->plugin_dell, (guint32 *)&tpm_out, 0, 0, NULL, TRUE);
ret = fu_dell_plugin_detect_tpm(self->plugin_dell, &error);
g_assert_no_error(error);
g_assert_true(ret);
@ -218,8 +220,8 @@ fu_plugin_dell_tpm_func(gconstpointer user_data)
*/
tpm_out.status = TPM_EN_MASK | (TPM_2_0_MODE << 8);
tpm_out.flashes_left = 1;
fu_plugin_dell_inject_fake_data(self->plugin_dell, (guint32 *)&tpm_out, 0, 0, NULL, TRUE);
ret = fu_plugin_dell_detect_tpm(self->plugin_dell, &error);
fu_dell_plugin_inject_fake_data(self->plugin_dell, (guint32 *)&tpm_out, 0, 0, NULL, TRUE);
ret = fu_dell_plugin_detect_tpm(self->plugin_dell, &error);
g_assert_no_error(error);
g_assert_true(ret);
@ -264,7 +266,7 @@ fu_plugin_dell_tpm_func(gconstpointer user_data)
}
static void
fu_plugin_dell_dock_func(gconstpointer user_data)
fu_dell_plugin_dock_func(gconstpointer user_data)
{
FuTest *self = (FuTest *)user_data;
gboolean ret;
@ -289,13 +291,13 @@ fu_plugin_dell_dock_func(gconstpointer user_data)
self->plugin_uefi_capsule);
/* make sure bad device doesn't trigger this */
fu_plugin_dell_inject_fake_data(self->plugin_dell,
fu_dell_plugin_inject_fake_data(self->plugin_dell,
(guint32 *)&out,
0x1234,
0x4321,
NULL,
FALSE);
ret = fu_plugin_dell_backend_device_added(self->plugin_dell,
ret = fu_dell_plugin_backend_device_added(self->plugin_dell,
FU_DEVICE(fake_usb_device),
&error);
g_assert_false(ret);
@ -305,13 +307,13 @@ fu_plugin_dell_dock_func(gconstpointer user_data)
/* inject a USB receiver matching correct VID/PID */
out[0] = 0;
out[1] = 0;
fu_plugin_dell_inject_fake_data(self->plugin_dell,
fu_dell_plugin_inject_fake_data(self->plugin_dell,
(guint32 *)&out,
DOCK_NIC_VID,
DOCK_NIC_PID,
NULL,
FALSE);
ret = fu_plugin_dell_backend_device_added(self->plugin_dell,
ret = fu_dell_plugin_backend_device_added(self->plugin_dell,
FU_DEVICE(fake_usb_device),
&error);
g_assert_true(ret);
@ -342,13 +344,13 @@ fu_plugin_dell_dock_func(gconstpointer user_data)
44);
out[0] = 0;
out[1] = 1;
fu_plugin_dell_inject_fake_data(self->plugin_dell,
fu_dell_plugin_inject_fake_data(self->plugin_dell,
(guint32 *)&out,
DOCK_NIC_VID,
DOCK_NIC_PID,
buf.buf,
FALSE);
ret = fu_plugin_dell_backend_device_added(self->plugin_dell,
ret = fu_dell_plugin_backend_device_added(self->plugin_dell,
FU_DEVICE(fake_usb_device),
NULL);
g_assert_true(ret);
@ -380,13 +382,13 @@ fu_plugin_dell_dock_func(gconstpointer user_data)
44);
out[0] = 0;
out[1] = 1;
fu_plugin_dell_inject_fake_data(self->plugin_dell,
fu_dell_plugin_inject_fake_data(self->plugin_dell,
(guint32 *)&out,
DOCK_NIC_VID,
DOCK_NIC_PID,
buf.buf,
FALSE);
ret = fu_plugin_dell_backend_device_added(self->plugin_dell,
ret = fu_dell_plugin_backend_device_added(self->plugin_dell,
FU_DEVICE(fake_usb_device),
NULL);
g_assert_true(ret);
@ -416,13 +418,13 @@ fu_plugin_dell_dock_func(gconstpointer user_data)
43);
out[0] = 0;
out[1] = 1;
fu_plugin_dell_inject_fake_data(self->plugin_dell,
fu_dell_plugin_inject_fake_data(self->plugin_dell,
(guint32 *)&out,
DOCK_NIC_VID,
DOCK_NIC_PID,
buf.buf,
FALSE);
ret = fu_plugin_dell_backend_device_added(self->plugin_dell,
ret = fu_dell_plugin_backend_device_added(self->plugin_dell,
FU_DEVICE(fake_usb_device),
&error);
g_assert_no_error(error);
@ -453,13 +455,13 @@ fu_plugin_dell_dock_func(gconstpointer user_data)
43);
out[0] = 0;
out[1] = 1;
fu_plugin_dell_inject_fake_data(self->plugin_dell,
fu_dell_plugin_inject_fake_data(self->plugin_dell,
(guint32 *)&out,
DOCK_NIC_VID,
DOCK_NIC_PID,
buf.buf,
FALSE);
ret = fu_plugin_dell_backend_device_added(self->plugin_dell,
ret = fu_dell_plugin_backend_device_added(self->plugin_dell,
FU_DEVICE(fake_usb_device),
&error);
g_assert_no_error(error);
@ -484,13 +486,13 @@ fu_plugin_dell_dock_func(gconstpointer user_data)
43);
out[0] = 0;
out[1] = 1;
fu_plugin_dell_inject_fake_data(self->plugin_dell,
fu_dell_plugin_inject_fake_data(self->plugin_dell,
(guint32 *)&out,
DOCK_NIC_VID,
DOCK_NIC_PID,
buf.buf,
FALSE);
ret = fu_plugin_dell_backend_device_added(self->plugin_dell,
ret = fu_dell_plugin_backend_device_added(self->plugin_dell,
FU_DEVICE(fake_usb_device),
&error);
g_assert_false(ret);
@ -509,33 +511,19 @@ fu_test_self_init(FuTest *self)
g_autoptr(FuContext) ctx = fu_context_new();
g_autoptr(FuProgress) progress = fu_progress_new(G_STRLOC);
g_autoptr(GError) error = NULL;
g_autofree gchar *pluginfn_uefi = NULL;
g_autofree gchar *pluginfn_dell = NULL;
/* do not save silo */
ret = fu_context_load_quirks(ctx, FU_QUIRKS_LOAD_FLAG_NO_CACHE, &error);
g_assert_no_error(error);
g_assert_true(ret);
self->plugin_uefi_capsule = fu_plugin_new(ctx);
pluginfn_uefi = g_test_build_filename(G_TEST_BUILT,
"..",
"uefi-capsule",
"libfu_plugin_uefi_capsule." G_MODULE_SUFFIX,
NULL);
ret = fu_plugin_open(self->plugin_uefi_capsule, pluginfn_uefi, &error);
g_assert_no_error(error);
g_assert_true(ret);
self->plugin_uefi_capsule =
fu_plugin_new_from_gtype(fu_uefi_capsule_plugin_get_type(), ctx);
ret = fu_plugin_runner_startup(self->plugin_uefi_capsule, progress, &error);
g_assert_no_error(error);
g_assert_true(ret);
self->plugin_dell = fu_plugin_new(ctx);
pluginfn_dell =
g_test_build_filename(G_TEST_BUILT, "libfu_plugin_dell." G_MODULE_SUFFIX, NULL);
ret = fu_plugin_open(self->plugin_dell, pluginfn_dell, &error);
g_assert_no_error(error);
g_assert_true(ret);
self->plugin_dell = fu_plugin_new_from_gtype(fu_dell_plugin_get_type(), ctx);
ret = fu_plugin_runner_startup(self->plugin_dell, progress, &error);
g_assert_no_error(error);
g_assert_true(ret);
@ -583,7 +571,7 @@ main(int argc, char **argv)
/* tests go here */
fu_test_self_init(self);
g_test_add_data_func("/fwupd/plugin{dell:tpm}", self, fu_plugin_dell_tpm_func);
g_test_add_data_func("/fwupd/plugin{dell:dock}", self, fu_plugin_dell_dock_func);
g_test_add_data_func("/fwupd/plugin{dell:tpm}", self, fu_dell_plugin_tpm_func);
g_test_add_data_func("/fwupd/plugin{dell:dock}", self, fu_dell_plugin_dock_func);
return g_test_run();
}

33
plugins/dell/meson.build
View File

@ -9,23 +9,13 @@ cargs = ['-DG_LOG_DOMAIN="FuPluginDell"']
plugin_quirks += files('dell.quirk')
shared_module('fu_plugin_dell',
fu_hash,
plugin_builtin_dell = static_library('fu_plugin_dell',
sources: [
'fu-plugin-dell.c',
'fu-dell-plugin.c',
'fu-dell-smi.c',
],
include_directories: [
root_incdir,
fwupd_incdir,
fwupdplugin_incdir,
],
install: true,
install_dir: plugin_dir,
link_with: [
fwupd,
fwupdplugin,
],
include_directories: plugin_incdirs,
link_with: plugin_libs,
c_args: [
cargs,
],
@ -35,6 +25,7 @@ shared_module('fu_plugin_dell',
tpm2tss_dell,
],
)
plugin_builtins += plugin_builtin_dell
if get_option('tests')
env = environment()
@ -43,17 +34,10 @@ if get_option('tests')
env.set('FWUPD_LOCALSTATEDIR', '/tmp/fwupd-self-test/var')
e = executable(
'dell-self-test',
fu_hash,
sources: [
'fu-self-test.c',
'fu-dell-smi.c',
'fu-plugin-dell.c',
],
include_directories: [
root_incdir,
fwupd_incdir,
fwupdplugin_incdir,
],
include_directories: plugin_incdirs,
dependencies: [
plugin_deps,
libsmbios_c,
@ -61,8 +45,9 @@ if get_option('tests')
tpm2tss_dell,
],
link_with: [
fwupd,
fwupdplugin,
plugin_libs,
plugin_builtin_uefi_capsule,
plugin_builtin_dell,
],
c_args: [
cargs,

35
plugins/dfu-csr/fu-dfu-csr-plugin.c Normal file
View File

@ -0,0 +1,35 @@
/*
* Copyright (C) 2017 Richard Hughes <richard@hughsie.com>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#include "config.h"
#include "fu-dfu-csr-device.h"
#include "fu-dfu-csr-plugin.h"
struct _FuDfuCsrPlugin {
FuPlugin parent_instance;
};
G_DEFINE_TYPE(FuDfuCsrPlugin, fu_dfu_csr_plugin, FU_TYPE_PLUGIN)
static void
fu_dfu_csr_plugin_init(FuDfuCsrPlugin *self)
{
}
static void
fu_dfu_csr_plugin_constructed(GObject *obj)
{
FuPlugin *plugin = FU_PLUGIN(obj);
fu_plugin_add_device_gtype(plugin, FU_TYPE_DFU_CSR_DEVICE);
}
static void
fu_dfu_csr_plugin_class_init(FuDfuCsrPluginClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS(klass);
object_class->constructed = fu_dfu_csr_plugin_constructed;
}

11
plugins/dfu-csr/fu-dfu-csr-plugin.h Normal file
View File

@ -0,0 +1,11 @@
/*
* Copyright (C) 2022 Richard Hughes <richard@hughsie.com>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#pragma once
#include <fwupdplugin.h>
G_DECLARE_FINAL_TYPE(FuDfuCsrPlugin, fu_dfu_csr_plugin, FU, DFU_CSR_PLUGIN, FuPlugin)

24
plugins/dfu-csr/fu-plugin-dfu-csr.c
View File

@ -1,24 +0,0 @@
/*
* Copyright (C) 2017 Richard Hughes <richard@hughsie.com>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#include "config.h"
#include <fwupdplugin.h>
#include "fu-dfu-csr-device.h"
static void
fu_plugin_dfu_csr_init(FuPlugin *plugin)
{
fu_plugin_add_device_gtype(plugin, FU_TYPE_DFU_CSR_DEVICE);
}
void
fu_plugin_init_vfuncs(FuPluginVfuncs *vfuncs)
{
vfuncs->build_hash = FU_BUILD_HASH;
vfuncs->init = fu_plugin_dfu_csr_init;
}

14
plugins/dfu-csr/meson.build
View File

@ -2,12 +2,10 @@ if gusb.found()
cargs = ['-DG_LOG_DOMAIN="FuPluginDfuCsr"']
plugin_quirks += files('dfu-csr.quirk')
shared_module('fu_plugin_dfu_csr',
fu_hash,
plugin_builtins += static_library('fu_plugin_dfu_csr',
sources: [
'fu-dfu-csr-device.c',
'fu-plugin-dfu-csr.c',
'fu-dfu-csr-plugin.c',
],
include_directories: [
root_incdir,
@ -15,15 +13,11 @@ shared_module('fu_plugin_dfu_csr',
fwupdplugin_incdir,
plugindfu_incdir,
],
install: true,
install_dir: plugin_dir,
c_args: cargs,
dependencies: [
plugin_deps,
],
dependencies: plugin_deps,
link_with: [
fwupdplugin,
dfu,
plugin_builtin_dfu,
],
)
endif

39
plugins/dfu/fu-dfu-plugin.c Normal file
View File

@ -0,0 +1,39 @@
/*
* Copyright (C) 2016 Richard Hughes <richard@hughsie.com>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#include "config.h"
#include "fu-dfu-device.h"
#include "fu-dfu-plugin.h"
struct _FuDfuPlugin {
FuPlugin parent_instance;
};
G_DEFINE_TYPE(FuDfuPlugin, fu_dfu_plugin, FU_TYPE_PLUGIN)
static void
fu_dfu_plugin_init(FuDfuPlugin *self)
{
}
static void
fu_dfu_plugin_constructed(GObject *obj)
{
FuPlugin *plugin = FU_PLUGIN(obj);
FuContext *ctx = fu_plugin_get_context(plugin);
fu_context_add_quirk_key(ctx, "DfuAltName");
fu_context_add_quirk_key(ctx, "DfuForceTimeout");
fu_context_add_quirk_key(ctx, "DfuForceVersion");
fu_plugin_add_device_gtype(plugin, FU_TYPE_DFU_DEVICE);
}
static void
fu_dfu_plugin_class_init(FuDfuPluginClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS(klass);
object_class->constructed = fu_dfu_plugin_constructed;
}

11
plugins/dfu/fu-dfu-plugin.h Normal file
View File

@ -0,0 +1,11 @@
/*
* Copyright (C) 2022 Richard Hughes <richard@hughsie.com>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#pragma once
#include <fwupdplugin.h>
G_DECLARE_FINAL_TYPE(FuDfuPlugin, fu_dfu_plugin, FU, DFU_PLUGIN, FuPlugin)

33
plugins/dfu/fu-plugin-dfu.c
View File

@ -1,33 +0,0 @@
/*
* Copyright (C) 2016 Richard Hughes <richard@hughsie.com>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#include "config.h"
#include <fwupdplugin.h>
#include "fu-dfu-device.h"
static void
fu_plugin_dfu_init(FuPlugin *plugin)
{
fu_plugin_add_device_gtype(plugin, FU_TYPE_DFU_DEVICE);
}
static void
fu_plugin_dfu_load(FuContext *ctx)
{
fu_context_add_quirk_key(ctx, "DfuAltName");
fu_context_add_quirk_key(ctx, "DfuForceTimeout");
fu_context_add_quirk_key(ctx, "DfuForceVersion");
}
void
fu_plugin_init_vfuncs(FuPluginVfuncs *vfuncs)
{
vfuncs->build_hash = FU_BUILD_HASH;
vfuncs->load = fu_plugin_dfu_load;
vfuncs->init = fu_plugin_dfu_init;
}

66
plugins/dfu/meson.build
View File

@ -3,10 +3,9 @@ cargs = ['-DG_LOG_DOMAIN="FuPluginDfu"']
plugin_quirks += files('dfu.quirk')
dfu = static_library(
'dfu',
fu_hash,
plugin_builtin_dfu = static_library('fu_plugin_dfu',
sources: [
'fu-dfu-plugin.c',
'fu-dfu-common.c',
'fu-dfu-device.c',
'fu-dfu-sector.c',
@ -14,63 +13,26 @@ dfu = static_library(
'fu-dfu-target-stm.c',
'fu-dfu-target-avr.c',
],
dependencies: [
plugin_deps,
libm,
],
link_with: [
fwupd,
fwupdplugin,
],
c_args: cargs,
include_directories: [
root_incdir,
fwupd_incdir,
fwupdplugin_incdir,
],
)
shared_module('fu_plugin_dfu',
fu_hash,
sources: [
'fu-plugin-dfu.c',
],
include_directories: [
root_incdir,
fwupd_incdir,
fwupdplugin_incdir,
],
install: true,
install_dir: plugin_dir,
include_directories: plugin_incdirs,
c_args: cargs,
dependencies: [
plugin_deps,
libm,
],
link_with: [
fwupd,
fwupdplugin,
dfu,
],
link_with: plugin_libs,
)
plugin_builtins += plugin_builtin_dfu
if get_option('compat_cli')
fu_dfu_tool = executable(
'dfu-tool',
fu_hash,
sources: [
'fu-dfu-tool.c',
],
include_directories: [
root_incdir,
fwupd_incdir,
fwupdplugin_incdir,
],
dependencies: [
plugin_deps,
],
include_directories: plugin_incdirs,
dependencies: plugin_deps,
link_with: [
dfu,
plugin_builtin_dfu,
fwupd,
fwupdplugin,
],
@ -96,23 +58,17 @@ if get_option('tests')
env.set('G_TEST_BUILDDIR', meson.current_build_dir())
e = executable(
'fu-dfu-self-test',
fu_hash,
sources: [
'fu-dfu-self-test.c'
],
include_directories: [
root_incdir,
fwupd_incdir,
fwupdplugin_incdir,
],
include_directories: plugin_incdirs,
dependencies: [
plugin_deps,
libm,
],
link_with: [
dfu,
fwupd,
fwupdplugin,
plugin_libs,
plugin_builtin_dfu,
],
install: true,
install_rpath: plugin_dir,

37
plugins/ebitdo/fu-ebitdo-plugin.c Normal file
View File

@ -0,0 +1,37 @@
/*
* Copyright (C) 2016 Richard Hughes <richard@hughsie.com>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#include "config.h"
#include "fu-ebitdo-device.h"
#include "fu-ebitdo-firmware.h"
#include "fu-ebitdo-plugin.h"
struct _FuEbitdoPlugin {
FuPlugin parent_instance;
};
G_DEFINE_TYPE(FuEbitdoPlugin, fu_ebitdo_plugin, FU_TYPE_PLUGIN)
static void
fu_ebitdo_plugin_init(FuEbitdoPlugin *self)
{
}
static void
fu_ebitdo_plugin_constructed(GObject *obj)
{
FuPlugin *plugin = FU_PLUGIN(obj);
fu_plugin_add_device_gtype(plugin, FU_TYPE_EBITDO_DEVICE);
fu_plugin_add_firmware_gtype(plugin, NULL, FU_TYPE_EBITDO_FIRMWARE);
}
static void
fu_ebitdo_plugin_class_init(FuEbitdoPluginClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS(klass);
object_class->constructed = fu_ebitdo_plugin_constructed;
}

11
plugins/ebitdo/fu-ebitdo-plugin.h Normal file
View File

@ -0,0 +1,11 @@
/*
* Copyright (C) 2022 Richard Hughes <richard@hughsie.com>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#pragma once
#include <fwupdplugin.h>
G_DECLARE_FINAL_TYPE(FuEbitdoPlugin, fu_ebitdo_plugin, FU, EBITDO_PLUGIN, FuPlugin)

26
plugins/ebitdo/fu-plugin-ebitdo.c
View File

@ -1,26 +0,0 @@
/*
* Copyright (C) 2016 Richard Hughes <richard@hughsie.com>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#include "config.h"
#include <fwupdplugin.h>
#include "fu-ebitdo-device.h"
#include "fu-ebitdo-firmware.h"
static void
fu_plugin_ebitdo_init(FuPlugin *plugin)
{
fu_plugin_add_device_gtype(plugin, FU_TYPE_EBITDO_DEVICE);
fu_plugin_add_firmware_gtype(plugin, NULL, FU_TYPE_EBITDO_FIRMWARE);
}
void
fu_plugin_init_vfuncs(FuPluginVfuncs *vfuncs)
{
vfuncs->build_hash = FU_BUILD_HASH;
vfuncs->init = fu_plugin_ebitdo_init;
}

23
plugins/ebitdo/meson.build
View File

@ -2,29 +2,16 @@ if gusb.found()
cargs = ['-DG_LOG_DOMAIN="FuPluginEbitdo"']
plugin_quirks += files('ebitdo.quirk')
shared_module('fu_plugin_ebitdo',
fu_hash,
plugin_builtins += static_library('fu_plugin_ebitdo',
sources: [
'fu-plugin-ebitdo.c',
'fu-ebitdo-plugin.c',
'fu-ebitdo-common.c',
'fu-ebitdo-device.c',
'fu-ebitdo-firmware.c', # fuzzing
],
include_directories: [
root_incdir,
fwupd_incdir,
fwupdplugin_incdir,
],
install: true,
install_dir: plugin_dir,
link_with: [
fwupd,
fwupdplugin,
],
include_directories: plugin_incdirs,
link_with: plugin_libs,
c_args: cargs,
dependencies: [
plugin_deps,
],
dependencies: plugin_deps,
)
endif

37
plugins/elanfp/fu-elanfp-plugin.c Normal file
View File

@ -0,0 +1,37 @@
/*
* Copyright (C) 2021
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#include "config.h"
#include "fu-elanfp-device.h"
#include "fu-elanfp-firmware.h"
#include "fu-elanfp-plugin.h"
struct _FuElanfpPlugin {
FuPlugin parent_instance;
};
G_DEFINE_TYPE(FuElanfpPlugin, fu_elanfp_plugin, FU_TYPE_PLUGIN)
static void
fu_elanfp_plugin_init(FuElanfpPlugin *self)
{
}
static void
fu_elanfp_plugin_constructed(GObject *obj)
{
FuPlugin *plugin = FU_PLUGIN(obj);
fu_plugin_add_device_gtype(plugin, FU_TYPE_ELANFP_DEVICE);
fu_plugin_add_firmware_gtype(plugin, NULL, FU_TYPE_ELANFP_FIRMWARE);
}
static void
fu_elanfp_plugin_class_init(FuElanfpPluginClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS(klass);
object_class->constructed = fu_elanfp_plugin_constructed;
}

11
plugins/elanfp/fu-elanfp-plugin.h Normal file
View File

@ -0,0 +1,11 @@
/*
* Copyright (C) 2022 Richard Hughes <richard@hughsie.com>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#pragma once
#include <fwupdplugin.h>
G_DECLARE_FINAL_TYPE(FuElanfpPlugin, fu_elanfp_plugin, FU, ELANFP_PLUGIN, FuPlugin)

24
plugins/elanfp/fu-plugin-elanfp.c
View File

@ -1,24 +0,0 @@
/*
* Copyright (C) 2021
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#include "config.h"
#include "fu-elanfp-device.h"
#include "fu-elanfp-firmware.h"
static void
fu_plugin_elanfp_init(FuPlugin *plugin)
{
fu_plugin_add_device_gtype(plugin, FU_TYPE_ELANFP_DEVICE);
fu_plugin_add_firmware_gtype(plugin, NULL, FU_TYPE_ELANFP_FIRMWARE);
}
void
fu_plugin_init_vfuncs(FuPluginVfuncs *vfuncs)
{
vfuncs->build_hash = FU_BUILD_HASH;
vfuncs->init = fu_plugin_elanfp_init;
}

23
plugins/elanfp/meson.build
View File

@ -2,28 +2,15 @@ if gusb.found()
cargs = ['-DG_LOG_DOMAIN="FuPluginElanfp"']
plugin_quirks += files('elanfp.quirk')
shared_module('fu_plugin_elanfp',
fu_hash,
plugin_builtins += static_library('fu_plugin_elanfp',
sources: [
'fu-plugin-elanfp.c',
'fu-elanfp-plugin.c',
'fu-elanfp-device.c',
'fu-elanfp-firmware.c' # fuzzing
],
include_directories: [
root_incdir,
fwupd_incdir,
fwupdplugin_incdir,
],
install: true,
install_dir: plugin_dir,
link_with: [
fwupd,
fwupdplugin,
],
include_directories: plugin_incdirs,
link_with: plugin_libs,
c_args: cargs,
dependencies: [
plugin_deps,
],
dependencies: plugin_deps,
)
endif

35
plugins/elantp/fu-plugin-elantp.c → plugins/elantp/fu-elantp-plugin.c
View File

@ -6,14 +6,19 @@
#include "config.h"
#include <fwupdplugin.h>
#include "fu-elantp-firmware.h"
#include "fu-elantp-hid-device.h"
#include "fu-elantp-i2c-device.h"
#include "fu-elantp-plugin.h"
struct _FuElantpPlugin {
FuPlugin parent_instance;
};
G_DEFINE_TYPE(FuElantpPlugin, fu_elantp_plugin, FU_TYPE_PLUGIN)
static gboolean
fu_plugin_elantp_device_created(FuPlugin *plugin, FuDevice *dev, GError **error)
fu_elantp_plugin_device_created(FuPlugin *plugin, FuDevice *dev, GError **error)
{
if (fu_device_get_specialized_gtype(dev) == FU_TYPE_ELANTP_I2C_DEVICE &&
!fu_context_has_hwid_flag(fu_plugin_get_context(plugin), "elantp-recovery") &&
@ -25,16 +30,18 @@ fu_plugin_elantp_device_created(FuPlugin *plugin, FuDevice *dev, GError **error)
}
static void
fu_plugin_elantp_load(FuContext *ctx)
fu_elantp_plugin_init(FuElantpPlugin *self)
{
fu_context_add_quirk_key(ctx, "ElantpI2cTargetAddress");
fu_context_add_quirk_key(ctx, "ElantpIapPassword");
fu_context_add_quirk_key(ctx, "ElantpIcPageCount");
}
static void
fu_plugin_elantp_init(FuPlugin *plugin)
fu_elantp_plugin_constructed(GObject *obj)
{
FuPlugin *plugin = FU_PLUGIN(obj);
FuContext *ctx = fu_plugin_get_context(plugin);
fu_context_add_quirk_key(ctx, "ElantpI2cTargetAddress");
fu_context_add_quirk_key(ctx, "ElantpIapPassword");
fu_context_add_quirk_key(ctx, "ElantpIcPageCount");
fu_plugin_add_udev_subsystem(plugin, "i2c");
fu_plugin_add_udev_subsystem(plugin, "i2c-dev");
fu_plugin_add_udev_subsystem(plugin, "hidraw");
@ -43,11 +50,11 @@ fu_plugin_elantp_init(FuPlugin *plugin)
fu_plugin_add_device_gtype(plugin, FU_TYPE_ELANTP_HID_DEVICE);
}
void
fu_plugin_init_vfuncs(FuPluginVfuncs *vfuncs)
static void
fu_elantp_plugin_class_init(FuElantpPluginClass *klass)
{
vfuncs->build_hash = FU_BUILD_HASH;
vfuncs->load = fu_plugin_elantp_load;
vfuncs->init = fu_plugin_elantp_init;
vfuncs->device_created = fu_plugin_elantp_device_created;
FuPluginClass *plugin_class = FU_PLUGIN_CLASS(klass);
GObjectClass *object_class = G_OBJECT_CLASS(klass);
object_class->constructed = fu_elantp_plugin_constructed;
plugin_class->device_created = fu_elantp_plugin_device_created;
}

11
plugins/elantp/fu-elantp-plugin.h Normal file
View File

@ -0,0 +1,11 @@
/*
* Copyright (C) 2022 Richard Hughes <richard@hughsie.com>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#pragma once
#include <fwupdplugin.h>
G_DECLARE_FINAL_TYPE(FuElantpPlugin, fu_elantp_plugin, FU, ELANTP_PLUGIN, FuPlugin)

42
plugins/elantp/meson.build
View File

@ -2,35 +2,22 @@ if gudev.found()
cargs = ['-DG_LOG_DOMAIN="FuPluginElantp"']
plugin_quirks += files('elantp.quirk')
shared_module('fu_plugin_elantp',
fu_hash,
plugin_builtin_elantp = static_library('fu_plugin_elantp',
sources: [
'fu-plugin-elantp.c',
'fu-elantp-plugin.c',
'fu-elantp-firmware.c', # fuzzing
'fu-elantp-hid-device.c',
'fu-elantp-i2c-device.c',
],
include_directories: [
root_incdir,
fwupd_incdir,
fwupdplugin_incdir,
],
install: true,
install_dir: plugin_dir,
include_directories: plugin_incdirs,
c_args: [
cargs,
'-DLOCALSTATEDIR="' + localstatedir + '"',
],
link_with: [
fwupd,
fwupdplugin,
],
dependencies: [
plugin_deps,
],
link_with: plugin_libs,
dependencies: plugin_deps,
)
endif
plugin_builtins += plugin_builtin_elantp
if get_option('tests')
install_data(['tests/elantp.builder.xml'],
@ -40,22 +27,14 @@ if get_option('tests')
env.set('G_TEST_BUILDDIR', meson.current_build_dir())
e = executable(
'elantp-self-test',
fu_hash,
sources: [
'fu-self-test.c',
'fu-elantp-firmware.c',
],
include_directories: [
root_incdir,
fwupd_incdir,
fwupdplugin_incdir,
],
dependencies: [
plugin_deps,
],
include_directories: plugin_incdirs,
dependencies: plugin_deps,
link_with: [
fwupd,
fwupdplugin,
plugin_libs,
plugin_builtin_elantp,
],
install: true,
install_rpath: plugin_dir,
@ -63,3 +42,4 @@ if get_option('tests')
)
test('elantp-self-test', e, env: env)
endif
endif

36
plugins/emmc/fu-emmc-plugin.c Normal file
View File

@ -0,0 +1,36 @@
/*
* Copyright (C) 2019 Mario Limonciello <mario.limonciello@dell.com>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#include "config.h"
#include "fu-emmc-device.h"
#include "fu-emmc-plugin.h"
struct _FuEmmcPlugin {
FuPlugin parent_instance;
};
G_DEFINE_TYPE(FuEmmcPlugin, fu_emmc_plugin, FU_TYPE_PLUGIN)
static void
fu_emmc_plugin_init(FuEmmcPlugin *self)
{
}
static void
fu_emmc_plugin_constructed(GObject *obj)
{
FuPlugin *plugin = FU_PLUGIN(obj);
fu_plugin_add_udev_subsystem(plugin, "block");
fu_plugin_add_device_gtype(plugin, FU_TYPE_EMMC_DEVICE);
}
static void
fu_emmc_plugin_class_init(FuEmmcPluginClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS(klass);
object_class->constructed = fu_emmc_plugin_constructed;
}

11
plugins/emmc/fu-emmc-plugin.h Normal file
View File

@ -0,0 +1,11 @@
/*
* Copyright (C) 2022 Richard Hughes <richard@hughsie.com>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#pragma once
#include <fwupdplugin.h>
G_DECLARE_FINAL_TYPE(FuEmmcPlugin, fu_emmc_plugin, FU, EMMC_PLUGIN, FuPlugin)

25
plugins/emmc/fu-plugin-emmc.c
View File

@ -1,25 +0,0 @@
/*
* Copyright (C) 2019 Mario Limonciello <mario.limonciello@dell.com>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#include "config.h"
#include <fwupdplugin.h>
#include "fu-emmc-device.h"
static void
fu_plugin_emmc_init(FuPlugin *plugin)
{
fu_plugin_add_udev_subsystem(plugin, "block");
fu_plugin_add_device_gtype(plugin, FU_TYPE_EMMC_DEVICE);
}
void
fu_plugin_init_vfuncs(FuPluginVfuncs *vfuncs)
{
vfuncs->build_hash = FU_BUILD_HASH;
vfuncs->init = fu_plugin_emmc_init;
}

23
plugins/emmc/meson.build
View File

@ -4,27 +4,14 @@ if get_option('plugin_emmc').require(gudev.found(),
cargs = ['-DG_LOG_DOMAIN="FuPluginEmmc"']
plugin_quirks += files('emmc.quirk')
shared_module('fu_plugin_emmc',
fu_hash,
plugin_builtins += static_library('fu_plugin_emmc',
sources: [
'fu-plugin-emmc.c',
'fu-emmc-plugin.c',
'fu-emmc-device.c',
],
include_directories: [
root_incdir,
fwupd_incdir,
fwupdplugin_incdir,
],
install: true,
install_dir: plugin_dir,
link_with: [
fwupd,
fwupdplugin,
],
include_directories: plugin_incdirs,
link_with: plugin_libs,
c_args: cargs,
dependencies: [
plugin_deps,
],
dependencies: plugin_deps,
)
endif

37
plugins/ep963x/fu-ep963x-plugin.c Normal file
View File

@ -0,0 +1,37 @@
/*
* Copyright (C) 2020 Richard Hughes <richard@hughsie.com>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#include "config.h"
#include "fu-ep963x-device.h"
#include "fu-ep963x-firmware.h"
#include "fu-ep963x-plugin.h"
struct _FuEp963XPlugin {
FuPlugin parent_instance;
};
G_DEFINE_TYPE(FuEp963XPlugin, fu_ep963x_plugin, FU_TYPE_PLUGIN)
static void
fu_ep963x_plugin_init(FuEp963XPlugin *self)
{
}
static void
fu_ep963x_plugin_constructed(GObject *obj)
{
FuPlugin *plugin = FU_PLUGIN(obj);
fu_plugin_add_device_gtype(plugin, FU_TYPE_EP963X_DEVICE);
fu_plugin_add_firmware_gtype(plugin, NULL, FU_TYPE_EP963X_FIRMWARE);
}
static void
fu_ep963x_plugin_class_init(FuEp963XPluginClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS(klass);
object_class->constructed = fu_ep963x_plugin_constructed;
}

Some files were not shown because too many files have changed in this diff Show More