ROM-Dateisystem (RFS) — Technischer Leitfaden

Technischer Leitfaden RFS

Dieser Leitfaden dokumentiert die Hardware-Integration, Speicherarchitektur, das Software-Modullayout, das Design des SD Card Filing System, die CP/M-Implementierung und das vollstaendige Build-System des Rom Filing Systems. Er richtet sich an Benutzer, die verstehen moechten, wie RFS auf Systemebene funktioniert, RFS auf neue Hardware portieren oder einen vollstaendigen Build aus dem Quellcode durchfuehren moechten.
Fuer die taegliche Nutzung und die Monitorbefehlsreferenz siehe das Benutzerhandbuch. Fuer Z80-Assembler-Quellcode-Walkthroughs siehe das Entwicklerhandbuch.

Hardware-Plattformen

RFS unterstuetzt vier Hardware-Plattformen. Jede wird zur Kompilierzeit ueber ein Flag in asm/include/rfs_definitions.asm ausgewaehlt. Die resultierenden Binaer-Images unterscheiden sich in Bank-Layout, Funktionsumfang und den verwendeten ROM-Adressen.

RomDisk-Karte
Das urspruengliche und leistungsfaehigste RFS-Ziel. Die RomDisk-Platine wird in den Erweiterungsslot des Sharp MZ-80A eingesetzt und bietet:
  • Bis zu 4 x 512 KB SST39SF040 Flash-RAMs — ersetzt die Monitor-ROM und stellt drei User-ROM-Chips bereit, insgesamt bis zu 2 MB Flash-basierter ROM-Speicher.
  • 512 KB statisches RAM — verfuegbar als zusaetzlicher paginierter Arbeitsbereich (zukuenftige Verwendung).
  • SDXC-Kartenleser mit Hardware-SPI-Schnittstelle (v2+-Platinen) oder Software-Bit-Bang-SPI (v1-Platinen, ueber den parallelen Druckerport).
  • Ein codierter Latch (v2.0+-Platinen), der die Bank-Steuerregister schuetzt — der Latch oeffnet sich nur nach einer festen Sequenz von Lesezugriffen auf die oberen 8 Bytes des User-ROM-Adressbereichs (0xEFF8–0xEFFF), wodurch versehentliche Bankwechsel waehrend des normalen Betriebs verhindert werden.
Der Monitor-ROM-Chip (bei 0x0000–0x0FFF auf dem MZ-80A) wird durch einen paginierten Flash-RAM-Socket-Adapter ersetzt, der als 4-KB-Fenster in den vollen 512-KB-Chip erscheint. Ebenso wird die User-ROM (bei 0xE800–0xEFFF) durch ein paginiertes 2-KB-Fenster ersetzt.

SFD-700 Floppy-Schnittstelle
Die SFD-700 mkII Floppy-Disk-Schnittstellenkarte enthaelt eine 512-KB-Flash-ROM. RFS belegt Seiten dieser Flash-ROM neben dem Floppy-AFI-Bootcode:
  • 0x00000–0x00FFF — MZ-80A AFI Floppy-Boot-ROM (Original, benoetigt fuer den 2-MHz-DRQ-Trick).
  • 0x01000–0x01FFF — MZ-700 AFI Floppy-Boot-ROM.
  • 0x02000–0x0BFFF — RFS-Firmware (10 x 2 KB User-ROM-Baenke, entsprechend User-ROM-Baenken 0–4).
  • 0x0C000 aufwaerts — ROM-Dateisystem (Programme als MZF-Images gespeichert).
Im SFD-700-Build beginnt der User-ROM-Code bei 0xE000 und wird auf 0xE300 ausgerichtet (unter Beruecksichtigung des speicher-gemappten I/O-Bereichs des MZ-700). Es gibt keine SD-Karte; die SD-Karten-Befehle sind aus diesem Build ausgeschlossen.

picoZ80
Die picoZ80-Platine (RP2350-basierter Z80-Ersatz) emuliert das vollstaendige Speicherabbild des MZ-80A in PSRAM und Flash. RFS laeuft innerhalb des emulierten ROM-Bereichs und verwendet die gleichen Bank-Adressen wie der RomDisk-Build. Der picoZ80 bietet seinen eigenen SPI-verbundenen SD-Karten-Speicher, sodass der volle RomDisk-Funktionsumfang (SD-Karten-Laufwerke, Band↔SD-Kopie usw.) verfuegbar ist.

RFS laeuft unter der jeweiligen Maschinen-Persona, die der picoZ80 dem Host praesentiert. Neben dem MZ-80A umfasst dies nun auch die Sharp MZ-80K-Persona, die dieselben Sharp-Schnittstellenkarten wie der MZ-80A binden kann (RFS, MZ80AFI, MZ-1E14/E19, MZ-1R12/R18/R37, PIO-3034) sowie ihren eigenen nativen MZ-80FD (T3444M) Floppy-Controller. Mit einer MZ80AFI-Karte erkennt das RFS CP/M CBIOS originale MZ-80K CP/M-Disks (128-Byte-Sektoren, nicht invertiert) automatisch und bindet sie als CP/M-Laufwerke C:/D: ein.

Speicherarchitektur

Die Z80-CPU des Sharp MZ-80A adressiert 64 KB Speicher. RFS passt seine gesamte Firmware in die beiden ROM-Fenster, ohne RAM zu verbrauchen, und laesst den vollen Bereich 0x1200–0xCFFF fuer Benutzerprogramme frei.

