GPD Pocket 4: out-of-the-box touchscreen rotation, autorotation, and boot orientation

[ekollof]

Omarchy 4.0.1 on a GPD Pocket 4 needs three hardware-specific tweaks to be fully usable. All three are verified working on kernel 7.1.9-arch1-2 / Hyprland 0.56.2. Since Omarchy already ships device integrators (e.g. omarchy hw dell xps haptic touchpad), I'd like to propose an omarchy hw gpd pocket 4 integration covering them.

Hardware: 8.8" 1600x2560 portrait panel mounted landscape (used at Hyprland transform 3, scale 2), NVTK0603 I2C touchscreen (nvtk0603:00-0603:f001), mxc4005 accelerometer, Limine bootloader with LUKS.

1. Touchscreen coordinate rotation

Touch events work but the digitizer frame is unrotated relative to the landscape display, so touch lands 90° off. Fix in ~/.config/hypr/input.lua:

hl.device({ name = "nvtk0603:00-0603:f001", output = "eDP-1", transform = 3 })

The transform must match the monitor transform (also documented on the ArchWiki GPD Pocket 4 page).

2. Autorotation

The mxc4005 accelerometer is detected by the kernel, but iio-sensor-proxy is not installed, so nothing bridges it to the session. After installing it, a small user daemon (claims the accelerometer on the system bus and follows AccelerometerOrientation → hyprctl eval monitor + touch transforms) provides full rotation, including keeping the touch transform in sync with the monitor.

Important calibration note: on this unit, laptop mode reports right-up, not normal as the ArchWiki GPD Pocket 4 page claims — the orientation→transform mapping had to be shifted 90°: normal→0, left-up→1, bottom-up→2, right-up→3. A generic integrator should treat this mapping as per-unit calibration (or detect the laptop orientation once at first run).

autorotate.py + systemd user unit (as running on this machine)

#!/usr/bin/env python3
"""GPD Pocket 4 autorotation for Hyprland via iio-sensor-proxy.

The panel is natively portrait and sits at transform 3 in laptop mode.
Empirically calibrated on this unit (2026-08-29): in normal laptop position
the accelerometer reports "right-up" (the ArchWiki mapping assumes "normal"
and is off by 90 deg here). Transform = clockwise 90-degree steps from the
proxy's reference orientation. Touch device transform must match the
monitor transform (confirmed working on this unit).
"""

import os
import subprocess
import sys

import gi

gi.require_version("Gio", "2.0")
from gi.repository import Gio, GLib

MONITOR = "eDP-1"
TOUCH_DEVICE = "nvtk0603:00-0603:f001"
ORIENTATION_TO_TRANSFORM = {
    "normal": 0,
    "left-up": 1,
    "bottom-up": 2,
    "right-up": 3,  # laptop mode on this unit
}


def ensure_hyprland_env():
    if os.environ.get("HYPRLAND_INSTANCE_SIGNATURE"):
        return
    runtime = os.environ.get("XDG_RUNTIME_DIR") or f"/run/user/{os.getuid()}"
    hypr_dir = os.path.join(runtime, "hypr")
    try:
        candidates = sorted(
            (d, os.path.getmtime(os.path.join(hypr_dir, d)))
            for d in os.listdir(hypr_dir)
            if os.path.isdir(os.path.join(hypr_dir, d))
        )
    except OSError:
        return
    if candidates:
        os.environ["HYPRLAND_INSTANCE_SIGNATURE"] = candidates[-1][0]


def apply_transform(transform):
    for expr in (
        f'hl.monitor({{ output = "{MONITOR}", transform = {transform} }})',
        f'hl.device({{ name = "{TOUCH_DEVICE}", transform = {transform} }})',
    ):
        result = subprocess.run(["hyprctl", "eval", expr], capture_output=True, text=True)
        if "ok" not in result.stdout.lower():
            print(f"hyprctl eval failed: {expr!r}: {result.stdout}{result.stderr}", file=sys.stderr, flush=True)
    print(f"applied transform {transform}", flush=True)


def dbus_unpack(value):
    # g-properties-changed hands PyGObject either a Variant or an already
    # unpacked Python value depending on GI version. Calling .unpack() on a
    # str raises AttributeError and rotation silently dies.
    if value is None:
        return None
    unpack = getattr(value, "unpack", None)
    return unpack() if callable(unpack) else value


