fwupd/plugins/thunderbolt/fu-thunderbolt-firmware.c

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

#include "config.h"

#include <fwupdplugin.h>

#include "fu-thunderbolt-firmware.h"

typedef struct {
	guint32 sections[_SECTION_LAST];
	FuThunderboltFamily family;
	gboolean is_host;
	gboolean is_native;
	gboolean has_pd;
	guint16 device_id;
	guint16 vendor_id;
	guint16 model_id;
	guint gen;
	guint ports;
	guint8 flash_size;
} FuThunderboltFirmwarePrivate;

G_DEFINE_TYPE_WITH_PRIVATE(FuThunderboltFirmware, fu_thunderbolt_firmware, FU_TYPE_FIRMWARE)

#define GET_PRIVATE(o) (fu_thunderbolt_firmware_get_instance_private(o))

typedef struct {
	guint16 id;
	guint gen;
	FuThunderboltFamily family;
	guint ports;
} FuThunderboltHwInfo;

enum {
	DROM_ENTRY_MC = 0x6,
};

gboolean
fu_thunderbolt_firmware_is_host(FuThunderboltFirmware *self)
{
	FuThunderboltFirmwarePrivate *priv;
	g_return_val_if_fail(FU_IS_THUNDERBOLT_FIRMWARE(self), FALSE);
	priv = GET_PRIVATE(self);
	return priv->is_host;
}

gboolean
fu_thunderbolt_firmware_is_native(FuThunderboltFirmware *self)
{
	FuThunderboltFirmwarePrivate *priv;
	g_return_val_if_fail(FU_IS_THUNDERBOLT_FIRMWARE(self), FALSE);
	priv = GET_PRIVATE(self);
	return priv->is_native;
}

gboolean
fu_thunderbolt_firmware_get_has_pd(FuThunderboltFirmware *self)
{
	FuThunderboltFirmwarePrivate *priv;
	g_return_val_if_fail(FU_IS_THUNDERBOLT_FIRMWARE(self), FALSE);
	priv = GET_PRIVATE(self);
	return priv->has_pd;
}

guint16
fu_thunderbolt_firmware_get_device_id(FuThunderboltFirmware *self)
{
	FuThunderboltFirmwarePrivate *priv;
	g_return_val_if_fail(FU_IS_THUNDERBOLT_FIRMWARE(self), 0x0);
	priv = GET_PRIVATE(self);
	return priv->device_id;
}

guint16
fu_thunderbolt_firmware_get_vendor_id(FuThunderboltFirmware *self)
{
	FuThunderboltFirmwarePrivate *priv;
	g_return_val_if_fail(FU_IS_THUNDERBOLT_FIRMWARE(self), 0x0);
	priv = GET_PRIVATE(self);
	return priv->vendor_id;
}

guint16
fu_thunderbolt_firmware_get_model_id(FuThunderboltFirmware *self)
{
	FuThunderboltFirmwarePrivate *priv;
	g_return_val_if_fail(FU_IS_THUNDERBOLT_FIRMWARE(self), 0x0);
	priv = GET_PRIVATE(self);
	return priv->model_id;
}

guint8
fu_thunderbolt_firmware_get_flash_size(FuThunderboltFirmware *self)
{
	FuThunderboltFirmwarePrivate *priv;
	g_return_val_if_fail(FU_IS_THUNDERBOLT_FIRMWARE(self), 0x0);
	priv = GET_PRIVATE(self);
	return priv->flash_size;
}

static const gchar *
fu_thunderbolt_firmware_family_to_string(FuThunderboltFamily family)
{
	if (family == _FAMILY_FR)
		return "Falcon Ridge";
	if (family == _FAMILY_WR)
		return "Win Ridge";
	if (family == _FAMILY_AR)
		return "Alpine Ridge";
	if (family == _FAMILY_AR_C)
		return "Alpine Ridge C";
	if (family == _FAMILY_TR)
		return "Titan Ridge";
	if (family == _FAMILY_BB)
		return "BB";
	if (family == _FAMILY_MR)
		return "Maple Ridge";
	return "Unknown";
}

