xref: /dports/emulators/yaze-ag/yaze-ag-2.51.0/doc/yaze.doc

This document describes only the features of the old version yaze-1.00.
But read this document because the features which are described here are
also the features of the new yaze-ag-2.20 (this version).

If you want to read about the new features of yaze-ag-2.20 use yaze-ag.doc.

-------------------------------------------------------------------------------

Yet Another Z80 Emulator (yaze-1.00)
====================================

Contents
========

  1. Introduction
  2. Installation and Testing
  3. Command-line options
  4. Bootstrap file formats
  5. Creating bootstrap files
  6. CP/M disks
  7. Benchmarks
  8. Emulating embedded systems
  9. Software sources
 10. Why?


1.  Introduction
================
The README file gives a brief overview of what yaze is and why you
might want to install it.  This package assumes you have a unix system
and that a number of common tools are available on it.


2.  Installation and Testing (yaze-1.00)
========================================
First you need to uncompress and untar the archive file, which you
have probably already done if you are reading this.  Go to the
directory under which you want yaze to be unpacked,
e.g. /usr/local/src.  Then, if you have gnu-tar, type
'tar xzf yaze-1.00.tar.gz' and otherwise
'zcat yaze-1.00.tar.gz | tar xf -'.  Change to the newly created
directory yaze-1.00 and edit the Makefile.

If GNU Readline is available on your system you will probably want to
use it with yaze.  Readline comes together with most interactive
programs from the Free Software Foundation, such as gdb and bash.  It
permits command-line editing, history recall and (unix-) filename
completion when used with yaze and cdm.  The include files and library
should be somewhere where your compiler can find them, otherwise you
will have to add the paths to the Makefile.

When you have customized the Makefile, try 'make'.  Yaze was developed
under SunOS5 and I have briefly tried it under Linux and FreeBSD.  You
will have to do some hacking if your system does not support the
termios tty interface.  You will have to do a lot of hacking if your
system does not have memory mapped files via mmap() and munmap().

Once you have a clean make of yaze you can try it out.  WARNING! Yaze
disables all tty interrupts by default, so if you only have 1 terminal
session available it may be difficult to regain control if yaze goes
haywire.  You may want to add the line 'interrupt ^C' (or some other
character) to .yazerc to be safe (though you cannot use that character
under CP/M then).  Under X11 or screen this is not a problem because
you can kill a runaway process from a different window.  The normal
way to leave yaze is to type 'sys quit' at the CP/M A> prompt.

Start yaze by typing 'yaze -v'.  This will use the defaults and give a
verbose account of the system configuration.

---------------------------------------------------------------------------
    $ yaze -v

    Yet Another Z80 Emulator version 1.00, Copyright 1995 Frank D. Cringle.
    yaze comes with ABSOLUTELY NO WARRANTY; for details
    see the file "COPYING" in the distribution directory.

    Running 'yaze.boot'
    bootfile:       /usr/local/lib/yaze.boot
    startup file:   .yazerc
    basepage:       d8
    ccp_base:       d800
    bdos_base:      e000
    bios_base:      ee00
    bios_top:       ee66
    dptable:        fd90
    dirbuf:         ff80

    A>
---------------------------------------------------------------------------

This shows the default values of various parameters which can be
overridden on the command line.  The bootfile will be described in more
detail later.  The basepage is where the CP/M ccp is placed, and the
other addresses follow from that.  The ccp is 800h bytes long and the
bdos is 0e00h long.  The bios occupies only 66h bytes in the Z80 ram,
because all we need is the jump table for 17 vectors and the targets
for these jumps to transfer control to the real bios executing on the
host cpu.  The space between bios_top and dptable is available for
disk allocation vectors.  Dptable has space for the maximum possible
16 disk parameter headers and disk parameter blocks.  The dirbuf is
shared between all disks as in standard CP/M.

Yaze reads the file .yazerc when it starts up and the distributed
.yazerc contains:
    mount a test
    go

The first line mounts the unix directory 'test' as CP/M drive A and
the second line starts the emulator.  Commands such as 'mount' and
'go' can also be entered interactively when the emulator is in
monitor mode.  It starts out in monitor mode (unless the command line
or startup file contain 'go'), and you can get back to monitor mode by
executing the CP/M command 'sys'.  This command is found in the file
sys.com in the test directory.  It is difficult to get out of the
emulator if you do not keep a copy of sys.com accessible on a mounted
disk.

