CP/M v2.23

Panoramica

Processo di Avvio del CP/M

L’avvio del CP/M avviene in due fasi:

1. Usando il software di controllo Floppy Disk AFI originale, leggere un settore di boot invertito, verificare che contenga a 0x0000 il codice di controllo 0x02 + “IPLPRO”, quindi passare il controllo al boot loader incapsulato
2. Caricare, a partire da 0x9C00, il CCP, il BDOS e il CBIOS. Il CBIOS prende ora il controllo e applica un formato di disco diverso e usa una logica del controller FDC diversa (cioe’ re-inverte i dati).

CBIOS

Per creare un CBIOS occorre fornire i seguenti metodi API:

Quindi, per scrivere il CBIOS, occorre programmare i seguenti sotto-moduli del firmware:

Tutta questa funzionalita occupa spazio ed e stata ripartita come segue:

Unita Disco CPM

L’ordinamento delle unita e mostrato nella tabella seguente. I dischi CP/M originali MZ-80K (e MZ-80A) letti tramite la scheda MZ80AFI appaiono come le unita Floppy Disk in questa tabella — tipicamente C: e D: quando sono presenti anche un’unita ROM e/o una scheda SD.

Caratteristiche

Oltre alla funzionalita BIOS standard, le seguenti caratteristiche sono state aggiunte al CBIOS.

• Real Time Clock con granularita di 50mS
• Tastiera pilotata da interrupt con buffer e ripetizione automatica.
• Blocco tasti tri-modale, Normal, Caps Lock, Shift Lock
• Funzionalita Terminale ANSI
• Unita Floppy Disk riassegnabili di dimensione 1.44M, 720K e 320K
• Avvio e lettura diretti di dischi CP/M originali (non convertiti) MZ-80K tramite la scheda MZ80AFI, rilevati automaticamente in base alla dimensione del settore e montati come unita C:/D:
• Unita ROM riassegnabili di dimensione 240K (modificabile tramite config)
• Hard disk su scheda SD da 16Mb riassegnabili.
• Uscita al Monitor tramite SHIFT+GRAPH+BREAK.

Configurazione e compilazione automatizzate (consigliato)

macOS / Linux / WSL — setup_RFS.sh

chmod +x setup_RFS.sh
./setup_RFS.sh

Windows 10 / 11 (nativo — consigliato) — setup_RFS_windows_native.ps1, da un prompt PowerShell:

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

Windows 10 / 11 (tramite WSL2) — setup_RFS_windows.ps1, da una PowerShell come Amministratore:

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

