11622366407

Committed 01 Nov 2024 01:03AM UTC coverage: 52.886% (+0.05%) from 52.839%

Build # 11622366407

Build Type

push

github

Committed by

CragW

Commit Message

dell-k2: rework the update flow for ec managed devices

1. Consolidate the update code for the devices managed by ec
2. Use chunk and page for ec relevant update
3. RMM has its own usb handle so separate it from ec subcomponents
4. Add delay time for chunk and page to improve the stability
5. Move per device prepare to the composite level

Run Details

20450 of 35730 branches covered (57.23%)

Branch coverage included in aggregate %.

23 of 136 new or added lines in 11 files covered. (16.91%)

19 existing lines in 2 files now uncovered.

64218 of 124364 relevant lines covered (51.64%)

25320.5 hits per line

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

0.0

/plugins/dell-k2/fu-dell-k2-rtshub.c

/*
 * Copyright 2024 Dell Technologies
 *
 * SPDX-License-Identifier: LGPL-2.1-or-later OR MIT
 */

#include "config.h"

#include "fu-dell-k2-common.h"
#include "fu-dell-k2-rtshub-firmware.h"
#include "fu-dell-k2-rtshub.h"

struct _FuDellK2RtsHub {
        FuHidDevice parent_instance;
        FuDellK2BaseType dock_type;
        gboolean fw_auth;
        gboolean dual_bank;
};

G_DEFINE_TYPE(FuDellK2RtsHub, fu_dell_k2_rtshub, FU_TYPE_HID_DEVICE)

static void
fu_dell_k2_rtshub_to_string(FuDevice *device, guint idt, GString *str)
{
        FuDellK2RtsHub *self = FU_DELL_K2_RTSHUB(device);
        fwupd_codec_string_append_bool(str, idt, "FwAuth", self->fw_auth);
        fwupd_codec_string_append_bool(str, idt, "DualBank", self->dual_bank);
        fwupd_codec_string_append_hex(str, idt, "DockType", self->dock_type);
}

static gboolean
fu_dell_k2_rtshub_set_clock_mode(FuDellK2RtsHub *self, gboolean enable, GError **error)
{
        FuRtshubHIDCmdBuffer cmd_buffer = {
            .cmd = RTSHUB_CMD_WRITE_DATA,
            .ext = RTSHUB_EXT_MCUMODIFYCLOCK,
            .cmd_data0 = (guint8)enable,
            .cmd_data1 = 0,
            .cmd_data2 = 0,
            .cmd_data3 = 0,
            .bufferlen = 0,
        };
        guint8 buf[DELL_K2_RTSHUB_BUFFER_SIZE] = {0};

        if (!fu_memcpy_safe(buf,
                            sizeof(buf),
                            0x0, /* dst */
                            (const guint8 *)&cmd_buffer,
                            sizeof(cmd_buffer),
                            0x0, /* src */
                            sizeof(cmd_buffer),
                            error))
                return FALSE;
        if (!fu_hid_device_set_report(FU_HID_DEVICE(self),
                                      0x0,
                                      buf,
                                      sizeof(buf),
                                      DELL_K2_RTSHUB_TIMEOUT,
                                      FU_HID_DEVICE_FLAG_NONE,
                                      error)) {
                g_prefix_error(error, "failed to set clock-mode=%i: ", enable);
                return FALSE;
        }
        return TRUE;
}

static gboolean
fu_dell_k2_rtshub_erase_spare_bank(FuDellK2RtsHub *self, GError **error)
{
        FuRtshubHIDCmdBuffer cmd_buffer = {
            .cmd = RTSHUB_CMD_WRITE_DATA,
            .ext = RTSHUB_EXT_ERASEBANK,
            .cmd_data0 = 0,
            .cmd_data1 = 1,
            .cmd_data2 = 0,
            .cmd_data3 = 0,
            .bufferlen = 0,
        };
        guint8 buf[DELL_K2_RTSHUB_BUFFER_SIZE] = {0};

        if (!fu_memcpy_safe(buf,
                            sizeof(buf),
                            0x0, /* dst */
                            (const guint8 *)&cmd_buffer,
                            sizeof(cmd_buffer),
                            0x0, /* src */
                            sizeof(cmd_buffer),
                            error))
                return FALSE;
        if (!fu_hid_device_set_report(FU_HID_DEVICE(self),
                                      0x0,
                                      buf,
                                      sizeof(buf),
                                      DELL_K2_RTSHUB_TIMEOUT * 3,
                                      FU_HID_DEVICE_FLAG_NONE,
                                      error)) {
                g_prefix_error(error, "failed to erase spare bank: ");
                return FALSE;
        }
        return TRUE;
}

