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

#include "config.h"

#include "fu-common.h"
#include "fu-firmware.h"

#include "fu-vli-pd-device.h"
#include "fu-vli-pd-firmware.h"
#include "fu-vli-pd-parade-device.h"

struct _FuVliPdDevice
{
	FuVliDevice		 parent_instance;
};

G_DEFINE_TYPE (FuVliPdDevice, fu_vli_pd_device, FU_TYPE_VLI_DEVICE)

static gboolean
fu_vli_pd_device_read_regs (FuVliPdDevice *self, guint16 addr,
			    guint8 *buf, gsize bufsz, GError **error)
{
	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,
					    0xe0,
					    ((addr & 0xff) << 8) | 0x01,
					    addr >> 8,
					    buf, bufsz, NULL,
					    1000, NULL, error)) {
		g_prefix_error (error, "failed to write register @0x%x: ", addr);
		return FALSE;
	}
	if (g_getenv ("FWUPD_VLI_USBHUB_VERBOSE") != NULL) {
		g_autofree gchar *title = g_strdup_printf ("ReadRegs@0x%x", addr);
		fu_common_dump_raw (G_LOG_DOMAIN, title, buf, bufsz);
	}
	return TRUE;
}

static gboolean
fu_vli_pd_device_read_reg (FuVliPdDevice *self, guint16 addr, guint8 *value, GError **error)
{
	return fu_vli_pd_device_read_regs (self, addr, value, 0x1, error);
}

static gboolean
fu_vli_pd_device_write_reg (FuVliPdDevice *self, guint16 addr, guint8 value, GError **error)
{
	if (g_getenv ("FWUPD_VLI_USBHUB_VERBOSE") != NULL) {
		g_autofree gchar *title = g_strdup_printf ("WriteReg@0x%x", addr);
		fu_common_dump_raw (G_LOG_DOMAIN, title, &value, sizeof(value));
	}
	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,
					    0xe0,
					    ((addr & 0xff) << 8) | 0x02,
					    addr >> 8,
					    &value, sizeof(value), NULL,
					    1000, NULL, error)) {
		g_prefix_error (error, "failed to write register @0x%x: ", addr);
		return FALSE;
	}
	return TRUE;
}

static gboolean
fu_vli_pd_device_spi_read_status (FuVliDevice *self, guint8 *status, GError **error)
{
	guint8 spi_cmd = 0x0;
	if (!fu_vli_device_get_spi_cmd (self, FU_VLI_DEVICE_SPI_REQ_READ_STATUS,
					&spi_cmd, error))
		return FALSE;
	return 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,
					      0xc5, spi_cmd, 0x0000,
					      status, 0x1, NULL,
					      FU_VLI_DEVICE_TIMEOUT,
					      NULL, error);
}

static gboolean
fu_vli_pd_device_spi_read_data (FuVliDevice *self, guint32 addr, guint8 *buf, gsize bufsz, GError **error)
{
	guint8 spi_cmd = 0x0;
	guint16 value;
	guint16 index;
	if (!fu_vli_device_get_spi_cmd (self, FU_VLI_DEVICE_SPI_REQ_READ_DATA,
					&spi_cmd, error))
		return FALSE;
	value = ((addr << 8) & 0xff00) | spi_cmd;
	index = addr >> 8;
	return 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,
					      0xc4, value, index,
					      buf, bufsz, NULL,
					      FU_VLI_DEVICE_TIMEOUT,
					      NULL, error);
}

static gboolean
fu_vli_pd_device_spi_write_status (FuVliDevice *self, guint8 status, GError **error)
{
	guint8 spi_cmd = 0x0;
	guint16 value;
	if (!fu_vli_device_get_spi_cmd (self, FU_VLI_DEVICE_SPI_REQ_WRITE_STATUS,
					&spi_cmd, error))
		return FALSE;
	value = ((guint16) status << 8) | spi_cmd;
	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,
					    0xd8, value, 0x0,
					    NULL, 0, NULL,
					    FU_VLI_DEVICE_TIMEOUT,
					    NULL, error)) {
		return FALSE;
	}

	/* Fix_For_GD_&_EN_SPI_Flash */
	g_usleep (100 * 1000);
	return TRUE;
}

