BT Interactive TV GameCart (V1.0-573)
The BT GameCart is a rewritable Super NES cartridge used by British Telecom's Interactive TV Games Service. The information below comes from a cartidge that has the rear label V1.0-573. Its 64 KiB loader starts the console, receives game data from the set-top system over a serial connection, programs up to 4 MiB of flash, and hands execution to the selected game. On this cart the flash still contained Super Mario All-Stars + Super Mario World (Europe). You can read more about the history and process on the release article.
Board Identification
The board is marked 32M FLASH, Nintendo of America Inc. ©1995, bare PCB 32795 Rev A, assembly 32794. The front and back photographs together account for all four flash packages. The four 1 MiB windows below are logical addresses. Individual chip-select wiring would be needed to assign each window to a particular package.


| Device | Identification & Measured Role |
|---|---|
| U15 | TI device, sticker PGM U15 V1.0. The loader occupies 65,536 distinct bytes in the boot ROM window. |
| U4, U6, U7, U8 | Sharp LH28F800SUT-series flash, 8 Mbit each. Combined capacity is 4 MiB. |
| U25 | Sony CXK58257AM-10L, a 32 KiB static RAM. The rear board carries a CR2032. The mapper exposes different amounts to different games. |
| U21 | AMD PALCE programmable logic, sticker MODE U21 V1.0. The label obscures the full part number. Its internal configuration has no identified readback path through the cartridge edge. |
| U22, U26 | Zilog Z85233 Enhanced Mono Serial Communications Controller and MAX490 line transceiver. Their presence and the firmware identify the cartridge side of the link. The connector pinout and original host implementation remain unresolved. |
| Data | Bytes | SHA-256 |
|---|---|---|
| V1.0-573 loader, also rebuilt from source | 65,536 | 19dc84a136735d921651bbcddd983572348699fea3d6539250b72d6ad7bc117c |
| Entire flash in upper-half window order | 4,194,304 | dd9b219dbcd8f7d78f46da8cf632ba45825967e371168910d95c661c29ac2dc7 |
European All-Stars + World, flash offsets $000000–27FFFF |
2,621,440 | ea61ce8e5e977624a8135faa8dbd433f3138fc78b79d473f173bb3e38007de2f |
| Full U25 SRAM through the 32 KiB mapping | 32,768 | 93befc6d4b411bb94fd88790f2dd747da3757e0c755e15748c10b8c82b056a4e |
Boot, START and Cartridge Registers
The boot ROM maps as LoROM. The header at file offset $7FC0 has zeroed title, mapper, size and checksum fields. The emulation reset vector points to $00:8000. The loader sets up the display and serial controller, samples the rental state and polls the held START bit on controller 1. The cartridge IRQ at $00:853E can interrupt that wait to receive a download. In a bare-loader observation, START followed the reset vector back into BT code. No download IRQ occurred. With a game mapped, the same jump starts the game. CPU addresses below use bank $00 for loader code. The source also uses its $80 mirror.
The bare-loader trace records 3,507,044 instructions. On each pass the status read returned $70. Bit 6 drew the service message, bit 7 allowed the START prompt, and bit 5 selected full-bank flash. The value matches the last address byte on the bus, a possible explanation for that emulator reading. The foreground checks the busy flag at direct-page $51 before testing held START ($1000). The mash-mods cartridge reader returned $41 or $61 on cold starts.
| CPU Address in Boot Mode | Function |
|---|---|
$70:0001 |
Read rental expiry (bit 7), battery / service indication (bit 6) and flash layout (bit 5). Writes supply the timer control byte. The time per unit is unknown. |
$70:0002 |
Serial control, register selection and status. In RR0, bit 0 indicates receive data and bit 2 permits transmission. |
$70:0003 |
Serial data FIFO. The loader reads requests and writes replies here. |
$70:0004 |
Memory configuration during download setup and again after reading the game's RAM-size header. |
$70:0005 |
Receives a copy of each outgoing control or data byte before the write to the selected port. Its electrical purpose is unresolved. |
$70:6000 |
A write of zero arms the handoff. After handoff this address can read as game SRAM. |
The initialization writes $C0 to WR9, $20 to WR4 and $7E to WR7, consistent with a reset followed by SDLC framing and its flag byte. The code polls RR1 for end of frame and checks the CRC / framing flag. The captures establish the firmware-visible byte stream. The on-wire clock rate and protocol upstream of the set-top box are separate questions.
Request & Reply Format
The dispatcher at $00:8D03 reads a four-byte big-endian length, then one command byte. The length includes those five bytes and the payload. The frame checker consumes two additional trailer bytes and polls RR1 up to 20 times for end of frame. Internally, the dispatcher subtracts five from the low word of the length with SBC and no immediately preceding SEC. Reproducing its edge cases requires tracking the incoming carry.
| Request | Handler | Payload, Reply & Effect |
|---|---|---|
$00 Query |
$9460 |
Compares the compatibility byte with $01. The 12-byte $01 reply includes service/compatibility status and rental validity. |
$10 Begin |
$959A |
Reads a three-byte size, mapping byte, two-byte big-endian expected sum and one rental-control byte. Clears the running sum, complements rental control, and prepares flash. Replies $11 plus status. |
$20 Block |
$981A |
Reads two prefix bytes, a three-byte big-endian destination and the block data. Programs each byte and adds it to the 16-bit sum. Replies $21 plus status. The test host used 1,024 data bytes per block. |
$30 Finish |
$9A22 |
Displays completion, waits 30 frames, then compares the accumulated and advertised sums. Replies $31 plus status. A match proceeds to save configuration and launch. |
$40 Abort |
$9C17 |
Checks the frame and sends a five-byte $41 acknowledgement. Displays abort, expiry and thank-you messages. |
$5A Diagnostic |
$925F |
Runs the on-screen timer and battery tests. The service instructions refer to START and test points TP4 and TP5. |
For example, a successful block reply was 00 00 00 06 21 00. In the bad-checksum test the finish request 00 00 00 05 30 received 00 00 00 06 31 04. The loader had already displayed its completion message when it compared actual $ED1A with expected $ED1B. It then displayed the load-failure screen. In the abort test, 00 00 00 05 40 received 00 00 00 05 41 with no trailing status byte. Neither run reached the handoff write. Other named status values are $01 for flash failure, $02 for version mismatch, $03 for rental expiry, $05 for service and $08 for frame error. Several frame failures use the short $FF error reply.
The high byte of the remaining count at direct-page $3D also serves as command status. Unknown commands fall through. Ordinary receive-ready and transmit-ready polls have no timeout. The 20-poll limit applies specifically to the end-of-frame check. The loader can report a link framing error on an intact game, or reject an incorrect whole-game sum after every individual frame has passed.
On checksum failure, the branch at $00:9ABC goes to $9AC6, sets status $04 and eventually writes $FF to rental control. On abort, the successful trailer check branches from $9C2A to $9C3A, and $9C72 sends the last byte of the acknowledgement. The abort handler displays the expiry message. The last rental-register write in that run was during preparation.
Flash Programming & Physical Address Order
The loader prepares the four flash windows in pairs. It issues $50/$71, polls status, issues $A7/$D0/$71, then checks ready and error bits. During a block it writes $40 to arm a flash address, reads a payload byte from $70:0003, and writes that byte to the same flash address. This flash command shares its numeric value with the serial abort command. The destination on the bus distinguishes them.
| Status Bit 5 | Firmware's Four Flash Bases | Block Addressing | Game SRAM Header |
|---|---|---|---|
| Clear | $00:8000, $20:8000, $40:8000, $60:8000 |
Each 64 KiB of logical data spans two upper 32 KiB bank windows. The connector capture used the $80–FF mirrors. |
$80:FFD8 |
| Set | $C0:0000, $D0:0000, $E0:0000, $F0:0000 |
Add $C0 to the destination bank and use the full 64 KiB address range. |
$C0:FFD8 |
The block handler recognises capacities in 512 KiB steps up to 4 MiB. In the upper-half path, $00:8DE8 arms the address, $8DEB reads the serial byte, $8DEF stores it and $8DFA saves the running sum. The full-bank path performs the corresponding arm, read and store at $8E3F, $8E42 and $8E46. These are useful breakpoints on a single block.
The Mash-Mod observed both $41 and $61 at $70:0001 on different cold starts. In the $61 view, successive 32 KiB blocks within each MiB alternate between its first and second 512 KiB halves. Taking the even-numbered blocks first and then the odd-numbered ones reproduces every byte of the $41 capture. This accounts for different raw hashes from the same four flash chips.
Save RAM and the Handoff to the Game
The two rows below are the values the loader writes to $70:0004 for each recognised game-header RAM code. Other codes leave the prior setting in place.
| Flash Layout | No RAM ($00) | 2 KiB ($01) | 8 KiB ($03) | 32 KiB ($05) |
|---|---|---|---|---|
| Upper-Half Banks | $40 |
$7E |
$72 |
$42 |
| Full Banks | $00 |
$3E |
$32 |
$02 |
Super Mario All-Stars + Super Mario World (Europe) declares 8 KiB. To preserve it, the reader issued two mapper writes, $72 to $70:0004 and then zero to $70:6000. It supplied subsequent bus reads itself, so the SNES game never ran an initialization routine against the physical SRAM. Two passes across eight 8 KiB aliases agreed. Fresh copies of that first capture produced NEW in all four slots of all five games in ares. The saved words at offsets $0002 and $1FFC were $0000 and $FFFF. The game expects $9743 and $5321.
For independent save verification, the collection checks its marker words at CPU $00:8C6E. Each of the 16 All-Stars records starting at SRAM offset $0010 should sum to zero. World checks 141 payload bytes and a 16-bit check word against $5A5A at $30:9E16. Its primary records start at SRAM offset $1000 and the backups sit $023C bytes later. On an emulator copy, initialization changed 4,532 bytes.
Two separate $42 acquisitions exposed four distinct 8 KiB quarters at $70:0000–7FFF. Both passes at banks $70, $71, $F0 and $F1 matched across both acquisitions. A subsequent $72 read matched offsets $6000–7FFF of that full image exactly. It differed in 7,598 bytes from the earlier 8 KiB capture. The cause is unknown, but likely the old Mash-Mods hardware. Full loader and flash hashes agreed before and after the mapper tests.
After clearing WRAM and preparing the CPU, the loader ends with these three instructions. A is zero at the store and carry is set for XCE.
STA.l CartGameSelect
XCE
JMP ($FFFC)
With $42 selected, the fourth connector read after the store returned loader byte $FF at $00:8ED2. On the fifth read the programmer presented the very same address and received the game's $30. Both runs switched before either reset-vector address appeared on the bus. The ares model used for the earlier recordings switched on a read of $00:FFFC. The board measurement narrows the timing considerably, although it cannot distinguish a read counter from an elapsed-time condition or another bus signal.
Reproducing a Transfer
Run a Download in ares
- Check out
ares-integrationbranch feature/bt-gamecart in the Uttori ares fork and build the Super Famicom desktop executable. This revision includes both the GameCart and the debugger used in the VS Code steps below. The standalone BT branch contains the cartridge mapper and the host that sends the game. The host supplies the download locally. - From the top of the GameCart source project, prepare a directory containing a pair of files. The first is the 65,536-byte BT loader. The second is the game to deliver. The fork appends
.btgameto the loader's complete filename, including.sfc. Use your own supported game image in the following commands. Replace the example path with its location.
mkdir -p .uttori-local/wiki-demo
cp .uttori-local/original.sfc .uttori-local/wiki-demo/loader.sfc
cp "/path/to/your/game.sfc" .uttori-local/game.sfc
cp .uttori-local/game.sfc .uttori-local/wiki-demo/loader.sfc.btgame
- In ares choose Super Famicom and open
loader.sfcfrom that directory. From a shell with the fork's executable on PATH, the equivalent isares --system "Super Famicom" .uttori-local/wiki-demo/loader.sfc. Leave the controller idle at the START prompt. After the loader enables interrupts, the local host sends its query, waits for each reply, and transfers the game in blocks of up to 1,024 bytes. Watch for DOWNLOADING IN PROGRESS and DOWNLOAD COMPLETED!, followed by the game's own startup screen. A bare loader in its own directory reproduces the START loop. - To test a failure, close the game, put
bad-checksumorabortin a plain-text file namedloader.sfc.btmodenext to the pair, then reopenloader.sfc. The first flips one bit in the advertised sum while preserving every game byte. The second waits for the first block acknowledgement before sending$40. Move the mode file out of that directory before retrying a successful transfer.
Supply a headerless image between 64 KiB and 4 MiB inclusive. The fork accepts a single recognisable HiROM header for a ROM-only game, or a LoROM header for ROM-only or battery RAM of 2, 8 or 32 KiB. It checks the map byte, cartridge type, RAM-size field and reset vector. Battery saves are keyed to the payload's SHA-256. The published US Mario trace used a reader-supplied 512 KiB LoROM.
Follow the transfer in VS Code Uttori ASM
Open the project root and run Build and Check. For the download profiles, give VS Code the runtime directory in ARES_RUNTIME_DIR (containing ares-runtime-manifest.json) and the matching desktop executable in ARES_EXECUTABLE. Start VS Code with these variables in its environment. Place your game at .uttori-local/game.sfc. With Node.js on PATH, choose BT GameCart: Download and Play in Run and Debug, press F5, and continue if the debugger pauses at entry. The pre-launch task pairs the rebuilt loader and its source map with your game. BT GameCart: Checksum failure and BT GameCart: Abort download exercise both failure paths with the same image.
To follow one block, break at $00:981A. Break at $00:9ABA to inspect the final sum, then at $00:8ED0 to see the reset-vector jump. After that jump the instruction addresses refer to the game's flash mapping. For the USA Mario image used in the recorded transfer, inspect $7E:0100 for title mode $07.
Game Transfers
Testing in the local ares fork with Super Mario World (USA), the standalone retail game, we observed 515 requests and included 512 blocks of 1,024 bytes. All 524,288 payload bytes matched, from $00:8000 to $0F:FFFF in the upper bank halves. The sum was $A0DA, header code $01 selected 2 KiB SRAM via $7E, and the trace reached the Mario title screen.
At the game handoff, the reset vector and first opcode match the loader in both mappings. The distinguishing fetch is at $00:8001, where the downloaded game (Mario) executes 9C 00 42 (STZ $4200) and the loader contains A9 80. The trace ends with Mario's title-mode byte $07 at $7E:0100. The imported loader annotations stop at the handoff so game instructions at overlapping bus addresses do not get assigned to the firmware. The native video was a separate boot.
Loader Contents & the Uncalled Table Reader
| File Offset | Contents |
|---|---|
$0000–1D70 |
Confirmed code, inline text, a DMA fill byte and font advances. The annotated source identifies 2,938 instructions and 32 inline text records. |
$1D71–1DFF |
Disconnected code fragments and a 35-word table. |
$1E00–3FFF |
A 256-colour BGR555 palette, two BG1 tilemap pages and two text-map pages. |
$4000–5FFF |
512 two-bitplane font tiles. The renderer uses proportional glyph advances to draw messages on a separate layer. |
$6000–7FFF |
Zero-filled space followed by the header and vectors at $7FC0. |
$8000–FFFF |
512 eight-bitplane tiles for the title background. |
The 32 inline message calls contain 28 distinct records. Each JSR is followed by three display parameters, the text, and a NUL. The renderer moves the stacked return address past the record and uploads the text canvas over four refreshes. The first BG1 map page supplies the normal background. Both BG2 map pages initially contain tile $00FE. The alternate Mode 3 setup reuses the map region as tiles. The three populated vectors are native NMI $8523, native IRQ $853E and emulation reset $8000. The normal loop leaves NMI disabled and calls $8523 as an ordinary subroutine ending in RTS. No SPC upload, music or sample data was found.
One fragment, ResidualTableReader at $00:9DEC, appears to be leftover with no clear use and no callers. With bit 0 clear at direct-page offset $FD, it reads a table word indexed by the cursor at $E3, stores the value at $E5 in native 16-bit accumulator mode, and advances the cursor by two. The aligned entries rise in steps of $20 and end with three copies of $EC00. That could describe positions in a 32-unit-wide buffer. No observed instruction consumes from those positions. With the gate bit set, the branch instead lands inside the title palette. No direct caller was found and there were zero fetches in the region across five captured paths. The verified 64 KiB rebuild preserves the fragment exactly.
In single-step probes, cursor $0001 read the unaligned value $20E8, and $0046 advanced into the reader's own first two opcode bytes. The fragment does not enforce alignment or an end marker. The incoming index width matters, and emulation mode stores only the low result byte. The five traces covered 34,252,100 loader instructions. Static analysis checked all 2,938 confirmed boundaries for direct references into $9D71–9DFF. Neither method found an entry from the working loader.
Anything attempting to run this that requires an internal header will not do well, as there is no internal header.
The loader can be rebuilt from source/main.asm with the accompanying Uttori ASM configuration. In a bound project, Build and Check in VS Code Uttori ASM or by command line uttori-asm source build . reproduces the 65,536-byte loader digest above.