static gboolean
fu_dell_k2_rtshub_verify_update_fw(FuDellK2RtsHub *self, FuProgress *progress, GError **error)
{
        const FuRtshubHIDCmdBuffer cmd_buffer = {
            .cmd = RTSHUB_CMD_WRITE_DATA,
            .ext = RTSHUB_EXT_VERIFYUPDATE,
            .cmd_data0 = 1,
            .cmd_data1 = 0,
            .cmd_data2 = 0,
            .cmd_data3 = 0,
            .bufferlen = 0,
        };
        guint8 buf[DELL_K2_RTSHUB_BUFFER_SIZE] = {0};

        /* set then get */
        if (!fu_memcpy_safe(buf,
                            sizeof(buf),
                            0x0, /* dst */
                            (const guint8 *)&cmd_buffer,
                            sizeof(cmd_buffer),
                            0x0, /* src */
                            sizeof(cmd_buffer),
                            error))
                return FALSE;
        if (!fu_hid_device_set_report(FU_HID_DEVICE(self),
                                      0x0,
                                      buf,
                                      sizeof(buf),
                                      DELL_K2_RTSHUB_TIMEOUT,
                                      FU_HID_DEVICE_FLAG_NONE,
                                      error))
                return FALSE;
        fu_device_sleep_full(FU_DEVICE(self), 4000, progress); /* ms */
        if (!fu_hid_device_get_report(FU_HID_DEVICE(self),
                                      0x0,
                                      buf,
                                      sizeof(buf),
                                      DELL_K2_RTSHUB_TIMEOUT,
                                      FU_HID_DEVICE_FLAG_NONE,
                                      error))
                return FALSE;

        /* check device status, 1 for success otherwise fail */
        if (buf[0] != 0x01) {
                g_set_error_literal(error, FWUPD_ERROR, FWUPD_ERROR_WRITE, "firmware flash failed");
                return FALSE;
        }

        /* success */
        return TRUE;
}

static gboolean
fu_dell_k2_rtshub_write_flash(FuDellK2RtsHub *self,
                              guint32 addr,
                              const guint8 *data,
                              guint16 data_sz,
                              GError **error)
{
        FuRtshubHIDCmdBuffer cmd_buffer = {
            .cmd = RTSHUB_CMD_WRITE_DATA,
            .ext = RTSHUB_EXT_WRITEFLASH,
            .dwregaddr = GUINT32_TO_LE(addr),
            .bufferlen = GUINT16_TO_LE(data_sz),
        };
        guint8 buf[DELL_K2_RTSHUB_BUFFER_SIZE] = {0};

        g_return_val_if_fail(data_sz <= 128, FALSE);
        g_return_val_if_fail(data != NULL, FALSE);
        g_return_val_if_fail(data_sz != 0, FALSE);

        /* vendor command */
        if (!fu_memcpy_safe(buf,
                            sizeof(buf),
                            0x0, /* dst */
                            (const guint8 *)&cmd_buffer,
                            sizeof(cmd_buffer),
                            0x0, /* src */
                            sizeof(cmd_buffer),
                            error))
                return FALSE;

        /* data payload */
        if (!fu_memcpy_safe(buf,
                            sizeof(buf),
                            DELL_K2_RTSHUB_WRITE_FLASH_OFFSET_DATA, /* dst */
                            data,
                            data_sz,
                            0x0, /* src */
                            data_sz,
                            error))
                return FALSE;

        if (!fu_hid_device_set_report(FU_HID_DEVICE(self),
                                      0x0,
                                      buf,
                                      sizeof(buf),
                                      DELL_K2_RTSHUB_TIMEOUT,
                                      FU_HID_DEVICE_FLAG_NONE,
                                      error)) {
                g_prefix_error(error, "failed to write flash @%08x: ", (guint)addr);
                return FALSE;
        }
        return TRUE;
}

static gboolean
fu_dell_k2_rtshub_write_firmware(FuDevice *device,
                                 FuFirmware *firmware,
                                 FuProgress *progress,
                                 FwupdInstallFlags flags,
                                 GError **error)
{
        FuDellK2RtsHub *self = FU_DELL_K2_RTSHUB(device);
        g_autoptr(GInputStream) stream = NULL;
        g_autoptr(FuChunkArray) chunks = NULL;

        /* progress */
        fu_progress_set_id(progress, G_STRLOC);
        fu_progress_add_step(progress, FWUPD_STATUS_DEVICE_ERASE, 2, NULL);
        fu_progress_add_step(progress, FWUPD_STATUS_DEVICE_WRITE, 28, NULL);
        fu_progress_add_step(progress, FWUPD_STATUS_DEVICE_VERIFY, 70, NULL);

        /* set MCU to high clock rate for better ISP performance */
        if (!fu_dell_k2_rtshub_set_clock_mode(self, TRUE, error))
                return FALSE;

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

        chunks = fu_chunk_array_new_from_stream(stream,
                                                FU_CHUNK_ADDR_OFFSET_NONE,
                                                FU_CHUNK_PAGESZ_NONE,
                                                DELL_K2_RTSHUB_TRANSFER_BLOCK_SIZE,
                                                error);
        if (chunks == NULL)
                return FALSE;

        /* erase spare flash bank only if it is not empty */
        if (!fu_dell_k2_rtshub_erase_spare_bank(self, error))
                return FALSE;
        fu_progress_step_done(progress);

        /* write each block */
        for (guint i = 0; i < fu_chunk_array_length(chunks); i++) {
                g_autoptr(FuChunk) chk = NULL;

                /* prepare chunk */
                chk = fu_chunk_array_index(chunks, i, error);
                if (chk == NULL)
                        return FALSE;

                /* write chunk */
                if (!fu_dell_k2_rtshub_write_flash(self,
                                                   fu_chunk_get_address(chk),
                                                   fu_chunk_get_data(chk),
                                                   fu_chunk_get_data_sz(chk),
                                                   error))
                        return FALSE;

                /* update progress */
                fu_progress_set_percentage_full(fu_progress_get_child(progress),
                                                (gsize)i + 1,
                                                (gsize)fu_chunk_array_length(chunks));
        }
        fu_progress_step_done(progress);

        /* get device to authenticate the firmware */
        if (!fu_dell_k2_rtshub_verify_update_fw(self, fu_progress_get_child(progress), error))
                return FALSE;
        fu_progress_step_done(progress);

        /* success! */
        return TRUE;
}

