tranZPUter SW-700 — Guida Tecnica
Guida Tecnica del tranZPUter SW-700 (Versione Attuale)
Questa guida documenta l'architettura hardware, il meccanismo di bus mastering, le modalita di gestione della memoria, i registri di sistema, l'API di servizio K64F, la commutazione CPU, il modulo video, le specifiche FPGA e il sistema di build per la versione attuale del tranZPUter SW-700 — la scheda di espansione che aggiunge un processore di I/O K64F, un CPLD e un FPGA Altera allo Sharp MZ-700 (e, nella versione attuale, anche allo Sharp MZ-2000).
La versione attuale supporta l'emulazione hardware del MZ-2000 e utilizza FPGA piu grandi (Cyclone IV EP4CE75 o EP4CE115) rispetto alla base v1.2 (Cyclone III EP3C25). Tutto in questa guida si applica all'hardware attuale a meno che non sia esplicitamente indicato un qualificatore di versione (v1.2 / v1.3).
Per l'uso quotidiano e il riferimento ai comandi TZFS vedere il Manuale Utente. Per le spiegazioni del codice sorgente Z80 e FPGA vedere la Guida per Sviluppatori.
Bus Mastering
Il tranZPUter SW-700 si collega al bus di espansione dello Sharp MZ-700 (o MZ-2000). Il suo CPLD monitora il bus e puo attivare la linea
/BUSRQ del Z80 in qualsiasi momento. Quando /BUSRQ viene attivato, lo Z80 completa il suo ciclo macchina corrente e poi mette i suoi bus di indirizzo, dati e controllo in alta impedenza, segnalando il rilascio del bus tramite /BUSAK.
Una volta che lo Z80 rilascia il bus, l'FPGA assume la proprieta di tutti e tre i bus. In questo stato l'FPGA puo agire come:
- Un motore DMA — trasferimento massivo di dati tra i 512 KB di SRAM e la memoria della scheda madre senza coinvolgimento dello Z80.
- Una CPU software — i core T80 o ZPU Evolution eseguono direttamente dalla SRAM, indirizzando l'intero spazio di memoria come se fossero la CPU di sistema.
/BUSRQ lo Z80 recupera i suoi bus e riprende l'esecuzione esattamente dal punto in cui e stato sospeso — tutto lo stato dei registri e preservato perche lo Z80 non e mai stato resettato. Anche il contenuto della SRAM e preservato durante il passaggio, quindi il codice o i dati inseriti dall'FPGA rimangono disponibili per i programmi Z80.
Il CPLD gestisce la traduzione di livello tra i segnali del bus MZ a 5 V e le linee di I/O FPGA a 3,3 V, ed esegue la decodifica degli indirizzi in modo che i registri del tranZPUter appaiano nello spazio di I/O dello Z80 senza entrare in conflitto con le periferiche della scheda madre MZ.
Componenti Hardware
K64F ARM Cortex-M4 (Processore di I/O)
Il NXP/Freescale K64F funziona a 120 MHz e agisce come processore di I/O del sistema. Opera indipendentemente dallo Z80 e dall'FPGA, eseguendo il sistema operativo embedded zOS. Le sue responsabilita sono:
MAX 7000A CPLD (512 Macro Cells)
- Gestione scheda SD — fornisce accesso al file system FAT32 sulla scheda SD. Tutti i file programma MZF, le immagini ROM e i bitstream FPGA sono memorizzati qui.
- Caricamento firmware/ROM — legge le immagini ROM e i bitstream FPGA dalla scheda SD e li carica nei 512 KB di SRAM o nel flash di configurazione FPGA.
- API di servizio TZFS — gestisce le richieste dei programmi Z80 in esecuzione sotto TZFS. Lo Z80 scrive un comando e i parametri in una regione di memoria condivisa a 0xED80, poi attiva il K64F tramite il registro SVCREQ alla porta di I/O 0x68. Il K64F interroga la richiesta, la esegue, scrive i risultati nella memoria condivisa e cancella il flag SVCREQ.
- Sintesi di frequenza CPU — genera un clock CPU alternativo che puo essere commutato sullo Z80 a richiesta, consentendo allo Z80 di funzionare a velocita diverse dalla frequenza nativa della scheda madre MZ.
L'Altera MAX 7000A e un CPLD tollerante a 5 V con 512 macrocelle. Si trova direttamente sul bus di espansione MZ e svolge tre funzioni:
Altera FPGA
- Traduzione di livello — collega i segnali del bus MZ-700/MZ-2000 a 5 V alle linee di I/O FPGA a 3,3 V.
- Logica di bus mastering — attiva
/BUSRQverso lo Z80 e monitora/BUSAKper arbitrare la proprieta del bus tra Z80 e FPGA. - Decodifica indirizzi — mappa i registri di I/O del tranZPUter (0x60–0x6F, 0xA8–0xAD, 0xF0, ecc.) nello spazio di I/O dello Z80 e commuta la SRAM nello spazio degli indirizzi dello Z80 secondo la modalita di gestione memoria TZMM attiva.
Due varianti FPGA sono utilizzate nelle diverse revisioni delle schede:
| Version | Device | Logic Elements | BRAM | Package |
|---|---|---|---|---|
| v1.2 | Cyclone III EP3C25E144C8 | 25K LE | 76 KB | 144-pin TQFP |
| v1.3 | Cyclone IV EP4CE75F484C8 | 75K LE | 360 KB | 484-pin BGA |
| v1.3 | Cyclone IV EP4CE115F484C8 | 115K LE | 480 KB | 484-pin BGA |
L'FPGA implementa:
512 KB di RAM Statica (AS6C4008)
- T80 Soft Z80 — un core CPU compatibile Z80 sintetizzato che prende il controllo dei bus quando il bus mastering e attivo.
- ZPU Evolution Soft CPU — un processore software a 32 bit basato su stack che puo eseguire binari ZPU dalla SRAM.
- Controller video — supporta tutte le modalita video Sharp MZ e fornisce uscita VGA (vedere Modulo Video).
- GPU — primitive grafiche accelerate hardware (cancellazione VRAM, riempimento rettangolo, cancellazione GRAM).
Un singolo componente SRAM AS6C4008 da 512 KB x 8 fornisce la memoria espansa del tranZPUter. Il CPLD pagina diverse regioni di questa SRAM nello spazio degli indirizzi da 64 KB dello Z80 a seconda della modalita TZMM attiva (vedere Modalita di Gestione della Memoria). La SRAM e accessibile sia allo Z80 (tramite il decodificatore di indirizzi del CPLD) che all'FPGA (tramite connessione diretta), e il suo contenuto persiste attraverso i trasferimenti di bus mastering.
Alimentazione
Tre regolatori LDO integrati derivano le linee di alimentazione richieste dall'alimentazione a 5 V del bus di espansione MZ:
| Rail | Consumers |
|---|---|
| 3.3 V | CPLD, K64F, general I/O, SRAM |
| 2.5 V | FPGA I/O banks |
| 1.2 V | FPGA core |
Modalita di Gestione della Memoria
Il CPLD implementa un'unita di gestione della memoria controllata scrivendo un valore di modalita alla porta di I/O 0x60. Ogni modalita determina come le regioni dei 512 KB di SRAM vengono paginate nello spazio degli indirizzi da 64 KB dello Z80 e se la ROM e la RAM della scheda madre MZ o la SRAM del tranZPUter serve ciascun intervallo di indirizzi.
Il registro di modalita e indicato come registro TZMM (tranZPUter Memory Mode). Le modalita principali sono:
| Mode | Value | Description |
|---|---|---|
| TZMM_ORIG | 0x00 | Original MZ-700 mode — mainboard IPL ROM, DRAM, and VRAM visible as normal. tranZPUter SRAM inactive. |
| TZMM_BOOT | 0x01 | tranZPUter SRAM mapped at 0xE800–0xEFFF to hold the TZFS bootstrap. All other addresses use mainboard resources. |
| TZMM_TZFS | 0x22 | TZFS mode — entire 64 KB address space served from tranZPUter SRAM. The K64F has preloaded TZFS code and ROM images. |
| TZMM_CPM | 0x26 | CP/M mode — full 64 KB SRAM mapped, CBIOS and CCP loaded by K64F. |
All'accensione il CPLD parte in modalita TZMM_ORIG (0x00), presentando la mappa di memoria standard del MZ-700. La ROM bootstrap TZFS a 0xE800 commuta su TZMM_BOOT per rendersi visibile, poi commuta su TZMM_TZFS una volta che il K64F ha caricato l'immagine TZFS completa nella SRAM.
TZMM_ORIG (0x00) — Original MZ-700 layout 0x0000–0x0FFF MZ mainboard IPL ROM 0x1000–0xCFFF MZ mainboard DRAM 0xD000–0xDFFF MZ mainboard VRAM / memory-mapped I/O 0xE000–0xE7FF MZ mainboard VRAM extension / I/O 0xE800–0xEFFF MZ mainboard ROM (User ROM area) 0xF000–0xFFFF MZ mainboard ROM / unused TZMM_TZFS (0x22) — Full SRAM mode 0x0000–0xFFFF tranZPUter 512 KB SRAM (64 KB window) TZMM_CPM (0x26) — CP/M mode 0x0000–0xFFFF tranZPUter 512 KB SRAM (64 KB window)
Registri di Sistema
Il tranZPUter mappa i suoi registri di controllo nello spazio degli indirizzi di I/O dello Z80. Tutti i registri sono accessibili con le istruzioni Z80
Mappa dei Registri
IN e OUT. Il CPLD decodifica gli indirizzi di I/O e instrada gli accessi all'hardware appropriato.
Port Register R/W Description ────────────────────────────────────────────────────────────────────────────── 0x60 Memory Management Config W TZMM mode select (see Memory Modes) 0x62 Set CPU Alt Frequency W Switch Z80 clock to K64F-generated alternate frequency 0x64 Set CPU Base Frequency W Switch Z80 clock back to MZ mainboard frequency 0x66 CPU Frequency Change W Set exact CPU frequency in Hz (32-bit value via shared mem) 0x68 Service Request (SVCREQ) W Trigger K64F service request 0x6B System Command Register W System-level commands (reset, mode changes) 0x6C CPU Configuration R/W Select active CPU core (Z80, T80, ZPU Evolution) 0x6D CPU Information R Read available CPU capabilities and soft-CPU presence 0x6E System Configuration R/W System feature flags 0x6F System Information R Board identification and hardware status 0xA8 Video Control R/W Machine model, column width, colour enable, PCG, VGA mode 0xA9 Video Graphics Mode R/W GRAM bank select, VRAM/GRAM output enable, blend operator 0xAA-AC Colour Writer R/G/B W 8-pixel channel filter masks for indirect GRAM writes 0xAD Memory Page / Status R/W GRAM/CGROM CPU enable; H/V blanking status ──────────────────────────────────────────────────────────────────────────────
API di Servizio K64F
Il K64F espone un'API di servizio per i programmi Z80 in esecuzione sotto TZFS. Il meccanismo e una regione di memoria condivisa nella SRAM — lo Z80 scrive un comando e i parametri nella regione, attiva il K64F e attende il completamento. Non e richiesto bus mastering; lo Z80 e il K64F comunicano tramite normali letture e scritture in memoria mentre il K64F monitora il registro SVCREQ.
Meccanismo Richiesta/Risposta
Shared memory base: 0xED80 (in SRAM, visible to Z80 in TZMM_TZFS and related modes) Z80 procedure: 1. Write command code to TZSVCCMD (0xED80). 2. Write parameters to TZSVCP1 onwards. 3. OUT (0x68), A ; assert SVCREQ — wakes K64F 4. Poll TZSVCSTS until non-zero (K64F has completed the request). 5. Read result data from shared memory.Riferimento Comandi di Servizio
La tabella seguente elenca i principali comandi di servizio. I dettagli dei parametri sono documentati nel codice sorgente del firmware TZFS.
| Command | Category | Description |
|---|---|---|
| READDIR | File I/O | Read directory entries from the SD card FAT32 volume |
| LOADFILE | File I/O | Load a named file from SD card into SRAM |
| SAVEFILE | File I/O | Save a region of SRAM as a named file on SD card |
| CPU_SETZ80 | CPU Switch | Activate the physical Z80 (release bus mastering) |
| CPU_SETT80 | CPU Switch | Load T80 firmware and activate the T80 soft Z80 in FPGA |
| CPU_SETZPUEVO | CPU Switch | Load ZPU Evolution firmware and activate the ZPU soft CPU |
| EMU_SETMZ80K | Emulation | Configure FPGA video and I/O to emulate MZ-80K |
| EMU_SETMZ700 | Emulation | Configure FPGA to emulate MZ-700 |
| EMU_SETMZ2000 | Emulation | Configure FPGA to emulate MZ-2000 (current version only) |
Commutazione CPU
Il tranZPUter puo operare con tre scelte di CPU: lo Z80 fisico sulla scheda madre MZ, il T80 soft Z80 implementato nell'FPGA e la CPU software ZPU Evolution a 32 bit implementata nell'FPGA. La commutazione CPU e coordinata tra il programma Z80, il K64F e l'FPGA.
Procedura di Commutazione
- Il programma Z80 emette una richiesta di servizio
CPU_SETT80oCPU_SETZPUEVOtramite l'API K64F (porta 0x68). - Il K64F carica l'immagine firmware richiesta per la CPU target dalla scheda SD nei 512 KB di SRAM.
- Il K64F segnala all'FPGA di attivare il nuovo core CPU. Il CPLD attiva
/BUSRQverso lo Z80. - Una volta che lo Z80 rilascia il bus (
/BUSAKattivato), la CPU software dell'FPGA prende possesso dei bus di indirizzo, dati e controllo e inizia l'esecuzione dalla SRAM. - Lo Z80 fisico rimane mantenuto in stato di bus rilasciato per tutta la durata dell'esecuzione della CPU software.
- Per tornare all'esecuzione Z80, il programma in esecuzione (o il K64F) emette
CPU_SETZ80, causando il rilascio di/BUSRQda parte dell'FPGA. Lo Z80 recupera i suoi bus e riprende. Il contenuto della SRAM e preservato.
| Core | Port 0x6C bits 2:0 | Notes |
|---|---|---|
| Z80 (hard) | 000 | Physical Z80 on MZ mainboard. Default after reset. |
| T80 | 001 | Synthesised Z80-compatible core in FPGA fabric. Full Z80 instruction set. |
| ZPU Evolution | 010 | 32-bit stack-based soft CPU in FPGA. Executes ZPU binaries. |
| Reserved | 011–111 | Not currently assigned. |
Modulo Video
L'FPGA implementa un controller video completo che supporta tutte le modalita di visualizzazione Sharp MZ e aggiunge un framebuffer grafico con uscita VGA. I registri video sono mappati nello spazio di I/O dello Z80 a 0xA8–0xAD (controllo primario), con registri aggiuntivi a 0xD0–0xD7 (palette e parametri di modalita) e 0xF3, 0xF5 (bordo VGA e selezione palette).
Nella versione attuale, il supporto per l'hardware video MZ-2000 e incluso accanto a tutti i modelli MZ precedentemente supportati.
Registri Video Primari (0xA8–0xAD)
Port 0xA8 — Video Control Register Bits 2:0 Machine model select (000=MZ-80K through 111=MZ-2000) Bit 3 Column width: 0 = 40 columns, 1 = 80 columns Bit 4 Colour enable: 0 = monochrome, 1 = colour Bit 5 PCG (Programmable Character Generator) enable Bits 7:6 VGA output mode (00=640x480, 01=800x600, 10=1024x768) Port 0xA9 — Graphics Mode Register Port 0xAA-AC — Colour Writer R/G/B Filters Port 0xAD — Memory Page / Status RegisterFramebuffer Grafico
L'FPGA implementa uno strato grafico 640x200 (o 320x200) accanto al display a caratteri. Il framebuffer e organizzato come tre banchi indipendenti da 16 KB — Rosso, Verde e Blu — che forniscono dati pixel a 3 bit (8 colori).
Uscita VGA
L'FPGA scala il display nativo Sharp MZ ai timing VGA standard. Tre risoluzioni di uscita sono selezionabili. Sull'hardware v1.3, il display a doppio buffer e disponibile in tutte le modalita.
| VGA Mode (bits 7:6) | Output Resolution | Refresh |
|---|---|---|
| 00 | 640 × 480 | 60 Hz |
| 01 | 800 × 600 | 60 Hz |
| 10 | 1024 × 768 | 60 Hz |
Una GPU semplice e accessibile tramite le porte di I/O ?F6 (parametri) e ?F7 (comando/stato). Primitive supportate: cancellazione VRAM, riempimento rettangolo, cancellazione GRAM.
Specifiche FPGA
Riepilogo completo delle capacita per ogni variante FPGA utilizzata sul tranZPUter SW-700:
| Feature | v1.2 (EP3C25) | v1.3 (EP4CE75 / EP4CE115) |
|---|---|---|
| Logic elements | 25K | 75K / 115K |
| On-chip BRAM | 76 KB | 360 KB / 480 KB |
| Package | 144-pin TQFP | 484-pin BGA |
| Soft CPUs | T80, ZPU Evolution | T80, ZPU Evolution |
| MZ video models | MZ-80K/C/1200/80A/700/800/80B | + MZ-2000 (current) |
| VGA output | 640×480, 800×600, 1024×768 | 640×480, 800×600, 1024×768 |
Sistema di Build
Il firmware del tranZPUter SW-700 comprende tre componenti, ciascuno con la propria toolchain: bitstream FPGA (Quartus Prime), firmware K64F (ARM GCC) e software Z80 (assemblatore GLASS). Tutto lo sviluppo viene effettuato sotto Linux.
Il modo raccomandato per ottenere un build funzionante e lo script di setup automatizzato per la propria piattaforma — vedere Setup automatizzato e build subito sotto. Installa le toolchain, costruisce le immagini Docker Quartus e recupera i sorgenti per voi. Il dettaglio componente per componente che segue spiega cosa produce il build e come eseguire gli strumenti manualmente.
Setup automatizzato e build (raccomandato)
Il modo raccomandato per ottenere un build funzionante e lo script di setup automatizzato per la propria piattaforma — vedere Setup automatizzato e build subito sotto. Installa le toolchain, costruisce le immagini Docker Quartus e recupera i sorgenti per voi. Il dettaglio componente per componente che segue spiega cosa produce il build e come eseguire gli strumenti manualmente.
Invece di installare a mano tre versioni di Quartus, le toolchain ARM GCC e Java e Docker, eseguire lo script di setup incluso per la propria piattaforma. Installa gli strumenti di base, installa Java (JRE) per l'assemblatore GLASS Z80 e Docker, costruisce tre immagini Docker Quartus riproducibili, clona il repository
--recurse-submodules (TZFS, zSoft/zOS, zpu) e propone di eseguire il primo build (./build.sh -t all). Quartus stesso non viene installato sull'host — i build di CPLD e FPGA vengono eseguiti all'interno delle immagini Docker. Ogni script e autonomo.
| Script | Platform | Notes |
|---|---|---|
setup_tranZPUter.sh |
Linux / macOS | Installs base tools + Java (JRE) + Docker, builds the three Quartus images, clones into ~/tranZPUter, offers ./build.sh -t all. |
setup_tranZPUter_windows.cmd |
Windows 10 / 11 | Double-click launcher — runs the .ps1 non-interactively and logs to setup_tranZPUter_log.txt. |
setup_tranZPUter_windows_native.ps1 |
Windows 10 / 11 | winget installs Git for Windows + Docker Desktop, builds the Quartus images, clones into %HOME%\tranZPUter, runs ./build.sh -t all via Git Bash. |
Linux / macOS:
chmod +x setup_tranZPUter.sh
./setup_tranZPUter.sh
Windows — doppio clic su setup_tranZPUter_windows.cmd, oppure da PowerShell:
Set-ExecutionPolicy -Scope Process -ExecutionPolicy Bypass
.\setup_tranZPUter_windows_native.ps1
Il setup costruisce tre immagini Docker Quartus gratuite (Web/Lite Edition, senza licenza):
tzpu-quartus:13.0.1 (CPLD MAX7000), tzpu-quartus:13.1 (Cyclone III, SW-700 v1.2) e tzpu-quartus:17.1 (Cyclone IV, SW-700 v1.3 / Fusion). Il build e quindi guidato da build.sh, che esegue Quartus nativamente se viene trovata una versione corrispondente, altrimenti all'interno di queste immagini (Java/GLASS viene sempre eseguito nativamente). Gli output (.pof, .sof, boot flash .jic, immagini ROM/TZFS/CP/M) vengono raccolti sotto ./build/output/.
./build.sh -t all # CPLD + FPGA + software (default: -V v1.3 -M all -D E115 -C emuMZ)
./build.sh -h # list all targets and options
Override utili dell’ambiente:
| Variable (alias) | Purpose |
|---|---|
TZPU_REPO_URL (tranZPUter_REPO_URL) |
Repository URL to clone. Default https://git.eaw.app/eaw/tranZPUter.git. |
TZPU_DIR (tranZPUter_DIR) |
Build in an existing checkout instead of cloning. |
TZPU_ASSUME_YES (tranZPUter_ASSUME_YES)=1 |
Non-interactive; accept all defaults. |
TZPU_QUARTUS_CPLD_IMAGE (tranZPUter_CPLD_IMAGE) |
Override the CPLD image (default tzpu-quartus:13.0.1). |
TZPU_QUARTUS_C3_IMAGE (tranZPUter_FPGA_IMAGE) |
Override the Cyclone III image (default tzpu-quartus:13.1). |
TZPU_QUARTUS_C4_IMAGE |
Override the Cyclone IV image (default tzpu-quartus:17.1). |
Il dettaglio del build manuale componente per componente qui sotto rimane pienamente supportato per gli utenti avanzati e le ricompilazioni parziali.
FPGA — Quartus Prime
L'RTL dell'FPGA e sintetizzato con Altera/Intel Quartus Prime. Container Docker sono forniti nel repository per riprodurre l'ambiente di build esatto per ogni versione.
| Board Version | FPGA Device | Quartus Version |
|---|---|---|
| v1.2 | Cyclone III EP3C25 | 13.1 (last version with Cyclone III support) |
| v1.3 | Cyclone IV EP4CE75 / EP4CE115 | Current Quartus Prime Lite / Standard |
Il firmware K64F (zOS) e costruito con la toolchain ARM bare-metal GCC (
Software Z80 / TZFS — Assemblatore GLASS
arm-none-eabi-gcc). Il punto di ingresso del build e buildhost.sh sotto software.moved.to.TZFS/.
TZFS e il software Z80 associato sono assemblati con l'assemblatore GLASS Z80 (fornito come
tools/glass.jar, richiede Java 8+).
Siti di Riferimento
| Resource | Link |
|---|---|
| tranZPUter SW-700 project page | /sharpmz-upgrades-tranzputer-sw700/ |
| tranZPUter SW-700 User Manual | /sharpmz-upgrades-tranzputer-sw700-usermanual/ |
| tranZPUter SW-700 Developer’s Guide | /sharpmz-upgrades-tranzputer-sw700-developersguide/ |
| Sharp MZ-700 hardware reference | MZ-700 Technical Manual |
| GLASS Z80 Assembler | Bundled in tools/glass.jar |
| Quartus Prime (Intel FPGA) | https://www.intel.com/content/www/us/en/collections/products/fpga/software/downloads.html |