Z80-Adressraum-Layout 
Address     Size    Contents
─────────────────────────────────────────────────────────────────────
0x0000      4 KB    Monitor ROM (MROM)  — 4 KB window into 512 KB Flash
                    Paged across 16 banks:
                      banks 0–5 = monitor variants + CP/M CBIOS + RFS mrom utils,
                      banks 6–7 = ASM/DASM opcode tables,
                      bank 8 = IPL, bank 9 = RFS message strings,
                      banks 10–15 = reserved
0x1000      256 B   MZ-80A system variables / stack
0x1200    ~46 KB    User RAM  (main program area)
0xCFFF
0xD000      12 KB   Video RAM + memory-mapped I/O (MZ-80A hardware)
0xE800       2 KB   User ROM (UROM) — 2 KB window into 512 KB Flash
                    Paged: banks 0–11 = RFS modules,
                           banks 12–15 = CP/M CBIOS banks
                    Note: on the SFD-700 build the UROM window starts at
                    0xE300 (0xE000–0xE2FF is MZ-700 memory-mapped I/O).
                    The command table (CMDTABLE2) is placed at 0xE300 and
                    the main bank code remains at 0xE800 as on other builds.
0xEFFF
0xF000       4 KB   Floppy AFI ROM / FDC ROM (SFD-700 MROM location)
─────────────────────────────────────────────────────────────────────

Monitor-ROM-Baenke (je 4 KB)
Das Monitor-ROM-Fenster bei 0x0000–0x0FFF wird ueber 16 Seiten umgeschaltet, die im Monitor-ROM-Flash-Chip gespeichert sind. Davon sind drei Seiten (Baenke 6, 7 und 9) RFS gewidmet — sie enthalten die Opcode-Tabellen des Z80-Assemblers/Disassemblers bzw. die Meldungstexte:
Bank Modul Beschreibung
0 monitor_sa1510.asm Originale SA-1510 Monitor-ROM — 40 Spalten. Die Standard-Bank beim Einschalten.
1 monitor_80c_sa1510.asm SA-1510 fuer 80-Spalten-Anzeige angepasst (erfordert Kuma-Upgrade).
2 cbios.asm CP/M 2.2 CBIOS-Kernel — waehrend des CP/M-Boots hierhin verlagert.
3 rfs_mrom.asm RFS Monitor-ROM-Dienstprogramme. Laeuft vom MROM-Bereich aus, um im User-ROM-Flash gespeicherte MZF-Dateien zu scannen und zu laden, da User-ROM-Code sich nicht selbst ausblenden kann.
4 monitor_1z-013a.asm MZ-1Z-013A Monitor (MZ-700 / MZ-1200 Variante).
5 monitor_80c_1z-013a.asm 1Z-013A Monitor fuer 80-Spalten-Anzeige angepasst.
6 rfs_mrom_bank6.asm Z80-Assembler/Disassembler Opcode-Tabelle 1.
7 rfs_mrom_bank7.asm Z80-Assembler/Disassembler Opcode-Tabelle 2.
8 ipl.asm Initial Program Loader.
9 rfs_mrom_bank9.asm RFS-Meldungstexte-Repository.
10–15 — Reserviert / frei.

User-ROM-Baenke (je 2 KB)
Das User-ROM-Fenster bei 0xE800–0xEFFF wird ueber 16 Baenke in den User-ROM-Flash-Chips umgeschaltet — 12 Baenke fuer RFS (Baenke 0–11) und 4 Baenke fuer das CP/M CBIOS (Baenke 12–15):
Bank Modul Beschreibung
0 rfs.asm Primaerer RFS-Einstiegspunkt, Befehlsverteiler, Befehlstabelle, Bank-Switch-Infrastruktur, die von allen Baenken gemeinsam genutzt wird.
1 rfs_bank1.asm Floppy-Disk-Controller-Funktionen (FDC) — Floppy-Boot (FL), Floppy-Verzeichnis (FD), Floppy-Kopie (FC), Floppy-zu-Band (FD2T), Band-zu-Floppy (T2FD) und Laufwerksauswahl. Der vollstaendige FDC-Befehlssatz wird in allen Builds assembliert.
2 rfs_bank2.asm SD-Karten-Controller — SPI-Treiber, SD-Karten-Initialisierung, SDCFS-Verzeichnis sowie Datei-Lesen/-Schreiben. Wird im SFD-700-Build nicht assembliert (keine SD-Karten-Hardware).
3 rfs_bank3.asm Monitor-Speicher-Dienstprogramme — Hex-Dump (D), Speicher-Edit (M), Speicher-Kopie (CP), SD-Karten-Datei-Dump (DUC), I/O-Port-Lesen/-Schreiben (IN / OUT). Band↔SD-Kopie (T2SD/SD2T) ist nur in RomDisk-/picoZ80-Builds enthalten.
4 rfs_bank4.asm CMT-Controller (Kassette) — Bandladen, Speichern und Verifizieren.
5 rfs_bank5.asm Allgemeine Dienstprogrammfunktionen — formatierte Ausgabe, String-Routinen, gemeinsam genutzter Hilfscode.
6 rfs_bank6.asm Z80-Assembler/Disassembler Opcode-Tabelle 1, PRINTMSG-Funktion und Meldungstext-Infrastruktur.
7 rfs_bank7.asm Z80-Assembler/Disassembler Opcode-Tabelle 2, Z80-Disassembler (DASM), DRAM-Speichertest, 8253-Timer-Test.
8 rfs_bank8.asm Z80 interaktiver Assembler (ASM).
9 rfs_bank9.asm ROM-Verzeichnis, Dateisuche, Lade- und Druckfunktionen (aus Bank 0 in freien Speicher verschoben).
10 rfs_bank10.asm Reserviert / frei.
11 rfs_bank11.asm Hilfebildschirm.
12 cbios_bank1.asm CP/M CBIOS — Audiofunktionen, RTC, Tastatur und Low-Level-Dienstprogramme.
13 cbios_bank2.asm CP/M CBIOS — Bildschirmtreiber und ANSI-Terminal-Emulation.
14 cbios_bank3.asm CP/M CBIOS — SD-Karten-Treiber (stellt CP/M-Laufwerke A:–G: bereit).
15 cbios_bank4.asm CP/M CBIOS — Floppy-Disk-Controller. Erkennt die Sektorgroesse automatisch ueber die MZ80AFI-Karte (256-Byte MZ-80A vs. 128-Byte MZ-80K Disks) und kann originale MZ-80K CP/M-Disks direkt lesen und sie auf die CP/M-Laufwerke C:/D: abbilden.