static gboolean
fu_dell_k2_rtshub_get_status(FuDevice *device, GError **error)
{
        FuDellK2RtsHub *self = FU_DELL_K2_RTSHUB(device);
        FuRtshubHIDCmdBuffer cmd_buffer = {
            .cmd = RTSHUB_CMD_READ_DATA,
            .ext = RTSHUB_EXT_READ_STATUS,
            .cmd_data0 = 0,
            .cmd_data1 = 0,
            .cmd_data2 = 0,
            .cmd_data3 = 0,
            .bufferlen = GUINT16_TO_LE(12),
        };
        guint8 buf[DELL_K2_RTSHUB_BUFFER_SIZE] = {0};
        g_autofree gchar *version = NULL;

        if (!fu_memcpy_safe(buf,
                            sizeof(buf),
                            0x0, /* dst */
                            (const guint8 *)&cmd_buffer,
                            sizeof(cmd_buffer),
                            0x0, /* src */
                            sizeof(cmd_buffer),
                            error))
                return FALSE;
        if (!fu_hid_device_set_report(FU_HID_DEVICE(self),
                                      0x0,
                                      buf,
                                      sizeof(buf),
                                      DELL_K2_RTSHUB_TIMEOUT,
                                      FU_HID_DEVICE_FLAG_RETRY_FAILURE,
                                      error))
                return FALSE;
        if (!fu_hid_device_get_report(FU_HID_DEVICE(self),
                                      0x0,
                                      buf,
                                      sizeof(buf),
                                      DELL_K2_RTSHUB_TIMEOUT,
                                      FU_HID_DEVICE_FLAG_RETRY_FAILURE,
                                      error))
                return FALSE;

        /* version: index 10, subversion: index 11 */
        version = g_strdup_printf("%x.%x", buf[10], buf[11]);
        fu_device_set_version(device, version);

        /* dual bank capability */
        self->dual_bank = (buf[13] & 0xf0) == 0x80;

        /* authentication capability */
        self->fw_auth = (buf[13] & 0x02) > 0;

        return TRUE;
}

static gboolean
fu_dell_k2_rtshub_setup(FuDevice *device, GError **error)
{
        FuDellK2RtsHub *self = FU_DELL_K2_RTSHUB(device);

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

        if (!fu_dell_k2_rtshub_get_status(device, error))
                return FALSE;

        if (self->dual_bank)
                fu_device_add_flag(device, FWUPD_DEVICE_FLAG_DUAL_IMAGE);

        if (!self->fw_auth)
                fu_device_set_update_error(device, "device does not support authentication");

        return TRUE;
}

static gboolean
fu_dell_k2_rtshub_probe(FuDevice *device, GError **error)
{
        g_autofree const gchar *logical_id = NULL;
        FuDellK2RtsHub *self = FU_DELL_K2_RTSHUB(device);

        /* not interesting */
        if (fu_device_get_vid(device) != DELL_VID) {
                g_set_error(error,
                            FWUPD_ERROR,
                            FWUPD_ERROR_NOT_SUPPORTED,
                            "device vid not dell, expected: 0x%04x, got: 0x%04x",
                            (guint)DELL_VID,
                            fu_device_get_vid(device));
                return FALSE;
        }

        /* caring for my family back home after fw reset */
        switch (fu_device_get_pid(device)) {
        case DELL_K2_USB_RTS5480_GEN1_PID:
                fu_device_set_name(device, "RTS5480 Gen 1 USB Hub");
                break;
        case DELL_K2_USB_RTS5480_GEN2_PID:
                fu_device_set_name(device, "RTS5480 Gen 2 USB Hub");
                break;
        case DELL_K2_USB_RTS5485_GEN2_PID:
                fu_device_set_name(device, "RTS5485 Gen 2 USB Hub");
                break;
        default:
                g_set_error(error,
                            FWUPD_ERROR,
                            FWUPD_ERROR_NOT_SUPPORTED,
                            "device pid '%04x' is not supported",
                            fu_device_get_pid(device));
                return FALSE;
        }

        /* build logical id */
        logical_id = g_strdup_printf("RTSHUB_%04X", fu_device_get_pid(device));
        fu_device_set_logical_id(device, logical_id);

        /* build instance id */
        fu_device_add_instance_u8(device, "DOCKTYPE", self->dock_type);
        fu_device_build_instance_id(device, error, "USB", "VID", "PID", "DOCKTYPE", NULL);
        return TRUE;
}

