Build many more plugins as builtin

This reduces the plugin directory size by 2.2Mb

contrib/fwupd.spec.in

@@ -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}

docs/tutorial.md

@@ -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
+- **Helpers**: Providing more metadata about devices, for instance handling device quirks.
-- 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.
 
 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.
 
-    /*
+    /* fu-foo-plugin.h
-     * Copyright (C) 2017 Richard Hughes <richard@hughsie.com>
+     *
+     * 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
+    G_DEFINE_TYPE(FuFooPlugin, fu_foo_plugin, FU_TYPE_PLUGIN)
-    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);
-    }
 
     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();
+        self->proxy = create_proxy();
-        if(data->proxy == NULL) {
+        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
+    static void
-    fu_plugin_init_vfuncs(FuPluginVfuncs *vfuncs)
+    fu_foo_plugin_init(FuFooPlugin *self)
     {
-        vfuncs->build_hash = FU_BUILD_HASH;
+    }
-        vfuncs->init = fu_plugin_foo_init;
+
-        vfuncs->destroy = fu_plugin_foo_destroy;
+    static void
-        vfuncs->startup = fu_plugin_foo_startup;
+    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
+    static void
-    fu_plugin_init_vfuncs(FuPluginVfuncs *vfuncs)
+    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
+    static void
-    fu_plugin_init_vfuncs(FuPluginVfuncs *vfuncs)
+    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
+    static void
-    fu_plugin_init_vfuncs(FuPluginVfuncs *vfuncs)
+    fu_foo_plugin_class_init(FuFooPluginClass *klass)
     {
         …
-        vfuncs->prepare = fu_plugin_foo_prepare;
+        plugin_class->prepare = fu_foo_plugin_prepare;
-        vfuncs->cleanup = fu_plugin_foo_cleanup;
+        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
+    static void
-    fu_plugin_init_vfuncs(FuPluginVfuncs *vfuncs)
+    fu_foo_plugin_class_init(FuFooPluginClass *klass)
     {
         …
-        vfuncs->detach = fu_plugin_foo_detach;
+        plugin_class->detach = fu_foo_plugin_detach;
-        vfuncs->attach = fu_plugin_foo_attach;
+        plugin_class->attach = fu_foo_plugin_attach;
-        vfuncs->reload = fu_plugin_foo_reload;
+        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
+    static void
-    fu_plugin_steelseries_init(FuPlugin *plugin)
+    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
+    static void
-    fu_plugin_init_vfuncs(FuPluginVfuncs *vfuncs)
+    fu_foo_plugin_class_init(FuFooPluginClass *klass)
     {
-        vfuncs->build_hash = FU_BUILD_HASH;
+        plugin_class->init = fu_foo_plugin_constructed;
-        vfuncs->init = fu_plugin_steelseries_init;
     }
 
 ### Creating a new device type

libfwupdplugin/fu-plugin-private.h

@@ -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

libfwupdplugin/fu-plugin.h

@@ -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 *

plugins/acpi-dmar/fu-acpi-dmar-plugin.c

@@ -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
+static void
-fu_plugin_init_vfuncs(FuPluginVfuncs *vfuncs)
+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;
 }

plugins/acpi-dmar/fu-acpi-dmar-plugin.h

@@ -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)

plugins/acpi-dmar/meson.build

@@ -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',
+plugin_builtin_acpi_dmar = static_library('fu_plugin_acpi_dmar',
-  fu_hash,
   sources: [
-    'fu-plugin-acpi-dmar.c',
+    'fu-acpi-dmar-plugin.c',
     'fu-acpi-dmar.c',
   ],
-  include_directories: [
+  include_directories: plugin_incdirs,
-    root_incdir,
+  link_with: plugin_libs,
-    fwupd_incdir,
-    fwupdplugin_incdir,
-  ],
-  install: true,
-  install_dir: plugin_dir,
-  link_with: [
-    fwupd,
-    fwupdplugin,
-  ],
   c_args: cargs,
-  dependencies: [
+  dependencies: plugin_deps,
-    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,
+      plugin_libs,
-      fwupdplugin,
+      plugin_builtin_acpi_dmar,
     ],
     install: true,
     install_rpath: plugin_dir,

plugins/acpi-facp/fu-acpi-facp-plugin.c

@@ -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
+static void
-fu_plugin_init_vfuncs(FuPluginVfuncs *vfuncs)
+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;
 }

plugins/acpi-facp/fu-acpi-facp-plugin.h

@@ -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)

plugins/acpi-facp/meson.build

@@ -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',
+plugin_builtin_acpi_facp = static_library('fu_plugin_acpi_facp',
-  fu_hash,
   sources: [
-    'fu-plugin-acpi-facp.c',
+    'fu-acpi-facp-plugin.c',
     'fu-acpi-facp.c',
   ],
-  include_directories: [
+  include_directories: plugin_incdirs,
-    root_incdir,
+  link_with: plugin_libs,
-    fwupd_incdir,
-    fwupdplugin_incdir,
-  ],
-  install: true,
-  install_dir: plugin_dir,
-  link_with: [
-    fwupd,
-    fwupdplugin,
-  ],
   c_args: cargs,
-  dependencies: [
+  dependencies: plugin_deps,
-    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,
+      plugin_libs,
-      fwupdplugin,
+      plugin_builtin_acpi_facp,
     ],
     install: true,
     install_rpath: plugin_dir,

plugins/acpi-ivrs/fu-acpi-ivrs-plugin.c

@@ -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
+static void
-fu_plugin_init_vfuncs(FuPluginVfuncs *vfuncs)
+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;
 }

plugins/acpi-ivrs/fu-acpi-ivrs-plugin.h

@@ -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)

plugins/acpi-ivrs/meson.build

@@ -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',
+plugin_builtin_acpi_ivrs = static_library('fu_plugin_acpi_ivrs',
-  fu_hash,
   sources: [
-    'fu-plugin-acpi-ivrs.c',
+    'fu-acpi-ivrs-plugin.c',
     'fu-acpi-ivrs.c',
   ],
-  include_directories: [
+  include_directories: plugin_incdirs,
-    root_incdir,
+  link_with: plugin_libs,
-    fwupd_incdir,
-    fwupdplugin_incdir,
-  ],
-  install: true,
-  install_dir: plugin_dir,
-  link_with: [
-    fwupd,
-    fwupdplugin,
-  ],
   c_args: cargs,
-  dependencies: [
+  dependencies: plugin_deps,
-    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,
+      plugin_libs,
-      fwupdplugin,
+      plugin_builtin_acpi_ivrs,
     ],
     install: true,
     install_rpath: plugin_dir,

plugins/acpi-phat/fu-acpi-phat-plugin.c

@@ -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
+struct _FuAcpiPhatPlugin {
-fu_plugin_acpi_phat_init(FuPlugin *plugin)
+	FuPlugin parent_instance;
-{
+};
-	fu_plugin_add_firmware_gtype(plugin, NULL, FU_TYPE_ACPI_PHAT);
+
-	fu_plugin_add_firmware_gtype(plugin, NULL, FU_TYPE_ACPI_PHAT_HEALTH_RECORD);
+G_DEFINE_TYPE(FuAcpiPhatPlugin, fu_acpi_phat_plugin, FU_TYPE_PLUGIN)
-	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 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
+static void
-fu_plugin_init_vfuncs(FuPluginVfuncs *vfuncs)
+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;
 }

plugins/acpi-phat/fu-acpi-phat-plugin.h

@@ -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)

plugins/acpi-phat/meson.build

@@ -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',
+plugin_builtin_acpi_phat = static_library('fu_plugin_acpi_phat',
-  fu_hash,
   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: [
+  include_directories: plugin_incdirs,
-    root_incdir,
+  link_with: plugin_libs,
-    fwupd_incdir,
-    fwupdplugin_incdir,
-  ],
-  install: true,
-  install_dir: plugin_dir,
-  link_with: [
-    fwupd,
-    fwupdplugin,
-  ],
   c_args: cargs,
-  dependencies: [
+  dependencies: plugin_deps,
-    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,
+      plugin_libs,
-      fwupdplugin,
+      plugin_builtin_acpi_phat,
     ],
     install: true,
     install_rpath: plugin_dir,

plugins/amd-pmc/fu-amd-pmc-plugin.c

@@ -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;
+}

plugins/amd-pmc/fu-amd-pmc-plugin.h

@@ -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)

plugins/amd-pmc/fu-plugin-amd-pmc.c

@@ -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;
-}

plugins/amd-pmc/meson.build

@@ -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')
-
+plugin_builtins += static_library('fu_plugin_amd_pmc',
-shared_module('fu_plugin_amd_pmc',
-  fu_hash,
   sources: [
-    'fu-plugin-amd-pmc.c',
+    'fu-amd-pmc-plugin.c',
     'fu-amd-pmc-device.c',
   ],
-  include_directories: [
+  include_directories: plugin_incdirs,
-    root_incdir,
+  link_with: plugin_libs,
-    fwupd_incdir,
-    fwupdplugin_incdir,
-  ],
-  install: true,
-  install_dir: plugin_dir,
-  link_with: [
-    fwupd,
-    fwupdplugin,
-  ],
   c_args: cargs,
-  dependencies: [
+  dependencies: plugin_deps,
-    plugin_deps,
-  ],
 )
 endif

plugins/amt/fu-amt-plugin.c

@@ -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;
+}

plugins/amt/fu-amt-plugin.h

@@ -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)

plugins/amt/fu-plugin-amt.c

@@ -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;
-}

plugins/amt/meson.build

@@ -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')
-
+plugin_builtins += static_library('fu_plugin_amt',
-shared_module('fu_plugin_amt',
-  fu_hash,
   sources: [
-    'fu-plugin-amt.c',
+    'fu-amt-plugin.c',
     'fu-amt-device.c',
   ],
-  include_directories: [
+  include_directories: plugin_incdirs,
-    root_incdir,
+  link_with: plugin_libs,
-    fwupd_incdir,
-    fwupdplugin_incdir,
-  ],
-  install: true,
-  install_dir: plugin_dir,
-  link_with: [
-    fwupd,
-    fwupdplugin,
-  ],
   c_args: cargs,
-  dependencies: [
+  dependencies: plugin_deps,
-    plugin_deps,
-  ],
 )
 endif

plugins/analogix/fu-analogix-plugin.c

@@ -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;
+}

plugins/analogix/fu-analogix-plugin.h

@@ -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)

plugins/analogix/fu-plugin-analogix.c

@@ -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;
-}

plugins/analogix/meson.build

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

plugins/android-boot/fu-android-boot-plugin.c

@@ -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;
+}

plugins/android-boot/fu-android-boot-plugin.h

@@ -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)

plugins/android-boot/fu-plugin-android-boot.c

@@ -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;
-}

plugins/android-boot/meson.build

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

plugins/ata/fu-ata-plugin.c

@@ -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;
+}

plugins/ata/fu-ata-plugin.h

@@ -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)

plugins/ata/fu-plugin-ata.c

@@ -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;
-}

plugins/ata/meson.build

@@ -2,32 +2,20 @@ if gudev.found()
 cargs = ['-DG_LOG_DOMAIN="FuPluginAta"']
 
 plugin_quirks += files('ata.quirk')
-
+plugin_builtin_ata = static_library('fu_plugin_ata',
-shared_module('fu_plugin_ata',
-  fu_hash,
   sources: [
-    'fu-plugin-ata.c',
+    'fu-ata-plugin.c',
     'fu-ata-device.c',
   ],
-  include_directories: [
+  include_directories: plugin_incdirs,
-    root_incdir,
-    fwupd_incdir,
-    fwupdplugin_incdir,
-  ],
-  install: true,
-  install_dir: plugin_dir,
   c_args: [
     cargs,
     '-DLOCALSTATEDIR="' + localstatedir + '"',
   ],
-  link_with: [
+  link_with: plugin_libs,
-    fwupd,
+  dependencies: plugin_deps,
-    fwupdplugin,
-  ],
-  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,
+      plugin_libs,
-      fwupdplugin,
+      plugin_builtin_ata,
     ],
     install: true,
     install_rpath: plugin_dir,

plugins/bcm57xx/fu-bcm57xx-plugin.c

@@ -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
+static void
-fu_plugin_init_vfuncs(FuPluginVfuncs *vfuncs)
+fu_bcm57xx_plugin_class_init(FuBcm57XxPluginClass *klass)
 {
-	vfuncs->build_hash = FU_BUILD_HASH;
+	GObjectClass *object_class = G_OBJECT_CLASS(klass);
-	vfuncs->init = fu_plugin_bcm57xx_init;
+	object_class->constructed = fu_bcm57xx_plugin_constructed;
 }

plugins/bcm57xx/fu-bcm57xx-plugin.h

@@ -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)

plugins/bcm57xx/meson.build

@@ -3,11 +3,9 @@ if get_option('plugin_bcm57xx').require(gudev.found(),
 cargs = ['-DG_LOG_DOMAIN="FuPluginBcm57xx"']
 
 plugin_quirks += files('bcm57xx.quirk')
-
+plugin_builtin_bcm57xx = static_library('fu_plugin_bcm57xx',
-shared_module('fu_plugin_bcm57xx',
-  fu_hash,
   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: [
+  include_directories: plugin_incdirs,
-    root_incdir,
+  link_with: plugin_libs,
-    fwupd_incdir,
-    fwupdplugin_incdir,
-  ],
-  install: true,
-  install_dir: plugin_dir,
-  link_with: [
-    fwupd,
-    fwupdplugin,
-  ],
   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,
+      plugin_libs,
-      fwupdplugin,
+      plugin_builtin_bcm57xx,
     ],
     install: true,
     install_rpath: plugin_dir,

plugins/bios/fu-bios-plugin.c

@@ -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
+static void
-fu_plugin_init_vfuncs(FuPluginVfuncs *vfuncs)
+fu_bios_plugin_init(FuBiosPlugin *self)
 {
-	vfuncs->build_hash = FU_BUILD_HASH;
+}
-	vfuncs->startup = fu_plugin_bios_startup;
+
-	vfuncs->coldplug = fu_plugin_bios_coldplug;
+static void
-	vfuncs->add_security_attrs = fu_plugin_bios_add_security_attrs;
+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;
 }

plugins/bios/fu-bios-plugin.h

@@ -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)

plugins/bios/meson.build

@@ -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',
+plugin_builtins += static_library('fu_plugin_bios',
-  fu_hash,
   sources: [
-    'fu-plugin-bios.c',
+    'fu-bios-plugin.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: [
+  dependencies: plugin_deps,
-    plugin_deps,
-  ],
 )
 endif

plugins/ccgx/fu-ccgx-plugin.c

@@ -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");
+	GObjectClass *object_class = G_OBJECT_CLASS(klass);
-	fu_context_add_quirk_key(ctx, "CcgxFlashSize");
+	object_class->constructed = fu_ccgx_plugin_constructed;
-	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;
 }

plugins/ccgx/fu-ccgx-plugin.h

@@ -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)

plugins/ccgx/meson.build

@@ -5,11 +5,9 @@ plugin_quirks += files([
   'ccgx-ids.quirk',
   'ccgx.quirk',
   ])
-
+plugin_builtin_ccgx = static_library('fu_plugin_ccgx',
-shared_module('fu_plugin_ccgx',
-  fu_hash,
   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: [
+  include_directories: plugin_incdirs,
-    root_incdir,
+  link_with: plugin_libs,
-    fwupd_incdir,
-    fwupdplugin_incdir,
-  ],
-  install: true,
-  install_dir: plugin_dir,
-  link_with: [
-    fwupd,
-    fwupdplugin,
-  ],
   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,
+      plugin_libs,
-      fwupdplugin,
+      plugin_builtin_ccgx,
     ],
     install: true,
     install_rpath: plugin_dir,

plugins/cfu/fu-cfu-plugin.c

@@ -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;
+}

plugins/cfu/fu-cfu-plugin.h

@@ -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)

plugins/cfu/fu-plugin-cfu.c

@@ -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;
-}

plugins/cfu/meson.build

@@ -3,28 +3,15 @@ if get_option('plugin_cfu').require(gudev.found(),
 cargs = ['-DG_LOG_DOMAIN="FuPluginCfu"']
 
 plugin_quirks += files('cfu.quirk')
-
+plugin_builtins += static_library('fu_plugin_cfu',
-shared_module('fu_plugin_cfu',
-  fu_hash,
   sources: [
     'fu-cfu-device.c',
     'fu-cfu-module.c',
-    'fu-plugin-cfu.c',
+    'fu-cfu-plugin.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: [
+  dependencies: plugin_deps,
-    plugin_deps,
-  ],
 )
 endif

plugins/ch341a/fu-ch341a-plugin.c

@@ -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;
+}

plugins/ch341a/fu-ch341a-plugin.h

@@ -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)

plugins/ch341a/fu-plugin-ch341a.c

@@ -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;
-}

plugins/ch341a/meson.build

@@ -2,28 +2,15 @@ if gusb.found()
 cargs = ['-DG_LOG_DOMAIN="FuPluginCh341a"']
 
 plugin_quirks += files('ch341a.quirk')
-
+plugin_builtins += static_library('fu_plugin_ch341a',
-shared_module('fu_plugin_ch341a',
-  fu_hash,
   sources: [
     'fu-ch341a-cfi-device.c',
     'fu-ch341a-device.c',
-    'fu-plugin-ch341a.c',
+    'fu-ch341a-plugin.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: [
+  dependencies: plugin_deps,
-    plugin_deps,
-  ],
 )
 endif

plugins/corsair/fu-corsair-bp.c

@@ -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,

plugins/corsair/fu-corsair-plugin.c

@@ -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;
+}

plugins/corsair/fu-corsair-plugin.h

@@ -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)

plugins/corsair/fu-plugin-corsair.c

@@ -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;
-}

plugins/corsair/meson.build

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

plugins/cpu/fu-cpu-plugin.c

@@ -6,18 +6,17 @@
 
 #include "config.h"
 
-#include <fwupdplugin.h>
-
 #include "fu-cpu-device.h"
+#include "fu-cpu-plugin.h"
 
-static void
+struct _FuCpuPlugin {
-fu_plugin_cpu_init(FuPlugin *plugin)
+	FuPlugin parent_instance;
-{
+};
-	fu_plugin_add_rule(plugin, FU_PLUGIN_RULE_RUN_BEFORE, "msr");
+
-}
+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
+static void
-fu_plugin_init_vfuncs(FuPluginVfuncs *vfuncs)
+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;
 }

plugins/cpu/fu-cpu-plugin.h

@@ -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)

plugins/cpu/meson.build

@@ -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')
-
+plugin_builtins += static_library('fu_plugin_cpu',
-shared_module('fu_plugin_cpu',
-  fu_hash,
   sources: [
-    'fu-plugin-cpu.c',
+    'fu-cpu-plugin.c',
     'fu-cpu-device.c',
   ],
-  include_directories: [
+  include_directories: plugin_incdirs,
-    root_incdir,
+  link_with: plugin_libs,
-    fwupd_incdir,
-    fwupdplugin_incdir,
-  ],
-  install: true,
-  install_dir: plugin_dir,
-  link_with: [
-    fwupd,
-    fwupdplugin,
-  ],
   c_args: cargs,
-  dependencies: [
+  dependencies: plugin_deps,
-    plugin_deps,
-  ],
 )
 
 code = '''

plugins/cros-ec/fu-cros-ec-plugin.c

@@ -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;
+}

plugins/cros-ec/fu-cros-ec-plugin.h

@@ -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)

plugins/cros-ec/fu-plugin-cros-ec.c

@@ -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;
-}

plugins/cros-ec/meson.build

@@ -2,29 +2,16 @@ if gusb.found()
 cargs = ['-DG_LOG_DOMAIN="FuPluginCrosEc"']
 
 plugin_quirks += files('cros-ec.quirk')
-
+plugin_builtins += static_library('fu_plugin_cros_ec',
-shared_module('fu_plugin_cros_ec',
-  fu_hash,
   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: [
+  include_directories: plugin_incdirs,
-    root_incdir,
+  link_with: plugin_libs,
-    fwupd_incdir,
-    fwupdplugin_incdir,
-  ],
-  install: true,
-  install_dir: plugin_dir,
-  link_with: [
-    fwupd,
-    fwupdplugin,
-  ],
   c_args: cargs,
-  dependencies: [
+  dependencies: plugin_deps,
-    plugin_deps,
-  ],
 )
 endif

plugins/dell-dock/fu-dell-dock-plugin.c

@@ -15,39 +15,17 @@
 
 #include "config.h"
 
-#include <fwupdplugin.h>
-
 #include "fu-dell-dock-common.h"
+#include "fu-dell-dock-plugin.h"
 
-static void
+struct _FuDellDockPlugin {
-fu_plugin_dell_dock_load(FuContext *ctx)
+	FuPlugin parent_instance;
-{
+};
-	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");
-}
 
-static void
+G_DEFINE_TYPE(FuDellDockPlugin, fu_dell_dock_plugin, FU_TYPE_PLUGIN)
-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
-}
 
 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
+static void
-fu_plugin_init_vfuncs(FuPluginVfuncs *vfuncs)
+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;
+static void
-	vfuncs->device_registered = fu_plugin_dell_dock_device_registered;
+fu_dell_dock_plugin_constructed(GObject *obj)
-	vfuncs->backend_device_added = fu_plugin_dell_dock_backend_device_added;
+{
-	vfuncs->backend_device_removed = fu_plugin_dell_dock_backend_device_removed;
+	FuPlugin *plugin = FU_PLUGIN(obj);
-	vfuncs->composite_cleanup = fu_plugin_dell_dock_composite_cleanup;
+	FuContext *ctx = fu_plugin_get_context(plugin);
-	vfuncs->composite_prepare = fu_plugin_dell_dock_composite_prepare;
+	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;
 }

plugins/dell-dock/fu-dell-dock-plugin.h

@@ -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)

plugins/dell-dock/meson.build

@@ -2,11 +2,9 @@ if gusb.found()
 cargs = ['-DG_LOG_DOMAIN="FuPluginDellDock"']
 
 plugin_quirks += files('dell-dock.quirk')
-
+plugin_builtins += static_library('fu_plugin_dell_dock',
-shared_module('fu_plugin_dell_dock',
-  fu_hash,
   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: [
+  include_directories: plugin_incdirs,
-    root_incdir,
+  link_with: plugin_libs,
-    fwupd_incdir,
-    fwupdplugin_incdir,
-  ],
-  install: true,
-  install_dir: plugin_dir,
-  link_with: [
-    fwupd,
-    fwupdplugin,
-  ],
   c_args: cargs,
   dependencies: [
     plugin_deps,

plugins/dell-esrt/fu-dell-esrt-plugin.c

@@ -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
+static void
-fu_plugin_init_vfuncs(FuPluginVfuncs *vfuncs)
+fu_dell_esrt_plugin_init(FuDellEsrtPlugin *self)
 {
-	vfuncs->build_hash = FU_BUILD_HASH;
+	fu_plugin_add_rule(FU_PLUGIN(self), FU_PLUGIN_RULE_BETTER_THAN, "bios");
-	vfuncs->init = fu_plugin_dell_esrt_init;
+}
-	vfuncs->startup = fu_plugin_dell_esrt_startup;
+
-	vfuncs->coldplug = fu_plugin_dell_esrt_coldplug;
+static void
-	vfuncs->unlock = fu_plugin_dell_esrt_unlock;
+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;
 }

plugins/dell-esrt/fu-dell-esrt-plugin.h

@@ -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)

plugins/dell-esrt/meson.build

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

plugins/dell/fu-dell-plugin.c

@@ -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);
+	FuDellPlugin *self = FU_DELL_PLUGIN(plugin);
-
+	if (!self->smi_obj->fake_smbios)
-	if (!priv->smi_obj->fake_smbios)
 		return;
 	for (guint i = 0; i < 4; i++)
-		priv->smi_obj->output[i] = output[i];
+		self->smi_obj->output[i] = output[i];
-	priv->fake_vid = vid;
+	self->fake_vid = vid;
-	priv->fake_pid = pid;
+	self->fake_pid = pid;
-	priv->smi_obj->fake_buffer = buf;
+	self->smi_obj->fake_buffer = buf;
-	priv->can_switch_modes = TRUE;
+	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);
+	FuDellPlugin *self = FU_DELL_PLUGIN(plugin);
-
+	return self->smi_obj->fake_smbios || self->capsule_supported;
-	return priv->smi_obj->fake_smbios || priv->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;
+		vid = self->fake_vid;
-		pid = priv->fake_pid;
+		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);
+	vendor2 = fu_dell_plugin_get_tpm_capability(ctx, TPM2_PT_VENDOR_STRING_2);
-	vendor3 = fu_plugin_dell_get_tpm_capability(ctx, TPM2_PT_VENDOR_STRING_3);
+	vendor3 = fu_dell_plugin_get_tpm_capability(ctx, TPM2_PT_VENDOR_STRING_3);
-	vendor4 = fu_plugin_dell_get_tpm_capability(ctx, TPM2_PT_VENDOR_STRING_4);
+	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);
+	fu_dell_clear_smi(self->smi_obj);
-	out = (struct tpm_status *)priv->smi_obj->output;
+	out = (struct tpm_status *)self->smi_obj->output;
 
 	/* execute TPM Status Query */
