fwupd/plugins/ccgx/fu-ccgx-dmc-device.c

/*
 * Copyright (C) 2020 Cypress Semiconductor Corporation.
 * Copyright (C) 2020 Richard Hughes <richard@hughsie.com>
 *
 * SPDX-License-Identifier: LGPL-2.1+
 */

#include "config.h"

#include <fwupdplugin.h>

#include "fu-ccgx-common.h"
#include "fu-ccgx-dmc-common.h"
#include "fu-ccgx-dmc-device.h"
#include "fu-ccgx-dmc-firmware.h"

#define DMC_FW_WRITE_STATUS_RETRY_COUNT	   3
#define DMC_FW_WRITE_STATUS_RETRY_DELAY_MS 30

struct _FuCcgxDmcDevice {
	FuUsbDevice parent_instance;
	FWImageType fw_image_type;
	DmcDockIdentity dock_id;
	guint8 ep_intr_in;
	guint8 ep_bulk_out;
	DmcUpdateModel update_model;
};

/**
 * FU_CCGX_DMC_DEVICE_FLAG_HAS_MANUAL_REPLUG:
 *
 * Needs a manual replug from the end-user.
 */
#define FU_CCGX_DMC_DEVICE_FLAG_HAS_MANUAL_REPLUG (1 << 0)

G_DEFINE_TYPE(FuCcgxDmcDevice, fu_ccgx_dmc_device, FU_TYPE_USB_DEVICE)

static gboolean
fu_ccgx_dmc_device_get_dock_id(FuCcgxDmcDevice *self, DmcDockIdentity *dock_id, GError **error)
{
	g_return_val_if_fail(dock_id != NULL, FALSE);

	if (!g_usb_device_control_transfer(fu_usb_device_get_dev(FU_USB_DEVICE(self)),
					   G_USB_DEVICE_DIRECTION_DEVICE_TO_HOST,
					   G_USB_DEVICE_REQUEST_TYPE_VENDOR,
					   G_USB_DEVICE_RECIPIENT_DEVICE,
					   DMC_RQT_CODE_DOCK_IDENTITY, /* request */
					   0,			       /* value */
					   0,			       /* index */
					   (guint8 *)dock_id,	       /* data */
					   sizeof(DmcDockIdentity),    /* length */
					   NULL,		       /* actual length */
					   DMC_CONTROL_TRANSFER_DEFAULT_TIMEOUT,
					   NULL,
					   error)) {
		g_prefix_error(error, "get_dock_id error: ");
		return FALSE;
	}
	return TRUE;
}

static gboolean
fu_ccgx_dmc_device_get_dock_status(FuCcgxDmcDevice *self,
				   DmcDockStatus *dock_status,
				   GError **error)
{
	g_return_val_if_fail(dock_status != NULL, FALSE);

	/* read minimum status length */
	if (!g_usb_device_control_transfer(fu_usb_device_get_dev(FU_USB_DEVICE(self)),
					   G_USB_DEVICE_DIRECTION_DEVICE_TO_HOST,
					   G_USB_DEVICE_REQUEST_TYPE_VENDOR,
					   G_USB_DEVICE_RECIPIENT_DEVICE,
					   DMC_RQT_CODE_DOCK_STATUS, /* request */
					   0,			     /* value */
					   0,			     /* index */
					   (guint8 *)dock_status,    /* data */
					   DMC_GET_STATUS_MIN_LEN,   /* length */
					   NULL,		     /* actual length */
					   DMC_CONTROL_TRANSFER_DEFAULT_TIMEOUT,
					   NULL,
					   error)) {
		g_prefix_error(error, "get_dock_status min size error: ");
		return FALSE;
	}
	if (dock_status->status_length <= sizeof(DmcDockStatus)) {
		/* read full status length */
		if (!g_usb_device_control_transfer(fu_usb_device_get_dev(FU_USB_DEVICE(self)),
						   G_USB_DEVICE_DIRECTION_DEVICE_TO_HOST,
						   G_USB_DEVICE_REQUEST_TYPE_VENDOR,
						   G_USB_DEVICE_RECIPIENT_DEVICE,
						   DMC_RQT_CODE_DOCK_STATUS, /* request */
						   0,			     /* value */
						   0,			     /* index */
						   (guint8 *)dock_status,    /* data */
						   sizeof(DmcDockStatus),    /* length */
						   NULL,		     /* actual length */
						   DMC_CONTROL_TRANSFER_DEFAULT_TIMEOUT,
						   NULL,
						   error)) {
			g_prefix_error(error, "get_dock_status actual size error: ");
			return FALSE;
		}
	}
	return TRUE;
}