static gboolean
fu_vli_pd_device_spi_write_enable (FuVliDevice *self, GError **error)
{
	guint8 spi_cmd = 0x0;
	if (!fu_vli_device_get_spi_cmd (self, FU_VLI_DEVICE_SPI_REQ_WRITE_EN,
					&spi_cmd, error))
		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,
					    0xd4, spi_cmd, 0x0000,
					    NULL, 0x0, NULL,
					    FU_VLI_DEVICE_TIMEOUT,
					    NULL, error)) {
		g_prefix_error (error, "failed to write enable SPI: ");
		return FALSE;
	}
	return TRUE;
}

static gboolean
fu_vli_pd_device_spi_chip_erase (FuVliDevice *self, GError **error)
{
	guint8 spi_cmd = 0x0;
	if (!fu_vli_device_get_spi_cmd (self, FU_VLI_DEVICE_SPI_REQ_CHIP_ERASE,
					&spi_cmd, error))
		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,
					    0xd1, spi_cmd, 0x0000,
					    NULL, 0x0, NULL,
					    FU_VLI_DEVICE_TIMEOUT,
					    NULL, error)) {
		return FALSE;
	}
	return TRUE;
}

static gboolean
fu_vli_pd_device_spi_sector_erase (FuVliDevice *self, guint32 addr, GError **error)
{
	guint8 spi_cmd = 0x0;
	guint16 value;
	guint16 index;
	if (!fu_vli_device_get_spi_cmd (self, FU_VLI_DEVICE_SPI_REQ_SECTOR_ERASE,
					&spi_cmd, error))
		return FALSE;
	value = ((addr << 8) & 0xff00) | spi_cmd;
	index = addr >> 8;
	return 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,
					      0xd2, value, index,
					      NULL, 0x0, NULL,
					      FU_VLI_DEVICE_TIMEOUT,
					      NULL, error);
}

static gboolean
fu_vli_pd_device_spi_write_data (FuVliDevice *self,
				 guint32 addr,
				 const guint8 *buf,
				 gsize bufsz,
				 GError **error)
{
	guint8 spi_cmd = 0x0;
	guint16 value;
	guint16 index;
	if (!fu_vli_device_get_spi_cmd (self, FU_VLI_DEVICE_SPI_REQ_PAGE_PROG,
					&spi_cmd, error))
		return FALSE;
	value = ((addr << 8) & 0xff00) | spi_cmd;
	index = addr >> 8;
	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,
					    0xdc, value, index,
					    (guint8 *) buf, bufsz, NULL,
					    FU_VLI_DEVICE_TIMEOUT,
					    NULL, error)) {
		return FALSE;
	}
	return TRUE;
}

static gboolean
fu_vli_pd_device_parade_setup (FuVliPdDevice *self, GError **error)
{
	g_autoptr(FuDevice) dev = NULL;
	g_autoptr(GError) error_local = NULL;

	/* add child */
	dev = fu_vli_pd_parade_device_new (FU_VLI_DEVICE (self));
	if (!fu_device_probe (dev, &error_local)) {
		if (g_error_matches (error_local,
				     FWUPD_ERROR,
				     FWUPD_ERROR_NOT_FOUND)) {
			g_debug ("%s", error_local->message);
		} else {
			g_warning ("cannot create I²C parade device: %s",
				   error_local->message);
		}
		return TRUE;
	}
	if (!fu_device_setup (dev, error)) {
		g_prefix_error (error, "failed to set up parade device: ");
		return FALSE;
	}
	fu_device_add_child (FU_DEVICE (self), dev);
	return TRUE;
}

