11245171714

Committed 08 Oct 2024 11:09PM UTC coverage: 49.025% (-0.02%) from 49.048%

Build # 11245171714

Build Type

push

github

Committed by

web-flow

Commit Message

Initial version, leverage rust for hid transfer (#7757)

* Leverage rust for hid transfer

* WIP

* Incorporated code review feedback

* Incorporated code review feedback

* logitech-tap: Leverage rust for hid transfer

Run Details

19445 of 35473 branches covered (54.82%)

Branch coverage included in aggregate %.

0 of 46 new or added lines in 1 file covered. (0.0%)

30 existing lines in 6 files now uncovered.

58466 of 123448 relevant lines covered (47.36%)

20129.72 hits per line

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

1.37

/plugins/logitech-tap/fu-logitech-tap-sensor-device.c

/*
 * Copyright 2023 Logitech, Inc.
 *
 * SPDX-License-Identifier: LGPL-2.1-or-later
 */

#include "config.h"

#include <linux/types.h>
#include <linux/usb/video.h>
#include <linux/uvcvideo.h>
#ifdef HAVE_IOCTL_H
#include <linux/hidraw.h>
#include <sys/ioctl.h>
#endif

#include <string.h>

#include "fu-logitech-tap-sensor-device.h"
#include "fu-logitech-tap-struct.h"

#define FU_LOGITECH_TAP_SENSOR_DEVICE_IOCTL_TIMEOUT 50000 /* ms */

#ifndef HIDIOCGINPUT
#define HIDIOCGINPUT(len) _IOC(_IOC_READ, 'H', 0x0A, len)
#endif

const guint kLogiDefaultSensorSleepIntervalMs = 50;

struct _FuLogitechTapSensorDevice {
        FuHidrawDevice parent_instance;
};

G_DEFINE_TYPE(FuLogitechTapSensorDevice, fu_logitech_tap_sensor_device, FU_TYPE_HIDRAW_DEVICE)

static gboolean
fu_logitech_tap_sensor_device_get_feature(FuLogitechTapSensorDevice *self,
                                          guint8 *data,
                                          guint datasz,
                                          GError **error)
{
        g_autoptr(GError) error_local = NULL;

        /* try HIDIOCGINPUT request in case of failure */
        if (!fu_hidraw_device_get_feature(FU_HIDRAW_DEVICE(self),
                                          data,
                                          datasz,
                                          FU_UDEV_DEVICE_IOCTL_FLAG_RETRY,
                                          &error_local)) {
                g_debug("failed to send get request, retrying: %s", error_local->message);
                if (!fu_udev_device_ioctl(FU_UDEV_DEVICE(self),
                                          HIDIOCGINPUT(datasz),
                                          data,
                                          datasz,
                                          NULL,
                                          FU_LOGITECH_TAP_SENSOR_DEVICE_IOCTL_TIMEOUT,
                                          FU_UDEV_DEVICE_IOCTL_FLAG_RETRY,
                                          error))
                        return FALSE;
        }

        /* success */
        return TRUE;
}

static gboolean
fu_logitech_tap_sensor_device_enable_tde(FuDevice *device, GError **error)
{
        FuLogitechTapSensorDevice *self = FU_LOGITECH_TAP_SENSOR_DEVICE(device);
        g_autoptr(FuStructLogitechTapSensorHidReq) st = fu_struct_logitech_tap_sensor_hid_req_new();

        fu_struct_logitech_tap_sensor_hid_req_set_cmd(st, FU_LOGITECH_TAP_SENSOR_HID_SET_CMD_TDE);
        fu_struct_logitech_tap_sensor_hid_req_set_payload_byte1(
            st,
            FU_LOGITECH_TAP_SENSOR_HID_TDE_MODE_SELECTOR);
        fu_struct_logitech_tap_sensor_hid_req_set_payload_byte2(
            st,
            FU_LOGITECH_TAP_SENSOR_HID_TDE_MODE_ENABLE);

        return fu_hidraw_device_set_feature(FU_HIDRAW_DEVICE(self),
                                            st->data,
                                            st->len,
                                            FU_UDEV_DEVICE_IOCTL_FLAG_RETRY,
                                            error);
}

static gboolean
fu_logitech_tap_sensor_device_disable_tde(FuDevice *device, GError **error)
{
        FuLogitechTapSensorDevice *self = FU_LOGITECH_TAP_SENSOR_DEVICE(device);
        g_autoptr(FuStructLogitechTapSensorHidReq) st = fu_struct_logitech_tap_sensor_hid_req_new();

        fu_struct_logitech_tap_sensor_hid_req_set_cmd(st, FU_LOGITECH_TAP_SENSOR_HID_SET_CMD_TDE);
        fu_struct_logitech_tap_sensor_hid_req_set_payload_byte1(
            st,
            FU_LOGITECH_TAP_SENSOR_HID_TDE_MODE_SELECTOR);
        fu_struct_logitech_tap_sensor_hid_req_set_payload_byte2(
            st,
            FU_LOGITECH_TAP_SENSOR_HID_TDE_MODE_DISABLE);

        return fu_hidraw_device_set_feature(FU_HIDRAW_DEVICE(self),
                                            st->data,
                                            st->len,
                                            FU_UDEV_DEVICE_IOCTL_FLAG_RETRY,
                                            error);
}

gboolean
fu_logitech_tap_sensor_device_reboot_device(FuLogitechTapSensorDevice *self, GError **error)
{
        g_autoptr(FuDeviceLocker) locker = NULL;
        g_autoptr(FuProgress) progress = fu_progress_new(G_STRLOC);
        g_autoptr(FuStructLogitechTapSensorHidReq) st = fu_struct_logitech_tap_sensor_hid_req_new();

        /* progress */
        fu_progress_set_id(progress, G_STRLOC);
        fu_progress_add_step(progress, FWUPD_STATUS_DEVICE_RESTART, 100, "attach");
        fu_progress_set_status(progress, FWUPD_STATUS_DEVICE_RESTART);

        /* need to reopen the device, as at composite_cleanup time, device is already closed */
        if (!fu_device_open(FU_DEVICE(self), error))
                return FALSE;

        /* enable/disable TDE mode */
        locker =
            fu_device_locker_new_full(FU_DEVICE(self),
                                      (FuDeviceLockerFunc)fu_logitech_tap_sensor_device_enable_tde,
                                      (FuDeviceLockerFunc)fu_logitech_tap_sensor_device_disable_tde,
                                      error);
        if (locker == NULL)
                return FALSE;

        /* setup HID report for power cycle */
        fu_struct_logitech_tap_sensor_hid_req_set_cmd(st,
                                                      FU_LOGITECH_TAP_SENSOR_HID_SET_CMD_REBOOT);
        fu_struct_logitech_tap_sensor_hid_req_set_payload_byte1(
            st,
            FU_LOGITECH_TAP_SENSOR_HID_REBOOT_PIN_CLR);
        fu_struct_logitech_tap_sensor_hid_req_set_payload_byte2(
            st,
            FU_LOGITECH_TAP_SENSOR_HID_REBOOT_PWR);
        if (!fu_hidraw_device_set_feature(FU_HIDRAW_DEVICE(self),
                                          st->data,
                                          st->len,
                                          FU_UDEV_DEVICE_IOCTL_FLAG_RETRY,
                                          error))
                return FALSE;

        fu_struct_logitech_tap_sensor_hid_req_set_payload_byte2(
            st,
            FU_LOGITECH_TAP_SENSOR_HID_REBOOT_RST);
        if (!fu_hidraw_device_set_feature(FU_HIDRAW_DEVICE(self),
                                          st->data,
                                          st->len,
                                          FU_UDEV_DEVICE_IOCTL_FLAG_RETRY,
                                          error))
                return FALSE;

        fu_device_sleep(FU_DEVICE(self), 2000); /* 2 sec */

        fu_struct_logitech_tap_sensor_hid_req_set_payload_byte1(
            st,
            FU_LOGITECH_TAP_SENSOR_HID_REBOOT_PIN_SET);
        fu_struct_logitech_tap_sensor_hid_req_set_payload_byte2(
            st,
            FU_LOGITECH_TAP_SENSOR_HID_REBOOT_PWR);
        if (!fu_hidraw_device_set_feature(FU_HIDRAW_DEVICE(self),
                                          st->data,
                                          st->len,
                                          FU_UDEV_DEVICE_IOCTL_FLAG_RETRY,
                                          error))
                return FALSE;

        fu_device_sleep(FU_DEVICE(self), 2000); /* 2 sec */

        fu_struct_logitech_tap_sensor_hid_req_set_payload_byte2(
            st,
            FU_LOGITECH_TAP_SENSOR_HID_REBOOT_RST);
        if (!fu_hidraw_device_set_feature(FU_HIDRAW_DEVICE(self),
                                          st->data,
                                          st->len,
                                          FU_UDEV_DEVICE_IOCTL_FLAG_RETRY,
                                          error))
                return FALSE;

        fu_progress_step_done(progress);

        /* success */
        return TRUE;
}

static gboolean
fu_logitech_tap_sensor_device_set_version(FuLogitechTapSensorDevice *self, GError **error)
{
        guint32 version = 0;
        g_autoptr(FuStructLogitechTapSensorHidReq) st_req =
            fu_struct_logitech_tap_sensor_hid_req_new();
        g_autoptr(FuStructLogitechTapSensorHidRes) st_res =
            fu_struct_logitech_tap_sensor_hid_res_new();

        fu_struct_logitech_tap_sensor_hid_req_set_cmd(st_req,
                                                      FU_LOGITECH_TAP_SENSOR_HID_SET_CMD_VERSION);
        fu_struct_logitech_tap_sensor_hid_req_set_payload_byte1(
            st_req,
            FU_LOGITECH_TAP_SENSOR_HID_COLOSSUS_APP_GET_VERSION);
        fu_struct_logitech_tap_sensor_hid_res_set_cmd(st_res,
                                                      FU_LOGITECH_TAP_SENSOR_HID_GET_CMD_VERSION);
        /* setup HID report to query current device version */
        if (!fu_hidraw_device_set_feature(FU_HIDRAW_DEVICE(self),
                                          st_req->data,
                                          st_req->len,
                                          FU_UDEV_DEVICE_IOCTL_FLAG_RETRY,
                                          error))
                return FALSE;
        if (!fu_logitech_tap_sensor_device_get_feature(self,
                                                       (guint8 *)st_res->data,
                                                       st_res->len,
                                                       error))
                return FALSE;

        /* MinorVersion byte 3, MajorVersion byte 4, BuildVersion byte 2 & 1 */
        if (!fu_memread_uint32_safe((guint8 *)st_res->data,
                                    st_res->len,
                                    0x01,
                                    &version,
                                    G_LITTLE_ENDIAN,
                                    error))
                return FALSE;
        fu_device_set_version_raw(FU_DEVICE(self), version);

        /* success */
        return TRUE;
}

static gboolean
fu_logitech_tap_sensor_device_set_serial(FuLogitechTapSensorDevice *self, GError **error)
{
        g_autoptr(FuDeviceLocker) locker = NULL;
        g_autoptr(GString) serial_number = g_string_new(NULL);
        g_autoptr(FuStructLogitechTapSensorHidReq) st_req =
            fu_struct_logitech_tap_sensor_hid_req_new();

        fu_struct_logitech_tap_sensor_hid_req_set_cmd(
            st_req,
            FU_LOGITECH_TAP_SENSOR_HID_SET_CMD_SERIAL_NUMBER);
        fu_struct_logitech_tap_sensor_hid_req_set_payload_byte1(
            st_req,
            FU_LOGITECH_TAP_SENSOR_HID_SERIAL_NUMBER_SET_REPORT_BYTE1);
        fu_struct_logitech_tap_sensor_hid_req_set_payload_byte2(
            st_req,
            FU_LOGITECH_TAP_SENSOR_HID_SERIAL_NUMBER_SET_REPORT_BYTE2);
        fu_struct_logitech_tap_sensor_hid_req_set_payload_byte3(
            st_req,
            FU_LOGITECH_TAP_SENSOR_HID_SERIAL_NUMBER_SET_REPORT_BYTE3);
        fu_struct_logitech_tap_sensor_hid_req_set_payload_byte4(
            st_req,
            FU_LOGITECH_TAP_SENSOR_HID_SERIAL_NUMBER_SET_REPORT_BYTE4);

        /* enable/disable TDE mode */
        locker =
            fu_device_locker_new_full(FU_DEVICE(self),
                                      (FuDeviceLockerFunc)fu_logitech_tap_sensor_device_enable_tde,
                                      (FuDeviceLockerFunc)fu_logitech_tap_sensor_device_disable_tde,
                                      error);
        if (locker == NULL)
                return FALSE;

        /* setup HID report for serial number */
        if (!fu_hidraw_device_set_feature(FU_HIDRAW_DEVICE(self),
                                          st_req->data,
                                          st_req->len,
                                          FU_UDEV_DEVICE_IOCTL_FLAG_RETRY,
                                          error))
                return FALSE;
        fu_device_sleep(FU_DEVICE(self), kLogiDefaultSensorSleepIntervalMs); /* 50 ms */
        /* serial number is a 12-byte-string that is stored in MCU  */
        /* each get request fetches 1 word (4 bytes), so iterate 3 times */
        for (int index = 1; index <= 3; index++) {
                g_autoptr(FuStructLogitechTapSensorHidRes) st_res =
                    fu_struct_logitech_tap_sensor_hid_res_new();

                fu_struct_logitech_tap_sensor_hid_res_set_cmd(
                    st_res,
                    FU_LOGITECH_TAP_SENSOR_HID_GET_CMD_SERIAL_NUMBER);

                if (!fu_logitech_tap_sensor_device_get_feature(self,
                                                               (guint8 *)st_res->data,
                                                               st_res->len,
                                                               error))
                        return FALSE;
                g_string_append_printf(serial_number,
                                       "%c%c%c%c",
                                       st_res->data[1],
                                       st_res->data[2],
                                       st_res->data[3],
                                       st_res->data[4]);
        }
        fu_device_set_serial(FU_DEVICE(self), serial_number->str);

        /* success */
        return TRUE;
}

static gboolean
fu_logitech_tap_sensor_device_setup(FuDevice *device, GError **error)
{
        FuLogitechTapSensorDevice *self = FU_LOGITECH_TAP_SENSOR_DEVICE(device);

        if (!fu_logitech_tap_sensor_device_set_version(self, error))
                return FALSE;
        if (!fu_logitech_tap_sensor_device_set_serial(self, error))
                return FALSE;
        return TRUE;
}

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

static gchar *
fu_logitech_tap_sensor_device_convert_version(FuDevice *device, guint64 version_raw)
{
        return fu_version_from_uint32(version_raw, fu_device_get_version_format(device));
}

static void
fu_logitech_tap_sensor_device_init(FuLogitechTapSensorDevice *self)
{
        fu_device_add_protocol(FU_DEVICE(self), "com.logitech.hardware.tap");
        fu_device_set_version_format(FU_DEVICE(self), FWUPD_VERSION_FORMAT_TRIPLET);
        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_retry_set_delay(FU_DEVICE(self), 1000);
        fu_udev_device_add_open_flag(FU_UDEV_DEVICE(self), FU_IO_CHANNEL_OPEN_FLAG_READ);
        fu_udev_device_add_open_flag(FU_UDEV_DEVICE(self), FU_IO_CHANNEL_OPEN_FLAG_WRITE);
        fu_udev_device_add_open_flag(FU_UDEV_DEVICE(self), FU_IO_CHANNEL_OPEN_FLAG_NONBLOCK);
}

static void
fu_logitech_tap_sensor_device_class_init(FuLogitechTapSensorDeviceClass *klass)
{
        FuDeviceClass *device_class = FU_DEVICE_CLASS(klass);
        device_class->setup = fu_logitech_tap_sensor_device_setup;
        device_class->set_progress = fu_logitech_tap_sensor_device_set_progress;
        device_class->convert_version = fu_logitech_tap_sensor_device_convert_version;
}

1	/*
2	* Copyright 2023 Logitech, Inc.
3	*
4	* SPDX-License-Identifier: LGPL-2.1-or-later
5	*/
6
7	#include "config.h"
8
9	#include <linux/types.h>
10	#include <linux/usb/video.h>
11	#include <linux/uvcvideo.h>
12	#ifdef HAVE_IOCTL_H
13	#include <linux/hidraw.h>
14	#include <sys/ioctl.h>
15	#endif
16
17	#include <string.h>
18
19	#include "fu-logitech-tap-sensor-device.h"
20	#include "fu-logitech-tap-struct.h"
21
22	#define FU_LOGITECH_TAP_SENSOR_DEVICE_IOCTL_TIMEOUT 50000 /* ms */
23
24	#ifndef HIDIOCGINPUT
25	#define HIDIOCGINPUT(len) _IOC(_IOC_READ, 'H', 0x0A, len)
26	#endif
27
28	const guint kLogiDefaultSensorSleepIntervalMs = 50;
29
30	struct _FuLogitechTapSensorDevice {
31	FuHidrawDevice parent_instance;
32	};
33
34	G_DEFINE_TYPE(FuLogitechTapSensorDevice, fu_logitech_tap_sensor_device, FU_TYPE_HIDRAW_DEVICE)	208✔
35
36	static gboolean
37	fu_logitech_tap_sensor_device_get_feature(FuLogitechTapSensorDevice *self,	×
38	guint8 *data,
39	guint datasz,
40	GError **error)
41	{
42	g_autoptr(GError) error_local = NULL;	×
43
44	/* try HIDIOCGINPUT request in case of failure */
45	if (!fu_hidraw_device_get_feature(FU_HIDRAW_DEVICE(self),	×
46	data,
47	datasz,
48	FU_UDEV_DEVICE_IOCTL_FLAG_RETRY,
49	&error_local)) {
50	g_debug("failed to send get request, retrying: %s", error_local->message);	×
51	if (!fu_udev_device_ioctl(FU_UDEV_DEVICE(self),	×
52	HIDIOCGINPUT(datasz),	×
53	data,
54	datasz,
55	NULL,
56	FU_LOGITECH_TAP_SENSOR_DEVICE_IOCTL_TIMEOUT,
57	FU_UDEV_DEVICE_IOCTL_FLAG_RETRY,
58	error))
59	return FALSE;
60	}
61
62	/* success */
63	return TRUE;
64	}
65
66	static gboolean
67	fu_logitech_tap_sensor_device_enable_tde(FuDevice device, GError *error)	×
68	{
69	FuLogitechTapSensorDevice *self = FU_LOGITECH_TAP_SENSOR_DEVICE(device);	×
NEW 70	g_autoptr(FuStructLogitechTapSensorHidReq) st = fu_struct_logitech_tap_sensor_hid_req_new();	×
71
NEW 72	fu_struct_logitech_tap_sensor_hid_req_set_cmd(st, FU_LOGITECH_TAP_SENSOR_HID_SET_CMD_TDE);	×
NEW 73	fu_struct_logitech_tap_sensor_hid_req_set_payload_byte1(	×
74	st,
75	FU_LOGITECH_TAP_SENSOR_HID_TDE_MODE_SELECTOR);
NEW 76	fu_struct_logitech_tap_sensor_hid_req_set_payload_byte2(	×
77	st,
78	FU_LOGITECH_TAP_SENSOR_HID_TDE_MODE_ENABLE);
79
UNCOV 80	return fu_hidraw_device_set_feature(FU_HIDRAW_DEVICE(self),	×
NEW 81	st->data,	×
82	st->len,
83	FU_UDEV_DEVICE_IOCTL_FLAG_RETRY,
84	error);
85	}
86
87	static gboolean
88	fu_logitech_tap_sensor_device_disable_tde(FuDevice device, GError *error)	×
89	{
90	FuLogitechTapSensorDevice *self = FU_LOGITECH_TAP_SENSOR_DEVICE(device);	×
NEW 91	g_autoptr(FuStructLogitechTapSensorHidReq) st = fu_struct_logitech_tap_sensor_hid_req_new();	×
92
NEW 93	fu_struct_logitech_tap_sensor_hid_req_set_cmd(st, FU_LOGITECH_TAP_SENSOR_HID_SET_CMD_TDE);	×
NEW 94	fu_struct_logitech_tap_sensor_hid_req_set_payload_byte1(	×
95	st,
96	FU_LOGITECH_TAP_SENSOR_HID_TDE_MODE_SELECTOR);
NEW 97	fu_struct_logitech_tap_sensor_hid_req_set_payload_byte2(	×
98	st,
99	FU_LOGITECH_TAP_SENSOR_HID_TDE_MODE_DISABLE);
100
UNCOV 101	return fu_hidraw_device_set_feature(FU_HIDRAW_DEVICE(self),	×
NEW 102	st->data,	×
103	st->len,
104	FU_UDEV_DEVICE_IOCTL_FLAG_RETRY,
105	error);
106	}
107
108	gboolean
109	fu_logitech_tap_sensor_device_reboot_device(FuLogitechTapSensorDevice self, GError *error)	×
110	{
111	g_autoptr(FuDeviceLocker) locker = NULL;	×
112	g_autoptr(FuProgress) progress = fu_progress_new(G_STRLOC);	×
NEW 113	g_autoptr(FuStructLogitechTapSensorHidReq) st = fu_struct_logitech_tap_sensor_hid_req_new();	×
114
115	/* progress */
116	fu_progress_set_id(progress, G_STRLOC);	×
117	fu_progress_add_step(progress, FWUPD_STATUS_DEVICE_RESTART, 100, "attach");	×
118	fu_progress_set_status(progress, FWUPD_STATUS_DEVICE_RESTART);	×
119
120	/* need to reopen the device, as at composite_cleanup time, device is already closed */
121	if (!fu_device_open(FU_DEVICE(self), error))	×
122	return FALSE;
123
124	/* enable/disable TDE mode */
125	locker =	×
126	fu_device_locker_new_full(FU_DEVICE(self),	×
127	(FuDeviceLockerFunc)fu_logitech_tap_sensor_device_enable_tde,
128	(FuDeviceLockerFunc)fu_logitech_tap_sensor_device_disable_tde,
129	error);
130	if (locker == NULL)	×
131	return FALSE;
132
133	/* setup HID report for power cycle */
NEW 134	fu_struct_logitech_tap_sensor_hid_req_set_cmd(st,	×
135	FU_LOGITECH_TAP_SENSOR_HID_SET_CMD_REBOOT);
NEW 136	fu_struct_logitech_tap_sensor_hid_req_set_payload_byte1(	×
137	st,
138	FU_LOGITECH_TAP_SENSOR_HID_REBOOT_PIN_CLR);
NEW 139	fu_struct_logitech_tap_sensor_hid_req_set_payload_byte2(	×
140	st,
141	FU_LOGITECH_TAP_SENSOR_HID_REBOOT_PWR);
UNCOV 142	if (!fu_hidraw_device_set_feature(FU_HIDRAW_DEVICE(self),	×
NEW 143	st->data,	×
144	st->len,
145	FU_UDEV_DEVICE_IOCTL_FLAG_RETRY,
146	error))
147	return FALSE;
148
NEW 149	fu_struct_logitech_tap_sensor_hid_req_set_payload_byte2(	×
150	st,
151	FU_LOGITECH_TAP_SENSOR_HID_REBOOT_RST);
UNCOV 152	if (!fu_hidraw_device_set_feature(FU_HIDRAW_DEVICE(self),	×
NEW 153	st->data,	×
154	st->len,
155	FU_UDEV_DEVICE_IOCTL_FLAG_RETRY,
156	error))
157	return FALSE;
158
159	fu_device_sleep(FU_DEVICE(self), 2000); /* 2 sec */	×
160
NEW 161	fu_struct_logitech_tap_sensor_hid_req_set_payload_byte1(	×
162	st,
163	FU_LOGITECH_TAP_SENSOR_HID_REBOOT_PIN_SET);
NEW 164	fu_struct_logitech_tap_sensor_hid_req_set_payload_byte2(	×
165	st,
166	FU_LOGITECH_TAP_SENSOR_HID_REBOOT_PWR);
UNCOV 167	if (!fu_hidraw_device_set_feature(FU_HIDRAW_DEVICE(self),	×
NEW 168	st->data,	×
169	st->len,
170	FU_UDEV_DEVICE_IOCTL_FLAG_RETRY,
171	error))
172	return FALSE;
173
174	fu_device_sleep(FU_DEVICE(self), 2000); /* 2 sec */	×
175
NEW 176	fu_struct_logitech_tap_sensor_hid_req_set_payload_byte2(	×
177	st,
178	FU_LOGITECH_TAP_SENSOR_HID_REBOOT_RST);
UNCOV 179	if (!fu_hidraw_device_set_feature(FU_HIDRAW_DEVICE(self),	×
NEW 180	st->data,	×
181	st->len,
182	FU_UDEV_DEVICE_IOCTL_FLAG_RETRY,
183	error))
184	return FALSE;
185
186	fu_progress_step_done(progress);	×
187
188	/* success */
189	return TRUE;	×
190	}
191
192	static gboolean
193	fu_logitech_tap_sensor_device_set_version(FuLogitechTapSensorDevice self, GError *error)	×
194	{
195	guint32 version = 0;	×
NEW 196	g_autoptr(FuStructLogitechTapSensorHidReq) st_req =	×
NEW 197	fu_struct_logitech_tap_sensor_hid_req_new();	×
NEW 198	g_autoptr(FuStructLogitechTapSensorHidRes) st_res =	×
NEW 199	fu_struct_logitech_tap_sensor_hid_res_new();	×
200
NEW 201	fu_struct_logitech_tap_sensor_hid_req_set_cmd(st_req,	×
202	FU_LOGITECH_TAP_SENSOR_HID_SET_CMD_VERSION);
NEW 203	fu_struct_logitech_tap_sensor_hid_req_set_payload_byte1(	×
204	st_req,
205	FU_LOGITECH_TAP_SENSOR_HID_COLOSSUS_APP_GET_VERSION);
NEW 206	fu_struct_logitech_tap_sensor_hid_res_set_cmd(st_res,	×
207	FU_LOGITECH_TAP_SENSOR_HID_GET_CMD_VERSION);
208	/* setup HID report to query current device version */
209	if (!fu_hidraw_device_set_feature(FU_HIDRAW_DEVICE(self),	×
NEW 210	st_req->data,	×
211	st_req->len,
212	FU_UDEV_DEVICE_IOCTL_FLAG_RETRY,
213	error))
214	return FALSE;
215	if (!fu_logitech_tap_sensor_device_get_feature(self,	×
216	(guint8 *)st_res->data,
217	st_res->len,
218	error))
219	return FALSE;
220
221	/* MinorVersion byte 3, MajorVersion byte 4, BuildVersion byte 2 & 1 */
NEW 222	if (!fu_memread_uint32_safe((guint8 *)st_res->data,	×
223	st_res->len,
224	0x01,
225	&version,
226	G_LITTLE_ENDIAN,
227	error))
228	return FALSE;
229	fu_device_set_version_raw(FU_DEVICE(self), version);	×
230
231	/* success */
232	return TRUE;	×
233	}
234
235	static gboolean
236	fu_logitech_tap_sensor_device_set_serial(FuLogitechTapSensorDevice self, GError *error)	×
237	{
238	g_autoptr(FuDeviceLocker) locker = NULL;	×
239	g_autoptr(GString) serial_number = g_string_new(NULL);	×
NEW 240	g_autoptr(FuStructLogitechTapSensorHidReq) st_req =	×
NEW 241	fu_struct_logitech_tap_sensor_hid_req_new();	×
242
NEW 243	fu_struct_logitech_tap_sensor_hid_req_set_cmd(	×
244	st_req,
245	FU_LOGITECH_TAP_SENSOR_HID_SET_CMD_SERIAL_NUMBER);
NEW 246	fu_struct_logitech_tap_sensor_hid_req_set_payload_byte1(	×
247	st_req,
248	FU_LOGITECH_TAP_SENSOR_HID_SERIAL_NUMBER_SET_REPORT_BYTE1);
NEW 249	fu_struct_logitech_tap_sensor_hid_req_set_payload_byte2(	×
250	st_req,
251	FU_LOGITECH_TAP_SENSOR_HID_SERIAL_NUMBER_SET_REPORT_BYTE2);
NEW 252	fu_struct_logitech_tap_sensor_hid_req_set_payload_byte3(	×
253	st_req,
254	FU_LOGITECH_TAP_SENSOR_HID_SERIAL_NUMBER_SET_REPORT_BYTE3);
NEW 255	fu_struct_logitech_tap_sensor_hid_req_set_payload_byte4(	×
256	st_req,
257	FU_LOGITECH_TAP_SENSOR_HID_SERIAL_NUMBER_SET_REPORT_BYTE4);
258
259	/* enable/disable TDE mode */
260	locker =	×
261	fu_device_locker_new_full(FU_DEVICE(self),	×
262	(FuDeviceLockerFunc)fu_logitech_tap_sensor_device_enable_tde,
263	(FuDeviceLockerFunc)fu_logitech_tap_sensor_device_disable_tde,
264	error);
265	if (locker == NULL)	×
266	return FALSE;
267
268	/* setup HID report for serial number */
269	if (!fu_hidraw_device_set_feature(FU_HIDRAW_DEVICE(self),	×
NEW 270	st_req->data,	×
271	st_req->len,
272	FU_UDEV_DEVICE_IOCTL_FLAG_RETRY,
273	error))
274	return FALSE;
275	fu_device_sleep(FU_DEVICE(self), kLogiDefaultSensorSleepIntervalMs); /* 50 ms */	×
276	/* serial number is a 12-byte-string that is stored in MCU */
277	/* each get request fetches 1 word (4 bytes), so iterate 3 times */
278	for (int index = 1; index <= 3; index++) {	×
NEW 279	g_autoptr(FuStructLogitechTapSensorHidRes) st_res =	×
NEW 280	fu_struct_logitech_tap_sensor_hid_res_new();	×
281
NEW 282	fu_struct_logitech_tap_sensor_hid_res_set_cmd(	×
283	st_res,
284	FU_LOGITECH_TAP_SENSOR_HID_GET_CMD_SERIAL_NUMBER);
285
UNCOV 286	if (!fu_logitech_tap_sensor_device_get_feature(self,	×
287	(guint8 *)st_res->data,
288	st_res->len,
289	error))
290	return FALSE;	×
291	g_string_append_printf(serial_number,	×
292	"%c%c%c%c",
NEW 293	st_res->data[1],	×
NEW 294	st_res->data[2],	×
NEW 295	st_res->data[3],	×
NEW 296	st_res->data[4]);	×
297	}
298	fu_device_set_serial(FU_DEVICE(self), serial_number->str);	×
299
300	/* success */
301	return TRUE;	×
302	}
303
304	static gboolean
305	fu_logitech_tap_sensor_device_setup(FuDevice device, GError *error)	×
306	{
307	FuLogitechTapSensorDevice *self = FU_LOGITECH_TAP_SENSOR_DEVICE(device);	×
308
UNCOV 309	if (!fu_logitech_tap_sensor_device_set_version(self, error))	×
310	return FALSE;
311	if (!fu_logitech_tap_sensor_device_set_serial(self, error))	×
312	return FALSE;
313	return TRUE;
314	}
315
316	static void
317	fu_logitech_tap_sensor_device_set_progress(FuDevice self, FuProgress progress)	×
318	{
319	fu_progress_set_id(progress, G_STRLOC);	×
320	fu_progress_add_step(progress, FWUPD_STATUS_DEVICE_RESTART, 0, "detach");	×
321	fu_progress_add_step(progress, FWUPD_STATUS_DEVICE_WRITE, 0, "write");	×
322	fu_progress_add_step(progress, FWUPD_STATUS_DEVICE_RESTART, 100, "attach");	×
323	fu_progress_add_step(progress, FWUPD_STATUS_DEVICE_BUSY, 0, "reload");	×
324	}	×
325
326	static gchar *
327	fu_logitech_tap_sensor_device_convert_version(FuDevice *device, guint64 version_raw)	×
328	{
329	return fu_version_from_uint32(version_raw, fu_device_get_version_format(device));	×
330	}
331
332	static void
333	fu_logitech_tap_sensor_device_init(FuLogitechTapSensorDevice *self)	×
334	{
335	fu_device_add_protocol(FU_DEVICE(self), "com.logitech.hardware.tap");	×
336	fu_device_set_version_format(FU_DEVICE(self), FWUPD_VERSION_FORMAT_TRIPLET);	×
337	fu_device_add_flag(FU_DEVICE(self), FWUPD_DEVICE_FLAG_UPDATABLE);	×
338	fu_device_add_flag(FU_DEVICE(self), FWUPD_DEVICE_FLAG_SIGNED_PAYLOAD);	×
339	fu_device_retry_set_delay(FU_DEVICE(self), 1000);	×
340	fu_udev_device_add_open_flag(FU_UDEV_DEVICE(self), FU_IO_CHANNEL_OPEN_FLAG_READ);	×
341	fu_udev_device_add_open_flag(FU_UDEV_DEVICE(self), FU_IO_CHANNEL_OPEN_FLAG_WRITE);	×
342	fu_udev_device_add_open_flag(FU_UDEV_DEVICE(self), FU_IO_CHANNEL_OPEN_FLAG_NONBLOCK);	×
343	}	×
344
345	static void
346	fu_logitech_tap_sensor_device_class_init(FuLogitechTapSensorDeviceClass *klass)	×
347	{
348	FuDeviceClass *device_class = FU_DEVICE_CLASS(klass);	×
349	device_class->setup = fu_logitech_tap_sensor_device_setup;	×
350	device_class->set_progress = fu_logitech_tap_sensor_device_set_progress;	×
351	device_class->convert_version = fu_logitech_tap_sensor_device_convert_version;	×
352	}

fwupd / fwupd / 11245171714

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