static void
fu_thunderbolt_firmware_export(FuFirmware *firmware, FuFirmwareExportFlags flags, XbBuilderNode *bn)
{
	FuThunderboltFirmware *self = FU_THUNDERBOLT_FIRMWARE(firmware);
	FuThunderboltFirmwarePrivate *priv = GET_PRIVATE(self);

	fu_xmlb_builder_insert_kv(bn,
				  "family",
				  fu_thunderbolt_firmware_family_to_string(priv->family));
	fu_xmlb_builder_insert_kb(bn, "is_host", priv->is_host);
	fu_xmlb_builder_insert_kb(bn, "is_native", priv->is_native);
	fu_xmlb_builder_insert_kx(bn, "device_id", priv->device_id);
	fu_xmlb_builder_insert_kx(bn, "vendor_id", priv->vendor_id);
	fu_xmlb_builder_insert_kx(bn, "model_id", priv->model_id);
	fu_xmlb_builder_insert_kx(bn, "flash_size", priv->flash_size);
	fu_xmlb_builder_insert_kx(bn, "generation", priv->gen);
	fu_xmlb_builder_insert_kx(bn, "ports", priv->ports);
	fu_xmlb_builder_insert_kb(bn, "has_pd", priv->has_pd);
	for (guint i = 0; i < _SECTION_LAST; i++) {
		g_autofree gchar *tmp = g_strdup_printf("%x", priv->sections[i]);
		xb_builder_node_insert_text(bn, "section", tmp, NULL);
	}
}

static inline gboolean
fu_thunderbolt_firmware_valid_pd_pointer(guint32 pointer)
{
	return pointer != 0 && pointer != 0xFFFFFFFF;
}

gboolean
fu_thunderbolt_firmware_read_location(FuThunderboltFirmware *self,
				      FuThunderboltSection section,
				      guint32 offset,
				      guint8 *buf,
				      guint32 len,
				      GError **error)
{
	const guint8 *srcbuf;
	gsize srcbufsz = 0;
	FuThunderboltFirmwarePrivate *priv = GET_PRIVATE(self);
	guint32 location_start = priv->sections[section] + offset;
	g_autoptr(GBytes) fw = NULL;

	/* get blob */
	fw = fu_firmware_get_bytes(FU_FIRMWARE(self), error);
	if (fw == NULL)
		return FALSE;
	srcbuf = g_bytes_get_data(fw, &srcbufsz);

	if (!fu_memcpy_safe(buf,
			    len,
			    0x0, /* dst */
			    srcbuf,
			    srcbufsz,
			    location_start, /* src */
			    len,
			    error)) {
		g_prefix_error(error, "location is outside of the given image: ");
		return FALSE;
	}
	return TRUE;
}

static gboolean
fu_thunderbolt_firmware_read_uint8(FuThunderboltFirmware *self,
				   FuThunderboltSection section,
				   guint32 offset,
				   guint8 *value,
				   GError **error)
{
	return fu_thunderbolt_firmware_read_location(self, section, offset, value, 1, error);
}

static gboolean
fu_thunderbolt_firmware_read_uint16(FuThunderboltFirmware *self,
				    FuThunderboltSection section,
				    guint32 offset,
				    guint16 *value,
				    GError **error)
{
	guint16 tmp = 0;
	if (!fu_thunderbolt_firmware_read_location(self,
						   section,
						   offset,
						   (guint8 *)&tmp,
						   sizeof(tmp),
						   error)) {
		g_prefix_error(error, "failed to read uint16: ");
		return FALSE;
	}
	*value = GUINT16_FROM_LE(tmp);
	return TRUE;
}

static gboolean
fu_thunderbolt_firmware_read_uint32(FuThunderboltFirmware *self,
				    FuThunderboltSection section,
				    guint32 offset,
				    guint32 *value,
				    GError **error)
{
	guint32 tmp = 0;
	if (!fu_thunderbolt_firmware_read_location(self,
						   section,
						   offset,
						   (guint8 *)&tmp,
						   sizeof(tmp),
						   error)) {
		g_prefix_error(error, "failed to read uint32: ");
		return FALSE;
	}
	*value = GUINT32_FROM_LE(tmp);
	return TRUE;
}

