/src/fwupd/plugins/synaptics-mst/fu-synaptics-mst-firmware.c

Source
/*
 * Copyright 2021 Richard Hughes <richard@hughsie.com>
 *
 * SPDX-License-Identifier: LGPL-2.1-or-later
 */

#include "config.h"

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

struct _FuSynapticsMstFirmware {
  FuFirmware parent_instance;
  guint16 board_id;
  FuSynapticsMstFamily family;
};

G_DEFINE_TYPE(FuSynapticsMstFirmware, fu_synaptics_mst_firmware, FU_TYPE_FIRMWARE)

#define ADDR_CUSTOMER_ID_CARRERA 0x620E
#define ADDR_CUSTOMER_ID_CAYENNE 0x20E
#define ADDR_CUSTOMER_ID_TESLA   0x10E
#define ADDR_CONFIG_CARRERA  0x6200
#define ADDR_CONFIG_CAYENNE  0x200
#define ADDR_CONFIG_TESLA  0x100

guint16
fu_synaptics_mst_firmware_get_board_id(FuSynapticsMstFirmware *self)
{
  g_return_val_if_fail(FU_IS_SYNAPTICS_MST_FIRMWARE(self), 0);
  return self->board_id;
}

void
fu_synaptics_mst_firmware_set_family(FuSynapticsMstFirmware *self, FuSynapticsMstFamily family)
{
  g_return_if_fail(FU_IS_SYNAPTICS_MST_FIRMWARE(self));
  self->family = family;
}

static void
fu_synaptics_mst_firmware_export(FuFirmware *firmware,
         FuFirmwareExportFlags flags,
         XbBuilderNode *bn)
{
  FuSynapticsMstFirmware *self = FU_SYNAPTICS_MST_FIRMWARE(firmware);
  fu_xmlb_builder_insert_kx(bn, "board_id", self->board_id);
  fu_xmlb_builder_insert_kv(bn, "family", fu_synaptics_mst_family_to_string(self->family));
}

static gboolean
fu_synaptics_mst_firmware_detect_family(FuSynapticsMstFirmware *self,
          GInputStream *stream,
          gsize offset,
          GError **error)
{
  guint16 addrs[] = {ADDR_CONFIG_TESLA, ADDR_CONFIG_CAYENNE, ADDR_CONFIG_CARRERA};
  for (guint i = 0; i < G_N_ELEMENTS(addrs); i++) {
    g_autoptr(FuStructSynapticsFirmwareConfig) st = NULL;
    st = fu_struct_synaptics_firmware_config_parse_stream(stream,
                      offset + addrs[i],
                      error);
    if (st == NULL)
      return FALSE;
    if ((fu_struct_synaptics_firmware_config_get_magic1(st) & 0x80) &&
        (fu_struct_synaptics_firmware_config_get_magic2(st) & 0x80)) {
      self->family = fu_struct_synaptics_firmware_config_get_version(st) >> 4;
      return TRUE;
    }
  }
  g_set_error_literal(error,
          FWUPD_ERROR,
          FWUPD_ERROR_NOT_SUPPORTED,
          "unable to autodetect chip family");
  return FALSE;
}

static gboolean
fu_synaptics_mst_firmware_parse(FuFirmware *firmware,
        GInputStream *stream,
        FuFirmwareParseFlags flags,
        GError **error)
{
  FuSynapticsMstFirmware *self = FU_SYNAPTICS_MST_FIRMWARE(firmware);
  guint16 addr;

  /* if device family not specified by caller, try to get from firmware file */
  if (self->family == FU_SYNAPTICS_MST_FAMILY_UNKNOWN) {
    if (!fu_synaptics_mst_firmware_detect_family(self, stream, 0x0, error))
      return FALSE;
  }

  switch (self->family) {
  case FU_SYNAPTICS_MST_FAMILY_TESLA:
  case FU_SYNAPTICS_MST_FAMILY_LEAF:
  case FU_SYNAPTICS_MST_FAMILY_PANAMERA:
    addr = ADDR_CUSTOMER_ID_TESLA;
    break;
  case FU_SYNAPTICS_MST_FAMILY_CAYENNE:
  case FU_SYNAPTICS_MST_FAMILY_SPYDER:
    addr = ADDR_CUSTOMER_ID_CAYENNE;
    break;
  case FU_SYNAPTICS_MST_FAMILY_CARRERA:
    addr = ADDR_CUSTOMER_ID_CARRERA;
    break;
  default:
    g_set_error(error,
          FWUPD_ERROR,
          FWUPD_ERROR_NOT_SUPPORTED,
          "unsupported chip family %s",
          fu_synaptics_mst_family_to_string(self->family));
    return FALSE;
  }
  if (!fu_input_stream_read_u16(stream, addr, &self->board_id, G_BIG_ENDIAN, error))
    return FALSE;

  /* success */
  return TRUE;
}

