From eed716e117922bde91b12d8a0ca20d9b752d83e6 Mon Sep 17 00:00:00 2001 From: Justin Hall Date: Thu, 23 Apr 2026 11:19:31 -0400 Subject: [PATCH 1/3] samsung7305: Add driver for Samsung 04e8:7305 fingerprint sensor Adds an image driver for the Samsung USB fingerprint sensor (04e8:7305) shipped in the Samsung Notebook 7 Spin (NP730QAA-K02US). The protocol was reverse-engineered from USB captures of the Windows vendor driver. The sensor is a 56x192 8-bit grayscale area sensor. Capture requires a 4-trigger sequence (3 pre-capture strip reads plus one full-frame read) and a vendor control-transfer bracket (heartbeat / response-length prime / wait-ready doorbell on EP0) around every bulk transfer. The sensor is physically a press sensor but is declared as FP_SCAN_TYPE_SWIPE and assembled from multiple frames via fpi_assemble_frames(), because NBIS's minutia extractor needs more ridge area than a single 56x192 frame provides. An inline comment near ASSEMBLE_STRIDE explains the rationale and references drivers/elan.c for precedent. A umockdev-based capture test is included. Protocol documentation and development history: https://github.com/jwhall/samsung7305 Co-Authored-By: Claude Opus 4.7 --- data/autosuspend.hwdb | 5 + libfprint/drivers/samsung7305.c | 1296 ++++++++++++++++++++++++++++++ libfprint/meson.build | 2 + meson.build | 1 + tests/meson.build | 1 + tests/samsung7305/capture.pcapng | Bin 0 -> 452672 bytes tests/samsung7305/capture.png | Bin 0 -> 21084 bytes tests/samsung7305/device | 261 ++++++ 8 files changed, 1566 insertions(+) create mode 100644 libfprint/drivers/samsung7305.c create mode 100644 tests/samsung7305/capture.pcapng create mode 100644 tests/samsung7305/capture.png create mode 100644 tests/samsung7305/device diff --git a/data/autosuspend.hwdb b/data/autosuspend.hwdb index fe682714..4464ac57 100644 --- a/data/autosuspend.hwdb +++ b/data/autosuspend.hwdb @@ -256,6 +256,11 @@ usb:v2541pFA03* ID_AUTOSUSPEND=1 ID_PERSIST=0 +# Supported by libfprint driver samsung7305 +usb:v04E8p7305* + ID_AUTOSUSPEND=1 + ID_PERSIST=0 + # Supported by libfprint driver synaptics usb:v06CBp00BD* usb:v06CBp00C2* diff --git a/libfprint/drivers/samsung7305.c b/libfprint/drivers/samsung7305.c new file mode 100644 index 00000000..ae421934 --- /dev/null +++ b/libfprint/drivers/samsung7305.c @@ -0,0 +1,1296 @@ +/* + * Samsung Fingerprint Device (04e8:7305) driver for libfprint + * + * Reverse-engineered from USB captures of the Windows driver on a + * Samsung Notebook 7 Spin (NP730QAA-K02US). + * + * Copyright (C) 2026 Justin Hall + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#define FP_COMPONENT "samsung7305" + +#include "fpi-log.h" +#include "drivers_api.h" +#include "fpi-assembling.h" + +/* ── Frame assembly ─────────────────────────────────────────────────────── */ + +#define MAX_FRAMES 8 +#define MIN_FRAMES 4 /* need 1 to drop + ASSEMBLE_FRAMES to keep */ +#define ASSEMBLE_FRAMES 3 +#define ASSEMBLE_STRIDE 64 /* fixed y-offset between kept frames */ + +/* NOTE: The sensor is physically an area (press) sensor — the user holds + * the finger flat, not swiping. We still declare scan_type = SWIPE and use + * fpi_assemble_frames because NBIS/bozorth3 cannot extract enough minutiae + * from a single 56x192 frame (~4–6 minutiae; bozorth3 wants hundreds of + * edges). Stacking several frames at a fixed stride produces a composite + * large enough for reliable matching. The stride is deterministic rather + * than motion-estimated so enroll and verify produce identical geometry. + * Compare drivers/elan.c, which takes the same approach for similarly + * narrow area-style sensors. */ +static unsigned char +samsung7305_get_pixel (struct fpi_frame_asmbl_ctx *ctx, + struct fpi_frame *frame, unsigned int x, + unsigned int y) +{ + return frame->data[x + y * ctx->frame_width]; +} + +static struct fpi_frame_asmbl_ctx assembling_ctx = { + .frame_width = 56, + .frame_height = 192, + .image_width = 56 * 3 / 2, + .get_pixel = samsung7305_get_pixel, +}; + +/* ── Image geometry ─────────────────────────────────────────────────────── */ + +#define FRAME_WIDTH 56 +#define FRAME_HEIGHT 192 +#define FRAME_SIZE (FRAME_WIDTH * FRAME_HEIGHT) /* 10752 bytes */ + +#define STRIP_WIDTH 56 +#define STRIP_HEIGHT 24 +#define STRIP_SIZE (STRIP_WIDTH * STRIP_HEIGHT) /* 1344 bytes */ + +/* ── USB endpoints ──────────────────────────────────────────────────────── */ + +#define SAMSUNG_EP_OUT (0x01 | FPI_USB_ENDPOINT_OUT) +#define SAMSUNG_EP_IN (0x02 | FPI_USB_ENDPOINT_IN) + +/* ── Timeouts ───────────────────────────────────────────────────────────── */ + +#define CMD_TIMEOUT 2000 +#define IMG_TIMEOUT 5000 +#define POLL_DELAY 30 +#define DRAIN_TIMEOUT 50 +#define DRAIN_BUF_SIZE 16384 + +/* ── Status register (0x1c 0x00) response byte[1] values ───────────────── */ + +#define STATUS_FINGER 0x81 +#define STATUS_IDLE 0x80 +#define STATUS_READY 0x20 + +/* ── Protocol: init sequence ────────────────────────────────────────────── */ + +static const guint8 cmd_reset[] = { 0xf8 }; +static const guint8 cmd_status[] = { 0x1c, 0x00 }; +static const guint8 cmd_cfg1[] = { 0xfc, 0x00, 0x00 }; +static const guint8 cmd_cfg2[] = { 0x90, 0x34 }; +static const guint8 cmd_cfg3[] = { 0x68, 0x33, 0x33, 0x33, 0x33, + 0x3f, 0x3f, 0x3f, 0x3f }; +static const guint8 cmd_cfg4[] = { 0x9c, 0x55, 0x40, 0x00, 0x2d, 0x24 }; +static const guint8 cmd_cfg5[] = { 0x6c, 0x2b }; +static const guint8 cmd_cfg6[] = { 0x8c, 0x12 }; +static const guint8 cmd_cfg7[] = { 0x5c, 0x0b }; +/* Calibration blob — captured from the Windows driver (04e8:7305) and + * identical across every init across two independent captures on the same + * unit. If future testing on a second physical unit shows a different + * payload, this blob will need to be read from device storage instead of + * being hardcoded. See PROTOCOL.md § Calibration. */ +static const guint8 cmd_calib[] = { 0x98, 0x03, 0xea, 0xbf, 0x68, + 0x02, 0x09, 0x15, 0x2a, 0x7a, 0xde }; +static const guint8 cmd_capparam[] = { 0xd8, 0x00, 0x01, 0x20, 0x20 }; +static const guint8 cmd_cfg8[] = { 0xe0, 0x32, 0x70, 0x22 }; +static const guint8 cmd_cfg9[] = { 0xe4, 0x32, 0x88, 0x70 }; +static const guint8 cmd_cfg10[] = { 0xe8, 0x32, 0x88 }; +static const guint8 cmd_cfg11[] = { 0xdc, 0x19, 0x01, 0x00, 0x0a }; +static const guint8 cmd_cfg12[] = { 0xa8, 0x0f, 0x0a }; +static const guint8 cmd_cfg13[] = { 0xa0, 0x0a, 0x02 }; +static const guint8 cmd_initdone[] = { 0x28 }; + +static const guint8 cmd_arm[] = { 0x20 }; +static const guint8 cmd_cap_rd[] = { 0xd4, 0x00, 0x00, 0x00, 0x00 }; + +static const guint8 cmd_capgeo[] = { 0x54, 0x50, 0x18, 0x00, 0x38 }; +static const guint8 cmd_capcfg1[] = { 0xa0, 0x10, 0x00 }; +static const guint8 cmd_capcfg2[] = { 0xa8, 0x0f, 0x1a }; +static const guint8 cmd_capcfg3[] = { 0x64, 0x0c }; +static const guint8 cmd_capcfg4[] = { 0x5c, 0x0a }; + +static const guint8 cmd_trigger[] = { 0xc0 }; +static const guint8 cmd_between_strips[] = { 0xa8, 0x0f, 0x0a }; + +static const guint8 cmd_ff_cfg1[] = { 0xa0, 0x0e, 0x06 }; +static const guint8 cmd_ff_cfg2[] = { 0x64, 0x1e }; +static const guint8 cmd_ff_cfg3[] = { 0x5c, 0x0b }; +static const guint8 cmd_ff_geo[] = { 0x54, 0x00, 0xc0, 0x00, 0x38 }; + +/* Per-transfer heartbeat payload (PROTOCOL.md → Transport) — identical in + * every occurrence across the Windows capture. */ +static const guint8 heartbeat_payload[16] = { + 0xc0, 0xc6, 0x2d, 0x00, 0x08, 0x00, 0xff, 0x01, + 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 +}; + +typedef struct { + const guint8 *data; + gsize len; +} SamsungCmd; + +#define SCMD(arr) { (arr), G_N_ELEMENTS (arr) } + +static const SamsungCmd init_seq[] = { + SCMD (cmd_reset), + SCMD (cmd_status), + SCMD (cmd_status), + SCMD (cmd_cfg1), + SCMD (cmd_cfg2), + SCMD (cmd_cfg3), + SCMD (cmd_cfg4), + SCMD (cmd_cfg5), + SCMD (cmd_cfg6), + SCMD (cmd_cfg7), + SCMD (cmd_calib), + SCMD (cmd_capparam), + SCMD (cmd_cfg8), + SCMD (cmd_cfg9), + SCMD (cmd_cfg10), + SCMD (cmd_cfg11), + SCMD (cmd_cfg12), + SCMD (cmd_cfg13), + SCMD (cmd_initdone), +}; + +static const SamsungCmd cap_setup_seq[] = { + SCMD (cmd_capgeo), + SCMD (cmd_capcfg1), + SCMD (cmd_capcfg2), + SCMD (cmd_capcfg3), + SCMD (cmd_capcfg4), +}; + +static const SamsungCmd ff_setup_seq[] = { + SCMD (cmd_ff_cfg1), + SCMD (cmd_ff_cfg2), + SCMD (cmd_ff_cfg3), + SCMD (cmd_ff_geo), +}; + +/* ── SSM states ─────────────────────────────────────────────────────────── */ + +enum { + M_DRAIN, + M_INIT, + M_POLL_ARM, + M_POLL_STATUS, + M_POLL_CAP, + M_CAP_SETUP, + M_TRIGGER1, + M_WAIT1, + M_STRIP1_READ, + M_STRIP1_FTR, + M_BETWEEN_S1_S2, + M_TRIGGER2, + M_WAIT2, + M_STRIP2_READ, + M_STRIP2_FTR, + M_REPOLL_ARM, + M_REPOLL_STATUS, + M_REPOLL_CAP, + M_TRIGGER3, + M_WAIT3, + M_STRIP3_READ, + M_STRIP3_FTR, + M_FF_SETUP, + M_TRIGGER4, + M_WAIT4, + M_FRAME_READ, + M_STORE_FRAME, + M_ASSEMBLE, + M_NUM_STATES, +}; + +struct _FpiDeviceSamsung7305 +{ + FpImageDevice parent; + FpiSsm *ssm; + guint8 *img_buf; + guint8 *img_cmd_buf; + guint8 *img_strip[3]; + guint cur_strip; + gboolean deactivating; + guint seq_idx; + guint strip_bytes_received; + guint frame_bytes_received; + GSList *frames; /* GSList of struct fpi_frame*, prepended */ + guint frames_captured; +}; + +G_DECLARE_FINAL_TYPE (FpiDeviceSamsung7305, fpi_device_samsung7305, + FPI, DEVICE_SAMSUNG7305, FpImageDevice); +G_DEFINE_TYPE (FpiDeviceSamsung7305, fpi_device_samsung7305, FP_TYPE_IMAGE_DEVICE); + +/* ── Forward declarations ───────────────────────────────────────────────── */ + +typedef void (*ExchangeDone) (FpDevice *dev, FpiSsm *ssm, + const guint8 *resp, gsize resp_len, + GError *error); + +static void run_init_seq (FpiDeviceSamsung7305 *self); +static void run_cap_seq (FpiDeviceSamsung7305 *self); +static void strip_image_read_cb (FpiUsbTransfer *transfer, FpDevice *dev, + gpointer unused, GError *error); +static void image_read_cb (FpiUsbTransfer *transfer, FpDevice *dev, + gpointer unused, GError *error); +static void img_cmd_write_cb (FpiUsbTransfer *transfer, FpDevice *dev, + gpointer unused, GError *error); + +static void bracketed_submit (FpDevice *dev, FpiSsm *ssm, + const guint8 *cmd, gsize cmd_len, + guint16 prime_len, gboolean doorbell, + ExchangeDone done_cb); +static void bracketed_c4_submit (FpDevice *dev, FpiSsm *ssm, + guint8 *cmd_buf, gsize len, + FpiUsbTransferCallback read_cb); + +/* ── Deactivation guard ─────────────────────────────────────────────────── */ + +static gboolean +check_deactivating (FpiUsbTransfer *transfer, GError *error) +{ + FpiDeviceSamsung7305 *self = FPI_DEVICE_SAMSUNG7305 (transfer->device); + + if (error) + { + fp_warn ("samsung7305: error in SSM state %d (seq_idx=%u): %s", + fpi_ssm_get_cur_state (transfer->ssm), + self->seq_idx, + error->message); + fpi_ssm_mark_failed (transfer->ssm, error); + return TRUE; + } + if (self->deactivating) + { + fpi_ssm_mark_completed (transfer->ssm); + return TRUE; + } + return FALSE; +} + +/* ── Bracketed bulk exchange ────────────────────────────────────────────── * + * + * Every bulk write+read on this device must be wrapped in vendor control + * transfers on EP0 (PROTOCOL.md → Transport). The chain is: + * + * 1. CTRL-OUT 0xc3 (heartbeat, 16-byte fixed payload) + * 2. CTRL-OUT 0xca wValue=0x0003 wIndex=N (primes EP2 response length) + * 3. BULK-OUT cmd + * 4. BULK-IN N bytes + * 5. CTRL-IN 0xda wValue=0x0007 (2 B doorbell) — only if doorbell==TRUE, + * which is required for 0x20 / 0x28 / 0xc0 / 0xf8. + * + * The context is allocated on ex start and freed on ex completion. The + * response buffer is handed to done_cb as a read-only snapshot; done_cb + * owns the error (if non-NULL) and must consume it via fpi_ssm_mark_failed + * or g_error_free. + */ + +typedef struct { + const guint8 *cmd; + gsize cmd_len; + guint16 prime_len; + gboolean doorbell; + ExchangeDone done_cb; + guint8 *resp_buf; + gsize resp_actual; +} ExchangeCtx; + +static void ex_after_heartbeat (FpiUsbTransfer *t, FpDevice *dev, gpointer ud, GError *err); +static void ex_after_prime (FpiUsbTransfer *t, FpDevice *dev, gpointer ud, GError *err); +static void ex_after_write (FpiUsbTransfer *t, FpDevice *dev, gpointer ud, GError *err); +static void ex_after_read (FpiUsbTransfer *t, FpDevice *dev, gpointer ud, GError *err); +static void ex_after_doorbell (FpiUsbTransfer *t, FpDevice *dev, gpointer ud, GError *err); + +static void +ex_complete (FpDevice *dev, FpiSsm *ssm, ExchangeCtx *ctx, GError *err) +{ + ExchangeDone cb = ctx->done_cb; + guint8 *buf = ctx->resp_buf; + gsize n = ctx->resp_actual; + + ctx->resp_buf = NULL; + g_free (ctx); + + cb (dev, ssm, buf, n, err); + g_free (buf); +} + +static gboolean +ex_check_bail (FpiUsbTransfer *t, ExchangeCtx *ctx, GError *err) +{ + FpiDeviceSamsung7305 *self = FPI_DEVICE_SAMSUNG7305 (t->device); + + if (self->deactivating) + { + if (err) g_error_free (err); + fpi_ssm_mark_completed (t->ssm); + g_free (ctx->resp_buf); + g_free (ctx); + return TRUE; + } + if (err) + { + ex_complete (t->device, t->ssm, ctx, err); + return TRUE; + } + return FALSE; +} + +static void +bracketed_submit (FpDevice *dev, FpiSsm *ssm, + const guint8 *cmd, gsize cmd_len, + guint16 prime_len, gboolean doorbell, + ExchangeDone done_cb) +{ + ExchangeCtx *ctx = g_new0 (ExchangeCtx, 1); + FpiUsbTransfer *t; + + ctx->cmd = cmd; + ctx->cmd_len = cmd_len; + ctx->prime_len = prime_len; + ctx->doorbell = doorbell; + ctx->done_cb = done_cb; + + t = fpi_usb_transfer_new (dev); + t->ssm = ssm; + t->short_is_error = FALSE; + fpi_usb_transfer_fill_control (t, + G_USB_DEVICE_DIRECTION_HOST_TO_DEVICE, + G_USB_DEVICE_REQUEST_TYPE_VENDOR, + G_USB_DEVICE_RECIPIENT_DEVICE, + 0xc3, 0x0000, 0x0000, 16); + memcpy (t->buffer, heartbeat_payload, 16); + fpi_usb_transfer_submit (t, CMD_TIMEOUT, + fpi_device_get_cancellable (dev), + ex_after_heartbeat, ctx); +} + +static void +ex_after_heartbeat (FpiUsbTransfer *t, FpDevice *dev, gpointer ud, GError *err) +{ + ExchangeCtx *ctx = ud; + FpiUsbTransfer *n; + + if (ex_check_bail (t, ctx, err)) return; + + n = fpi_usb_transfer_new (dev); + n->ssm = t->ssm; + n->short_is_error = FALSE; + fpi_usb_transfer_fill_control (n, + G_USB_DEVICE_DIRECTION_HOST_TO_DEVICE, + G_USB_DEVICE_REQUEST_TYPE_VENDOR, + G_USB_DEVICE_RECIPIENT_DEVICE, + 0xca, 0x0003, ctx->prime_len, 0); + fpi_usb_transfer_submit (n, CMD_TIMEOUT, + fpi_device_get_cancellable (dev), + ex_after_prime, ctx); +} + +static void +ex_after_prime (FpiUsbTransfer *t, FpDevice *dev, gpointer ud, GError *err) +{ + ExchangeCtx *ctx = ud; + FpiUsbTransfer *n; + + if (ex_check_bail (t, ctx, err)) return; + + n = fpi_usb_transfer_new (dev); + n->ssm = t->ssm; + n->short_is_error = TRUE; + fpi_usb_transfer_fill_bulk_full (n, SAMSUNG_EP_OUT, + (guint8 *) ctx->cmd, ctx->cmd_len, NULL); + fpi_usb_transfer_submit (n, CMD_TIMEOUT, + fpi_device_get_cancellable (dev), + ex_after_write, ctx); +} + +static void +ex_after_write (FpiUsbTransfer *t, FpDevice *dev, gpointer ud, GError *err) +{ + ExchangeCtx *ctx = ud; + FpiUsbTransfer *n; + + if (ex_check_bail (t, ctx, err)) return; + + n = fpi_usb_transfer_new (dev); + n->ssm = t->ssm; + n->short_is_error = FALSE; + fpi_usb_transfer_fill_bulk (n, SAMSUNG_EP_IN, ctx->prime_len); + fpi_usb_transfer_submit (n, CMD_TIMEOUT, + fpi_device_get_cancellable (dev), + ex_after_read, ctx); +} + +static void +ex_after_read (FpiUsbTransfer *t, FpDevice *dev, gpointer ud, GError *err) +{ + ExchangeCtx *ctx = ud; + FpiUsbTransfer *n; + + if (ex_check_bail (t, ctx, err)) return; + + ctx->resp_actual = t->actual_length; + ctx->resp_buf = g_memdup2 (t->buffer, t->actual_length); + + if (!ctx->doorbell) + { + ex_complete (dev, t->ssm, ctx, NULL); + return; + } + + n = fpi_usb_transfer_new (dev); + n->ssm = t->ssm; + n->short_is_error = FALSE; + fpi_usb_transfer_fill_control (n, + G_USB_DEVICE_DIRECTION_DEVICE_TO_HOST, + G_USB_DEVICE_REQUEST_TYPE_VENDOR, + G_USB_DEVICE_RECIPIENT_DEVICE, + 0xda, 0x0007, 0x0000, 2); + fpi_usb_transfer_submit (n, CMD_TIMEOUT, + fpi_device_get_cancellable (dev), + ex_after_doorbell, ctx); +} + +static void +ex_after_doorbell (FpiUsbTransfer *t, FpDevice *dev, gpointer ud, GError *err) +{ + ExchangeCtx *ctx = ud; + FpiDeviceSamsung7305 *self = FPI_DEVICE_SAMSUNG7305 (dev); + + if (self->deactivating) + { + if (err) g_error_free (err); + fpi_ssm_mark_completed (t->ssm); + g_free (ctx->resp_buf); + g_free (ctx); + return; + } + + fp_dbg ("samsung7305: doorbell %02x %02x", + err ? 0 : t->buffer[0], err ? 0 : t->buffer[1]); + ex_complete (dev, t->ssm, ctx, err); +} + +/* ── Bracketed 0xc4 image exchange ──────────────────────────────────────── * + * + * The 0xc4 image read uses a concurrent EP1 OUT write + EP2 IN read after + * the control-transfer preamble. Concurrency is still needed because the + * device starts staging image bytes on EP2 while the host is still writing + * the padded command on EP1 (see STATE.md § "0xc4 image read command"). + */ + +typedef struct { + guint8 *cmd_buf; + gsize len; + FpiUsbTransferCallback read_cb; +} C4Ctx; + +static void c4_after_heartbeat (FpiUsbTransfer *t, FpDevice *dev, gpointer ud, GError *err); +static void c4_after_prime (FpiUsbTransfer *t, FpDevice *dev, gpointer ud, GError *err); + +static void +bracketed_c4_submit (FpDevice *dev, FpiSsm *ssm, + guint8 *cmd_buf, gsize len, + FpiUsbTransferCallback read_cb) +{ + C4Ctx *c = g_new0 (C4Ctx, 1); + FpiUsbTransfer *t; + + c->cmd_buf = cmd_buf; + c->len = len; + c->read_cb = read_cb; + + t = fpi_usb_transfer_new (dev); + t->ssm = ssm; + t->short_is_error = FALSE; + fpi_usb_transfer_fill_control (t, + G_USB_DEVICE_DIRECTION_HOST_TO_DEVICE, + G_USB_DEVICE_REQUEST_TYPE_VENDOR, + G_USB_DEVICE_RECIPIENT_DEVICE, + 0xc3, 0x0000, 0x0000, 16); + memcpy (t->buffer, heartbeat_payload, 16); + fpi_usb_transfer_submit (t, CMD_TIMEOUT, + fpi_device_get_cancellable (dev), + c4_after_heartbeat, c); +} + +static void +c4_after_heartbeat (FpiUsbTransfer *t, FpDevice *dev, gpointer ud, GError *err) +{ + C4Ctx *c = ud; + FpiDeviceSamsung7305 *self = FPI_DEVICE_SAMSUNG7305 (dev); + FpiUsbTransfer *n; + + if (self->deactivating) + { if (err) g_error_free (err); fpi_ssm_mark_completed (t->ssm); g_free (c); return; } + if (err) + { fpi_ssm_mark_failed (t->ssm, err); g_free (c); return; } + + n = fpi_usb_transfer_new (dev); + n->ssm = t->ssm; + n->short_is_error = FALSE; + fpi_usb_transfer_fill_control (n, + G_USB_DEVICE_DIRECTION_HOST_TO_DEVICE, + G_USB_DEVICE_REQUEST_TYPE_VENDOR, + G_USB_DEVICE_RECIPIENT_DEVICE, + 0xca, 0x0003, (guint16) c->len, 0); + fpi_usb_transfer_submit (n, CMD_TIMEOUT, + fpi_device_get_cancellable (dev), + c4_after_prime, c); +} + +static void +c4_after_prime (FpiUsbTransfer *t, FpDevice *dev, gpointer ud, GError *err) +{ + C4Ctx *c = ud; + FpiDeviceSamsung7305 *self = FPI_DEVICE_SAMSUNG7305 (dev); + FpiUsbTransfer *rd, *wr; + + if (self->deactivating) + { if (err) g_error_free (err); fpi_ssm_mark_completed (t->ssm); g_free (c); return; } + if (err) + { fpi_ssm_mark_failed (t->ssm, err); g_free (c); return; } + + rd = fpi_usb_transfer_new (dev); + rd->ssm = t->ssm; + rd->short_is_error = FALSE; + fpi_usb_transfer_fill_bulk (rd, SAMSUNG_EP_IN, c->len); + fpi_usb_transfer_submit (rd, IMG_TIMEOUT, + fpi_device_get_cancellable (dev), + c->read_cb, NULL); + + wr = fpi_usb_transfer_new (dev); + wr->short_is_error = FALSE; + fpi_usb_transfer_fill_bulk_full (wr, SAMSUNG_EP_OUT, + c->cmd_buf, c->len, NULL); + fpi_usb_transfer_submit (wr, IMG_TIMEOUT, + fpi_device_get_cancellable (dev), + img_cmd_write_cb, NULL); + + g_free (c); +} + +/* ── EP2 drain (session-start flush + strip footer drain) ──────────────── */ + +static void +drain_read_cb (FpiUsbTransfer *transfer, FpDevice *dev, + gpointer unused, GError *error) +{ + FpiDeviceSamsung7305 *self = FPI_DEVICE_SAMSUNG7305 (dev); + + if (self->deactivating) + { + if (error) g_error_free (error); + fpi_ssm_mark_completed (transfer->ssm); + return; + } + + if (error) + { + fp_dbg ("samsung7305: drain complete (state %d): %s", + fpi_ssm_get_cur_state (transfer->ssm), error->message); + g_error_free (error); + fpi_ssm_next_state (transfer->ssm); + } + else + { + fp_dbg ("samsung7305: drain: flushed %zu bytes (state %d)", + transfer->actual_length, + fpi_ssm_get_cur_state (transfer->ssm)); + fpi_ssm_jump_to_state (transfer->ssm, + fpi_ssm_get_cur_state (transfer->ssm)); + } +} + +/* ── Per-state done callbacks ──────────────────────────────────────────── */ + +static void +init_done_cb (FpDevice *dev, FpiSsm *ssm, + const guint8 *resp, gsize n, GError *err) +{ + FpiDeviceSamsung7305 *self = FPI_DEVICE_SAMSUNG7305 (dev); + + if (err) { fpi_ssm_mark_failed (ssm, err); return; } + + fp_dbg ("samsung7305: init[%u] read %zu bytes: %02x %02x", + self->seq_idx, n, + n > 0 ? resp[0] : 0, n > 1 ? resp[1] : 0); + + self->seq_idx++; + if (self->seq_idx < G_N_ELEMENTS (init_seq)) + run_init_seq (self); + else + fpi_ssm_next_state (ssm); +} + +static void +run_init_seq (FpiDeviceSamsung7305 *self) +{ + const SamsungCmd *c = &init_seq[self->seq_idx]; + /* 0xf8 (reset) and 0x28 (init-complete) require the 0xda doorbell. */ + gboolean doorbell = (c->data[0] == 0xf8 || c->data[0] == 0x28); + + bracketed_submit (FP_DEVICE (self), self->ssm, + c->data, c->len, + (guint16) c->len, doorbell, + init_done_cb); +} + +/* Poll arm (0x20): doorbell required. */ +static void +arm_done_cb (FpDevice *dev, FpiSsm *ssm, + const guint8 *resp, gsize n, GError *err) +{ + if (err) { fpi_ssm_mark_failed (ssm, err); return; } + fp_dbg ("samsung7305: arm %zu bytes", n); + fpi_ssm_next_state (ssm); +} + +/* Poll status (0x1c 0x00): check finger-present bit. */ +static void +status_done_cb (FpDevice *dev, FpiSsm *ssm, + const guint8 *resp, gsize n, GError *err) +{ + if (err) { fpi_ssm_mark_failed (ssm, err); return; } + fp_dbg ("samsung7305: status %zu bytes: %02x %02x", + n, n > 0 ? resp[0] : 0, n > 1 ? resp[1] : 0); + if (n >= 2 && resp[1] == STATUS_FINGER) + fpi_ssm_next_state (ssm); + else + fpi_ssm_jump_to_state_delayed (ssm, M_POLL_ARM, POLL_DELAY); +} + +/* Capacitive read (0xd4): require full saturation. + * If the finger has lifted after at least one frame was captured, assemble + * the collected frames instead of looping. */ +static void +cap_check_done_cb (FpDevice *dev, FpiSsm *ssm, + const guint8 *resp, gsize n, GError *err) +{ + FpiDeviceSamsung7305 *self = FPI_DEVICE_SAMSUNG7305 (dev); + + if (err) { fpi_ssm_mark_failed (ssm, err); return; } + fp_dbg ("samsung7305: cap_check %zu bytes: %02x %02x %02x %02x %02x (frames=%u)", + n, + n > 0 ? resp[0] : 0, n > 1 ? resp[1] : 0, + n > 2 ? resp[2] : 0, n > 3 ? resp[3] : 0, + n > 4 ? resp[4] : 0, self->frames_captured); + if (n >= 3 && resp[1] == 0x0f && resp[2] == 0xff) + { + if (self->frames_captured >= MAX_FRAMES) + fpi_ssm_jump_to_state (ssm, M_ASSEMBLE); + else + fpi_ssm_next_state (ssm); + } + else if (self->frames_captured > 0) + fpi_ssm_jump_to_state (ssm, M_ASSEMBLE); + else + fpi_ssm_jump_to_state_delayed (ssm, M_POLL_ARM, POLL_DELAY); +} + +/* Capture-setup-sequence loop (cap_setup_seq or ff_setup_seq). */ +static const SamsungCmd * +active_cap_seq (FpiDeviceSamsung7305 *self, gsize *out_len) +{ + if (fpi_ssm_get_cur_state (self->ssm) == M_FF_SETUP) + { + *out_len = G_N_ELEMENTS (ff_setup_seq); + return ff_setup_seq; + } + *out_len = G_N_ELEMENTS (cap_setup_seq); + return cap_setup_seq; +} + +static void +cap_seq_done_cb (FpDevice *dev, FpiSsm *ssm, + const guint8 *resp, gsize n, GError *err) +{ + FpiDeviceSamsung7305 *self = FPI_DEVICE_SAMSUNG7305 (dev); + gsize seq_len; + + if (err) { fpi_ssm_mark_failed (ssm, err); return; } + + fp_dbg ("samsung7305: cap_seq[%u] %zu bytes", self->seq_idx, n); + self->seq_idx++; + active_cap_seq (self, &seq_len); + if (self->seq_idx < seq_len) + run_cap_seq (self); + else + fpi_ssm_next_state (ssm); +} + +static void +run_cap_seq (FpiDeviceSamsung7305 *self) +{ + gsize seq_len; + const SamsungCmd *seq = active_cap_seq (self, &seq_len); + const SamsungCmd *c = &seq[self->seq_idx]; + + bracketed_submit (FP_DEVICE (self), self->ssm, + c->data, c->len, + (guint16) c->len, FALSE, + cap_seq_done_cb); +} + +/* Simple oneshot: advance SSM on completion. Used for trigger (with + * doorbell), between-strips, and the re-poll triple. */ +static void +oneshot_done_cb (FpDevice *dev, FpiSsm *ssm, + const guint8 *resp, gsize n, GError *err) +{ + if (err) { fpi_ssm_mark_failed (ssm, err); return; } + fp_dbg ("samsung7305: oneshot %zu bytes (state %d)", + n, fpi_ssm_get_cur_state (ssm)); + fpi_ssm_next_state (ssm); +} + +/* cap_wait: poll status until STATUS_READY bit set. */ +static void +cap_wait_done_cb (FpDevice *dev, FpiSsm *ssm, + const guint8 *resp, gsize n, GError *err) +{ + if (err) { fpi_ssm_mark_failed (ssm, err); return; } + fp_dbg ("samsung7305: cap_wait %zu bytes: %02x %02x (state %d)", + n, n > 0 ? resp[0] : 0, n > 1 ? resp[1] : 0, + fpi_ssm_get_cur_state (ssm)); + if (n >= 2 && (resp[1] & STATUS_READY)) + fpi_ssm_next_state_delayed (ssm, 5); + else + fpi_ssm_jump_to_state_delayed (ssm, + fpi_ssm_get_cur_state (ssm), + POLL_DELAY); +} + +/* ── Image read callbacks (shared, used by M_STRIP*_READ / M_FRAME_READ) ─ */ + +static void +img_cmd_write_cb (FpiUsbTransfer *transfer, FpDevice *dev, + gpointer unused, GError *error) +{ + if (error) + { + fp_warn ("samsung7305: 0xc4 write error: %s", error->message); + g_error_free (error); + } + else + { + fp_dbg ("samsung7305: 0xc4 write complete (%zu bytes)", + transfer->actual_length); + } +} + +static void +strip_image_read_cb (FpiUsbTransfer *transfer, FpDevice *dev, + gpointer unused, GError *error) +{ + FpiDeviceSamsung7305 *self = FPI_DEVICE_SAMSUNG7305 (dev); + + if (check_deactivating (transfer, error)) + return; + + { + gsize to_copy = MIN ((gsize) transfer->actual_length, + (gsize) (STRIP_SIZE - self->strip_bytes_received)); + if (to_copy > 0 && self->cur_strip < 3) + memcpy (self->img_strip[self->cur_strip] + self->strip_bytes_received, + transfer->buffer, to_copy); + } + self->strip_bytes_received += (guint) transfer->actual_length; + fp_dbg ("samsung7305: strip chunk %zu total=%u/%d", + (gsize) transfer->actual_length, + self->strip_bytes_received, STRIP_SIZE); + + if (self->strip_bytes_received < STRIP_SIZE) + { + FpiUsbTransfer *rd = fpi_usb_transfer_new (dev); + rd->ssm = transfer->ssm; + rd->short_is_error = FALSE; + fpi_usb_transfer_fill_bulk (rd, SAMSUNG_EP_IN, DRAIN_BUF_SIZE); + fpi_usb_transfer_submit (rd, IMG_TIMEOUT, + fpi_device_get_cancellable (dev), + strip_image_read_cb, NULL); + } + else + { + fpi_ssm_next_state (transfer->ssm); + } +} + +static void +image_read_cb (FpiUsbTransfer *transfer, FpDevice *dev, + gpointer unused, GError *error) +{ + FpiDeviceSamsung7305 *self = FPI_DEVICE_SAMSUNG7305 (dev); + gsize to_copy; + + if (check_deactivating (transfer, error)) + return; + + to_copy = MIN ((gsize) transfer->actual_length, + (gsize) (FRAME_SIZE - self->frame_bytes_received)); + if (to_copy > 0) + memcpy (self->img_buf + self->frame_bytes_received, + transfer->buffer, to_copy); + self->frame_bytes_received += (guint) transfer->actual_length; + + fp_dbg ("samsung7305: frame chunk %zu total=%u/%d", + (gsize) transfer->actual_length, + self->frame_bytes_received, FRAME_SIZE); + + if (self->frame_bytes_received < FRAME_SIZE - 2) + { + FpiUsbTransfer *rd = fpi_usb_transfer_new (dev); + rd->ssm = transfer->ssm; + rd->short_is_error = FALSE; + fpi_usb_transfer_fill_bulk (rd, SAMSUNG_EP_IN, DRAIN_BUF_SIZE); + fpi_usb_transfer_submit (rd, IMG_TIMEOUT, + fpi_device_get_cancellable (dev), + image_read_cb, NULL); + } + else + { + fpi_ssm_next_state (transfer->ssm); + } +} + +/* ── SSM state handler ──────────────────────────────────────────────────── */ + +static void +m_loop_state (FpiSsm *ssm, FpDevice *dev) +{ + FpiDeviceSamsung7305 *self = FPI_DEVICE_SAMSUNG7305 (dev); + FpImageDevice *img = FP_IMAGE_DEVICE (dev); + + if (self->deactivating) + { + fpi_ssm_mark_completed (ssm); + return; + } + + switch (fpi_ssm_get_cur_state (ssm)) + { + case M_DRAIN: + { + FpiUsbTransfer *rd = fpi_usb_transfer_new (dev); + rd->ssm = ssm; + rd->short_is_error = FALSE; + fpi_usb_transfer_fill_bulk (rd, SAMSUNG_EP_IN, DRAIN_BUF_SIZE); + fpi_usb_transfer_submit (rd, DRAIN_TIMEOUT, + fpi_device_get_cancellable (dev), + drain_read_cb, NULL); + } + break; + + case M_INIT: + self->seq_idx = 0; + run_init_seq (self); + break; + + case M_POLL_ARM: + bracketed_submit (dev, ssm, cmd_arm, G_N_ELEMENTS (cmd_arm), + (guint16) G_N_ELEMENTS (cmd_arm), TRUE, + arm_done_cb); + break; + + case M_POLL_STATUS: + bracketed_submit (dev, ssm, cmd_status, G_N_ELEMENTS (cmd_status), + (guint16) G_N_ELEMENTS (cmd_status), FALSE, + status_done_cb); + break; + + case M_POLL_CAP: + bracketed_submit (dev, ssm, cmd_cap_rd, G_N_ELEMENTS (cmd_cap_rd), + (guint16) G_N_ELEMENTS (cmd_cap_rd), FALSE, + cap_check_done_cb); + break; + + case M_CAP_SETUP: + fpi_image_device_report_finger_status (img, TRUE); + self->seq_idx = 0; + run_cap_seq (self); + break; + + case M_FF_SETUP: + self->seq_idx = 0; + run_cap_seq (self); + break; + + case M_TRIGGER1: + case M_TRIGGER2: + case M_TRIGGER3: + case M_TRIGGER4: + bracketed_submit (dev, ssm, cmd_trigger, G_N_ELEMENTS (cmd_trigger), + (guint16) G_N_ELEMENTS (cmd_trigger), TRUE, + oneshot_done_cb); + break; + + case M_BETWEEN_S1_S2: + bracketed_submit (dev, ssm, + cmd_between_strips, G_N_ELEMENTS (cmd_between_strips), + (guint16) G_N_ELEMENTS (cmd_between_strips), FALSE, + oneshot_done_cb); + break; + + case M_REPOLL_ARM: + bracketed_submit (dev, ssm, cmd_arm, G_N_ELEMENTS (cmd_arm), + (guint16) G_N_ELEMENTS (cmd_arm), TRUE, + oneshot_done_cb); + break; + + case M_REPOLL_STATUS: + bracketed_submit (dev, ssm, cmd_status, G_N_ELEMENTS (cmd_status), + (guint16) G_N_ELEMENTS (cmd_status), FALSE, + oneshot_done_cb); + break; + + case M_REPOLL_CAP: + bracketed_submit (dev, ssm, cmd_cap_rd, G_N_ELEMENTS (cmd_cap_rd), + (guint16) G_N_ELEMENTS (cmd_cap_rd), FALSE, + oneshot_done_cb); + break; + + case M_WAIT1: + case M_WAIT2: + case M_WAIT3: + case M_WAIT4: + bracketed_submit (dev, ssm, cmd_status, G_N_ELEMENTS (cmd_status), + (guint16) G_N_ELEMENTS (cmd_status), FALSE, + cap_wait_done_cb); + break; + + case M_STRIP1_READ: + case M_STRIP2_READ: + case M_STRIP3_READ: + self->strip_bytes_received = 0; + self->cur_strip = (fpi_ssm_get_cur_state (ssm) == M_STRIP1_READ) ? 0 : + (fpi_ssm_get_cur_state (ssm) == M_STRIP2_READ) ? 1 : 2; + memset (self->img_strip[self->cur_strip], 0, STRIP_SIZE); + bracketed_c4_submit (dev, ssm, self->img_cmd_buf, STRIP_SIZE + 2, + strip_image_read_cb); + break; + + case M_STRIP1_FTR: + case M_STRIP2_FTR: + case M_STRIP3_FTR: + { + FpiUsbTransfer *rd = fpi_usb_transfer_new (dev); + rd->ssm = ssm; + rd->short_is_error = FALSE; + fpi_usb_transfer_fill_bulk (rd, SAMSUNG_EP_IN, DRAIN_BUF_SIZE); + fpi_usb_transfer_submit (rd, DRAIN_TIMEOUT, + fpi_device_get_cancellable (dev), + drain_read_cb, NULL); + } + break; + + case M_FRAME_READ: + self->frame_bytes_received = 0; + bracketed_c4_submit (dev, ssm, self->img_cmd_buf, FRAME_SIZE + 2, + image_read_cb); + break; + + case M_STORE_FRAME: + { + struct fpi_frame *fr = g_malloc0 (sizeof (struct fpi_frame) + FRAME_SIZE); + memcpy (fr->data, self->img_buf + 2, FRAME_SIZE - 2); + self->frames = g_slist_prepend (self->frames, fr); + self->frames_captured++; + fp_dbg ("samsung7305: stored frame %u", self->frames_captured); + if (self->frames_captured >= MAX_FRAMES) + fpi_ssm_jump_to_state (ssm, M_ASSEMBLE); + else + fpi_ssm_jump_to_state (ssm, M_POLL_ARM); + } + break; + + case M_ASSEMBLE: + { + FpImage *assembled; + GSList *ordered = g_slist_reverse (self->frames); + self->frames = NULL; + + if (self->frames_captured < MIN_FRAMES) + { + fp_dbg ("samsung7305: too few frames (%u < %u), requesting retry", + self->frames_captured, MIN_FRAMES); + g_slist_free_full (ordered, g_free); + self->frames_captured = 0; + fpi_image_device_retry_scan (img, FP_DEVICE_RETRY_TOO_SHORT); + fpi_image_device_report_finger_status (img, FALSE); + fpi_ssm_mark_completed (ssm); + return; + } + + /* Drop the first frame (partial contact / AGC settle), then keep + * exactly ASSEMBLE_FRAMES so the assembled geometry is identical + * between enroll and verify regardless of how many frames the + * capture loop collected. */ + { + GSList *head = ordered; + ordered = ordered->next; + head->next = NULL; + g_slist_free_full (head, g_free); + self->frames_captured--; + + GSList *keep_tail = ordered; + for (guint i = 1; i < ASSEMBLE_FRAMES && keep_tail; i++) + keep_tail = keep_tail->next; + if (keep_tail && keep_tail->next) + { + g_slist_free_full (keep_tail->next, g_free); + keep_tail->next = NULL; + } + self->frames_captured = MIN (self->frames_captured, ASSEMBLE_FRAMES); + fp_dbg ("samsung7305: dropped first + truncated, assembling %u", + self->frames_captured); + } + + if (self->frames_captured >= 2) + { + /* Fixed stride instead of motion estimation — see the note + * near ASSEMBLE_STRIDE. First frame's delta_y is forced to 0 + * inside fpi_assemble_frames. */ + for (GSList *l = ordered->next; l != NULL; l = l->next) + { + struct fpi_frame *f = l->data; + f->delta_x = 0; + f->delta_y = ASSEMBLE_STRIDE; + } + assembled = fpi_assemble_frames (&assembling_ctx, ordered); + } + else if (ordered) + { + struct fpi_frame *only = ordered->data; + assembled = fp_image_new (FRAME_WIDTH, FRAME_HEIGHT); + memcpy (assembled->data, only->data, FRAME_SIZE); + } + else + { + assembled = NULL; + } + + g_slist_free_full (ordered, g_free); + self->frames_captured = 0; + + if (!assembled) + { + fpi_ssm_mark_failed (ssm, + fpi_device_error_new (FP_DEVICE_ERROR_GENERAL)); + return; + } + + assembled->ppmm = 19.69; + fp_dbg ("samsung7305: assembled image %ux%u", + assembled->width, assembled->height); + + fpi_image_device_image_captured (img, assembled); + fpi_image_device_report_finger_status (img, FALSE); + fpi_ssm_mark_completed (ssm); + } + break; + + default: + g_assert_not_reached (); + } +} + +/* ── SSM completion ─────────────────────────────────────────────────────── */ + +static void +m_loop_complete (FpiSsm *ssm, FpDevice *dev, GError *error) +{ + FpImageDevice *img = FP_IMAGE_DEVICE (dev); + FpiDeviceSamsung7305 *self = FPI_DEVICE_SAMSUNG7305 (dev); + + /* report_finger_status(FALSE) on the completing SSM can synchronously + * drive fprintd's state machine into AWAIT_FINGER_ON, which invokes + * samsung_dev_change_state and installs a new SSM on self->ssm before + * this completion callback fires. Only null the pointer if it is still + * referring to the SSM that just completed, so we don't clobber the + * successor. */ + if (self->ssm == ssm) + self->ssm = NULL; + + if (self->frames) + { + g_slist_free_full (g_steal_pointer (&self->frames), g_free); + self->frames_captured = 0; + } + + if (self->deactivating) + fpi_image_device_deactivate_complete (img, error); + else if (error) + fpi_image_device_session_error (img, error); +} + +/* ── Session-level vendor control transfers ─────────────────────────────── * + * + * Once per device open/close (PROTOCOL.md → Transport). Synchronous — + * issued outside the SSM. + */ + +static gboolean +session_ctrl_out (GUsbDevice *usb, guint16 value, guint16 idx, GError **error) +{ + return g_usb_device_control_transfer (usb, + G_USB_DEVICE_DIRECTION_HOST_TO_DEVICE, + G_USB_DEVICE_REQUEST_TYPE_VENDOR, + G_USB_DEVICE_RECIPIENT_DEVICE, + 0xdb, value, idx, + NULL, 0, NULL, + CMD_TIMEOUT, NULL, error); +} + +/* ── Device lifecycle ───────────────────────────────────────────────────── */ + +static void +samsung_dev_init (FpImageDevice *dev) +{ + FpiDeviceSamsung7305 *self = FPI_DEVICE_SAMSUNG7305 (dev); + GUsbDevice *usb = fpi_device_get_usb_device (FP_DEVICE (dev)); + GError *error = NULL; + + /* NOTE: g_usb_device_reset() was previously invoked here to clear stale + * EP2 data between sessions, but it also resets the device's AGC/calibration + * state, producing bit-wise-different captures of the same finger across + * fprintd sessions (enroll vs. verify). The M_DRAIN loop in the SSM now + * handles stale data without touching firmware state. */ + + g_usb_device_claim_interface (usb, 0, 0, &error); + if (error) + { + fpi_image_device_open_complete (dev, error); + return; + } + + /* Session-open vendor control transfers: 0xdb wValue=0x0006 wIndex=0,1 + * then 0xdb wValue=0x000b wIndex=0,1. Non-fatal on failure — log only. */ + { + GError *werr = NULL; + if (!session_ctrl_out (usb, 0x0006, 0, &werr)) + { fp_warn ("samsung7305: session open 0xdb/6/0 failed: %s", + werr->message); g_clear_error (&werr); } + if (!session_ctrl_out (usb, 0x0006, 1, &werr)) + { fp_warn ("samsung7305: session open 0xdb/6/1 failed: %s", + werr->message); g_clear_error (&werr); } + if (!session_ctrl_out (usb, 0x000b, 0, &werr)) + { fp_warn ("samsung7305: session open 0xdb/b/0 failed: %s", + werr->message); g_clear_error (&werr); } + if (!session_ctrl_out (usb, 0x000b, 1, &werr)) + { fp_warn ("samsung7305: session open 0xdb/b/1 failed: %s", + werr->message); g_clear_error (&werr); } + } + + self->img_buf = g_malloc0 (FRAME_SIZE + 2); + self->img_cmd_buf = g_malloc0 (FRAME_SIZE + 2); + self->img_cmd_buf[0] = 0xc4; + for (guint s = 0; s < 3; s++) + self->img_strip[s] = g_malloc0 (STRIP_SIZE); + + fpi_image_device_open_complete (dev, NULL); +} + +static void +samsung_dev_deinit (FpImageDevice *dev) +{ + FpiDeviceSamsung7305 *self = FPI_DEVICE_SAMSUNG7305 (dev); + GError *error = NULL; + + g_clear_pointer (&self->img_buf, g_free); + g_clear_pointer (&self->img_cmd_buf, g_free); + for (guint s = 0; s < 3; s++) + g_clear_pointer (&self->img_strip[s], g_free); + if (self->frames) + { + g_slist_free_full (g_steal_pointer (&self->frames), g_free); + self->frames_captured = 0; + } + + g_usb_device_release_interface (fpi_device_get_usb_device (FP_DEVICE (dev)), + 0, 0, &error); + fpi_image_device_close_complete (dev, error); +} + +static void +samsung_dev_activate (FpImageDevice *dev) +{ + FPI_DEVICE_SAMSUNG7305 (dev)->deactivating = FALSE; + fpi_image_device_activate_complete (dev, NULL); +} + +static void +samsung_dev_deactivate (FpImageDevice *dev) +{ + FpiDeviceSamsung7305 *self = FPI_DEVICE_SAMSUNG7305 (dev); + + self->deactivating = TRUE; + if (self->ssm == NULL) + fpi_image_device_deactivate_complete (dev, NULL); +} + +static void +samsung_dev_change_state (FpImageDevice *dev, FpiImageDeviceState state) +{ + FpiDeviceSamsung7305 *self = FPI_DEVICE_SAMSUNG7305 (dev); + + if (state == FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON) + { + FpiSsm *ssm = fpi_ssm_new (FP_DEVICE (dev), m_loop_state, M_NUM_STATES); + self->ssm = ssm; + fpi_ssm_start (ssm, m_loop_complete); + } +} + +/* ── USB ID table ───────────────────────────────────────────────────────── */ + +static const FpIdEntry id_table[] = { + { .vid = 0x04e8, .pid = 0x7305 }, + { .vid = 0, .pid = 0 }, +}; + +/* ── GObject boilerplate ────────────────────────────────────────────────── */ + +static void +fpi_device_samsung7305_init (FpiDeviceSamsung7305 *self) +{ +} + +static void +fpi_device_samsung7305_class_init (FpiDeviceSamsung7305Class *klass) +{ + FpDeviceClass *dev_class = FP_DEVICE_CLASS (klass); + FpImageDeviceClass *img_class = FP_IMAGE_DEVICE_CLASS (klass); + + dev_class->id = FP_COMPONENT; + dev_class->full_name = "Samsung Fingerprint Device (04e8:7305)"; + dev_class->type = FP_DEVICE_TYPE_USB; + dev_class->id_table = id_table; + dev_class->scan_type = FP_SCAN_TYPE_SWIPE; + + img_class->img_width = FRAME_WIDTH; + img_class->img_height = FRAME_HEIGHT; + img_class->bz3_threshold = 10; + + img_class->img_open = samsung_dev_init; + img_class->img_close = samsung_dev_deinit; + img_class->activate = samsung_dev_activate; + img_class->deactivate = samsung_dev_deactivate; + img_class->change_state = samsung_dev_change_state; +} diff --git a/libfprint/meson.build b/libfprint/meson.build index ae0f6e24..4135dd63 100644 --- a/libfprint/meson.build +++ b/libfprint/meson.build @@ -137,6 +137,8 @@ driver_sources = { [ 'drivers/elanspi.c' ], 'nb1010' : [ 'drivers/nb1010.c' ], + 'samsung7305' : + [ 'drivers/samsung7305.c' ], 'virtual_image' : [ 'drivers/virtual-image.c' ], 'virtual_device' : diff --git a/meson.build b/meson.build index 14fb11f2..5f28b60f 100644 --- a/meson.build +++ b/meson.build @@ -141,6 +141,7 @@ default_drivers = [ 'upekts', 'goodixmoc', 'nb1010', + 'samsung7305', 'fpcmoc', 'realtek', 'focaltech_moc', diff --git a/tests/meson.build b/tests/meson.build index 07c924be..ad5f2694 100644 --- a/tests/meson.build +++ b/tests/meson.build @@ -59,6 +59,7 @@ drivers_tests = [ 'realtek', 'realtek-5816', 'focaltech_moc', + 'samsung7305', ] if get_option('introspection') diff --git a/tests/samsung7305/capture.pcapng b/tests/samsung7305/capture.pcapng new file mode 100644 index 0000000000000000000000000000000000000000..e2869bc97d239a542d95ce7f32e2d6c5ac8c9e7b GIT binary patch literal 452672 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�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

M)QnD&Z;8u>qV^kO5lEQ-B9_nlBm^iry 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 W&upxn0l#FoRNXT=Gx6qZ>Hh+HZ`W!7 literal 0 HcmV?d00001 diff --git a/tests/samsung7305/capture.png b/tests/samsung7305/capture.png new file mode 100644 index 0000000000000000000000000000000000000000..00bcb8b7637ee8260a65052891203217783ef14b GIT binary patch literal 21084 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 IM6N<$g1{WXrT_o{ literal 0 HcmV?d00001 diff --git a/tests/samsung7305/device b/tests/samsung7305/device new file mode 100644 index 00000000..b31bdcce --- /dev/null +++ b/tests/samsung7305/device @@ -0,0 +1,261 @@ +P: /devices/pci0000:00/0000:00:14.0/usb1/1-8 +N: bus/usb/001/005=1201000200000008E804057300000102000109022700010100E0320904000003FF02000007050102400000070582024000000705830340000A +E: BUSNUM=001 +E: CURRENT_TAGS=:seat: +E: DEVNAME=/dev/bus/usb/001/005 +E: DEVNUM=005 +E: DEVTYPE=usb_device +E: DRIVER=usb +E: ID_BUS=usb +E: ID_FOR_SEAT=usb-pci-0000_00_14_0-usb-0_8 +E: ID_INTEGRATION=internal +E: ID_MODEL=Fingerprint_Device +E: ID_MODEL_ENC=Fingerprint\x20Device +E: ID_MODEL_ID=7305 +E: ID_PATH=pci-0000:00:14.0-usb-0:8 +E: ID_PATH_TAG=pci-0000_00_14_0-usb-0_8 +E: ID_PATH_WITH_USB_REVISION=pci-0000:00:14.0-usbv2-0:8 +E: ID_REVISION=0000 +E: ID_SERIAL=Samsung_Fingerprint_Device +E: ID_USB_INTERFACES=:ff0200: +E: ID_USB_MODEL=Fingerprint_Device +E: ID_USB_MODEL_ENC=Fingerprint\x20Device +E: ID_USB_MODEL_ID=7305 +E: ID_USB_REVISION=0000 +E: ID_USB_SERIAL=Samsung_Fingerprint_Device +E: ID_USB_VENDOR=Samsung +E: ID_USB_VENDOR_ENC=Samsung +E: ID_USB_VENDOR_ID=04e8 +E: ID_VENDOR=Samsung +E: ID_VENDOR_ENC=Samsung +E: ID_VENDOR_FROM_DATABASE=Samsung Electronics Co., Ltd +E: ID_VENDOR_ID=04e8 +E: MAJOR=189 +E: MINOR=4 +E: PRODUCT=4e8/7305/0 +E: SUBSYSTEM=usb +E: TAGS=:seat: +E: TYPE=0/0/0 +A: authorized=1\n +A: avoid_reset_quirk=0\n +A: bConfigurationValue=1\n +A: bDeviceClass=00\n +A: bDeviceProtocol=00\n +A: bDeviceSubClass=00\n +A: bMaxPacketSize0=8\n +A: bMaxPower=100mA\n +A: bNumConfigurations=1\n +A: bNumInterfaces= 1\n +A: bcdDevice=0000\n +A: bmAttributes=e0\n +A: busnum=1\n +A: configuration= +H: descriptors=1201000200000008E804057300000102000109022700010100E0320904000003FF02000007050102400000070582024000000705830340000A +A: dev=189:4\n +A: devnum=5\n +A: devpath=8\n +L: driver=../../../../../bus/usb/drivers/usb +L: firmware_node=../../../../LNXSYSTM:00/LNXSYBUS:00/PNP0A08:00/device:4d/device:4e/device:57 +A: idProduct=7305\n +A: idVendor=04e8\n +A: ltm_capable=no\n +A: manufacturer=Samsung\n +A: maxchild=0\n +A: physical_location/dock=no\n +A: physical_location/horizontal_position=center\n +A: physical_location/lid=no\n +A: physical_location/panel=unknown\n +A: physical_location/vertical_position=center\n +L: port=../1-0:1.0/usb1-port8 +A: power/active_duration=3119015\n +A: power/autosuspend=2\n +A: power/autosuspend_delay_ms=2000\n +A: power/connected_duration=3119015\n +A: power/control=on\n +A: power/level=on\n +A: power/persist=0\n +A: power/runtime_active_time=3118779\n +A: power/runtime_status=active\n +A: power/runtime_suspended_time=0\n +A: power/wakeup=disabled\n +A: power/wakeup_abort_count=\n +A: power/wakeup_active=\n +A: power/wakeup_active_count=\n +A: power/wakeup_count=\n +A: power/wakeup_expire_count=\n +A: power/wakeup_last_time_ms=\n +A: power/wakeup_max_time_ms=\n +A: power/wakeup_total_time_ms=\n +A: product=Fingerprint Device\n +A: quirks=0x0\n +A: removable=fixed\n +A: rx_lanes=1\n +A: speed=12\n +A: tx_lanes=1\n +A: urbnum=5360\n +A: version= 2.00\n + +P: /devices/pci0000:00/0000:00:14.0/usb1 +N: bus/usb/001/001=12010002090001406B1D020019060302010109021900010100E0000904000001090000000705810304000C +E: BUSNUM=001 +E: CURRENT_TAGS=:seat: +E: DEVNAME=/dev/bus/usb/001/001 +E: DEVNUM=001 +E: DEVTYPE=usb_device +E: DRIVER=usb +E: ID_AUTOSUSPEND=1 +E: ID_BUS=usb +E: ID_FOR_SEAT=usb-pci-0000_00_14_0 +E: ID_MODEL=xHCI_Host_Controller +E: ID_MODEL_ENC=xHCI\x20Host\x20Controller +E: ID_MODEL_FROM_DATABASE=2.0 root hub +E: ID_MODEL_ID=0002 +E: ID_PATH=pci-0000:00:14.0 +E: ID_PATH_TAG=pci-0000_00_14_0 +E: ID_REVISION=0619 +E: ID_SERIAL=Linux_6.19.11-arch1-1_xhci-hcd_xHCI_Host_Controller_0000:00:14.0 +E: ID_SERIAL_SHORT=0000:00:14.0 +E: ID_USB_INTERFACES=:090000: +E: ID_USB_MODEL=xHCI_Host_Controller +E: ID_USB_MODEL_ENC=xHCI\x20Host\x20Controller +E: ID_USB_MODEL_ID=0002 +E: ID_USB_REVISION=0619 +E: ID_USB_SERIAL=Linux_6.19.11-arch1-1_xhci-hcd_xHCI_Host_Controller_0000:00:14.0 +E: ID_USB_SERIAL_SHORT=0000:00:14.0 +E: ID_USB_VENDOR=Linux_6.19.11-arch1-1_xhci-hcd +E: ID_USB_VENDOR_ENC=Linux\x206.19.11-arch1-1\x20xhci-hcd +E: ID_USB_VENDOR_ID=1d6b +E: ID_VENDOR=Linux_6.19.11-arch1-1_xhci-hcd +E: ID_VENDOR_ENC=Linux\x206.19.11-arch1-1\x20xhci-hcd +E: ID_VENDOR_FROM_DATABASE=Linux Foundation +E: ID_VENDOR_ID=1d6b +E: MAJOR=189 +E: MINOR=0 +E: PRODUCT=1d6b/2/619 +E: SUBSYSTEM=usb +E: TAGS=:seat: +E: TYPE=9/0/1 +A: authorized=1\n +A: authorized_default=1\n +A: avoid_reset_quirk=0\n +A: bConfigurationValue=1\n +A: bDeviceClass=09\n +A: bDeviceProtocol=01\n +A: bDeviceSubClass=00\n +A: bMaxPacketSize0=64\n +A: bMaxPower=0mA\n +A: bNumConfigurations=1\n +A: bNumInterfaces= 1\n +A: bcdDevice=0619\n +A: bmAttributes=e0\n +A: busnum=1\n +A: configuration= +H: descriptors=12010002090001406B1D020019060302010109021900010100E0000904000001090000000705810304000C +A: dev=189:0\n +A: devnum=1\n +A: devpath=0\n +L: driver=../../../../bus/usb/drivers/usb +L: firmware_node=../../../LNXSYSTM:00/LNXSYBUS:00/PNP0A08:00/device:4d/device:4e +A: idProduct=0002\n +A: idVendor=1d6b\n +A: interface_authorized_default=1\n +A: ltm_capable=no\n +A: manufacturer=Linux 6.19.11-arch1-1 xhci-hcd\n +A: maxchild=12\n +A: power/active_duration=3119934\n +A: power/autosuspend=0\n +A: power/autosuspend_delay_ms=0\n +A: power/connected_duration=3119934\n +A: power/control=auto\n +A: power/level=auto\n +A: power/runtime_active_time=3119932\n +A: power/runtime_status=active\n +A: power/runtime_suspended_time=0\n +A: power/wakeup=disabled\n +A: power/wakeup_abort_count=\n +A: power/wakeup_active=\n +A: power/wakeup_active_count=\n +A: power/wakeup_count=\n +A: power/wakeup_expire_count=\n +A: power/wakeup_last_time_ms=\n +A: power/wakeup_max_time_ms=\n +A: power/wakeup_total_time_ms=\n +A: product=xHCI Host Controller\n +A: quirks=0x0\n +A: removable=unknown\n +A: rx_lanes=1\n +A: serial=0000:00:14.0\n +A: speed=480\n +A: tx_lanes=1\n +A: urbnum=255\n +A: version= 2.00\n + +P: /devices/pci0000:00/0000:00:14.0 +E: DRIVER=xhci_hcd +E: ID_AUTOSUSPEND=1 +E: ID_MODEL_FROM_DATABASE=Sunrise Point-LP USB 3.0 xHCI Controller +E: ID_PATH=pci-0000:00:14.0 +E: ID_PATH_TAG=pci-0000_00_14_0 +E: ID_PCI_CLASS_FROM_DATABASE=Serial bus controller +E: ID_PCI_INTERFACE_FROM_DATABASE=XHCI +E: ID_PCI_SUBCLASS_FROM_DATABASE=USB controller +E: ID_VENDOR_FROM_DATABASE=Intel Corporation +E: MODALIAS=pci:v00008086d00009D2Fsv0000144Dsd0000C165bc0Csc03i30 +E: PCI_CLASS=C0330 +E: PCI_ID=8086:9D2F +E: PCI_SLOT_NAME=0000:00:14.0 +E: PCI_SUBSYS_ID=144D:C165 +E: SUBSYSTEM=pci +A: ari_enabled=0\n +A: broken_parity_status=0\n +A: class=0x0c0330\n +H: config=86802F9D060490022130030C00008000040021F70000000000000000000000000000000000000000000000004D1465C10000000070000000000000000B010000FD01348088C60F8000000000000000005B6ECE0F000000000000000000000000306000000000000000000000000000000180C2C10800000000000000000000000500B7001803E0FE0000000000000000090014F01000400100000000C10A080000080000001800008F40020000010400FF0F0000000000000000000000000000000000000000000000000000000000003F000000000000000000000000000000000000000000000000000000000000000000000000000000B30F410800000000 +A: consistent_dma_mask_bits=64\n +A: d3cold_allowed=1\n +A: dbc=disabled\n +A: dbc_bInterfaceProtocol=01\n +A: dbc_bcdDevice=0010\n +A: dbc_idProduct=0010\n +A: dbc_idVendor=1d6b\n +A: dbc_poll_interval_ms=64\n +A: device=0x9d2f\n +A: dma_mask_bits=64\n +L: driver=../../../bus/pci/drivers/xhci_hcd +A: driver_override=(null)\n +A: enable=1\n +L: firmware_node=../../LNXSYSTM:00/LNXSYBUS:00/PNP0A08:00/device:4d +A: irq=122\n +A: local_cpulist=0-7\n +A: local_cpus=ff\n +A: modalias=pci:v00008086d00009D2Fsv0000144Dsd0000C165bc0Csc03i30\n +A: msi_bus=1\n +A: msi_irqs/122=msi\n +A: msi_irqs/123=msi\n +A: msi_irqs/124=msi\n +A: msi_irqs/125=msi\n +A: msi_irqs/126=msi\n +A: msi_irqs/127=msi\n +A: msi_irqs/128=msi\n +A: msi_irqs/129=msi\n +A: numa_node=-1\n +A: pools=poolinfo - 0.1\nbuffer-2048 0 0 2048 0\nbuffer-512 0 0 512 0\nbuffer-128 0 0 128 0\nbuffer-32 0 0 32 0\nxHCI 256 port bw ctx arrays 0 0 256 0\nxHCI 1KB stream ctx arrays 0 0 1024 0\nxHCI 256 byte stream ctx arrays 0 0 256 0\nxHCI input/output contexts 8 9 2112 9\nxHCI ring segments 33 33 4096 33\nbuffer-2048 0 0 2048 0\nbuffer-512 3 8 512 1\nbuffer-128 0 0 128 0\nbuffer-32 0 0 32 0\n +A: power/control=auto\n +A: power/runtime_active_time=3120191\n +A: power/runtime_status=active\n +A: power/runtime_suspended_time=0\n +A: power/wakeup=enabled\n +A: power/wakeup_abort_count=0\n +A: power/wakeup_active=0\n +A: power/wakeup_active_count=0\n +A: power/wakeup_count=0\n +A: power/wakeup_expire_count=0\n +A: power/wakeup_last_time_ms=0\n +A: power/wakeup_max_time_ms=0\n +A: power/wakeup_total_time_ms=0\n +A: power_state=D0\n +A: resource=0x00000000f7210000 0x00000000f721ffff 0x0000000000140204\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n +A: revision=0x21\n +A: subsystem_device=0xc165\n +A: subsystem_vendor=0x144d\n +A: vendor=0x8086\n + From 006720505950dce3aa251ed06d0125560344a682 Mon Sep 17 00:00:00 2001 From: Justin Hall Date: Thu, 23 Apr 2026 11:45:48 -0400 Subject: [PATCH 2/3] samsung7305: apply uncrustify formatting Co-Authored-By: Claude Sonnet 4.6 --- libfprint/drivers/samsung7305.c | 312 +++++++++++++++++++++----------- 1 file changed, 210 insertions(+), 102 deletions(-) diff --git a/libfprint/drivers/samsung7305.c b/libfprint/drivers/samsung7305.c index ae421934..af7ec3aa 100644 --- a/libfprint/drivers/samsung7305.c +++ b/libfprint/drivers/samsung7305.c @@ -60,32 +60,32 @@ static struct fpi_frame_asmbl_ctx assembling_ctx = { /* ── Image geometry ─────────────────────────────────────────────────────── */ -#define FRAME_WIDTH 56 +#define FRAME_WIDTH 56 #define FRAME_HEIGHT 192 -#define FRAME_SIZE (FRAME_WIDTH * FRAME_HEIGHT) /* 10752 bytes */ +#define FRAME_SIZE (FRAME_WIDTH * FRAME_HEIGHT) /* 10752 bytes */ -#define STRIP_WIDTH 56 +#define STRIP_WIDTH 56 #define STRIP_HEIGHT 24 -#define STRIP_SIZE (STRIP_WIDTH * STRIP_HEIGHT) /* 1344 bytes */ +#define STRIP_SIZE (STRIP_WIDTH * STRIP_HEIGHT) /* 1344 bytes */ /* ── USB endpoints ──────────────────────────────────────────────────────── */ #define SAMSUNG_EP_OUT (0x01 | FPI_USB_ENDPOINT_OUT) -#define SAMSUNG_EP_IN (0x02 | FPI_USB_ENDPOINT_IN) +#define SAMSUNG_EP_IN (0x02 | FPI_USB_ENDPOINT_IN) /* ── Timeouts ───────────────────────────────────────────────────────────── */ -#define CMD_TIMEOUT 2000 -#define IMG_TIMEOUT 5000 -#define POLL_DELAY 30 -#define DRAIN_TIMEOUT 50 +#define CMD_TIMEOUT 2000 +#define IMG_TIMEOUT 5000 +#define POLL_DELAY 30 +#define DRAIN_TIMEOUT 50 #define DRAIN_BUF_SIZE 16384 /* ── Status register (0x1c 0x00) response byte[1] values ───────────────── */ #define STATUS_FINGER 0x81 -#define STATUS_IDLE 0x80 -#define STATUS_READY 0x20 +#define STATUS_IDLE 0x80 +#define STATUS_READY 0x20 /* ── Protocol: init sequence ────────────────────────────────────────────── */ @@ -139,7 +139,8 @@ static const guint8 heartbeat_payload[16] = { 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; -typedef struct { +typedef struct +{ const guint8 *data; gsize len; } SamsungCmd; @@ -219,18 +220,18 @@ enum { struct _FpiDeviceSamsung7305 { - FpImageDevice parent; - FpiSsm *ssm; - guint8 *img_buf; - guint8 *img_cmd_buf; - guint8 *img_strip[3]; - guint cur_strip; - gboolean deactivating; - guint seq_idx; - guint strip_bytes_received; - guint frame_bytes_received; - GSList *frames; /* GSList of struct fpi_frame*, prepended */ - guint frames_captured; + FpImageDevice parent; + FpiSsm *ssm; + guint8 *img_buf; + guint8 *img_cmd_buf; + guint8 *img_strip[3]; + guint cur_strip; + gboolean deactivating; + guint seq_idx; + guint strip_bytes_received; + guint frame_bytes_received; + GSList *frames; /* GSList of struct fpi_frame*, prepended */ + guint frames_captured; }; G_DECLARE_FINAL_TYPE (FpiDeviceSamsung7305, fpi_device_samsung7305, @@ -239,25 +240,38 @@ G_DEFINE_TYPE (FpiDeviceSamsung7305, fpi_device_samsung7305, FP_TYPE_IMAGE_DEVIC /* ── Forward declarations ───────────────────────────────────────────────── */ -typedef void (*ExchangeDone) (FpDevice *dev, FpiSsm *ssm, - const guint8 *resp, gsize resp_len, - GError *error); +typedef void (*ExchangeDone) (FpDevice *dev, + FpiSsm *ssm, + const guint8 *resp, + gsize resp_len, + GError *error); -static void run_init_seq (FpiDeviceSamsung7305 *self); -static void run_cap_seq (FpiDeviceSamsung7305 *self); -static void strip_image_read_cb (FpiUsbTransfer *transfer, FpDevice *dev, - gpointer unused, GError *error); -static void image_read_cb (FpiUsbTransfer *transfer, FpDevice *dev, - gpointer unused, GError *error); -static void img_cmd_write_cb (FpiUsbTransfer *transfer, FpDevice *dev, - gpointer unused, GError *error); +static void run_init_seq (FpiDeviceSamsung7305 *self); +static void run_cap_seq (FpiDeviceSamsung7305 *self); +static void strip_image_read_cb (FpiUsbTransfer *transfer, + FpDevice *dev, + gpointer unused, + GError *error); +static void image_read_cb (FpiUsbTransfer *transfer, + FpDevice *dev, + gpointer unused, + GError *error); +static void img_cmd_write_cb (FpiUsbTransfer *transfer, + FpDevice *dev, + gpointer unused, + GError *error); -static void bracketed_submit (FpDevice *dev, FpiSsm *ssm, - const guint8 *cmd, gsize cmd_len, - guint16 prime_len, gboolean doorbell, - ExchangeDone done_cb); -static void bracketed_c4_submit (FpDevice *dev, FpiSsm *ssm, - guint8 *cmd_buf, gsize len, +static void bracketed_submit (FpDevice *dev, + FpiSsm *ssm, + const guint8 *cmd, + gsize cmd_len, + guint16 prime_len, + gboolean doorbell, + ExchangeDone done_cb); +static void bracketed_c4_submit (FpDevice *dev, + FpiSsm *ssm, + guint8 *cmd_buf, + gsize len, FpiUsbTransferCallback read_cb); /* ── Deactivation guard ─────────────────────────────────────────────────── */ @@ -302,7 +316,8 @@ check_deactivating (FpiUsbTransfer *transfer, GError *error) * or g_error_free. */ -typedef struct { +typedef struct +{ const guint8 *cmd; gsize cmd_len; guint16 prime_len; @@ -312,18 +327,33 @@ typedef struct { gsize resp_actual; } ExchangeCtx; -static void ex_after_heartbeat (FpiUsbTransfer *t, FpDevice *dev, gpointer ud, GError *err); -static void ex_after_prime (FpiUsbTransfer *t, FpDevice *dev, gpointer ud, GError *err); -static void ex_after_write (FpiUsbTransfer *t, FpDevice *dev, gpointer ud, GError *err); -static void ex_after_read (FpiUsbTransfer *t, FpDevice *dev, gpointer ud, GError *err); -static void ex_after_doorbell (FpiUsbTransfer *t, FpDevice *dev, gpointer ud, GError *err); +static void ex_after_heartbeat (FpiUsbTransfer *t, + FpDevice *dev, + gpointer ud, + GError *err); +static void ex_after_prime (FpiUsbTransfer *t, + FpDevice *dev, + gpointer ud, + GError *err); +static void ex_after_write (FpiUsbTransfer *t, + FpDevice *dev, + gpointer ud, + GError *err); +static void ex_after_read (FpiUsbTransfer *t, + FpDevice *dev, + gpointer ud, + GError *err); +static void ex_after_doorbell (FpiUsbTransfer *t, + FpDevice *dev, + gpointer ud, + GError *err); static void ex_complete (FpDevice *dev, FpiSsm *ssm, ExchangeCtx *ctx, GError *err) { ExchangeDone cb = ctx->done_cb; - guint8 *buf = ctx->resp_buf; - gsize n = ctx->resp_actual; + guint8 *buf = ctx->resp_buf; + gsize n = ctx->resp_actual; ctx->resp_buf = NULL; g_free (ctx); @@ -339,7 +369,8 @@ ex_check_bail (FpiUsbTransfer *t, ExchangeCtx *ctx, GError *err) if (self->deactivating) { - if (err) g_error_free (err); + if (err) + g_error_free (err); fpi_ssm_mark_completed (t->ssm); g_free (ctx->resp_buf); g_free (ctx); @@ -359,7 +390,7 @@ bracketed_submit (FpDevice *dev, FpiSsm *ssm, guint16 prime_len, gboolean doorbell, ExchangeDone done_cb) { - ExchangeCtx *ctx = g_new0 (ExchangeCtx, 1); + ExchangeCtx *ctx = g_new0 (ExchangeCtx, 1); FpiUsbTransfer *t; ctx->cmd = cmd; @@ -385,10 +416,11 @@ bracketed_submit (FpDevice *dev, FpiSsm *ssm, static void ex_after_heartbeat (FpiUsbTransfer *t, FpDevice *dev, gpointer ud, GError *err) { - ExchangeCtx *ctx = ud; + ExchangeCtx *ctx = ud; FpiUsbTransfer *n; - if (ex_check_bail (t, ctx, err)) return; + if (ex_check_bail (t, ctx, err)) + return; n = fpi_usb_transfer_new (dev); n->ssm = t->ssm; @@ -406,10 +438,11 @@ ex_after_heartbeat (FpiUsbTransfer *t, FpDevice *dev, gpointer ud, GError *err) static void ex_after_prime (FpiUsbTransfer *t, FpDevice *dev, gpointer ud, GError *err) { - ExchangeCtx *ctx = ud; + ExchangeCtx *ctx = ud; FpiUsbTransfer *n; - if (ex_check_bail (t, ctx, err)) return; + if (ex_check_bail (t, ctx, err)) + return; n = fpi_usb_transfer_new (dev); n->ssm = t->ssm; @@ -424,10 +457,11 @@ ex_after_prime (FpiUsbTransfer *t, FpDevice *dev, gpointer ud, GError *err) static void ex_after_write (FpiUsbTransfer *t, FpDevice *dev, gpointer ud, GError *err) { - ExchangeCtx *ctx = ud; + ExchangeCtx *ctx = ud; FpiUsbTransfer *n; - if (ex_check_bail (t, ctx, err)) return; + if (ex_check_bail (t, ctx, err)) + return; n = fpi_usb_transfer_new (dev); n->ssm = t->ssm; @@ -441,10 +475,11 @@ ex_after_write (FpiUsbTransfer *t, FpDevice *dev, gpointer ud, GError *err) static void ex_after_read (FpiUsbTransfer *t, FpDevice *dev, gpointer ud, GError *err) { - ExchangeCtx *ctx = ud; + ExchangeCtx *ctx = ud; FpiUsbTransfer *n; - if (ex_check_bail (t, ctx, err)) return; + if (ex_check_bail (t, ctx, err)) + return; ctx->resp_actual = t->actual_length; ctx->resp_buf = g_memdup2 (t->buffer, t->actual_length); @@ -476,7 +511,8 @@ ex_after_doorbell (FpiUsbTransfer *t, FpDevice *dev, gpointer ud, GError *err) if (self->deactivating) { - if (err) g_error_free (err); + if (err) + g_error_free (err); fpi_ssm_mark_completed (t->ssm); g_free (ctx->resp_buf); g_free (ctx); @@ -496,21 +532,28 @@ ex_after_doorbell (FpiUsbTransfer *t, FpDevice *dev, gpointer ud, GError *err) * the padded command on EP1 (see STATE.md § "0xc4 image read command"). */ -typedef struct { +typedef struct +{ guint8 *cmd_buf; gsize len; FpiUsbTransferCallback read_cb; } C4Ctx; -static void c4_after_heartbeat (FpiUsbTransfer *t, FpDevice *dev, gpointer ud, GError *err); -static void c4_after_prime (FpiUsbTransfer *t, FpDevice *dev, gpointer ud, GError *err); +static void c4_after_heartbeat (FpiUsbTransfer *t, + FpDevice *dev, + gpointer ud, + GError *err); +static void c4_after_prime (FpiUsbTransfer *t, + FpDevice *dev, + gpointer ud, + GError *err); static void bracketed_c4_submit (FpDevice *dev, FpiSsm *ssm, guint8 *cmd_buf, gsize len, FpiUsbTransferCallback read_cb) { - C4Ctx *c = g_new0 (C4Ctx, 1); + C4Ctx *c = g_new0 (C4Ctx, 1); FpiUsbTransfer *t; c->cmd_buf = cmd_buf; @@ -534,14 +577,24 @@ bracketed_c4_submit (FpDevice *dev, FpiSsm *ssm, static void c4_after_heartbeat (FpiUsbTransfer *t, FpDevice *dev, gpointer ud, GError *err) { - C4Ctx *c = ud; + C4Ctx *c = ud; FpiDeviceSamsung7305 *self = FPI_DEVICE_SAMSUNG7305 (dev); - FpiUsbTransfer *n; + FpiUsbTransfer *n; if (self->deactivating) - { if (err) g_error_free (err); fpi_ssm_mark_completed (t->ssm); g_free (c); return; } + { + if (err) + g_error_free (err); + fpi_ssm_mark_completed (t->ssm); + g_free (c); + return; + } if (err) - { fpi_ssm_mark_failed (t->ssm, err); g_free (c); return; } + { + fpi_ssm_mark_failed (t->ssm, err); + g_free (c); + return; + } n = fpi_usb_transfer_new (dev); n->ssm = t->ssm; @@ -559,14 +612,24 @@ c4_after_heartbeat (FpiUsbTransfer *t, FpDevice *dev, gpointer ud, GError *err) static void c4_after_prime (FpiUsbTransfer *t, FpDevice *dev, gpointer ud, GError *err) { - C4Ctx *c = ud; + C4Ctx *c = ud; FpiDeviceSamsung7305 *self = FPI_DEVICE_SAMSUNG7305 (dev); - FpiUsbTransfer *rd, *wr; + FpiUsbTransfer *rd, *wr; if (self->deactivating) - { if (err) g_error_free (err); fpi_ssm_mark_completed (t->ssm); g_free (c); return; } + { + if (err) + g_error_free (err); + fpi_ssm_mark_completed (t->ssm); + g_free (c); + return; + } if (err) - { fpi_ssm_mark_failed (t->ssm, err); g_free (c); return; } + { + fpi_ssm_mark_failed (t->ssm, err); + g_free (c); + return; + } rd = fpi_usb_transfer_new (dev); rd->ssm = t->ssm; @@ -597,7 +660,8 @@ drain_read_cb (FpiUsbTransfer *transfer, FpDevice *dev, if (self->deactivating) { - if (error) g_error_free (error); + if (error) + g_error_free (error); fpi_ssm_mark_completed (transfer->ssm); return; } @@ -627,7 +691,11 @@ init_done_cb (FpDevice *dev, FpiSsm *ssm, { FpiDeviceSamsung7305 *self = FPI_DEVICE_SAMSUNG7305 (dev); - if (err) { fpi_ssm_mark_failed (ssm, err); return; } + if (err) + { + fpi_ssm_mark_failed (ssm, err); + return; + } fp_dbg ("samsung7305: init[%u] read %zu bytes: %02x %02x", self->seq_idx, n, @@ -658,7 +726,11 @@ static void arm_done_cb (FpDevice *dev, FpiSsm *ssm, const guint8 *resp, gsize n, GError *err) { - if (err) { fpi_ssm_mark_failed (ssm, err); return; } + if (err) + { + fpi_ssm_mark_failed (ssm, err); + return; + } fp_dbg ("samsung7305: arm %zu bytes", n); fpi_ssm_next_state (ssm); } @@ -668,7 +740,11 @@ static void status_done_cb (FpDevice *dev, FpiSsm *ssm, const guint8 *resp, gsize n, GError *err) { - if (err) { fpi_ssm_mark_failed (ssm, err); return; } + if (err) + { + fpi_ssm_mark_failed (ssm, err); + return; + } fp_dbg ("samsung7305: status %zu bytes: %02x %02x", n, n > 0 ? resp[0] : 0, n > 1 ? resp[1] : 0); if (n >= 2 && resp[1] == STATUS_FINGER) @@ -686,7 +762,11 @@ cap_check_done_cb (FpDevice *dev, FpiSsm *ssm, { FpiDeviceSamsung7305 *self = FPI_DEVICE_SAMSUNG7305 (dev); - if (err) { fpi_ssm_mark_failed (ssm, err); return; } + if (err) + { + fpi_ssm_mark_failed (ssm, err); + return; + } fp_dbg ("samsung7305: cap_check %zu bytes: %02x %02x %02x %02x %02x (frames=%u)", n, n > 0 ? resp[0] : 0, n > 1 ? resp[1] : 0, @@ -700,9 +780,13 @@ cap_check_done_cb (FpDevice *dev, FpiSsm *ssm, fpi_ssm_next_state (ssm); } else if (self->frames_captured > 0) - fpi_ssm_jump_to_state (ssm, M_ASSEMBLE); + { + fpi_ssm_jump_to_state (ssm, M_ASSEMBLE); + } else - fpi_ssm_jump_to_state_delayed (ssm, M_POLL_ARM, POLL_DELAY); + { + fpi_ssm_jump_to_state_delayed (ssm, M_POLL_ARM, POLL_DELAY); + } } /* Capture-setup-sequence loop (cap_setup_seq or ff_setup_seq). */ @@ -723,9 +807,13 @@ cap_seq_done_cb (FpDevice *dev, FpiSsm *ssm, const guint8 *resp, gsize n, GError *err) { FpiDeviceSamsung7305 *self = FPI_DEVICE_SAMSUNG7305 (dev); - gsize seq_len; + gsize seq_len; - if (err) { fpi_ssm_mark_failed (ssm, err); return; } + if (err) + { + fpi_ssm_mark_failed (ssm, err); + return; + } fp_dbg ("samsung7305: cap_seq[%u] %zu bytes", self->seq_idx, n); self->seq_idx++; @@ -739,7 +827,7 @@ cap_seq_done_cb (FpDevice *dev, FpiSsm *ssm, static void run_cap_seq (FpiDeviceSamsung7305 *self) { - gsize seq_len; + gsize seq_len; const SamsungCmd *seq = active_cap_seq (self, &seq_len); const SamsungCmd *c = &seq[self->seq_idx]; @@ -755,7 +843,11 @@ static void oneshot_done_cb (FpDevice *dev, FpiSsm *ssm, const guint8 *resp, gsize n, GError *err) { - if (err) { fpi_ssm_mark_failed (ssm, err); return; } + if (err) + { + fpi_ssm_mark_failed (ssm, err); + return; + } fp_dbg ("samsung7305: oneshot %zu bytes (state %d)", n, fpi_ssm_get_cur_state (ssm)); fpi_ssm_next_state (ssm); @@ -766,7 +858,11 @@ static void cap_wait_done_cb (FpDevice *dev, FpiSsm *ssm, const guint8 *resp, gsize n, GError *err) { - if (err) { fpi_ssm_mark_failed (ssm, err); return; } + if (err) + { + fpi_ssm_mark_failed (ssm, err); + return; + } fp_dbg ("samsung7305: cap_wait %zu bytes: %02x %02x (state %d)", n, n > 0 ? resp[0] : 0, n > 1 ? resp[1] : 0, fpi_ssm_get_cur_state (ssm)); @@ -838,7 +934,7 @@ image_read_cb (FpiUsbTransfer *transfer, FpDevice *dev, gpointer unused, GError *error) { FpiDeviceSamsung7305 *self = FPI_DEVICE_SAMSUNG7305 (dev); - gsize to_copy; + gsize to_copy; if (check_deactivating (transfer, error)) return; @@ -876,7 +972,7 @@ static void m_loop_state (FpiSsm *ssm, FpDevice *dev) { FpiDeviceSamsung7305 *self = FPI_DEVICE_SAMSUNG7305 (dev); - FpImageDevice *img = FP_IMAGE_DEVICE (dev); + FpImageDevice *img = FP_IMAGE_DEVICE (dev); if (self->deactivating) { @@ -1023,7 +1119,7 @@ m_loop_state (FpiSsm *ssm, FpDevice *dev) case M_ASSEMBLE: { FpImage *assembled; - GSList *ordered = g_slist_reverse (self->frames); + GSList *ordered = g_slist_reverse (self->frames); self->frames = NULL; if (self->frames_captured < MIN_FRAMES) @@ -1092,7 +1188,7 @@ m_loop_state (FpiSsm *ssm, FpDevice *dev) if (!assembled) { fpi_ssm_mark_failed (ssm, - fpi_device_error_new (FP_DEVICE_ERROR_GENERAL)); + fpi_device_error_new (FP_DEVICE_ERROR_GENERAL)); return; } @@ -1116,7 +1212,7 @@ m_loop_state (FpiSsm *ssm, FpDevice *dev) static void m_loop_complete (FpiSsm *ssm, FpDevice *dev, GError *error) { - FpImageDevice *img = FP_IMAGE_DEVICE (dev); + FpImageDevice *img = FP_IMAGE_DEVICE (dev); FpiDeviceSamsung7305 *self = FPI_DEVICE_SAMSUNG7305 (dev); /* report_finger_status(FALSE) on the completing SSM can synchronously @@ -1164,8 +1260,8 @@ static void samsung_dev_init (FpImageDevice *dev) { FpiDeviceSamsung7305 *self = FPI_DEVICE_SAMSUNG7305 (dev); - GUsbDevice *usb = fpi_device_get_usb_device (FP_DEVICE (dev)); - GError *error = NULL; + GUsbDevice *usb = fpi_device_get_usb_device (FP_DEVICE (dev)); + GError *error = NULL; /* NOTE: g_usb_device_reset() was previously invoked here to clear stale * EP2 data between sessions, but it also resets the device's AGC/calibration @@ -1185,17 +1281,29 @@ samsung_dev_init (FpImageDevice *dev) { GError *werr = NULL; if (!session_ctrl_out (usb, 0x0006, 0, &werr)) - { fp_warn ("samsung7305: session open 0xdb/6/0 failed: %s", - werr->message); g_clear_error (&werr); } + { + fp_warn ("samsung7305: session open 0xdb/6/0 failed: %s", + werr->message); + g_clear_error (&werr); + } if (!session_ctrl_out (usb, 0x0006, 1, &werr)) - { fp_warn ("samsung7305: session open 0xdb/6/1 failed: %s", - werr->message); g_clear_error (&werr); } + { + fp_warn ("samsung7305: session open 0xdb/6/1 failed: %s", + werr->message); + g_clear_error (&werr); + } if (!session_ctrl_out (usb, 0x000b, 0, &werr)) - { fp_warn ("samsung7305: session open 0xdb/b/0 failed: %s", - werr->message); g_clear_error (&werr); } + { + fp_warn ("samsung7305: session open 0xdb/b/0 failed: %s", + werr->message); + g_clear_error (&werr); + } if (!session_ctrl_out (usb, 0x000b, 1, &werr)) - { fp_warn ("samsung7305: session open 0xdb/b/1 failed: %s", - werr->message); g_clear_error (&werr); } + { + fp_warn ("samsung7305: session open 0xdb/b/1 failed: %s", + werr->message); + g_clear_error (&werr); + } } self->img_buf = g_malloc0 (FRAME_SIZE + 2); @@ -1211,7 +1319,7 @@ static void samsung_dev_deinit (FpImageDevice *dev) { FpiDeviceSamsung7305 *self = FPI_DEVICE_SAMSUNG7305 (dev); - GError *error = NULL; + GError *error = NULL; g_clear_pointer (&self->img_buf, g_free); g_clear_pointer (&self->img_cmd_buf, g_free); @@ -1224,7 +1332,7 @@ samsung_dev_deinit (FpImageDevice *dev) } g_usb_device_release_interface (fpi_device_get_usb_device (FP_DEVICE (dev)), - 0, 0, &error); + 0, 0, &error); fpi_image_device_close_complete (dev, error); } @@ -1275,7 +1383,7 @@ fpi_device_samsung7305_init (FpiDeviceSamsung7305 *self) static void fpi_device_samsung7305_class_init (FpiDeviceSamsung7305Class *klass) { - FpDeviceClass *dev_class = FP_DEVICE_CLASS (klass); + FpDeviceClass *dev_class = FP_DEVICE_CLASS (klass); FpImageDeviceClass *img_class = FP_IMAGE_DEVICE_CLASS (klass); dev_class->id = FP_COMPONENT; From 7912a0cb26727611e0d10c1615efa99bba2576fc Mon Sep 17 00:00:00 2001 From: Justin Hall Date: Thu, 23 Apr 2026 14:18:00 -0400 Subject: [PATCH 3/3] samsung7305: guard frame-list walk against scan-build false positive scan-build flags ordered->next as a possible null deref because it cannot correlate the GSList length with frames_captured. The frames_captured >= MIN_FRAMES guard upstream of the head drop makes the deref safe in practice, but adding an explicit ordered && ordered->next check silences the analyzer without changing behavior. Co-Authored-By: Claude Opus 4.7 --- libfprint/drivers/samsung7305.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libfprint/drivers/samsung7305.c b/libfprint/drivers/samsung7305.c index af7ec3aa..05d5b038 100644 --- a/libfprint/drivers/samsung7305.c +++ b/libfprint/drivers/samsung7305.c @@ -1158,7 +1158,7 @@ m_loop_state (FpiSsm *ssm, FpDevice *dev) self->frames_captured); } - if (self->frames_captured >= 2) + if (self->frames_captured >= 2 && ordered && ordered->next) { /* Fixed stride instead of motion estimation — see the note * near ASSEMBLE_STRIDE. First frame's delta_y is forced to 0