-	priv->smi_obj->input[0] = DACI_FLASH_ARG_TPM;
+	self->smi_obj->input[0] = DACI_FLASH_ARG_TPM;
-	if (!fu_dell_execute_simple_smi(priv->smi_obj,
+	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)
+	if (self->smi_obj->fake_smbios)
-		can_switch_modes = priv->can_switch_modes;
+		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;
+	FuDellPlugin *self = FU_DELL_PLUGIN(plugin);
-
+	fu_string_append_kb(str, idt, "CanSwitchModes", self->can_switch_modes);
-	tmp = g_strdup_printf("%d.%d",
+	fu_string_append_kb(str, idt, "CapsuleSupported", self->capsule_supported);
-			      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);
 }
 
 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
+static void
-fu_plugin_init_vfuncs(FuPluginVfuncs *vfuncs)
+fu_dell_plugin_init(FuDellPlugin *self)
 {
-	vfuncs->build_hash = FU_BUILD_HASH;
+	self->smi_obj = g_malloc0(sizeof(FuDellSmiObj));
-	vfuncs->load = fu_plugin_dell_load;
+	if (g_getenv("FWUPD_DELL_VERBOSE") != NULL)
-	vfuncs->init = fu_plugin_dell_init;
+		(void)g_setenv("LIBSMBIOS_C_DEBUG_OUTPUT_ALL", "1", TRUE);
-	vfuncs->destroy = fu_plugin_dell_destroy;
+	else
-	vfuncs->to_string = fu_plugin_dell_to_string;
+		(void)g_setenv("TSS2_LOG", "esys+none,tcti+none", FALSE);
-	vfuncs->startup = fu_plugin_dell_startup;
+}
-	vfuncs->coldplug = fu_plugin_dell_coldplug;
+
-	vfuncs->backend_device_added = fu_plugin_dell_backend_device_added;
+static void
-	vfuncs->device_registered = fu_plugin_dell_device_registered;
+fu_dell_plugin_constructed(GObject *obj)
-	vfuncs->get_results = fu_plugin_dell_get_results;
+{
+	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;
 }