static gboolean
fu_dell_k2_rtshub_open(FuDevice *device, GError **error)
{
        FuDevice *parent = fu_device_get_parent(device);

        if (!FU_DEVICE_CLASS(fu_dell_k2_rtshub_parent_class)->open(device, error))
                return FALSE;

        if (parent != NULL)
                return fu_device_open(parent, error);
        return TRUE;
}

static void
fu_dell_k2_rtshub_set_progress(FuDevice *self, FuProgress *progress)
{
        fu_progress_set_id(progress, G_STRLOC);
        fu_progress_add_flag(progress, FU_PROGRESS_FLAG_GUESSED);
        fu_progress_add_step(progress, FWUPD_STATUS_DEVICE_RESTART, 0, "detach");
        fu_progress_add_step(progress, FWUPD_STATUS_DEVICE_WRITE, 100, "write");
        fu_progress_add_step(progress, FWUPD_STATUS_DEVICE_RESTART, 0, "attach");
        fu_progress_add_step(progress, FWUPD_STATUS_DEVICE_BUSY, 0, "reload");
}

static void
fu_dell_k2_rtshub_init(FuDellK2RtsHub *self)
{
        fu_device_add_protocol(FU_DEVICE(self), "com.dell.k2");
        fu_device_add_icon(FU_DEVICE(self), "dock-usb");
        fu_device_add_flag(FU_DEVICE(self), FWUPD_DEVICE_FLAG_UPDATABLE);
        fu_device_add_flag(FU_DEVICE(self), FWUPD_DEVICE_FLAG_SIGNED_PAYLOAD);
        fu_device_add_flag(FU_DEVICE(self), FWUPD_DEVICE_FLAG_INSTALL_SKIP_VERSION_CHECK);
        fu_device_add_private_flag(FU_DEVICE(self), FU_DEVICE_PRIVATE_FLAG_SKIPS_RESTART);
        fu_device_add_private_flag(FU_DEVICE(self), FU_DEVICE_PRIVATE_FLAG_EXPLICIT_ORDER);
        fu_device_add_private_flag(FU_DEVICE(self), FU_DEVICE_PRIVATE_FLAG_RETRY_OPEN);
        fu_device_set_version_format(FU_DEVICE(self), FWUPD_VERSION_FORMAT_PAIR);
        fu_device_set_firmware_gtype(FU_DEVICE(self), FU_TYPE_DELL_K2_RTSHUB_FIRMWARE);
        fu_device_retry_set_delay(FU_DEVICE(self), 1000);
}

static void
fu_dell_k2_rtshub_class_init(FuDellK2RtsHubClass *klass)
{
        FuDeviceClass *device_class = FU_DEVICE_CLASS(klass);
        device_class->to_string = fu_dell_k2_rtshub_to_string;
        device_class->setup = fu_dell_k2_rtshub_setup;
        device_class->probe = fu_dell_k2_rtshub_probe;
        device_class->write_firmware = fu_dell_k2_rtshub_write_firmware;
        device_class->set_progress = fu_dell_k2_rtshub_set_progress;
        device_class->open = fu_dell_k2_rtshub_open;
}

FuDellK2RtsHub *
fu_dell_k2_rtshub_new(FuUsbDevice *device, FuDellK2BaseType dock_type)
{
        FuDellK2RtsHub *self = g_object_new(FU_TYPE_DELL_K2_RTSHUB, NULL);

        fu_device_incorporate(FU_DEVICE(self), FU_DEVICE(device), FU_DEVICE_INCORPORATE_FLAG_ALL);
        self->dock_type = dock_type;
        return self;
}

