zemu 0.4.2 → 1.1.0

data/lib/zemu/config.rb

@@ -1,3 +1,5 @@
+require 'ostruct'
+
 module Zemu
     # Abstract configuration object.
     # All configuration objects should inherit from this.
@@ -75,10 +77,123 @@ module Zemu
     # @param [String] compiler The path to the compiler to be used for compiling the emulator executable.
     #
     class Config < ConfigObject
+        # Bus Device.
+        #
+        # Represents a device connected to the I/O
+        # or memory buses, or both.
+        class BusDevice < ConfigObject
+            # Constructor.
+            #
+            # This object should not be constructed directly.
+            def initialize
+                if self.class == Zemu::Config::BusDevice
+                    raise NotImplementedError, "Cannot construct an instance of the abstract class Zemu::Config::BusDevice."
+                end
+
+                @nmi = false
+                @interrupt = false
+
+                super
+            end
+
+            # Parameters used for generating C code to
+            # implement this bus device.
+            def memory
+                nil
+            end
+
+            # Setup to be performed on initialising the emulator
+            # instance.
+            def when_setup
+                ""
+            end
+
+            # Memory bus write handler.
+            #
+            # Handles write access via the memory bus to this device.
+            #
+            # @param addr The address being accessed.
+            # @param value The value being written.
+            def mem_write(addr, value)
+            end
+
+            # Memory bus read handler.
+            #
+            # Handles read access via the memory bus to this device.
+            #
+            # @param addr The address being accessed.
+            #
+            # Returns the value read, or nil if no value
+            # (e.g. if address falls outside range for this device).
+            def mem_read(addr)
+                nil
+            end
+
+            # IO bus write handler.
+            #
+            # Handles write access via the IO bus to this device.
+            #
+            # @param port The IO port being accessed.
+            # @param value The value being written.
+            def io_write(port, value)
+            end
+
+            # IO bus read handler.
+            #
+            # Handles read access via the IO bus to this device.
+            #
+            # @param port The IO port being accessed.
+            #
+            # Returns the value read from the port, or nil if no
+            # value (e.g. port does not correspond to this device).
+            def io_read(port)
+                nil
+            end
+
+            # Clock handler.
+            #
+            # Handles a clock cycle for this device.
+            # Deriving objects can use the nmi function
+            # to set the state of the non-maskable interrupt
+            # at each clock cycle.
+            def clock(cycles)
+            end
+
+            # FFI functions provided by this device.
+            def functions
+                []
+            end
+
+            # Sets state of the NMI for this device.
+            def nmi(state)
+                @nmi = state
+            end
+
+            # Gets state of NMI for this device.
+            def nmi?
+                @nmi
+            end
+
+            # Sets state of INT for this device.
+            def interrupt(state)
+                @interrupt = state
+            end
+
+            # Gets state of INT for this device.
+            def interrupt?
+                @interrupt
+            end
+
+            # Parameters for a bus device.
+            def params
+                %w(name)
+            end
+        end
+
         # Memory object.
         #
         # This is an abstract class from which all other memory objects inherit.
-        class Memory < ConfigObject
+        class Memory < BusDevice
             # Constructor.
             #
             # Do not use, as this is an abstract class. Use one of the subclasses instead.
@@ -107,15 +222,62 @@ module Zemu
                 end
             end
 
-            # @return [Boolean] true if this memory section is readonly, false otherwise.
+            # Is this memory read-only?
             def readonly?
-                return false
+                false
+            end
+
+            # Parameters used for generating C code to
+            # implement this memory block.
+            def memory
+                contents_initializer = ""
+                @contents.each_slice(32) do |c|
+                    contents_initializer += c.map { |b| b.to_s }.join(", ")
+                    contents_initializer += ",\n"
+                end
+
+                m = OpenStruct.new
+
+                m.setup = <<eos
+zuint8 memory_#{name}[#{size}] =
+{
+    #{contents_initializer}
+};
+eos
+
+                m.address = address
+                m.size = size
+                m.access_read = "memory_#{name}"
+                m.access_write = "memory_#{name}"
+
+                m
+            end
+
+            # Memory bus read handler.
+            #
+            # Handles read access via the memory bus to this device.
+            #
+            # @param addr The address being accessed.
+            #
+            # Returns the value read, or nil if no value
+            # (e.g. if address falls outside range for this device).
+            def mem_read(addr)
+                nil
+            end
+
+            # Memory bus write handler.
+            #
+            # Handles write access via the memory bus to this device.
+            #
+            # @param addr The address being accessed.
+            # @param value The value being written.
+            def mem_write(addr, value)
             end
 
             # Valid parameters for this object.
             # Should be extended by subclasses but NOT REPLACED.
             def params