plugins/dell/fu-dell-plugin.h

@@ -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)

plugins/dell/fu-plugin-dell.h

@@ -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

plugins/dell/fu-self-test.c

@@ -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);
+	fu_dell_plugin_inject_fake_data(self->plugin_dell, (guint32 *)&tpm_out, 0, 0, NULL, FALSE);
-	ret = fu_plugin_dell_detect_tpm(self->plugin_dell, &error);
+	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);
+	fu_dell_plugin_inject_fake_data(self->plugin_dell, (guint32 *)&tpm_out, 0, 0, NULL, TRUE);
-	ret = fu_plugin_dell_detect_tpm(self->plugin_dell, &error);
+	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);
+	fu_dell_plugin_inject_fake_data(self->plugin_dell, (guint32 *)&tpm_out, 0, 0, NULL, TRUE);
-	ret = fu_plugin_dell_detect_tpm(self->plugin_dell, &error);
+	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);
+	fu_dell_plugin_inject_fake_data(self->plugin_dell, (guint32 *)&tpm_out, 0, 0, NULL, TRUE);
-	ret = fu_plugin_dell_detect_tpm(self->plugin_dell, &error);
+	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);
+	fu_dell_plugin_inject_fake_data(self->plugin_dell, (guint32 *)&tpm_out, 0, 0, NULL, TRUE);
-	ret = fu_plugin_dell_detect_tpm(self->plugin_dell, &error);
+	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);
+	self->plugin_uefi_capsule =
-	pluginfn_uefi = g_test_build_filename(G_TEST_BUILT,
+	    fu_plugin_new_from_gtype(fu_uefi_capsule_plugin_get_type(), ctx);
-					      "..",
-					      "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);
 	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);