Gli script rispettano le variabili d’ambiente RFS_REPO_URL (predefinito https://git.eaw.app/eaw/RFS.git) e RFS_FILES_URL (posizione del bundle di contenuti) per sovrascrivere i prompt interattivi. La compilazione scrive le immagini Monitor/User ROM (con il CBIOS CP/M e l’applicazione MZF CP/M incorporati) e l’immagine della scheda SD contenente le immagini disco CP/M nella directory roms/. Per la procedura completa passo passo, vedere la Guida tecnica RFS — Sistema di build.

Compilazione del CPM

Per realizzarlo servono diversi strumenti e al momento e un processo piuttosto manuale.

Percorsi

Per facilitare la lettura, le seguenti abbreviazioni si riferiscono al corrispondente percorso in questo capitolo.

Strumenti

Z80 Glass Assembler - Un assemblatore Z80 per convertire i file Assembly in codice macchina.
samdisk - Uno strumento multi-OS a riga di comando per la manipolazione di dischi a basso livello.
cpmtools - Uno strumento multi-OS a riga di comando per la manipolazione di dischi CP/M.
CPMToolsGUI - Uno strumento GUI per Windows per la manipolazione di dischi CP/M.
z88dk - Un eccellente kit di sviluppo C per la CPU Z80.
sdcc - Un altro eccellente Small Device C compiler, lo Z80 e uno dei suoi target. z88dk fornisce una versione migliorata (per lo Z80) di questo strumento all’interno del suo pacchetto.

Software

La compilazione delle immagini software puo essere fatta clonando il repository ed eseguendo alcuni degli script shell e dei binari forniti.

Il sistema CP/M e costruito in 4 parti,

1. il cpm22.bin che contiene il CCP, il BDOS e uno stub del CBIOS.
2. il CBIOS bancato che ha il suo sorgente primario in una ROM da 4K e 4 ROM bancate da 2K. Questi
   sono generati per essere aggiunti alla Banked Monitor ROM dell'RFS e alla Banked User ROM.
3. fino a 2 (attualmente) unita ROM CP/M in sola lettura che possono essere assegnate a qualsiasi lettera
   di unita CP/M.
4. conversione dei binari generati al punto 1. e 3. in immagini MZF settorizzate adatte
   all'aggiunta diretta nel Rom Filing System come un qualsiasi altro programma.

Tutto quanto sopra e codificato nello script bash assemble_cpm.sh che puo essere eseguito come segue:

cd <software>
tools/assemble_cpm.sh

Lo script e attualmente impostato per generare 1 unita ROM CPM in sola lettura. Per aggiungere una seconda unita ROM CPM, segui queste istruzioni:

1. Modifica lo script <tools>/make_cpmdisks.sh e cambia la
   variabile:
   da BUILDCPMLIST="cpm22 CPM_RFS_1"
   a  BUILDCPMLIST="cpm22 CPM_RFS_1 CPM_RFS_2"

   cambia la variabile:
   da SOURCEDIRS="CPM_RFS_[1] CPM[0-9][0-9]_* CPM_MC_5 CPM_MC_C? CPM_MC_D? CPM_MC_E? CPM_MC_F? CPM[0-9][0-9]_MZ800*" a
   a  SOURCEDIRS="CPM_RFS_[1-2] CPM[0-9][0-9]_* CPM_MC_5 CPM_MC_C? CPM_MC_D? CPM_MC_E? CPM_MC_F? CPM[0-9][0-9]_MZ800*"
   
2. Crea una directory (se non esiste): 
   <CPM>/CPM_RFS_2

3. Riempi la directory con i file CPM richiesti da collocare nella ROM.

4. Costruisci l'immagine eseguendo lo script make_cpmdisks.sh o come parte della sequenza di comandi elencata sotto.

Per usare il CPM, e necessario creare le immagini MonitorROM e USERROM che possono essere programmate nelle 2x512KByte Flash RAM. Esegui i seguenti comandi per compilare il CPM insieme a tutto l’RFS, le ROM e le applicazioni in ROM:

cd <software>
tools/assemble_cpm.sh
tools/assemble_rfs.sh
tools/assemble_roms.sh
tools/make_cpmdisks.sh
tools/make_roms.sh
tools/make_sdcard.sh

L’output dei comandi sopra sono le immagini ROM <roms>/MROM_256.bin e <roms>/USER_ROM.256.bin che devono essere programmate nelle Flash RAM da 512Kbyte e inserite negli zoccoli sull’ adattatore RFS.

Le immagini dei dischi CPM si trovano in <CPM>/1M44/RAW per le immagini raw o in <CPM>/1M44/DSK per le immagini dei dischi in formato CPC Extended. Queste immagini sono costruite dalle directory in <CPM>, ogni directory che inizia con CPM* viene impacchettata in un’immagine di unita da 1.44MB. NB. Inoltre, le directory sono anche impacchettate in tutti gli altri dischi supportati come immagini in una directory corrispondente, cioe’ <CPM>/SDC16M per l’immagine dell’unita scheda SD da 16MB.

L’immagine della scheda SD si trova in <roms>/SHARP_MZ80A_RFS_CPM_IMAGE_1.img che contiene l’immagine del disco RFS <roms>/SHARP_MZ80A_RFS_IMAGE_1.img all’inizio seguita da sette immagini di unita in formato CPM che, come sopra, sono memorizzate in <CPM>/SDC16M/RAW. Queste immagini sono costruite dalle directory in <CPM> ma vengono aggiunte manualmente nelle immagini finali codificando il tutto nello script make_cpmdisks.sh.

Le applicazioni memorizzate nelle unita ROM si trovano nella directory <MZF>. Copia in questa directory tutte le applicazioni che desideri, quindi esegui il seguente comando per elaborarle in immagini arrotondate al settore memorizzate nella directory <MZB>.

cd <software>
tools/processMSFfiles.sh

Le applicazioni effettive che vengono integrate nella ROM sono selezionate nello script <tools>/make_roms.sh. Questo script elenca tutte le applicazioni richieste e ne impacchettera tante quante lo spazio permette nella ROM. Per assicurarti che la tua applicazione appaia in ROM, aggiungila in cima alla lista (solo il nome del file, non l’estensione .MZF), cioe’:

Modifica il file <tools>/make_roms.sh
Individua la riga: ROM_INCLUDE=
Sotto questa riga, aggiungi la tua applicazione nel formato: ROM_INCLUDE+="${MZBPATH}/<LA TUA APPLICAZIONE>.${SECTORSIZE}.bin"
cioe' ROM_INCLUDE+="${MZB_PATH}/A-BASIC_SA-5510.${SECTORSIZE}.bin:"
Salva il file ed esegui i comandi sopra per compilare la MonitorROM e le USERROM.

Formati di Disco

Come ho scoperto, ci sono centinaia di formati di disco CP/M e la sola serie Sharp ne implementa 2-3 per macchina. Nel decidere quale formato usare per questa implementazione del CP/M ho esaminato i formati esistenti. Non avendo accesso a dischi Sharp MZ80A originali e dato che comunque sono in formato invertito non standard, essendo l’MZ80B simile all’MZ80A ma con capacita leggermente superiore, l’MZ800 un ibrido e l’MZ80K a bassa capacita, ho optato per usare i formati standard per Floppy da 1.44MB, 720K da 3.5”, lo stesso formato fisico dei dischi Sharp MZ80A e l’unita ROM da 240K basata su ROM.

I formati che uso possono essere manipolati da cpmtools usando le seguenti definizioni diskdefs, inserisci quanto sopra nel file diskdefs posizionato insieme a cpmtools o CPMToolsGUI per l’uso:

   # 320K Disk for the MZ80A - Same format as the MZ800
   # but implements a cylinder in uniform manner (ie. 1 cyl
   # = 1 track x 2(heads) where as the MZ800 implements as 
   # 160 tracks, 80 x Head 1 0->79 then 80 x Head 2 80->159.
   diskdef MZ80A-A
     seclen 256
     tracks 40
     sectrk 32
     blocksize 2048
     maxdir 64
     skew 0
     boottrk 1
     os 2.2
   end
   
   # A standard format 1.44Mb Floppy format for the MZ80A
   diskdef MZ80A-1440
     seclen 512
     tracks 80
     sectrk 36
     blocksize 2048
     maxdir 128
     skew 0
     boottrk 0
     os 2.2
   end
   
   # A standard format 720K Floppy format for the MZ80A.
   diskdef MZ80A-720
     seclen 256
     tracks 80
     sectrk 36
     blocksize 2048
     maxdir 128
     skew 0
     boottrk 0
     os 2.2
   end
   
   # A 240K Rom Filing System ROM Drive image.
   diskdef mz80a-rfs
     seclen 128
     tracks 15
     sectrk 128
     blocksize 1024
     maxdir 32
     skew 0
     boottrk 0
     os 2.2
   end

   # A 16Mb fixed disk SD Card Image.
   diskdef MZ80A-SDC16M
     seclen 512
     tracks 1024
     sectrk 32
     blocksize 8192
     maxdir 512
     skew 0
     boottrk 0
     os 2.2
   end   

Creazione di un Disco CPM

Per convertire l’immagine, usa uno dei seguenti:

Per le unita da 1.44MB usa:
./samdisk copy <RAW IMAGE FILE, ie. CPM00_SYSTEM.RAW> <DSK IMAGE FILE, ie.CPM00_SYSTEM.DSK> --cyls=80 --head=2 --gap3=78 --sectors=36 --interleave=4
Samdisk riconoscera automaticamente il formato dalla dimensione del file, cioe' 1474560 byte

Per le unita da 720K usa:
./samdisk copy <RAW IMAGE FILE, ie. CPM00_SYSTEM.RAW> <DSK IMAGE FILE, ie.CPM00_SYSTEM.DSK> --cyls=80 --head=2 --gap3=78 --sectors=36 --size=2 --interleave=4
Samdisk riconoscera automaticamente il formato dalla dimensione del file, cioe' 737280 byte

Per le unita MZ80A da 320K usa:
./samdisk copy CPM00_320K_SYSTEM.RAW CPM00_320K_SYSTEM.DSK --cyls=40 --gap3=78 --head=2 --sectors=16
Samdisk riconoscera automaticamente il formato dalla dimensione del file, cioe' 327680 byte

L'unita ROM RFS non necessita di conversione, la funzionalita RFS presuppone un'immagine raw.

NB. Non usare Samdisk v4, ha un bug per cui colloca un settore casuale all'inizio del disco. Molte ore di debug sono andate perse a causa di questo bug. Meglio usare
samdisk v3.8.8

I comandi samdisk sopra creano un’immagine in formato Amstrad CPC Extended DSK che puo essere letta ed elaborata da Lotharek HxCFloppyEmulator o dagli strumenti usati per scrivere floppy disk fisici.

Estrazione di Dischi CP/M MZ80A

Usa samdisk per convertire l’immagine EDSK in un’immagine RAW piatta:

  samdisk copy <MZ80A DISK NAME>.DSK <MZ80A DISK NAME>.RAW --cyls=40 --head=2 --sectors=16 --size=256

Esegui il seguente comando per invertire ogni byte nell’immagine RAW, convertendo il formato invertito dell’MZ-80A in dati standard che CPMTools puo elaborare:

  python3 -c "import sys; sys.stdout.buffer.write(bytes(~b & 0xFF for b in open('<MZ80A DISK NAME>.RAW','rb').read()))" > <MZ80A DISK NAME>_normal.RAW

Usa il diskdef MZ80A-A (definito nella sezione delle disk definitions sopra) con CPMTools per elencare ed estrarre i file dall’immagine elaborata:

  # List files on the disk
  cpmls -f MZ80A-A <MZ80A DISK NAME>_normal.RAW

  # Copy all files to a local directory
  cpmcp -f MZ80A-A <MZ80A DISK NAME>_normal.RAW 0:*.* /output/directory/

Estrazione di Dischi CP/M MZ80K

Usa samdisk per estrarre l’immagine raw da una sorgente EDSK:

  samdisk copy <MZ80K DISK NAME>.DSK <MZ80K DISK NAME>.RAW --cyls=40 --head=1 --sectors=18 --size=128

  # List files (adjust diskdef name to match your MZ-80K diskdef entry)
  cpmls -f mz80k <MZ80K DISK NAME>.RAW

  # Extract all files
  cpmcp -f mz80k <MZ80K DISK NAME>.RAW 0:*.* /output/directory/

Estrazione di Dischi CP/M MZ80B

Usa samdisk per convertire l’immagine EDSK in un’immagine RAW piatta:

  samdisk copy <MZ80B DISK NAME>.DSK <MZ80B DISK NAME>.RAW --cyls=40 --head=2 --sectors=18 --size=256

Applica la stessa inversione dei byte usata per l’MZ-80A per convertire i dati invertiti in formato standard:

  python3 -c "import sys; sys.stdout.buffer.write(bytes(~b & 0xFF for b in open('<MZ80B DISK NAME>.RAW','rb').read()))" > <MZ80B DISK NAME>_normal.RAW

  # List files (adjust diskdef name to match your MZ-80B diskdef entry)
  cpmls -f mz80b <MZ80B DISK NAME>_normal.RAW

  # Extract all files
  cpmcp -f mz80b <MZ80B DISK NAME>_normal.RAW 0:*.* /output/directory/

Estrazione di Dischi CP/M MZ800

Usa samdisk per convertire l’EDSK (Extended DSK, formato creato per la macchina Amstrad CPC, la maggior parte dei dischi MZ800 sembra essere in questo formato) in un’immagine RAW.

  samdisk copy <MZ800 DISK NAME>.DSK <MZ800 DISK NAME>.RAW --cyls=40 --head=2 --sectors=8 --size=256

Esegui i seguenti comandi bash per convertire il disco in formato RAW ottenuto sopra in qualcosa che possa essere letto da CPMTools.

   mv <MZ800 DISK NAME>.RAW workingfile.raw
   > total
   dd if=workingfile.raw of=total count=8192 bs=1
   for i in $(seq 8192 8192 327680); do 
     dd if=workingfile.raw of=blob skip=$i bs=1 count=4096
     cat blob >> total
     echo $i
   done
   for i in $(seq 12288 8192 327680); do
     dd if=workingfile.raw of=blob skip=$i bs=1 count=4096
     cat blob >> total
     echo $i
   done
   mv total <MZ800 DISK NAME>.RAW

Avrai bisogno della seguente definizione diskdefs per leggere i dati dall’immagine RAW elaborata.

   # Definition for the MZ800 CP/M Boot Disk. The reserved
   # track is in inverted data format but this is skipped in
   # CPM Tools.
   diskdef mz800-BOOT
     seclen 256
     tracks 80
     sectrk 16
     blocksize 2048
     maxdir 64
     skew 0
     boottrk 1
     os 2.2
   end

   # Definition for the MZ800 CP/M Data disk. No reserved tracks.
   diskdef mz800-DATA
     seclen 256
     tracks 80
     sectrk 16
     blocksize 2048
     maxdir 64
     skew 0
     boottrk 0
     os 2.2
   end

Archivi CP/M

Ho rimosso gli archivi CP/M da Gitea poiche’ non e il posto per memorizzare/archiviare file. Per favore scarica il file zip se ti servono e scompattalo nella tua directory /software.

I file nell’archivio sono programmi selezionati e provengono da vari archivi CP/M e sono raccolti in directory con la convenzione di denominazione CPM[0-9[0-9]_. E incluso anche (con il dovuto credito e (C) per il suo lavoro nell'assemblare l'archivio) il computer MultiComp di Grant Searle, che e piu computer in uno (o piu tipi di CPU) e una delle sue modalita e l'esecuzione del CP/M. L'archivio di Grant e eccellente e una base ideale per usare il CP/M sull'MZ80A.

Per costruire gli archivi in un set di immagini Floppy da 1.4MB adatte all’uso in un’unita da 3.5” o in un Floppy Emulator, esegui il comando:

cd <software>
tools/make_cpmdisks.sh

I dischi saranno creati nella directory: <CPM>/1M44/DSK.

Questo script costruisce anche le immagini delle unita su scheda SD da 16MB usando una combinazione degli archivi. La combinazione e codificata all’interno dello script.

Manuali CP/M

Guida dello Sviluppatore

Riconoscimenti

Licenze

La Licenza Pubblica Generale GNU v3