Draft. Draft — assembled from the working notes by `tools/build_book.py`. The source document is the authority; this page is a copy for reading, and it is regenerated from that source.

Status: Partially solved. The ROM half is settled and measured — 7695 bytes for an interposer + ACB-4000 boot with no floppy read, ever (§2.3); the 53-entry jump table at 0100h and the ROMVEC+3N contract that pins its numbering (§3); the payload split and the boot path, built and booted in osborne1nx (§4.3, §4.6); the 150-byte monitor budget (§4.7); and the feature set decided against OZROM’s — what to take and what to refuse (§4.8). The hardware half is open: there is no ROM 2.00 part (§4.1), and the window’s address, paging and selector are #12’s interface spec (§4.1a). §8 lists what is left, item by item.

The answer. ROM 2.0 is an O1 ROM that boots the machine to a usable prompt without reading a floppy — real or virtual. It replaces the monitor’s boot path, not its interface: the stock ROM’s 53-vector jump table at 0100h and the CBIOS’s ROMVEC+3N arithmetic stay exactly as Osborne shipped them (§3), and the boot keys the build needs are re-lettered in place for two bytes (§4.6). The boot itself is the ACB-4000 hard-disk path: RETURN runs the vendor’s own loader block out of the ROM window, and the MD-10 BIOS reads CP/M off the drive, so the machine reaches A0> with no floppy in it — measured in the emulated machine (§4.6, §7). What it costs is 7695 bytes, the one number for this boot (§2.3), served from the interposer’s softROM rather than from a part in the ROM socket (§4.1).

What is left is the hardware half and every check that needs a real machine: the window’s address, paging and selector belong to #12 (§4.1a), and each acceptance below is a MAME run — nothing here has been run on a physical O1 (§8).

Issues: #83 (deliverable 1; deliverable 2’s toolchain proof landed as #203/#204), #49 (the reproduction this ROM is for), #72 (the ROM source), #179 (the MD-10 boot that wants the same ROM window), #12 (the window’s address, paging and selector), #247 (the window, the door and the boot screen as built), #278 (the ROM-side frame path, retired), #24 (the column mode), #81 (OZROM, the pattern), #22 and #19 (the peripherals the feature set refuses to give up), #29 (the memory test as a second oracle).

1. What ROM 2.0 is, and what it is not

The goal from #83 is an O1 ROM that boots to a working A> with no disk access at all. What this project builds is the half of that goal that survived: a boot with no floppy read, ever — real or virtual — which the ACB-4000 hard-disk path reaches (§2.3). CP/M resident in the ROM with no disk of any kind is the larger goal, and it was dropped as a product decision (§4.4). ROM 2.0 is a replacement part, not a patch: optional, socket-reversible, legitimate on the replica and (with the interposer’s ROM daughterboard, below) on a real O1.

One ROM, two hosts. The interposer carries a lead-set to the main ROM socket (UD11) as well as the character-generator socket (UA15), so the ROM window is the interposer’s to fill on any OEM-faithful mainboard, and the SFF board grafts the same capability in. There is one ROM 2.00 — one image, one layout — and it runs on either.

That is also why there is one host brief: the interposer’s ROM window does not care which OEM-faithful mainboard it is plugged into — an existing OEM board, or any faithful 1:1 recreation of one with the Dual Density upgrade built in. (Such a recreation is possible if a chassis ever needs restoring; it is not in the set, and it has no directory — see Hardware that is not a board in hardware/README.md.) So “the stock machine” in this document means the mainboard-plus-interposer combination, and there is no second path to design for.

OZROM 1E is the pattern, not the feature set. #83’s direction, and the measured shortcomings in docs/ozrom-1e.md:

Borrow — structural Why Explicitly not wanted
A documented ROM jump table and memory map OZROM’s manual is why third-party code can target it; the stock ROM already has a table (§3), it is just undocumented OZROM’s keyboard redefinition, which takes FC00–FFFF of video space. #24’s VRAM shadow assumes F000–FFFF and OZROM’s move constrains every later decision
A software 52/80/104-column switch The mechanism already exists in the stock CBIOS (§4.7, SCRMOD) and it is on #24’s design path —
A chip-level memory tester The O1 has no built-in RAM test; it is cheap and it is what a new ROM is for —

2. The arithmetic, measured

The four pieces, all read from primary sources or the shipped bytes:

Piece Size Where it lives How we know
Monitor ROM 4096 0000–0FFF, bank 2 The part: 2732 at UD11. Its own source asserts its code ends below 0FFBh
CCP 2048 CB00–D2FF occbio15.asm pins CCP = 0CB00h, BDOS = ccp+806h → the CCP is 0x800
BDOS 3584 D300–E0FF BIOS = ccp+1600h and the CCP/BDOS boundary at ccp+806h → 1600h − 800h = 0E00h
CBIOS 2048 E100–E8FF BIOS = ccp+1600h, MSIZE = 59 → the BIOS region is E100–EBFF; its own guard stops code at CCP+1E00h = E900h
Total resident 11776   11.5 KB

This is the no-disk-anywhere list — CP/M resident with no disk of any kind, real or virtual. It is not the list for the boot this project is building, which is shorter because the ACB-4000 supplies the CCP and BDOS: see §2.3 for that list and its single total.

The ROM’s own boot code states the total, and it agrees. rom144.asm’s CBOOT and WBOOT load the system in 128-byte blocks, and the counts are the arithmetic:

Routine Constant Bytes Equals
CBOOT (cold boot) LDK B,60 ;CCP/BDOS/CBIOS 7680 2048 + 3584 + 2048
WBOOT (warm boot) LDK B,44 ;CCP/BDOS and don't read CBIOS 5632 2048 + 3584

That is the strongest evidence available for the 11776-byte figure: the shipped firmware says it reads 7680 bytes of “CCP/BDOS/CBIOS”, and 4096 + 7680 = 11776.

2.1 The numbers are measured on a shipped disk too

research/shipped-software/OS1SYSD.IMD (DD, 1024-byte sectors, 5/track, 3 reserved tracks) carries the system image from the CCP upward, and every piece lands exactly where the source’s equates say:

Image offset Address Content Size
0000 CB00 CCP 2048
0800 D300 BDOS — entry at D306 holds JP 0D311h 3584
1600 E100 CBIOS — its 34-entry jump table, byte for byte 2048
1E00 E900 CCP+1E00h: the CBIOS’s own RAM area begins here —
2000 EA00 end of what SYSGEN wrote (8 sectors, rounded up) —

Four independent anchors, none of them assumed:

  1. The CBIOS’s jump table is at image offset 1600, and occbio15.asm puts it at BIOS = CCP+1600h. Its 13 CALL ROMCDE entries are 13 consecutive CD 12 E3 at E139h–E15Ah — one routine, called thirteen times, exactly as the source’s table is written.
  2. That routine’s address is confirmed by module order. occbio35.asm places ROMRI, then ROMCDE, ROMCD1 and ROMJMP; the image has ROMRI at E2FEh (20 bytes of POP/EI/RET), ROMCDE at E312h, ROMCD1 at E317h (16 01 = LD D,01h = high(ROMVEC)) and ROMJMP at E319h.
  3. The ROM locates the CCP itself, at every boot, from the same bytes. CBOOT reads sector one to 0D000h and checks three bytes of it: [0D000h] == 0C3h, [0D001h] == 05Ch, and then [0D002h] − 3 is the CCP’s page. On the disk those bytes are C3 5C CE — and 0CEh − 3 = 0CBh, so the CCP is at CB00h. The first three bytes of the CCP are therefore a marker as well as code (JP 0CE5Ch), which is why 0x5C is checked.
  4. The ROMCDE arithmetic requires it. It forces the high byte of the vector to high(ROMVEC) = 01h and leaves the low byte as the CBIOS’s own address low byte, so BIOS & 0FFh must be 00h — E100h does, E000h would not.

A caution, because it nearly fooled this pass. The 512 bytes at image offset 1E00–1FFF are not CBIOS code. They are the contents of RAM at E900h when the disk was made — DDT’s leftovers, written out because SYSGEN writes whole sectors. On this disk they happen to be a readable Osborne sales text (“… Accessories planned for the Osborne 1: 12” display monitor … battery pack for portable operation …”). Anyone who reads the system image as “the CBIOS” will count 2560 bytes and be wrong by 512. The 2048 figure is the source’s own guard: IF XXX > CCP + 1E00H / .9 ERROR SYSTEM SIZE TOO LARGE.

2.2 Why 4 KB cannot hold it, and why the ROM page is not one block

Bank 2 is the only place the CPU reads ROM (docs/o1-memory-io-map.md §2):

Range Bank 2
0000–0FFF Monitor ROM (2732 at UD11)
1000–1FFF Unused — mirror of the ROM, because A12 is not decoded
2000–2FFF Memory-mapped I/O
3000–3FFF Unused — mirror of 2000–2FFF
4000–FFFF Mirrors bank 1 RAM

