gpu-unlock-ada and the Millisecond Before the Driver Loads

A Linux kernel module flips a firmware permission bit on Ada GPUs before NVIDIA's driver can claim the card, and then publishes the numbers it cannot hit.

9 min read • View on GitHub • More from JustAResearcher

A wide editorial illustration of a vast industrial machine room. On the left, a heavy steel blast door swings shut, driven by a flywheel and counterweights. On the right, a single human hand reaches through the narrowing gap to flip a small brass lever on a control panel. The image is a metaphor for the boot-order race: the door is the NVIDIA driver binding the device, the gap is the initramfs window, the lever is the firmware speed-select bit, and the hand is the kernel module.
The driver is the closing door. The module is the hand that has to reach the lever before it shuts.
Key Takeaways

The Millisecond Before the Driver Loads

The machine powers on. Firmware runs. The bootloader hands off. The initramfs unpacks into memory. And in that narrow slice of the boot sequence, a small kernel module loads, reaches into the GPU's BAR0 register space, and flips one permission bit.

Then nvidia.ko binds the device, and the window slams shut.

That ordering is the entire project. JustAResearcher/gpu-unlock-ada is not a driver patch, a userspace tool, or a firmware flash. It is a kernel module that does one thing at one instant and then gets out of the way.

The lock is a firmware permission bit. Once the driver claims the card, it owns the device state and re-asserts the locked value. You have to get there first, and you have to be gone before the driver shows up.

Miss the window and you wait for the next boot. There is no second chance from a running system.

The module also does nothing unless gpu_unlock.targets= is on the kernel command line. That opt-in gate is a safety, not a feature flag. Remove the parameter and the system boots stock. A user has to choose the unlock, per card, every boot.

The boot-order race. The gate is open until nvidia.ko binds the card, and the register strip flips exactly once inside that window.

What Is Actually Locked

The README calls the target the "SM speed-select override." Concretely, NVIDIA's consumer Ada cards ship with an SM speed-select permission set to a value that caps certain tensor-core issue paths.

The bit governs instruction issue rate for tensor operations. It does not govern memory bandwidth. It does not govern clocks. It does not make the silicon faster.

What it changes is how often the tensor cores are allowed to accept new work. Think of it as a rate limiter on the issue port, not a throttle on the engine. The distinction matters every time a number appears later in this article.

The bit lives in BAR0, in a register cluster the diagnostic module calls the speed-select cluster. Flipping it is a small write. Finding it, and reaching it before the driver does, is the hard part.

An extreme close-up editorial illustration of a jeweler's loupe held over a printed register map. Through the round lens, a single bit in a dense grid of bits is magnified, with a small padlock resting on it and a fine key inserted into the lock. The surrounding bits are drawn in soft stipple, while the magnified bit is in sharp crosshatched focus. The image makes the abstract idea of a firmware permission bit physical: one specific bit among thousands is the thing being unlocked.
One bit in a register cluster. The unlock is a small write to a very specific place.

A Compass That Only Reads

The project ships diagnostics/peek/gpu_peek.c, a separate kernel module that does nothing but read. No writes to config space. No writes to BAR space. No firmware execution. No resets. No device enablement.

A module that is provably incapable of changing anything is a strange thing to build on purpose. It gives you a before and after on the register state with no driver and no benchmark in the loop.

The module expands its output through parameters. target= selects one card. cluster=1 adds the 31-word speed-select cluster. permissions=1 adds the AD102 permission targets. Every parameter is read-only at load time, so nothing can be changed through sysfs after the fact.

The register map is self-describing. Each entry carries a human-readable name, so an unlock gets a before and after that needs no driver and no benchmark.

/* Self-describing register map: an unlock has a before/after
   that needs no driver and no benchmark. */
static const struct cluster_reg cluster_regs[] = {
    { "FEAT_READOUT_1 (SS effective)",  0x..., 4 },
    { "FEAT_OVR_SM_SPEED_SELECT",       0x..., 4 },
    /* ... 31 words total ... */
};

