fwupd/plugins/hailuck/fu-hailuck-bl-device.c

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

#include "config.h"

#include <fwupdplugin.h>

#include "fu-hailuck-common.h"
#include "fu-hailuck-bl-device.h"
#include "fu-hailuck-kbd-firmware.h"

struct _FuHailuckBlDevice {
	FuHidDevice		 parent_instance;
};

G_DEFINE_TYPE (FuHailuckBlDevice, fu_hailuck_bl_device, FU_TYPE_HID_DEVICE)

static gboolean
fu_hailuck_bl_device_attach (FuDevice *device, GError **error)
{
	guint8 buf[6] = {
		FU_HAILUCK_REPORT_ID_SHORT,
		FU_HAILUCK_CMD_ATTACH,
	};
	fu_device_set_status (device, FWUPD_STATUS_DEVICE_RESTART);
	if (!fu_hid_device_set_report (FU_HID_DEVICE (device),
				       buf[0], buf, sizeof(buf), 1000,
				       FU_HID_DEVICE_FLAG_IS_FEATURE, error))
		return FALSE;
	if (!g_usb_device_reset (fu_usb_device_get_dev (FU_USB_DEVICE (device)), error))
		return FALSE;
	fu_device_add_flag (device, FWUPD_DEVICE_FLAG_WAIT_FOR_REPLUG);
	return TRUE;
}

static gboolean
fu_hailuck_bl_device_probe (FuDevice *device, GError **error)
{
	g_autofree gchar *devid = NULL;

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

	/* add extra keyboard-specific GUID */
	devid = g_strdup_printf ("USB\\VID_%04X&PID_%04X&MODE_KBD",
				 fu_usb_device_get_vid (FU_USB_DEVICE (device)),
				 fu_usb_device_get_pid (FU_USB_DEVICE (device)));
	fu_device_add_instance_id (device, devid);

	/* success */
	return TRUE;
}

static gboolean
fu_hailuck_bl_device_read_block_start (FuHailuckBlDevice *self,
					guint32 length,
					GError **error)
{
	guint8 buf[6] = {
		FU_HAILUCK_REPORT_ID_SHORT,
		FU_HAILUCK_CMD_READ_BLOCK_START,
	};
	fu_common_write_uint16 (buf + 4, length, G_LITTLE_ENDIAN);
	return fu_hid_device_set_report (FU_HID_DEVICE (self), buf[0],
					 buf, sizeof(buf), 100,
					 FU_HID_DEVICE_FLAG_IS_FEATURE, error);
}

static gboolean
fu_hailuck_bl_device_read_block (FuHailuckBlDevice *self,
				  guint8 *data, gsize data_sz,
				  GError **error)
{
	gsize bufsz = data_sz + 2;
	g_autofree guint8 *buf = g_malloc0 (bufsz);

	buf[0] = FU_HAILUCK_REPORT_ID_LONG;
	buf[1] = FU_HAILUCK_CMD_READ_BLOCK;
	if (!fu_hid_device_get_report (FU_HID_DEVICE (self), buf[0],
				       buf, bufsz, 2000,
				       FU_HID_DEVICE_FLAG_IS_FEATURE,
				       error))
		return FALSE;
	if (!fu_memcpy_safe (data, data_sz, 0x0,	/* dst */
			     buf, bufsz, 0x02,		/* src */
			     data_sz, error))
		return FALSE;

	/* success */
	g_usleep (10000);
	return TRUE;
}

