Jump to content
Toggle menu
Toggle preferences menu
Toggle personal menu
Not logged in
Your IP address will be publicly visible if you make any edits.

SW-IFF unlock on the 10 GB card

From CMP Wiki
Extra SMs on the 10 GB card: SW-IFF, then an FF burn
Reported 10 GB
Drivernvidia-open 615.71.09 (cmpunlocker, 10gb profile)
Unlock build170hx-rir-tool (gate) + iff_apply.py (SW-IFF) + cmp170hx-ffcalc burntool, patched (FF)
StepsSW-IFF unlock on the 10 GB card
Sourcelab notes
ConfirmationsNone 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.py aborted 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_OVERRIDE is 1, a fuse-row read inside the window returns the SRAM overlay slot, and never-written SRAM looks random. A driver built with cmp_fuse_* options sets EN_SW_OVERRIDE=1 before RM and GSP boot ("CMP fuse: EN_SW_OVERRIDE=1 (pre-RM/GSP)" in dmesg), and it stays set after unbind. The lab's dumps were taken with 0x820040 at 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: 0x8200E0 and 0x8200F4 read 0xffffffff. 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 open 0x8200F4 by a direct write: the iff_apply.py README records a card where that went wrong.
  • The stock window: IFF_RECORD reads 0x01fb01e8 and rows 488 to 507 hold the stream above. iff_apply.py checks 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=relaxed on the kernel command line for the BAR0 tools.
  • Your card's defect masks, read with Gpcprobe or cmp170hx-ffcalc (both read-only).
  • SBFE (0x821108) and WDATA_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 mask 0xff) stays disabled.
  • TPC disable (0x820760 + 4*g for 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 stays 0xff).
  • 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)

  1. 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.
  2. Enable memory access on the device and check the preconditions above with reads only: 0x820084 = 0, 0x8200E0 and 0x8200F4 = 0xffffffff, IFF_RECORD = 0x01fb01e8, EN_SW_OVERRIDE = 0.
  3. Arm the records, stock stream first: IFF_STOCK_FIRST=1 python3 iff_apply.py 0000:01:00.0 install 0x820350=0 0x820690=0 .... Require INSTALL=OK. iff_apply.py ... show decodes the armed window.
  4. Reset the card with an FLR: echo flr > /sys/bus/pci/devices/0000:01:00.0/reset_method, then echo 1 > /sys/bus/pci/devices/0000:01:00.0/reset.
  5. Read back before you bind (next section). If the census is wrong, undo and stop.
  6. Bind the driver. Check dmesg for 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 and IFF_RECORD points 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 status 0x80, TPC GPC 0 = 0x02, GPC 3 = 0x80, GPC 7 = 0xff, PES GPC 7 = 7.
  • Memory unchanged: nvidia-smi shows 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

  1. 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.
  2. 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.
  3. 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.
  4. Unbind the card, open the burn window (above) and check it.
  5. 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.
  6. Read back all 512 rows and compare them with the capture plus the plan. CRC must still read 0x55.
  7. Settle the card before any reboot: FLR, bind the driver, check it comes up. Then shut down and remove power.
  8. 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, CRC 0x55, 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 calls int(addr, 0) on integer offsets, so the first status call fails with a TypeError; 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 restored FUSEADDR after 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 only 0x20c2 and 0x2080 cards, 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 (DEBUGCTRL RWL = 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.

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.py aborts 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 0x820040 first (see #Is the stock window the same on every 10 GB card?); read it with EN_SW_OVERRIDE at 0. If FUSECTRL ever reads 0xBADFxxxx, 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.py on 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