static gboolean
fu_vli_pd_device_setup (FuVliDevice *device, GError **error)
{
	FuVliPdDevice *self = FU_VLI_PD_DEVICE (device);
	guint32 version_raw;
	guint8 verbuf[4] = { 0x0 };
	guint8 tmp = 0;
	g_autofree gchar *version_str = NULL;

	/* get version */
	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,
					    0xe2, 0x0001, 0x0000,
					    verbuf, sizeof(verbuf), NULL,
					    1000, NULL, error)) {
		g_prefix_error (error, "failed to get version: ");
		return FALSE;
	}
	if (!fu_common_read_uint32_safe (verbuf, sizeof(verbuf), 0x0,
					 &version_raw, G_BIG_ENDIAN, error))
		return FALSE;
	fu_device_set_version_raw (FU_DEVICE (self), version_raw);
	version_str = fu_common_version_from_uint32 (version_raw, FWUPD_VERSION_FORMAT_QUAD);
	fu_device_set_version (FU_DEVICE (self), version_str);

	/* get device kind if not already in ROM mode */
	if (fu_vli_device_get_kind (device) == FU_VLI_DEVICE_KIND_UNKNOWN) {
		if (!fu_vli_pd_device_read_reg (self, 0x0018, &tmp, error))
			return FALSE;
		switch (tmp & 0xF0) {
		case 0x00:
			fu_vli_device_set_kind (device, FU_VLI_DEVICE_KIND_VL100);
			break;
		case 0x10:
			/* this is also the code for VL101, but VL102 is more likely */
			fu_vli_device_set_kind (device, FU_VLI_DEVICE_KIND_VL102);
			break;
		case 0x80:
			fu_vli_device_set_kind (device, FU_VLI_DEVICE_KIND_VL103);
			break;
		case 0x90:
			fu_vli_device_set_kind (device, FU_VLI_DEVICE_KIND_VL104);
			break;
		default:
			g_set_error (error,
				     FWUPD_ERROR,
				     FWUPD_ERROR_INVALID_FILE,
				     "unable to map 0x0018=0x%02X to device kind",
				     tmp);
			return FALSE;
		}
	}

	/* get bootloader mode */
	if (!fu_vli_pd_device_read_reg (self, 0x00F7, &tmp, error))
		return FALSE;
	if ((tmp & 0x80) == 0x00)
		fu_device_add_flag (FU_DEVICE (self), FWUPD_DEVICE_FLAG_IS_BOOTLOADER);
	else
		fu_device_remove_flag (FU_DEVICE (self), FWUPD_DEVICE_FLAG_IS_BOOTLOADER);

	/* detect any I²C child, e.g. parade device */
	if (fu_device_has_custom_flag (FU_DEVICE (self), "has-i2c-ps186")) {
		if (!fu_vli_pd_device_parade_setup (self, error))
			return FALSE;
	}

	/* success */
	return TRUE;
}

static FuFirmware *
fu_vli_pd_device_prepare_firmware (FuDevice *device,
				   GBytes *fw,
				   FwupdInstallFlags flags,
				   GError **error)
{
	FuVliPdDevice *self = FU_VLI_PD_DEVICE (device);
	FuVliDeviceKind device_kind;
	g_autoptr(FuFirmware) firmware = fu_vli_pd_firmware_new ();

	/* check size */
	if (g_bytes_get_size (fw) > fu_device_get_firmware_size_max (device)) {
		g_set_error (error,
			     FWUPD_ERROR,
			     FWUPD_ERROR_INVALID_FILE,
			     "firmware too large, got 0x%x, expected <= 0x%x",
			     (guint) g_bytes_get_size (fw),
			     (guint) fu_device_get_firmware_size_max (device));
		return NULL;
	}

	/* check is compatible with firmware */
	if (!fu_firmware_parse (firmware, fw, flags, error))
		return NULL;
	device_kind = fu_vli_pd_firmware_get_kind (FU_VLI_PD_FIRMWARE (firmware));
	if (fu_vli_device_get_kind (FU_VLI_DEVICE (self)) != device_kind) {
		g_set_error (error,
			     FWUPD_ERROR,
			     FWUPD_ERROR_INVALID_FILE,
			     "firmware incompatible, got %s, expected %s",
			     fu_vli_common_device_kind_to_string (device_kind),
			     fu_vli_common_device_kind_to_string (fu_vli_device_get_kind (FU_VLI_DEVICE (self))));
		return NULL;
	}

	/* we could check this against flags */
	g_debug ("parsed version: %s", fu_firmware_get_version (firmware));
	return g_steal_pointer (&firmware);
}