static GByteArray *
fu_synaptics_mst_firmware_write(FuFirmware *firmware, GError **error)
{
  FuSynapticsMstFirmware *self = FU_SYNAPTICS_MST_FIRMWARE(firmware);
  g_autoptr(GByteArray) buf = g_byte_array_new();
  g_autoptr(GBytes) blob = NULL;
  guint16 addr;

  switch (self->family) {
  case FU_SYNAPTICS_MST_FAMILY_TESLA:
  case FU_SYNAPTICS_MST_FAMILY_LEAF:
  case FU_SYNAPTICS_MST_FAMILY_PANAMERA:
    addr = ADDR_CUSTOMER_ID_TESLA;
    break;
  case FU_SYNAPTICS_MST_FAMILY_CAYENNE:
  case FU_SYNAPTICS_MST_FAMILY_SPYDER:
    addr = ADDR_CUSTOMER_ID_CAYENNE;
    break;
  case FU_SYNAPTICS_MST_FAMILY_CARRERA:
    addr = ADDR_CUSTOMER_ID_CARRERA;
    break;
  default:
    g_set_error_literal(error,
            FWUPD_ERROR,
            FWUPD_ERROR_NOT_SUPPORTED,
            "unsupported chip family");
    return NULL;
  }
  /* assumed header */
  fu_byte_array_set_size(buf, addr + sizeof(guint16), 0x00);
  if (!fu_memwrite_uint16_safe(buf->data,
             buf->len,
             addr,
             fu_firmware_get_idx(firmware),
             G_BIG_ENDIAN,
             error))
    return NULL;

  /* payload */
  blob = fu_firmware_get_bytes_with_patches(firmware, error);
  if (blob == NULL)
    return NULL;
  fu_byte_array_append_bytes(buf, blob);

  /* success */
  return g_steal_pointer(&buf);
}

static gboolean
fu_synaptics_mst_firmware_build(FuFirmware *firmware, XbNode *n, GError **error)
{
  FuSynapticsMstFirmware *self = FU_SYNAPTICS_MST_FIRMWARE(firmware);
  guint64 tmp;

  /* optional properties */
  tmp = xb_node_query_text_as_uint(n, "board_id", NULL);
  if (tmp != G_MAXUINT64)
    self->board_id = tmp;
  tmp = xb_node_query_text_as_uint(n, "family", NULL);
  if (tmp != G_MAXUINT64)
    self->family = tmp;

  /* success */
  return TRUE;
}

static void
fu_synaptics_mst_firmware_init(FuSynapticsMstFirmware *self)
{
  self->family = FU_SYNAPTICS_MST_FAMILY_UNKNOWN;
  fu_firmware_add_flag(FU_FIRMWARE(self), FU_FIRMWARE_FLAG_NO_AUTO_DETECTION);
}

static void
fu_synaptics_mst_firmware_class_init(FuSynapticsMstFirmwareClass *klass)
{
  FuFirmwareClass *firmware_class = FU_FIRMWARE_CLASS(klass);
  firmware_class->parse = fu_synaptics_mst_firmware_parse;
  firmware_class->export = fu_synaptics_mst_firmware_export;
  firmware_class->write = fu_synaptics_mst_firmware_write;
  firmware_class->build = fu_synaptics_mst_firmware_build;
}

FuFirmware *
fu_synaptics_mst_firmware_new(void)
{
  return FU_FIRMWARE(g_object_new(FU_TYPE_SYNAPTICS_MST_FIRMWARE, NULL));
}

Coverage Report

Created: 2026-01-17 07:04