static gboolean
fu_ccgx_dmc_device_send_reset_state_machine(FuCcgxDmcDevice *self, GError **error)
{
	if (!g_usb_device_control_transfer(fu_usb_device_get_dev(FU_USB_DEVICE(self)),
					   G_USB_DEVICE_DIRECTION_HOST_TO_DEVICE,
					   G_USB_DEVICE_REQUEST_TYPE_VENDOR,
					   G_USB_DEVICE_RECIPIENT_DEVICE,
					   DMC_RQT_CODE_RESET_STATE_MACHINE, /* request */
					   0,				     /* value */
					   0,				     /* index */
					   0,				     /* data */
					   0,				     /* length */
					   NULL,			     /* actual length */
					   DMC_CONTROL_TRANSFER_DEFAULT_TIMEOUT,
					   NULL,
					   error)) {
		g_prefix_error(error, "send reset state machine error: ");
		return FALSE;
	}
	return TRUE;
}

static gboolean
fu_ccgx_dmc_device_send_sort_reset(FuCcgxDmcDevice *self, gboolean reset_later, GError **error)
{
	if (!g_usb_device_control_transfer(fu_usb_device_get_dev(FU_USB_DEVICE(self)),
					   G_USB_DEVICE_DIRECTION_HOST_TO_DEVICE,
					   G_USB_DEVICE_REQUEST_TYPE_VENDOR,
					   G_USB_DEVICE_RECIPIENT_DEVICE,
					   DMC_RQT_CODE_SOFT_RESET, /* request */
					   reset_later,		    /* value */
					   0,			    /* index */
					   0,			    /* data */
					   0,			    /* length */
					   NULL,		    /* actual length */
					   DMC_CONTROL_TRANSFER_DEFAULT_TIMEOUT,
					   NULL,
					   error)) {
		g_prefix_error(error, "send reset error: ");
		return FALSE;
	}
	return TRUE;
}

static gboolean
fu_ccgx_dmc_device_send_start_upgrade(FuCcgxDmcDevice *self,
				      const guint8 *custom_meta_data,
				      guint16 custom_meta_bufsz,
				      GError **error)
{
	guint16 value = 0;
	if (custom_meta_bufsz > 0)
		value = 1;

	if (custom_meta_bufsz > 0 && custom_meta_data == NULL) {
		g_set_error(error,
			    FWUPD_ERROR,
			    FWUPD_ERROR_NOT_SUPPORTED,
			    "invalid metadata, buffer is NULL but size = %d",
			    custom_meta_bufsz);
		return FALSE;
	}
	if (!g_usb_device_control_transfer(
		fu_usb_device_get_dev(FU_USB_DEVICE(self)),
		G_USB_DEVICE_DIRECTION_HOST_TO_DEVICE,
		G_USB_DEVICE_REQUEST_TYPE_VENDOR,
		G_USB_DEVICE_RECIPIENT_DEVICE,
		DMC_RQT_CODE_UPGRADE_START, /* request */
		value,			    /* value */
		1, /* index, forced update for Adicora only, other dock will ignore it */
		(guint8 *)custom_meta_data, /* data */
		custom_meta_bufsz,	    /* length */
		NULL,			    /* actual length */
		DMC_CONTROL_TRANSFER_DEFAULT_TIMEOUT,
		NULL,
		error)) {
		g_prefix_error(error, "send reset error: ");
		return FALSE;
	}
	return TRUE;
}

