Luigit
repositories / dotfiles

dotfiles

bugabingas dorkfiles

owned by admin

quickshell/nuguland/ambient-light-native/read.c

Raw
// Installed libcolorhug APIs only. Cancellation is cooperative: SIGKILL cannot
// guarantee rollback, nor can these budgets bound non-cancellable GUsb setup.
#include <colorhug.h>
#include <glib-unix.h>
#include <signal.h>
#include <stdio.h>

typedef struct {
	ChColorSelect channel;
	ChFreqScale scale;
	guint16 integral;
} Settings;

typedef struct {
	GCancellable *active;
	gboolean work;
	gboolean interrupted;
	gboolean expired;
} Control;

typedef enum { READ_SETTINGS, SET_SCALE, SET_INTEGRAL, SAMPLE } Operation;

static const char *channel_name(ChColorSelect channel)
{
	switch (channel) {
	case CH_COLOR_SELECT_RED: return "red";
	case CH_COLOR_SELECT_WHITE: return "white";
	case CH_COLOR_SELECT_BLUE: return "blue";
	case CH_COLOR_SELECT_GREEN: return "green";
	default: return "";
	}
}

static int frequency_percent(ChFreqScale scale)
{
	switch (scale) {
	case CH_FREQ_SCALE_0: return 0;
	case CH_FREQ_SCALE_2: return 2;
	case CH_FREQ_SCALE_20: return 20;
	case CH_FREQ_SCALE_100: return 100;
	default: return -1;
	}
}

static gboolean valid(const Settings *s)
{
	return *channel_name(s->channel) && frequency_percent(s->scale) >= 0;
}

static gboolean equal(const Settings *a, const Settings *b)
{
	return a->channel == b->channel && a->scale == b->scale &&
	       a->integral == b->integral;
}

static gboolean interrupted(gpointer data)
{
	Control *c = data;
	c->interrupted = TRUE;
	if (c->work && c->active != NULL)
		g_cancellable_cancel(c->active);
	return G_SOURCE_CONTINUE;
}

static gboolean expired(gpointer data)
{
	Control *c = data;
	c->expired = TRUE;
	g_cancellable_cancel(c->active);
	return G_SOURCE_REMOVE;
}

// Every operation owns a new queue and token. A failed queue must never replay.
// Absolute deadlines keep three-field snapshots inside one phase budget.
static gboolean call(Control *c, GUsbDevice *device, Operation op,
		     Settings *settings, guint32 *raw, gint64 deadline)
{
	gint64 remaining = deadline - g_get_monotonic_time();
	GError *error = NULL;
	ChDeviceQueue *queue = NULL;
	gboolean ok;
	guint timer;

	if (remaining <= 0 || (c->work && c->interrupted))
		return FALSE;
	c->active = g_cancellable_new();
	c->expired = FALSE;
	timer = g_timeout_add((guint)((remaining + 999) / 1000), expired, c);
	if (op == SET_INTEGRAL) {
		// The queue setter rejects zero; the direct installed API accepts it.
		ok = ch_device_set_integral_time(device, settings->integral,
						c->active, &error);
	} else {
		queue = ch_device_queue_new();
		switch (op) {
		case READ_SETTINGS:
			ch_device_queue_get_color_select(queue, device, &settings->channel);
			ch_device_queue_get_multiplier(queue, device, &settings->scale);
			ch_device_queue_get_integral_time(queue, device, &settings->integral);
			break;
		case SET_SCALE:
			ch_device_queue_set_multiplier(queue, device, settings->scale);
			break;
		case SAMPLE:
			ch_device_queue_take_reading_raw(queue, device, raw);
			break;
		case SET_INTEGRAL: g_assert_not_reached();
		}
		ok = ch_device_queue_process(queue, CH_DEVICE_QUEUE_PROCESS_FLAGS_NONE,
					     c->active, &error);
	}
	// Dispatch queued Unix signals even when a synchronous call returned fast.
	while (g_main_context_pending(NULL))
		g_main_context_iteration(NULL, FALSE);
	if (!c->expired)
		g_source_remove(timer);
	ok = ok && !c->expired && g_get_monotonic_time() < deadline &&
	     !(c->work && c->interrupted);
	g_clear_object(&queue);
	g_clear_object(&c->active);
	g_clear_error(&error);
	return ok;
}