static GBytes *
fu_vli_pd_device_dump_firmware (FuDevice *device, GError **error)
{
	FuVliPdDevice *self = FU_VLI_PD_DEVICE (device);
	g_autoptr(FuDeviceLocker) locker = NULL;

	/* require detach -> attach */
	locker = fu_device_locker_new_full (device,
					    (FuDeviceLockerFunc) fu_device_detach,
					    (FuDeviceLockerFunc) fu_device_attach,
					    error);
	if (locker == NULL)
		return NULL;
	fu_device_set_status (FU_DEVICE (self), FWUPD_STATUS_DEVICE_READ);
	return fu_vli_device_spi_read (FU_VLI_DEVICE (self), 0x0,
				       fu_device_get_firmware_size_max (device),
				       error);
}

static gboolean
fu_vli_pd_device_write_gpios (FuVliPdDevice *self, GError **error)
{
	/* disable UART-Rx mode */
	if (!fu_vli_pd_device_write_reg (self, 0x0015, 0x7F, error))
		return FALSE;
	/* disable 'Watch Mode', chip is not in debug mode */
	if (!fu_vli_pd_device_write_reg (self, 0x0019, 0x00, error))
		return FALSE;
	/* GPIO3 output enable, switch/CMOS/Boost control pin */
	if (!fu_vli_pd_device_write_reg (self, 0x001C, 0x02, error))
		return FALSE;
	return TRUE;
}

static gboolean
fu_vli_pd_device_write_dual_firmware (FuVliPdDevice *self, GBytes *fw, GError **error)
{
	const guint8 *buf = NULL;
	const guint8 *sbuf = NULL;
	gsize bufsz = 0;
	gsize sbufsz = 0;
	guint16 crc_actual;
	guint16 crc_file = 0x0;
	guint32 sec_addr = 0x28000;
	g_autoptr(GBytes) spi_fw = NULL;

	/* check spi fw1 crc16 */
	fu_device_set_status (FU_DEVICE (self), FWUPD_STATUS_DEVICE_VERIFY);
	spi_fw = fu_vli_device_spi_read (FU_VLI_DEVICE (self),
					 fu_vli_device_get_offset (FU_VLI_DEVICE (self)),
					 fu_device_get_firmware_size_max (FU_DEVICE (self)),
					 error);
	if (spi_fw == NULL)
		return FALSE;
	sbuf = g_bytes_get_data (spi_fw, &sbufsz);
	if (sbufsz != 0x8000)
		sec_addr = 0x30000;
	if (!fu_common_read_uint16_safe	(sbuf, sbufsz, sbufsz - 2, &crc_file,
					 G_LITTLE_ENDIAN, error)) {
		g_prefix_error (error, "failed to read file CRC: ");
		return FALSE;
	}
	crc_actual = fu_common_crc16 (sbuf, sbufsz - 2);
	fu_device_set_status (FU_DEVICE (self), FWUPD_STATUS_DEVICE_WRITE);

	/* update fw2 first if fw1 correct */
	buf = g_bytes_get_data (fw, &bufsz);
	if (crc_actual == crc_file) {
		if (!fu_vli_device_spi_write (FU_VLI_DEVICE (self),
					      sec_addr,
					      buf, bufsz, error))
			return FALSE;
		if (!fu_vli_device_spi_write (FU_VLI_DEVICE (self),
					      fu_vli_device_get_offset (FU_VLI_DEVICE (self)),
					      buf, bufsz, error))
			return FALSE;

	/* else update fw1 first */
	} else {
		if (!fu_vli_device_spi_write (FU_VLI_DEVICE (self),
					      fu_vli_device_get_offset (FU_VLI_DEVICE (self)),
					      buf, bufsz, error))
			return FALSE;
		if (!fu_vli_device_spi_write (FU_VLI_DEVICE (self),
					      sec_addr,
					      buf, bufsz, error))
			return FALSE;
	}

	/* success */
	return TRUE;
}