-                return %w(name address size)
+                super + %w(address size)
             end
 
             # Reads the contents of a file in binary format and
@@ -155,8 +317,14 @@ module Zemu
                 super
             end
 
+            # Is this memory block readonly?
             def readonly?
-                return true
+                true
+            end
+
+            # Memory write handler.
+            def mem_write(addr, port)
+                # Does nothing - cannot write to read-only memory.
             end
         end
 
@@ -165,169 +333,13 @@ module Zemu
         # Represents a block of memory which can be read and written.
         class RAM < Memory
         end
-
-        # Input/Output Port object
-        #
-        # Represents an input/output device assigned to one or more ports.
-        #
-        # This is an abstract class and cannot be instantiated directly.
-        # The when_setup, when_read, and when_write methods can be used to define
-        # the behaviour of a subclass.
-        #
-        # @example
-        #    class MyIODevice < IOPort
-        #        # Extend the parameters of the object so we can define a port.
-        #        def params
-        #            super + "port"
-        #        end
-        #
-        #        def initialize
-        #            super
-        # 
-        #            # Define the setup for the IO device.
-        #            # This is some global C code that ends up in "io.c".
-        #            # Parameters can be used here, as the block is instance-evaluated.
-        #            when_setup do
-        #                %Q(zuint8 #{name}_value = 42;)
-        #            end
-        #
-        #            # Define the logic when reading from an IO port.
-        #            # The C variable "port" takes the value of the 8-bit port
-        #            # address being read from, and should be used to identify
-        #            # if this IO device is the one being used.
-        #            when_read do
-        #                %Q(if (port == #{port}) return #{name}_value;)
-        #            end
-        #
-        #            # Define the logic when writing to the IO port.
-        #            # Similar to #when_read, but we have access to an extra
-        #            # C variable, "value". This is the value being written
-        #            # to the IO port.
-        #            when_write do
-        #                %Q(if (port == #{port}) #{name}_value = value;)
-        #            end
-        #        end
-        #    end
-        #
-        #    # The subclass can now be declared as below:
-        #    device = MyIODevice.new do
-        #        name "myDevice"
-        #        port 11
-        #    end
-        #
-        #
-        class IOPort < ConfigObject
-            attr_reader :io_type
-
-            # Constructor.
-            #
-            # Do not use, as this is an abstract class. Use one of the subclasses instead.
-            def initialize
-                if self.class == Zemu::Config::IOPort
-                    raise NotImplementedError, "Cannot construct an instance of the abstract class Zemu::Config::IOPort."
-                end
-
-                @ports = []
-                @setup_block = nil
-                @read_block = nil
-                @write_block = nil
-                @clock_block = nil
-
-                super
-            end
-
-            # Defines the setup behaviour of this IO device.
-            #
-            # Expects a block, the return value of which is a string
-            # containing all data and function declarations required by this IO device.
-            #
-            # The block will be instance-evaluated at build-time, so it is possible to use
-            # instance variables of the IO device.
-            def when_setup(&block)
-                @setup_block = block
-            end
-
-            # Defines the read behaviour of this IO device.
-            #
-            # Expects a block, the return value of which is a string
-            # containing the behaviour of this IO device when a value is read from the IO bus.
-            # Care must be taken to ensure that this functionality does not conflict with that of
-            # any other IO devices.
-            #
-            # The block will be instance-evaluated at build-time, so it is possible to use
-            # instance variables of the IO device.
-            def when_read(&block)
-                @read_block = block
-            end
-
-            # Defines the write behaviour of this IO device.
-            #
-            # Expects a block, the return value of which is a string
-            # containing the behaviour of this IO device when a value is written to the IO bus.
-            # Care must be taken to ensure that this functionality does not conflict with that of
-            # any other IO devices.
-            #
-            # The block will be instance-evaluated at build-time, so it is possible to use
-            # instance variables of the IO device.
-            def when_write(&block)
-                @write_block = block
-            end
-
-            # Defines the per-cycle behaviour of this IO device.
-            #
-            # Expects a block, the return value of which is a string
-            # defining the behaviour of the IO device on each system clock cycle.
-            # Care must be taken to ensure that this functionality does not conflict with that of
-            # any other IO devices.
-            #
-            # The block will be instance-evaluated at build-time, so it is possible to use
-            # instance variables of the IO device.
-            def when_clock(&block)
-                @clock_block = block
-            end
-
-            # Evaluates the when_setup block of this IO device and returns the resulting string.
-            def setup
-                return instance_eval(&@setup_block) unless @setup_block.nil?
-                return ""
-            end
-
-            # Evaluates the when_read block of this IO device and returns the resulting string.
-            def read
-                return instance_eval(&@read_block) unless @read_block.nil?
-                return ""
-            end
-
-            # Evaluates the when_write block of this IO device and returns the resulting string.
-            def write
-                return instance_eval(&@write_block) unless @write_block.nil?
-                return ""
-            end
-
-            # Evaluates the when_clock block of this IO device and returns the resulting string.
-            def clock
-                return instance_eval(&@clock_block) unless @clock_block.nil?
-                return ""
-            end
-
-            # Defines FFI API which will be available to the instance wrapper if this IO device is used.
-            def functions
-                []
-            end
-
-            # Valid parameters for this object.
-            # Should be extended by subclasses but NOT REPLACED.
-            def params
-                %w(name)
-            end
-        end
         
         # Serial Input/Output object
         #
         # Represents a serial connection between the emulated CPU
         # and the host machine, with input and output mapped to Z80 I/O
         # ports.