def on_properties_changed(proxy, changed, invalidated):
    props = dbus_unpack(changed) or {}
    orientation = dbus_unpack(props.get("AccelerometerOrientation"))
    transform = ORIENTATION_TO_TRANSFORM.get(orientation)
    if transform is not None:
        apply_transform(transform)


def main():
    ensure_hyprland_env()
    try:
        proxy = Gio.DBusProxy.new_for_bus_sync(
            Gio.BusType.SYSTEM,
            Gio.DBusProxyFlags.NONE,
            None,
            "net.hadess.SensorProxy",
            "/net/hadess/SensorProxy",
            "net.hadess.SensorProxy",
        )
    except GLib.Error as error:
        print(f"iio-sensor-proxy not reachable: {error.message}", file=sys.stderr, flush=True)
        return 0
    if not dbus_unpack(proxy.get_cached_property("HasAccelerometer")):
        print("no accelerometer exposed by iio-sensor-proxy", file=sys.stderr, flush=True)
        return 1
    proxy.connect("g-properties-changed", on_properties_changed)
    try:
        proxy.call_sync("ClaimAccelerometer", None, Gio.DBusCallFlags.NONE, -1)
    except GLib.Error as error:
        print(f"ClaimAccelerometer failed: {error.message}", file=sys.stderr, flush=True)
        return 0
    initial = dbus_unpack(proxy.get_cached_property("AccelerometerOrientation"))
    if initial is not None:
        transform = ORIENTATION_TO_TRANSFORM.get(initial)
        if transform is not None:
            apply_transform(transform)
    print("watching accelerometer orientation...", flush=True)
    GLib.MainLoop().run()


if __name__ == "__main__":
    sys.exit(main())

[Unit]
Description=Automatic screen rotation for Hyprland (GPD Pocket 4, iio-sensor-proxy)
ConditionEnvironment=WAYLAND_DISPLAY
PartOf=graphical-session.target
After=graphical-session.target wayland-session-waitenv.service

[Service]
ExecStart=/usr/bin/python3 %h/.config/hypr/scripts/autorotate.py
Restart=on-failure
RestartSec=2

[Install]
WantedBy=graphical-session.target

3. Boot console / LUKS prompt orientation

Without kernel params the initramfs LUKS prompt and TTYs render sideways (panel is physically portrait). Fix via /etc/default/limine + limine-update:

KERNEL_CMDLINE[default]+=" fbcon=rotate:1 video=eDP-1:panel_orientation=right_side_up"

• fbcon=rotate:1 = 90° clockwise (per kernel fbcon docs), matching the panel mounting → fixes the text LUKS prompt and TTYs
• video=eDP-1:panel_orientation=right_side_up sets the DRM panel-orientation property → covers plymouth/DRM-based renderers. Hyprland ignores the property, so there's no double rotation in the session.
• Limine's own graphical menu cannot be rotated (tool limitation).

Proposal

Add an omarchy hw gpd pocket 4 command (or a generic autorotate feature with per-device orientation calibration) that applies:

1. the touch device quirk from §1
2. omarchy pkg add iio-sensor-proxy + the rotation user service from §2
3. the Limine cmdline params from §3

Debug log (omarchy debug --no-sudo --print) available on request.

[ekollof]

Correction / appendix to §3 — the Limine menu itself CAN be rotated

Limine ≥ v10 supports interface_rotation (values 0 / 90 / 180 / 270). On this hardware 90 is the correct value. Add at the top of /boot/limine.conf, before any entries:

interface_rotation: 90

On this machine (Limine 12.6.0, limine-mkinitcpio-hook 1.37.1) this line survives limine-update regeneration — the entry tool preserves unmanaged global options when rewriting the config, so no extra hook or re-application step is needed. Verified by running limine-update and re-checking the file afterwards.

So the complete rotation story for the GPD Pocket 4 is:

1. Limine menu: interface_rotation: 90 (one-time prepend; survives regeneration)
2. Kernel console + text LUKS prompt: fbcon=rotate:1
3. Plymouth / DRM consumers: video=eDP-1:panel_orientation=right_side_up
4. Session: Hyprland monitor transform 3 + touchscreen device transform 3 + the autorotate daemon from §2