static gboolean
fu_vli_pd_device_write_firmware (FuDevice *device,
				 FuFirmware *firmware,
				 FwupdInstallFlags flags,
				 GError **error)
{
	FuVliPdDevice *self = FU_VLI_PD_DEVICE (device);
	gsize bufsz = 0;
	guint8 tmp = 0;
	const guint8 *buf = NULL;
	g_autoptr(GBytes) fw = NULL;

	/* binary blob */
	fw = fu_firmware_get_image_default_bytes (firmware, error);
	if (fw == NULL)
		return FALSE;

	/* write GPIOs in new mode */
	if (!fu_vli_pd_device_write_gpios (self, error))
		return FALSE;

	/* disable write protect in GPIO_3 */
	if (!fu_vli_pd_device_read_reg (self, 0x0003, &tmp, error))
		return FALSE;
	if (!fu_vli_pd_device_write_reg (self, 0x0003, tmp | 0x44, error))
		return FALSE;

	/* dual image on VL103 */
	if (fu_vli_device_get_kind (FU_VLI_DEVICE (device)) == FU_VLI_DEVICE_KIND_VL103 &&
	    fu_device_has_flag (device, FWUPD_DEVICE_FLAG_DUAL_IMAGE))
		return fu_vli_pd_device_write_dual_firmware (self, fw, error);

	/* erase */
	fu_device_set_status (FU_DEVICE (self), FWUPD_STATUS_DEVICE_ERASE);
	if (!fu_vli_device_spi_erase_all (FU_VLI_DEVICE (self), error))
		return FALSE;

	/* write in chunks */
	fu_device_set_status (FU_DEVICE (self), FWUPD_STATUS_DEVICE_WRITE);
	buf = g_bytes_get_data (fw, &bufsz);
	if (!fu_vli_device_spi_write (FU_VLI_DEVICE (self),
				      fu_vli_device_get_offset (FU_VLI_DEVICE (self)),
				      buf, bufsz, error))
		return FALSE;

	/* success */
	return TRUE;
}