/*
 * Size of ucode sections is uint16 value saved at the start of the section,
 * it's in DWORDS (4-bytes) units and it doesn't include itself. We need the
 * offset to the next section, so we translate it to bytes and add 2 for the
 * size field itself.
 *
 * offset parameter must be relative to digital section
 */
static gboolean
fu_thunderbolt_firmware_read_ucode_section_len(FuThunderboltFirmware *self,
					       guint32 offset,
					       guint16 *value,
					       GError **error)
{
	if (!fu_thunderbolt_firmware_read_uint16(self, _SECTION_DIGITAL, offset, value, error)) {
		g_prefix_error(error, "failed to read ucode section len: ");
		return FALSE;
	}
	*value *= sizeof(guint32);
	*value += sizeof(guint16);
	return TRUE;
}

/* assumes sections[_SECTION_DIGITAL].offset is already set */
static gboolean
fu_thunderbolt_firmware_read_sections(FuThunderboltFirmware *self, GError **error)
{
	guint32 offset;
	FuThunderboltFirmwarePrivate *priv = GET_PRIVATE(self);

	if (priv->gen >= 3 || priv->gen == 0) {
		if (!fu_thunderbolt_firmware_read_uint32(self,
							 _SECTION_DIGITAL,
							 0x10e,
							 &offset,
							 error))
			return FALSE;
		priv->sections[_SECTION_DROM] = offset + priv->sections[_SECTION_DIGITAL];

		if (!fu_thunderbolt_firmware_read_uint32(self,
							 _SECTION_DIGITAL,
							 0x75,
							 &offset,
							 error))
			return FALSE;
		priv->sections[_SECTION_ARC_PARAMS] = offset + priv->sections[_SECTION_DIGITAL];
	}

	if (priv->is_host && priv->gen > 2) {
		/*
		 * To find the DRAM section, we have to jump from section to
		 * section in a chain of sections.
		 * available_sections location tells what sections exist at all
		 * (with a flag per section).
		 * ee_ucode_start_addr location tells the offset of the first
		 * section in the list relatively to the digital section start.
		 * After having the offset of the first section, we have a loop
		 * over the section list. If the section exists, we read its
		 * length (2 bytes at section start) and add it to current
		 * offset to find the start of the next section. Otherwise, we
		 * already have the next section offset...
		 */
		const guint8 DRAM_FLAG = 1 << 6;
		guint16 ucode_offset;
		guint8 available_sections = 0;

		if (!fu_thunderbolt_firmware_read_uint8(self,
							_SECTION_DIGITAL,
							0x2,
							&available_sections,
							error)) {
			g_prefix_error(error, "failed to read available sections: ");
			return FALSE;
		}
		if (!fu_thunderbolt_firmware_read_uint16(self,
							 _SECTION_DIGITAL,
							 0x3,
							 &ucode_offset,
							 error)) {
			g_prefix_error(error, "failed to read ucode offset: ");
			return FALSE;
		}
		offset = ucode_offset;
		if ((available_sections & DRAM_FLAG) == 0) {
			g_set_error_literal(error,
					    FWUPD_ERROR,
					    FWUPD_ERROR_INVALID_FILE,
					    "Can't find needed FW sections in the FW image file");
			return FALSE;
		}

		for (guint8 i = 1; i < DRAM_FLAG; i <<= 1) {
			if (available_sections & i) {
				if (!fu_thunderbolt_firmware_read_ucode_section_len(self,
										    offset,
										    &ucode_offset,
										    error))
					return FALSE;
				offset += ucode_offset;
			}
		}
		priv->sections[_SECTION_DRAM_UCODE] = offset + priv->sections[_SECTION_DIGITAL];
	}

	return TRUE;
}