+	self->plugin_dell = fu_plugin_new_from_gtype(fu_dell_plugin_get_type(), 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);
 	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:tpm}", self, fu_dell_plugin_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:dock}", self, fu_dell_plugin_dock_func);
 	return g_test_run();
 }

plugins/dell/meson.build

@@ -9,23 +9,13 @@ cargs = ['-DG_LOG_DOMAIN="FuPluginDell"']
 
 plugin_quirks += files('dell.quirk')
 
-shared_module('fu_plugin_dell',
+plugin_builtin_dell = static_library('fu_plugin_dell',
-  fu_hash,
   sources: [
-    'fu-plugin-dell.c',
+    'fu-dell-plugin.c',
     'fu-dell-smi.c',
   ],
-  include_directories: [
+  include_directories: plugin_incdirs,
-    root_incdir,
+  link_with: plugin_libs,
-    fwupd_incdir,
-    fwupdplugin_incdir,
-  ],
-  install: true,
-  install_dir: plugin_dir,
-  link_with: [
-    fwupd,
-    fwupdplugin,
-  ],
   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,
+      plugin_libs,
-      fwupdplugin,
+      plugin_builtin_uefi_capsule,
+      plugin_builtin_dell,
     ],
     c_args: [
       cargs,

plugins/dfu-csr/fu-dfu-csr-plugin.c

@@ -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;
+}

plugins/dfu-csr/fu-dfu-csr-plugin.h

@@ -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)

