proxmox-mirrors/fwupd
1
0
Fork 0
mirror of https://git.proxmox.com/git/fwupd synced 2025-07-10 18:56:57 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

csr: Rename plugin to dfu-csr as it depends on the prefixed plugin

Browse Source
This commit is contained in:
Richard Hughes 2021-02-18 10:04:17 +00:00
parent d2130f73a3
commit 90254a5152
11 changed files with 111 additions and 111 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
contrib/fwupd.spec.in
View File

@ -409,7 +409,6 @@ done
%{_libdir}/fwupd-plugins-3/libfu_plugin_ccgx.so %{_libdir}/fwupd-plugins-3/libfu_plugin_ccgx.so
%{_libdir}/fwupd-plugins-3/libfu_plugin_colorhug.so %{_libdir}/fwupd-plugins-3/libfu_plugin_colorhug.so
%{_libdir}/fwupd-plugins-3/libfu_plugin_cros_ec.so %{_libdir}/fwupd-plugins-3/libfu_plugin_cros_ec.so
%{_libdir}/fwupd-plugins-3/libfu_plugin_csr.so
%{_libdir}/fwupd-plugins-3/libfu_plugin_cpu.so %{_libdir}/fwupd-plugins-3/libfu_plugin_cpu.so
%if 0%{?have_dell} %if 0%{?have_dell}
%{_libdir}/fwupd-plugins-3/libfu_plugin_dell.so %{_libdir}/fwupd-plugins-3/libfu_plugin_dell.so
@ -417,6 +416,7 @@ done
%endif %endif
%{_libdir}/fwupd-plugins-3/libfu_plugin_dell_dock.so %{_libdir}/fwupd-plugins-3/libfu_plugin_dell_dock.so
%{_libdir}/fwupd-plugins-3/libfu_plugin_dfu.so %{_libdir}/fwupd-plugins-3/libfu_plugin_dfu.so
%{_libdir}/fwupd-plugins-3/libfu_plugin_dfu_csr.so
%{_libdir}/fwupd-plugins-3/libfu_plugin_ebitdo.so %{_libdir}/fwupd-plugins-3/libfu_plugin_ebitdo.so
%{_libdir}/fwupd-plugins-3/libfu_plugin_elantp.so %{_libdir}/fwupd-plugins-3/libfu_plugin_elantp.so
%{_libdir}/fwupd-plugins-3/libfu_plugin_emmc.so %{_libdir}/fwupd-plugins-3/libfu_plugin_emmc.so

4
plugins/csr/README.md → plugins/dfu-csr/README.md
View File

@ -1,5 +1,5 @@
CSR Support DFU CSR Support
=========== ===============
Introduction Introduction
------------ ------------

0
plugins/csr/data/lsusb.txt → plugins/dfu-csr/data/lsusb.txt
View File

0
plugins/csr/data/upgrade.tdc.gz → plugins/dfu-csr/data/upgrade.tdc.gz
View File

4
plugins/csr/csr-aiaiai.quirk → plugins/dfu-csr/dfu-csr.quirk
View File

@ -1,5 +1,5 @@
[DeviceInstanceId=USB\VID_0A12&PID_1337] [DeviceInstanceId=USB\VID_0A12&PID_1337]
Plugin = csr Plugin = dfu_csr
Name = H05 Name = H05
Summary = Bluetooth Headphones Summary = Bluetooth Headphones
Icon = audio-headphones Icon = audio-headphones
@ -8,7 +8,7 @@ Vendor = AIAIAI
Version = 1.2 Version = 1.2
[DeviceInstanceId=USB\VID_0A12&PID_4004] [DeviceInstanceId=USB\VID_0A12&PID_4004]
Plugin = csr Plugin = dfu_csr
Name = H60 Name = H60
Summary = Bluetooth Headphones Summary = Bluetooth Headphones
Icon = audio-headphones Icon = audio-headphones

178
plugins/csr/fu-csr-device.c → plugins/dfu-csr/fu-dfu-csr-device.c
View File

