11282215792

Committed 10 Oct 2024 09:23PM UTC coverage: 49.076% (-0.02%) from 49.091%

Build # 11282215792

Build Type

push

github

Committed by

superm1

Commit Message

Simplify firmware loading

Remove the offset from `FuFirmware->tokenize()` and `FuFirmware->parse()` --
out of 128 superclasses only 59 were using it and only 25 were actually using
it *correctly*.

Rather that adding masses of code to fix up the ~80% of plugins doing it wrong,
just remove the feature altogether now that FuPartialStream exists.

We're already creating the FuInputStream with the offset, so just use that in
the superclass with no additional overhead.

Run Details

19483 of 35491 branches covered (54.9%)

Branch coverage included in aggregate %.

102 of 178 new or added lines in 95 files covered. (57.3%)

30 existing lines in 11 files now uncovered.

58536 of 123485 relevant lines covered (47.4%)

19947.08 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

1.23

/plugins/amd-gpu/fu-amd-gpu-atom-firmware.c

/*
 * Copyright 2023 Advanced Micro Devices Inc.
 * All rights reserved.
 *
 * This file is provided under a dual MIT/LGPLv2 license.  When using or
 * redistributing this file, you may do so under either license.
 * AMD Chooses the MIT license part of Dual MIT/LGPLv2 license agreement.
 *
 * SPDX-License-Identifier: LGPL-2.1-or-later OR MIT
 */

#include "config.h"

#include "fu-amd-gpu-atom-firmware.h"
#include "fu-amd-gpu-atom-struct.h"

#define BIOS_VERSION_PREFIX "ATOMBIOSBK-AMD VER"
#define BIOS_STRING_LENGTH  43
#define STRLEN_NORMAL            32
#define STRLEN_LONG            64

struct _FuAmdGpuAtomFirmware {
        FuOpromFirmware parent_instance;
        gchar *part_number;
        gchar *asic;
        gchar *pci_type;
        gchar *memory_type;
        gchar *bios_date;
        gchar *model_name;
        gchar *config_filename;
};

/**
 * FuAmdGpuAtomFirmware:
 *
 * Firmware for AMD dGPUs.
 *
 * This parser collects information from the "CSM" image also known as
 * the ATOM image.
 *
 * This image contains strings that describe the version and the hardware
 * the ATOM is intended to be used for.
 */
G_DEFINE_TYPE(FuAmdGpuAtomFirmware, fu_amd_gpu_atom_firmware, FU_TYPE_OPROM_FIRMWARE)

static void
fu_amd_gpu_atom_firmware_export(FuFirmware *firmware,
                                FuFirmwareExportFlags flags,
                                XbBuilderNode *bn)
{
        FuAmdGpuAtomFirmware *self = FU_AMD_GPU_ATOM_FIRMWARE(firmware);

        FU_FIRMWARE_CLASS(fu_amd_gpu_atom_firmware_parent_class)->export(firmware, flags, bn);

        fu_xmlb_builder_insert_kv(bn, "part_number", self->part_number);
        fu_xmlb_builder_insert_kv(bn, "asic", self->asic);
        fu_xmlb_builder_insert_kv(bn, "pci_type", self->pci_type);
        fu_xmlb_builder_insert_kv(bn, "memory_type", self->memory_type);
        fu_xmlb_builder_insert_kv(bn, "bios_date", self->bios_date);
        fu_xmlb_builder_insert_kv(bn, "model_name", self->model_name);
        fu_xmlb_builder_insert_kv(bn, "config_filename", self->config_filename);
}

static gboolean
fu_amd_gpu_atom_firmware_validate(FuFirmware *firmware,
                                  GInputStream *stream,
                                  gsize offset,
                                  GError **error)
{
        g_autoptr(GByteArray) atom = NULL;

        atom = fu_struct_atom_image_parse_stream(stream, offset, error);
        if (atom == NULL)
                return FALSE;
        return fu_struct_atom_rom21_header_validate_stream(
            stream,
            offset + fu_struct_atom_image_get_rom_loc(atom),
            error);
}