If you execute 'sys' without arguments it takes you into monitor mode,
which is indicated by the $> prompt.  Here a number of commands are
available, including a help command.

---------------------------------------------------------------------------
    A>sys

    $>help
    help        Display this text or give help about a command
    ?           Synonym for `help'
    attach      Attach CP/M device to a unix file
    detach      Detach CP/M device from file
    mount       Mount a unix file or directory as a CP/M disk
    umount      Unmount a CP/M disk
    create      Create a new disk
    interrupt   Set user interrupt key
    go          Start/Continue CP/M execution
    !           Execute a unix command
    quit        Terminate yaze
    time        Display elapsed time since last `time' command
    $>
---------------------------------------------------------------------------

More information about each command is available by entering
'help command'.

---------------------------------------------------------------------------
    $>help help
    help <cmd>                 displays more information about <cmd>

    $>help attach
    attach                     without arguments lists the current attachments
    attach <physdev> <file>    attaches <physdev> to the unix <file>,
    			       where <physdev> is one of ttyin, ttyout,
    			       crtin, crtout, uc1in, uc1out, rdr,
    			       ur1, ur2, pun, up1, up2, lpt, ul1

    $>help detach
    detach <physdev>           closes the file attached to <physdev>
    			       (see attach)

    $>help mount
    mount                      without arguments lists the mount table
    mount -v                   lists the mount table verbosely
    mount <drive> <file>       mounts <file> as CP/M disk <drive>
    			       (a letter from a..p).
    	    If <file> is a plain file it must contain a CP/M filesystem.
    	    If <file> is a unix directory its contents may be accessed
    	       as a read-only CP/M disk
    mount -r <drive> <file>    mounts the <file> read/only.

    $>help umount
    umount <drive>             closes the file associated with <drive>
    			       and frees the resources

    $>help create
    create {flags} <file> {size}  creates a unix <file> initialized as a
    				  CP/M disk of size {size} (default 1MB).
    	   -b <block size>        default 1024 if size < 256K, else 2048
    	   -d <# dir entries - 1> default 1023
    	   -o <track offset>      default 0
    	   -s <sectors per track> default 26
    create <file> 256256          create a raw SSSD disk image

    $>help interrupt
    interrupt <key>            makes <key> interrupt CP/M back to the monitor
    	    <key> may be a 2-digit hex number or ^x where x is one of a..z[\]^_
    	    ^@ makes CP/M uninterruptible (from the keyboard)
    interrupt                  without an argument displays the current setting

    $>help go
    Start/Continue CP/M execution

    $>help !
    !                          escape to a unix shell
    !cmd                       execute unix cmd

    $>help quit
    Terminate yaze

    $>help time
    displays elapsed, user and system time in seconds,
    	     along with simulator options
---------------------------------------------------------------------------

Monitor commands can be abbreviated (e.g. 'm' for 'mount'), except
'quit' must by typed in full.


The yaze-1.00/test directory contains a number of .com files (CP/M
executables).  The quickest way to test the installation is to execute
prelim.com

---------------------------------------------------------------------------
A>dir
PRELIM  .Z80  |  ZEXLAX  .PL   |  ZEXALL  .Z80  |  ZEXDOC  .Z80
PRELIM  .COM  |  ZEXALL  .COM  |  ZEXDOC  .COM  |  SAVAGE  .PAS
SAVAGE  .COM  |  SYS     .AZM  |  SYS     .COM
A>prelim
Preliminary tests complete
A>
---------------------------------------------------------------------------

Zexall.com and zexdoc.com are both derived from zexlax.pl.  They are
designed to exhaustively compare Z80 implementations.  This is done by
executing all practicable instructions for as wide a range of operands
as feasible, and calculating a 32-bit crc of the resulting machine
states.  If the crc values of two implementations match we can be
confident that they are, for practical purposes, identical.

Zexall and zexdoc differ only in that zexall tests all 8 bits in the
flag register for all instruction whereas zexdoc only tests the
documented flag values.

The expected crc values are those produced by a Mostek MK3880-4 CPU,
date code 8010, and confirmed on an Epson PX-8.  Zexall and zexdoc run
about 3.25 hours each on a 4MHz Z80.

Savage.com is a simple benchmark compiled from savage.pas with
Pascal/MT+.  Its execution time depends almost exclusively on the
quality of the run-time library.  Also, Pascal/MT+ only uses 8080
instructions, so it does not say anything about the speed of Z80
extensions.