@ -9,71 +9,71 @@
#include <string.h> #include <string.h>
#include "fu-chunk.h" #include "fu-chunk.h"
#include "fu-csr-device.h" #include "fu-dfu-csr-device.h"
#include "fu-dfu-firmware.h" #include "fu-dfu-firmware.h"
#include "dfu-common.h" #include "dfu-common.h"
/** /**
* FU_CSR_DEVICE_QUIRK_FLAG_REQUIRE_DELAY: * FU_DFU_CSR_DEVICE_QUIRK_FLAG_REQUIRE_DELAY:
* *
* Respect the write timeout value when performing actions. This is sometimes * Respect the write timeout value when performing actions. This is sometimes
* set to a huge amount of time, and so is not used by default. * set to a huge amount of time, and so is not used by default.
* *
* Since: 1.0.3 * Since: 1.0.3
*/ */
#define FU_CSR_DEVICE_FLAG_REQUIRE_DELAY "require-delay" #define FU_DFU_CSR_DEVICE_FLAG_REQUIRE_DELAY "require-delay"
typedef enum { typedef enum {
FU_CSR_DEVICE_QUIRK_NONE = 0, FU_DFU_CSR_DEVICE_QUIRK_NONE = 0,
FU_CSR_DEVICE_QUIRK_REQUIRE_DELAY = (1 << 0), FU_DFU_CSR_DEVICE_QUIRK_REQUIRE_DELAY = (1 << 0),
FU_CSR_DEVICE_QUIRK_LAST FU_DFU_CSR_DEVICE_QUIRK_LAST
} FuCsrDeviceQuirks; } FuDfuCsrDeviceQuirks;
struct _FuCsrDevice struct _FuDfuCsrDevice
{ {
FuHidDevice parent_instance; FuHidDevice parent_instance;
FuCsrDeviceQuirks quirks; FuDfuCsrDeviceQuirks quirks;
DfuState dfu_state; DfuState dfu_state;
guint32 dnload_timeout; guint32 dnload_timeout;
}; };
G_DEFINE_TYPE (FuCsrDevice, fu_csr_device, FU_TYPE_HID_DEVICE) G_DEFINE_TYPE (FuDfuCsrDevice, fu_dfu_csr_device, FU_TYPE_HID_DEVICE)
#define FU_CSR_REPORT_ID_COMMAND 0x01 #define FU_DFU_CSR_REPORT_ID_COMMAND 0x01
#define FU_CSR_REPORT_ID_STATUS 0x02 #define FU_DFU_CSR_REPORT_ID_STATUS 0x02
#define FU_CSR_REPORT_ID_CONTROL 0x03 #define FU_DFU_CSR_REPORT_ID_CONTROL 0x03
#define FU_CSR_COMMAND_HEADER_SIZE 6 /* bytes */ #define FU_DFU_CSR_COMMAND_HEADER_SIZE 6 /* bytes */
#define FU_CSR_COMMAND_UPGRADE 0x01 #define FU_DFU_CSR_COMMAND_UPGRADE 0x01
#define FU_CSR_STATUS_HEADER_SIZE 7 #define FU_DFU_CSR_STATUS_HEADER_SIZE 7
#define FU_CSR_CONTROL_HEADER_SIZE 2 /* bytes */ #define FU_DFU_CSR_CONTROL_HEADER_SIZE 2 /* bytes */
#define FU_CSR_CONTROL_CLEAR_STATUS 0x04 #define FU_DFU_CSR_CONTROL_CLEAR_STATUS 0x04
#define FU_CSR_CONTROL_RESET 0xff #define FU_DFU_CSR_CONTROL_RESET 0xff
/* maximum firmware packet, including the command header */ /* maximum firmware packet, including the command header */
#define FU_CSR_PACKET_DATA_SIZE 1023 /* bytes */ #define FU_DFU_CSR_PACKET_DATA_SIZE 1023 /* bytes */
#define FU_CSR_DEVICE_TIMEOUT 5000 /* ms */ #define FU_DFU_CSR_DEVICE_TIMEOUT 5000 /* ms */
static void static void
fu_csr_device_to_string (FuDevice *device, guint idt, GString *str) fu_dfu_csr_device_to_string (FuDevice *device, guint idt, GString *str)
{ {
FuCsrDevice *self = FU_CSR_DEVICE (device); FuDfuCsrDevice *self = FU_DFU_CSR_DEVICE (device);
fu_common_string_append_kv (str, idt, "State", dfu_state_to_string (self->dfu_state)); fu_common_string_append_kv (str, idt, "State", dfu_state_to_string (self->dfu_state));
fu_common_string_append_ku (str, idt, "DownloadTimeout", self->dnload_timeout); fu_common_string_append_ku (str, idt, "DownloadTimeout", self->dnload_timeout);
} }
static gboolean static gboolean
fu_csr_device_attach (FuDevice *device, GError **error) fu_dfu_csr_device_attach (FuDevice *device, GError **error)
{ {
guint8 buf[] = { FU_CSR_REPORT_ID_CONTROL, FU_CSR_CONTROL_RESET }; guint8 buf[] = { FU_DFU_CSR_REPORT_ID_CONTROL, FU_DFU_CSR_CONTROL_RESET };
if (!fu_hid_device_set_report (FU_HID_DEVICE (device), if (!fu_hid_device_set_report (FU_HID_DEVICE (device),
FU_CSR_REPORT_ID_CONTROL, FU_DFU_CSR_REPORT_ID_CONTROL,
buf, sizeof(buf), buf, sizeof(buf),
FU_CSR_DEVICE_TIMEOUT, FU_DFU_CSR_DEVICE_TIMEOUT,
FU_HID_DEVICE_FLAG_IS_FEATURE, FU_HID_DEVICE_FLAG_IS_FEATURE,
error)) { error)) {
g_prefix_error (error, "failed to attach: "); g_prefix_error (error, "failed to attach: ");
@ -83,15 +83,15 @@ fu_csr_device_attach (FuDevice *device, GError **error)
} }
static gboolean static gboolean
fu_csr_device_get_status (FuCsrDevice *self, GError **error) fu_dfu_csr_device_get_status (FuDfuCsrDevice *self, GError **error)
{ {
guint8 buf[64] = {0}; guint8 buf[64] = {0};
/* hit hardware */ /* hit hardware */
if (!fu_hid_device_get_report (FU_HID_DEVICE (self), if (!fu_hid_device_get_report (FU_HID_DEVICE (self),
FU_CSR_REPORT_ID_STATUS, FU_DFU_CSR_REPORT_ID_STATUS,
buf, sizeof(buf), buf, sizeof(buf),
FU_CSR_DEVICE_TIMEOUT, FU_DFU_CSR_DEVICE_TIMEOUT,
FU_HID_DEVICE_FLAG_ALLOW_TRUNC | FU_HID_DEVICE_FLAG_ALLOW_TRUNC |
FU_HID_DEVICE_FLAG_IS_FEATURE, FU_HID_DEVICE_FLAG_IS_FEATURE,
error)) { error)) {
@ -100,12 +100,12 @@ fu_csr_device_get_status (FuCsrDevice *self, GError **error)
} }
/* check packet */ /* check packet */
if (buf[0] != FU_CSR_REPORT_ID_STATUS) { if (buf[0] != FU_DFU_CSR_REPORT_ID_STATUS) {
g_set_error (error, g_set_error (error,
FWUPD_ERROR, FWUPD_ERROR,
FWUPD_ERROR_INTERNAL, FWUPD_ERROR_INTERNAL,
"GetStatus packet-id was %i expected %i", "GetStatus packet-id was %i expected %i",
buf[0], FU_CSR_REPORT_ID_STATUS); buf[0], FU_DFU_CSR_REPORT_ID_STATUS);
return FALSE; return FALSE;
} }
@ -119,22 +119,22 @@ fu_csr_device_get_status (FuCsrDevice *self, GError **error)
static gboolean static gboolean
fu_csr_device_clear_status (FuCsrDevice *self, GError **error) fu_dfu_csr_device_clear_status (FuDfuCsrDevice *self, GError **error)
{ {
guint8 buf[] = { FU_CSR_REPORT_ID_CONTROL, guint8 buf[] = { FU_DFU_CSR_REPORT_ID_CONTROL,
FU_CSR_CONTROL_CLEAR_STATUS }; FU_DFU_CSR_CONTROL_CLEAR_STATUS };
/* only clear the status if the state is error */ /* only clear the status if the state is error */
if (!fu_csr_device_get_status (self, error)) if (!fu_dfu_csr_device_get_status (self, error))
return FALSE; return FALSE;
if (self->dfu_state != DFU_STATE_DFU_ERROR) if (self->dfu_state != DFU_STATE_DFU_ERROR)
return TRUE; return TRUE;
/* hit hardware */ /* hit hardware */
if (!fu_hid_device_set_report (FU_HID_DEVICE (self), if (!fu_hid_device_set_report (FU_HID_DEVICE (self),
FU_CSR_REPORT_ID_CONTROL, FU_DFU_CSR_REPORT_ID_CONTROL,
buf, sizeof(buf), buf, sizeof(buf),
FU_CSR_DEVICE_TIMEOUT, FU_DFU_CSR_DEVICE_TIMEOUT,
FU_HID_DEVICE_FLAG_IS_FEATURE, FU_HID_DEVICE_FLAG_IS_FEATURE,
error)) { error)) {
g_prefix_error (error, "failed to ClearStatus: "); g_prefix_error (error, "failed to ClearStatus: ");
@ -142,20 +142,20 @@ fu_csr_device_clear_status (FuCsrDevice *self, GError **error)
} }
/* check the hardware again */ /* check the hardware again */
return fu_csr_device_get_status (self, error); return fu_dfu_csr_device_get_status (self, error);
} }
static GBytes * static GBytes *
fu_csr_device_upload_chunk (FuCsrDevice *self, GError **error) fu_dfu_csr_device_upload_chunk (FuDfuCsrDevice *self, GError **error)
{ {
guint16 data_sz; guint16 data_sz;
guint8 buf[64] = {0}; guint8 buf[64] = {0};
/* hit hardware */ /* hit hardware */
if (!fu_hid_device_get_report (FU_HID_DEVICE (self), if (!fu_hid_device_get_report (FU_HID_DEVICE (self),
FU_CSR_REPORT_ID_COMMAND, FU_DFU_CSR_REPORT_ID_COMMAND,
buf, sizeof(buf), buf, sizeof(buf),
FU_CSR_DEVICE_TIMEOUT, FU_DFU_CSR_DEVICE_TIMEOUT,
FU_HID_DEVICE_FLAG_ALLOW_TRUNC | FU_HID_DEVICE_FLAG_ALLOW_TRUNC |
FU_HID_DEVICE_FLAG_IS_FEATURE, FU_HID_DEVICE_FLAG_IS_FEATURE,
error)) { error)) {
@ -164,7 +164,7 @@ fu_csr_device_upload_chunk (FuCsrDevice *self, GError **error)
} }
/* check command byte */ /* check command byte */
if (buf[0] != FU_CSR_REPORT_ID_COMMAND) { if (buf[0] != FU_DFU_CSR_REPORT_ID_COMMAND) {
g_set_error (error, g_set_error (error,
FWUPD_ERROR, FWUPD_ERROR,
FWUPD_ERROR_INTERNAL, FWUPD_ERROR_INTERNAL,
@ -174,7 +174,7 @@ fu_csr_device_upload_chunk (FuCsrDevice *self, GError **error)
/* check the length */ /* check the length */
data_sz = fu_common_read_uint16 (&buf[1], G_LITTLE_ENDIAN); data_sz = fu_common_read_uint16 (&buf[1], G_LITTLE_ENDIAN);
if (data_sz + FU_CSR_COMMAND_HEADER_SIZE != (guint16) sizeof(buf)) { if (data_sz + FU_DFU_CSR_COMMAND_HEADER_SIZE != (guint16) sizeof(buf)) {
g_set_error (error, g_set_error (error,
FWUPD_ERROR, FWUPD_ERROR,
FWUPD_ERROR_INTERNAL, FWUPD_ERROR_INTERNAL,
@ -184,14 +184,14 @@ fu_csr_device_upload_chunk (FuCsrDevice *self, GError **error)
} }
/* return as bytes */ /* return as bytes */
return g_bytes_new (buf + FU_CSR_COMMAND_HEADER_SIZE, return g_bytes_new (buf + FU_DFU_CSR_COMMAND_HEADER_SIZE,
sizeof(buf) - FU_CSR_COMMAND_HEADER_SIZE); sizeof(buf) - FU_DFU_CSR_COMMAND_HEADER_SIZE);
} }
static GBytes * static GBytes *
fu_csr_device_upload (FuDevice *device, GError **error) fu_dfu_csr_device_upload (FuDevice *device, GError **error)
{ {
FuCsrDevice *self = FU_CSR_DEVICE (device); FuDfuCsrDevice *self = FU_DFU_CSR_DEVICE (device);
g_autoptr(GPtrArray) chunks = NULL; g_autoptr(GPtrArray) chunks = NULL;
guint32 total_sz = 0; guint32 total_sz = 0;
gsize done_sz = 0; gsize done_sz = 0;
@ -205,15 +205,15 @@ fu_csr_device_upload (FuDevice *device, GError **error)
gsize chunk_sz; gsize chunk_sz;
/* hit hardware */ /* hit hardware */
chunk = fu_csr_device_upload_chunk (self, error); chunk = fu_dfu_csr_device_upload_chunk (self, error);
if (chunk == NULL) if (chunk == NULL)
return NULL; return NULL;
chunk_sz = g_bytes_get_size (chunk); chunk_sz = g_bytes_get_size (chunk);
/* get the total size using the CSR header */ /* get the total size using the DFU_CSR header */
if (i == 0 && chunk_sz >= 10) { if (i == 0 && chunk_sz >= 10) {
const guint8 *buf = g_bytes_get_data (chunk, NULL); const guint8 *buf = g_bytes_get_data (chunk, NULL);
if (memcmp (buf, "CSR-dfu", 7) == 0) { if (memcmp (buf, "DFU_CSR-dfu", 7) == 0) {
guint16 hdr_ver; guint16 hdr_ver;
guint16 hdr_len; guint16 hdr_len;
if (!fu_common_read_uint16_safe (buf, chunk_sz, 8, if (!fu_common_read_uint16_safe (buf, chunk_sz, 8,
@ -224,7 +224,7 @@ fu_csr_device_upload (FuDevice *device, GError **error)
g_set_error (error, g_set_error (error,
FWUPD_ERROR, FWUPD_ERROR,
FWUPD_ERROR_INTERNAL, FWUPD_ERROR_INTERNAL,
"CSR header version is " "DFU_CSR header version is "
"invalid %" G_GUINT16_FORMAT, "invalid %" G_GUINT16_FORMAT,
hdr_ver); hdr_ver);
return NULL; return NULL;
@ -237,7 +237,7 @@ fu_csr_device_upload (FuDevice *device, GError **error)
g_set_error (error, g_set_error (error,
FWUPD_ERROR, FWUPD_ERROR,
FWUPD_ERROR_INTERNAL, FWUPD_ERROR_INTERNAL,
"CSR header data length " "DFU_CSR header data length "
"invalid %" G_GUINT32_FORMAT, "invalid %" G_GUINT32_FORMAT,
total_sz); total_sz);
return NULL; return NULL;
@ -246,7 +246,7 @@ fu_csr_device_upload (FuDevice *device, GError **error)
&hdr_len, G_LITTLE_ENDIAN, &hdr_len, G_LITTLE_ENDIAN,
error)) error))
return NULL; return NULL;
g_debug ("CSR header length: %" G_GUINT16_FORMAT, hdr_len); g_debug ("DFU_CSR header length: %" G_GUINT16_FORMAT, hdr_len);
} }
} }
@ -256,7 +256,7 @@ fu_csr_device_upload (FuDevice *device, GError **error)
fu_device_set_progress_full (device, done_sz, (gsize) total_sz); fu_device_set_progress_full (device, done_sz, (gsize) total_sz);
/* we're done */ /* we're done */
if (chunk_sz < 64 - FU_CSR_COMMAND_HEADER_SIZE) if (chunk_sz < 64 - FU_DFU_CSR_COMMAND_HEADER_SIZE)
break; break;
} }
@ -265,15 +265,15 @@ fu_csr_device_upload (FuDevice *device, GError **error)
} }
static gboolean static gboolean
fu_csr_device_download_chunk (FuCsrDevice *self, guint16 idx, GBytes *chunk, GError **error) fu_dfu_csr_device_download_chunk (FuDfuCsrDevice *self, guint16 idx, GBytes *chunk, GError **error)
{ {
const guint8 *chunk_data; const guint8 *chunk_data;
gsize chunk_sz = 0; gsize chunk_sz = 0;
guint8 buf[FU_CSR_PACKET_DATA_SIZE] = {0}; guint8 buf[FU_DFU_CSR_PACKET_DATA_SIZE] = {0};
/* too large? */ /* too large? */
chunk_data = g_bytes_get_data (chunk, &chunk_sz); chunk_data = g_bytes_get_data (chunk, &chunk_sz);
if (chunk_sz + FU_CSR_COMMAND_HEADER_SIZE > FU_CSR_PACKET_DATA_SIZE) { if (chunk_sz + FU_DFU_CSR_COMMAND_HEADER_SIZE > FU_DFU_CSR_PACKET_DATA_SIZE) {
g_set_error (error, g_set_error (error,
FWUPD_ERROR, FWUPD_ERROR,
FWUPD_ERROR_INTERNAL, FWUPD_ERROR_INTERNAL,
@ -283,20 +283,20 @@ fu_csr_device_download_chunk (FuCsrDevice *self, guint16 idx, GBytes *chunk, GEr
g_debug ("writing %" G_GSIZE_FORMAT " bytes of data", chunk_sz); g_debug ("writing %" G_GSIZE_FORMAT " bytes of data", chunk_sz);
/* create packet */ /* create packet */
buf[0] = FU_CSR_REPORT_ID_COMMAND; buf[0] = FU_DFU_CSR_REPORT_ID_COMMAND;
buf[1] = FU_CSR_COMMAND_UPGRADE; buf[1] = FU_DFU_CSR_COMMAND_UPGRADE;
fu_common_write_uint16 (&buf[2], idx, G_LITTLE_ENDIAN); fu_common_write_uint16 (&buf[2], idx, G_LITTLE_ENDIAN);
fu_common_write_uint16 (&buf[4], chunk_sz, G_LITTLE_ENDIAN); fu_common_write_uint16 (&buf[4], chunk_sz, G_LITTLE_ENDIAN);
if (!fu_memcpy_safe (buf, sizeof(buf), FU_CSR_COMMAND_HEADER_SIZE, /* dst */ if (!fu_memcpy_safe (buf, sizeof(buf), FU_DFU_CSR_COMMAND_HEADER_SIZE, /* dst */
chunk_data, chunk_sz, 0x0, /* src */ chunk_data, chunk_sz, 0x0, /* src */
chunk_sz, error)) chunk_sz, error))
return FALSE; return FALSE;
/* hit hardware */ /* hit hardware */
if (!fu_hid_device_set_report (FU_HID_DEVICE (self), if (!fu_hid_device_set_report (FU_HID_DEVICE (self),
FU_CSR_REPORT_ID_COMMAND, FU_DFU_CSR_REPORT_ID_COMMAND,
buf, sizeof(buf), buf, sizeof(buf),
FU_CSR_DEVICE_TIMEOUT, FU_DFU_CSR_DEVICE_TIMEOUT,
FU_HID_DEVICE_FLAG_IS_FEATURE, FU_HID_DEVICE_FLAG_IS_FEATURE,
error)) { error)) {
g_prefix_error (error, "failed to Upgrade: "); g_prefix_error (error, "failed to Upgrade: ");
@ -304,20 +304,20 @@ fu_csr_device_download_chunk (FuCsrDevice *self, guint16 idx, GBytes *chunk, GEr
} }
/* wait for hardware */ /* wait for hardware */
if (self->quirks & FU_CSR_DEVICE_QUIRK_REQUIRE_DELAY) { if (self->quirks & FU_DFU_CSR_DEVICE_QUIRK_REQUIRE_DELAY) {
g_debug ("sleeping for %ums", self->dnload_timeout); g_debug ("sleeping for %ums", self->dnload_timeout);
g_usleep (self->dnload_timeout * 1000); g_usleep (self->dnload_timeout * 1000);
} }
/* get status */ /* get status */
if (!fu_csr_device_get_status (self, error)) if (!fu_dfu_csr_device_get_status (self, error))
return FALSE; return FALSE;
/* is still busy */ /* is still busy */
if (self->dfu_state == DFU_STATE_DFU_DNBUSY) { if (self->dfu_state == DFU_STATE_DFU_DNBUSY) {
g_debug ("busy, so sleeping a bit longer"); g_debug ("busy, so sleeping a bit longer");
g_usleep (G_USEC_PER_SEC); g_usleep (G_USEC_PER_SEC);
if (!fu_csr_device_get_status (self, error)) if (!fu_dfu_csr_device_get_status (self, error))
return FALSE; return FALSE;
} }
@ -336,7 +336,7 @@ fu_csr_device_download_chunk (FuCsrDevice *self, guint16 idx, GBytes *chunk, GEr
} }
static FuFirmware * static FuFirmware *
fu_csr_device_prepare_firmware (FuDevice *device, fu_dfu_csr_device_prepare_firmware (FuDevice *device,
GBytes *fw, GBytes *fw,
FwupdInstallFlags flags, FwupdInstallFlags flags,
GError **error) GError **error)
@ -346,7 +346,7 @@ fu_csr_device_prepare_firmware (FuDevice *device,
/* parse the file */ /* parse the file */
if (!fu_firmware_parse (firmware, fw, flags, error)) if (!fu_firmware_parse (firmware, fw, flags, error))
return NULL; return NULL;
if (g_getenv ("FWUPD_CSR_VERBOSE") != NULL) { if (g_getenv ("FWUPD_DFU_CSR_VERBOSE") != NULL) {
g_autofree gchar *fw_str = NULL; g_autofree gchar *fw_str = NULL;
fw_str = fu_firmware_to_string (firmware); fw_str = fu_firmware_to_string (firmware);
g_debug ("%s", fw_str); g_debug ("%s", fw_str);
@ -357,12 +357,12 @@ fu_csr_device_prepare_firmware (FuDevice *device,
} }
static gboolean static gboolean
fu_csr_device_download (FuDevice *device, fu_dfu_csr_device_download (FuDevice *device,
FuFirmware *firmware, FuFirmware *firmware,
FwupdInstallFlags flags, FwupdInstallFlags flags,
GError **error) GError **error)
{ {
FuCsrDevice *self = FU_CSR_DEVICE (device); FuDfuCsrDevice *self = FU_DFU_CSR_DEVICE (device);
guint16 idx; guint16 idx;
g_autoptr(GBytes) blob_empty = NULL; g_autoptr(GBytes) blob_empty = NULL;
g_autoptr(GBytes) blob = NULL; g_autoptr(GBytes) blob = NULL;
@ -378,7 +378,7 @@ fu_csr_device_download (FuDevice *device,
/* create chunks */ /* create chunks */
chunks = fu_chunk_array_new_from_bytes (blob, 0x0, 0x0, chunks = fu_chunk_array_new_from_bytes (blob, 0x0, 0x0,
FU_CSR_PACKET_DATA_SIZE - FU_CSR_COMMAND_HEADER_SIZE); FU_DFU_CSR_PACKET_DATA_SIZE - FU_DFU_CSR_COMMAND_HEADER_SIZE);
/* send to hardware */ /* send to hardware */
for (idx = 0; idx < chunks->len; idx++) { for (idx = 0; idx < chunks->len; idx++) {
@ -386,7 +386,7 @@ fu_csr_device_download (FuDevice *device,
g_autoptr(GBytes) blob_tmp = fu_chunk_get_bytes (chk); g_autoptr(GBytes) blob_tmp = fu_chunk_get_bytes (chk);
/* send packet */ /* send packet */
if (!fu_csr_device_download_chunk (self, idx, blob_tmp, error)) if (!fu_dfu_csr_device_download_chunk (self, idx, blob_tmp, error))
return FALSE; return FALSE;
/* update progress */ /* update progress */
@ -396,18 +396,18 @@ fu_csr_device_download (FuDevice *device,
/* all done */ /* all done */
blob_empty = g_bytes_new (NULL, 0); blob_empty = g_bytes_new (NULL, 0);
return fu_csr_device_download_chunk (self, idx, blob_empty, error); return fu_dfu_csr_device_download_chunk (self, idx, blob_empty, error);
} }
static gboolean static gboolean
fu_csr_device_probe (FuUsbDevice *device, GError **error) fu_dfu_csr_device_probe (FuUsbDevice *device, GError **error)
{ {
FuCsrDevice *self = FU_CSR_DEVICE (device); FuDfuCsrDevice *self = FU_DFU_CSR_DEVICE (device);
/* proxy the quirk delay */ /* proxy the quirk delay */
if (fu_device_has_custom_flag (FU_DEVICE (device), if (fu_device_has_custom_flag (FU_DEVICE (device),
FU_CSR_DEVICE_FLAG_REQUIRE_DELAY)) FU_DFU_CSR_DEVICE_FLAG_REQUIRE_DELAY))
self->quirks = FU_CSR_DEVICE_QUIRK_REQUIRE_DELAY; self->quirks = FU_DFU_CSR_DEVICE_QUIRK_REQUIRE_DELAY;
/* hardcoded */ /* hardcoded */
fu_device_add_flag (FU_DEVICE (device), FWUPD_DEVICE_FLAG_UPDATABLE); fu_device_add_flag (FU_DEVICE (device), FWUPD_DEVICE_FLAG_UPDATABLE);
@ -417,11 +417,11 @@ fu_csr_device_probe (FuUsbDevice *device, GError **error)
} }
static gboolean static gboolean
fu_csr_device_setup (FuDevice *device, GError **error) fu_dfu_csr_device_setup (FuDevice *device, GError **error)
{ {
FuCsrDevice *self = FU_CSR_DEVICE (device); FuDfuCsrDevice *self = FU_DFU_CSR_DEVICE (device);
if (!fu_csr_device_clear_status (self, error)) if (!fu_dfu_csr_device_clear_status (self, error))
return FALSE; return FALSE;
/* success */ /* success */
@ -429,21 +429,21 @@ fu_csr_device_setup (FuDevice *device, GError **error)
} }
static void static void
fu_csr_device_init (FuCsrDevice *self) fu_dfu_csr_device_init (FuDfuCsrDevice *self)
{ {
fu_device_set_protocol (FU_DEVICE (self), "com.qualcomm.dfu"); fu_device_set_protocol (FU_DEVICE (self), "com.qualcomm.dfu");
} }
static void static void
fu_csr_device_class_init (FuCsrDeviceClass *klass) fu_dfu_csr_device_class_init (FuDfuCsrDeviceClass *klass)
{ {
FuDeviceClass *klass_device = FU_DEVICE_CLASS (klass); FuDeviceClass *klass_device = FU_DEVICE_CLASS (klass);
FuUsbDeviceClass *klass_usb_device = FU_USB_DEVICE_CLASS (klass); FuUsbDeviceClass *klass_usb_device = FU_USB_DEVICE_CLASS (klass);
klass_device->to_string = fu_csr_device_to_string; klass_device->to_string = fu_dfu_csr_device_to_string;
klass_device->write_firmware = fu_csr_device_download; klass_device->write_firmware = fu_dfu_csr_device_download;
klass_device->dump_firmware = fu_csr_device_upload; klass_device->dump_firmware = fu_dfu_csr_device_upload;
klass_device->prepare_firmware = fu_csr_device_prepare_firmware; klass_device->prepare_firmware = fu_dfu_csr_device_prepare_firmware;
klass_device->attach = fu_csr_device_attach; klass_device->attach = fu_dfu_csr_device_attach;
klass_device->setup = fu_csr_device_setup; klass_device->setup = fu_dfu_csr_device_setup;
klass_usb_device->probe = fu_csr_device_probe; klass_usb_device->probe = fu_dfu_csr_device_probe;
} }

4
plugins/csr/fu-csr-device.h → plugins/dfu-csr/fu-dfu-csr-device.h
View File

@ -9,5 +9,5 @@
#include "fu-hid-device.h" #include "fu-hid-device.h"
#include "fu-plugin.h" #include "fu-plugin.h"
#define FU_TYPE_CSR_DEVICE (fu_csr_device_get_type ()) #define FU_TYPE_DFU_CSR_DEVICE (fu_dfu_csr_device_get_type ())
G_DECLARE_FINAL_TYPE (FuCsrDevice, fu_csr_device, FU, CSR_DEVICE, FuHidDevice) G_DECLARE_FINAL_TYPE (FuDfuCsrDevice, fu_dfu_csr_device, FU, DFU_CSR_DEVICE, FuHidDevice)

4
plugins/csr/fu-plugin-csr.c → plugins/dfu-csr/fu-plugin-dfu-csr.c
View File

@ -8,11 +8,11 @@
#include "fu-plugin-vfuncs.h" #include "fu-plugin-vfuncs.h"
#include "fu-csr-device.h" #include "fu-dfu-csr-device.h"
void void
fu_plugin_init (FuPlugin *plugin) fu_plugin_init (FuPlugin *plugin)
{ {
fu_plugin_set_build_hash (plugin, FU_BUILD_HASH); fu_plugin_set_build_hash (plugin, FU_BUILD_HASH);
fu_plugin_set_device_gtype (plugin, FU_TYPE_CSR_DEVICE); fu_plugin_set_device_gtype (plugin, FU_TYPE_DFU_CSR_DEVICE);
} }

10
plugins/csr/meson.build → plugins/dfu-csr/meson.build
View File

@ -1,14 +1,14 @@
cargs = ['-DG_LOG_DOMAIN="FuPluginCsr"'] cargs = ['-DG_LOG_DOMAIN="FuPluginDfuCsr"']
install_data(['csr-aiaiai.quirk'], install_data(['dfu-csr.quirk'],
install_dir: join_paths(datadir, 'fwupd', 'quirks.d') install_dir: join_paths(datadir, 'fwupd', 'quirks.d')
) )
shared_module('fu_plugin_csr', shared_module('fu_plugin_dfu_csr',
fu_hash, fu_hash,
sources : [ sources : [
'fu-csr-device.c', 'fu-dfu-csr-device.c',
'fu-plugin-csr.c', 'fu-plugin-dfu-csr.c',
], ],
include_directories : [ include_directories : [
root_incdir, root_incdir,

2
plugins/meson.build
View File

@ -63,7 +63,7 @@ subdir('vli')
subdir('wacom-usb') subdir('wacom-usb')
# depends on dfu # depends on dfu
subdir('csr') subdir('dfu-csr')
endif endif
if get_option('plugin_tpm') if get_option('plugin_tpm')

2
src/README.md
View File

@ -111,7 +111,7 @@ Here is an example as seen in the CSR plugin.
``` ```
[DeviceInstanceId=USB\VID_0A12&PID_1337] [DeviceInstanceId=USB\VID_0A12&PID_1337]
Plugin = csr Plugin = dfu_csr
Name = H05 Name = H05
Summary = Bluetooth Headphones Summary = Bluetooth Headphones
Icon = audio-headphones Icon = audio-headphones