static gboolean
fu_ccgx_dmc_device_send_download_trigger(FuCcgxDmcDevice *self,
					 DmcTriggerCode trigger,
					 GError **error)
{
	if (!g_usb_device_control_transfer(fu_usb_device_get_dev(FU_USB_DEVICE(self)),
					   G_USB_DEVICE_DIRECTION_HOST_TO_DEVICE,
					   G_USB_DEVICE_REQUEST_TYPE_VENDOR,
					   G_USB_DEVICE_RECIPIENT_DEVICE,
					   DMC_RQT_CODE_TRIGGER, /* request */
					   trigger,		 /* value */
					   0,			 /* index */
					   0,			 /* data */
					   0,			 /* length */
					   NULL,		 /* actual length */
					   DMC_CONTROL_TRANSFER_DEFAULT_TIMEOUT,
					   NULL,
					   error)) {
		g_prefix_error(error, "send download trigger error: ");
		return FALSE;
	}
	return TRUE;
}

static gboolean
fu_ccgx_dmc_device_send_fwct(FuCcgxDmcDevice *self,
			     const guint8 *fwct_buf,
			     guint16 fwct_sz,
			     GError **error)
{
	g_return_val_if_fail(fwct_buf != NULL, FALSE);

	if (!g_usb_device_control_transfer(fu_usb_device_get_dev(FU_USB_DEVICE(self)),
					   G_USB_DEVICE_DIRECTION_HOST_TO_DEVICE,
					   G_USB_DEVICE_REQUEST_TYPE_VENDOR,
					   G_USB_DEVICE_RECIPIENT_DEVICE,
					   DMC_RQT_CODE_FWCT_WRITE, /* request */
					   0,			    /* value */
					   0,			    /* index */
					   (guint8 *)fwct_buf,	    /* data */
					   fwct_sz,		    /* length */
					   NULL,		    /* actual length */
					   DMC_CONTROL_TRANSFER_DEFAULT_TIMEOUT,
					   NULL,
					   error)) {
		g_prefix_error(error, "send fwct error: ");
		return FALSE;
	}
	return TRUE;
}

static gboolean
fu_ccgx_dmc_device_read_intr_req(FuCcgxDmcDevice *self, DmcIntRqt *intr_rqt, GError **error)
{
	g_return_val_if_fail(intr_rqt != NULL, FALSE);

	if (!g_usb_device_interrupt_transfer(fu_usb_device_get_dev(FU_USB_DEVICE(self)),
					     self->ep_intr_in,
					     (guint8 *)intr_rqt,
					     sizeof(DmcIntRqt),
					     NULL,
					     DMC_GET_REQUEST_TIMEOUT,
					     NULL,
					     error)) {
		g_prefix_error(error, "read intr rqt error: ");
		return FALSE;
	}
	return TRUE;
}

static gboolean
fu_ccgx_dmc_device_send_write_command(FuCcgxDmcDevice *self,
				      guint16 start_row,
				      guint16 num_of_row,
				      GError **error)
{
	if (!g_usb_device_control_transfer(fu_usb_device_get_dev(FU_USB_DEVICE(self)),
					   G_USB_DEVICE_DIRECTION_HOST_TO_DEVICE,
					   G_USB_DEVICE_REQUEST_TYPE_VENDOR,
					   G_USB_DEVICE_RECIPIENT_DEVICE,
					   DMC_RQT_CODE_IMG_WRITE, /* request */
					   start_row,		   /* value */
					   num_of_row,		   /* index */
					   0,			   /* data */
					   0,			   /* length */
					   NULL,		   /* actual length */
					   DMC_CONTROL_TRANSFER_DEFAULT_TIMEOUT,
					   NULL,
					   error)) {
		g_prefix_error(error, "send fwct error: ");
		return FALSE;
	}
	return TRUE;
}

static gboolean
fu_ccgx_dmc_device_send_row_data(FuCcgxDmcDevice *self,
				 const guint8 *row_buffer,
				 guint16 row_size,
				 GError **error)
{
	g_return_val_if_fail(row_buffer != NULL, FALSE);

	if (!g_usb_device_bulk_transfer(fu_usb_device_get_dev(FU_USB_DEVICE(self)),
					self->ep_bulk_out,
					(guint8 *)row_buffer,
					row_size,
					NULL,
					DMC_BULK_OUT_PIPE_TIMEOUT,
					NULL,
					error)) {
		g_prefix_error(error, "write row data error: ");
		return FALSE;
	}
	return TRUE;
}

