SW-IFF unlock on the 10 GB card
More actions
| Reported 10 GB | |
| Driver | nvidia-open 615.71.09 (cmpunlocker, 10gb profile) |
|---|---|
| Unlock build | 170hx-rir-tool (gate) + iff_apply.py (SW-IFF) + cmp170hx-ffcalc burntool, patched (FF) |
| Steps | SW-IFF unlock on the 10 GB card |
| Source | lab notes |
| Confirmations | None yet. |
SW-IFF (software IFF) is the reversible way to bring a 10 GB card up to its full defect-preserving SM count. After the RIR fuse burn has opened the software-override gate, you write fuse-override records into a volatile SRAM overlay. A function-level reset (FLR) makes the fuse block replay those records at fuse sense, before devinit, so GPCs that were fused off as a whole come up and initialise. Nothing else is burned, and a power cycle returns the card to stock. Once a configuration has held up under load, the same masks can be written as FF (fuseless fuse) records in the main fuse array, which makes them permanent and should let the card run in a VM.
On 2026-11-17 the lab took two 10 GB cards (10de:2082, Samsung HBM) from 74 to 122 and 108 SMs on bare metal with every factory-defective unit still masked, then burned the same masks as FF records and confirmed both after a cold boot. Memory stayed at 40 GiB on both. Proven 10 GB
Source: @darkmaniac7, 2026-11-17 (lab notes)
Warning Read this before you write anything. The RIR gate burn and the FF burn are one-time fuse writes: there is no undo, and a wrong record can brick the card or switch a unit off for good. Prove every configuration with SW-IFF first, under load, then burn exactly that configuration and nothing more. Check that your card has blank FF rows before you plan a burn. SW-IFF does not work inside a VMware ESXi passthrough VM (below). The order of operations for both cards and the list of mistakes that have already bricked cards are on Unlock without bricking.
Results
| Card A | Card B | |
|---|---|---|
| Stock GPC disable mask | 0x64 (GPC 2, 5 and 6 off) |
0x89 (GPC 0, 3 and 7 off)
|
| Factory-defective units | one TPC each in GPC 2, 5 and 6 | TPC 1 of GPC 0, TPC 7 of GPC 3, all of GPC 7 |
| cmpunlocker only | 74 SM, 40 GiB | 74 SM, 40 GiB |
| Driver-time OPT writes (late) | 80 SM; enabling a whole GPC timed out (tested in an ESXi VM) | not run |
| SW-IFF, then FLR (volatile) | 122 SM | 108 SM |
| FF burn, then cold boot (permanent) | 122 SM, 7 FF records | 108 SM, 7 FF records |
| CUDA SM check | 122 distinct SM IDs, 5 of 5 runs | 108 distinct SM IDs, 3 of 3 runs |
| Memory test | 38 GiB, 92 rounds, 7,508 GB verified, 0 errors | 38 GiB, 92 rounds, 7,508 GB verified, 0 errors |
| Load test before the burn | gpu-burn on all SMs, 300 s, 0 errors, 0 Xid | gpu-burn, 300 s, 39,922 iterations, 0 errors, 0 Xid |
Host: a desktop board, UEFI, Ubuntu 24.04, kernel 6.8.0-149, Secure Boot off, cmpunlocker on nvidia-open 615.71.09 with the 10gb profile. Both cards ran at x4 (no capacitor mod). The SM check is a CUDA tensor-core kernel that records the SM ID of every block and checks its results; the memory test writes address-dependent patterns. The only fuse writes on either card are the RIR gate and the seven FF records each. Proven 10 GB
Source: @darkmaniac7, 2026-11-17 (lab notes)
How it works
Why driver-time OPT writes stop at about 80 SMs
Every 10 GB card ships with three GPCs fused off, so five GPCs are enabled: at 8 TPCs and 2 SMs per TPC that is 80 SMs. With the gate open, writing the OPT floorsweep registers while the driver loads does enable the missing TPCs inside those five GPCs (the lab's card A went 74, 76, then 80, with CUDA confirming each step). Enabling one of the three fused-off GPCs the same way failed on card A (tested inside an ESXi passthrough VM): the driver bind hit FECS and HOST PRI timeouts and Xid errors. A late write misses the stage where the GPC is initialised. SW-IFF records are replayed at fuse sense, before devinit, which is why the same GPCs come up cleanly through SW-IFF. This matches the members who stopped at 80 to 82 SMs with the RIR tool alone. Proven 10 GB
Source: @darkmaniac7, 2026-11-16 (lab notes)
Source: @_orrorin, 2026-10-25
Source: @zarknoth, 2026-11-15
The IFF window and the record stream
IFF_RECORD (0x820050) points the fuse block at a window of rows that it executes as a small program at every reset: START in bits 8:0, LAST in bits 24:16. The stock value 0x01fb01e8 is rows 488 to 507. Each record is an op word, ((addr >> 2) << 6) | op, followed by its data: op 0x3D (WRITE_DW) takes one data word, 0x3C (MODIFY_DW) takes two (mask, then value). With EN_SW_OVERRIDE (0x820040) set, the window can point into a volatile SRAM overlay instead of the fuse array. iff_apply.py writes your records into that overlay just below the stock stream, puts an EN_SW_OVERRIDE=1 record first (op word 0x0820043D), keeps the 20 stock rows in the window and moves START down. An FLR then makes the fuse block run the extended window. The interpreter stops at the first empty slot, so every slot in the window must hold a record. Reported 10 GB
Source: @xeax, 2026-10-22
Source: @darkmaniac7, 2026-11-17 (lab notes)
The stock window as read on both lab cards (identical on both, and equal to the values iff_apply.py checks for, although the two cards have different floorsweeps):
| Rows | Words | Decoded |
|---|---|---|
| 488-489 | 0x000d56bd, 0x0000ef8f |
WRITE_DW 0x00D568
|
| 490-492 | 0x008c2c3c, 0xff7fdffb, 0x00802004 |
MODIFY_DW 0x08C2C0 (mask, value)
|
| 493-494 | 0x0088ff7d, 0xffffff8f |
WRITE_DW 0x088FF4
|
| 495-496 | 0x0122437d, 0x009a4000 |
WRITE_DW 0x122434
|
| 497-498 | 0x01226b7d, 0x0003c000 |
WRITE_DW 0x1226B4
|
| 499-500 | 0x01224b7d, 0xfc001fff |
WRITE_DW 0x1224B4
|
| 501-502 | 0x0122637d, 0x00000008 |
WRITE_DW 0x122634
|
| 503-505 | 0x000020fc, 0xdffffff3, 0x2000000c |
MODIFY_DW 0x00020C (PMC_ELPG_ENABLE)
|
| 506-507 | 0x008d173d, 0xa0802007 |
WRITE_DW 0x08D170
|
That is 9 op words in 20 rows. 0x000d56bd is the first stock record (a write to 0x00D568), not an encoding of 0x820040. Proven 10 GB
Source: @darkmaniac7, 2026-11-17 (lab notes)
Is the stock window the same on every 10 GB card?
Contested 10 GB In the order posted:
- bruno063185 (gate burned, 80 SMs volatile) read rows 488 to 507 on his card as words with no op codes in them, so
iff_apply.pyaborted with "stock IFF stream not recognised", and he asked whether the 10 GB window is encoded per card. Source: @bruno063185, 2026-11-16
Source: @bruno063185, 2026-11-16 - The lab's two cards read the stock stream above, byte for byte, with different floorsweeps, so on these two the stream is not keyed per card. Source: @darkmaniac7, 2026-11-17 (lab notes)
- Theory The lab's explanation, not yet checked on his card: while
EN_SW_OVERRIDEis 1, a fuse-row read inside the window returns the SRAM overlay slot, and never-written SRAM looks random. A driver built withcmp_fuse_*options setsEN_SW_OVERRIDE=1before RM and GSP boot ("CMP fuse: EN_SW_OVERRIDE=1 (pre-RM/GSP)" indmesg), and it stays set after unbind. The lab's dumps were taken with0x820040at 0. Source: @darkmaniac7, 2026-11-17 (lab notes)
Before you start
- A 10 GB card (
10de:2082) on bare metal. Not a VMware ESXi passthrough VM. Other hypervisors are untested. - The RIR fuse burn done and active:
DISABLE_SW_OVERRIDE_STATUS(0x820084) reads 0. A freshly burned gate becomes active only after a bus reset or a cold boot, not after an FLR (below). - The fuse PLMs open:
0x8200E0and0x8200F4read0xffffffff. cmpunlocker opens them during GSP boot and they stay open after the driver is unbound. After a bus reset with no driver loaded they read closed; bind the driver once and unbind it. Do not open0x8200F4by a direct write: theiff_apply.pyREADME records a card where that went wrong. - The stock window:
IFF_RECORDreads0x01fb01e8and rows 488 to 507 hold the stream above.iff_apply.pychecks the first and last words and aborts on a mismatch. - Driver cmpunlocker on nvidia-open 615.71.09, 10gb profile, built for your kernel;
iomem=relaxedon the kernel command line for the BAR0 tools. - Your card's defect masks, read with Gpcprobe or cmp170hx-ffcalc (both read-only).
- SBFE (
0x821108) andWDATA_WR_SECURE(0x82048c) do not matter for SW-IFF; they gate the FF burn.
Proven 10 GB
Source: @darkmaniac7, 2026-11-17 (lab notes)
Source: @xeax, 2026-10-22
Work out the masks for your card
The rule the lab used: enable every unit that is disabled but not marked defective, and nothing that is marked defective. GPCs marked defective really are defective; inside an enabled GPC, mask only the defective TPCs.
- GPC disable (
0x820350, 8 bits, one per GPC): clear the bit of every GPC that has at least one working TPC. A GPC whose TPCs are all marked defective (TPC defective mask0xff) stays disabled. - TPC disable (
0x820760 + 4*gfor GPC g, 8 bits each): write the defective mask of that GPC, so only the defective TPCs stay off. A GPC that stays disabled keeps its mask (0xff). - PES disable (
0x820690, 3 bits per GPC): clear the bits of every enabled GPC; a GPC that stays disabled keeps its three bits set. Do not leave PES out: an earlier plan with only GPC and TPC records was rejected in review because it would leave the new GPCs without their PES units. - SM count = sum over the enabled GPCs of 2 x (8 - defective TPCs in that GPC).
Proven 10 GB
Source: @zorg33, 2026-10-22
Source: @darkmaniac7, 2026-11-17 (lab notes)
Worked examples:
- Card A: GPCs 2, 5 and 6 were disabled but not defective, with one defective TPC each. All 8 GPCs on, 3 TPCs masked: 64 - 3 = 61 TPCs = 122 SMs. Records:
0x820350=0 0x820690=0 0x820760=0 0x820764=0 0x820768=0x02 0x82076c=0 0x820770=0 0x820774=0x02 0x820778=0x01 0x82077c=0. - Card B: GPC 7 is defective as a whole and stays off; TPC 1 of GPC 0 and TPC 7 of GPC 3 are defective. Seven GPCs: 7 + 8 + 8 + 7 + 8 + 8 + 8 = 54 TPCs = 108 SMs. Records:
0x820350=0x80 0x820690=0xe00000 0x820760=0x02 0x820764=0 0x820768=0 0x82076c=0x80 0x820770=0 0x820774=0 0x820778=0(GPC 7's TPC mask is not written and stays0xff). - 126 SMs needs a die with exactly one defective TPC and no defective GPC, 128 a die with none. Higher counts posted for other cards came either from relaxed masks (Colo's 126-SM card has a GPC marked defective, of which only one SM pair failed his tests) or from cards with fewer defects. The lab did not enable any defective unit.
Proven 10 GB
Source: @darkmaniac7, 2026-11-17 (lab notes)
Source: @colo2442, 2026-10-22
RECONFIG: the last TPCs come from cmpunlocker, not from the masks
Each GPC also has a soft reconfiguration fuse, NV_FUSE_OPT_TPC_GPCx_RECONFIG (GPC 0 to 5 at 0x820788 to 0x82079c, GPC 6 at 0x820b94, GPC 7 at 0x820b90). A TPC is off when its bit is set in STATUS = OPT | (RECONFIG & ~OVR). cmpunlocker writes the volatile override 0x820a40 + 4*g = 0xff for every GPC before GSP boot, on every 0x20c2 and 0x2082 card. That is the 70 to 74 SM step, and it is also the "extra 4 SMs" that cmpunlocker adds after an FF burn. Defects stay masked, because the fused TPC-disable bits stay set and the override only clears RECONFIG. On both lab cards RECONFIG is set on TPC 0 of two GPCs (card A: GPC 4 and GPC 7; card B: GPC 4 and GPC 5); the override clears them, and the 122 and 108 counts include those TPCs. On a stock 8 GB card it is not a further step: all eight of the lab's 8 GB cards already show every RECONFIG-only TPC (74 SMs each). Proven 8 GB and 10 GB
Source: @akuchen_66498, 2026-09-26
Source: repo github.com/amoghmunikote/cmpunlocker by amoghmunikote on GitHub
Source: @darkmaniac7, 2026-11-17 (lab notes)
Theory The lab's FF burns wrote no RECONFIG records, so without cmpunlocker loaded the burned cards would most likely read 118 and 104 SMs; this was not tested. The same pattern was seen on an 8 GB card after GA100VFI: @._.patrik had all 128 SMs with none defective, but only 124 showed without cmpunlocker and 128 with it, and Zagitta asked whether he had enabled "the RECONFIG ones". 8 GB and 10 GB
Source: @._.patrik, 2026-11-15
Source: @zagitta, 2026-11-15
Source: @darkmaniac7, 2026-11-17 (lab notes)
Warning Do not burn RECONFIG records. Their FF field positions are not mapped by any public tool (ffcalc and ffburn's planner map the TPC disable fields only), and the volatile override already gives those TPCs back at every driver load. 8 GB and 10 GB
Source: @darkmaniac7, 2026-11-17 (lab notes)
Steps: SW-IFF (volatile)
- Stop every CUDA client on the card and unbind it from the driver through its sysfs path (
echo 0000:01:00.0 > /sys/bus/pci/drivers/nvidia/unbind). Leave other GPUs bound. - Enable memory access on the device and check the preconditions above with reads only:
0x820084= 0,0x8200E0and0x8200F4=0xffffffff,IFF_RECORD=0x01fb01e8,EN_SW_OVERRIDE= 0. - Arm the records, stock stream first:
IFF_STOCK_FIRST=1 python3 iff_apply.py 0000:01:00.0 install 0x820350=0 0x820690=0 .... RequireINSTALL=OK.iff_apply.py ... showdecodes the armed window. - Reset the card with an FLR:
echo flr > /sys/bus/pci/devices/0000:01:00.0/reset_method, thenecho 1 > /sys/bus/pci/devices/0000:01:00.0/reset. - Read back before you bind (next section). If the census is wrong, undo and stop.
- Bind the driver. Check
dmesgfor Xid, FECS or HOST PRI errors, then run a CUDA SM-ID check and a memory test before any real work.
Proven 10 GB
Source: @darkmaniac7, 2026-11-17 (lab notes)
Source: @scallion_9883, 2026-10-22
Source: @xeax, 2026-10-22
Expected readback after the FLR
EN_SW_OVERRIDE= 1 andIFF_RECORDpoints at the extended window (START 466 for card A's 10 records, 468 for card B's 9; LAST stays 507).- GPC status (
0x820c1c), TPC status (0x820c38 + 4*g) and PES status (0x820dbc + 4*g) show the target census with the defective bits still set. Card A: GPC status 0, TPC status GPC 2 =0x02, GPC 5 =0x02, GPC 6 =0x01, PES all 0. Card B: GPC status0x80, TPC GPC 0 =0x02, GPC 3 =0x80, GPC 7 =0xff, PES GPC 7 = 7. - Memory unchanged:
nvidia-smishows 40960 MiB after the bind.
Proven 10 GB
Source: @darkmaniac7, 2026-11-17 (lab notes)
Undo
Run iff_apply.py <bdf> undo, then an FLR; or power the machine off. The overlay lives in SRAM and dies with power, so a cold boot is always back to stock (the RIR gate stays burned). An armed window replays at every reset, including ones you did not plan (a driver fault, nvidia-smi -r), until you undo it. Proven 10 GB
Source: @darkmaniac7, 2026-11-17 (lab notes)
Source: @xeax, 2026-10-22
Resets: which one does what
| You want to | Use | Why |
|---|---|---|
| Execute an armed SW-IFF window | FLR (reset_method=flr) on bare metal, driver unbound |
A bare-metal FLR keeps the SRAM overlay and replays it at fuse sense. |
| Activate a freshly burned RIR gate | Secondary bus reset (reset_method=bus) or a cold boot |
An FLR does not re-sense the gate: 0x820084 stayed 1 after an FLR and read 0 after a bus reset.
|
| Go back to stock | Power cycle | The overlay dies; RIR and FF fuses stay. |
Proven 10 GB
Source: @darkmaniac7, 2026-11-17 (lab notes)
Warning VMware ESXi passthrough wipes the overlay. Inside an ESXi passthrough VM the arming works (INSTALL=OK, the overlay rows decode correctly and survive a driver bind), but every reset the guest can issue clears it before replay: after a guest FLR or nvidia-smi -r, IFF_RECORD was back at stock and the overlay rows read 0. Setting the VM's pciPassthru.resetMethod to flr or link changed nothing. A driver bind keeps the overlay but does not replay it. The same arm and FLR worked at once after the cards moved to a bare-metal host. To run an unlocked 10 GB card in a VM, burn the configuration as FF records first (see the next section; the burned cards have not yet been checked inside a VM). 10 GB
Source: @darkmaniac7, 2026-11-16 (lab notes)
Making it permanent: the FF burn
Warning This is permanent. FF records are one-time fuse writes in the main fuse array. A later record can override an earlier one only while there are blank rows left and only if the card still boots. Burn only a configuration that has run under SW-IFF, under load, on this card. Leave Gen3/Gen4, ECC and NVLink out of it: Gen3 and Gen4 already work volatile through the driver and need no burn, and ECC and NVLink do not work volatile yet (see below).
FF records sit in the fuse array and replay at every reset, so a burned floorsweep should also work in a passthrough VM; the lab has not checked that yet. The 10 GB route needs no voltage glitch: with the RIR gate burned, the burn window opens in software. Kate's GA100VFI write-up describes the FF programming method; zarknoth reported 104 SMs on 10 GB cards this way on 2026-11-15, and GhostInTheDatacenter burned an FF record on a 10 GB card to clear the NVLink disable mask at boot. Reported 10 GB
Source: repo github.com/kate-land/ga100vfi by kate-land on GitHub, 2026-11-10
Source: @ghostinthedatacenter_87281, 2026-11-13
Source: @zarknoth, 2026-11-15
Source: @zarknoth, 2026-11-15
The burn window
On a gate-burned card, unbound, with the PLMs opened by one driver bind and unbind, every precondition is set in software: EN_SW_OVERRIDE (0x820040) = 1; write 0 to SBFE (0x821108) and to WDATA_WR_SECURE (0x82048c) and read back 0; EFP (0x820078) = 1; fuse chain CRC (0x820070) = 0x55; DEBUGCTRL (0x820060) = 0, so writes go to the main array and not the RIR aperture; controller idle; 0x8200F4 and 0x8200F8 = 0xffffffff. All of it is volatile and an FLR clears it. Proven 10 GB
Source: @darkmaniac7, 2026-11-17 (lab notes)
Record format
An FF record is one 32-bit row: data[31:16] | block[15:6] | chain[4:0], bit 5 clear (the IFF records above have bit 5 set). Each record replaces one 16-bit block of a fuse chain, and the last record for a block wins. The floorsweep sits in chain 1: GPC disable at bits 131 to 138 (block 8), TPC disable of GPC g at bit 187 + 8g (blocks 11 to 15), PES disable at bits 251 to 274 (blocks 15 to 17). Main-array rows 222 to 487 are the FF space in ffcalc and ffburn; the IFF window starts at row 488. Kate's GA100VFI work published the chain mapping and ffcalc encodes it. Reported 8 GB and 10 GB
Source: repo github.com/sayhellotojungle/cmp170hx-ffcalc by sayhellotojungle on GitHub
Source: repo github.com/kate-land/ga100vfi by kate-land on GitHub, 2026-11-10
Warning Only rows the boot parser reads count. On one 8 GB card the parsed window ended at row 302: appends after it were ignored at boot, and a record with bit 5 set in row 303 blocked every later row. The lab's records in rows 298 to 307 were read on its two 10 GB cards (both counts held after a cold boot), but check where your card's parsed records end before you plan, and never set bit 5 in an FF record. 8 GB and 10 GB
Source: @port00, 2026-11-16
Source: @wgxli, 2026-11-16
Source: @darkmaniac7, 2026-11-17 (lab notes)
Card A's plan, as the order and layout only. The data words are not shown: they encode this die's defect masks, and the same words on another card would enable its dead units. Generate your own plan from your own card.
| Order | Row | Chain, block | Field |
|---|---|---|---|
| 1 | 299 | 1, 11 | TPC masks |
| 2 | 300 | 1, 12 | TPC masks (keeps the defective TPC of GPC 2) |
| 3 | 301 | 1, 13 | TPC masks |
| 4 | 302 | 1, 14 | TPC masks (keeps the defective TPCs of GPC 5 and 6) |
| 5 | 303 | 1, 15 | TPC and PES masks |
| 6 | 304 | 1, 16 | PES masks |
| 7 | 298 | 1, 8 | GPC disable, written last |
Card B used rows 301 to 307 with its own words, GPC record (row 301) last. Neither plan has a RECONFIG record. Proven 10 GB
Source: @darkmaniac7, 2026-11-17 (lab notes)
Steps
- Run the configuration under SW-IFF first: CUDA SM-ID check, memory test, and at least 300 s of gpu-burn on all SMs with 0 errors and 0 Xid.
- Capture all 512 main fuse rows from this card, twice, and check the two captures match. Plan from that capture only: it must decode to the masks you ran under SW-IFF, and every target row must be blank.
- Generate a compute-only plan: GPC, TPC and PES records, with every memory, identity, PCIe and NVLink bit unchanged (check neighbouring bits in shared blocks). Drop any PCIe records the planner adds.
- Unbind the card, open the burn window (above) and check it.
- Write the child records (TPC, PES) first and the GPC disable record last. If the burn stops part way, every complete prefix still keeps the new GPCs disabled. Read back each row after writing it. Stop at the first fault; do not retry.
- Read back all 512 rows and compare them with the capture plus the plan. CRC must still read
0x55. - Settle the card before any reboot: FLR, bind the driver, check it comes up. Then shut down and remove power.
- Cold boot with nothing armed and the cmpunlocker driver loaded as usual. Check
EN_SW_OVERRIDE= 0,IFF_RECORD=0x01fb01e8, the GPC disable mask as planned, CRC0x55, the CUDA SM count and 40960 MiB. The count includes the TPCs that cmpunlocker's RECONFIG override gives back (above).
Result on the lab's cards: card A native 122 SMs (EN_SW_OVERRIDE 0, GPC disable 0x00), card B native 108 SMs (GPC disable 0x80), both 40 GiB, CRC 0x55, no boot faults, every defect still masked. Proven 10 GB
Source: @darkmaniac7, 2026-11-17 (lab notes)
Warning Do not reboot straight from the open burn window. After card A's burn the lab rebooted with the card unbound, EN_SW_OVERRIDE = 1 and SBFE = 0; the first boot hung at POST and needed a hard reset. The burn itself had landed and card A came up at 122 SMs after the reset. Card B was settled (FLR, driver bind) before the reboot and booted cleanly. 10 GB
Source: @darkmaniac7, 2026-11-17 (lab notes)
Tools, and what had to be fixed
- cmp170hx-ffcalc (sayhellotojungle) reads the fuses, decodes the floorsweep and generates a burn plan; it is 2082-aware and reproduced every mask on the lab's cards from the raw rows. Its SM prediction can still over-count when it misses TPC defects (@killred), so check a plan against a direct register read of the defect masks. Issue #1 (planning over rows that are already burned) was fixed on 2026-11-16 by reading all 512 rows and refusing an incomplete capture. A main-array burner,
burntool, was added on 2026-11-17. Before the lab used it on 2082 cards, four things needed fixing: its capture accessor callsint(addr, 0)on integer offsets, so the firststatuscall fails with aTypeError; it writes in plan order and sends a SENSE at the start of every run, so the GPC-last order has to be enforced by the caller; it read other registers and restoredFUSEADDRafter a controller fault, where it should stop all access; and it does not bind the live BDF to the card the plan was made for. Do not use its--force. Reported
Source: repo github.com/sayhellotojungle/cmp170hx-ffcalc by sayhellotojungle on GitHub
Source: @killred, 2026-11-16
Source: @darkmaniac7, 2026-11-17 (lab notes) - ffburn.py3 (68x0, posted 2026-11-16) is a guarded main-array writer: it refuses to run unless DSOV = 0, CRC =
0x55, SBFE = 0, override on,WDATA_WR_SECURE= 0, EFP = 1 and both PLMs open; it writes only blank rows 222 to 487 with the main array selected, reads back every row and the full array, and keeps a journal. It does no setup of its own, accepts only0x20c2and0x2080cards, and its planner is for the 8 GB card. Its author calls much of the tooling LLM-generated with spot checks only. Reported
Source: @68x0, 2026-11-16
Source: @68x0, 2026-11-16 - Warning Do not burn FF rows with the RIR tool. 170hx-rir-tool writes through the RIR aperture (
DEBUGCTRLRWL = 1). Aimed at a main-array row it would alias into the RIR bank and could corrupt the burned gate. Kate: "don't waste a RIR slot on FF". Source: @onemillionkates, 2026-11-13
Source: @darkmaniac7, 2026-11-17 (lab notes)
Memory: 40 or 48 GiB
On the 10 GB card each FBP carries 4 GiB, and a full GA100 has 12 FBPs (48 GiB). Compare the disable fuses with the defective fuses: OPT_FBP_DISABLE (0x820364) against fbp_defective (0x8205cc), and the same for FBPA (0x820368 / 0x8205d0), FBIO (0x82036c / 0x8205d4) and ROP_L2 (0x8202c4 / 0x8205e8). If fbp_disable & ~fbp_defective is 0, every missing FBP is dead silicon and the card stops at 40 GiB. Both lab cards are 40 GiB cards (FBP disable equal to defective, 0x180 and 0x600), so their FF burns left every memory field at stock. A SW-IFF probe that enabled all 12 FBPs on card B bound cleanly but still gave 40 GiB. Details: Memory unlock on the 10 GB card#How to tell a 40 GiB card from a 48 GiB card (lab, 2026-11-17). Proven 10 GB
Source: @darkmaniac7, 2026-11-17 (lab notes)
Other fuses: Gen3 and Gen4, ECC, NVLink, P2P
Clearing a feature's disable fuse through SW-IFF applies in hardware, but on its own it turned on none of these features on the lab's cards. Each needs driver or board work as well, so none of them belongs in an FF burn until it works volatile.
- PCIe Gen3 and Gen4 work on both cards through a driver-side route that is re-trained at every boot; the SW-IFF fuse clear alone only changed what the card advertises, and a forced retrain dropped the card off the bus. Gen3 x4 ran on both cards at once through a 30-minute soak. Gen4 x4 (16 GT/s at both ends, 6.37 / 6.76 GB/s pinned copies) took the same build plus a Gen4 patch, a runtime PHY init and one config-space retrain. See PCIe Gen3 on the 10 GB card#Lab reproduction on driver 615.71.09 (2026-11-17) and PCIe Gen4 on the 10 GB card.
- ECC:
OPT_ECC_ENset through SW-IFF, ECC mode still N/A. See ECC#ECC fuse override on the 10 GB card (lab, 2026-11-17). - NVLink:
OPT_NVLINK_DISABLEcleared through SW-IFF, driver still reports no NVLink. See NVLink#NVLink disable fuse cleared on the 10 GB card, no link (lab, 2026-11-17). - P2P: the SM burn does not change it. CUDA peer access stays off without a P2P driver patch. See P2P#10 GB pair after the SM unlock: peer access still off without a P2P patch (lab, 2026-11-17).
Proven 10 GB
Source: @darkmaniac7, 2026-11-17 (lab notes)
Mining numbers
Pearl at the stock 250 W power cap (except the reference row), measured by the lab. TMAC/s is the lab's own Pearl miner build; TH/s is OneZeroMiner's pearlhash display. The two are different instruments; do not compare across them.
| Setup | Result | Power |
|---|---|---|
| 74 SM reference: an 8 GB card in the lab's chassis, 190 W cap (different variant and cap, rough reference only) | 165.1 TMAC/s | 188.8 W |
| 122 SM (card A) | 233.4 TMAC/s (0.94 TMAC/J) | 250 W cap |
| 108 SM (card B) | 217.7 TMAC/s (0.88 TMAC/J) | 250 W cap |
| Both cards, OneZeroMiner, offset 0 | peak 263.25 + 248.12 = 511.37 TH/s; 5-minute average 486.55 TH/s; 17 shares accepted, 0 rejected | 250 W cap each |
Both cards sit at the power cap after the unlock, and the 108-SM card was also thermally throttled until its shroud blower ran at full speed. With an in-memory VBIOS override that unlocks the V/F offset, the 122-SM card gained up to 9.8 % at the same 250 W. Numbers, method and the airflow lesson: Undervolting and power limits#V/F offset on the 10 GB card through an in-memory VBIOS override (lab, 2026-11-17). PCIe Gen3 did not change the hash rate: Pearl is bound by compute and power, not by the link. Proven 10 GB
Source: @darkmaniac7, 2026-11-17 (lab notes)
Known issues
- Warning A card in an ESXi passthrough VM cannot run SW-IFF. See #Resets: which one does what.
- The gate reads 1 after the RIR burn. An FLR does not re-sense it; use a bus reset or a cold boot.
iff_apply.pyaborts with "not L0-open". The PLMs are closed, typically after a bus reset with no driver bound. Bind the driver once and unbind it.- The window reads as random words. Check
0x820040first (see #Is the stock window the same on every 10 GB card?); read it withEN_SW_OVERRIDEat 0. IfFUSECTRLever reads0xBADFxxxx, stop reading and cold boot. - About 80 SMs and FECS or HOST PRI timeouts. The fused-off GPCs were enabled by a driver-time write. Use SW-IFF.
- The card is gone after a reboot from the burn window. Hard reset; settle the card before rebooting next time.
Proven 10 GB
Source: @darkmaniac7, 2026-11-17 (lab notes)
Who found what
- The route itself, gate burn then volatile SW-IFF: Humvee55 (@scallion_9883), who ran 20 cards at 128 SMs and said on 2026-10-16 "just dont flash any actual FF/IFF and you'll be fine. the SW IFF is volatile on reboot". He posted
iff_apply.pyon 2026-10-22; @xeax posted its README the same day. Source: @scallion_9883, 2026-10-16
Source: @scallion_9883, 2026-10-16
Source: @scallion_9883, 2026-10-22
Source: @xeax, 2026-10-22 - The RIR gate record and tool: @lxtend (lxwx). Source: repo github.com/lixiangwuxian/170hx-rir-tool by lixiangwuxian on GitHub, posted by @lxtend, 2026-10-10
- The FF format, register maps and burn method: Kate (@onemillionkates), GA100VFI. Source: repo github.com/kate-land/ga100vfi by kate-land on GitHub, 2026-11-10
- The planner and burntool: sayhellotojungle, cmp170hx-ffcalc. The guarded writer: @68x0. Source: repo github.com/sayhellotojungle/cmp170hx-ffcalc by sayhellotojungle on GitHub
Source: @68x0, 2026-11-16 - The no-glitch FF route on the 10 GB card: @zarknoth (104 SMs) and @ghostinthedatacenter_87281 (NVLink mask). Source: @zarknoth, 2026-11-15
Source: @ghostinthedatacenter_87281, 2026-11-13 - Defect-preserving masks on bare metal, the ESXi passthrough finding, the reset table, the 40 GiB check and the burn order: the lab. Source: @darkmaniac7, 2026-11-17 (lab notes)
See also
Unlock without bricking · 10 GB card · RIR fuse burn · Full SM unlock · Fuses and floorsweep maps · Memory unlock on the 10 GB card · PCIe Gen3 on the 10 GB card · PCIe Gen4 on the 10 GB card · Undervolting and power limits · VBIOS and firmware · Virtual machines and passthrough · Driver and unlock failures · ECC · NVLink · P2P · 170hx-rir-tool · cmp170hx-ffcalc · Gpcprobe · Verifying an unlock · Unlocks · Unlock internals: status and what is next