-        class SerialPort < IOPort
+        class SerialPort < BusDevice
             # Constructor.
             #
             # Takes a block in which the parameters of the serial port
@@ -348,92 +360,93 @@ module Zemu
             def initialize
                 super
 
-                when_setup do
-                    "SerialBuffer io_#{name}_buffer_master = { .head = 0, .tail = 0 };\n" +
-                    "SerialBuffer io_#{name}_buffer_slave = { .head = 0, .tail = 0 };\n" +
-                    "\n" +
-                    "zusize zemu_io_#{name}_buffer_size(void)\n" +
-                    "{\n" +
-                    "    zusize start = io_#{name}_buffer_slave.head;\n" +
-                    "    zusize end = io_#{name}_buffer_slave.tail\n;" +
-                    "    if (end < start) end += ZEMU_IO_SERIAL_BUFFER_SIZE;\n" +
-                    "    return end - start;\n" +
-                    "}\n" +
-                    "\n" +
-                    "void zemu_io_#{name}_slave_puts(zuint8 val)\n" +
-                    "{\n" +
-                    "    io_#{name}_buffer_slave.buffer[io_#{name}_buffer_slave.tail] = val;\n" +
-                    "    io_#{name}_buffer_slave.tail++;\n" +
-                    "    if (io_#{name}_buffer_slave.tail >= ZEMU_IO_SERIAL_BUFFER_SIZE)\n" +
-                    "        io_#{name}_buffer_slave.tail = 0;\n" +
-                    "}\n" +
-                    "\n" +
-                    "zuint8 zemu_io_#{name}_slave_gets(void)\n" +
-                    "{\n" +
-                    "    zuint8 val = io_#{name}_buffer_master.buffer[io_#{name}_buffer_master.head];\n" +
-                    "    io_#{name}_buffer_master.head++;\n" +
-                    "    if (io_#{name}_buffer_master.head >= ZEMU_IO_SERIAL_BUFFER_SIZE)\n" +
-                    "        io_#{name}_buffer_master.head = 0;\n" +
-                    "\n" +
-                    "    return val;\n" +
-                    "}\n" +
-                    "\n" +
-                    "void zemu_io_#{name}_master_puts(zuint8 val)\n" +
-                    "{\n" +
-                    "    io_#{name}_buffer_master.buffer[io_#{name}_buffer_master.tail] = val;\n" +
-                    "    io_#{name}_buffer_master.tail++;\n" +
-                    "    if (io_#{name}_buffer_master.tail >= ZEMU_IO_SERIAL_BUFFER_SIZE)\n" +
-                    "        io_#{name}_buffer_master.tail = 0;\n" +
-                    "}\n" +
-                    "\n" +
-                    "zuint8 zemu_io_#{name}_master_gets(void)\n" +
-                    "{\n" +
-                    "    zuint8 val = io_#{name}_buffer_slave.buffer[io_#{name}_buffer_slave.head];\n" +
-                    "    io_#{name}_buffer_slave.head++;\n" +
-                    "    if (io_#{name}_buffer_slave.head >= ZEMU_IO_SERIAL_BUFFER_SIZE)\n" +
-                    "        io_#{name}_buffer_slave.head = 0;\n" +
-                    "\n" +
-                    "    return val;\n" +
-                    "}\n"
-                end
+                @buffer_tx = []
+                @buffer_rx = []
+            end
 