plugins/dfu-csr/fu-plugin-dfu-csr.c

@@ -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;
-}

plugins/dfu-csr/meson.build

@@ -2,12 +2,10 @@ if gusb.found()
 cargs = ['-DG_LOG_DOMAIN="FuPluginDfuCsr"']
 
 plugin_quirks += files('dfu-csr.quirk')
-
+plugin_builtins += static_library('fu_plugin_dfu_csr',
-shared_module('fu_plugin_dfu_csr',
-  fu_hash,
   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: [
+  dependencies: plugin_deps,
-    plugin_deps,
-  ],
   link_with: [
     fwupdplugin,
-    dfu,
+    plugin_builtin_dfu,
   ],
 )
 endif

plugins/dfu/fu-dfu-plugin.c

@@ -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;
+}

plugins/dfu/fu-dfu-plugin.h

@@ -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)

plugins/dfu/fu-plugin-dfu.c

@@ -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;
-}

plugins/dfu/meson.build

@@ -3,10 +3,9 @@ cargs = ['-DG_LOG_DOMAIN="FuPluginDfu"']
 
 plugin_quirks += files('dfu.quirk')
 
-dfu = static_library(
+plugin_builtin_dfu = static_library('fu_plugin_dfu',
-  'dfu',
-  fu_hash,
   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: [
+  include_directories: plugin_incdirs,
-    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,
   c_args: cargs,
   dependencies: [
     plugin_deps,
     libm,
   ],
-  link_with: [
+  link_with: plugin_libs,
-    fwupd,
-    fwupdplugin,
-    dfu,
-  ],
 )
+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: [
+  include_directories: plugin_incdirs,
-    root_incdir,
+  dependencies: plugin_deps,
-    fwupd_incdir,
-    fwupdplugin_incdir,
-  ],
-  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: [
+    include_directories: plugin_incdirs,
-      root_incdir,
-      fwupd_incdir,
-      fwupdplugin_incdir,
-    ],
     dependencies: [
       plugin_deps,
       libm,
     ],
     link_with: [
-      dfu,
+      plugin_libs,
-      fwupd,
+      plugin_builtin_dfu,
-      fwupdplugin,
     ],
     install: true,
     install_rpath: plugin_dir,

plugins/ebitdo/fu-ebitdo-plugin.c

@@ -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;
+}

plugins/ebitdo/fu-ebitdo-plugin.h

@@ -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)