static void
fu_ccgx_dmc_device_to_string(FuDevice *device, guint idt, GString *str)
{
	FuCcgxDmcDevice *self = FU_CCGX_DMC_DEVICE(device);
	fu_common_string_append_kv(str,
				   idt,
				   "UpdateModel",
				   fu_ccgx_dmc_update_model_type_to_string(self->update_model));
	fu_common_string_append_kv(str,
				   idt,
				   "FwImageType",
				   fu_ccgx_fw_image_type_to_string(self->fw_image_type));
	fu_common_string_append_kx(str, idt, "EpBulkOut", self->ep_bulk_out);
	fu_common_string_append_kx(str, idt, "EpIntrIn", self->ep_intr_in);
}

static gboolean
fu_ccgx_dmc_get_image_write_status_cb(FuDevice *device, gpointer user_data, GError **error)
{
	FuCcgxDmcDevice *self = FU_CCGX_DMC_DEVICE(device);
	DmcIntRqt dmc_int_req = {0};

	/* get interrupt request */
	if (!fu_ccgx_dmc_device_read_intr_req(self, &dmc_int_req, error)) {
		g_prefix_error(error, "read intr req error in image write status: ");
		return FALSE;
	}
	/* check opcode for fw write */
	if (dmc_int_req.opcode != DMC_INT_OPCODE_IMG_WRITE_STATUS) {
		g_set_error(error,
			    FWUPD_ERROR,
			    FWUPD_ERROR_NOT_SUPPORTED,
			    "invalid dmc intr req opcode in image write status = %d",
			    dmc_int_req.opcode);
		return FALSE;
	}

	/* retry if data[0] is 1 otherwise error */
	if (dmc_int_req.data[0] != 0) {
		g_set_error(error,
			    FWUPD_ERROR,
			    FWUPD_ERROR_NOT_SUPPORTED,
			    "invalid dmc intr req data in image write status = %d",
			    dmc_int_req.data[0]);
		g_usleep(DMC_FW_WRITE_STATUS_RETRY_DELAY_MS * 1000);
		return FALSE;
	}
	return TRUE;
}

static gboolean
fu_ccgx_dmc_write_firmware_image(FuDevice *device,
				 FuCcgxDmcFirmwareRecord *img_rcd,
				 gsize *fw_data_written,
				 const gsize fw_data_size,
				 GError **error)
{
	FuCcgxDmcDevice *self = FU_CCGX_DMC_DEVICE(device);
	GPtrArray *seg_records;

	g_return_val_if_fail(img_rcd != NULL, FALSE);
	g_return_val_if_fail(fw_data_written != NULL, FALSE);

	/* get segment records */
	seg_records = img_rcd->seg_records;
	for (guint32 seg_index = 0; seg_index < seg_records->len; seg_index++) {
		GPtrArray *data_records = NULL;
		FuCcgxDmcFirmwareSegmentRecord *seg_rcd = g_ptr_array_index(seg_records, seg_index);

		/* write start row and number of rows to a device */
		if (!fu_ccgx_dmc_device_send_write_command(self,
							   seg_rcd->start_row,
							   seg_rcd->num_rows,
							   error))
			return FALSE;

		/* get data records */
		data_records = seg_rcd->data_records;
		for (guint32 data_index = 0; data_index < data_records->len; data_index++) {
			GBytes *data_rcd = g_ptr_array_index(data_records, data_index);
			const guint8 *row_buffer = NULL;
			gsize row_size = 0;

			/* write row data */
			row_buffer = g_bytes_get_data(data_rcd, &row_size);
			if (!fu_ccgx_dmc_device_send_row_data(self,
							      row_buffer,
							      (guint16)row_size,
							      error))
				return FALSE;

			/* increase fw written size */
			*fw_data_written += row_size;
			fu_device_set_progress_full(device, *fw_data_written, fw_data_size);

			/* get status */
			if (!fu_device_retry(FU_DEVICE(self),
					     fu_ccgx_dmc_get_image_write_status_cb,
					     DMC_FW_WRITE_STATUS_RETRY_COUNT,
					     NULL,
					     error))
				return FALSE;
		}
	}
	return TRUE;
}

