Baseline Environment: Windows 11 (24H2) / Intel Core Ultra / Xiaomi Redmi Book Pro 14 2026

1. Quick Self-Check (30 Seconds)

Symptoms: When moving the cursor with the touchpad on a Windows laptop on battery power, the cursor intermittently freezes for roughly 100–400ms, then suddenly snaps (teleports) to the finger’s latest position.

Diagnostic Criteria (Matches this issue if all three hold):

  • Plugging in fixes it immediately: Highly reproducible on battery power (DC mode), but disappears instantly when plugged into the charger (AC mode).
  • Keyboard works flawlessly: Typing continuously remains perfectly responsive, without dropped keystrokes, lag, or input latency.
  • Always freezes on the initial stroke after a brief pause: Cursor tracking is not uniformly slow. Instead, the freeze occurs specifically on the first stroke after pausing for a second; continuous movement remains smooth.

2. Solution (3 Steps to Fix Completely)

Step 1: Disable I2C Controller Power Management

  1. Press Win + X and select Device Manager.

  2. Expand System devices and locate:

    • Intel(R) Serial IO I2C Host Controller - E450
    • Intel(R) Serial IO I2C Host Controller - E451

  3. Double-click each controller to open its Properties → switch to the Power Management tab.

  4. Uncheck: Allow the computer to turn off this device to save power, then click OK to save.

Step 2: Disable Intel GPU “Panel Self Refresh (PSR)”

  1. Open Intel Graphics Software (or Intel Graphics Command Center).
  2. Click Display in the left navigation sidebar.
  3. Scroll down to the Power / Energy Saving section.
  4. Toggle Panel Self Refresh (PSR) to Off.

Step 3: [Mandatory] Restart the Computer

  • Required Action: After modifying both settings above, you must reboot the system (Start menu → Restart).
  • Mechanism: The I2C host controller is a motherboard system bus device. Its runtime power management policy is loaded during initial system boot and cannot be hot-reloaded dynamically from Device Manager. Without a full restart, the previous power policy remains resident in memory.

3. Verification & Battery Trade-off

  • Observed Result (Verified): After unplugging the power cable, touchpad tracking feels identical to AC plugged-in operation—stuttering and teleportation are completely eliminated.
  • Battery Trade-off (⚠️ Theoretical estimate; unverified by full-discharge benchmarks): Disabling PSR keeps the GPU display engine and eDP link transmitting frames continuously. Based on typical Intel mobile power models, disabling PSR reduces battery life by an estimated 5%–10% during static workloads (e.g., pure typing or reading—shifting roughly a 10-hour battery life to 9–9.5 hours), which remains well within acceptable limits.

4. Common Pitfalls (Why Intuitive Fixes Fail)

When encountering touchpad lag, developers frequently try adjusting sensitivity or killing background tasks, but these standard remedies do not solve this issue:

  • ⚠️ Pitfall 1: Adjusting pointer speed or enabling “Enhance pointer precision”
    • Why it fails: The freeze stems from hardware link dormancy and wake handshakes, not insufficient DPI sampling. Increasing pointer speed merely amplifies the jump distance when the cursor catches up.
  • ⚠️ Pitfall 2: Hunting background tasks or killing startup programs
    • Why it fails: Typing remains perfectly responsive, proving that CPU scheduling and the DWM compositor are not bottlenecked. The bottleneck resides exclusively on specific bus and display pipelines.
  • ⚠️ Pitfall 3: Disabling “Display Power Saving Technology (DPST)”
    • Why it fails: DPST adjusts backlight PWM brightness dynamically based on image content (causing brightness shifts), without disrupting frame transmission timing. The feature responsible for putting the display engine to sleep is PSR (Panel Self Refresh).
  • ⚠️ Pitfall 4: Modifying Device Manager settings without restarting
    • Why it fails: Testing immediately after toggling settings without rebooting will still produce stutters, leading users to falsely assume the fix did not work. The bus driver’s power policy only updates upon a reboot.

5. Deep Dive: Root Causes Explained

5.1 Why Does Typing Stay Smooth While the Touchpad Sleeps?

Root Cause: The keyboard and touchpad operate on physically isolated power domains. To maximize battery endurance, Windows enforces strict “device-level autonomy”—active keyboard usage does not signal the I2C bus to stay awake. If the touchpad stays idle for roughly one second, its bus cuts power. Using it again triggers a hardware wake handshake, creating a perceptible freeze on the first stroke.

  • Keyboard Path (Always Active): Keyboard (continuous typing) → EC (Embedded Controller) → Permanent power rail (D0) → Completely smooth
  • Isolation Boundary: ⚡ Physical Power Domain Isolation (OS does not broadcast activity across separate buses; idle devices sleep autonomously)
  • Touchpad Path (Independent Sleep): Touchpad (idle for ~1s) → I2C Host Controller → Cuts power (D3) → Next touch requires wake handshake (Stutter & Teleport)

Hardware Detail: The touchpad communicates over Intel Serial IO I2C Host Controller - E451. Keeping each peripheral independent is an intentional operating system design trade-off to maximize battery benchmark scores.

5.2 Dual-Layer Hardware Latency Resonance

Under battery power, two separate aggressive power-saving mechanisms engage simultaneously, compounding the perceived delay:

Layer 1: I2C Bus Selective Suspend (~100–300ms typical wake handshake)

Windows defaults to enabling runtime power management on the I2C Host Controller. When touchpad input ceases for 0.5–1 second, the controller transitions from active state D0 to low-power state D3hot. When a finger touches down, the bus powers up, resynchronizes clocks, and completes handshake renegotiation with the touchpad controller, which typically consumes 100–300ms per bus specifications. Coordinates gathered during this window accumulate in local FIFO buffers and are flushed in a sudden burst once the link is re-established, causing the cursor to jump.

When the screen is static, the Intel iGPU display engine sleeps, instructing the eDP panel to refresh autonomously from its embedded frame buffer. When the cursor starts moving, the GPU detects frame changes, restarts its display clocks, and re-engages the eDP link, which typically requires 200–400ms per eDP specifications. Even if I2C coordinates have reached the OS input stack, display pixels remain temporarily frozen, amplifying the delay into severe visual stutter.