For an omarchy hw gpd pocket 4 integrator, item 1 should be included too — it's a one-line prepend to limine.conf and a one-time operation per install.

[ekollof]

Addendum — §4: Fingerprint sensor (FocalTech FT9362, USB 2808:0752, power-button mounted)

The fingerprint reader is the last piece that needs hardware-specific work on the GPD Pocket 4. Current state and a working solution:

Situation

• FocalTech shipped an official Linux libfprint build (1.94.4+tod1, suse_all_x64_20250219) with a driver that natively lists 2808:0752 in its FpIdEntry table. The distribution repo (ftfpteams/focaltech-linux-fingerprint-driver) was DMCA'd; the same binary build is still available from community re-hosts (e.g. the unpatched blob inside ryenyuku/libfprint-ft9201's release).
• The open-source reimplementation (shokerplz/ft9362-driver) is not a viable alternative: its CNN matcher was trained solely on the author's own fingerprints (stated in its README), so it is effectively unusable for anyone else.
• Upstream libfprint (1.94.100, focaltech_moc) does not support 0752 — no rules entry, fprintd-list finds nothing.

Arch-specific blocker

The blob imports six libgusb symbols under the old version node LIBGUSB_0.1.0, but current libgusb (0.4.9) provides them under LIBGUSB_0.2.8 — the loader matches on the (symbol, version) pair, so the blob fails with undefined symbol: g_usb_interface_get_subclass, version LIBGUSB_0.1.0. Affected symbols: g_usb_device_get_interfaces, g_usb_device_get_release, g_usb_interface_get_class, g_usb_interface_get_number, g_usb_interface_get_protocol, g_usb_interface_get_subclass.

Solution: version-node shim

I published a small shim that defines a LIBGUSB_0.1.0 node of its own and re-exports those six symbols, forwarding to the real libgusb via dlsym — https://github.com/ekollof/libfpgusb-compat-shim (MIT, no proprietary code included):

patchelf --add-needed libfpgusb-compat.so libfprint-2.so.2.0.0

The repo includes a complete PKGBUILD (libfprint-focaltech, conflicts/provides libfprint). With it installed on Omarchy 4.0.1 (kernel 7.1.9, fprintd 1.94.5): fprintd-list discovers the device, enrollment and verify-match succeed, and the existing omarchy setup security fingerprint wizard covers the PAM side unchanged.

For an omarchy hw gpd pocket 4 integrator

The blob itself can't be shipped (unfree, DMCA-tainted source), but Omarchy could ship or reference:

1. the shim package (tiny, MIT, no unfree content)
2. a omarchy hw gpd pocket 4 fingerprint command that installs it, applies the patchelf --add-needed step, and points the user at obtaining the blob themselves
3. no PAM changes needed — the existing fingerprint setup wizard already works once the device is visible to fprintd

[ekollof]

Implementation notes for the integrator + verification checklist

Consolidating the remaining findings from getting this machine fully working, since they materially affect anyone building omarchy hw gpd pocket 4:

1. Touch transform: set it explicitly, don't rely on output-binding inheritance

Hyprland #3538 documents that a touch device bound via output inherits the monitor transform when no explicit device transform is set. On Hyprland 0.56.2 with this unit, inheritance did not apply — touch behaved unrotated until the device transform was set explicitly:

hl.device({ name = "nvtk0603:00-0603:f001", output = "eDP-1", transform = 3 })

The integrator should always write the explicit transform (and update monitor + touch transforms together in the rotation daemon).

2. Runtime rotation must use hyprctl eval, not hyprctl keyword

With Omarchy's Lua configuration layer, hyprctl keyword device[...]:transform N fails with keyword can't work with non-legacy parsers. Use eval. The working forms:

hyprctl eval 'hl.monitor({ output = "eDP-1", transform = 2 })'
hyprctl eval 'hl.device({ name = "nvtk0603:00-0603:f001", transform = 2 })'

Verified that a partial hl.monitor eval (only output + transform) preserves the configured mode and scale. The autorotate daemon from §2 uses exactly this, applying monitor and touch transforms in one step.

3. Orientation mapping should be first-run calibrated, not hardcoded