-                when_read do
-                    "if (port == #{in_port})\n" +
-                    "{\n" +
-                    "    return zemu_io_#{name}_slave_gets();\n" +
-                    "}\n" +
-                    "else if (port == #{ready_port})\n" +
-                    "{\n" +
-                    "    if (io_#{name}_buffer_master.head == io_#{name}_buffer_master.tail)\n" +
-                    "    {\n" +
-                    "        return 0;\n" +
-                    "    }\n" +
-                    "    else\n" +
-                    "    {\n" +
-                    "        return 1;\n" +
-                    "    }\n" +
-                    "}\n"
+            # IO bus read handler.
+            #
+            # Handles read access via the IO bus to this device.
+            #
+            # @param port The IO port being accessed.
+            #
+            # Returns the value read, or nil if the port does not
+            # correspond to this device.
+            def io_read(port)
+                if port == in_port
+                    return @buffer_rx.shift()
+                elsif port == ready_port
+                    if @buffer_rx.empty?
+                        return 0
+                    else
+                        return 1
+                    end
                 end
 
-                when_write do
-                    "if (port == #{out_port})\n" +
-                    "{\n" +
-                    "    zemu_io_#{name}_slave_puts(value);\n" +
-                    "}\n"
+                nil
+            end
+
+            # IO bus write handler.
+            #
+            # Handles write access via the IO bus to this device.
+            #
+            # @param port The IO port being accessed.
+            # @param value The value being written.
+            def io_write(port, value)
+                if port == out_port
+                    @buffer_tx << value
                 end
             end
 
-            # Defines FFI API which will be available to the instance wrapper if this IO device is used.
-            def functions
-                [
-                    {"name" => "zemu_io_#{name}_master_puts".to_sym, "args" => [:uint8], "return" => :void},
-                    {"name" => "zemu_io_#{name}_master_gets".to_sym, "args" => [], "return" => :uint8},
-                    {"name" => "zemu_io_#{name}_buffer_size".to_sym, "args" => [], "return" => :uint64}
-                ]
+            # Gets number of bytes transmitted by the CPU,
+            # but not yet read from this device.
+            def transmitted_count
+                @buffer_tx.size
+            end
+
+            # Gets a byte transmitted by the CPU, or nil
+            # if transmit buffer is empty.
+            def get_byte
+                @buffer_tx.shift()
+            end
+
+            # Puts a byte in the receive buffer of this device.
+            def put_byte(b)
+                @buffer_rx << b
+            end
+
+            # Puts a string in the receive buffer of this device.
+            def puts(s)
+                s.each_byte { |b| put_byte(b) }
+            end
+
+            # Gets a string from the transmit buffer of this device.
+            # String length will be no more than n, but may be less
+            # if fewer characters exist in buffer.
+            #
+            # @param n Length of string to retrieve. If omitted the
+            # entire buffer will be returned.
+            def gets(n=nil)
+                s = ""
+
+                if n.nil?
+                    until (c = get_byte()).nil?
+                        s += c.chr
+                    end
+                else
+                    n.times do
+                        c = get_byte()
+                        break if c.nil?
+
+                        s += c.chr
+                    end
+                end
+
+                s
             end
 
             # Valid parameters for a SerialPort, along with those
-            # defined in [Zemu::Config::IOPort].
+            # defined in [Zemu::Config::BusDevice].
             def params
                 super + %w(in_port out_port ready_port)
             end
@@ -443,7 +456,16 @@ module Zemu
         #
         # Represents a device with a sequence of sectors of a fixed size,
         # which can be accessed via IO instructions as an IDE drive.
-        class BlockDrive < IOPort
+        class BlockDrive < BusDevice
+            # Mode for reading drive.
+            DRIVE_MODE_READ = 0x01
+
+            # Mode for writing drive.
+            DRIVE_MODE_WRITE = 0x02
+
+            # Uninitialised drive mode.
+            DRIVE_MODE_UNINIT = 0x00
+
             # Constructor.
             #
             # Takes a block in which the parameters of the block drive
@@ -479,131 +501,110 @@ module Zemu
                     end
                 end
 
-                when_setup do
-<<-eos
-#include <stdio.h>
+                @lba_0 = 0
+                @lba_1 = 0
+                @lba_2 = 0
+                @lba_3 = 0
 
-zuint8 sector_data_#{name}[#{sector_size}];
-zuint32 sector_data_#{name}_offset;
-zuint32 loaded_sector_#{name} = Z_UINT32_MAXIMUM;
-zuint8 drive_mode_#{name};
-zuint8 drive_status_#{name} = 0b01000000;
+                @drive_mode = DRIVE_MODE_UNINIT
+                @drive_status = 0b01000000
+                @sector_offset = 0
+                @sector_data = []
+            end
 
-zuint8 lba_#{name}_0;
-zuint8 lba_#{name}_1;
-zuint8 lba_#{name}_2;
-zuint8 lba_#{name}_3;
+            # IO bus read handler.
+            #
+            # Handles read access via the IO bus to this device.
+            #
+            # @param port The IO port being accessed.
+            #
+            # Returns the value read, or nil if the port does not
+            # correspond to this device.
+            def io_read(port)
+                if port == base_port
+                    b = @sector_data.shift()
+
+                    if @sector_data.empty?
+                        @drive_status = 0b01000000
+                    end
 