static gboolean
fu_thunderbolt_firmware_missing_needed_drom(FuThunderboltFirmware *self)
{
	FuThunderboltFirmwarePrivate *priv = GET_PRIVATE(self);
	if (priv->sections[_SECTION_DROM] != 0)
		return FALSE;
	if (priv->is_host && priv->gen < 3)
		return FALSE;
	return TRUE;
}

void
fu_thunderbolt_firmware_set_digital(FuThunderboltFirmware *self, guint32 offset)
{
	FuThunderboltFirmwarePrivate *priv = GET_PRIVATE(self);
	priv->sections[_SECTION_DIGITAL] = offset;
}

static gboolean
fu_thunderbolt_firmware_parse(FuFirmware *firmware,
			      GBytes *fw,
			      guint64 addr_start,
			      guint64 addr_end,
			      FwupdInstallFlags flags,
			      GError **error)
{
	FuThunderboltFirmware *self = FU_THUNDERBOLT_FIRMWARE(firmware);
	FuThunderboltFirmwarePrivate *priv = GET_PRIVATE(self);
	FuThunderboltFirmwareClass *klass_firmware = FU_THUNDERBOLT_FIRMWARE_GET_CLASS(firmware);

	guint8 tmp = 0;
	guint16 version = 0;
	static const FuThunderboltHwInfo hw_info_arr[] = {
	    {0x156D, 2, _FAMILY_FR, 2},	  /* FR 4C */
	    {0x156B, 2, _FAMILY_FR, 1},	  /* FR 2C */
	    {0x157E, 2, _FAMILY_WR, 1},	  /* WR */
	    {0x1578, 3, _FAMILY_AR, 2},	  /* AR 4C */
	    {0x1576, 3, _FAMILY_AR, 1},	  /* AR 2C */
	    {0x15C0, 3, _FAMILY_AR, 1},	  /* AR LP */
	    {0x15D3, 3, _FAMILY_AR_C, 2}, /* AR-C 4C */
	    {0x15DA, 3, _FAMILY_AR_C, 1}, /* AR-C 2C */
	    {0x15E7, 3, _FAMILY_TR, 1},	  /* TR 2C */
	    {0x15EA, 3, _FAMILY_TR, 2},	  /* TR 4C */
	    {0x15EF, 3, _FAMILY_TR, 2},	  /* TR 4C device */
	    {0x15EE, 3, _FAMILY_BB, 0},	  /* BB device */
	    /* Maple ridge devices
	     * NOTE: These are expected to be flashed via UEFI capsules *not* Thunderbolt plugin
	     * Flashing via fwupd will require matching kernel work.
	     * They're left here only for parsing the binaries
	     */
	    {0x1136, 4, _FAMILY_MR, 2},
	    {0x1137, 4, _FAMILY_MR, 2},
	    {0}};
	g_autofree gchar *version_str = NULL;

	/* add this straight away so we can read it without a self */
	fu_firmware_set_bytes(firmware, fw);

	/* subclassed */
	if (klass_firmware->parse != NULL) {
		if (!klass_firmware->parse(firmware, fw, addr_start, addr_end, flags, error))
			return FALSE;
	}

	/* is native */
	if (!fu_thunderbolt_firmware_read_uint8(self,
						_SECTION_DIGITAL,
						FU_TBT_OFFSET_NATIVE,
						&tmp,
						error)) {
		g_prefix_error(error, "failed to read native: ");
		return FALSE;
	}
	priv->is_native = tmp & 0x20;

	/* we're only reading the first chunk */
	if (g_bytes_get_size(fw) == 0x80)
		return TRUE;

	/* host or device */
	if (!fu_thunderbolt_firmware_read_uint8(self, _SECTION_DIGITAL, 0x10, &tmp, error)) {
		g_prefix_error(error, "failed to read is-host: ");
		return FALSE;
	}
	priv->is_host = tmp & (1 << 1);

	/* device ID */
	if (!fu_thunderbolt_firmware_read_uint16(self,
						 _SECTION_DIGITAL,
						 0x5,
						 &priv->device_id,
						 error)) {
		g_prefix_error(error, "failed to read device-id: ");
		return FALSE;
	}

	/* this is best-effort */
	for (guint i = 0; hw_info_arr[i].id != 0; i++) {
		if (hw_info_arr[i].id == priv->device_id) {
			priv->family = hw_info_arr[i].family;
			priv->gen = hw_info_arr[i].gen;
			priv->ports = hw_info_arr[i].ports;
			break;
		}
	}
	if (priv->ports == 0 && priv->is_host) {
		g_set_error(error,
			    FWUPD_ERROR,
			    FWUPD_ERROR_NOT_SUPPORTED,
			    "Unknown controller: %x",
			    priv->device_id);
		return FALSE;
	}

	/* read sections from file */
	if (!fu_thunderbolt_firmware_read_sections(self, error))
		return FALSE;
	if (fu_thunderbolt_firmware_missing_needed_drom(self)) {
		g_set_error_literal(error,
				    FWUPD_ERROR,
				    FWUPD_ERROR_READ,
				    "Can't find required FW sections");
		return FALSE;
	}

	/* vendor:model */
	if (priv->sections[_SECTION_DROM] != 0) {
		if (!fu_thunderbolt_firmware_read_uint16(self,
							 _SECTION_DROM,
							 0x10,
							 &priv->vendor_id,
							 error)) {
			g_prefix_error(error, "failed to read vendor-id: ");
			return FALSE;
		}
		if (!fu_thunderbolt_firmware_read_uint16(self,
							 _SECTION_DROM,
							 0x12,
							 &priv->model_id,
							 error)) {
			g_prefix_error(error, "failed to read model-id: ");
			return FALSE;
		}
	}

	/* has PD */
	if (priv->sections[_SECTION_ARC_PARAMS] != 0) {
		guint32 pd_pointer = 0x0;
		if (!fu_thunderbolt_firmware_read_uint32(self,
							 _SECTION_ARC_PARAMS,
							 0x10C,
							 &pd_pointer,
							 error)) {
			g_prefix_error(error, "failed to read pd-pointer: ");
			return FALSE;
		}
		priv->has_pd = fu_thunderbolt_firmware_valid_pd_pointer(pd_pointer);
	}

	/* versions */
	switch (priv->family) {
	case _FAMILY_TR:
		if (!fu_thunderbolt_firmware_read_uint16(self,
							 _SECTION_DIGITAL,
							 0x09,
							 &version,
							 error)) {
			g_prefix_error(error, "failed to read version: ");
			return FALSE;
		}
		version_str = fu_common_version_from_uint16(version, FWUPD_VERSION_FORMAT_BCD);
		fu_firmware_set_version(FU_FIRMWARE(self), version_str);
		break;
	default:
		break;
	}

	if (priv->is_host) {
		switch (priv->family) {
		case _FAMILY_AR:
		case _FAMILY_AR_C:
		case _FAMILY_TR:
			/* This is used for comparison between old and new image, not a raw number
			 */
			if (!fu_thunderbolt_firmware_read_uint8(self,
								_SECTION_DIGITAL,
								0x45,
								&tmp,
								error)) {
				g_prefix_error(error, "failed to read flash size: ");
				return FALSE;
			}
			priv->flash_size = tmp & 0x07;
			break;
		default:
			break;
		}
	}

	/* success */
	return TRUE;
}

static void
fu_thunderbolt_firmware_init(FuThunderboltFirmware *self)
{
	fu_firmware_add_flag(FU_FIRMWARE(self), FU_FIRMWARE_FLAG_HAS_VID_PID);
}

static void
fu_thunderbolt_firmware_class_init(FuThunderboltFirmwareClass *klass)
{
	FuFirmwareClass *klass_firmware = FU_FIRMWARE_CLASS(klass);
	klass_firmware->parse = fu_thunderbolt_firmware_parse;
	klass_firmware->export = fu_thunderbolt_firmware_export;
}

FuThunderboltFirmware *
fu_thunderbolt_firmware_new(void)
{
	return g_object_new(FU_TYPE_THUNDERBOLT_FIRMWARE, NULL);
}