const gchar *
fu_amd_gpu_atom_firmware_get_vbios_pn(FuFirmware *firmware)
{
        FuAmdGpuAtomFirmware *self = FU_AMD_GPU_ATOM_FIRMWARE(firmware);
        return self->part_number;
}

static gboolean
fu_amd_gpu_atom_firmware_parse_vbios_version(FuAmdGpuAtomFirmware *self,
                                             GBytes *blob,
                                             GError **error)
{
        gsize bufsz = 0;
        gsize offset = 0;
        const guint8 *buf = g_bytes_get_data(blob, &bufsz);
        g_autofree gchar *version = NULL;

        if (!fu_memmem_safe(buf,
                            bufsz,
                            (const guint8 *)BIOS_VERSION_PREFIX,
                            sizeof(BIOS_VERSION_PREFIX) - 1,
                            &offset,
                            error)) {
                g_prefix_error(error, "failed to find anchor: ");
                return FALSE;
        }

        /* skip anchor */
        offset += sizeof(BIOS_VERSION_PREFIX) - 1;

        version = fu_memstrsafe(buf, bufsz, offset, BIOS_STRING_LENGTH, error);
        if (version == NULL)
                return FALSE;

        fu_firmware_set_version(FU_FIRMWARE(self), version);

        return TRUE;
}

static gboolean
fu_amd_gpu_atom_firmware_parse_vbios_date(FuAmdGpuAtomFirmware *self,
                                          FuStructAtomImage *atom_image,
                                          GError **error)
{
        g_autoptr(GByteArray) st = fu_struct_atom_image_get_vbios_date(atom_image);

        if (st == NULL) {
                g_set_error(error,
                            FWUPD_ERROR,
                            FWUPD_ERROR_INVALID_DATA,
                            "ATOMBIOS date is invalid");
                return FALSE;
        }

        /* same date format as atom_get_vbios_date() */
        self->bios_date = g_strdup_printf("20%s/%s/%s %s:%s",
                                          fu_struct_vbios_date_get_year(st),
                                          fu_struct_vbios_date_get_month(st),
                                          fu_struct_vbios_date_get_day(st),
                                          fu_struct_vbios_date_get_hours(st),
                                          fu_struct_vbios_date_get_minutes(st));

        return TRUE;
}

static gboolean
fu_amd_gpu_atom_firmware_parse_vbios_pn(FuAmdGpuAtomFirmware *self,
                                        GBytes *blob,
                                        FuStructAtomImage *atom_image,
                                        GError **error)
{
        gsize bufsz = 0;
        guint16 atombios_size;
        gint num_str, i;
        guint16 idx;
        const guint8 *buf = g_bytes_get_data(blob, &bufsz);
        g_autofree gchar *model = NULL;

        num_str = fu_struct_atom_image_get_num_strings(atom_image);
        if (num_str == 0) {
                g_set_error(error,
                            FWUPD_ERROR,
                            FWUPD_ERROR_INVALID_DATA,
                            "ATOMBIOS number of strings is 0");
                return FALSE;
        }
        idx = fu_struct_atom_image_get_str_loc(atom_image);
        if (idx == 0) {
                g_set_error(error,
                            FWUPD_ERROR,
                            FWUPD_ERROR_INVALID_DATA,
                            "ATOMBIOS string location is invalid");
                return FALSE;
        }

        /* make sure there is enough space for all the strings */
        atombios_size = fu_firmware_get_size(FU_FIRMWARE(self));
        if ((gsize)(idx + (num_str * (STRLEN_NORMAL - 1))) > atombios_size) {
                g_set_error(error,
                            FWUPD_ERROR,
                            FWUPD_ERROR_INVALID_DATA,
                            "bufsz is too small for all strings");
                return FALSE;
        }

        /* parse atombios strings */
        for (i = 0; i < num_str; i++) {
                g_autofree char *str = NULL;

                str = fu_memstrsafe(buf, bufsz, idx, STRLEN_NORMAL - 1, error);
                if (str == NULL)
                        return FALSE;

                idx += strlen(str) + 1;

                switch (i) {
                case FU_ATOM_STRING_INDEX_PART_NUMBER:
                        self->part_number = g_steal_pointer(&str);
                        break;
                case FU_ATOM_STRING_INDEX_ASIC:
                        self->asic = g_steal_pointer(&str);
                        break;
                case FU_ATOM_STRING_INDEX_PCI_TYPE:
                        self->pci_type = g_steal_pointer(&str);
                        break;
                case FU_ATOM_STRING_INDEX_MEMORY_TYPE:
                        self->memory_type = g_steal_pointer(&str);
                        break;
                default:
                        g_set_error(error,
                                    FWUPD_ERROR,
                                    FWUPD_ERROR_INVALID_DATA,
                                    "unknown string index: %d",
                                    i);
                        return FALSE;
                }
        }

        /* skip the following 2 chars: 0x0D 0x0A */
        idx += 2;

        /* make sure there is enough space for name string */
        if ((gsize)(idx + STRLEN_LONG - 1) > atombios_size) {
                g_set_error(error,
                            FWUPD_ERROR,
                            FWUPD_ERROR_INVALID_DATA,
                            "bufsz is too small for name string");
                return FALSE;
        }

        model = fu_memstrsafe(buf, bufsz, idx, STRLEN_LONG - 1, error);
        if (model == NULL)
                return FALSE;
        self->model_name = fu_strstrip(model);

        return TRUE;
}

