Skip to contentSkip to conversation

Input: synaptics - add pass-through mode for TrackPoint

PATCH In review Evan Lawrence 3 participants 6 messages Aug 10 – Sep 25

Subsystems (3)
lore
Share & tools
lore
#0 lore raw

PATCH v5 1/1 Input: synaptics - add pass-through mode for TrackPoint

Synaptics touchpads with a pass-through port (PS/2 guest) default to encapsulating guest data in the touchpad's own packets, limiting the guest device (typically a TrackPoint) to the touchpad's low poll rate. Enabling transparent pass-through mode tells the touchpad to stop generating its own packets and relay the raw byte stream from the guest directly, letting the TrackPoint run at its full native speed while the touchpad is effectively disabled.

This reworks an earlier implementation by Miroslav Bendík from 2022 that was never merged. It keeps the same hardware-mode approach but commits the mode flag only after a successful mode command, moves the reconnect handling into a generic psmouse hook instead of protocol- specific checks in psmouse-interrupt, and documents the interface.

The mode is exposed via a sysfs transparent_mode attribute that allows userspace to switch between full-rate TrackPoint and full-rate touchpad operation at runtime.

If the system warm-boots while transparent mode is active the touchpad stays in that mode and does not acknowledge command bytes, so ps2_command() hangs and the device fails to be detected. Escape transparent mode by writing SETSCALE21 + SETSCALE11 directly to the wire with serio_write() before attempting a reset or probe, both during initial detection and on reconnect.

Assisted-by DeepSeek:deepseek-v4-flash,deepseek-v4-pro

---

Notes:
Changes in v2 (addressing review feedback):
- Only consult the parent serio in psmouse_receive_byte() when it is a genuine psmouse pass-through port; a psmouse attached to a ps2mult child port has a parent whose drvdata is not a struct psmouse, so the unconditional cast could read a bogus function pointer.
- Guard the guest state reset in synaptics_set_transparent_mode() on the pass-through port actually being bound to a psmouse, and commit the protocol handler/pktsize update with RX paused to avoid a torn update.
- Exit transparent mode on the hardware as well as in software when the pass-through guest port is removed while the mode is active.
- Re-run the full initialization (query, identity check, mode setup) before re-entering transparent mode during reconnect, so the device is in a known configuration after a reset.
- Use psmouse_set_state(PSMOUSE_ACTIVATED) to drop stale guest data instead of the bare pktcnt = 0 assignment, which could leave the psmouse state machine (flags, state) out of sync with the packet counter.
- Move the dev-attr creation ahead of the pass-through port registration so that an attribute creation failure cannot leak a registered child port whose callbacks reference freed synaptics_data.

Changes in v3 (addressing review feedback):
- Scope the serio_pause_rx guard in synaptics_set_transparent_mode() to the protocol-handler commit only; calling psmouse_set_state() inside it re-enables interrupts via serio_continue_rx() while the parent lock is held, which can deadlock.
- In synaptics_pt_stop(), exit hardware transparent mode before updating the software protocol handler, so guest data is never misparsed as host touchpad packets.

Changes in v4 (addressing review feedback):
- Drop the pt_psmouse field and the child-state reset in synaptics_set_transparent_mode(): storing drvdata as a psmouse pointer without verifying the driver type creates a type-confusion risk. The PS/2 psmouse handler already resynchronizes after stale bytes, so dropping the explicit reset is safe.
- Remove the pass-through serio unregistration from synaptics_disconnect(): calling serio_unregister_port() from inside the parent disconnect callback deadlocks on serio_mutex, and the child port is already destroyed by serio_disconnect_port() before the parent disconnect runs, making the call a use-after-free.
- Guard the two-command write sequence in synaptics_pt_write() with a per-device mutex and hold it across both the transparent fast-path and the hardware mode-switch commands in synaptics_set_transparent_mode(), so a concurrent pt_write cannot inject a byte onto the PS/2 bus mid-command and corrupt the passthrough transaction.
- Add defensive id.type == SERIO_PS_PSTHRU checks before the psmouse_from_serio() casts in synaptics_pass_pt_packet() and synaptics_pt_activate().
- Issue SETSCALE21/SETSCALE11 commands after the initial reset in __synaptics_init() so that a touchpad left in transparent mode from a previous session can still be detected and initialized after a warm reboot.
- Skip the BAT (0xAA) detection in psmouse_receive_byte() while transparent mode is active, via a pt_bypass_bat flag on struct psmouse. Every byte on the parent serio belongs to the pass-through guest; a TrackPoint can legitimately send 0xAA 0x00 as motion data, and consuming the 0xAA byte would silently drop it before it reaches the guest handler.
- Clear pt_bypass_bat in synaptics_pt_stop() when the guest port is removed so that BAT detection resumes for the touchpad itself.