plugins/ebitdo/fu-plugin-ebitdo.c

@@ -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;
-}

plugins/ebitdo/meson.build

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

plugins/elanfp/fu-elanfp-plugin.c

@@ -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;
+}

plugins/elanfp/fu-elanfp-plugin.h

@@ -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)

plugins/elanfp/fu-plugin-elanfp.c

@@ -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;
-}

plugins/elanfp/meson.build

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

plugins/elantp/fu-elantp-plugin.c

@@ -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
+static void
-fu_plugin_init_vfuncs(FuPluginVfuncs *vfuncs)
+fu_elantp_plugin_class_init(FuElantpPluginClass *klass)
 {
-	vfuncs->build_hash = FU_BUILD_HASH;
+	FuPluginClass *plugin_class = FU_PLUGIN_CLASS(klass);
-	vfuncs->load = fu_plugin_elantp_load;
+	GObjectClass *object_class = G_OBJECT_CLASS(klass);
-	vfuncs->init = fu_plugin_elantp_init;
+	object_class->constructed = fu_elantp_plugin_constructed;
-	vfuncs->device_created = fu_plugin_elantp_device_created;
+	plugin_class->device_created = fu_elantp_plugin_device_created;
 }

plugins/elantp/fu-elantp-plugin.h

@@ -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)

plugins/elantp/meson.build

@@ -2,35 +2,22 @@ if gudev.found()
 cargs = ['-DG_LOG_DOMAIN="FuPluginElantp"']
 
 plugin_quirks += files('elantp.quirk')
-
+plugin_builtin_elantp = static_library('fu_plugin_elantp',
-shared_module('fu_plugin_elantp',
-  fu_hash,
   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: [
+  include_directories: plugin_incdirs,
-    root_incdir,
-    fwupd_incdir,
-    fwupdplugin_incdir,
-  ],
-  install: true,
-  install_dir: plugin_dir,
   c_args: [
     cargs,
     '-DLOCALSTATEDIR="' + localstatedir + '"',
   ],
-  link_with: [
+  link_with: plugin_libs,
-    fwupd,
+  dependencies: plugin_deps,
-    fwupdplugin,
-  ],
-  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,
+      plugin_libs,
-      fwupdplugin,
+      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

plugins/emmc/fu-emmc-plugin.c

@@ -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;
+}

plugins/emmc/fu-emmc-plugin.h

@@ -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)

plugins/emmc/fu-plugin-emmc.c

@@ -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;
-}

plugins/emmc/meson.build

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

plugins/ep963x/fu-ep963x-plugin.c

@@ -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;
+}