Bank-Switching-Mechanismus
Da der Z80 jeweils nur einen 2-KB-Ausschnitt der User-ROM sehen kann, enthaelt jede Bank eine Kopie des Bank-Switching-Stubs — ein kleiner, fester Codeblock an einer bekannten Adresse innerhalb des 2-KB-Fensters. Wenn Bank 0 eine Routine in Bank 3 aufrufen muss:
  1. Schreibt sie die Ziel-Banknummer in das Hardware-Bank-Latch-Register.
  2. Springt zum bekannten Einstiegspunkt in der neu eingeblendeten Bank.
  3. Fuehrt die gewuenschte Routine aus.
  4. Schreibt Bank 0 zurueck in den Latch und kehrt zurueck.
Dieser Mechanismus macht alle 12 RFS-Baenke (12 x 2 KB = 24 KB) plus die 4 CBIOS-Baenke (4 x 2 KB = 8 KB) — insgesamt 32 KB — von jedem Ausfuehrungskontext aus zugreifbar, obwohl nur 2 KB gleichzeitig sichtbar sind. Der Bank-Switching-Stub belegt die ersten 32 Bytes jeder Bank (0xE800–0xE81F), und die Bank-Switching-Tabelle beginnt bei 0xE800 + 0xB0. Kritisch: Keine Schleifenanweisung darf jemals den Bereich 0xEFF8–0xEFFF auf v2+-RomDisk-Platinen ueberspannen, da diese Adressen die codierte Latch-Entriegelungssequenz ausloesen.

Software-Architektur

Die vollstaendige Modultabelle — jede Quelldatei, ihre Ziel-ROM, Bank und Funktion:
Modul ROM Bank Groesse Beschreibung
rfs.asm User 0 2 KB Befehlsverteiler, Befehlstabelle, Bank-Switch-Infrastruktur.
rfs_bank1.asm User 1 2 KB Floppy-Disk-Controller — Laufwerksauswahl, FDC-Boot, Floppy-Kopie (FC), Floppy-zu-Band (FD2T), Band-zu-Floppy (T2FD) (RomDisk/picoZ80); nur FDCK-AFI-Sprung (SFD-700).
rfs_bank2.asm User 2 2 KB SD-Karten-Controller — SPI, SDCFS-Verzeichnis, Datei-Lesen/-Schreiben. Nicht im SFD-700-Build assembliert.
rfs_bank3.asm User 3 2 KB Speicher-Dienstprogramme — D, M, CP, DUC, IN, OUT (alle Builds); T2SD, SD2T (nur RomDisk / picoZ80).
rfs_bank4.asm User 4 2 KB CMT-Controller — Bandladen, Speichern, Verifizieren.
rfs_bank5.asm User 5 2 KB Allgemeine Dienstprogramme — Druckroutinen, String-Helfer.
rfs_bank6.asm User 6 2 KB Z80-Assembler/Disassembler Opcode-Tabelle 1, PRINTMSG-Funktion, Meldungstext-Infrastruktur.
rfs_bank7.asm User 7 2 KB Z80-Assembler/Disassembler Opcode-Tabelle 2, DASM, DRAM-Test, Timer-Test.
rfs_bank8.asm User 8 2 KB Z80 interaktiver Assembler (ASM).
rfs_bank9.asm User 9 2 KB ROM-Verzeichnis, Dateisuche, Lade- und Druckfunktionen (aus Bank 0 verschoben).
rfs_bank10.asm User 10 2 KB Reserviert / frei.
rfs_bank11.asm User 11 2 KB Hilfebildschirm.
cbios_bank1.asm User 12 2 KB CP/M CBIOS — Audio, RTC, Tastatur, Low-Level-Dienstprogramme.
cbios_bank2.asm User 13 2 KB CP/M CBIOS — Bildschirmtreiber, ANSI-Terminal-Emulator.
cbios_bank3.asm User 14 2 KB CP/M CBIOS — SD-Karten-Treiber (CP/M-Laufwerke A:–G:).
cbios_bank4.asm User 15 2 KB CP/M CBIOS — Floppy-Disk-Controller.
monitor_sa1510.asm Monitor 0 4 KB Originale SA-1510 Monitor-ROM (40 Spalten).
monitor_80c_sa1510.asm Monitor 1 4 KB SA-1510 fuer 80-Spalten-Anzeige angepasst.
cbios.asm Monitor 2 4 KB CP/M 2.2 CBIOS-Kernel (waehrend des CP/M-Boots nach 0xC000 verlagert).
rfs_mrom.asm Monitor 3 4 KB RFS Monitor-ROM-Dienstprogramme — ROM-Scannen, MZF-Laden.
monitor_1z-013a.asm Monitor 4 4 KB MZ-1Z-013A Monitor (MZ-700 / MZ-1200 Variante).
monitor_80c_1z-013a.asm Monitor 5 4 KB 1Z-013A fuer 80-Spalten-Anzeige angepasst.
rfs_mrom_bank6.asm Monitor 6 4 KB Z80-Assembler/Disassembler Opcode-Tabelle 1.
rfs_mrom_bank7.asm Monitor 7 4 KB Z80-Assembler/Disassembler Opcode-Tabelle 2.
ipl.asm Monitor 8 4 KB Initial Program Loader.
rfs_mrom_bank9.asm Monitor 9 4 KB RFS-Meldungstexte-Repository.
CP/M 2.2 liefert 47 KB nutzbares Programm-RAM. CCP und BDOS befinden sich im RAM und koennen von grossen Anwendungen ueberschrieben werden (sie werden beim Warmstart neu geladen). Das CBIOS lebt vollstaendig in Monitor-ROM-Bank 2 und User-ROM-Baenken 12–15 und verbraucht kein Programm-RAM.
Die Monitor-ROM erzeugt zur Build-Zeit ausserdem mehrere zusaetzliche Varianten-Images: Hi-Load-Varianten von SA-1510 und 80c SA-1510 (verwendet, wenn das DRAM den Bereich 0x0000–0xCFFF ueberspannen muss) sowie Kuma-80-Varianten (ausgewaehlt ueber das Flag KUMA80_ENA).