static gboolean
fu_amd_gpu_atom_firmware_parse_config_filename(FuAmdGpuAtomFirmware *self,
                                               GBytes *blob,
                                               FuStructAtomRom21Header *atom_header,
                                               GError **error)
{
        gsize bufsz = 0;
        const guint8 *buf = g_bytes_get_data(blob, &bufsz);
        g_autofree gchar *config_filename = NULL;

        config_filename =
            fu_memstrsafe(buf,
                          bufsz,
                              fu_struct_atom_rom21_header_get_config_filename_offset(atom_header),
                          STRLEN_LONG - 1,
                          error);
        if (config_filename == NULL)
                return FALSE;

        /* this function is called twice, but value only stored once */
        if (self->config_filename == NULL)
                self->config_filename = fu_strstrip(config_filename);

        return TRUE;
}

static gboolean
fu_amd_gpu_atom_firmware_parse(FuFirmware *firmware,
                               GInputStream *stream,
                               FwupdInstallFlags flags,
                               GError **error)
{
        FuAmdGpuAtomFirmware *self = FU_AMD_GPU_ATOM_FIRMWARE(firmware);
        guint32 loc;
        g_autoptr(FuStructAtomImage) atom_image = NULL;
        g_autoptr(FuStructAtomRom21Header) atom_rom = NULL;
        g_autoptr(GBytes) blob = NULL;

        if (!FU_FIRMWARE_CLASS(fu_amd_gpu_atom_firmware_parent_class)
                 ->parse(firmware, stream, flags, error))
                return FALSE;

        /* atom rom image */
        atom_image = fu_struct_atom_image_parse_stream(stream, 0x0, error);
        if (atom_image == NULL)
                return FALSE;

        /* unit is 512 bytes */
        fu_firmware_set_size(firmware, fu_struct_atom_image_get_size(atom_image) * 512);

        /* atom rom header */
        loc = fu_struct_atom_image_get_rom_loc(atom_image);
        atom_rom = fu_struct_atom_rom21_header_parse_stream(stream, loc, error);
        if (atom_rom == NULL)
                return FALSE;

        blob = fu_input_stream_read_bytes(stream, 0x0, G_MAXSIZE, error);
        if (blob == NULL)
                return FALSE;
        if (!fu_amd_gpu_atom_firmware_parse_config_filename(self, blob, atom_rom, error))
                return FALSE;
        if (!fu_amd_gpu_atom_firmware_parse_vbios_date(self, atom_image, error))
                return FALSE;
        if (!fu_amd_gpu_atom_firmware_parse_vbios_pn(self, blob, atom_image, error))
                return FALSE;
        if (!fu_amd_gpu_atom_firmware_parse_vbios_version(self, blob, error))
                return FALSE;

        return TRUE;
}