So the ROM page offers 8 KB contiguous (0000–1FFF) and 4 KB more at 3000–3FFF — but only by jumping past the assigned I/O block at 2000–2FFF, so the two runs are not one block.

The boot this project is building fits the contiguous 8 KB. Interposer + ACB-4000, to A>, with no floppy ever read, is 7695 bytes (§2.3) — 497 bytes to spare, and no paging. The 11776-byte figure in §2 is a different list for a different goal (CP/M resident with no disk of any kind): it is the one that fits neither run, it is the one that needed §4.1a’s paging, and the goal itself was dropped (§4.4). There is no 16 KB ROM in any case, and never will be (§4.1). The stock 2732 holds 4096 of which 150 bytes are free (0F6Ah–0FFFh; the code ends at 0F69h and the source’s own guard is IF RLWA > 0FFBH).

2.3 The contents, and the one number

This is the goal the project is actually building: an interposer + ACB-4000 that boots to A> on the hard disk with no floppy read, ever — virtual or physical. It has one content list and one total.

Piece Bytes Why it is there Source
Monitor ROM 4096 the machine’s ROM. Its boot path is replaced; its 53-vector jump table is kept rom144.asm
CBIOS 2048 the MD-10 BIOS borrows 30 of its 34 jump-table entries. Measured: HARD.COM copies 18 + 21 + 3 + 3 + 45 = 90 bytes from (page zero+1)+3 = 0xE106 — CBIOS vectors 2–31 — into the MD-10 BIOS’s slots at 0xD806, 0xD86A, 0xD82D, 0xD87F and 0xD833. Those are JMPs into the CBIOS, so the CBIOS’s code has to be in RAM for them to land anywhere OS1SYSD.IMD, image offset 0x1600
MD-10 BIOS image 1477 the ACB-4000 driver, and the partial BIOS that reads the system off the hard disk. Copied to 0xD800 HARD.COM, file offset 0x053A (0x5C5 bytes)
install / patch / jump 60 the vendor’s own loader block — the shim, in §4.6’s language — kept in the window as the reference HCBOOT was lifted from: LD HL,053Ah / LD DE,0D800h / LD BC,(0547h) / LDIR, the five patching LDIRs, XOR A / LD (0013h),A, JP 0D800h. Nothing calls it — the machine forces HCBOOT to do that work in the monitor instead (§4.6) — so the window’s copy is the anchor the image is checked against, not code HARD.COM, 0x01E5–0x0220
the hand-over stub 14 the one piece only RAM can run: LD HL,0CB00h / LD (0EFD2h),HL / LD A,80h / LD (0003h),A / JP 0D800h. HCBOOT copies it to 0E0F0h, and the bank switch enters it (§4.6) tools/research/rom2image.py
Total 7695    

7695 bytes — and it fits the 8 KB contiguous window with 497 bytes to spare. No paging is needed for this boot at all.

What is deliberately not in the list. The CCP and BDOS, 5632 bytes, because the ACB-4000 supplies them: HARD.COM’s BIOS reads 11 blocks from LBA 5 into 0xC200 and jumps to it (docs/md10-system.md §3–§5). Carrying them in ROM as well would be a second copy of bytes already on the drive, and would make the ROM decide which one wins.

Nor are the loader’s other 1022 bytes. HARD.COM is 2560 bytes — a 1082-byte loader and a 1478-byte embedded BIOS, of which 1477 are copied. The loader’s banner, its presence probe and its TEST UNIT READY are diagnostics for a human installing a card; the MD-10 BIOS’s own BOOT selects the card and reads. The shim does not need them.

One number, and it is this one. 11.2 KB and 11776 bytes are two different lists, and neither is the boot described here: 11.2 KB is monitor + MD-10 + CCP/BDOS with no CBIOS; 11776 is monitor + CCP + BDOS + CBIOS with no MD-10. The boot described here is 7695, and any figure quoted for it has to name the list it came from. The boot screen does not come out of the 497-byte spare, and does not need to. research/boot-screen/ holds the authored art and tools/research/rom2strokes.py measures it: every raster-shaped encoding of the logo lands at 784–857 B — raw striped bitmap 857, RLE 816, an exact rectangle cover 784 — because the letters are heavy and the cover is dominated by diagonals (the X is 72 rectangles where it is structurally two strokes). The geometric route was not converged, so it is estimated rather than demonstrated.

What settles it is the architecture: one window page is 4096 bytes and the video buffer is 128 × 32 = 4096 cells, so one page is exactly one screen. In bank 2 the window and the video RAM are both visible (§4.4), so a frame is one LDIR from 1000h to F000h — about 40 bytes of ROM, with the frames in the interposer’s flash, and the animation is the viewport slide, which is a register write. The one casualty is that the art is 153 columns and a screen is 128, so the 26 columns of hatch to the left of the O are dropped in favour of keeping the logo whole.

3. The interface that already exists

ROM 2.0 does not have to invent its jump table. The stock ROM already publishes one, at 0x0100, and the CBIOS already calls it — Osborne simply never documented it outside the source.

Measured: 53 entries, 0100h–019Eh, 3 bytes each. The table ends exactly where the source’s IMSG: sign-on message begins (019Fh), which is what makes 53 the whole table rather than a guess — the first byte of IMSG is 'Z'-40h = 1Ah and 019Fh holds 1Ah. tools/research/romvec.py prints the table, labels each entry from rom144.asm’s own table text, and cross-checks the binary’s opcode sequence against the source’s — 0 disagreements on the 1.44 ROM.

# Addr Target ROM source CBIOS vector Note
0 0100 0255 CBOOT CBOOT cold boot — this is the one ROM 2.0 replaces
1 0103 02AB WBOOT WBOOT warm boot — hard-coded by occbio55.asm
2 0106 0375 SKEY CONST keyboard status
3 0109 0382 CI CONIN keyboard input
4 010C 03EF COUT CONOUT console output
5,6 010F,0112 0BEC LIST LIST, PUNCH both point at one routine
7 0115 0BD2 READER READER reader input
8 0118 0C15 RDRV HOME home the drive
9 011B — RET/NOP/NOP SELDSK stub — the CBIOS supplies SELDSK itself
10–12 011E–0124 0D49,0D50,0DBE READ, WRITE, RADR SETTRK, SETSEC, SETDMA labels do not line up — see §3.2
13 0127 0C2F RSEC READ one sector read — hard-coded by occbio65.asm
14,15 012A,012D 0C36,0BE3 WSEC, SLST WRITE, LISTST one sector write; list status
16 0130 0C7C SENDEN SECTRN labels do not line up — see §3.2
17,18 0133,0136 0099,009E ROMJP1, ROMJP2 RRI, ROMJMP RAM/ROM exit; the ROM call gate
19 0139 0F29 FORMAT FMTJ format a track
20 013C 0BC5 SIRST SBAUD / ACICTL SIO reset = set the baud/control register
21–28 013F–0154 0949…0AAC IE.CO … IE.PP IEB1C … IEB8C the eight IEEE-488 drivers
29–31 0157–015D 06DD,06F1,06D5 VLDDR, VLDIR, STODIM (extensions) SuperCalc video helpers
32–52 0160–019C 0F0A…0BB0 21 entries — disk primitives, SELDRV, and the IEEE status/input/output quartet

3.1 How the CBIOS reaches it — and why the numbering is a contract

Two mechanisms, both in the source, both already load-bearing:

  1. By arithmetic, from the CBIOS’s own address. occbio35.asm’s ROMCDE pops the return address, subtracts 3, and forces the high byte to high(ROMVEC) = 01h. So CBIOS vector N, sitting at BIOS + 3N, selects ROM vector N. occbio15.asm states the requirement in a comment: “NOTE: ROM jump vector must match CBIOS vector”. This is why BIOS & 0FFh must stay 00h, and why the CBIOS’s 13 CALL ROMCDE entries all land on the right routines without a table pointer.
  2. By absolute address, twice. occbio55.asm’s warm boot does LDK DE,ROMVEC+3*1, and occbio65.asm’s sector transfer does LDK HL,ROMVEC+3*13. The CBIOS also calls the ROM’s SENDEN by its absolute ROM address (LDK DE,SENDEN), which is why the monitor must stay mapped while the CBIOS is running — see §4.2.

The consequence for ROM 2.0: vectors 0–52 keep their numbers and their semantics, and the monitor stays where it is. Both of the hard-coded vectors are exactly the two the diskless build wants to change (§4.5), and both are changed inside the ROM, so the CBIOS does not have to move.