SD Card Filing System (SDCFS)

Anstatt FAT zu implementieren (was fuer die verfuegbaren 2-KB-ROM-Baenke zu gross waere), verwendet RFS ein speziell entwickeltes Dateisystem namens SD Card Filing System (SDCFS). Das Design priorisiert Einfachheit und einen kompakten ROM-Footprint gegenueber Flexibilitaet.

Verzeichnisstruktur
Jedes SDCFS-Laufwerks-Image enthaelt ein flaches Verzeichnis mit bis zu 256 Eintraegen. Jeder Eintrag ist genau 32 Bytes gross und basiert auf dem Standard-MZF-Band-Header-Format:
Feld Bytes Beschreibung
FLAG1 1 Bit 7 = 1: gueltiger Eintrag. Bit 7 = 0: inaktiv / geloescht.
FLAG2 1 MZF-Ausfuehrungstyp (0x01 = Binaerprogramm).
FILE NAME 17 Standard 17-Zeichen MZF-Dateiname (Sharp-Zeichencodierung).
START SECTOR 4 Erster Sektor innerhalb dieses Laufwerks-Images, an dem der Datenblock der Datei beginnt.
SIZE 2 Tatsaechliche Byte-Anzahl der Dateidaten.
LOAD ADDR 2 Z80-RAM-Adresse, in die die Dateidaten geladen werden.
EXEC ADDR 2 Automatische Ausfuehrungsadresse fuer Binaerdateien (Sprung nach dem Laden).
RESERVED 3 Derzeit nicht verwendet.
Das Verzeichnis belegt die ersten 8 KB jedes Laufwerks-Images (256 Eintraege x 32 Bytes). Die Dateidaten folgen unmittelbar, beginnend an der 256. 32-Byte-Grenze. Jeder Datei wird ein fester 64-KB-Block zugewiesen — passend zur maximalen CMT-Band-Blockgroesse — was das Layout trivial einfach haelt und SD↔Band-Kopien zu einem direkten Byte-fuer-Byte-Transfer macht.

SD-Karten-Layout 
ADDRESS    CONTENT
────────────────────────────────────────────────────────────
0x00000000  RFS DRIVE 0
              0x00000000–0x00001FE0  Directory (256 × 32 B)
              0x00002000–0xFF2000    File blocks (256 × 64 KB)
0x01002000  RFS DRIVE 1  (same structure)
...
0x09012000  RFS DRIVE 9  (same structure)
0x0A014000  (padding to 256 MB boundary)
────────────────────────────────────────────────────────────
0x10000000  CP/M DISK IMAGE 0   (16 MB — 32 sectors × 1024 tracks)
0x11000000  CP/M DISK IMAGE 1
...
0xXX000000  CP/M DISK IMAGE 6
────────────────────────────────────────────────────────────
Es wird keine Partitionstabelle geschrieben. Das SDCFS-Image beginnt bei Byte 0 der SD-Karte. CP/M-Disk-Images beginnen an der 256-MB-Grenze, um Platz fuer alle 10 RFS-Laufwerke zu lassen, unabhaengig davon, wie voll sie sind.