static gboolean
fu_vli_pd_device_detach (FuDevice *device, GError **error)
{
	FuVliPdDevice *self = FU_VLI_PD_DEVICE (device);
	g_autoptr(GError) error_local = NULL;

	/* sanity check */
	if (fu_device_has_flag (device, FWUPD_DEVICE_FLAG_IS_BOOTLOADER)) {
		g_debug ("already in bootloader mode, skipping");
		return TRUE;
	}

	/* write GPIOs */
	if (!fu_vli_pd_device_write_gpios (self, error))
		return FALSE;

	/* VL103 set ROM sig does not work, so use alternate function */
	if (fu_vli_device_get_kind (FU_VLI_DEVICE (device)) == FU_VLI_DEVICE_KIND_VL103) {
		fu_device_set_status (device, FWUPD_STATUS_DEVICE_RESTART);
		if (!g_usb_device_control_transfer (fu_usb_device_get_dev (FU_USB_DEVICE (device)),
						    G_USB_DEVICE_DIRECTION_HOST_TO_DEVICE,
						    G_USB_DEVICE_REQUEST_TYPE_VENDOR,
						    G_USB_DEVICE_RECIPIENT_DEVICE,
						    0xc0, 0x0000, 0x0000,
						    NULL, 0x0, NULL,
						    FU_VLI_DEVICE_TIMEOUT,
						    NULL, &error_local)) {
			if (g_error_matches (error_local,
					     G_USB_DEVICE_ERROR,
					     G_USB_DEVICE_ERROR_FAILED)) {
				g_debug ("ignoring %s", error_local->message);
			} else {
				g_propagate_prefixed_error (error,
							    g_steal_pointer (&error_local),
							    "failed to restart device: ");
				return FALSE;
			}
		}
		fu_device_add_flag (device, FWUPD_DEVICE_FLAG_WAIT_FOR_REPLUG);
		return TRUE;
	}

	/* patch APP5 FW bug (2AF2 -> 2AE2) on VL100-App5 and VL102 */
	if (fu_vli_device_get_kind (FU_VLI_DEVICE (device)) == FU_VLI_DEVICE_KIND_VL100 ||
	    fu_vli_device_get_kind (FU_VLI_DEVICE (device)) == FU_VLI_DEVICE_KIND_VL102) {
		guint8 tmp = 0;
		if (!fu_vli_pd_device_read_reg (self, 0x0018, &tmp, error))
			return FALSE;
		if (tmp != 0x80) {
			if (!fu_vli_pd_device_write_reg (self, 0x2AE2, 0x1E, error))
				return FALSE;
			if (!fu_vli_pd_device_write_reg (self, 0x2AE3, 0xC3, error))
				return FALSE;
			if (!fu_vli_pd_device_write_reg (self, 0x2AE4, 0x5A, error))
				return FALSE;
			if (!fu_vli_pd_device_write_reg (self, 0x2AE5, 0x87, error))
				return FALSE;
		}
	}

	/* set ROM sig */
	if (!g_usb_device_control_transfer (fu_usb_device_get_dev (FU_USB_DEVICE (device)),
					    G_USB_DEVICE_DIRECTION_HOST_TO_DEVICE,
					    G_USB_DEVICE_REQUEST_TYPE_VENDOR,
					    G_USB_DEVICE_RECIPIENT_DEVICE,
					    0xa0,
					    0x0000, 0x0000,
					    NULL, 0x0, NULL,
					    FU_VLI_DEVICE_TIMEOUT,
					    NULL, error))
		return FALSE;

	/* reset from SPI_Code into ROM_Code */
	fu_device_set_status (device, FWUPD_STATUS_DEVICE_RESTART);
	if (!g_usb_device_control_transfer (fu_usb_device_get_dev (FU_USB_DEVICE (device)),
					    G_USB_DEVICE_DIRECTION_HOST_TO_DEVICE,
					    G_USB_DEVICE_REQUEST_TYPE_VENDOR,
					    G_USB_DEVICE_RECIPIENT_DEVICE,
					    0xb0, 0x0000, 0x0000,
					    NULL, 0x0, NULL,
					    FU_VLI_DEVICE_TIMEOUT,
					    NULL, &error_local)) {
		if (g_error_matches (error_local,
				     G_USB_DEVICE_ERROR,
				     G_USB_DEVICE_ERROR_FAILED)) {
			g_debug ("ignoring %s", error_local->message);
		} else {
			g_propagate_prefixed_error (error,
						    g_steal_pointer (&error_local),
						    "failed to restart device: ");
			return FALSE;
		}
	}
	fu_device_add_flag (device, FWUPD_DEVICE_FLAG_WAIT_FOR_REPLUG);
	return TRUE;
}