static GBytes *
fu_hailuck_bl_device_dump_firmware (FuDevice *device, GError **error)
{
	FuHailuckBlDevice *self = FU_HAILUCK_BL_DEVICE (device);
	gsize fwsz = fu_device_get_firmware_size_max (device);
	g_autoptr(GByteArray) fwbuf = g_byte_array_new ();
	g_autoptr(GPtrArray) chunks = NULL;

	/* tell device amount of data to send */
	fu_device_set_status (FU_DEVICE (self), FWUPD_STATUS_DEVICE_READ);
	if (!fu_hailuck_bl_device_read_block_start (self, fwsz, error))
		return NULL;

	/* receive data back */
	fu_byte_array_set_size (fwbuf, fwsz);
	chunks = fu_chunk_array_mutable_new (fwbuf->data, fwbuf->len, 0x0, 0x0, 2048);
	for (guint i = 0; i < chunks->len; i++) {
		FuChunk *chk = g_ptr_array_index (chunks, i);
		if (!fu_hailuck_bl_device_read_block (self,
						      fu_chunk_get_data_out (chk),
						      fu_chunk_get_data_sz (chk),
						      error))
			return NULL;
		fu_device_set_progress_full (device, i, chunks->len - 1);
	}

	/* success */
	return g_byte_array_free_to_bytes (g_steal_pointer (&fwbuf));
}

static gboolean
fu_hailuck_bl_device_erase (FuHailuckBlDevice *self, GError **error)
{
	guint8 buf[6] = {
		FU_HAILUCK_REPORT_ID_SHORT,
		FU_HAILUCK_CMD_ERASE,
	};
	if (!fu_hid_device_set_report (FU_HID_DEVICE (self), buf[0],
				       buf, sizeof(buf), 100,
				       FU_HID_DEVICE_FLAG_IS_FEATURE, error))
		return FALSE;
	fu_device_sleep_with_progress (FU_DEVICE (self), 2);
	return TRUE;
}

static gboolean
fu_hailuck_bl_device_write_block_start (FuHailuckBlDevice *self,
					 guint32 length, GError **error)
{
	guint8 buf[6] = {
		FU_HAILUCK_REPORT_ID_SHORT,
		FU_HAILUCK_CMD_WRITE_BLOCK_START,
	};
	fu_common_write_uint16 (buf + 4, length, G_LITTLE_ENDIAN);
	return fu_hid_device_set_report (FU_HID_DEVICE (self), buf[0],
					 buf, sizeof(buf), 100,
					 FU_HID_DEVICE_FLAG_IS_FEATURE, error);
}

static gboolean
fu_hailuck_bl_device_write_block (FuHailuckBlDevice *self,
				   const guint8 *data, gsize data_sz,
				   GError **error)
{
	gsize bufsz = data_sz + 2;
	g_autofree guint8 *buf = g_malloc0 (bufsz);

	buf[0] = FU_HAILUCK_REPORT_ID_LONG;
	buf[1] = FU_HAILUCK_CMD_WRITE_BLOCK;
	if (!fu_memcpy_safe (buf, bufsz, 0x02,		/* dst */
			     data, data_sz, 0x0,	/* src */
			     data_sz, error))
		return FALSE;
	if (!fu_hid_device_set_report (FU_HID_DEVICE (self), buf[0],
				       buf, bufsz, 2000,
				       FU_HID_DEVICE_FLAG_IS_FEATURE,
				       error))
		return FALSE;

	/* success */
	g_usleep (10000);
	return TRUE;
}

static FuFirmware *
fu_hailuck_bl_device_prepare_firmware (FuDevice *device,
				     GBytes *fw,
				     FwupdInstallFlags flags,
				     GError **error)
{
	g_autoptr(FuFirmware) firmware = fu_hailuck_kbd_firmware_new ();
	if (!fu_firmware_parse (firmware, fw, flags, error))
		return NULL;
	return g_steal_pointer (&firmware);
}