Changes in v5 (addressing review feedback):
- In synaptics_pt_stop(), sample the transparent_mode flag inside the pt_mutex guard instead of before it. A concurrent synaptics_set_transparent_mode() could otherwise change the flag between the snapshot and the lock acquire, causing the function to either skip hardware exit when it should not, or double-exit on an already-disabled device.
- In synaptics_set_transparent_mode(), check pt_port for NULL inside the pt_mutex guard rather than before it, so a concurrent synaptics_pt_stop() cannot clear pt_port after the check and before the mode-switch commands are sent.
- In synaptics_set_rate(), bail out early when transparent mode is active. The set_rate callback sends a mode command via synaptics_mode_cmd() without holding pt_mutex, while synaptics_pt_write() in transparent fast-path mode holds pt_mutex but bypasses ps2_cmd_mutex, so the two byte streams can interleave on the PS/2 bus and corrupt the command.
- In synaptics_reconnect(), hold pt_mutex across the synaptics_enter_transparent_mode() call that re-enters the mode after resume, and re-read pt_port inside the mutex, saving it to a local variable so that the subsequent serio_reconnect() uses a consistent pointer.
- Use READ_ONCE() when reading pt_port and pt_port_open in interrupt and serio callback contexts to prevent loads from being torn or reordered across the pt_mutex boundary.
- Move the serio_reconnect() call in synaptics_reconnect() inside the pt_mutex guard so that pt_port remains valid for its duration.
- After a warm reboot while transparent mode is active the touchpad does not acknowledge command bytes, so ps2_command() hangs and the device is not detected. Escape transparent mode by writing SETSCALE21 + SETSCALE11 directly to the wire with serio_write() before attempting a reset or probe, both during initial detection and on reconnect.

 .../ABI/testing/sysfs-driver-synaptics        |  28 ++
 MAINTAINERS                                   |   1 +
 drivers/input/mouse/psmouse-base.c            |  20 +-
 drivers/input/mouse/psmouse.h                 |  15 +
 drivers/input/mouse/synaptics.c               | 373 +++++++++++++++++-
 drivers/input/mouse/synaptics.h               |   6 +
 6 files changed, 420 insertions(+), 23 deletions(-)
 create mode 100644 Documentation/ABI/testing/sysfs-driver-synaptics
Documentation/ABI/testing/sysfs-driver-synaptics new file +28 -0
new file mode 100644
index 000000000000..bec715677e3e
@@ -0,0 +1,28 @@
+What:		/sys/bus/serio/devices/serioX/transparent_mode
+Date:		August 2026
+Contact:	[email protected]
+Description:
+		Controls the transparent pass-through mode of Synaptics
+		touchpads that feature a pass-through (PS/2 guest) port, such as
+		those used for a TrackPoint.
+
+		In normal operation the touchpad serves as the PS/2 host for
+		the pass-through guest: it scans the guest during its own scan
+		cycle and encapsulates the guest's data into its own packets,
+		which limits the guest to the touchpad's low poll rate. When
+		transparent mode is enabled the touchpad stops generating its
+		own packets and simply relays the raw byte stream of the
+		pass-through guest, letting the guest run at its high poll rate
+		while the touchpad is effectively disabled.
+
+		Write 1 to enable the mode, or 0 to disable it. Reading the
+		attribute returns the current state ("0" or "1").
+
+		Note that both devices cannot be serviced at full rate at the
+		same time on this hardware; enabling the mode disables the
+		touchpad until it is disabled again. The attribute is present
+		only on devices that report the pass-through capability.
+
+Users:		Userspace that arbitrates between full-rate TrackPoint and
+		full-rate touchpad operation. No consumer exists yet; the
+		interface is provided so that one can be developed.
MAINTAINERS +1 -0
index 8014b9f8253e..312c13690c91 100644
@@ -12817,6 +12817,7 @@ L:	[email protected]
 S:	Maintained
 Q:	http://patchwork.kernel.org/project/linux-input/list/
 T:	git git://git.kernel.org/pub/scm/linux/kernel/git/dtor/input.git