CP/M 2.2-Implementierung

Boot-Prozess
Der CP/M-Boot unter RFS erfolgt in zwei Phasen:
  1. Phase 1 — AFI-Boot: Der originale MZ-80A AFI (Auto Floppy Interface) ROM-Code bei 0xF000 liest den ersten Sektor der Floppy oder den SD-Karten-Bootblock. Er prueft auf die Markierungsbytes 0x02 + "IPLPRO" bei Byte 0 (die Signatur einer bootfaehigen MZ-80A CP/M-Disk). Falls gefunden, uebergibt er die Kontrolle an den eingebetteten Second-Stage-Loader in diesem Sektor.
  2. Phase 2 — CCP+BDOS+CBIOS laden: Der Second-Stage-Loader liest CCP, BDOS und CBIOS von der Disk in den RAM ab 0x9C00. Sobald geladen, wird der Cold-Boot-Einstiegspunkt des CBIOS aufgerufen. Das CBIOS konfiguriert die Hardware (Tastatur, Bildschirm, Disk-Laufwerke) und uebergibt die Kontrolle an den CCP bei 0x9C00.

CBIOS-Architektur
Das Custom BIOS (CBIOS) ist auf fuenf ROM-Module verteilt, um in den verfuegbaren Bank-Speicher zu passen:
Modul ROM-Position Inhalt
cbios.asm MROM Bank 2 (0xC000–0xCFFF) CBIOS-Einstiegspunkte (alle 17 API-Vektoren), Cold/Warm-Boot, Interrupt-Handler, ROM-Disk-Controller, Disk-Parametertabellen.
cbios_bank1.asm UROM Bank 12 Audio (Signalton, Melodie), Echtzeituhr-Routinen, Tastatur-Handler mit Auto-Repeat.
cbios_bank2.asm UROM Bank 13 Bildschirmtreiber (Zeichenausgabe, Scrollen, Cursor), ANSI-Terminal-Emulator (VT52/VT100-Teilmenge).
cbios_bank3.asm UROM Bank 14 SD-Karten-Disk-Treiber — liest und schreibt 128-Byte-CP/M-Sektoren aus SDCFS-Laufwerks-Images ab der 256-MB-Grenze.
cbios_bank4.asm UROM Bank 15 Floppy-Disk-Controller — Standard-Unterstuetzung fuer 8-Zoll-/5,25-Zoll-Laufwerke fuer physische CP/M-Disks.

CBIOS-API
Das CP/M CBIOS implementiert alle 17 Standard-CP/M 2.2-API-Einstiegspunkte:
Einstiegspunkt Beschreibung
BOOT Kaltstart — initialisiert alle Hardware, richtet die Disk-Parametertabellen ein, ruft CCP auf.
WBOOT Warmstart — stellt den Hardware-Zustand wieder her, laedt CCP+BDOS von Disk neu, ruft CCP auf.
CONST Konsolenstatus — gibt 0xFF zurueck, wenn eine Taste wartet, 0x00 wenn nicht.
CONIN Konsoleneingabe — wartet auf einen Tastendruck und gibt den ASCII-Code zurueck.
CONOUT Konsolenausgabe — schreibt ein Zeichen auf den Bildschirm.
LIST Druckerausgabe — gibt ein Zeichen an den angeschlossenen Drucker aus.
PUNCH Lochstreifen-/Bandausgabe — gibt an das Lochstreifen-Geraet aus.
READER Lesereingabe — liest vom Lochstreifen-Leser-Geraet.
HOME Sucht auf Spur 0 der aktuell ausgewaehlten Disk.
SELDSK Waehlt ein Disk-Laufwerk (A:–G:) aus und gibt die Adresse des Disk-Parameter-Headers zurueck.
SETTRK Setzt die Disk-Spur fuer die naechste Lese- oder Schreiboperation.
SETSEC Setzt den Disk-Sektor fuer die naechste Lese- oder Schreiboperation.
SETDMA Setzt die Disk-Speicheradresse — wohin Daten gelesen oder woher geschrieben werden.
READ Liest einen 128-Byte-Sektor von der ausgewaehlten Disk in den DMA-Puffer.
WRITE Schreibt einen 128-Byte-Sektor aus dem DMA-Puffer auf die ausgewaehlte Disk.
LISTST Druckerstatus — gibt den Bereitschaftsstatus des List-Geraets zurueck.
SECTRN Sektoruebersetzung — bildet logische Sektornummern ueber die Skew-Tabelle der Disk auf physische Positionen ab.

CP/M-Laufwerkskonfiguration
CP/M-Laufwerke werden waehrend des Kaltstarts vom CBIOS dynamisch erstellt, abhaengig davon, welche Disk-Controller verfuegbar sind. Die Standard-Laufwerkszuordnung auf einem voll ausgestatteten RomDisk-/picoZ80-System ist:
CP/M-Laufwerk Controller Image
A: SD-Karte CPM_SYSTEM — Betriebssystemprogramme, Turbo Pascal, Hi-Soft C, Fortran 80, MS-BASIC 80
B: SD-Karte Pascal MTP v5.61, Turbo Pascal v3.00a, Pascal User Group Disks
C: SD-Karte PLI, PLM 80, WordStar v3.0/v3.3/v4.0
D:–G: SD-Karte Grant Searle CP/M-Sammlung Disks C0–F9

Build-System