static gboolean
fu_vli_pd_device_attach (FuDevice *device, GError **error)
{
	FuVliPdDevice *self = FU_VLI_PD_DEVICE (device);
	g_autoptr(GError) error_local = NULL;

	/* Work around a silicon bug: Once the CC-resistor is removed, the
	 * CC-host thinks the device is un-plugged and turn off VBUS (power).
	 * When VL103 is powered-off, VL103 puts a resistor at CC-pin.
	 * The CC-host will think the device is re-plugged and provides VBUS
	 * again. Then, VL103 will be powered on and runs new FW. */
	if (fu_vli_device_get_kind (FU_VLI_DEVICE (device)) == FU_VLI_DEVICE_KIND_VL103) {
		if (!fu_vli_pd_device_write_reg (self, 0x1201, 0xf6, error))
			return FALSE;
		if (!fu_vli_pd_device_write_reg (self, 0x1001, 0xf6, error))
			return FALSE;
		fu_device_set_status (device, FWUPD_STATUS_DEVICE_RESTART);
		fu_device_add_flag (device, FWUPD_DEVICE_FLAG_WAIT_FOR_REPLUG);
		return TRUE;
	}

	/* sanity check */
	if (!fu_device_has_flag (device, FWUPD_DEVICE_FLAG_IS_BOOTLOADER)) {
		g_debug ("already in runtime mode, skipping");
		return TRUE;
	}

	/* chip reset command works only for non-VL103 */
	if (!g_usb_device_control_transfer (fu_usb_device_get_dev (FU_USB_DEVICE (device)),
					    G_USB_DEVICE_DIRECTION_HOST_TO_DEVICE,
					    G_USB_DEVICE_REQUEST_TYPE_VENDOR,
					    G_USB_DEVICE_RECIPIENT_DEVICE,
					    0xb0,
					    0x0000, 0x0000,
					    NULL, 0x0, NULL,
					    FU_VLI_DEVICE_TIMEOUT,
					    NULL, &error_local)) {
		if (g_error_matches (error_local,
				     G_USB_DEVICE_ERROR,
				     G_USB_DEVICE_ERROR_NO_DEVICE) ||
		    g_error_matches (error_local,
				     G_USB_DEVICE_ERROR,
				     G_USB_DEVICE_ERROR_TIMED_OUT) ||
		    g_error_matches (error_local,
				     G_USB_DEVICE_ERROR,
				     G_USB_DEVICE_ERROR_FAILED)) {
			g_debug ("ignoring %s", error_local->message);
		} else {
			g_propagate_prefixed_error (error,
						    g_steal_pointer (&error_local),
						    "failed to restart device: ");
			return FALSE;
		}
	}

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

static void
fu_vli_pd_device_kind_changed_cb (FuVliDevice *device, GParamSpec *pspec, gpointer user_data)
{
	if (fu_vli_device_get_kind (device) == FU_VLI_DEVICE_KIND_VL103) {
		/* wait for USB-C timeout */
		fu_device_set_remove_delay (FU_DEVICE (device), 10000);
	}
}

static void
fu_vli_pd_device_init (FuVliPdDevice *self)
{
	fu_device_add_icon (FU_DEVICE (self), "audio-card");
	fu_device_add_protocol (FU_DEVICE (self), "com.vli.pd");
	fu_device_set_summary (FU_DEVICE (self), "USB PD");
	fu_device_add_flag (FU_DEVICE (self), FWUPD_DEVICE_FLAG_UPDATABLE);
	fu_device_add_flag (FU_DEVICE (self), FWUPD_DEVICE_FLAG_CAN_VERIFY_IMAGE);
	fu_device_set_remove_delay (FU_DEVICE (self), FU_DEVICE_REMOVE_DELAY_RE_ENUMERATE);
	fu_device_set_version_format (FU_DEVICE (self), FWUPD_VERSION_FORMAT_QUAD);
	fu_vli_device_set_spi_auto_detect (FU_VLI_DEVICE (self), FALSE);

	/* connect up attach or detach vfuncs when kind is known */
	g_signal_connect (self, "notify::kind",
			  G_CALLBACK (fu_vli_pd_device_kind_changed_cb), NULL);
}

static void
fu_vli_pd_device_class_init (FuVliPdDeviceClass *klass)
{
	FuDeviceClass *klass_device = FU_DEVICE_CLASS (klass);
	FuVliDeviceClass *klass_vli_device = FU_VLI_DEVICE_CLASS (klass);
	klass_device->dump_firmware = fu_vli_pd_device_dump_firmware;
	klass_device->write_firmware = fu_vli_pd_device_write_firmware;
	klass_device->prepare_firmware = fu_vli_pd_device_prepare_firmware;
	klass_device->attach = fu_vli_pd_device_attach;
	klass_device->detach = fu_vli_pd_device_detach;
	klass_vli_device->setup = fu_vli_pd_device_setup;
	klass_vli_device->spi_chip_erase = fu_vli_pd_device_spi_chip_erase;
	klass_vli_device->spi_sector_erase = fu_vli_pd_device_spi_sector_erase;
	klass_vli_device->spi_read_data = fu_vli_pd_device_spi_read_data;
	klass_vli_device->spi_read_status = fu_vli_pd_device_spi_read_status;
	klass_vli_device->spi_write_data = fu_vli_pd_device_spi_write_data;
	klass_vli_device->spi_write_enable = fu_vli_pd_device_spi_write_enable;
	klass_vli_device->spi_write_status = fu_vli_pd_device_spi_write_status;
}