1	/*
2	* Copyright 2024 Dell Technologies
3	*
4	* SPDX-License-Identifier: LGPL-2.1-or-later OR MIT
5	*/
6
7	#include "config.h"
8
9	#include "fu-dell-k2-common.h"
10	#include "fu-dell-k2-rtshub-firmware.h"
11	#include "fu-dell-k2-rtshub.h"
12
13	struct _FuDellK2RtsHub {
14	FuHidDevice parent_instance;
15	FuDellK2BaseType dock_type;
16	gboolean fw_auth;
17	gboolean dual_bank;
18	};
19
20	G_DEFINE_TYPE(FuDellK2RtsHub, fu_dell_k2_rtshub, FU_TYPE_HID_DEVICE)	×
21
22	static void
23	fu_dell_k2_rtshub_to_string(FuDevice device, guint idt, GString str)	×
24	{
25	FuDellK2RtsHub *self = FU_DELL_K2_RTSHUB(device);	×
26	fwupd_codec_string_append_bool(str, idt, "FwAuth", self->fw_auth);	×
27	fwupd_codec_string_append_bool(str, idt, "DualBank", self->dual_bank);	×
28	fwupd_codec_string_append_hex(str, idt, "DockType", self->dock_type);	×
29	}	×
30
31	static gboolean
32	fu_dell_k2_rtshub_set_clock_mode(FuDellK2RtsHub self, gboolean enable, GError *error)	×
33	{
34	FuRtshubHIDCmdBuffer cmd_buffer = {	×
35	.cmd = RTSHUB_CMD_WRITE_DATA,
36	.ext = RTSHUB_EXT_MCUMODIFYCLOCK,
37	.cmd_data0 = (guint8)enable,	×
38	.cmd_data1 = 0,
39	.cmd_data2 = 0,
40	.cmd_data3 = 0,
41	.bufferlen = 0,
42	};
43	guint8 buf[DELL_K2_RTSHUB_BUFFER_SIZE] = {0};	×
44
45	if (!fu_memcpy_safe(buf,	×
46	sizeof(buf),
47	0x0, /* dst */
48	(const guint8 *)&cmd_buffer,
49	sizeof(cmd_buffer),
50	0x0, /* src */
51	sizeof(cmd_buffer),
52	error))
53	return FALSE;
54	if (!fu_hid_device_set_report(FU_HID_DEVICE(self),	×
55	0x0,
56	buf,
57	sizeof(buf),
58	DELL_K2_RTSHUB_TIMEOUT,
59	FU_HID_DEVICE_FLAG_NONE,
60	error)) {
61	g_prefix_error(error, "failed to set clock-mode=%i: ", enable);	×
62	return FALSE;	×
63	}
64	return TRUE;
65	}
66
67	static gboolean
68	fu_dell_k2_rtshub_erase_spare_bank(FuDellK2RtsHub self, GError *error)	×
69	{
70	FuRtshubHIDCmdBuffer cmd_buffer = {	×
71	.cmd = RTSHUB_CMD_WRITE_DATA,
72	.ext = RTSHUB_EXT_ERASEBANK,
73	.cmd_data0 = 0,
74	.cmd_data1 = 1,
75	.cmd_data2 = 0,
76	.cmd_data3 = 0,
77	.bufferlen = 0,
78	};
79	guint8 buf[DELL_K2_RTSHUB_BUFFER_SIZE] = {0};	×
80
81	if (!fu_memcpy_safe(buf,	×
82	sizeof(buf),
83	0x0, /* dst */
84	(const guint8 *)&cmd_buffer,
85	sizeof(cmd_buffer),
86	0x0, /* src */
87	sizeof(cmd_buffer),
88	error))
89	return FALSE;
90	if (!fu_hid_device_set_report(FU_HID_DEVICE(self),	×
91	0x0,
92	buf,
93	sizeof(buf),
94	DELL_K2_RTSHUB_TIMEOUT * 3,
95	FU_HID_DEVICE_FLAG_NONE,
96	error)) {
97	g_prefix_error(error, "failed to erase spare bank: ");	×
98	return FALSE;	×
99	}
100	return TRUE;
101	}
102
103	static gboolean
104	fu_dell_k2_rtshub_verify_update_fw(FuDellK2RtsHub self, FuProgress progress, GError **error)	×
105	{
106	const FuRtshubHIDCmdBuffer cmd_buffer = {	×
107	.cmd = RTSHUB_CMD_WRITE_DATA,
108	.ext = RTSHUB_EXT_VERIFYUPDATE,
109	.cmd_data0 = 1,
110	.cmd_data1 = 0,
111	.cmd_data2 = 0,
112	.cmd_data3 = 0,
113	.bufferlen = 0,
114	};
115	guint8 buf[DELL_K2_RTSHUB_BUFFER_SIZE] = {0};	×
116
117	/* set then get */
118	if (!fu_memcpy_safe(buf,	×
119	sizeof(buf),
120	0x0, /* dst */
121	(const guint8 *)&cmd_buffer,
122	sizeof(cmd_buffer),
123	0x0, /* src */
124	sizeof(cmd_buffer),
125	error))
126	return FALSE;
127	if (!fu_hid_device_set_report(FU_HID_DEVICE(self),	×
128	0x0,
129	buf,
130	sizeof(buf),
131	DELL_K2_RTSHUB_TIMEOUT,
132	FU_HID_DEVICE_FLAG_NONE,
133	error))
134	return FALSE;
135	fu_device_sleep_full(FU_DEVICE(self), 4000, progress); /* ms */	×
136	if (!fu_hid_device_get_report(FU_HID_DEVICE(self),	×
137	0x0,
138	buf,
139	sizeof(buf),
140	DELL_K2_RTSHUB_TIMEOUT,
141	FU_HID_DEVICE_FLAG_NONE,
142	error))
143	return FALSE;
144
145	/* check device status, 1 for success otherwise fail */
146	if (buf[0] != 0x01) {	×
147	g_set_error_literal(error, FWUPD_ERROR, FWUPD_ERROR_WRITE, "firmware flash failed");	×
148	return FALSE;	×
149	}
150
151	/* success */
152	return TRUE;
153	}
154
155	static gboolean
156	fu_dell_k2_rtshub_write_flash(FuDellK2RtsHub *self,	×
157	guint32 addr,
158	const guint8 *data,
159	guint16 data_sz,
160	GError **error)
161	{
162	FuRtshubHIDCmdBuffer cmd_buffer = {	×
163	.cmd = RTSHUB_CMD_WRITE_DATA,
164	.ext = RTSHUB_EXT_WRITEFLASH,
165	.dwregaddr = GUINT32_TO_LE(addr),
166	.bufferlen = GUINT16_TO_LE(data_sz),
167	};
168	guint8 buf[DELL_K2_RTSHUB_BUFFER_SIZE] = {0};	×
169
170	g_return_val_if_fail(data_sz <= 128, FALSE);	×
171	g_return_val_if_fail(data != NULL, FALSE);	×
172	g_return_val_if_fail(data_sz != 0, FALSE);	×
173
174	/* vendor command */
175	if (!fu_memcpy_safe(buf,	×
176	sizeof(buf),
177	0x0, /* dst */
178	(const guint8 *)&cmd_buffer,
179	sizeof(cmd_buffer),
180	0x0, /* src */
181	sizeof(cmd_buffer),
182	error))
183	return FALSE;
184
185	/* data payload */
186	if (!fu_memcpy_safe(buf,	×
187	sizeof(buf),
188	DELL_K2_RTSHUB_WRITE_FLASH_OFFSET_DATA, /* dst */
189	data,
190	data_sz,
191	0x0, /* src */
192	data_sz,
193	error))
194	return FALSE;
195
196	if (!fu_hid_device_set_report(FU_HID_DEVICE(self),	×
197	0x0,
198	buf,
199	sizeof(buf),
200	DELL_K2_RTSHUB_TIMEOUT,
201	FU_HID_DEVICE_FLAG_NONE,
202	error)) {
203	g_prefix_error(error, "failed to write flash @%08x: ", (guint)addr);	×
204	return FALSE;	×
205	}
206	return TRUE;
207	}
208
209	static gboolean
210	fu_dell_k2_rtshub_write_firmware(FuDevice *device,	×
211	FuFirmware *firmware,
212	FuProgress *progress,
213	FwupdInstallFlags flags,
214	GError **error)
215	{
216	FuDellK2RtsHub *self = FU_DELL_K2_RTSHUB(device);	×
217	g_autoptr(GInputStream) stream = NULL;	×
218	g_autoptr(FuChunkArray) chunks = NULL;	×
219
220	/* progress */
221	fu_progress_set_id(progress, G_STRLOC);	×
222	fu_progress_add_step(progress, FWUPD_STATUS_DEVICE_ERASE, 2, NULL);	×
223	fu_progress_add_step(progress, FWUPD_STATUS_DEVICE_WRITE, 28, NULL);	×
224	fu_progress_add_step(progress, FWUPD_STATUS_DEVICE_VERIFY, 70, NULL);	×
225
226	/* set MCU to high clock rate for better ISP performance */
227	if (!fu_dell_k2_rtshub_set_clock_mode(self, TRUE, error))	×
228	return FALSE;
229
230	/* get default image */
231	stream = fu_firmware_get_stream(firmware, error);	×
232	if (stream == NULL)	×
233	return FALSE;
234
235	chunks = fu_chunk_array_new_from_stream(stream,	×
236	FU_CHUNK_ADDR_OFFSET_NONE,
237	FU_CHUNK_PAGESZ_NONE,
238	DELL_K2_RTSHUB_TRANSFER_BLOCK_SIZE,
239	error);
240	if (chunks == NULL)	×
241	return FALSE;
242
243	/* erase spare flash bank only if it is not empty */
244	if (!fu_dell_k2_rtshub_erase_spare_bank(self, error))	×
245	return FALSE;
246	fu_progress_step_done(progress);	×
247
248	/* write each block */
249	for (guint i = 0; i < fu_chunk_array_length(chunks); i++) {	×
250	g_autoptr(FuChunk) chk = NULL;	×
251
252	/* prepare chunk */
253	chk = fu_chunk_array_index(chunks, i, error);	×
254	if (chk == NULL)	×
255	return FALSE;
256
257	/* write chunk */
258	if (!fu_dell_k2_rtshub_write_flash(self,	×
259	fu_chunk_get_address(chk),
260	fu_chunk_get_data(chk),
261	fu_chunk_get_data_sz(chk),	×
262	error))
263	return FALSE;
264
265	/* update progress */
266	fu_progress_set_percentage_full(fu_progress_get_child(progress),	×
267	(gsize)i + 1,
268	(gsize)fu_chunk_array_length(chunks));	×
269	}
270	fu_progress_step_done(progress);	×
271
272	/* get device to authenticate the firmware */
273	if (!fu_dell_k2_rtshub_verify_update_fw(self, fu_progress_get_child(progress), error))	×
274	return FALSE;
275	fu_progress_step_done(progress);	×
276
277	/* success! */
278	return TRUE;	×
279	}
280
281	static gboolean
282	fu_dell_k2_rtshub_get_status(FuDevice device, GError *error)	×
283	{
284	FuDellK2RtsHub *self = FU_DELL_K2_RTSHUB(device);	×
285	FuRtshubHIDCmdBuffer cmd_buffer = {	×
286	.cmd = RTSHUB_CMD_READ_DATA,
287	.ext = RTSHUB_EXT_READ_STATUS,
288	.cmd_data0 = 0,
289	.cmd_data1 = 0,
290	.cmd_data2 = 0,
291	.cmd_data3 = 0,
292	.bufferlen = GUINT16_TO_LE(12),
293	};
294	guint8 buf[DELL_K2_RTSHUB_BUFFER_SIZE] = {0};	×
295	g_autofree gchar *version = NULL;	×
296
297	if (!fu_memcpy_safe(buf,	×
298	sizeof(buf),
299	0x0, /* dst */
300	(const guint8 *)&cmd_buffer,
301	sizeof(cmd_buffer),
302	0x0, /* src */
303	sizeof(cmd_buffer),
304	error))
305	return FALSE;
306	if (!fu_hid_device_set_report(FU_HID_DEVICE(self),	×
307	0x0,
308	buf,
309	sizeof(buf),
310	DELL_K2_RTSHUB_TIMEOUT,
311	FU_HID_DEVICE_FLAG_RETRY_FAILURE,
312	error))
313	return FALSE;
314	if (!fu_hid_device_get_report(FU_HID_DEVICE(self),	×
315	0x0,
316	buf,
317	sizeof(buf),
318	DELL_K2_RTSHUB_TIMEOUT,
319	FU_HID_DEVICE_FLAG_RETRY_FAILURE,
320	error))
321	return FALSE;
322
323	/* version: index 10, subversion: index 11 */
324	version = g_strdup_printf("%x.%x", buf[10], buf[11]);	×
325	fu_device_set_version(device, version);	×
326
327	/* dual bank capability */
328	self->dual_bank = (buf[13] & 0xf0) == 0x80;	×
329
330	/* authentication capability */
331	self->fw_auth = (buf[13] & 0x02) > 0;	×
332
333	return TRUE;	×
334	}
335
336	static gboolean
337	fu_dell_k2_rtshub_setup(FuDevice device, GError *error)	×
338	{
339	FuDellK2RtsHub *self = FU_DELL_K2_RTSHUB(device);	×
340
341	/* FuUsbDevice->setup */
342	if (!FU_DEVICE_CLASS(fu_dell_k2_rtshub_parent_class)->setup(device, error))	×
343	return FALSE;
344
345	if (!fu_dell_k2_rtshub_get_status(device, error))	×
346	return FALSE;
347
348	if (self->dual_bank)	×
349	fu_device_add_flag(device, FWUPD_DEVICE_FLAG_DUAL_IMAGE);	×
350
351	if (!self->fw_auth)	×
352	fu_device_set_update_error(device, "device does not support authentication");	×
353
354	return TRUE;
355	}
356
357	static gboolean
358	fu_dell_k2_rtshub_probe(FuDevice device, GError *error)	×
359	{
360	g_autofree const gchar *logical_id = NULL;	×
361	FuDellK2RtsHub *self = FU_DELL_K2_RTSHUB(device);	×
362
363	/* not interesting */
364	if (fu_device_get_vid(device) != DELL_VID) {	×
365	g_set_error(error,	×
366	FWUPD_ERROR,
367	FWUPD_ERROR_NOT_SUPPORTED,
368	"device vid not dell, expected: 0x%04x, got: 0x%04x",
369	(guint)DELL_VID,
370	fu_device_get_vid(device));	×
371	return FALSE;	×
372	}
373
374	/* caring for my family back home after fw reset */
375	switch (fu_device_get_pid(device)) {	×
376	case DELL_K2_USB_RTS5480_GEN1_PID:	×
377	fu_device_set_name(device, "RTS5480 Gen 1 USB Hub");	×
378	break;	×
379	case DELL_K2_USB_RTS5480_GEN2_PID:	×
380	fu_device_set_name(device, "RTS5480 Gen 2 USB Hub");	×
381	break;	×
382	case DELL_K2_USB_RTS5485_GEN2_PID:	×
383	fu_device_set_name(device, "RTS5485 Gen 2 USB Hub");	×
384	break;	×
385	default:	×
386	g_set_error(error,	×
387	FWUPD_ERROR,
388	FWUPD_ERROR_NOT_SUPPORTED,
389	"device pid '%04x' is not supported",
390	fu_device_get_pid(device));	×
391	return FALSE;	×
392	}
393
394	/* build logical id */
395	logical_id = g_strdup_printf("RTSHUB_%04X", fu_device_get_pid(device));	×
396	fu_device_set_logical_id(device, logical_id);	×
397
398	/* build instance id */
399	fu_device_add_instance_u8(device, "DOCKTYPE", self->dock_type);	×
400	fu_device_build_instance_id(device, error, "USB", "VID", "PID", "DOCKTYPE", NULL);	×
401	return TRUE;	×
402	}
403
404	static gboolean
405	fu_dell_k2_rtshub_open(FuDevice device, GError *error)	×
406	{
407	FuDevice *parent = fu_device_get_parent(device);	×
408
409	if (!FU_DEVICE_CLASS(fu_dell_k2_rtshub_parent_class)->open(device, error))	×
410	return FALSE;
411
412	if (parent != NULL)	×
413	return fu_device_open(parent, error);	×
414	return TRUE;
415	}
416
417	static void
418	fu_dell_k2_rtshub_set_progress(FuDevice self, FuProgress progress)	×
419	{
420	fu_progress_set_id(progress, G_STRLOC);	×
421	fu_progress_add_flag(progress, FU_PROGRESS_FLAG_GUESSED);	×
422	fu_progress_add_step(progress, FWUPD_STATUS_DEVICE_RESTART, 0, "detach");	×
423	fu_progress_add_step(progress, FWUPD_STATUS_DEVICE_WRITE, 100, "write");	×
424	fu_progress_add_step(progress, FWUPD_STATUS_DEVICE_RESTART, 0, "attach");	×
425	fu_progress_add_step(progress, FWUPD_STATUS_DEVICE_BUSY, 0, "reload");	×
426	}	×
427
428	static void
429	fu_dell_k2_rtshub_init(FuDellK2RtsHub *self)	×
430	{
431	fu_device_add_protocol(FU_DEVICE(self), "com.dell.k2");	×
432	fu_device_add_icon(FU_DEVICE(self), "dock-usb");	×
433	fu_device_add_flag(FU_DEVICE(self), FWUPD_DEVICE_FLAG_UPDATABLE);	×
434	fu_device_add_flag(FU_DEVICE(self), FWUPD_DEVICE_FLAG_SIGNED_PAYLOAD);	×
NEW 435	fu_device_add_flag(FU_DEVICE(self), FWUPD_DEVICE_FLAG_INSTALL_SKIP_VERSION_CHECK);	×
436	fu_device_add_private_flag(FU_DEVICE(self), FU_DEVICE_PRIVATE_FLAG_SKIPS_RESTART);	×
437	fu_device_add_private_flag(FU_DEVICE(self), FU_DEVICE_PRIVATE_FLAG_EXPLICIT_ORDER);	×
438	fu_device_add_private_flag(FU_DEVICE(self), FU_DEVICE_PRIVATE_FLAG_RETRY_OPEN);	×
439	fu_device_set_version_format(FU_DEVICE(self), FWUPD_VERSION_FORMAT_PAIR);	×
440	fu_device_set_firmware_gtype(FU_DEVICE(self), FU_TYPE_DELL_K2_RTSHUB_FIRMWARE);	×
441	fu_device_retry_set_delay(FU_DEVICE(self), 1000);	×
442	}	×
443
444	static void
445	fu_dell_k2_rtshub_class_init(FuDellK2RtsHubClass *klass)	×
446	{
447	FuDeviceClass *device_class = FU_DEVICE_CLASS(klass);	×
448	device_class->to_string = fu_dell_k2_rtshub_to_string;	×
449	device_class->setup = fu_dell_k2_rtshub_setup;	×
450	device_class->probe = fu_dell_k2_rtshub_probe;	×
451	device_class->write_firmware = fu_dell_k2_rtshub_write_firmware;	×
452	device_class->set_progress = fu_dell_k2_rtshub_set_progress;	×
453	device_class->open = fu_dell_k2_rtshub_open;	×
454	}
455
456	FuDellK2RtsHub *
457	fu_dell_k2_rtshub_new(FuUsbDevice *device, FuDellK2BaseType dock_type)	×
458	{
459	FuDellK2RtsHub *self = g_object_new(FU_TYPE_DELL_K2_RTSHUB, NULL);	×
460
461	fu_device_incorporate(FU_DEVICE(self), FU_DEVICE(device), FU_DEVICE_INCORPORATE_FLAG_ALL);	×
462	self->dock_type = dock_type;	×
463	return self;	×
464	}

fwupd / fwupd / 11622366407

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