static gboolean
fu_ccgx_dmc_write_firmware(FuDevice *device,
			   FuFirmware *firmware,
			   FwupdInstallFlags flags,
			   GError **error)
{
	FuCcgxDmcDevice *self = FU_CCGX_DMC_DEVICE(device);
	FuCcgxDmcFirmwareRecord *img_rcd = NULL;
	DmcIntRqt dmc_int_rqt = {0};
	GBytes *custom_meta_blob;
	GBytes *fwct_blob;
	GPtrArray *image_records;
	const guint8 *custom_meta_data = NULL;
	const guint8 *fwct_buf = NULL;
	gsize custom_meta_bufsz = 0;
	gsize fwct_sz = 0;
	gsize fw_data_size = 0;
	gsize fw_data_written = 0;
	guint8 img_index = 0;

	/* get fwct record */
	fwct_blob = fu_ccgx_dmc_firmware_get_fwct_record(FU_CCGX_DMC_FIRMWARE(firmware));
	fwct_buf = g_bytes_get_data(fwct_blob, &fwct_sz);
	if (fwct_buf == NULL) {
		g_set_error_literal(error,
				    FWUPD_ERROR,
				    FWUPD_ERROR_NOT_SUPPORTED,
				    "invalid fwct data");
		return FALSE;
	}

	/* get custom meta record */
	custom_meta_blob =
	    fu_ccgx_dmc_firmware_get_custom_meta_record(FU_CCGX_DMC_FIRMWARE(firmware));
	if (custom_meta_blob != NULL)
		custom_meta_data = g_bytes_get_data(custom_meta_blob, &custom_meta_bufsz);

	/* reset */
	fu_device_set_status(device, FWUPD_STATUS_DEVICE_BUSY);
	if (!fu_ccgx_dmc_device_send_reset_state_machine(self, error))
		return FALSE;

	/* start fw upgrade with custom metadata */
	if (!fu_ccgx_dmc_device_send_start_upgrade(self,
						   custom_meta_data,
						   custom_meta_bufsz,
						   error))
		return FALSE;

	/* send fwct data */
	if (!fu_ccgx_dmc_device_send_fwct(self, fwct_buf, fwct_sz, error))
		return FALSE;

	/* get total fw size */
	image_records = fu_ccgx_dmc_firmware_get_image_records(FU_CCGX_DMC_FIRMWARE(firmware));
	fw_data_size = fu_ccgx_dmc_firmware_get_fw_data_size(FU_CCGX_DMC_FIRMWARE(firmware));
	fu_device_set_status(device, FWUPD_STATUS_DEVICE_WRITE);
	while (1) {
		/* get interrupt request */
		if (!fu_ccgx_dmc_device_read_intr_req(self, &dmc_int_rqt, error))
			return FALSE;

		/* fw upgrade request */
		if (dmc_int_rqt.opcode != DMC_INT_OPCODE_FW_UPGRADE_RQT)
			break;

		img_index = dmc_int_rqt.data[0];
		if (img_index >= image_records->len) {
			g_set_error(error,
				    FWUPD_ERROR,
				    FWUPD_ERROR_NOT_SUPPORTED,
				    "invalid image index %d, expected less than %u",
				    img_index,
				    image_records->len);
			return FALSE;
		}

		/* write image */
		img_rcd = g_ptr_array_index(image_records, img_index);
		if (!fu_ccgx_dmc_write_firmware_image(device,
						      img_rcd,
						      &fw_data_written,
						      fw_data_size,
						      error))
			return FALSE;
	}

	if (dmc_int_rqt.opcode != DMC_INT_OPCODE_FW_UPGRADE_STATUS) {
		if (dmc_int_rqt.opcode == DMC_INT_OPCODE_FWCT_ANALYSIS_STATUS) {
			g_set_error(error,
				    FWUPD_ERROR,
				    FWUPD_ERROR_NOT_SUPPORTED,
				    "fwct analysis failed with status = %d",
				    dmc_int_rqt.data[0]);
			return FALSE;
		}
		g_set_error(error,
			    FWUPD_ERROR,
			    FWUPD_ERROR_NOT_SUPPORTED,
			    "invalid dmc intr req opcode = %d with status = %d",
			    dmc_int_rqt.opcode,
			    dmc_int_rqt.data[0]);
		return FALSE;
	}

	if (dmc_int_rqt.data[0] == DMC_DEVICE_STATUS_UPDATE_PHASE_1_COMPLETE) {
		self->update_model = DMC_UPDATE_MODEL_DOWNLOAD_TRIGGER;
	} else if (dmc_int_rqt.data[0] == DMC_DEVICE_STATUS_FW_DOWNLOADED_UPDATE_PEND) {
		self->update_model = DMC_UPDATE_MODEL_PENDING_RESET;
	} else {
		g_set_error(error,
			    FWUPD_ERROR,
			    FWUPD_ERROR_NOT_SUPPORTED,
			    "invalid status code = %u",
			    dmc_int_rqt.data[0]);
		return FALSE;
	}
	return TRUE;
}