RFS baut auf **Linux** (Debian/Ubuntu), **macOS** und **Windows** (ueber WSL2). Das Build-System ist fast vollstaendig im Repository enthalten. Der empfohlene Weg zum Bauen ist das automatisierte Setup-Skript fuer Ihre Plattform (siehe Automatisiertes Setup und Build unten); die nachfolgenden manuellen Flags und Schritte sind fuer fortgeschrittene Benutzer und Teil-Builds gedacht.

Voraussetzungen
Werkzeug Zweck
Java JRE 8+ Fuehrt den GLASS Z80-Assembler aus (tools/glass.jar). java muss im PATH liegen.
bash Alle Build-Skripte sind bash-Shell-Skripte.
perl Erforderlich fuer tools/mzftool.pl zur MZF-Dateibearbeitung.
gcc / make Kompiliert cpmtools beim ersten Build aus dem Quellcode (automatisch).
dd, cat, stat Standard-Linux-Dienstprogramme, die von den Packaging-Skripten verwendet werden.
Der GLASS Z80-Assembler ist in tools/glass.jar gebuendelt — keine separate Installation erforderlich.

Automatisiertes Setup und Build (empfohlen)
Das automatisierte Setup-Skript fuer Ihre Plattform installiert die Voraussetzungen, klont das Repository (falls Sie sich nicht bereits in einem Checkout befinden), laedt die Inhalts-Images herunter, schreibt die Umgebungsdatei und bietet an, den ersten Build auszufuehren — alles interaktiv, mit sinnvollen Standardwerten, die Sie durch Druecken von Enter uebernehmen koennen. Jedes Skript ist eigenstaendig: Kopieren Sie nur die einzelne Datei fuer Ihre Plattform und fuehren Sie sie aus.

macOS / Linux / WSL — setup_RFS.sh

chmod +x setup_RFS.sh
./setup_RFS.sh

Windows 10 / 11 — setup_RFS_windows_native.ps1 (empfohlen — nativ, kein WSL). In PowerShell:

Set-ExecutionPolicy -Scope Process -ExecutionPolicy Bypass
.\setup_RFS_windows_native.ps1

Das native Skript verwendet winget, um Git for Windows (bash, coreutils, perl, curl) und eine Temurin JRE (fuer den GLASS-Assembler) zu installieren, klont das Repository, holt das Inhaltspaket und fuehrt ./build.sh ueber Git Bash aus — ohne WSL, Docker oder Neustart. Zwei vorgefertigte Host-Werkzeuge (tools/cpmcp.exe, tools/sdtool.exe) werden mitgeliefert, sodass unter Windows kein C-Compiler benoetigt wird.

Windows 10 / 11 — setup_RFS_windows.ps1 (Alternative — WSL2 / Ubuntu). In einer Administrator-PowerShell:

Set-ExecutionPolicy -Scope Process -ExecutionPolicy Bypass
.\setup_RFS_windows.ps1

Diese WSL-Variante installiert WSL2 + Ubuntu, falls noch nicht vorhanden (ein einmaliger Neustart ist erforderlich — neu starten, Ubuntu einmal starten, um Ihren Linux-Benutzer anzulegen, dann erneut ausfuehren), und fuehrt anschliessend setup_RFS.sh innerhalb von Ubuntu aus. Bevorzugen Sie das native Skript, sofern Sie nicht ausdruecklich eine WSL-Umgebung wuenschen.

Fragen, die das Setup stellt, und was zu tun ist. Jede Eingabeaufforderung hat einen sicheren Standardwert in Klammern — der Grossbuchstabe ist der Standard, sodass Druecken von Enter ihn uebernimmt.

Nur Windows (PowerShell, bevor das Linux-Setup laeuft):