'make install' puts the binaries in BINDIR (default: /usr/local/bin),
the manual pages in MANDIR (default: /usr/local/man/man1) and the
bootstrap file in LIBDIR (default: /usr/local/lib).


3.  Command-line options
========================
New command line options for yaze-ag-2.01 are described in yaze-ag.doc
chapter 5.

Usage: yaze {flags} {commands}
           -b <file>       boot from this file
           -l <xxxx>       load bootfile at given (hex) address
           -p <xx>         base page (top 2 hex digits of ccp base)
           -s <file>       startup file
           -v              verbose
           -z <xxxx>       (hex) address of z3env (if desired)

If yaze is run without command-line options it loads the bootstrap
file from /usr/local/lib/yaze.boot or, if that does not exist, from
./yaze.boot to address 0d800h and relocates the contents to fit that
base address.  It then looks for a "run control" file .yazerc in the
current directory or, if not found there, $(HOME)/.yazerc.  If an
rc-file is found it is expected to contain a list of monitor commands,
typically mount, attach and go, and these commands are executed.
Finally, any remaining values on the command line are also interpreted
as monitor commands and executed.

If a "go" command was seen in the rc-file or on the command line the
emulator is started, otherwise control is passed to the monitor.

A different bootstrap file can be specified on the command line with
the -b option.  The base page (top 2 hex digits of the ccp location)
can be specified with the -p option.  The bootstrap file can be loaded
at an address other than the base page with the -l option.  The
required contents of bootstrap files are explained in the next
section.

A different startup file from .yazerc can be specified with the -s
option.  Space (1 Kbyte) can be reserved for a Z-system environment at
an address given by the -z flag.  The -v flag produces a configuration
summary.

Any monitor commands on the command line must be quoted if they are
more than one word.  Example:
	yaze "mount b foo" "attach lpt print.out"


4.  Bootstrap file formats
==========================
A bootstrap file contains the Z80 machine code that is executed when
the emulator starts.  Yaze accepts 3 types of bootstrap file:
a) arbitrary code that is loaded to a specified address and executed,
b) a single (non-relocatable) copy of CCP+BDOS that is loaded to the
   CCP base address and started via the BIOS cold boot entry-point and,
c) a double (and thus relocatable) copy of the CCP+BDOS that is
   loaded to the CCP base and if necessary suitably relocated before
   being started via the BIOS cold boot entry-point.

An address given via the -l parameter on the command line indicates
the first type of file.  It might be a bootstrap loader which contains
a clone CP/M for which extra environment data must be set up before
jumping to the BIOS cold boot routine.  Control is passed to the
bootstrap at the address to which it was loaded, with the desired CCP
base address in register HL.

If no -l parameter is present on the command line the size of the boot
file is used to differentiate cases b and c, and subcases.  The CCP
and BDOS might have been assembled from source to run at a fixed
address, in which case the file should be 5632 bytes long (1600h).
Alternatively, the file might have been saved after executing movcpm
on a real CP/M 2.2 system.  In this case it will be between 7808 and
11263 long and CCP will found at offset 880h in the file.

If the input file is twice the length of CCP+BDOS, i.e. 11264 bytes
long, it is assumed to contain 2 copies of the same source, assembled
to run at different 1K boundaries.  It does not matter what the
addresses actually are, yaze takes one copy and adjusts the addresses
(any bytes that differ between the 2 copies are assumed to be the high
byte of an address) to fit the final location.  Similarly, if the
input file is longer than 17407 it is assumed to contain 2 CP/M 2.2
saves after movcpm with different system sizes.


5.  Creating bootstrap files
============================
The bootstrap file distributed with yaze, yaze.boot, is a 2-copy file
containing Don Kirkpatrick et al's D&J ZCPR as CCP and SUPRBDOS by
Herman ten Brugge and Benjamin Ho as BDOS.  These programs claim to be
freely redistributable.  They are both on the Walnut Creek CP/M CDROM
and are also in the oak archives.

I assembled both programs twice, once with P2DOS (the BDOS base
address) set to 0C800H and once with it set to 0CC00H.  The resulting
hex files were loaded with mload and concatenated together, making
sure to pad the lengths of the individual components to 800H/0E00H.
I added an instruction to strip the high bit from console output
characters in SUPRBDOS, because I do not think this should be done in
the BIOS - a debatable position because DR's documentation is
inconclusive on the issue and the original BDOS does not strip the
bit.  I also disabled the "delay 256 characters" feature in SUPRBDOS,
because it was interfering with benchmarking when running yaze with
input redirection.