The diagnostic includes the module's own vbios_610.c directly rather than linking against a library. The two files can never disagree about an offset. That coupling is the tradeoff, and for a register map it is the right one.

That naming choice is the point. It separates "what state is the hardware in?" from "what throughput does it deliver?" The first question has a cheap, exact answer. The second does not.

How You Prove It Worked

The benchmarks live in diagnostics/bench. mma_bench.cu measures instruction issue rates across FP16, BF16, INT8, FP8, dp4a, and scalar fma.

Three details make the numbers trustworthy. Every kernel ends with a comparison that cannot be true in practice, so the optimizer cannot delete the loop.

/* The loop cannot be deleted: the store only fires if the
   comparison succeeds, and it never should. */
if (carry == (Acc)0x7fffffff)
    sink[threadIdx.x] = 1.0f;

The chain counts are tuned per unit: 8 independent accumulator chains for tensor operations, 32 for scalar units, because the scalar units are latency-bound. The grid is fixed at 1056 blocks so runs stay comparable.

Each mode runs multiple times and the best result is reported. The header tells you to record clocks and power alongside each invocation, because sustained tensor load moves both. That instruction is the difference between a benchmark and a marketing number.

Correctness is checked separately, in validate_gemm.cu. cuBLAS runs with deterministic seed inputs and is compared against a CPU reference quantized to the same values the GPU sees. The test sizes include 127x65x95, which is not a multiple of any tile size. The program refuses to run outside sm_86 and sm_89.

The stated purpose is "a correctness check, not a throughput benchmark." That separation is deliberate. The claim that an unlock does not corrupt results rests on this check passing.

The Numbers They Refuse to Claim

Here is where the project gets interesting.

The release notes report a 1.99x TF32 instruction-issue rate result in a register-resident probe on one RTX 4070 Ti SUPER. In the same release, unsigned INT4 does not improve. A prior release reports effectively unchanged results for a tested FP8 GEMM and an INT8 workload.

The release documentation draws the line explicitly.

These all-one, register-resident loops do not establish an application GEMM or inference speedup.

JustAResearcher/gpu-unlock-ada, Project release documentation · Releases · gpu-unlock-ada

A project that reports its losses is rare in a genre defined by hype. The negative results are the reason the positive ones are worth reading.

The Fork Lineage

The project is an Ada fork. It retains the Ampere device list from Zagitta's gpu-unlock and adds AD102 support plus an experimental AD103 path. A separate project, nlzy's turing-unlock, covers RTX 20-series cards with its own module and its own command-line option.

That's a fork of GP's work.

jacquesm, Hacker News commenter · Hacker News discussion
ProjectCards targetedModuleNotes
JustAResearcher/gpu-unlock-adaAmpere (retained) + AD102/4090 + experimental AD103/4070 Ti SUPERgpu_unlockLocally generated firmware from pinned NVIDIA inputs; opt-in via gpu_unlock.targets=
Zagitta/gpu-unlockGA102, GA103, GA104, GA106gpu_unlockThe Ampere precursor
nlzy/turing-unlockTU102, TU104, TU106turing_unlockSeparate module; different cmdline option; high tensor power warning

The build fetches pinned NVIDIA inputs and generates firmware locally. NVIDIA firmware binaries are never distributed in the repository. That is a licensing decision as much as a technical one.

All three projects build on the target machine. None ships prebuilt binaries. The Ada fork extends the lineage instead of replacing it.

The Edges

The AD103 path is a canary, and the project treats it like one. The report says it ran on a single card, and it says so plainly.

This is one physical card.

JustAResearcher/gpu-unlock-ada, Project technical report · AD103 2705 report

The report does not stretch its evidence past the boundary it can defend.

The list of cautions is longer than the list of features.

DKMS, three initramfs config files, and a kernel command-line parameter. This is an invasive early-boot operation, not a performance slider.

The honest edge is the ending. The project knows exactly how far its evidence reaches, and it stops there.