Eingabeaufforderung Standard Was zu tun ist
Continue anyway? [y/N] (falls nicht als Administrator gestartet) Nein N, dann PowerShell als Administrator neu oeffnen — die Installation von WSL erfordert Administratorrechte.
Install WSL2 + Ubuntu now? [y/N] (falls WSL/Ubuntu fehlt) Nein y — Windows installiert WSL2 + Ubuntu und fordert Sie dann zum Neustart auf; starten Sie danach Ubuntu einmal, um Ihren Benutzer anzulegen, und fuehren Sie das Skript erneut aus.
Repo URL [https://git.eaw.app/eaw/RFS.git] oeffentliches Repo Enter fuer das oeffentliche Repo oder eine andere URL einfuegen (z. B. das private Entwicklungs-Repo).

macOS / Linux / WSL (Linux/Ubuntu-Shell):

Eingabeaufforderung Standard Was zu tun ist
Install now? [Y/n] (falls Werkzeuge fehlen) Ja Enter — installiert fehlende Werkzeuge ueber apt/dnf/pacman oder Homebrew (macOS); fragt ggf. nach sudo. macOS loest zudem die Xcode CLT aus und benoetigt Homebrew.
Repo URL [https://git.eaw.app/eaw/RFS.git]: (falls nicht bereits in einem Checkout) oeffentliches Repo Enter fuer oeffentlich oder die private Repo-URL einfuegen. (Unter Windows uebersprungen — bereits gewaehlt.)
Install directory [~/RFS]: (beim Klonen) ~/RFS Enter fuer ~/RFS oder einen Pfad eingeben.
Remove <dir> and re-clone …? [y/N] (falls dieses Verzeichnis ein anderes Repo enthaelt) Nein y nur, wenn Sie sicher sind; andernfalls N und ein anderes Verzeichnis waehlen.
Download and install them now? [Y/n] (~110 MB Inhalt) Ja Enter, um die MZF-/Disk-/CP/M-/BASIC-Inhalte zu holen (fuer einen vollstaendigen Build erforderlich); n nur, falls ein paralleler SharpSoft-Checkout sie bereits bereitstellt.
Run the first build now (./build.sh -m …)? [Y/n] Ja Enter, um sofort zu bauen (verifiziert die Umgebung). Der erste Build verwendet -m, um MZF → MZB/ zu verarbeiten.

Sie werden moeglicherweise auch nach Ihrem sudo-Passwort und Ihren git-Anmeldedaten gefragt (privates Repo).

Nach dem Setup bauen Sie erneut mit ./build.sh -m (erster Build), danach ./build.sh; unter macOS zuvor source ./rfs_env.sh. build.sh baut standardmaessig alle Varianten; uebergeben Sie einen Variantennamen (sfd700, romdisk_mz80a, picoz80_mz80a, picoz80_kuma, picoz80_mz700, picoz80_mz1500, picoz80_mz80k), um nur eine zu bauen — die Auswahl einer Variante konfiguriert die Build-Flags automatisch. Optionen: -m (MZF verarbeiten), -s (gemeinsame Assemblierung ueberspringen), -c (clean), -v (ausfuehrlich), -h (Hilfe).

Fortgeschritten: Build-Flags (manuell)
Fuer die meisten Builds benoetigen Sie dies nicht — build.sh <variante> setzt diese automatisch. Um ein Ziel von Hand zu konfigurieren, bearbeiten Sie asm/include/rfs_definitions.asm und setzen Sie genau ein Ziel-Flag auf 1 (alle anderen muessen 0 sein):
Flag Ziel
BUILD_ROMDISK EQU 1 RomDisk-Karte
BUILD_SFD700 EQU 1 SFD-700 Floppy-Schnittstelle
BUILD_PICOZ80 EQU 1 picoZ80-Platine
Zusaetzliche optionale Feature-Flags:
Flag Standard Beschreibung
KUMA80_ENA 0 Auf 1 setzen, wenn das Kuma 40/80-Spalten-Upgrade verbaut ist.
VIDEOMODULE_ENA 0 Auf 1 setzen, wenn das 40/80-Farb-Videomodul verbaut ist.
FUSIONX_ENA 0 Auf 1 setzen, wenn auf der tranZPUter FusionX-Platine ausgefuehrt.
HW_SPI_ENA 1 Hardware-SPI (RomDisk v2+-PCB). Fuer alle aktuellen Platinen auf 1 belassen.
SW_SPI_ENA 0 Software-Bit-Bang-SPI (RomDisk v1 ueber Parallelport).
ENADEBUG 0 Aktiviert Debug-Ausgabe zur Assemblierzeit.

Manuelle Build-Schritte und was build.sh tut
Wenn Sie das Setup-Skript nicht verwenden moechten (oder einen CI-Build skripten), klonen und bauen Sie direkt. Sie muessen die Voraussetzungen bereits installiert haben und bei einem frischen, eigenstaendigen Klon die Inhalts-Images selbst holen (oder setup_RFS.sh ausfuehren, das dies fuer Sie erledigt). 
git clone --recurse-submodules https://git.eaw.app/eaw/RFS.git
cd RFS

# Full build — assembles all ROMs, packages images, builds SD card image:
./build.sh

# Full build including reprocessing all MZF application files
# (only needed when files in MZF/ have changed):
./build.sh -m
build.sh fuehrt die folgenden Schritte der Reihe nach aus:
  1. Kompiliert cpmtools aus dem Quellcode (nur beim ersten Lauf) und fuegt es dem PATH hinzu.
  2. tools/assemble_rfs.sh — assembliert rfs.asm und rfs_mrom.asm zu roms/rfs.rom und roms/rfs_mrom.rom.
  3. tools/assemble_cpm.sh — assembliert das CP/M 2.2 CBIOS und CCP+BDOS zu roms/*.rom.
  4. tools/assemble_roms.sh — assembliert alle Monitor-Varianten und MZF-Anwendungen. Behandelt die vier MS-BASIC-Build-Varianten, indem vor jedem Durchlauf ein BUILD_VERSION EQU nach include/msbasic_buildversion.asm geschrieben wird.
  5. tools/make_roms.sh — packt ROM- und MZF-Binaerdateien in Flash-ROM-Images fuer jedes Ziel.
  6. tools/make_cpmdisks.sh — erstellt CP/M-Disk-Images im RAW-Format (fuer SD-Karte) und im CPC Extended Disk Format (fuer Floppy-Emulatoren).
  7. tools/make_sdcard.sh — kombiniert 10 RFS-Laufwerks-Images und 7 CP/M-Disk-Images zum finalen SD-Karten-Image.

Ausgabedateien
Nach einem erfolgreichen Build enthaelt das Verzeichnis roms/:
Datei Flash-Chip Beschreibung
MROM_ROMDISK_256.bin Monitor-ROM-Flash Monitor-ROM fuer RomDisk: SA-1510, 80c SA-1510, CP/M CBIOS, RFS mrom utils, 1Z-013A Monitore, ASM/DASM Opcode-Tabellen, IPL und Meldungstexte ueber 16x4 KB Seiten.
MROM_PICOZ80_256.bin Monitor-ROM-Flash Monitor-ROM fuer picoZ80 (Bank-Reihenfolge unterscheidet sich von RomDisk).
USER_ROM_256.bin User-ROM 1 Flash RFS-Baenke 0–11, CP/M CBIOS-Baenke 12–15, CP/M 2.2-Image, gepackte MZF-Anwendungen.
USER_ROM_II_256.bin User-ROM 2 Flash Zusaetzliche MZF-Anwendungen.
USER_ROM_III_256.bin User-ROM 3 Flash Zusaetzliche MZF-Anwendungen.
SFD700_256.bin SFD-700 Flash AFI-ROMs + RFS-Firmware + ROM-Dateisystem.
SHARP_MZ80A_RFS_IMAGE_0–9.img SD-Karte Einzelne RFS-Laufwerks-Images (eines pro Laufwerk 0–9).
SHARP_MZ80A_RFS_CPM_IMAGE_1.img SD-Karte Kombiniertes Image: 10 RFS-Laufwerke + 7 CP/M-Disk-Images. Schreiben Sie dieses auf die SD-Karte.

Anwendungen zu den ROM-Laufwerken hinzufuegen
Anwendungsdateien im MZF-Format muessen vor der Aufnahme in die ROM-Laufwerke in sektor-aufgefuellte Binaer-Images konvertiert werden. Legen Sie MZF-Dateien im passenden Unterverzeichnis unter MZF/ ab und fuehren Sie dann aus: 
tools/processMZFfiles.sh
Dies erzeugt 128-Byte- und 256-Byte-sektor-aufgefuellte Images in MZB/. Um auszuwaehlen, welche Anwendungen in jedem ROM-Laufwerk erscheinen, bearbeiten Sie tools/make_roms.sh und passen die addMZFToROMImageList-Aufrufe an: 
# Format: addMZFToROMImageList <ROMDISK> <SFD700> <picoZ80> <reserved> "<path>"
#
# Include in all builds:
addMZFToROMImageList 1 1 1 0 "${MZB_PATH}/Common/sa-5510_rfs.${SECTORSIZE}.bin"
#
# RomDisk and picoZ80 only (no SFD700 — needs SD card):
addMZFToROMImageList 1 0 1 0 "${MZB_PATH}/MZ-80A/defender.${SECTORSIZE}.bin"
Anwendungen werden in der aufgelisteten Reihenfolge gepackt und fuellen zuerst User-ROM 1, dann User-ROM 2 und 3. Platzieren Sie die am haeufigsten verwendeten Anwendungen oben in der Liste.

Build-Werkzeuge-Referenz
Werkzeug Beschreibung
build.sh Top-Level-Build-Skript. Mit -m werden zusaetzlich MZF-Dateien neu verarbeitet.
tools/assemble_rfs.sh Assembliert die RFS-Kernmodule.
tools/assemble_cpm.sh Assembliert CP/M 2.2 CBIOS und Kernel.
tools/assemble_roms.sh Assembliert Monitor-Varianten und MZF-Anwendungsbinaerdateien.
tools/make_roms.sh Packt Binaerdateien in Flash-ROM-Images.
tools/make_cpmdisks.sh Erstellt CP/M-Disk-Images.
tools/make_sdcard.sh Kombiniert Images zum finalen SD-Karten-Image.
tools/processMZFfiles.sh Konvertiert MZF-Dateien zu sektor-aufgefuellten Binaerdateien in MZB/.
tools/mzftool.pl Erstellt, extrahiert und inspiziert Images im MZF-Format.
tools/sdtool Erstellt das RFS-SD-Karten-Verzeichnis und befuellt es mit Dateien.
tools/nasconv Konvertiert NASCOM-Kassetten-Images in das MZ-80A-ladbare Format und ordnet MS-BASIC-Token neu zu.
tools/glass.jar Gebuendelter GLASS Z80-Assembler (Java). Wird von allen Assembler-Skripten verwendet.
tools/MZFD/MZFDTool Erstellt und verwaltet rohe Floppy-Disk-Images fuer den MZ-700 FDC. Befehle: format, dir, add, extract, boot. Standard-Image: MZ700.img.
tools/MZQD/MZQDTool Erstellt und verwaltet QD-Images fuer das MZ-700 Quick-Disk-System. Befehle: format, dir, add. Standard-Image: MZ700.qd.
cpmtools/ Quellcode fuer cpmcp, cpmls, cpmrm usw. Wird beim ersten Build kompiliert.

Ressource Link
RFS-Projektseite /de/sharpmz-upgrades-rfs/
RFS-Benutzerhandbuch /de/sharpmz-upgrades-rfs-usermanual/
RFS-Entwicklerhandbuch /de/sharpmz-upgrades-rfs-developersguide/
RFS-Galerie /de/sharpmz-upgrades-rfs-gallery/
CP/M auf MZ-80A Hinweise Enthalten in _pages/MZ80A_RFS_CPM_README.md
SFD-700 mkII Technischer Leitfaden /sfd700-technicalguide/
picoZ80 Technischer Leitfaden /de/picoz80-technicalguide/
GLASS Z80-Assembler Enthalten in tools/glass.jar