+F:	Documentation/ABI/testing/sysfs-driver-synaptics
 F:	Documentation/devicetree/bindings/input/
 F:	Documentation/devicetree/bindings/serio/
 F:	Documentation/input/
drivers/input/mouse/psmouse-base.c +18 -2
index 6ab5f1d96eae..b1be88899e65 100644
@@ -378,15 +378,31 @@ static void psmouse_receive_byte(struct ps2dev *ps2dev, u8 data)
 	psmouse->packet[psmouse->pktcnt++] = data;
 
 	/* Check if this is a new device announcement (0xAA 0x00) */
-	if (unlikely(psmouse->packet[0] == PSMOUSE_RET_BAT && psmouse->pktcnt <= 2)) {
+	if (unlikely(!READ_ONCE(psmouse->pt_bypass_bat) &&
+		     psmouse->packet[0] == PSMOUSE_RET_BAT && psmouse->pktcnt <= 2)) {
 		if (psmouse->pktcnt == 1) {
 			psmouse->last = jiffies;
 			return;
 		}
 
 		if (psmouse->packet[1] == PSMOUSE_RET_ID) {
+			struct serio *serio = ps2dev->serio;
+			struct psmouse *parent_psmouse = NULL;
+
 			__psmouse_set_state(psmouse, PSMOUSE_IGNORE);
-			serio_reconnect(ps2dev->serio);
+			/*
+			 * Some devices need parent to be reconnected instead.
+			 * Only consult the parent if this is a genuine psmouse
+			 * pass-through port; other serio children may have a
+			 * parent whose drvdata is not a struct psmouse.
+			 */
+			if (serio->parent && serio->id.type == SERIO_PS_PSTHRU)
+				parent_psmouse = psmouse_from_serio(serio->parent);
+			if (parent_psmouse && parent_psmouse->pt_reconnect_parent &&
+			    parent_psmouse->pt_reconnect_parent(parent_psmouse))
+				serio_reconnect(serio->parent);
+			else
+				serio_reconnect(serio);
 			return;
 		}
 
drivers/input/mouse/psmouse.h +15 -0
index 90ed8cd15d85..9391002fedc9 100644
@@ -128,6 +128,21 @@ struct psmouse {
 
 	void (*pt_activate)(struct psmouse *psmouse);
 	void (*pt_deactivate)(struct psmouse *psmouse);
+
+	/*
+	 * Called on the parent device when a pass-through guest reports a new
+	 * device announcement (0xAA 0x00). Return true if the parent, and not
+	 * the guest, should be reconnected.
+	 */
+	bool (*pt_reconnect_parent)(struct psmouse *psmouse);
+
+	/*
+	 * When true the parent is in transparent mode and the standard
+	 * BAT (0xAA) detection in psmouse_receive_byte must be skipped:
+	 * every byte arriving on the parent serio belongs to the
+	 * pass-through guest and is not a device announcement.
+	 */
+	bool pt_bypass_bat;
 };
 
 struct psmouse *psmouse_from_serio(struct serio *serio);
drivers/input/mouse/synaptics.c +352 -21

519 lines not on this page · raw message

drivers/input/mouse/synaptics.h +6 -0
index 3853165b6b3a..dc2031851cfd 100644
@@ -6,6 +6,8 @@
 #ifndef _SYNAPTICS_H
 #define _SYNAPTICS_H
 
+#include <linux/mutex.h>
+
 /* synaptics queries */
 #define SYN_QUE_IDENTIFY		0x00
 #define SYN_QUE_MODES			0x01
@@ -24,6 +26,7 @@
 /* synaptics modes */
 #define SYN_BIT_ABSOLUTE_MODE		BIT(7)
 #define SYN_BIT_HIGH_RATE		BIT(6)
+#define SYN_BIT_TRANSPARENT_MODE	BIT(5)
 #define SYN_BIT_SLEEP_MODE		BIT(3)
 #define SYN_BIT_DISABLE_GESTURE		BIT(2)
 #define SYN_BIT_FOUR_BYTE_CLIENT	BIT(1)
@@ -186,10 +189,13 @@ struct synaptics_data {
 
 	bool absolute_mode;			/* run in Absolute mode */
 	bool disable_gesture;			/* disable gestures */
+	bool transparent_mode;			/* pass packets directly from guest */
 
 	struct serio *pt_port;			/* Pass-through serio port */
 	bool pt_port_open;
 
+	struct mutex pt_mutex;			/* Serializes pt_write commands */
+
 	/*
 	 * Last received Advanced Gesture Mode (AGM) packet. An AGM packet
 	 * contains position data for a second contact, at half resolution.

base-commit: db2ddb87143519e20a95aa36c60b36107b736a58

Signature · 1 line
2.55.0
#1 lore raw
Thank you for your contribution! Sashiko AI review found 4 potential issue(s) to consider: - [High] Type confusion leading to out-of-bounds read/write due to relying solely on hardware port ID for…

Thank you for your contribution! Sashiko AI review found 4 potential issue(s) to consider:
- [High] Type confusion leading to out-of-bounds read/write due to relying solely on hardware port ID for driver validation.
- [High] Unsynchronized hardware commands interleave with pass-through byte stream, corrupting PS/2 communication.
- [High] Child port is leaked when parent driver probe fails, leading to a Use-After-Free crash.
- [Medium] Escape sequence aborts if the first byte is not ACKed, permanently locking the hardware in transparent mode. --

--- Patch [1]: [PATCH v5] Input: synaptics - add pass-through mode for TrackPoint --- commit 0baba0d9c35febab280e4dc02e618df2555881dc
Author: Evan Lawrence <[email protected]>
Subject: Input: synaptics - add pass-through mode for TrackPoint

This commit introduces a transparent pass-through mode for Synaptics touchpads with a PS/2 guest port, allowing the guest (e.g., TrackPoint) to bypass the touchpad's low poll rate by relaying raw byte streams directly. It adds a sysfs attribute to toggle the mode at runtime.

Quoted 7 lines
drivers/input/mouse/synaptics.c +0 -0
@@ -636,12 +650,90 @@ static void synaptics_set_rate(struct psmouse *psmouse, unsigned int rate)
 /*****************************************************************************
  *	Synaptics pass-through PS/2 port support
  ****************************************************************************/

[ ... ]

drivers/input/mouse/synaptics.c static void synaptics_set_rate(struct psmouse *psmouse, unsigned int rate) · line 713

Quoted 12 lines
drivers/input/mouse/synaptics.c +12 -0
+static int synaptics_exit_transparent_mode(struct psmouse *psmouse)
+{
+	struct synaptics_data *priv = psmouse->private;
+	int error;
+
+	/* Send scaling 2:1, 1:1 to exit transparent mode */
+	error = ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_SETSCALE21);
+	if (error)
+		return error;
+	error = ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_SETSCALE11);
+	if (error)
+		return error;

[Severity: Medium]
Will a failure on the first byte permanently lock the hardware in transparent mode?

If the guest device is missing, resetting, or unresponsive, the first PSMOUSE_CMD_SETSCALE21 byte may time out waiting for an ACK. When ps2_command() returns an error, this function aborts without sending the crucial second byte (PSMOUSE_CMD_SETSCALE11).

Since synaptics_pt_stop() clears the software transparent_mode flag even if the hardware exit fails, doesn't this leave the driver fully desynchronized from the hardware state, leaving the touchpad permanently unresponsive until a reboot?

Quoted 12 lines
drivers/input/mouse/synaptics.c +11 -0
+
+	/* Re-enter the regular operating mode of the touchpad */
+	error = synaptics_mode_cmd(psmouse, priv->mode & ~SYN_BIT_TRANSPARENT_MODE);
+	if (error)
+		return error;
+
+	priv->mode &= ~SYN_BIT_TRANSPARENT_MODE;
+
+	return 0;
+}
+
 static int synaptics_pt_write(struct serio *serio, u8 c)

drivers/input/mouse/synaptics.c static void synaptics_set_rate(struct psmouse *psmouse, unsigned int rate) · line 735

Quoted 10 lines
drivers/input/mouse/synaptics.c +5 -0
 {
 	struct psmouse *parent = psmouse_from_serio(serio->parent);
+	struct synaptics_data *priv = parent->private;
 	u8 rate_param = SYN_PS_CLIENT_CMD; /* indicates that we want pass-through port */
 	int error;
 
+	guard(mutex)(&priv->pt_mutex);
+
+	if (READ_ONCE(priv->transparent_mode))
+		return parent->ps2dev.serio->write(parent->ps2dev.serio, c);

[Severity: High]
Can this lead to corrupted PS/2 communication due to interleaved byte streams?

When transparent_mode is active, synaptics_pt_write() bypasses ps2_cmd_mutex to forward raw guest bytes. However, other paths like synaptics_set_disable_gesture() or synaptics_reconnect() can send PS/2 commands while holding ps2_cmd_mutex but without checking transparent_mode or holding pt_mutex.

For example, if a user writes to the disable_gesture sysfs attribute while the pass-through guest is active, won't the host command bytes and guest data bytes interleave on the physical PS/2 bus?

Quoted 4 lines
drivers/input/mouse/synaptics.c +1 -0
+
 	error = ps2_sliced_command(&parent->ps2dev, c);
 	if (error)
 		return error;

[ ... ]

Quoted 6 lines
drivers/input/mouse/synaptics.c +2 -0
@@ -681,6 +795,19 @@ static int synaptics_pt_open(struct serio *serio)
 	guard(serio_pause_rx)(parent->ps2dev.serio);
 	priv->pt_port_open = true;
 
+	/*
+	 * In transparent mode every byte on the parent serio belongs to

drivers/input/mouse/synaptics.c static int synaptics_pt_open(struct serio *serio) · line 809

Quoted 10 lines
drivers/input/mouse/synaptics.c +10 -0
+	 * the pass-through guest and is not a BAT announcement.  Skip
+	 * BAT detection on the child as well so that guest motion data
+	 * that happens to look like 0xAA 0x00 does not trigger a
+	 * spurious parent reconnect.
+	 */
+	if (READ_ONCE(priv->transparent_mode) &&
+	    serio->id.type == SERIO_PS_PSTHRU) {
+		struct psmouse *child = psmouse_from_serio(serio);
+		WRITE_ONCE(child->pt_bypass_bat, true);
+	}

[Severity: High]
Can this cause an out-of-bounds write if the child port is bound to a different driver?

Checking serio->id.type == SERIO_PS_PSTHRU only verifies the hardware port type, but does not guarantee the bound driver is psmouse. If a privileged user unbinds the psmouse driver and binds serio_raw instead, won't psmouse_from_serio() cast a smaller private data structure to struct psmouse, causing WRITE_ONCE(child->pt_bypass_bat, true) to corrupt slab memory?

This type confusion also appears to happen in synaptics_pt_close(), synaptics_pass_pt_packet(), synaptics_pt_activate(), and synaptics_set_transparent_mode().

Quoted 3 lines
drivers/input/mouse/synaptics.c +1 -0
+
 	return 0;
 }

[ ... ]

Quoted 11 lines
drivers/input/mouse/synaptics.c +7 -0
@@ -1447,10 +1692,20 @@ static void synaptics_disconnect(struct psmouse *psmouse)
 	 */
 	psmouse_smbus_cleanup(psmouse);
 
+	if (READ_ONCE(priv->transparent_mode)) {
+		guard(mutex)(&priv->pt_mutex);
+		synaptics_exit_transparent_mode(psmouse);
+		WRITE_ONCE(priv->transparent_mode, false);
+		WRITE_ONCE(psmouse->pt_bypass_bat, false);
+	}
+

drivers/input/mouse/synaptics.c static void synaptics_disconnect(struct psmouse *psmouse) · line 1711

Quoted 10 lines
drivers/input/mouse/synaptics.c +3 -0
 	if (!priv->absolute_mode &&
 			SYN_ID_DISGEST_SUPPORTED(priv->info.identity))
 		device_remove_file(&psmouse->ps2dev.serio->dev,
 				   &psmouse_attr_disable_gesture.dattr);
+	if (SYN_CAP_PASS_THROUGH(priv->info.capabilities))
+		device_remove_file(&psmouse->ps2dev.serio->dev,
+				   &psmouse_attr_transparent_mode.dattr);
 
 	synaptics_reset(psmouse);
 	kfree(priv);

[Severity: High]
Does this leak the pass-through child port if probe fails, leading to a use-after-free?

If psmouse_connect() fails late in probe (for example, during input_register_device() due to memory exhaustion), it calls the driver's disconnect callback, which frees the priv structure here.

Since there is no call to serio_unregister_port() for the child port, it remains registered. When the system asynchronously finishes adding the leaked port, any driver binding to it will call synaptics_pt_start(). Won't this extract and dereference the freed parent driver data, causing a crash?

Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=1
maintainer
#2 lore raw
In reply to Evan Lawrence

Hi Evan,

Quoted 18 lines · Evan Lawrence

Synaptics touchpads with a pass-through port (PS/2 guest) default to encapsulating guest data in the touchpad's own packets, limiting the guest device (typically a TrackPoint) to the touchpad's low poll rate. Enabling transparent pass-through mode tells the touchpad to stop generating its own packets and relay the raw byte stream from the guest directly, letting the TrackPoint run at its full native speed while the touchpad is effectively disabled.

This reworks an earlier implementation by Miroslav Bendík from 2022 that was never merged. It keeps the same hardware-mode approach but commits the mode flag only after a successful mode command, moves the reconnect handling into a generic psmouse hook instead of protocol- specific checks in psmouse-interrupt, and documents the interface.

The mode is exposed via a sysfs transparent_mode attribute that allows userspace to switch between full-rate TrackPoint and full-rate touchpad operation at runtime.

Quoted 6 lines

If the system warm-boots while transparent mode is active the touchpad stays in that mode and does not acknowledge command bytes, so ps2_command() hangs and the device fails to be detected. Escape transparent mode by writing SETSCALE21 + SETSCALE11 directly to the wire with serio_write() before attempting a reset or probe, both during initial detection and on reconnect.

I have not looked at the implementation yet, just a high-level question:

What devices need this? Can they work in SMbus/RMI4 mode instead (which should alleviate bandwidth concerns)?

Thanks.

Signature · 1 line
Dmitry
#3 lore raw

Hi Dmitry,

Quoted 4 lines · Dmitry Torokhov

I have not looked at the implementation yet, just a high-level question:

What devices need this? Can they work in SMbus/RMI4 mode instead (which should alleviate bandwidth concerns)?

The target devices are ThinkPad T14/P14s Gen 1/2-class Synaptics pass-through touchpads. The primary test hardware is a ThinkPad T14 Gen 1 (AMD), whose touchpad reports firmware id LEN2064 and whose TrackPoint is an Elan PS/2 device connected through the touchpad's pass-through port.

On this device SMBus/RMI4 is not a viable alternative. Even with psmouse.synaptics_intertouch=1 forced and the touchpad re-probed, it stays in PS/2 mode (no RMI4 device is created). The touchpad's own bandwidth isn't problem; it reports at 75-85 Hz in both modes. The bottleneck is specifically the TrackPoint: behind the pass-through port it is serviced at only 35-40 Hz, but with transparent mode enabled it reaches 75-110 Hz. The exact peak rate may vary by model, but the improvement should be consistently positive.

The transparent pass-through mode addresses exactly that PS/2 pass-through bottleneck by relaying the guest's raw byte stream directly instead of encapsulating it.

I'll follow up with a v6 that also reduces the mode-switch latency by avoiding the ACK-waiting ps2_command() calls on the escape sequence; I will send it as soon as I have tested it.

Thanks, Evan

#4 lore raw

Hi Dmitry,

Following up on this thread: I am pausing all work on transparent pass-through mode, including the v6 I mentioned (the ACK-waiting latency reduction). I'd rather not push a workaround once the real transport works.

The reason is your original question. In my previous reply I said SMBus/RMI4 was not viable on the T14 Gen 1 because it stayed in PS/2 mode. That turned out to be a transport bug, not a device limitation: the AMD FCH needs the legacy SMB0001/ASF Host Notify path enabled before rmi_smbus can talk to the touchpad. With that in place, the T14 Gen 1 AMD now runs the touchpad (F12) and the TrackPoint (F03) natively on RMI4, with no transparent mode and no pass-through bandwidth limit. Both devices are working on a T14 Gen 1 AMD and on a P14s Gen 2a.

That work is being carried in a machine-specific, not-yet-upstream repository together with Spencer Michaels, who did the original T14 Gen 2a reverse-engineering:

https://github.com/SpencerMichaels/t14-amd-gen2-rmi

I'll keep the transparent-mode series archived and would be glad to revive it for any machine where RMI4 genuinely cannot work -- but that no longer looks like the general answer to your question.

Thanks for the review feedback along the way, and to Miroslav for the original transparent-mode work this was based on.

Also, this was my first real foray into kernel work, and parts were LLM-assisted; I've reviewed and tested everything on the hardware. Thanks for the patience with a newcomer.

Evan

#5 lore raw
In reply to Evan Lawrence

Quick clarification: the T14 Gen 1 / P14s Gen 2a RMI4 support is local to my tree only -- I haven't pushed it to Spencer's repo or submitted it anywhere. It's early but promising (bring-up works on both machines, no full test matrix yet). The only things I've filed there are the two hardware inventories, so I didn't mean to imply this had landed or been fully validated.

Evan