static void
fu_amd_gpu_atom_firmware_init(FuAmdGpuAtomFirmware *self)
{
}

static void
fu_amd_gpu_atom_firmware_finalize(GObject *object)
{
        FuAmdGpuAtomFirmware *self = FU_AMD_GPU_ATOM_FIRMWARE(object);
        g_free(self->part_number);
        g_free(self->asic);
        g_free(self->pci_type);
        g_free(self->memory_type);
        g_free(self->bios_date);
        g_free(self->model_name);
        g_free(self->config_filename);
        G_OBJECT_CLASS(fu_amd_gpu_atom_firmware_parent_class)->finalize(object);
}

static void
fu_amd_gpu_atom_firmware_class_init(FuAmdGpuAtomFirmwareClass *klass)
{
        GObjectClass *object_class = G_OBJECT_CLASS(klass);
        FuFirmwareClass *firmware_class = FU_FIRMWARE_CLASS(klass);
        object_class->finalize = fu_amd_gpu_atom_firmware_finalize;
        firmware_class->parse = fu_amd_gpu_atom_firmware_parse;
        firmware_class->export = fu_amd_gpu_atom_firmware_export;
        firmware_class->validate = fu_amd_gpu_atom_firmware_validate;
}

FuFirmware *
fu_amd_gpu_atom_firmware_new(void)
{
        return FU_FIRMWARE(g_object_new(FU_TYPE_AMD_GPU_ATOM_FIRMWARE, NULL));
}