An easy way to make a boot file on a real CP/M system is:
    B>movcpm 64 *

    CONSTRUCTING 64k CP/M vers 2.2
    READY FOR "SYSGEN" OR
    "SAVE 34 CPM64.COM"
    B>save 34 a:cpm64.com

Then transfer cpm64.com as a binary file to your unix system and
    yaze -b cm64.com

    Yet Another Z80 Emulator version 1.00, Copyright 1995 Frank D. Cringle.
    yaze comes with ABSOLUTELY NO WARRANTY; for details
    see the file "COPYING" in the distribution directory.

    Running 'cpm64.com'

    A>

This works because the default basepage is 0E4H and the CCP is located
at 0E400H in a 64K CP/M system.  You must take this into account when
using other system sizes, e.g.
    yaze -b cpm63.com -p e0


6.  CP/M disks
==============
CP/M version 1.4 used single-sided single-density 8" floppy disks with
77 tracks of 26 128 byte sectors each.  This format and the
arrangement of data within it remained the standard distribution
format for CP/M 2.2, but other formats were now also supported.  This
had advantages and disadvantages.  Double density, double sided disks,
hard disks, other floppy sizes etc. could be used, but there was no
standard method of determining what the format of a particular disk
was.  Tables had to be built into the BIOS which matched the disk in
question.

Yaze does not attempt to access CP/M disks directly.  It assumes that
it is accessing a unix file containing a copy of a CP/M disk.  The
file can contain either a raw copy of a standard single-sided
single-density disk (with sector skew = 6), or a de-skewed copy of any
format with a descriptive header.  The header is recognized when the
file starts with the string "<CPM_Disk>" (a sort of "magic number").

The disk header occupies the first 128 bytes of the file and has the
format:

  0 -   9    <CPM_Disk>
 10 -  31    a null-terminated ascii comment (may be empty)
 32 -  33    sectors per track
 34          block shift factor
 35          block mask
 36          extent mask
 37 -  38    disk size max
 39 -  40    directory max
 41          al0
 42          al1
 43 -  44    check size (always zero)
 45 -  46    track offset
 47 - 127    unused (zeros)

CP/M aficionados will recognize bytes 32 - 46 as a copy of the disk
parameter block.  2-byte values are stored little-endian (low-byte
first).  The check size is set to zero because yaze does not allocate
space for a check vector when mounting a disk.  Instead sys.com resets
the disk system whenever control is returned from the monitor to CP/M,
in case a disk was unmounted or remounted.  It is the responsibility
of the user not to mess with disks from a different process, at least
not without executing sys.com (or diskrst.com) before resuming a
running yaze session.

The raw contents of the disk follow the header.  The sectors must be
arranged sequentially, i.e. any sector skew must be removed when
copying a real disk into a <CPM_Disk> file, because yaze sets the
sector translation table address to zero in the disk parameter header.

If the file does not begin with "<CPM_Disk>" and is exactly 256256
bytes long (77*26*128), it is assumed to be an exact copy of a SSSD
disk.

Empty disks can be created by the yaze monitor and by cdm.  When a
disk is created only the directory and the last sector of the disk are
actually written out.  This has the advantage that unallocated data
does not occupy space in the unix file system. For example, if we
create an 8MByte disk (the maximum size supported by standard
CP/M-2.2), we can see that it only occupies 56KBytes of physical disk
space.

    A>sys

    $>create disk 8m
    $>mount b disk
    $>mount -v
    A: r/o  test/
      dph=FD90, xlt=0000, dirbuf=FF80, dpb=FDA0, csv=0000, alv=FA66, spt=0100
      bsh=05, blm=1F, exm=01, dsm=0100, drm=07EF, al=FFFF, cks=0000, off=0000
    B: r/w  disk
      dph=FDAF, xlt=0000, dirbuf=FF80, dpb=FDBF, csv=0000, alv=FA87, spt=001A
      bsh=04, blm=0F, exm=00, dsm=0FFF, drm=03FF, al=FFFF, cks=0000, off=0000
    $>quit

    % du -sk disk
    56      disk
    % ls -sl disk
     112 -rw-rw-r--   1 fdc      grp      8388736 Oct  9 21:32 disk