3.2 Two things that do not line up, recorded rather than smoothed over

  • Indices 10, 11, 12 and 16 carry the ROM’s own labels (READ, WRITE, RADR, SENDEN) where the CBIOS’s table has SETTRK, SETSEC, SETDMA, SECTRN. Nothing is broken: the CBIOS implements those four itself and never calls the ROM for them, so the ROM’s slots are free to be its own API.
  • occtxt6.ast publishes constants for the alignment that does not exist — BSTTRK = 10*3, BSTSEC = 11*3, BSTDMA = 12*3, BSECTR = 16*3, alongside the ones that are correct (BCONST = 2*3, BREAD = 13*3, BIECO = 21*3 … BIEPP = 28*3). No CBIOS source uses any B* constant, or BIOCAL, the macro that would. They are dead code, and four of them have the wrong numbers. Recorded here because the obvious reading of that file is that they are the mapping.

3.3 What this gives the design

  • A documented interface already exists — 53 entry points with a stable numbering — so ROM 2.0 extends it rather than inventing one, which is exactly the OZROM property worth borrowing (#81).
  • The warm-boot hook already exists: the CBIOS’s WBOOT calls ROM vector 1. A ROM-resident CP/M needs a different source for the system image, not a different mechanism.
  • The boot keys already exist, and ROM 2.0 re-letters them (#247 step 4): RETURN = the hard disk, : = floppy A, " = floppy B, and ESC is released. 1.44 had RETURN = floppy A, " = floppy B, ESC = hard disk — so the machine’s own disk sat on a shifted key while a facerolled RETURN booted a floppy nobody asked for. HCBOOT is a documented empty stub (JMP START) that Osborne left in the ROM for exactly this purpose (rom144.asm line 4634; it assembles to JP 0000h at 0F67h), and the re-lettering is two bytes of the dispatch, in place — §4.6.

4. The design

4.1 The softROM serves the window — there is no ROM 2.00 part

There is no physical ROM 2.00 and there never will be — not a 27128, not a 2764, not a 16 KB part in any form. The ROM window is served by the interposer’s softROM: the interposer already has the bus, and the ROM socket bridge gives it the window itself, so it presents the ROM in firmware.

   
The host OEM board + interposer, or the next-integrated board, where the interposer is built in as one unit. There is no third case and no part in the socket
A mainboard on its own Keeps a socket that takes a standard 1.44 ROM, so a stock machine boots stock. That is the stock part — not ROM 2.00
Window the monitor at 0000–0FFF; the payload at 1000–1FFF — two contiguous 4 KB pages, measured (§4.1b)
Banks page 1 is the payload, and PRESENT(0) is what serves it (docs/rom-pico-protocol.md §4). The 4 × 4 KB split — system image 2, MD-10 BIOS 1, diagnostics + spare 1 — was the dropped no-disk goal’s plan (§4.4)

What this document does not decide. The window’s address, how the payload is paged, and what the selector is are pseudo-hardware, and they are #12’s interface spec — not this document’s call. The route here needs none of the three: the Pico already sees every bus cycle and presents the window itself, so no part is fitted and no A12/A13 latch is needed (§4.1a). 2300h was proposed as that latch’s address, and it is not free (§8 item 3).

4.1a The socket’s limit, and why it does not bind

The limit is real, and worth stating because it is what would bind if we were fitting a part: a 24-pin 2732 socket has A0–A11, /CE, /OE and the data bus — no A12, no A13, and no write strobe. A part in that socket could never exceed 4 KB however large it was.

It does not bind, because we are not fitting a part. The softROM is not in the socket’s address space the way a part is: the Pico already sees every bus cycle and presents the ROM window itself, so the lines past A11 are irrelevant — which is also why ROM 2.00 needs no programmer and is updatable in flash. With the part removed nothing else drives those data lines either, so the per-cycle bus race #83 raised does not arise.

The socket bridge is not speculative as a technique. docs/o1-rom-variants.md records BrettHallen’s 2732→2764 daughterboard image (8 KiB, CRC32 edc31846): OCC 1.44 and OZROM 1E in one 2764, with A12 selecting between them — banking in the ROM socket, built and tested, passively. That is prior art for the mechanical form, and it is why the bridge is a known-good shape. It is not the route ROM 2.00 takes.

Why the larger-part route is not the design. A 24-pin 2732 socket has no way to reach a bigger part, and three things follow: there is no board with no interposer — the next-integrated board has one built in, and an OEM board takes one; with no part in the socket there is nothing for A12/A13 to address; and 2300h was proposed as a latch address, so with no latch it would be a candidate register address — and it is not free (§8 item 3).

What is open, and where it lands. The window’s address, the payload’s paging and the selector are #12’s interface spec (§4.1) — not decisions this document makes. What is settled here is the constraint from §2.2: the ROM page gives 8 KB contiguous plus 4 KB beyond the assigned I/O block, 11776 bytes must be presented for the no-disk goal, and there is no larger part to put them in.

4.1b The window this boot uses, measured in the machine (#247)

§4.1 leaves the window’s address, paging and selector to #12, and this does not close that. But the boot this project is actually building (§2.3, 7695 bytes) needs none of it — and that is measured in the emulated machine rather than argued.

The window is 0000–1FFF, and it is already 8 KB wide. The mainboard never decoded A12 (§2.2), so the stock machine reads the same 4 KB monitor twice across that range. MAME says so in one line:

m_rom_view[0](0x0000, 0x0fff).mirror(0x1000).rom().region("maincpu", 0).unmapw();

mirror(0x1000) is the undecoded A12. So a softROM that decodes it gets two 4 KB pages contiguous, in the ROM page, with no new address space, no latch and no register — which is exactly the “8 KB contiguous” of §2.2, and why the 7695-byte image fits with 497 bytes spare.

   
Page 0 (A12 = 0) the monitor, 0000–0FFF — the 4 KB that must never move (§4.2)
Page 1 (A12 = 1) the payload, 1000–1FFF — 3599 bytes of the 4096 (§4.3)
Given a 4 KB image A12 is ignored and the page mirrors: the stock part, unchanged

What that makes step 1 of #247. The machine already has the idiom for replacing a view entry: osborne1sp calls osborne1_mem(map) and then re-registers the entry it wants to own — and the same shape replaces the ROM window:

m_rom_view[0](0x0000, 0x1fff).r(m_softrom, FUNC(softrom_device::read)).unmapw();

So for this boot there is no window decision to wait on — only the file the device serves, and whether an image is 4 KB (mirror, stock) or more (two pages). A latch at 2300h would be for a part; the softROM needs none, and this is where the window stops being an argument and becomes an address map.

And it is built and measured. softrom_device is src/devices/machine/softrom.{h,cpp} in the patched tree (tools/emulator-setup/mame-osborne1nx/), osborne1nx_mem() is the one line above, and the image is named on the machine’s own command line after the device’s tag — -softrom rom2.rom. What the window serves:

Image The window
none the machine’s own ROM region, mirrored — a stock machine
4 KB or less the image, mirrored: the image is the stock part
larger two pages, 0000-0FFF and 1000-1FFF; past the image’s end, 0xFF (erased flash)

tools/emulator-setup/mame-osborne1nx/softrom-check.sh is the acceptance, and it is all of it:

  • the window is the device’s — o1next-softrom.lua reads all 8192 bytes back and compares them against the table above. This half is not optional: the stock monitor never reads page 1, so an override that reached only 0000-0FFF would boot identically and silently.
  • the boot is identical — osborne1nx with no image mounted, and with rom2image.py’s 7695-byte image mounted, both produce a screen dump byte-identical to osborne1’s, A> included (the machine name is the only difference).

Measured 2026-10-14, and again on 2026-10-15 with the hand-over in the image: all five checks pass. The 7695-byte image reads 31 C1 EF D3 at 0000h (the monitor) and C3 ED E4 C3 at 1000h (the CBIOS, which is JPs), with the hand-over stub’s 21 00 CB 22 D2 EF 3E 80 32 03 00 C3 00 D8 at 1E01h and FF from 1E0Fh to 1FFFh — the payload’s 497-byte spare. The MD-10 hard-disk boot to A0>/B0>/C0> is unchanged.

4.2 The invariant that keeps the CBIOS working

The monitor is never banked. Only the window moves, and for this boot it is 0000–1FFF (§4.1b). This is not a convenience — it is required, because the CBIOS calls ROM routines by absolute address (LDK DE,SENDEN in occbio45.asm, LDK DE,ROMVEC+3*13 in occbio65.asm) while bank 2 is mapped, and the CBIOS’s own ROMCDE arithmetic (ROMVEC+3N) depends on the monitor being where it always was. Bank the monitor and the CBIOS breaks in ways that look like data corruption.

The other invariant follows from it: 0000–0FFF must stay a 4 KB monitor, so ROM 2.0’s new monitor code has to fit in the 150 free bytes of the 1.44 layout. That budget is in §4.7, and it is the real design constraint of this whole document.

4.3 The content, and what it costs

The payload is what goes in the window; the monitor is not part of it. For the boot this project is building (§2.3) the payload is 3599 bytes:

Holds Size Why
CBIOS 2048 the running BIOS whose vectors 2–31 the MD-10 BIOS patches in (§4.6). Resident in RAM at 0xE100
MD-10 BIOS image 1477 copied to 0xD800 — the ACB-4000 driver, and the partial BIOS that reads the system off the drive
install / patch / jump 60 the shim — the vendor’s loader block at HARD.COM 0x01E5–0x0220 (§4.6). The machine forces HCBOOT to do that work in the monitor, so nothing calls this copy; it is carried as the reference
the hand-over stub 14 the store only RAM can make: CCPADR, the IOBYTE, and the MD-10 BIOS’s entry. HCBOOT copies it to 0xE0F0 and the bank switch enters it (§4.6)
spare 497 8192 (the contiguous window) − 4096 (monitor) − 3599
payload total 3599 7695 with the monitor (§2.3)

The no-disk goal’s payload was a different, larger one — the system image, 7680 bytes (CCP + BDOS + CBIOS) — and that is the one that does not fit the contiguous window (§2.2). It is not in the build, because the goal is dropped (§4.4); it is recorded here because it is the one that needed a paging answer.

Where any of it is presented is measured — the payload is window page 1 (§4.1b) — and what the rows above are is content slots, not addresses.

4.4 Cold boot — the dropped no-disk path

The no-disk goal is not a goal any more, and the decision is a product one rather than a technical one. What the project wanted was “it turns on and is sitting at a useful prompt” — no floppy in the drive to kick off the boot-transfer — and that is reached without this section: the firmware serves drive letters (the interposer’s own storage personalities), so there is always a disk, and the MD-10’s HCBOOT path (§4.6) boots the hard disk with no floppy in the machine at all.

Three consequences. The 11776-byte payload and its paging are out of the plan; SYSLD and §4.5’s vector-1 retarget have nothing left to do; and the largest open item in §8 item 1 is #12’s general window rather than this boot. The boot this project is actually building is HCBOOT, the ACB-4000 path (§4.6), and that is the one §2.3 sizes. What follows is the cold boot for the dropped goal, kept as the record of why it went.

The copy semantics below are the dropped goal’s design; “latch bank N” was a placeholder for a selector that is now window page 1 (§4.1b). The destinations, the LDIR lengths and the final jump do not depend on how the window is paged.

The copy is cheap because of a property of bank 2 that is easy to miss: in bank 2, 4000–FFFF mirrors bank 1 RAM. So while the monitor is running from the ROM window it can write the RAM at CB00h+ directly — source and destination are both visible at once, and no RAM/ROM mode switching is needed mid-copy.

  1. START prints the prompt (unchanged).
  2. RETURN/" → the ROM’s CBOOT path is replaced by SYSLD: latch bank 0, LDIR 4096 bytes from 1000h to CB00h; latch bank 1, LDIR 3584 bytes from 1000h to DB00h. Roughly 30 bytes of code.
  3. JP 0E100h — the CBIOS’s CBOOT, still in bank 2. No bank switch here, and that is deliberate: in bank 2 0E100h is already bank 1 RAM, so the jump lands on the freshly-copied CBIOS, and the CBIOS calls SW2RAM itself (its first CALLs) exactly as it does today. Switching to RAM before the jump would be a bug — it would unmap the monitor out from under the very instruction that follows.
  4. The CBIOS’s CBOOT does what it always did: MAGIC (screen size, via SW2ROM/02400h), the IOBYTE, the baud rate, CDISK = A, page zero (0000: JP WBOOT, 0005: JP BDOS), then JMP [CCP+3] with C = drive.
  5. The CCP prompts A> — and nothing has touched the FDC.

Note what does not change: HCBOOT becomes SYSLD with a different bank selection, RETURN still boots the machine’s own system — the one key that keeps its meaning across the two goals, §4.6 — and the CBIOS is byte-for-byte the vendor’s. The copy destinations also land exactly where the source’s own RAM equates put them: 0CB00h + 7680 = 0E900h, which is CCP+1E00h, the first byte of the CBIOS’s RAM area.

4.5 Warm boot

Warm boot needs no change, because ROM vector 1 keeps its meaning. The CBIOS’s WBOOT calls ROM vector 1 (LDK DE,ROMVEC+3*1), and with the firmware serving drive letters there is always a system on A:, so it reads CCP+BDOS from the disk exactly as the stock ROM does. The CBIOS does not change at all, and the mechanism is the one CP/M already uses on this machine.

The ROM-resident alternative — vector 1 pointing at SYSLD, or at a SYSLD variant that copies only the CCP+BDOS, 5632 bytes, matching the stock WBOOT’s B,44 — belongs to the dropped no-disk goal (§4.4). It is where #83’s “warm boot has no system tracks” question was answered: the ROM’s own jump table was always the hook.

One runtime consequence: the CBIOS’s disk vectors are still there and still real. HOME is harmless (it only flushes a buffer and clears flags), but a program that selects a drive will reach SELDSK → SENDEN → the ROM’s FDC spin loop and retry. The clean fix is a null-DPH gate (§5, question 4) rather than deleting the drivers.

4.6 HCBOOT, filled in

HCBOOT is JP 0000h at 0F67h — three bytes, and the ROM’s own end-of-code guard sits right behind it. It becomes, essentially byte for byte, what HARD.COM’s loader does once its diagnostics are dropped — 60 bytes, measured at HARD.COM 0x01E5–0x0220:

HCBOOT:  the MD-10 payload is window page 1, always    ; §4.1b
         LD   HL,053Ah                     ; the embedded BIOS in the ROM image
         LD   DE,0D800h                    ; where the MD-10 BIOS lives
         LD   BC,(0547h)                   ; 0x5C5 = 1477 bytes, read from the image
         LDIR
         LD   HL,(0001h)                   ; page zero+1 = the running BIOS's WBOOT
         INC  HL / INC HL / INC HL         ; +3 -> vector 2
         LD   DE,0D806h / LD C,12h / LDIR  ; 18 bytes -> 0xD806
         LD   DE,0D86Ah / LD C,15h / LDIR  ; 21 bytes -> 0xD86A
         LD   DE,0D82Dh / LD C,03h / LDIR  ;  3 bytes -> 0xD82D
         LD   DE,0D87Fh / LD C,03h / LDIR  ;  3 bytes -> 0xD87F
         LD   DE,0D833h / LD C,2Dh / LDIR  ; 45 bytes -> 0xD833
         XOR  A
         LD   (0013h),A                    ; page zero, drive A
         JP   0D800h                       ; the MD-10 BIOS's own jump table

Two things in that are load-bearing, and both are read out of the file rather than inferred:

  • The patch source is (page zero+1)+3 — the running BIOS’s jump table, not the ROM’s. LD HL,(0001h) reads the WBOOT vector, so on a stock boot the source is the CBIOS at 0xE100, and the 90 bytes copied are its vectors 2–31. That is why the CBIOS has to be resident (§2.3), and why it cannot be deleted from the build as “not needed on a hard-disk machine”.
  • The jump is to 0D800h, the BIOS’s jump table, not to 0D882h’s BOOT directly — entry 0 is a JP that gets there.

The copy, the patch and the jump are measured; presenting the payload needs no selector write at all, because it is window page 1 (§4.1b).

Built, and measured in the machine. ROM 2.0’s monitor is rom144.asm plus one diff — research/source-code/BIOS-200-source/rom2.diff — assembled by the vendor’s own ACT80 (tools/research/rom2asm.sh, the pipeline #203 proved). The result is checked against the invariant the design rests on: the stock 1.44 below 0F67h is byte-identical (3,943 bytes), and HCBOOT itself is 77 bytes, 0F67–0FB3 — 67 bytes of copy, patch and jump, plus the 10-byte LDIR that puts the hand-over stub in RAM. With the boot screen’s own 26 bytes behind it the whole new tail is 0F67h–0FCDh, 103 bytes of 149, 46 free to the vendor’s guard (§4.7).

Three things the machine forced, and none of them is visible in the source:

  • Page zero is the ROM in bank 2, so the shim’s LD HL,(0001H) cannot be used as it stands. HCBOOT runs from the monitor, in bank 2, where 0000–1FFF is the ROM window: a write to page zero is dropped and a read returns this file’s bytes — (0001H) reads C1 EF, the operand of the monitor’s own LD SP,0EFC1H, not a BIOS vector. HARD.COM had to ask page zero where the BIOS was; the ROM knows, and uses the CBIOS’s vector 2 at 0E106H, which is what (page zero+1)+3 resolves to on a booted system (§2.3).
  • The bank switch has to be taken by code that survives it. The monitor’s own code is in the bank it is leaving, so HCBOOT ends by pushing the MD-10 BIOS’s entry and jumping to the CBIOS’s SW2RAM (0E8E2H in the shipped bytes): SW2RAM switches the bank, and its RET lands on the pushed address.
  • The machine’s own interrupt exit needs a store only RAM can make. The ROM’s 60 Hz handler returns through the CBIOS at CCPADR + 1633h, and CCPADR is the ROM’s own CBOOT’s to write — HCBOOT was lifted from HARD.COM’s loader without it, so the exit lands on 1633h and the machine never comes back (measured below). It cannot be written from bank 2 either, because 0EFD2h is reached only in RAM mode — so HCBOOT copies a 14-byte stub out of the payload’s spare into RAM at 0E0F0h, pushes that address instead of 0D800h, and SW2RAM’s RET enters it. The stub writes CCPADR, the CBIOS’s IOBYTE default, and jumps to 0D800h.

tools/emulator-setup/mame-osborne1nx/rom2-check.sh measures the chain, and it passes: the CBIOS is at 0E100H and is the window’s 1000H; the MD-10 BIOS’s jump table is at 0D800H; it is patched from the CBIOS’s vectors, all 90 bytes into the five slots; the bank switches to RAM; the stub is in RAM at 0E0F0H with CCPADR = CB00H; and with a drive mounted the system is read off it into 0C200H (C3 C8 C4 …) and the machine reaches A0>.

The hand-over: measured, and it was one cell. The chain completed and the machine still did not reach A0>, and the reason was not the CBIOS’s uninitialised RAM in general. It was CCPADR (0EFD2h) — the cell the ROM’s own CBOOT writes at 02A3h and HCBOOT was lifted without.

The ROM’s 60 Hz interrupt handler ends by returning through the CBIOS:

;Exit interrupt code via exiting to RAM and then enable or disable ROM code
;depending on the value contained in ROMRAM cell.
	LD	A,ROMRAM	;IS ROM IN OR OUT?
	OR	A
	JNZ	ROMJP1		;if return to RAM

ROMJP1 is CCPADR + 1633h — the CBIOS’s RRI at 0E133h, whose OUT (C),A (C = ROMRAM) restores the bank. With CCPADR = 0 that exit jumps to 1633h, which in bank 2 is the softROM’s page 1: the payload’s own copy of the CBIOS’s console dispatch. That copy reads IOBYTE at page zero+3 — and in ROM mode page zero is the ROM, so it reads the ROM’s own byte D3h (the opcode of the OUT (03h),A at 0004h), whose low two bits are 3: the IEEE device. The dispatch trampolines through ROMJMP into the ROM’s IEEE input routine, which waits for a handshake no device answers, for ever.

Measured with rom2bank.lua — the same instrument on the same path, before the store was built and after:

  stock boot ROM 2.0, before the store ROM 2.0, with it
reads of 0003h (the IOBYTE) 858, all 80h — RAM, CRTOUT 1, returning D3h — the ROM, IEEE 11, all 80h — RAM, CRTOUT
bank selects 454 OUT 0, 492 OUT 1 1 OUT 1 (HCBOOT), 1 OUT 0 (the trampoline) 6 OUT 0, 44 OUT 1
CCPADR (0EFD2h), and the exit it gives CB00h → E133h, the CBIOS’s RRI 0000h → 1633h, the payload CB00h → E133h

ROMRAM (0EF08h) reads 00h at the end of both runs, because SW2ROM clears it on every ROM call and the sample lands inside one; it is 1 at the tick, which is what makes the handler take the ROMJP1 path at all.

The stock machine survives because its CBIOS brackets every ROM call with SW2ROM/SW2RAM, so it is in RAM mode whenever the dispatch runs — 492 asks for RAM in a single boot. The hand-over made exactly one, then left the guest to run across a tick, and the tick’s handler could not get back to RAM because CCPADR was zero. The bank is not something a guest can hold; it is re-derived on every instruction fetch and on interrupt acknowledge (docs/o1-memory-io-map.md §4), so what the hand-over has to do is make the machine’s own exit work — and the third column is that working: the guest asks for RAM 44 times in the 8 s after RETURN, and the IOBYTE answers 80h, which is the stock machine’s own answer.

The fix is one store, and it is proved twice. First by poking it in from outside: with CCPADR = CB00h — and the CBIOS’s own IOBYTE, 80h, at page zero+3 — written into RAM just after the hand-over (rom2handover.lua), the machine boots to A0> with no floppy in the machine:

                   OSBORNE 1
              Rev 1.44 (c) 1983 OCC
    Insert disk in Drive A and press RETURN.
A0>

And then by building it: HCBOOT copies the stub out of the payload’s spare into RAM and switches the bank to it, rom2-check.sh with a drive mounted reads the stub’s 14 bytes back at 0E0F0h and CCPADR = CB00h on the way past, and the prompt arrives from the ROM alone. Two details are worth keeping:

  • 0CB00h is not this boot’s CCP. This boot puts the system at 0C200h; the value is the base the exit adds 1633h to, and 0CB00h + 1633h = 0E133h is the CBIOS’s RRI — the stock CCP-to-CBIOS offset. This boot keeps the CBIOS at 0E100h exactly as a floppy boot does, so the stock value is the right one.
  • The stub’s home is 0E0F0h — 14 bytes in the 104-byte hole between the driver’s third allocation vector (0DFA7h + 241 = 0E098h, docs/md10-system.md §9.1) and the CBIOS at 0E100h. It has to be at or above 4000h: in bank 2 anything below that is the ROM, the window or I/O rather than RAM, and a write there is dropped.

The boot keys, and they cost two bytes (#247 step 4). HCBOOT hangs off the sign-on dispatch, which is three comparisons, and ROM 2.0 re-letters it in place — no code added, no address moved:

Key Boots 1.44
RETURN the hard disk (HCBOOT) floppy A
" floppy B (DSKSWP = 1) floppy B — unchanged
: floppy A (DSKSWP = 0) unused
ESC nothing — released the hard disk

CMP ESC becomes CMP CR and CMP CR becomes CMP ':' (rom144.asm ~295-309; the diff’s first hunk, and the two bytes are 0048h and 0050h in the image). It fits in place, and it is correct rather than merely lucky: START clears 0EF00h-0EFEFh on every pass — DSKSWP (0EFC7h) included — so : always finds it zero and means drive A, and " is the only path that increments it. Nothing else in the dispatch moves: the three JZs and the JR are the ones 1.44 has.

ESC gets no new job. It is a non-standard keystroke in MAME as well as a poor choice for a boot key, and it now falls through to the prompt’s JR START like any unclaimed key. The CBIOS’s own ESCH cell is a different thing and is untouched.

Because those two bytes are the only thing below 0F67h that moves, rom2asm.sh checks them by value rather than merely tolerating them: a build whose dispatch is not this map stops with the map in the message, and rom2boot.lua reads the same two bytes back out of the running monitor.

4.7 The ROM 2.0 jump table, and the 150-byte budget

The legacy table is preserved exactly — 53 entries, same numbers, same semantics (§3.1). ROM 2.0 adds a second, self-describing block after it, so third-party code can detect the ROM and find the new calls without guessing:

Address Content
0100–019E the 53 legacy vectors, unchanged
019F signature, 8 bytes ASCII: O1ROM2.0 (where IMSG sits today)
01A7 extension count (1 byte)
01A8+ the extension table: 3-byte JMPs, ROMVEC2 + 3N

Proposed extensions — short on purpose, each one justified by an issue:

# Entry Does Serves
0 SYSLD reload the system image from ROM (also ROM vector 1’s target) §4.5 — the dropped no-disk goal’s loader
1 BANKSEL A = the payload slot, write the selector §4.3 — and page 1 is the payload, so what the extension selects is the payload and nothing else (§4.1b, docs/rom-pico-protocol.md §4)
2 SCRMOD A = 0/1/3 → 52/104/80 columns, by the stock video-PIA write to 02C00h with EF61h (PIAAD) as the cached copy #24. The CBIOS’s own PLUGH mechanism (occbio55.asm’s MAGIC), and the register and routine confirmed against OZROM_1E.BIN (§4.8) — no video RAM taken, per #83’s constraint
3 MEMTEST chip-level memory test §1
4 HDBOOT install and enter the MD-10 BIOS from bank 2 #179
5 VERSION HL = version word so a program can branch on the ROM, which is the OZROM property worth having

The budget. The new monitor code has to fit in the 150 free bytes of the 1.44 layout, and the accounting for everything planned — the extensions included — is:

Piece Estimate
SYSLD copy loop + bank latch + entry ~30 B
HCBOOT body (reuses SYSLD’s loop) ~30 B
signature + count + 6 extension vectors ~26 B
SCRMOD, BANKSEL, VERSION ~40 B
Total ~126 B of 150

Feasible but tight, and the ACT source’s own IF RLWA > 0FFBH / .9 ERROR CODE TOO LARGE guard will fail the assembly if it is wrong — which is the right place to find out. Plan B if it does not fit: the loader moves into bank 3 and is paged in by a ~12-byte trampoline in the monitor, which buys a full 4 KB for loader code at the cost of one bank. MEMTEST is the first thing to move there.

Two of those rows have moved since the estimate was made: SYSLD is the dropped no-disk goal’s loader (§4.4), and the boot screen — 26 bytes, and not in the estimate at all — is now in the tail. What the measured fit below has to hold is the signature, the count and the six extension vectors.

Measured, not estimated. The build’s own numbers, as it stands and as it got there. Every row is measured with tools/research/rom2asm.sh, and the stock 1.44 below 0F67h is byte-identical in all of them (§4.6):

Build The monitor’s new code Free to the guard at 0FFBh
HCBOOT alone 77 B, 0F67–0FB3 — 67 of copy, patch and jump, plus the 10-byte LDIR that puts the hand-over stub in RAM 72
with the frame path — PRESENT(1)/(2)/(3), the trailer checks and the two blits 212 B (182 when first measured; #247’s W3 grew the fallback) against the 72 above HCBOOT → CODE TOO LARGE —
the screen’s code moved out of the monitor into PRESENT(3) 128 B, 0F67–0FE6 (130 before the acceptance found two defects in it) — the cold boot, the sign-on hook, and the 51-byte SCRN stub at 0FB4h–0FE6h 21
as it stands, after #278 103 B, 0F67–0FCD — the cold boot, the sign-on hook, and the screen’s own 26 bytes: bright fill, fallback print, return 46

So §8 item 2 has two answers, and the second is the useful one. No — the monitor code did not fit in 150 bytes, and the screen was the piece that proved it. The assembler’s own guard said so in its own words (2026-10-15, #247 turn 3):

I 1021  .9   ERROR   CODE TOO LARGE..      Program LWA = 1102h.

That is IF RLWA > 0FFBH / .9 ERROR CODE TOO LARGE doing its job. The answer was to give the screen’s code a home rather than squeeze it: a third content id in the softROM (PRESENT(3), a 4096-byte blob in the Pico’s flash beside the frame, reached by a ~21-byte stub that copies page 1 to RAM and jumps into it — no payload change, and the screen’s code is firmware like the frame), the payload’s spare (1E0Fh–1FFFh, 497 bytes, where the hand-over stub lives), or this section’s Plan B (a banked loader). The blob landed at 4000h–40B6h, 183 bytes, Program LWA = 40B7h, and one assembly produced both artifacts — rom2blob.py turned the 4000h records into the firmware asset firmware/rom-service/screen.bin, and the tool, the asset and the -bootsplash slot all retired with the frame path (#278). The per-piece arithmetic is in research/source-code/BIOS-200-source/rom2-screen.asm.

And yes, once #278 retired the frame path. With the trailer checks and the two blits gone the screen is 26 bytes, which fits the 72 the stub occupied, so the code came back into the monitor’s own tail and the blob, its asset and its tool went with it. The message went into IMSG’s own slot at 019Fh — 72 bytes of text where the vendor’s 182-byte sign-on message sat, at the vendor’s own length, with the vendor’s FF fill behind it — so nothing below 0F67h moved, and the 110 bytes left over there are what the signature and the extension table in this section will take.

Three defects the build found, and all three are read off the ACT80’s own listing (which L=B: writes to a file rather than scrolling past on the console). The door helper’s JNZ tested flags left by its length probe rather than by the result code, so every caller took its “no such content” path and the machine printed the stock 1.44 sign-on however well the door answered; the frame’s trailer sum was read from the half’s 0FFEh instead of the window’s 1FFEh — the ROM’s own byte — so the check could never pass. Neither was visible in a boot; both are why bootscreen-check.sh measures the character plane byte for byte and the attribute plane bit 7, and why with no splash mounted it measures the fallback instead. And the 85 errors were not syntax errors: five comment lines that had lost their leading ; assembled as four illegal mnemonics — three bytes of junk each at 0FB4h and 0FD9h — and one unterminated string, while the blob sat inside the vendor’s ECHO 0FFFH-RLWA ! DB 0FFH … ENDM block. ECHO repeats its body, so the blob was assembled and listed 11 times: ten extra passes over its eight labels, and 80 duplicate-label errors. 85 = 80 + 5. With both fixed the build is no ERRORs, 487 Labels, Program LWA = 40B7h.

4.8 The feature set: what to take from OZROM, and what to refuse

OZROM 1E is the pattern for how to be a replacement ROM (docs/ozrom-1e.md §4–§8). It is also the cautionary tale: its feature set is shaped by its part. It had a 4 KB 2732, and the two things it gave up are things this project needs.

Refuse, explicitly — both are 4 KB decisions, not ideas:

OZROM’s choice Why we refuse it
IEEE-488 removed — jump table 013F–0156 were the IEEE-488 routines, and calling one now “crashes the machine”; IEEE-488 AS IOBYTE DEVICE 3 NOW NULL DEVICE Drive C is an IEEE-488 device (#22, docs/drive-c-protocol.md) and we hold the driver’s own source (rom144.asm, #6). OZROM could not have both. We can
Video window cut to 3 KB (F000–FBFF), the last 1 KB (FC00–FFFF) spent on the redefinable keyboard #24’s VRAM shadow assumes the full F000–FFFF, and OZROM’s move “constrains every later decision” (docs/ozrom-1e.md §4)

Take — and there is room to take them:

OZROM feature Take? Notes
52 / 80 / 104-column switch Yes On #24’s design path, and it is not a new mechanism: the stock video-PIA write, register 2C00 with EF61 (PIAAD) as the cached copy — the same routine, unchanged from rom144.asm, disassembled out of OZROM_1E.BIN at 016F (§4.7)
Chip-level memory tester that names the failing chip Yes The O1 has none, and it is #29’s second oracle. TAB at power-up in OZROM; MEMTEST is already in §4.7’s extension table
A documented jump table, memory map and version Yes The stock ROM already publishes the 53-vector table (§3); OZROM’s manual is precisely why third-party code could target it. The O1ROM2.0 signature and VERSION (§4.7) are the same property
The interrupt hook at 0EFF2h — a bare RET continues, no register save/restore Yes #18. It is a different INTBL slot and calling convention from the RT-60A’s 0EFF8h (docs/rt60a-analysis.md); reconcile the two, do not merge them blindly
Time-of-day clock in EF66–EF69 (BCD) Yes #7/#18. The cells are the machine’s own, so this is not a new ABI
CRC checking on disk access Yes Free correctness; the stock ROM does not do it
Removing the “Centronics printer not connected” lockout on DD systems Yes #19, and cheap
Software-redefinable keyboard plus eight function keys Not yet #45/#47. This is the one feature that costs RAM (1 KB at FC00–FFFF), not ROM, and it is the reason OZROM moved the video window. Do it with a RAM budget, never by taking video space
1793/1797 FDC notes; truer Televideo 912/920 emulation Not yet #20; not on this boot’s path

The rule this leaves us with, and its one constraint. Every entry in the “refuse” table is a consequence of a 4 KB part. Ours is served from the interposer’s own flash, and the boot needs 7695 of the 8192 contiguous bytes (§2.3) — so there is room in the image that OZROM never had.

The constraint is narrower than that, and worth stating precisely: the 4 KB monitor is still 4 KB, with 150 free bytes (§4.7), and anything that must be resident there answers to that budget. The clock, the interrupt hook and the CRC check are bigger than that between them, so they cannot be monitor-resident. They do not have to be — the extension table at 01A8h (§4.7) is the hook for code that lives in the window, and that is what the window is for. The monitor stays a monitor; the new features live in the window and are reached through the table.

So no — we do not have to drop a peripheral the way OZROM did. IEEE-488 stays, the 4 KB video window stays, and the test of the design is that nothing in the “take” table above requires giving either one up.

4.9 The boot screen: one page, and a fallback that pays for itself

The screen is one window page — 4096 bytes, which is exactly the video buffer (128 × 32 cells). In bank 2 the window and the video RAM are both visible (§4.4), so one LDIR from 1000h to F000h is a whole frame: 4096 × 21 T-states = 86016, or 21.5 ms at 4 MHz. A fiftieth of a second, against a floppy boot measured in seconds. Serving that frame was the ROM’s job while the ROM served the frame; since #278 the frames live in the Pico’s own flash and the RP2354B draws them, so the ROM’s whole contribution to the screen is the bright fill below, and the animation is the viewport slide — a register write.

The frame is someone else’s file, so it validates itself. The flash is updatable and a hand-built image will get it wrong, and a bad frame puts garbage on the screen with no way back. So the frame carries a marker in the rows nobody can see — rows 24–31 are off-screen:

offset content
0FF8h O1NEXT, the magic — six bytes
0FFEh the 16-bit sum of 0000h–0FF7h, little-endian

The trailer is eight bytes: the magic is six bytes, which consumes the two reserved bytes at 0FFEh, so the checksum definition does not move — it still covers exactly the 4088 bytes before the trailer. The one cost is that the monitor’s compare is six bytes rather than four, inside the 150-byte budget §4.7 accounts (#228).

The fallback is the screen’s own two lines, and it costs nothing — because ROM 2.0 replaces the stock sign-on rather than adding to it. It carries the same text and the same bright/dim runs as the animation’s resting frame, at the frame’s own rows and columns — array rows 20 and 22, ink from columns 24 and 30 (#247’s W3):

  bytes
the message: VCLRS, the padding as OSTR’s 7Fh repeat escape, both lines, and the ESC,VSHI/ESC,VEHI mode changes 72
IMSG, which it replaces (§2.1) 182

So the fallback still frees 110 bytes, and it needs no code of its own: the attribute runs are the text’s own escapes, and dim is the vendor’s own half-intensity mode. Three things were measured rather than assumed, and the first is why an unpositioned fallback is not merely misplaced — it is invisible:

  • CURS is 0 when the screen code runs. START clears 0EF00h–0EFEFh on every pass, and COUT writes through CURS — so a message that does not position itself is written to address 0, which is the ROM, and nothing appears anywhere. The vendor’s IMSG began with VCLRS for exactly that reason; the fallback does too.
  • dim is ESC,VSHI … ESC,VEHI, the vendor’s half-intensity mode: VHALF writes DIMBIT (00h) into the attribute array, which reads back 7Fh — the animation’s own dim value, so the plane and the asset’s attribute half compare byte for byte.
  • the 7Fh repeat escape is OSTR’s own (IMSG uses it), so a padding run of twenty costs three bytes rather than twenty.

The order at boot is unchanged: print the text first, then page the frame in and check the trailer; if it is right, blit over the text. A missing or malformed image leaves the message on screen, which is the whole point of having it.

And the blit is two passes, not one — measured 2026-10-15. The O1’s video cell is 9 bits: 8 for the character and 1 for brightness, and the 9th bit is not in the video RAM. It lives in a separate 4K×1 array that OUT (02h) pages into F000–FFFF; OUT (03h) pages the character RAM back, and the array’s low seven bits are not physically present and read high. Measured in osborne1nx:

   
with OUT (02h) then writing 00h to F000h reads back 7Fh
the palette (palette_init_monochrome_highlight) 0 = black, 1 = C0C0C0, 2 = white
the renderer (BIT(attr,7) ? 2 : 1) bit 7 set = bright, clear = dim
the array at the sign-on 4072 × FFh, 24 × 7Fh — so it is not a blank slate
the 116 character cells at the sign-on all bright

So the screen fills the attribute array bright (OUT (02h), 4096 stores of FFh, OUT (03h)), because 24 stray dim cells would show in a 4096-cell screen. That is 21.5 ms, and it is what makes the fallback’s own dim runs the only dim cells on the screen — which is the trigger the RP2354B watches for (§4.9’s IMSG, and docs/rom-pico-protocol.md §5.1).

And that fill is the only thing the ROM does to the attribute plane. The RP2354B draws both planes out of the frame it is playing (#278), so nothing blits the frame’s attribute half over the fill. The frame is still two 4096-byte halves — characters and attributes — and v1.0’s attribute half is all FFh. The format, the trailer and the sequence the ROM used to run are docs/rom-pico-protocol.md §4.1 and §5.

And the frame lives in the Pico’s own flash, not the library flash — one animation, compiled into the firmware, swappable only by rebuilding it. The library flash holds the default disks.

tools/research/rom2strokes.py --frame writes the whole artifact — 8192 bytes, the character half then the attribute half, each with its own trailer at its own 0FF8h — and the art is placed by --origin; see §2.3 for why that is not cosmetic. --half writes one half, --verify validates a half or a whole frame off the disk. What the firmware compiles in is firmware/rom-service/boot-animation.bin — the animation the RP2354B plays (#247’s W5) — and firmware/rom-service/frame.bin (the single frame) is not in the tree: the animation replaced it. Nor is firmware/rom-service/screen.bin, the screen’s code served as a window page, because the code came back into the monitor’s own tail (#278); rom2blob.py and rom2asm.sh’s -b went with it.

5. The six open questions from #83, answered

# Question Answer
1 Where does the BDOS get its parameters with no disk? Keep the DPB. It costs nothing: the DPB, allocation vector and check vector live in the CBIOS’s own RAM area at E900h+ exactly as today, and with no media they are never dereferenced (§4.5, the null-DPH gate). Stubbing them would save no ROM space — they are RAM, not ROM — and would break the case where a real floppy is fitted
2 Warm boot, when there are no system tracks Moot — there is always a system on A:. The firmware serves drive letters, so warm boot reads the system off the disk exactly as the stock ROM does and ROM vector 1 keeps its meaning; no CBIOS change, no new mechanism (§4.5). The ROM-resident alternative — vector 1 pointing at SYSLD — belongs to the dropped no-disk goal (§4.4)
3 Does the CCP need to be relocatable? No — pin it. MSIZE = 59, CCP = CB00h, BDOS = D300h, BIOS = E100h, all as the vendor shipped them. MOVCPM/SYSGEN are disk-build tools for a disk build; a ROM build wants the layout fixed so the ROM’s copy loop can be two LDIRs with literal addresses. It also keeps the CBIOS’s ROMCDE arithmetic valid, which requires BIOS & 0FFh == 00h
4 Keep floppy support, or drop it? Keep it. The ROM carries the vendor’s CBIOS unchanged, so a real disk still boots. The diskless case is handled at SELDSK by returning a null DPH when no media is present, which is documented CP/M behaviour (the BDOS then reports Bdos Err on X: Select for that drive) rather than a hang in the FDC retry loop — and the gate belongs to the dropped no-disk build (§4.4), not to the image this project builds. Deleting the drivers would save ROM space we do not need to save — the CBIOS is 2048 bytes either way, and it is already written
5 Which socket/part on the replica? The ROM socket, and on a real machine no part in it. An OEM-faithful mainboard keeps a socket that takes a standard 1.44 ROM, so it is a stock machine on its own; with the interposer fitted, a daughterboard takes the socket and the Pico serves the ROM, so ROM 2.00 needs no new part and is updatable in flash. A 27128/2764 is only for a board with no interposer — and there is no such board, so there is no larger part at all, not in any form. Every host (OEM + interposer, and the next-integrated board) has the softROM, so there is one host to design for and one to test on
6 What can we borrow from OZROM’s memory map? The shape, not the contents: a documented table and map, a documented version, a column switch, a memory test. Its specific choices — video RAM at FC00–FFFF, keyboard redefinition, IEEE-488 removed — are the ones #83 rules out. docs/ozrom-1e.md §5–§8 has the detail

The LDIR/patch/jump body is exactly 60 bytes, not an estimate — measured at HARD.COM 0x01E5–0x0220 (§4.6) — and presenting the payload costs nothing on top of it, because the payload is window page 1 (§4.1b).

6. The build (deliverable 2)

Step Tool State
Monitor source assembles to the shipped 4096 bytes ACT80 (SORCIM 3.0/3.2, in-repo) under MAME Done — #203/#204, byte-identical, CRC32 c0596b14. tools/research/rom144-reassemble.sh
The jump table is what the source says it is tools/research/romvec.py Done — 53 entries, 0 opcode disagreements
ROM 2.0’s new monitor code assembles ACT80 Done — the stock 1.44 below 0F67h is byte-identical, HCBOOT is 77 bytes (0F67–0FB3), and with the screen’s 26 bytes the new tail is 0F67–0FCD, 103 of 149, 46 free to the vendor’s guard. tools/research/rom2asm.sh (§4.6, §4.7). CRC32 ce51a4eb for the HCBOOT-only build
The system image’s CCP+BDOS+CBIOS taken from the shipped disk, not rebuilt Available today — the reserved tracks of research/shipped-software/OS1SYSD.IMD, at image offsets 0000, 0800 and 1600 (§2.1)
The ACB-4000 boot payload (§2.3) CBIOS + HARD.COM’s embedded BIOS at file offset 0x053A + the vendor’s 60-byte loader block + the 14-byte hand-over stub Available — tools/research/hardbios.py already reads the BIOS; the loader block is measured at HARD.COM 0x01E5–0x0220, and the stub is written down in rom2image.py
The image itself tools/research/rom2image.py Done — 7695 bytes, every anchor re-checked. Built on the stock monitor it is CRC32 28840c50; built on the HCBOOT-only ROM 2.0 monitor it is a9453f51, and that is the one that boots (§4.6, §7)
The no-disk payload the 7680-byte system image split 4096 + 3584 Not built — the no-disk goal is dropped (§4.4); the split is mechanical from the above if it ever comes back

Why take the CCP/BDOS/CBIOS bytes rather than rebuild them: the CBIOS’s build recipe (bios141.gen) names ACT 3.5e, DDT 2.2, SYSGEN 2.1 and MOVCPM, and ACT 3.5e is not in the archive (docs/o1-rom-source.md; 3.0 and 3.2 are, and they agree with each other on rom144.asm). Rebuilding the CBIOS is therefore an open risk with no payoff: the vendor’s own 2048 bytes are on the disk, and the whole point of the design is that they do not need to change. The monitor is the part we are writing, and that is the part the toolchain is proven for.

The build therefore produces one image: the 4096-byte monitor plus the 3599-byte payload of §4.3 — 7695 bytes, fitting the contiguous 8 KB window with 497 to spare. That single artefact is what the SFF’s flash holds, what the interposer’s flash serves to the Pico, and what the emulator sees behind the softROM device (§7). One image, three consumers, no per-host variants. How the payload is presented is measured for this boot — two contiguous 4 KB pages in the softROM’s window (§4.1b) — so the emulator device models exactly that; the general window allocation is #12’s (§4.1a). The image’s content is not in question.

7. The boot test (deliverable 3)

Deliverable 3 is a MAME boot test, and it is worth making it stronger than “no floppy attached”, because “no floppy attached” is satisfiable by a ROM that hangs:

Check Passes when
A> reached the probe sees the banner and an A> prompt
No FDC access the harness sees no access to 2100–2103 from reset to the prompt — this is the “no disk access at all” of the issue title, asserted rather than implied
The BDOS is live, without a disk a nonsense command typed at the prompt is echoed and answered ?. The CCP reads the line with BDOS function 10 and prints the reply with function 9, so this exercises the CCP→BDOS path end to end — and unlike DIR, it does not need a disk, which is the whole point
Warm boot works a Ctrl-C (or a program exit) returns to A> without an FDC access
(CBIOS-ND build only) the gate holds DIR A: returns Bdos Err on A: Select rather than hanging in the FDC retry loop — the §5-question-4 null-DPH gate doing its job

The mechanism is the one #191 already built: tools/emulator-setup/mame-osborne1nx/ is a MAME patch that adds a machine and a device — softrom_device, re-registered over the ROM window (§4.1b) — the same shape as the ACB-4000 card (docs/osborne1nx-machine.md). The harness is tools/research/o1keys.sh + tools/research/mame-boot-probe.sh, which is what measured every row of docs/mame-emulation.md §4.

Run, and it boots. The image exists — tools/research/rom2image.py, 7695 bytes (§6) — the softROM window serves it, and HCBOOT runs the chain and the boot: rom2-check.sh boots the emulated interposer with no floppy, presses RETURN at the sign-on prompt — and reads the dispatch’s two key bytes, the CBIOS, the MD-10 BIOS, the patch, the bank switch, the hand-over stub’s 14 bytes in RAM at 0E0F0h, CCPADR = CB00h, the system off the drive and the A0> prompt back (§4.6).

Which rows that settles, exactly. The hard-disk boot is the one this project builds (§2.3), and it is measured; the no-disk payload the other three rows want is the dropped goal (§4.4), so those rows are moot rather than pending:

Check State
A> reached measured — A0> arrives with no floppy in the machine
No FDC access no — the system is read off the drive, so the FDC is used. A boot with no disk access at all is the dropped no-disk goal, and it needs the ROM-resident CCP/BDOS, not a selector
The BDOS is live, without a disk no — 0C200h came from the drive rather than from the ROM, for the same reason
Warm boot works yes for the hard-disk boot — the CBIOS’s WBOOT reads the system off the drive exactly as the stock ROM does (§4.5)
(CBIOS-ND build only) the gate holds not built — the null-DPH gate is for the no-disk build (§5 question 4)

So the ROM’s own half of deliverable 3 is done and measured on the boot this project builds; the no-disk half is not a gap, it is a goal that went away.

8. What is still open

  1. The window: address, paging and selector. For the boot this project builds it is settled and measured: the window is 0000–1FFF — mirror(0x1000) in the machine’s own address map is the undecoded A12, so a softROM that decodes it gets two contiguous 4 KB pages, with no latch and no register (§4.1b) — and softrom_device serves it, -softrom names the image, and softrom-check.sh accepts both. The 11776-byte payload and the paging it needed are retired with the no-disk goal (§4.4, §4.5), and the one bit that was left went too: window page 1 is the payload, always (#278). What remains open is #12’s interface spec for the general case — the window’s address, paging and selector for the virtual peripherals — and the constraint is fixed (8 KB contiguous plus 4 KB beyond the assigned I/O block, §2.2) while the answer is not.
  2. Does ROM 2.0’s monitor code fit in 150 bytes? Yes, as it stands — and the screen is what decided it (§4.7). HCBOOT is 77 bytes of the tail; with the screen’s code behind it the new monitor is 103 of the tail’s 149, 46 free to the guard. That is true because the ROM-side frame path retired (#278): with it, the screen’s code was 212 bytes against the 72 above HCBOOT, the assembler’s guard said CODE TOO LARGE, and the code went to the interposer’s flash as a third content id. What the fit buys is the extension table’s own home: IMSG’s slot is 182 bytes with 110 of them free (the fallback text took 72), and BANKSEL, SCRMOD, VERSION and the rest are still estimates — but there is room for them, in the tail and in the vendor’s dead sign-on slot.
  3. A register at 2300h? No — measured, not inferred. 2300–23FF is not free: the onboard selects check two address bits each, so 0x2300 is the floppy’s command/status register and 0x2301 is the floppy’s track register and the keyboard’s row 0 (docs/o1-mainboard-schematic.md §7a, docs/rom-pico-protocol.md §2). That is why the ROM↔Pico door is at 2800h/2801h — the part of docs/o1-memory-io-map.md §7’s recommended region that nothing selects. Nothing is left to check here.
  4. Does the CBIOS really never call ROM vectors 10–12 and 16? §3.2 says the labels do not line up and that nothing breaks; that is read from the sources, not traced. A MAME trace of a boot with a breakpoint on those addresses would settle it in an afternoon.
  5. MEMTEST’s scope. Chip-level means per-4116, which needs the refresh timing and the bank-3 dim bit to be respected. Not designed here.
  6. The 512 bytes of RAM residue. Harmless to the build (we take a fixed 2048 for the CBIOS), but it is a reminder that the system image is not a clean artefact and a future SYSGEN-equivalent should say so.
  7. The memory map at the moment the boot screen runs. Answered and measured — docs/rom-pico-protocol.md §6, which also records the BIT 9 finding: the 9th video bit is a separate 4K×1 array paged into F000–FFFF by OUT (02h), its polarity is measured from the palette, and the array is not a blank slate — so the screen is two passes, not one (§4.9).
  8. Where the frame comes from in Pico-land, and how the ROM asks for it. Answered — docs/rom-pico-protocol.md §4 and §5. The animation lives in the Pico’s own flash, compiled into the firmware, two 4096-byte halves (characters and attributes) per frame so the 9th bit is retained by construction, and each half carries its own trailer — which is the “is a frame there?” query, so there is no separate question. The ROM does not ask for a frame at all: the RP2354B plays the animation and stops on the Z80’s first video-RAM write (#278).
  9. The mailbox protocol for the ROM. Answered — the same protocol, with two doors, one protocol: the I/O pair 0E7h/0EBh for userland (a TPA program cannot reach bank 2) and the bank-2 register pair 2800h/2801h for the ROM, which runs in bank 2 where the console path’s own latch writes cannot perturb a comparator-decoded claim. docs/rom-pico-protocol.md §2 has the measurement that decided it. Since #278 the ROM’s own client does not drive the door at all: PRESENT/INFO serve the userland client and the web UI (firmware/rom-service/).
  10. The hand-over: built, and the one cell was CCPADR. The chain completed and the machine still did not reach A0>; the reason was one cell. The ROM’s 60 Hz interrupt handler exits through ROMJP1 — CCPADR (0EFD2h) + 1633h — to the CBIOS’s RRI at 0E133h, which is what restores the bank; the ROM’s own CBOOT writes that cell (02A3h), and HCBOOT does not, so the exit landed on 1633h — the softROM’s page 1, the payload’s copy of the CBIOS’s console dispatch — which reads IOBYTE from a page zero that in ROM mode is the ROM (D3h = the IEEE device) and never returned. Measured: the stock boot reads the IOBYTE 858 times, all 80h from RAM; the hand-over read it once, and got D3h. Built. HCBOOT copies a 14-byte stub out of the payload’s spare into RAM at 0E0F0h, pushes that address instead of 0D800h, and SW2RAM’s RET enters it; the stub writes CCPADR, the CBIOS’s IOBYTE default, and jumps to 0D800h. Measured with the same instrument that found the fault: the IOBYTE now answers 80h eleven times, the guest asks for RAM 44 times in the 8 s after RETURN, and CCPADR gives E133h — and rom2-check.sh with a drive mounted reaches A0> with no floppy in the machine (§4.6, §7). Nothing is left on this chain; what is left in this document is #12’s window (item 1) and the extension table’s contents (item 2).

Sources