The orientation→transform mapping is not fixed across units: the ArchWiki GPD Pocket 4 page claims accelerometer normal = laptop mode, but this unit reports right-up in laptop pose (off by 90°). Rather than hardcoding a table, a rotation daemon can anchor the mapping at first run: read the sensor orientation once while the machine is in the assumed laptop pose and derive the rest — orientation names cycle in a fixed order as the device rotates, and the transform equals clockwise 90°-steps from the proxy's reference frame.

4. The fingerprint recipe generalizes across GPD models

The blob's FpIdEntry table contains multiple FocalTech sensors: 2808:9338 (GPD Win 4) is natively present alongside 2808:0752 (Pocket 4), and FT9201-class devices (2808:93a9) work with the documented one-byte USB-ID patch (see Romk-a/ft9201-linux-setup). The shim at https://github.com/ekollof/libfpgusb-compat-shim is device-agnostic — it only bridges the libgusb version-node drift — so the same recipe covers several GPD machines.

5. Known firmware quirk: touchpad "gestures" are firmware key translations

The HAILUCK keyboard/touchpad firmware performs its own 3-finger gesture detection and sends key combos to the OS: 3-finger left → Alt+Shift+Tab+Left, right → Alt+Tab+Right, up → Super+Tab, down → Super+D. Root-caused in niri #3680. Anyone implementing compositor-level gesture handling on this device will chase ghosts — the compositor just receives those keypresses.

6. Hardware verification checklist

Quick QA pass for maintainers testing on real hardware (requires libinput, evtest, iio-sensor-proxy packages):

# Panel: native portrait 1600x2560, used landscape (transform 3, scale 2)
hyprctl monitors | grep -E 'eDP-1|transform'

# Touchscreen: NVTK0603 I2C-HID (NOT on lsusb); raw coords in portrait frame
evtest /dev/input/eventN   # ABS_MT_POSITION_X range 0-1600, Y range 0-2559

# Accelerometer: mxc4005 (MXC6655), bridged by iio-sensor-proxy
monitor-sensor            # laptop pose reports "right-up" on THIS unit

# Fingerprint: FocalTech FT9362 on the power button
lsusb | grep 2808:0752    # HOLTEK FocalTech Fingerprint Device
fprintd-list $USER

# Touchpad: HAILUCK USB keyboard composite device; libinput sees a plain pointer
libinput list-devices | grep -A5 HAILUCK

[ekollof]

§5: On-screen keyboard + touch gestures (tablet-mode usability)

For a convertible integrator, the OSK story matters as much as rotation. Findings from daily-driving this unit:

1. No native touchscreen gestures in Hyprland — a swipe-up-from-bottom-edge OSK summon requires the hyprgrass plugin. It works on Hyprland 0.56.2, but it pins to the Hyprland ABI and lags ~1–7 days behind each point release (needs a rebuild after every hyprland bump). An integrator shipping it should treat that as a maintenance window, or make the feature opt-in.
2. OSK choice: wvkbd works well here. I upstreamed a compact 60%-style layout set for exactly this class of device (jjsullivan5196/wvkbd#127) — traditional 60% arrangement, same primary layer in portrait and landscape, full shifted punctuation, tuned heights for ~7–9" UMPC screens.
3. Blocker, tracked in Menu blocks on-screen keyboard input: Exclusive keyboard focus routes all pointer input to the menu (touchscreen devices) #9029: with the menu open, OSK taps dismiss the menu and keys never arrive. Root cause: plugins/menu/Menu.qml uses WlrKeyboardFocus.Exclusive (Hyprland routes all pointer input to that surface) + ExclusionMode.Ignore (menu overlaps the OSK's exclusive zone). A validated two-line fix (ExclusionMode.Auto + WlrKeyboardFocus.OnDemand in a plugin clone) keeps type-to-search working for physical and virtual keyboards. Any integrator that ships an OSK should include this (or wait for it upstream).
4. Minor: omarchy hw touchscreen already detects the NVTK0603 digitizer, so the §1 device quirk can build on that detection rather than hardcoding the name.

[ekollof]

Addendum to the fingerprint section — on-device template DB quirk

The FT9362 keeps enrolled templates in its own on-device NVM, and fprintd-side deletion (fprintd-delete) does not purge the matching device entry — the driver only syncs its device database against fprintd's storage when the device is claimed for a verify. Symptom: after deleting an enrollment, re-enrolling the same finger fails with enroll-duplicate, and the failure persists through fprintd restarts and even a USB re-enumeration.

Working sequence when this hits:

fprintd-delete $USER -f <finger>
fprintd-verify             # fails with "NoEnrolledPrints" — but the claim purges the orphan device template
fprintd-enroll -f <finger> # now succeeds

Worth handling (or at least documenting) in whatever packaging/integrator flow lands for this device.

[ekollof]

Addendum — two-finger scrolling on the touchscreen (tablet-mode experience)

With touch mapping and autorotation working (§1, §2), the last missing piece of the touchscreen experience is scrolling: Hyprland pointer-emulates touchscreen input, so finger drags move the cursor instead of scrolling — apps never see scrollable touch. This is a compositor limitation, not a driver one:

• libinput has no touchscreen→scroll conversion
• hyprgrass gestures are discrete (swipes ≥3 fingers) and can't emit scroll axes
• the scroll_move gesture action only scrolls the window strip in the scrolling layout, not app content

Solution: a small userspace daemon — https://github.com/ekollof/hyprland-touchscroll (MIT, Python stdlib only). It reads the touchscreen's raw evdev stream, detects two-finger drags, and injects fractional REL_WHEEL_HI_RES events through a uinput virtual device; libinput/Hyprland treat it exactly like a hi-res mouse wheel, giving smooth proportional scrolling in every app.

Notable digitizer quirks it works around (NVTK0603 on this unit):

• the device never sends ABS_MT_TRACKING_ID — contact tracking uses per-slot position freshness instead
• fingers are multiplexed across MT slots between frames — deltas are computed from the per-frame sum over live slots, which is invariant to the swap
• the panel is natively portrait: displayed vertical motion is the raw X axis (and raw Y the horizontal), matching the transform-3 display setup from §1

Two integration details worth copying:

1. hyprgrass no-op capture binds for 2-finger swipes stop Hyprland's pointer emulation mid-drag (the cursor otherwise teleports and retargets the scroll), while the daemon keeps reading the raw kernel stream independently:

   for _, dir in ipairs({ "u", "d", "l", "r" }) do
     hl.plugin.hyprgrass.gesture({
       pattern = { kind = "swipe", fingers = 2, direction = dir },
       action = function() end,
     })
   end

2. apps interpret wheel steps differently (Chromium ≈ 2× terminals) — the daemon queries the focused window class at drag start and applies per-app speed overrides.

Setup (udev uaccess rule for /dev/uinput + systemd user service + script) is in the repo README. For an omarchy hw gpd pocket 4 integrator, shipping this as a user service alongside the §2 rotation daemon completes the tablet-mode experience.

[ekollof]

Addendum to the scrolling section — the daemon has matured

Two updates to https://github.com/ekollof/hyprland-touchscroll since the comment above:

1. Rewritten as a pure event-driven state machine. Contact sessions are delimited by BTN_TOUCH and slot identity lives within a session, so the per-slot freshness heuristic mentioned earlier turned out to be unnecessary — blocking reads, no timers, no wall-clock heuristics.

2. The wheel mapping now follows the monitor transform. A lightweight background poll of Hyprland's monitor state re-derives the raw-axis-to-wheel mapping per drag session, so two-finger scrolling works in every orientation — it composes with the §2 autorotation daemon (which also keeps the touch device transform in sync per §1). Scrolling in tablet portrait was previously the blind spot; it now behaves identically to landscape.

This completes the touchscreen story for the omarchy hw gpd pocket 4 proposal: calibration (§1), autorotation (§2), and touch scrolling that tracks rotation.

[ekollof]

Upstreamed the core of this proposal as #9160 — the omarchy hw gpd pocket 4 detector, the autorotation daemon + gated user service (monitor and touch transforms kept in sync), the NVTK0603 libinput calibration matrix, and the full boot-orientation story (Limine interface_rotation, fbcon/DRM kernel params via limine-entry-tool).

What was left out, and why:

• Two-finger touch scrolling + the hyprgrass no-op capture binds — deferred. The scroll daemon itself is shippable (MIT, stdlib-only, device-gated), but the experience depends on suppressing Hyprland's pointer emulation mid-drag, which currently requires the ABI-pinned hyprgrass plugin that isn't packaged anywhere. I'll revisit this once there's an AUR entry (for hyprgrass or an equivalent capture mechanism) to point the integration at.

• FT9362 fingerprint reader — not upstreamable. The biggest blocker is the proprietary blob: the only working driver is FocalTech's own libfprint build (1.94.4+tod1), shipped as an unfree binary whose original distribution repo was DMCA'd, so neither Omarchy nor a comfortable AUR entry can carry it. The MIT libgusb version-node shim (libfpgusb-compat-shim) only fixes the loader mismatch (LIBGUSB_0.1.0 symbols) and is useless without the blob itself. The full recipe — shim, blob source, patchelf step, and the enroll-duplicate purge workaround — stays documented in this discussion for anyone who wants the reader working on their own machine.

[ekollof]

§5/scroll addendum — solved properly, in-compositor: omarchy-osk

Since the upstreaming comment deferred two-finger touch scrolling pending a hyprgrass AUR entry: that whole block now has a better answer. I built a compositor plugin that owns the touchscreen experience end to end (touch→pointer emulation, two-finger scrolling, and the on-screen keyboard), and it retires the userspace scroll daemon from the earlier addendum:

• Two-finger scrolling lives in the compositor. The plugin consumes the touchscreen's post-transform events (orientation-independent by construction — composes with §1/§2), detects two-finger drags, and emits seat axis events directly. No evdev/uinput daemon, no /dev/input uaccess rule, no double-reading of the kernel stream — and no hyprgrass no-op capture binds needed, because the plugin itself suppresses Hyprland's pointer emulation per gesture (the cursor-teleport problem from the daemon approach disappears with the daemon).
• The "Chromium ≈ 2× terminals" split is fixed at the protocol level, not per-app override. Chromium rescales legacy axis values by 1/10 × 120 (wheel ticks) and Hyprland 0.56 only forwards axis_value120 for wheel source — so the plugin shapes events per focused window class: Chromium-class windows get SOURCE_WHEEL + exact-pixel value120 (its v8 handler replaces the legacy delta within the frame), everything else gets SOURCE_FINGER raw pixels. Kitty and Chromium both scroll 1:1 with the finger.
• The keyboard part supersedes the wvkbd recommendation (§5.2) for Omarchy specifically: a native Quickshell overlay whose main layer is generated from the active xkb keymap (any layout, locale-derived default, dead keys via real key injection), sticky mods/one-shot shift, hold-to-repeat with configurable rates, a bar applet (enable/toggle/layout/repeat), IPC (omarchy-shell ekollof.osk setLayout dk …), and socket access control (peer allowlist; injection gated to keyboard-visible).
• hyprgrass scope: only the swipe-up summon needs it, and the bundle vendors + builds it locally (install.sh), so the "ABI-pinned plugin isn't packaged anywhere" blocker doesn't apply. Scrolling, taps and the keyboard work without it (SUPER+SHIFT+K / applet still toggle).

./install.sh builds everything (meson) and deploys; daily-driven on this GPD Pocket 4 (transform 3, scale 2, NVTK0603 — the portrait-frame quirks from the scrolling addendum don't apply anymore since the compositor sees libinput-normalized coordinates). If #9160 lands, the deferred scroll item should point here instead of hyprland-touchscroll: the daemon double-reads the kernel stream and can't fix the per-app wheel-unit divergence at the protocol level.

[ekollof]

Correction to the §2 autorotate.py snippet (edited into the original post as well).

Two things in the copy-paste example were wrong on current Hyprland / PyGObject:

1. Hyprland's compositor socket is under $XDG_RUNTIME_DIR/hypr/, not /tmp/hypr/. Looking in /tmp/hypr leaves HYPRLAND_INSTANCE_SIGNATURE unset and hyprctl eval is a no-op.
2. g-properties-changed may already unpack AccelerometerOrientation to a str. Calling .unpack() on that raises AttributeError: 'str' object has no attribute 'unpack', so every tilt is dropped. The snippet now uses a small dbus_unpack() helper that accepts either a Variant or an already-unpacked value, and the user unit waits for wayland-session-waitenv.service.

This is the same fix as in #9160 (3734eb61).