static FuFirmware *
fu_ccgx_dmc_device_prepare_firmware(FuDevice *device,
				    GBytes *fw,
				    FwupdInstallFlags flags,
				    GError **error)
{
	g_autoptr(FuFirmware) firmware = fu_ccgx_dmc_firmware_new();
	FuCcgxDmcDevice *self = FU_CCGX_DMC_DEVICE(device);
	GBytes *custom_meta_blob = NULL;
	gboolean custom_meta_exist = FALSE;

	/* parse all images */
	if (!fu_firmware_parse(firmware, fw, flags, error))
		return NULL;

	/* get custom meta record */
	custom_meta_blob =
	    fu_ccgx_dmc_firmware_get_custom_meta_record(FU_CCGX_DMC_FIRMWARE(firmware));
	if (custom_meta_blob)
		if (g_bytes_get_size(custom_meta_blob) > 0)
			custom_meta_exist = TRUE;

	/* check custom meta flag */
	if (self->dock_id.custom_meta_data_flag != custom_meta_exist) {
		g_set_error_literal(error,
				    FWUPD_ERROR,
				    FWUPD_ERROR_NOT_SUPPORTED,
				    "custom metadata mismatch");
		return NULL;
	}
	return g_steal_pointer(&firmware);
}

static gboolean
fu_ccgx_dmc_device_attach(FuDevice *device, GError **error)
{
	FuCcgxDmcDevice *self = FU_CCGX_DMC_DEVICE(device);
	gboolean manual_replug;

	manual_replug =
	    fu_device_has_private_flag(device, FU_CCGX_DMC_DEVICE_FLAG_HAS_MANUAL_REPLUG);

	if (fu_device_get_update_state(self) != FWUPD_UPDATE_STATE_SUCCESS)
		return TRUE;

	if (self->update_model == DMC_UPDATE_MODEL_DOWNLOAD_TRIGGER) {
		DmcTriggerCode trigger_code = DMC_TRIGGER_CODE_UPDATE_NOW;

		if (manual_replug)
			trigger_code = DMC_TRIGGER_CODE_UPDATE_ON_DISCONNECT;

		if (!fu_ccgx_dmc_device_send_download_trigger(self, trigger_code, error)) {
			g_prefix_error(error, "download trigger error: ");
			return FALSE;
		}
	} else if (self->update_model == DMC_UPDATE_MODEL_PENDING_RESET) {
		if (!fu_ccgx_dmc_device_send_sort_reset(self, manual_replug, error)) {
			g_prefix_error(error, "soft reset error: ");
			return FALSE;
		}
	} else {
		g_set_error(error,
			    FWUPD_ERROR,
			    FWUPD_ERROR_NOT_SUPPORTED,
			    "invalid update model = %u",
			    self->update_model);
		return FALSE;
	}

	if (manual_replug)
		return TRUE;

	fu_device_set_status(device, FWUPD_STATUS_DEVICE_RESTART);
	fu_device_add_flag(device, FWUPD_DEVICE_FLAG_WAIT_FOR_REPLUG);
	return TRUE;
}