1	/*
2	* Copyright 2023 Advanced Micro Devices Inc.
3	* All rights reserved.
4	*
5	* This file is provided under a dual MIT/LGPLv2 license. When using or
6	* redistributing this file, you may do so under either license.
7	* AMD Chooses the MIT license part of Dual MIT/LGPLv2 license agreement.
8	*
9	* SPDX-License-Identifier: LGPL-2.1-or-later OR MIT
10	*/
11
12	#include "config.h"
13
14	#include "fu-amd-gpu-atom-firmware.h"
15	#include "fu-amd-gpu-atom-struct.h"
16
17	#define BIOS_VERSION_PREFIX "ATOMBIOSBK-AMD VER"
18	#define BIOS_STRING_LENGTH 43
19	#define STRLEN_NORMAL 32
20	#define STRLEN_LONG 64
21
22	struct _FuAmdGpuAtomFirmware {
23	FuOpromFirmware parent_instance;
24	gchar *part_number;
25	gchar *asic;
26	gchar *pci_type;
27	gchar *memory_type;
28	gchar *bios_date;
29	gchar *model_name;
30	gchar *config_filename;
31	};
32
33	/**
34	* FuAmdGpuAtomFirmware:
35	*
36	* Firmware for AMD dGPUs.
37	*
38	* This parser collects information from the "CSM" image also known as
39	* the ATOM image.
40	*
41	* This image contains strings that describe the version and the hardware
42	* the ATOM is intended to be used for.
43	*/
44	G_DEFINE_TYPE(FuAmdGpuAtomFirmware, fu_amd_gpu_atom_firmware, FU_TYPE_OPROM_FIRMWARE)	196✔
45
46	static void
47	fu_amd_gpu_atom_firmware_export(FuFirmware *firmware,	×
48	FuFirmwareExportFlags flags,
49	XbBuilderNode *bn)
50	{
51	FuAmdGpuAtomFirmware *self = FU_AMD_GPU_ATOM_FIRMWARE(firmware);	×
52
53	FU_FIRMWARE_CLASS(fu_amd_gpu_atom_firmware_parent_class)->export(firmware, flags, bn);	×
54
55	fu_xmlb_builder_insert_kv(bn, "part_number", self->part_number);	×
56	fu_xmlb_builder_insert_kv(bn, "asic", self->asic);	×
57	fu_xmlb_builder_insert_kv(bn, "pci_type", self->pci_type);	×
58	fu_xmlb_builder_insert_kv(bn, "memory_type", self->memory_type);	×
59	fu_xmlb_builder_insert_kv(bn, "bios_date", self->bios_date);	×
60	fu_xmlb_builder_insert_kv(bn, "model_name", self->model_name);	×
61	fu_xmlb_builder_insert_kv(bn, "config_filename", self->config_filename);	×
62	}	×
63
64	static gboolean
65	fu_amd_gpu_atom_firmware_validate(FuFirmware *firmware,	×
66	GInputStream *stream,
67	gsize offset,
68	GError **error)
69	{
70	g_autoptr(GByteArray) atom = NULL;	×
71
72	atom = fu_struct_atom_image_parse_stream(stream, offset, error);	×
73	if (atom == NULL)	×
74	return FALSE;
75	return fu_struct_atom_rom21_header_validate_stream(	×
76	stream,
77	offset + fu_struct_atom_image_get_rom_loc(atom),	×
78	error);
79	}
80
81	const gchar *
82	fu_amd_gpu_atom_firmware_get_vbios_pn(FuFirmware *firmware)	×
83	{
84	FuAmdGpuAtomFirmware *self = FU_AMD_GPU_ATOM_FIRMWARE(firmware);	×
85	return self->part_number;	×
86	}
87
88	static gboolean
89	fu_amd_gpu_atom_firmware_parse_vbios_version(FuAmdGpuAtomFirmware *self,	×
90	GBytes *blob,
91	GError **error)
92	{
93	gsize bufsz = 0;	×
94	gsize offset = 0;	×
95	const guint8 *buf = g_bytes_get_data(blob, &bufsz);	×
96	g_autofree gchar *version = NULL;	×
97
98	if (!fu_memmem_safe(buf,	×
99	bufsz,
100	(const guint8 *)BIOS_VERSION_PREFIX,
101	sizeof(BIOS_VERSION_PREFIX) - 1,
102	&offset,
103	error)) {
104	g_prefix_error(error, "failed to find anchor: ");	×
105	return FALSE;	×
106	}
107
108	/* skip anchor */
109	offset += sizeof(BIOS_VERSION_PREFIX) - 1;	×
110
111	version = fu_memstrsafe(buf, bufsz, offset, BIOS_STRING_LENGTH, error);	×
112	if (version == NULL)	×
113	return FALSE;
114
115	fu_firmware_set_version(FU_FIRMWARE(self), version);	×
116
117	return TRUE;	×
118	}
119
120	static gboolean
121	fu_amd_gpu_atom_firmware_parse_vbios_date(FuAmdGpuAtomFirmware *self,	×
122	FuStructAtomImage *atom_image,
123	GError **error)
124	{
125	g_autoptr(GByteArray) st = fu_struct_atom_image_get_vbios_date(atom_image);	×
126
127	if (st == NULL) {	×
128	g_set_error(error,	×
129	FWUPD_ERROR,
130	FWUPD_ERROR_INVALID_DATA,
131	"ATOMBIOS date is invalid");
132	return FALSE;	×
133	}
134
135	/* same date format as atom_get_vbios_date() */
136	self->bios_date = g_strdup_printf("20%s/%s/%s %s:%s",	×
137	fu_struct_vbios_date_get_year(st),
138	fu_struct_vbios_date_get_month(st),
139	fu_struct_vbios_date_get_day(st),
140	fu_struct_vbios_date_get_hours(st),
141	fu_struct_vbios_date_get_minutes(st));
142
143	return TRUE;	×
144	}
145
146	static gboolean
147	fu_amd_gpu_atom_firmware_parse_vbios_pn(FuAmdGpuAtomFirmware *self,	×
148	GBytes *blob,
149	FuStructAtomImage *atom_image,
150	GError **error)
151	{
152	gsize bufsz = 0;	×
153	guint16 atombios_size;	×
154	gint num_str, i;	×
155	guint16 idx;	×
156	const guint8 *buf = g_bytes_get_data(blob, &bufsz);	×
157	g_autofree gchar *model = NULL;	×
158
159	num_str = fu_struct_atom_image_get_num_strings(atom_image);	×
160	if (num_str == 0) {	×
161	g_set_error(error,	×
162	FWUPD_ERROR,
163	FWUPD_ERROR_INVALID_DATA,
164	"ATOMBIOS number of strings is 0");
165	return FALSE;	×
166	}
167	idx = fu_struct_atom_image_get_str_loc(atom_image);	×
168	if (idx == 0) {	×
169	g_set_error(error,	×
170	FWUPD_ERROR,
171	FWUPD_ERROR_INVALID_DATA,
172	"ATOMBIOS string location is invalid");
173	return FALSE;	×
174	}
175
176	/* make sure there is enough space for all the strings */
177	atombios_size = fu_firmware_get_size(FU_FIRMWARE(self));	×
178	if ((gsize)(idx + (num_str * (STRLEN_NORMAL - 1))) > atombios_size) {	×
179	g_set_error(error,	×
180	FWUPD_ERROR,
181	FWUPD_ERROR_INVALID_DATA,
182	"bufsz is too small for all strings");
183	return FALSE;	×
184	}
185
186	/* parse atombios strings */
187	for (i = 0; i < num_str; i++) {	×
188	g_autofree char *str = NULL;	×
189
190	str = fu_memstrsafe(buf, bufsz, idx, STRLEN_NORMAL - 1, error);	×
191	if (str == NULL)	×
192	return FALSE;
193
194	idx += strlen(str) + 1;	×
195
196	switch (i) {	×
197	case FU_ATOM_STRING_INDEX_PART_NUMBER:
198	self->part_number = g_steal_pointer(&str);	×
199	break;	×
200	case FU_ATOM_STRING_INDEX_ASIC:
201	self->asic = g_steal_pointer(&str);	×
202	break;	×
203	case FU_ATOM_STRING_INDEX_PCI_TYPE:
204	self->pci_type = g_steal_pointer(&str);	×
205	break;	×
206	case FU_ATOM_STRING_INDEX_MEMORY_TYPE:
207	self->memory_type = g_steal_pointer(&str);	×
208	break;	×
209	default:	×
210	g_set_error(error,	×
211	FWUPD_ERROR,
212	FWUPD_ERROR_INVALID_DATA,
213	"unknown string index: %d",
214	i);
215	return FALSE;	×
216	}
217	}
218
219	/* skip the following 2 chars: 0x0D 0x0A */
220	idx += 2;	×
221
222	/* make sure there is enough space for name string */
223	if ((gsize)(idx + STRLEN_LONG - 1) > atombios_size) {	×
224	g_set_error(error,	×
225	FWUPD_ERROR,
226	FWUPD_ERROR_INVALID_DATA,
227	"bufsz is too small for name string");
228	return FALSE;	×
229	}
230
231	model = fu_memstrsafe(buf, bufsz, idx, STRLEN_LONG - 1, error);	×
232	if (model == NULL)	×
233	return FALSE;
234	self->model_name = fu_strstrip(model);	×
235
236	return TRUE;	×
237	}
238
239	static gboolean
240	fu_amd_gpu_atom_firmware_parse_config_filename(FuAmdGpuAtomFirmware *self,	×
241	GBytes *blob,
242	FuStructAtomRom21Header *atom_header,
243	GError **error)
244	{
245	gsize bufsz = 0;	×
246	const guint8 *buf = g_bytes_get_data(blob, &bufsz);	×
247	g_autofree gchar *config_filename = NULL;	×
248
249	config_filename =	×
250	fu_memstrsafe(buf,	×
251	bufsz,
252	fu_struct_atom_rom21_header_get_config_filename_offset(atom_header),	×
253	STRLEN_LONG - 1,
254	error);
255	if (config_filename == NULL)	×
256	return FALSE;
257
258	/* this function is called twice, but value only stored once */
259	if (self->config_filename == NULL)	×
260	self->config_filename = fu_strstrip(config_filename);	×
261
262	return TRUE;
263	}
264
265	static gboolean
266	fu_amd_gpu_atom_firmware_parse(FuFirmware *firmware,	×
267	GInputStream *stream,
268	FwupdInstallFlags flags,
269	GError **error)
270	{
271	FuAmdGpuAtomFirmware *self = FU_AMD_GPU_ATOM_FIRMWARE(firmware);	×
272	guint32 loc;	×
273	g_autoptr(FuStructAtomImage) atom_image = NULL;	×
274	g_autoptr(FuStructAtomRom21Header) atom_rom = NULL;	×
275	g_autoptr(GBytes) blob = NULL;	×
276
277	if (!FU_FIRMWARE_CLASS(fu_amd_gpu_atom_firmware_parent_class)	×
NEW 278	->parse(firmware, stream, flags, error))	×
279	return FALSE;
280
281	/* atom rom image */
NEW 282	atom_image = fu_struct_atom_image_parse_stream(stream, 0x0, error);	×
283	if (atom_image == NULL)	×
284	return FALSE;
285
286	/* unit is 512 bytes */
287	fu_firmware_set_size(firmware, fu_struct_atom_image_get_size(atom_image) * 512);	×
288
289	/* atom rom header */
NEW 290	loc = fu_struct_atom_image_get_rom_loc(atom_image);	×
291	atom_rom = fu_struct_atom_rom21_header_parse_stream(stream, loc, error);	×
292	if (atom_rom == NULL)	×
293	return FALSE;
294
NEW 295	blob = fu_input_stream_read_bytes(stream, 0x0, G_MAXSIZE, error);	×
296	if (blob == NULL)	×
297	return FALSE;
298	if (!fu_amd_gpu_atom_firmware_parse_config_filename(self, blob, atom_rom, error))	×
299	return FALSE;
300	if (!fu_amd_gpu_atom_firmware_parse_vbios_date(self, atom_image, error))	×
301	return FALSE;
302	if (!fu_amd_gpu_atom_firmware_parse_vbios_pn(self, blob, atom_image, error))	×
303	return FALSE;
304	if (!fu_amd_gpu_atom_firmware_parse_vbios_version(self, blob, error))	×
305	return FALSE;
306
307	return TRUE;
308	}
309
310	static void
311	fu_amd_gpu_atom_firmware_init(FuAmdGpuAtomFirmware *self)	×
312	{
313	}	×
314
315	static void
316	fu_amd_gpu_atom_firmware_finalize(GObject *object)	×
317	{
318	FuAmdGpuAtomFirmware *self = FU_AMD_GPU_ATOM_FIRMWARE(object);	×
319	g_free(self->part_number);	×
320	g_free(self->asic);	×
321	g_free(self->pci_type);	×
322	g_free(self->memory_type);	×
323	g_free(self->bios_date);	×
324	g_free(self->model_name);	×
325	g_free(self->config_filename);	×
326	G_OBJECT_CLASS(fu_amd_gpu_atom_firmware_parent_class)->finalize(object);	×
327	}	×
328
329	static void
330	fu_amd_gpu_atom_firmware_class_init(FuAmdGpuAtomFirmwareClass *klass)	×
331	{
332	GObjectClass *object_class = G_OBJECT_CLASS(klass);	×
333	FuFirmwareClass *firmware_class = FU_FIRMWARE_CLASS(klass);	×
334	object_class->finalize = fu_amd_gpu_atom_firmware_finalize;	×
335	firmware_class->parse = fu_amd_gpu_atom_firmware_parse;	×
336	firmware_class->export = fu_amd_gpu_atom_firmware_export;	×
337	firmware_class->validate = fu_amd_gpu_atom_firmware_validate;	×
338	}
339
340	FuFirmware *
341	fu_amd_gpu_atom_firmware_new(void)	×
342	{
343	return FU_FIRMWARE(g_object_new(FU_TYPE_AMD_GPU_ATOM_FIRMWARE, NULL));	×
344	}

fwupd / fwupd / 11282215792

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous