Z80 USB-Controller Programming Model

Address references in each step are shown with a trailing 'h' which denotes the hexadecimal number system, and are given for a 8K ROM memory system. For larger ROM systems, add a 'bias' to each address which is shown with a +bias following it, where bias is equal to the ROM memory size - 8K. Values for bias in various standard ROM memory sizes are listed in the table.

Note that the standard distribution version of KIOS in USB-Controller is set for operation within a 32K ROM memory system. Also, if you select the 'Project', 'KIOS/BIOS Stubs' option in Debug Z80 , the stubs will be located for operation of a 32K ROM memory system. The reason you would have smaller or larger systems is if you were to build a physical 8080, 8085, Z80, Z180, eZ80, or Rabbit 2000 based circuit board and configure less or more than 32K of ROM memory on the system. The reason USB-Controller is set for a 32K ROM memory system is that an easy physical system to build would be 32K of ROM and 32K of RAM where all code and read only data variables are located below 8000h and all read/write data variables and program stack are located at or above address 8000h.

As a side note, in addition to KIOS and CP/M which both work on 8085/Z80 processors, the Sojourner Mars Rover also used an 8085 processor. Since the flat 16-bit (64K) address space of the 8085 was insufficient for the data and code requirements of the Sojourner Mars Rover mission, additional memory was provided, along with hardware to map the 64K logical address space into a larger physical memory space. The first 16K of the logical address space (0000h-3FFFh) was mapped into rad hard ROM at startup, then switched to rad hard shadow RAM. It was used for interrupt vectors and handlers, top-level control (the main loop/command dispatcher), and common library functions (compiler support library, device I/O, communications, etc.) The next 16K of the logical address space (4000h-7FFFh) was always mapped to rad hard RAM, and was used primarily for data (e.g. stack, state information, variables, buffers). The last two 16K of logical space were each mapped through bank registers (BANK1 for addresses 8000h-BFFFh, and BANK2 for addresses C000h-FFFFh) into any two of several physical memory segments. By configuring KIOS for a 16K ROM memory system, it would have a similar memory layout to the first two 16K memory banks of the Sojourner Rover.

First you need to write a program. Here's an example of a Z80 assembly program that pulses bits in USB parallel printer port as if it's wired to an H-bridge circuit for turning on and off motors.

  ORG 00001h
 
  WarmStartAddr:
 
  ORG 00100h
 
  setup:
  ;; do any I/O hardware setup operations here
    jp loop
 
  ;; determine ROM size and KIOS location based on page zero setting
  locatekios:
    ld hl, (WarmStartAddr)
    add hl, de
    jp (hl)
 
  ;; delay is a constant so it can reside in ROM with program instead of RAM
  delay:
    DD 32768
 
  loop:
  ;; forward
    ld a, 03Ch ;; output bits 00111100
    ld bc, delay
    ld de, 00066h
    call locatekios
    call stop
  ;; reverse
    ld a, 014h ;; output bits 00010100
    ld bc, delay
    ld de, 00066h
    call locatekios
    call stop
  ;; forward on one side and reverse on the other
  ;; results in turning
    ld a, 01Ch ;; output bits 00011100
    ld bc, delay
    ld de, 00066h
    call locatekios
    call stop
    jp loop
 
  stop:
  ;; stopped
    ld a, 000h ;; output bits 00000000
    ld bc, delay
    ld de, 00066h
    call locatekios
    ret
 
  END

Note that you don't need to use the locatekios routine above to call into KIOS entry points. Calling directly into KIOS will take fewer instructions. However, the locatekios routine can be used to eliminate the need for different *.hex files for different ROM size physical systems.

Otherwise pick almost any of the numerous pieces of example code on the internet for an 8080/8085, Z80/Z180, etc.

While not required, you can use the KAsm80 assembler that comes with Debug Z80 to assemble the above code. The command to run KAsm80 will look something like this:

  KAsm80.exe {source_file_name}.a80

KAsm80 will produce a *.hex file in the same directory as the *.asm or *.a80 source file. Make a note of the path to the directory where the *.hex file is created. Transfer the *.hex file from this location to your Android smartphone.

Note that like programs for CP/M, programs for USB-Controller and KIOS should start at address 00100h. This provides some compatibility with CP/M development tools. However, unlike CP/M that assumes all memory is RAM (read/write memory), programs for USB-Controller and KIOS should assume all memory addresses below KIOS memory are ROM and that RAM for variables starts above KIOS. Main memory page zero, between locations 000h and 0FFh, contains several pieces of code and data which might be used during execution. The code and data areas in page zero are given below for reference purposes. In addition to page zero, your program should reside between address 00100h and 01A00h+bias. KIOS 'jump vector' locations between 01A00h+bias and 01A7Fh+bias should only be used as defined above or be assumed to be reserved for future KIOS definitions. If you're implementing a physical CPU system, your I/O subroutines that you jump to from the KIOS jump vector can be implemented in the ROM between address 01A80h+bias and 01FFFh+bias.