static gboolean
fu_ccgx_dmc_device_setup(FuDevice *device, GError **error)
{
	FuCcgxDmcDevice *self = FU_CCGX_DMC_DEVICE(device);
	DmcDockStatus dock_status = {0};
	DmcDockIdentity dock_id = {0};
	guint32 version_raw = 0;
	g_autofree gchar *version = NULL;

	/* FuUsbDevice->setup */
	if (!FU_DEVICE_CLASS(fu_ccgx_dmc_device_parent_class)->setup(device, error))
		return FALSE;

	/* get dock identity */
	if (!fu_ccgx_dmc_device_get_dock_id(self, &dock_id, error))
		return FALSE;

	/* store dock identity */
	if (!fu_memcpy_safe((guint8 *)&self->dock_id,
			    sizeof(DmcDockIdentity),
			    0x0, /* dst */
			    (guint8 *)&dock_id,
			    sizeof(DmcDockIdentity),
			    0, /* src */
			    sizeof(DmcDockIdentity),
			    error))
		return FALSE;

	/* get dock status */
	if (!fu_ccgx_dmc_device_get_dock_status(self, &dock_status, error))
		return FALSE;

	/* set composite version */
	version_raw = dock_status.composite_version;
	version = fu_common_version_from_uint32(version_raw, FWUPD_VERSION_FORMAT_QUAD);
	fu_device_set_version(FU_DEVICE(self), version);
	fu_device_set_version_raw(FU_DEVICE(self), version_raw);
	fu_device_add_flag(FU_DEVICE(self), FWUPD_DEVICE_FLAG_UPDATABLE);
	return TRUE;
}

static gboolean
fu_ccgx_dmc_device_set_quirk_kv(FuDevice *device,
				const gchar *key,
				const gchar *value,
				GError **error)
{
	FuCcgxDmcDevice *self = FU_CCGX_DMC_DEVICE(device);

	if (g_strcmp0(key, "CcgxImageKind") == 0) {
		self->fw_image_type = fu_ccgx_fw_image_type_from_string(value);
		if (self->fw_image_type != FW_IMAGE_TYPE_UNKNOWN)
			return TRUE;
		g_set_error_literal(error,
				    G_IO_ERROR,
				    G_IO_ERROR_INVALID_DATA,
				    "invalid CcgxImageKind");
		return FALSE;
	}
	g_set_error_literal(error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED, "no supported");
	return FALSE;
}

static void
fu_ccgx_dmc_device_init(FuCcgxDmcDevice *self)
{
	self->ep_intr_in = DMC_INTERRUPT_PIPE_ID;
	self->ep_bulk_out = DMC_BULK_PIPE_ID;
	fu_device_add_protocol(FU_DEVICE(self), "com.cypress.ccgx.dmc");
	fu_device_set_version_format(FU_DEVICE(self), FWUPD_VERSION_FORMAT_QUAD);
	fu_device_add_flag(FU_DEVICE(self), FWUPD_DEVICE_FLAG_REQUIRE_AC);
	fu_device_add_flag(FU_DEVICE(self), FWUPD_DEVICE_FLAG_DUAL_IMAGE);
	fu_device_add_flag(FU_DEVICE(self), FWUPD_DEVICE_FLAG_SELF_RECOVERY);
	fu_device_add_internal_flag(FU_DEVICE(self), FU_DEVICE_INTERNAL_FLAG_REPLUG_MATCH_GUID);
	fu_device_register_private_flag(FU_DEVICE(self),
					FU_CCGX_DMC_DEVICE_FLAG_HAS_MANUAL_REPLUG,
					"has-manual-replug");
}

static void
fu_ccgx_dmc_device_class_init(FuCcgxDmcDeviceClass *klass)
{
	FuDeviceClass *klass_device = FU_DEVICE_CLASS(klass);
	klass_device->to_string = fu_ccgx_dmc_device_to_string;
	klass_device->write_firmware = fu_ccgx_dmc_write_firmware;
	klass_device->prepare_firmware = fu_ccgx_dmc_device_prepare_firmware;
	klass_device->attach = fu_ccgx_dmc_device_attach;
	klass_device->setup = fu_ccgx_dmc_device_setup;
	klass_device->set_quirk_kv = fu_ccgx_dmc_device_set_quirk_kv;
}