Initial GXFP5130 userspace prototype

2026-08-03 11:43:42 +03:00
commit 088d8ef75c
30 changed files with 5318 additions and 0 deletions
--- a/examples/sensor-probe.c
+++ b/examples/sensor-probe.c
@@ -0,0 +1,161 @@
+// SPDX-License-Identifier: GPL-2.0-only
+#include "gxfp/session.h"
+
+#include <errno.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+static const char *error_string(int error)
+{
+        if (error >= 0)
+                return "non-negative API error";
+
+        return strerror(-error);
+}
+
+static int print_image_stats(unsigned int index,
+                             const struct gxfp_image12 *image)
+{
+        size_t count;
+        uint16_t minimum = UINT16_MAX;
+        uint16_t maximum = 0;
+        uint64_t sum = 0;
+        size_t i;
+
+        if (!image || !image->pixels || !image->width || !image->height) {
+                fprintf(stderr, "invalid image returned by capture\n");
+                return -EINVAL;
+        }
+        if (image->width > SIZE_MAX / image->height) {
+                fprintf(stderr, "image dimensions overflow\n");
+                return -EOVERFLOW;
+        }
+        count = image->width * image->height;
+
+        for (i = 0; i < count; i++) {
+                uint16_t value = image->pixels[i];
+                if (value < minimum)
+                        minimum = value;
+                if (value > maximum)
+                        maximum = value;
+                sum += value;
+        }
+        printf("capture_index: %u\n", index);
+        printf("image: %zux%zu, samples=%zu\n",
+               image->width, image->height, count);
+        printf("CRC: stored=0x%08x calculated=0x%08x valid=yes\n",
+               image->crc_stored, image->crc_calculated);
+        printf("header: %02x %02x %02x %02x %02x\n",
+               image->header[0], image->header[1], image->header[2],
+               image->header[3], image->header[4]);
+        printf("frame_trailer: 0x%02x\n", image->trailer);
+        printf("pixel_min=%u pixel_max=%u pixel_mean=%.2f\n",
+               minimum, maximum, (double)sum / count);
+        return 0;
+}
+
+int main(int argc, char **argv)
+{
+        const char *path = argc > 1 ? argv[1] : "/dev/gxfp";
+        unsigned int capture_count = 1u;
+        struct gxfp_session *session = NULL;
+        const char *stage = "open";
+        unsigned int completed = 0;
+        unsigned int index;
+        int active = 0;
+        int ret;
+
+        if (argc > 3) {
+                fprintf(stderr, "usage: %s [device] [capture-count]\n", argv[0]);
+                return EXIT_FAILURE;
+        }
+
+        if (argc > 2) {
+                char *end = NULL;
+                unsigned long value;
+
+                errno = 0;
+                value = strtoul(argv[2], &end, 10);
+                if (errno == ERANGE || end == argv[2] || *end != '\0' ||
+                    value == 0 || value > 100) {
+                        fprintf(stderr, "capture count must be in range 1..100\n");
+                        return EXIT_FAILURE;
+                }
+                capture_count = (unsigned int)value;
+        }
+
+        ret = gxfp_session_open(&session, path);
+        if (ret) {
+                fprintf(stderr, "session open failed: %s (%d)\n",
+                        error_string(ret), ret);
+                return EXIT_FAILURE;
+        }
+        stage = "activate";
+        ret = gxfp_session_activate(session, 10000);
+        if (ret) {
+                fprintf(stderr, "session activate failed: %s (%d)\n",
+                        error_string(ret), ret);
+                goto out;
+        }
+        active = 1;
+        printf("Session active; TLS established.\n");
+
+        for (index = 1; index <= capture_count; index++) {
+                struct gxfp_image12 image = { 0 };
+
+                printf("\n=== Capture %u/%u ===\n", index, capture_count);
+                stage = "arm-finger-down";
+                ret = gxfp_session_arm_finger_down(session);
+                if (ret)
+                        goto capture_error;
+                printf("FDT down armed. Put finger on sensor...\n");
+                stage = "wait-finger-down";
+                ret = gxfp_session_wait_finger_down(session, 10000);
+                if (ret)
+                        goto capture_error;
+                stage = "capture";
+                ret = gxfp_session_capture(session, &image, 20000);
+                if (ret)
+                        goto capture_error;
+                stage = "print-image-stats";
+                ret = print_image_stats(index, &image);
+                if (ret)
+                        goto capture_error;
+                gxfp_image12_clear(&image);
+
+                stage = "arm-finger-up";
+                ret = gxfp_session_arm_finger_up(session);
+                if (ret)
+                        goto capture_error;
+                printf("Remove your finger...\n");
+                stage = "wait-finger-up";
+                ret = gxfp_session_wait_finger_up(session, 10000);
+                if (ret)
+                        goto capture_error;
+                completed++;
+                continue;
+
+capture_error:
+                gxfp_image12_clear(&image);
+                fprintf(stderr,
+                        "capture %u failed during %s, state=%d: %s (%d)\n",
+                        index, stage,
+                        (int)gxfp_session_get_state(session),
+                        error_string(ret), ret);
+                break;
+        }
+
+out:
+        printf("\ncompleted captures: %u/%u\n", completed, capture_count);
+        if (session) {
+                if (active) {
+                        int deactivate_ret = gxfp_session_deactivate(session);
+                        if (!ret && deactivate_ret)
+                                ret = deactivate_ret;
+                }
+                gxfp_session_close(session);
+        }
+        return ret ? EXIT_FAILURE : EXIT_SUCCESS;
+}