Line	Count	Source
1		/*
2		* Copyright 2021 Richard Hughes <richard@hughsie.com>
3		*
4		* SPDX-License-Identifier: LGPL-2.1-or-later
5		*/
6
7		#include "config.h"
8
9		#include "fu-synaptics-mst-common.h"
10		#include "fu-synaptics-mst-firmware.h"
11
12		struct _FuSynapticsMstFirmware {
13		FuFirmware parent_instance;
14		guint16 board_id;
15		FuSynapticsMstFamily family;
16		};
17
18	344	G_DEFINE_TYPE(FuSynapticsMstFirmware, fu_synaptics_mst_firmware, FU_TYPE_FIRMWARE)
19	344
20	344	#define ADDR_CUSTOMER_ID_CARRERA 0x620E
21	14	#define ADDR_CUSTOMER_ID_CAYENNE 0x20E
22	36	#define ADDR_CUSTOMER_ID_TESLA 0x10E
23	156	#define ADDR_CONFIG_CARRERA 0x6200
24	156	#define ADDR_CONFIG_CAYENNE 0x200
25	156	#define ADDR_CONFIG_TESLA 0x100
26
27		guint16
28		fu_synaptics_mst_firmware_get_board_id(FuSynapticsMstFirmware *self)
29	0	{
30	0	g_return_val_if_fail(FU_IS_SYNAPTICS_MST_FIRMWARE(self), 0);
31	0	return self->board_id;
32	0	}
33
34		void
35		fu_synaptics_mst_firmware_set_family(FuSynapticsMstFirmware *self, FuSynapticsMstFamily family)
36	0	{
37	0	g_return_if_fail(FU_IS_SYNAPTICS_MST_FIRMWARE(self));
38	0	self->family = family;
39	0	}
40
41		static void
42		fu_synaptics_mst_firmware_export(FuFirmware *firmware,
43		FuFirmwareExportFlags flags,
44		XbBuilderNode *bn)
45	0	{
46	0	FuSynapticsMstFirmware *self = FU_SYNAPTICS_MST_FIRMWARE(firmware);
47	0	fu_xmlb_builder_insert_kx(bn, "board_id", self->board_id);
48	0	fu_xmlb_builder_insert_kv(bn, "family", fu_synaptics_mst_family_to_string(self->family));
49	0	}
50
51		static gboolean
52		fu_synaptics_mst_firmware_detect_family(FuSynapticsMstFirmware *self,
53		GInputStream *stream,
54		gsize offset,
55		GError **error)
56	156	{
57	156	guint16 addrs[] = {ADDR_CONFIG_TESLA, ADDR_CONFIG_CAYENNE, ADDR_CONFIG_CARRERA};
58	296	for (guint i = 0; i < G_N_ELEMENTS(addrs); i++) {
59	278	g_autoptr(FuStructSynapticsFirmwareConfig) st = NULL;
60	278	st = fu_struct_synaptics_firmware_config_parse_stream(stream,
61	278	offset + addrs[i],
62	278	error);
63	278	if (st == NULL)
64	71	return FALSE;
65	207	if ((fu_struct_synaptics_firmware_config_get_magic1(st) & 0x80) &&
66	95	(fu_struct_synaptics_firmware_config_get_magic2(st) & 0x80)) {
67	67	self->family = fu_struct_synaptics_firmware_config_get_version(st) >> 4;
68	67	return TRUE;
69	67	}
70	207	}
71	18	g_set_error_literal(error,
72	18	FWUPD_ERROR,
73	18	FWUPD_ERROR_NOT_SUPPORTED,
74	18	"unable to autodetect chip family");
75	18	return FALSE;
76	156	}
77
78		static gboolean
79		fu_synaptics_mst_firmware_parse(FuFirmware *firmware,
80		GInputStream *stream,
81		FuFirmwareParseFlags flags,
82		GError **error)
83	156	{
84	156	FuSynapticsMstFirmware *self = FU_SYNAPTICS_MST_FIRMWARE(firmware);
85	156	guint16 addr;
86
87		/* if device family not specified by caller, try to get from firmware file */
88	156	if (self->family == FU_SYNAPTICS_MST_FAMILY_UNKNOWN) {
89	156	if (!fu_synaptics_mst_firmware_detect_family(self, stream, 0x0, error))
90	89	return FALSE;
91	156	}
92
93	67	switch (self->family) {
94	17	case FU_SYNAPTICS_MST_FAMILY_TESLA:
95	20	case FU_SYNAPTICS_MST_FAMILY_LEAF:
96	21	case FU_SYNAPTICS_MST_FAMILY_PANAMERA:
97	21	addr = ADDR_CUSTOMER_ID_TESLA;
98	21	break;
99	6	case FU_SYNAPTICS_MST_FAMILY_CAYENNE:
100	8	case FU_SYNAPTICS_MST_FAMILY_SPYDER:
101	8	addr = ADDR_CUSTOMER_ID_CAYENNE;
102	8	break;
103	17	case FU_SYNAPTICS_MST_FAMILY_CARRERA:
104	17	addr = ADDR_CUSTOMER_ID_CARRERA;
105	17	break;
106	21	default:
107	21	g_set_error(error,
108	21	FWUPD_ERROR,
109	21	FWUPD_ERROR_NOT_SUPPORTED,
110	21	"unsupported chip family %s",
111	21	fu_synaptics_mst_family_to_string(self->family));
112	21	return FALSE;
113	67	}
114	46	if (!fu_input_stream_read_u16(stream, addr, &self->board_id, G_BIG_ENDIAN, error))
115	14	return FALSE;
116
117		/* success */
118	32	return TRUE;
119	46	}
120
121		static GByteArray *
122		fu_synaptics_mst_firmware_write(FuFirmware firmware, GError *error)
123	32	{
124	32	FuSynapticsMstFirmware *self = FU_SYNAPTICS_MST_FIRMWARE(firmware);
125	32	g_autoptr(GByteArray) buf = g_byte_array_new();
126	32	g_autoptr(GBytes) blob = NULL;
127	32	guint16 addr;
128
129	32	switch (self->family) {
130	12	case FU_SYNAPTICS_MST_FAMILY_TESLA:
131	14	case FU_SYNAPTICS_MST_FAMILY_LEAF:
132	15	case FU_SYNAPTICS_MST_FAMILY_PANAMERA:
133	15	addr = ADDR_CUSTOMER_ID_TESLA;
134	15	break;
135	4	case FU_SYNAPTICS_MST_FAMILY_CAYENNE:
136	6	case FU_SYNAPTICS_MST_FAMILY_SPYDER:
137	6	addr = ADDR_CUSTOMER_ID_CAYENNE;
138	6	break;
139	11	case FU_SYNAPTICS_MST_FAMILY_CARRERA:
140	11	addr = ADDR_CUSTOMER_ID_CARRERA;
141	11	break;
142	0	default:
143	0	g_set_error_literal(error,
144	0	FWUPD_ERROR,
145	0	FWUPD_ERROR_NOT_SUPPORTED,
146	0	"unsupported chip family");
147	0	return NULL;
148	32	}
149		/* assumed header */
150	32	fu_byte_array_set_size(buf, addr + sizeof(guint16), 0x00);
151	32	if (!fu_memwrite_uint16_safe(buf->data,
152	32	buf->len,
153	32	addr,
154	32	fu_firmware_get_idx(firmware),
155	32	G_BIG_ENDIAN,
156	32	error))
157	0	return NULL;
158
159		/* payload */
160	32	blob = fu_firmware_get_bytes_with_patches(firmware, error);
161	32	if (blob == NULL)
162	32	return NULL;
163	0	fu_byte_array_append_bytes(buf, blob);
164
165		/* success */
166	0	return g_steal_pointer(&buf);
167	32	}
168
169		static gboolean
170		fu_synaptics_mst_firmware_build(FuFirmware firmware, XbNode n, GError **error)
171	0	{
172	0	FuSynapticsMstFirmware *self = FU_SYNAPTICS_MST_FIRMWARE(firmware);
173	0	guint64 tmp;
174
175		/* optional properties */
176	0	tmp = xb_node_query_text_as_uint(n, "board_id", NULL);
177	0	if (tmp != G_MAXUINT64)
178	0	self->board_id = tmp;
179	0	tmp = xb_node_query_text_as_uint(n, "family", NULL);
180	0	if (tmp != G_MAXUINT64)
181	0	self->family = tmp;
182
183		/* success */
184	0	return TRUE;
185	0	}
186
187		static void
188		fu_synaptics_mst_firmware_init(FuSynapticsMstFirmware *self)
189	156	{
190	156	self->family = FU_SYNAPTICS_MST_FAMILY_UNKNOWN;
191	156	fu_firmware_add_flag(FU_FIRMWARE(self), FU_FIRMWARE_FLAG_NO_AUTO_DETECTION);
192	156	}
193
194		static void
195		fu_synaptics_mst_firmware_class_init(FuSynapticsMstFirmwareClass *klass)
196	1	{
197	1	FuFirmwareClass *firmware_class = FU_FIRMWARE_CLASS(klass);
198	1	firmware_class->parse = fu_synaptics_mst_firmware_parse;
199	1	firmware_class->export = fu_synaptics_mst_firmware_export;
200	1	firmware_class->write = fu_synaptics_mst_firmware_write;
201	1	firmware_class->build = fu_synaptics_mst_firmware_build;
202	1	}
203
204		FuFirmware *
205		fu_synaptics_mst_firmware_new(void)
206	0	{
207	0	return FU_FIRMWARE(g_object_new(FU_TYPE_SYNAPTICS_MST_FIRMWARE, NULL));
208	0	}