static const char *work_error(Control *c, gint64 deadline, const char *fallback)
{
	if (c->interrupted)
		return "interrupted";
	if (g_get_monotonic_time() >= deadline)
		return "work-timeout";
	return fallback;
}

static void print_settings(const Settings *s, gboolean present)
{
	if (!present) {
		printf("null");
		return;
	}
	printf("{\"channel\":\"%s\",\"frequencyPercent\":%d,\"integrationTime\":%u}",
	       channel_name(s->channel), frequency_percent(s->scale), (unsigned)s->integral);
}

int main(int argc, char **argv)
{
	const gint64 deadline = g_get_monotonic_time() + 4000000;
	Control control = { .work = TRUE };
	Settings original = {0}, desired = {0}, effective = {0}, readback = {0};
	gboolean have_original = FALSE, have_effective = FALSE, have_readback = FALSE;
	gboolean changed_scale = FALSE, changed_integral = FALSE, raw_valid = FALSE;
	gboolean opened = FALSE, claimed = FALSE, found = FALSE;
	GUsbContext *context = NULL;
	GUsbDevice *device = NULL;
	GPtrArray *devices = NULL;
	GError *error = NULL;
	const char *operation_error = "", *restore_error = "";
	const char *verification_error = "", *cleanup_error = "";
	const char *restoration = "not-needed", *code;
	guint32 raw = 0;
	guint term = 0, intr = 0;
	int configuration;
	const gboolean probe = argc == 2 && g_strcmp0(argv[1], "--probe") == 0;

	if (argc == 2 && g_strcmp0(argv[1], "--help") == 0) {
		puts("usage: read [--probe]");
		return 0;
	}
	if (argc != 1 && !probe) {
		operation_error = "invalid-arguments";
		goto out;
	}
	term = g_unix_signal_add(SIGTERM, interrupted, &control);
	intr = g_unix_signal_add(SIGINT, interrupted, &control);
	context = g_usb_context_new(&error);
	if (context == NULL) {
		operation_error = "usb-context-failed";
		goto out;
	}
	g_usb_context_enumerate(context);
	devices = g_usb_context_get_devices(context);
	for (guint i = 0; i < devices->len; i++) {
		GUsbDevice *candidate = g_ptr_array_index(devices, i);
		if (g_usb_device_get_vid(candidate) == CH_USB_VID &&
		    g_usb_device_get_pid(candidate) == CH_USB_PID_FIRMWARE_ALS) {
			device = candidate;
			found = TRUE;
			break;
		}
	}
	if (device == NULL) {
		operation_error = "no-device";
		goto out;
	}
	// Enumeration-only discovery follows VID/PID across USB port changes.
	// Never opens, claims, activates or samples the device.
	if (probe)
		goto out;
	if (!g_usb_device_open(device, &error)) {
		operation_error = "usb-open-failed";
		goto out;
	}
	opened = TRUE;
	configuration = g_usb_device_get_configuration(device, &error);
	if (configuration != CH_USB_CONFIG) {
		operation_error = configuration < 0 ? "configuration-read-failed" :
			"unexpected-configuration";
		goto out;
	}
	if (!g_usb_device_claim_interface(device, CH_USB_INTERFACE,
		G_USB_DEVICE_CLAIM_INTERFACE_BIND_KERNEL_DRIVER, &error)) {
		operation_error = "interface-claim-failed";
		goto out;
	}
	claimed = TRUE;
	if (!call(&control, device, READ_SETTINGS, &original, NULL, deadline)) {
		operation_error = work_error(&control, deadline, "sensor-state-read-failed");
		goto out;
	}
	if (!valid(&original)) {
		operation_error = "sensor-state-invalid";
		goto out;
	}
	have_original = TRUE;
	desired = original;
	if (original.scale == CH_FREQ_SCALE_0)
		desired.scale = CH_FREQ_SCALE_20;
	if (original.integral == 0)
		desired.integral = CH_INTEGRAL_TIME_VALUE_100MS;
	if (desired.scale != original.scale) {
		changed_scale = TRUE; // Include applied writes whose acknowledgement is lost.
		if (!call(&control, device, SET_SCALE, &desired, NULL, deadline)) {
			operation_error = work_error(&control, deadline, "activation-scale-failed");
			goto rollback;
		}
	}
	if (desired.integral != original.integral) {
		changed_integral = TRUE;
		if (!call(&control, device, SET_INTEGRAL, &desired, NULL, deadline)) {
			operation_error = work_error(&control, deadline, "activation-integral-failed");
			goto rollback;
		}
	}
	if (!call(&control, device, READ_SETTINGS, &effective, NULL, deadline)) {
		operation_error = work_error(&control, deadline, "effective-read-failed");
		goto rollback;
	}
	have_effective = valid(&effective);
	if (!have_effective || !equal(&desired, &effective)) {
		operation_error = "effective-mismatch";
		goto rollback;
	}
	if (!call(&control, device, SAMPLE, NULL, &raw, deadline)) {
		operation_error = work_error(&control, deadline, "sensor-reading-failed");
		goto rollback;
	}
	raw_valid = TRUE;

rollback:
	// Signals still record interruption, but never cancel or skip rollback.
	control.work = FALSE;
	if (changed_scale && !call(&control, device, SET_SCALE, &original, NULL,
				  g_get_monotonic_time() + 1000000))
		restore_error = "restore-scale-failed";
	if (changed_integral && !call(&control, device, SET_INTEGRAL, &original, NULL,
				     g_get_monotonic_time() + 1000000) && !*restore_error)
		restore_error = "restore-integral-failed";
	// Independent storage, fresh queue, all three fields even after restore error.
	if (!call(&control, device, READ_SETTINGS, &readback, NULL,
		  g_get_monotonic_time() + 1500000)) {
		restoration = "unverified";
		verification_error = "verification-read-failed";
	} else if (!valid(&readback)) {
		restoration = "unverified";
		verification_error = "verification-state-invalid";
	} else {
		have_readback = TRUE;
		restoration = equal(&original, &readback) ? "verified" : "mismatch";
		if (!equal(&original, &readback))
			verification_error = "verification-mismatch";
	}

out:
	control.work = FALSE;
	g_clear_error(&error);
	if (claimed && !g_usb_device_release_interface(device, CH_USB_INTERFACE,
		G_USB_DEVICE_CLAIM_INTERFACE_BIND_KERNEL_DRIVER, &error))
		cleanup_error = "interface-release-failed";
	g_clear_error(&error);
	if (opened && !g_usb_device_close(device, &error) && !*cleanup_error)
		cleanup_error = "usb-close-failed";
	g_clear_error(&error);
	g_clear_pointer(&devices, g_ptr_array_unref);
	g_clear_object(&context);
	while (g_main_context_pending(NULL))
		g_main_context_iteration(NULL, FALSE);
	if (term) g_source_remove(term);
	if (intr) g_source_remove(intr);
	if (control.interrupted && !*operation_error)
		operation_error = "interrupted";
	code = *operation_error ? operation_error : *restore_error ? restore_error :
	       *verification_error ? verification_error : cleanup_error;
	if (probe) {
		const char *probe_error = g_strcmp0(code, "no-device") == 0 ? "" : code;
		printf("{\"found\":%s,\"error\":\"%s\"}\n", found ? "true" : "false", probe_error);
		return *probe_error ? 1 : 0;
	}
	printf("{\"status\":\"%s\",\"error\":\"%s\",\"raw\":",
	       *code ? "unavailable" : "ready", code);
	if (raw_valid) printf("%" G_GUINT32_FORMAT, raw); else printf("null");
	printf(",\"unit\":\"counts\",\"channel\":\"%s\",\"frequencyPercent\":%d,"
	       "\"integrationTime\":%u,\"original\":",
	       have_effective ? channel_name(effective.channel) : "",
	       have_effective ? frequency_percent(effective.scale) : 0,
	       have_effective ? (unsigned)effective.integral : 0);
	print_settings(&original, have_original);
	printf(",\"effective\":"); print_settings(&effective, have_effective);
	printf(",\"restored\":"); print_settings(&readback, have_readback);
	printf(",\"restoration\":\"%s\",\"operationError\":\"%s\",\"restoreError\":\"%s\","
	       "\"verificationError\":\"%s\",\"cleanupError\":\"%s\"}\n",
	       restoration, operation_error, restore_error, verification_error, cleanup_error);
	return *code ? 1 : 0;
}