static gboolean
fu_hailuck_bl_device_write_firmware (FuDevice *device,
				      FuFirmware *firmware,
				      FwupdInstallFlags flags,
				      GError **error)
{
	FuHailuckBlDevice *self = FU_HAILUCK_BL_DEVICE (device);
	FuChunk *chk0;
	g_autoptr(GBytes) fw = NULL;
	g_autoptr(GBytes) fw_new = NULL;
	g_autoptr(GPtrArray) chunks = NULL;
	g_autofree guint8 *chk0_data = NULL;

	/* get default image */
	fw = fu_firmware_get_bytes (firmware, error);
	if (fw == NULL)
		return FALSE;

	/* erase all contents */
	fu_device_set_status (device, FWUPD_STATUS_DEVICE_ERASE);
	if (!fu_hailuck_bl_device_erase (self, error))
		return FALSE;

	/* tell device amount of data to expect */
	fu_device_set_status (device, FWUPD_STATUS_DEVICE_WRITE);
	if (!fu_hailuck_bl_device_write_block_start (self, g_bytes_get_size (fw), error))
		return FALSE;

	/* build packets */
	chunks = fu_chunk_array_new_from_bytes (fw, 0x0, 0x00, 2048);

	/* intentionally corrupt first chunk so that CRC fails */
	chk0 = g_ptr_array_index (chunks, 0);
	chk0_data = fu_memdup_safe (fu_chunk_get_data (chk0),
				    fu_chunk_get_data_sz (chk0),
				    error);
	if (chk0_data == NULL)
		return FALSE;
	chk0_data[0] = 0x00;
	if (!fu_hailuck_bl_device_write_block (self,
					       chk0_data,
					       fu_chunk_get_data_sz (chk0),
					       error))
		return FALSE;

	/* send the rest of the chunks */
	for (guint i = 1; i < chunks->len; i++) {
		FuChunk *chk = g_ptr_array_index (chunks, i);
		if (!fu_hailuck_bl_device_write_block (self,
						       fu_chunk_get_data (chk),
						       fu_chunk_get_data_sz (chk),
						       error))
			return FALSE;
		fu_device_set_progress_full (device, i, chunks->len);
	}

	/* retry write of first block */
	if (!fu_hailuck_bl_device_write_block_start (self, g_bytes_get_size (fw), error))
		return FALSE;
	if (!fu_hailuck_bl_device_write_block (self,
					       fu_chunk_get_data (chk0),
					       fu_chunk_get_data_sz (chk0),
					       error))
		return FALSE;
	fu_device_set_progress_full (device, chunks->len, chunks->len);

	/* verify */
	fw_new = fu_hailuck_bl_device_dump_firmware (device, error);
	return fu_common_bytes_compare (fw, fw_new, error);
}

static void
fu_hailuck_bl_device_init (FuHailuckBlDevice *self)
{
	fu_device_set_firmware_size (FU_DEVICE (self), 0x4000);
	fu_device_add_protocol (FU_DEVICE (self), "com.hailuck.kbd");
	fu_device_set_name (FU_DEVICE (self), "Keyboard [bootloader]");
	fu_device_add_flag (FU_DEVICE (self), FWUPD_DEVICE_FLAG_IS_BOOTLOADER);
	fu_device_add_flag (FU_DEVICE (self), FWUPD_DEVICE_FLAG_INTERNAL);
	fu_device_add_flag (FU_DEVICE (self), FWUPD_DEVICE_FLAG_UPDATABLE);
	fu_device_add_internal_flag (FU_DEVICE (self), FU_DEVICE_INTERNAL_FLAG_REPLUG_MATCH_GUID);
	fu_device_add_icon (FU_DEVICE (self), "input-keyboard");
	fu_hid_device_add_flag (FU_HID_DEVICE (self), FU_HID_DEVICE_FLAG_NO_KERNEL_REBIND);
	fu_device_set_remove_delay (FU_DEVICE (self),
				    FU_DEVICE_REMOVE_DELAY_RE_ENUMERATE);
}

static void
fu_hailuck_bl_device_class_init (FuHailuckBlDeviceClass *klass)
{
	FuDeviceClass *klass_device = FU_DEVICE_CLASS (klass);
	klass_device->dump_firmware = fu_hailuck_bl_device_dump_firmware;
	klass_device->prepare_firmware = fu_hailuck_bl_device_prepare_firmware;
	klass_device->write_firmware = fu_hailuck_bl_device_write_firmware;
	klass_device->attach = fu_hailuck_bl_device_attach;
	klass_device->probe = fu_hailuck_bl_device_probe;
}