-void internal_#{name}_load_sector(zuint32 sector)
-{
-    if (loaded_sector_#{name} == sector) return;
+                    return b
+                elsif port == (base_port + 7)
+                    return @drive_status
+                end
 
-    FILE * fptr = fopen("#{@initialize_from}", "rb");
-    fseek(fptr, sector * #{sector_size}, SEEK_SET);
-    fread(sector_data_#{name}, #{sector_size}, 1, fptr);
-    fclose(fptr);
+                nil
+            end
 
-    loaded_sector_#{name} = sector;
-}
+            # Get a sector number from the four LBA registers.
+            def get_sector()
+                sector = 0
+                sector |= @lba_0
+                sector |= @lba_1 << 8
+                sector |= @lba_2 << 16
+                sector |= @lba_3 << 24
 
-void internal_#{name}_write_current_sector()
-{
-    FILE * fptr = fopen("#{@initialize_from}", "r+b");
-    fseek(fptr, loaded_sector_#{name} * #{sector_size}, SEEK_SET);
-    fwrite(sector_data_#{name}, 1, #{sector_size}, fptr);
-    fclose(fptr);
-}
+                sector
+            end
 
-zuint8 zemu_io_#{name}_readbyte(zuint32 sector, zuint32 offset)
-{
-    internal_#{name}_load_sector(sector);
-    return sector_data_#{name}[offset];
-}
-eos
+            # Write sector data to the sector currently pointed
+            # to by the LBA registers.
+            def write_current_sector()
+                file_offset = get_sector() * sector_size
+                File.open(@initialize_from, "r+b") do |f|
+                    f.seek(file_offset)
+                    f.write(@sector_data.pack("C" * sector_size))
                 end
+            end
 
-                when_read do
-<<-eos
-if (port == #{base_port})
-{
-    zuint8 b = sector_data_#{name}[sector_data_#{name}_offset];
-    sector_data_#{name}_offset++;
-    if (sector_data_#{name}_offset >= #{sector_size})
-    {
-        drive_status_#{name} = 0b01000000;
-    }
-    return b;
-}
-else if (port == #{base_port+7})
-{
-    return drive_status_#{name};
-}
-eos
+            # Load sector data pointed to by LBA registers.
+            def load_sector()
+                file_offset = get_sector() * sector_size
+                File.open(@initialize_from, "rb") do |f|
+                    f.seek(file_offset)
+                    s = f.read(sector_size)
+                    @sector_data = s.unpack("C" * sector_size)
                 end
+            end
 
-                when_write do
-<<-eos
-if (port == #{base_port})
-{
-    if (drive_mode_#{name} == 0x01)
-    {
-        sector_data_#{name}[sector_data_#{name}_offset] = value;
-        sector_data_#{name}_offset++;
-        if (sector_data_#{name}_offset >= #{sector_size})
-        {
-            internal_#{name}_write_current_sector();
-            drive_status_#{name} = 0b01000000;
-        }
-    }
-}
-else if (port == #{base_port+3})
-{
-    lba_#{name}_0 = value;
-}
-else if (port == #{base_port+4})
-{
-    lba_#{name}_1 = value;
-}
-else if (port == #{base_port+5})
-{
-    lba_#{name}_2 = value;
-}
-else if (port == #{base_port+6})
-{
-    lba_#{name}_3 = value & 0b00011111;
-}
-else if (port == #{base_port+7})
-{
-    if (value == 0x20)
-    {
-        zuint32 sector = 0;
-        sector |= (zuint32)lba_#{name}_3 << 24;
-        sector |= (zuint32)lba_#{name}_2 << 16;
-        sector |= (zuint32)lba_#{name}_1 << 8;
-        sector |= (zuint32)lba_#{name}_0;
-
-        internal_#{name}_load_sector(sector);
-        sector_data_#{name}_offset = 0;
-
-        drive_mode_#{name} = 0x00;
-        drive_status_#{name} = 0b00001000;
-    }
-    else if (value == 0x30)
-    {
-        zuint32 sector = 0;
-        sector |= (zuint32)lba_#{name}_3 << 24;
-        sector |= (zuint32)lba_#{name}_2 << 16;
-        sector |= (zuint32)lba_#{name}_1 << 8;
-        sector |= (zuint32)lba_#{name}_0;
-
-        internal_#{name}_load_sector(sector);
-        sector_data_#{name}_offset = 0;
-
-        drive_mode_#{name} = 0x01;
-        drive_status_#{name} = 0b00001000;
-    }
-}
-eos
+            # IO bus write handler.
+            #
+            # Handles write access via the IO bus to this device.
+            #
+            # @param port The IO port being accessed.
+            # @param value The value being written.
+            def io_write(port, value)
+                if port == base_port
+                    if @drive_mode == DRIVE_MODE_WRITE
+                        @sector_data << value
+                        if @sector_data.size >= sector_size
+                            write_current_sector()
+                            @drive_status = 0b01000000
+                        end
+                    end
+                elsif port == (base_port + 3)
+                    @lba_0 = (value & 0xff)
+                elsif port == (base_port + 4)
+                    @lba_1 = (value & 0xff)
+                elsif port == (base_port + 5)
+                    @lba_2 = (value & 0xff)
+                elsif port == (base_port + 6)
+                    @lba_3 = (value & 0x1f)
+                elsif port == (base_port + 7)
+                    # Read command.
+                    if value == 0x20
+                        load_sector()
+
+                        @drive_mode = DRIVE_MODE_READ
+                        @drive_status = 0b00001000
+
+                    # Write command.
+                    elsif value == 0x30
+                        @sector_data = []
+
+                        @drive_mode = DRIVE_MODE_WRITE
+                        @drive_status = 0b00001000
+                    end
                 end
             end
 
@@ -637,15 +638,29 @@ eos
                 @initialize_from = file
             end
 
+            # Read a byte at the given offset in a sector.
+            #
+            # @param sector The sector to read from.
+            # @param offset Offset in that sector to read.
+            #
+            # Returns the byte read from the file.
+            def read_byte(sector, offset)
+                file_offset = (sector * sector_size) + offset
+                File.open(@initialize_from, "rb") do |f|
+                    f.seek(file_offset)
+                    s = f.read(1)
+                    return s.unpack("C")[0]
+                end
+            end
+
             # Defines FFI API which will be available to the instance wrapper if this IO device is used.
             def functions
                 [
-                    {"name" => "zemu_io_#{name}_readbyte", "args" => [:uint32, :uint32], "return" => :uint8},
                 ]
             end
 
             # Valid parameters for a BlockDrive, along with those
-            # defined in [Zemu::Config::IOPort].
+            # defined in [Zemu::Config::BusDevice].
             def params
                 super + %w(base_port sector_size num_sectors)
             end
@@ -656,29 +671,45 @@ eos
         # Represents a timer device, the period of which can be controlled
         # by the CPU through an IO port. The timer generates an NMI once this
         # period has expired. The timer can be reset via a control port.
-        class Timer < IOPort
-            def initialize
-                super
+        class Timer < BusDevice
+            # Timer is running - count decrements once per clock cycle.
+            RUNNING = 0x01
 
-                when_setup do
-                    "zuint8 io_#{name}_count;\n" +
-                    "zuint8 io_#{name}_running = 0;\n"
-                end
+            # Timer is stopped - count does not change on clock cycle.
+            STOPPED = 0x00
 
-                when_read do
-                end
+            def initialize
+                super
 
-                when_write do
-                    "if (port == #{count_port}) io_#{name}_count = value;\n" +
-                    "else if (port == #{control_port}) io_#{name}_running = value;\n"
+                @count = 0
+                @running = false
+            end
+            
+            # IO bus write handler.
+            #
+            # Handles write access via the IO bus to this device.
+            #
+            # @param port The IO port being accessed.
+            # @param value The value being written.
+            def io_write(port, value)
+                if port == count_port
+                    @count = value
+                elsif port == control_port
+                    @running = if value == 0 then STOPPED else RUNNING end
                 end
+            end
 
-                when_clock do
-                    "if (io_#{name}_running)\n" +
-                    "{\n" +
-                    "    if (io_#{name}_count > 0) io_#{name}_count--;\n" +
-                    "    else zemu_io_nmi(instance);\n" +
-                    "}\n"
+            # Clock handler.
+            #
+            # Handles a clock cycle for this device.
+            # Sets NMI active if the count reaches 0.
+            def clock(cycles)
+                if @running == RUNNING
+                    if @count > 0
+                        @count -= cycles
+                    else
+                        nmi(true)
+                    end
                 end
             end
 
@@ -694,11 +725,8 @@ eos
             return binding
         end
 
-        # The memory sections of this configuration object.
-        attr_reader :memory
-
-        # The IO devices of this configuration object.
-        attr_reader :io
+        # The bus devices of this configuration object.
+        attr_reader :devices
 
         # Parameters accessible by this configuration object.
         def params
@@ -737,8 +765,7 @@ eos
         #
         # @raise [Zemu::ConfigError] Raised if the +name+ parameter is not set, or contains whitespace.
         def initialize
-            @memory = []
-            @io = []
+            @devices = []
 
             super
 
@@ -753,16 +780,29 @@ eos
 
         # Adds a new memory section to this configuration.
         #
+        # Deprecated - retained only for backwards compatibility.
+        # Use add_device instead.
+        #
         # @param [Zemu::Config::Memory] mem The memory object to add.
         def add_memory(mem)
-            @memory << mem
+            @devices << mem
         end
 
         # Adds a new IO device to this configuration.
         #
-        # @param [Zemu::Config::IOPort] io The IO device to add.
+        # Deprecated - retained only for backwards compatibility.
+        # Use add_device instead.
+        #
+        # @param [Zemu::Config::BusDevice] io The IO device to add.
         def add_io(io)
-            @io << io
+            @devices << io
+        end
+
+        # Adds a new device to the bus for this configuration.
+        #
+        # @param [Zemu::Config::BusDevice] device The device to add.
+        def add_device(device)
+            @devices << device
         end
     end