A disadvantage of this method is that if the unix filesystem becomes
full or the user's disk quota is exceeded when yaze tries to write
data into a not-yet allocated part of the file, the process will be
aborted with a SIGSEGV.  It might be possible to extend yaze with a
signal handler and longjmp to cover this case, but that is not in
version 1.00.


There is no specific support in this package for transferring data
from existing CP/M disks into a form suitable for use with yaze.  It
is highly dependent on the available hardware and interfacing
possibilities.  If the individual files from the disk can be got into
a unix directory (maybe via serial transfer with kermit or
x/y/zmodem), that directory can be mounted by yaze as a read-only
pseudo disk and its contents used from there or copied into a
<CPM_Disk> file.  If direct access to a floppy drive is available it
is probably best to write a small program to transfer the contents
with a header prepended and the sectors deskewed.  With luck it may be
possible to use dd to copy the disk into a file.  Then generate a
<CPM_Disk> of the same format with yaze or cdm, chop the unused data
part with tail(1) and cat(1) the disk's data onto it.


7.  Benchmarks
==============

SAVAGE.COM
 yaze/50MHz supersparc:               11.6 secs (~ 22.4 MHz)
 4.0MHz Z80:                          65   secs
 2.5MHz Z80 (PX-8):                  105   secs (~  2.48MHz)


ZEXALL.COM
 yaze/50MHz supersparc:               1855 secs (~ 25.2 MHz)
 4.0MHz Z80:                         11688 secs
 2.5MHz Z80 (PX-8):                  19114 secs (~  2.45MHz)


8.  Emulating embedded systems
==============================
The talk up to here has been of using yaze to run CP/M.  If you want
to use it to emulate some other system you will have to add that
system's interaction with the outsize world to the source code.  The
instruction set emulator is in simz80.c.  I tried to make all
references to memory and I/O ports via the macros that are defined in
simz80.h.  These could be modified or replaced by function calls to
reflect the behaviour of a particular embedded system.  If the target
system uses interrupts, that logic would have to be added from
scratch.

9.  Software sources
====================
(/cdrom/cpm_cdrom is the path to the Walnut Creek CP/M CDROM on my
system).

SUPRDOS from /cdrom/cpm_cdrom/cpm/bdos/suprdos2.lbr (length = 90112)

ZCPR from /cdrom/cpm_cdrom/demon/zcpr-d-j.com (length = 32896)
(same as ftp.demon.co.uk:/pub/cpm/zcpr-d&j.com)


10. Why?
========
Here are answers to some questions that I would probably be asking if
I were reading this.

Q. Why did you base this on CPM-2.2 rather than CPM-3?
A. I do not have access to a CPM-3 system, so I could not have tested
   the implementation.

Q. Why did you write it all from scratch, rather than starting with one
   of the other free emulators?
A. "Not invented here", I guess.  Starting from scratch meant that I
   could do what I liked with the code, including putting it under the
   GPL, without consulting others.  Also, I have been messing with
   this for years on and off.  I was not aware of other emulators when
   I started.

Q. Why didn't you rewrite CCP and BDOS in C and let them run on the
   host cpu?
A. That was the original plan, particularly while I thought there was
   no free bdos available.  Partly because I want to finally get this
   stuff out of the door and partly because it is a lot of work to do
   right, I have left it for now.

Q. Why no built-in debugger?
A. My main aims were emulation accuracy and speed.  As it is, you can
   run a CP/M debugger like zsid or z8e in the emulator.  If that is
   not enough, you can run yaze under gdb or put hooks in the yaze
   source to analyse particularly tricky cases.

Q. What's all this perl stuff?
A. I make no apology for using perl as a super-macro-processor to
   generate simz80.c and zexall.z80 / zexdoc.z80.  You do not need
   perl to install yaze, because the output files are provided, but
   you will need it if you want to experiment.

   Simz80.pl includes 5 booleans which define how simz80.c is
   structured - see the source for more documentation.  A good way to
   chew up machine cycles is to generate all 32 possible variants and
   benchmark them by running zexall.com.

   Zexlax.pl fills in pseudo-random initial states in the test cases.
   Be careful if you change anything - you will have to run the new
   version on a reference Z80 to find the expected CRC values.


*** Local Variables: ***
*** mode:outline ***
*** outline-regexp: "[0-9]+\\." ***
*** End: ***