zemu 0.2.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 79900374a7a271fbfc1333290b4078e8e587ebbec09034c9cde520623459fcd4
-  data.tar.gz: 6282f2f1d04cf8188d84a058100d7db55d9305c3c577104455ead68195d17adb
+  metadata.gz: dbdac0f92af987d3202f5975f4bc119c448a0c3356c5bfa069ff659977e6c150
+  data.tar.gz: 55becc89a08a3aee55baddf0dd172bd702dbfe2ab328340578f5ed313a983aa3
 SHA512:
-  metadata.gz: 30dcdd1f3b79b767816a23a28c34107fb91ea48a8bbff445fa90228d4c2fe83276ba4f5ffb727f881e1864edeb40cbbefe1f637cb2e07a2793c0bbbab3ecf7fb
-  data.tar.gz: cf6f4519a152b2f1372c581222a35bcd33a32934607bdeae878330216551a26f712a7837ddf5a9935389c4c6a1b2aeba600c2e0c178fc083bb5dce616542cf19
+  metadata.gz: a41f637706dc296b456da80be43af7cb1aeb7e7e34700c3d2e731f9da3698a16cb18f7b622b8a82054eb3c789d451bea6cbd73f145f9a76e6fd8c5850c9fbede
+  data.tar.gz: 8174742e9ab6adc69f284bd8a33763d03074daafaa638f385fc4ff3cc27db2ebbeed85d23999b77439a2340722882bc1048626a8b4bc5eda1768263cdecdbff4

data/lib/zemu/config.rb

@@ -228,6 +228,10 @@ module Zemu
                 end
 
                 @ports = []
+                @setup_block = nil
+                @read_block = nil
+                @write_block = nil
+                @clock_block = nil
 
                 super
             end
@@ -269,28 +273,46 @@ module Zemu
                 @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
-                instance_eval(&@setup_block)
+                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
-                instance_eval(&@read_block)
+                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
-                instance_eval(&@write_block)
+                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
-                [
-                    {"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}
-                ]
+                []
             end
 
             # Valid parameters for this object.
@@ -401,6 +423,15 @@ module Zemu
                 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}
+                ]
+            end
+
             # Valid parameters for a SerialPort, along with those
             # defined in [Zemu::Config::IOPort].
             def params
@@ -408,6 +439,44 @@ module Zemu
             end
         end
 
+        # Non-Maskable Interrupt Timer
+        #
+        # 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
+
+                when_setup do
+                    "zuint8 io_#{name}_count;\n" +
+                    "zuint8 io_#{name}_running = 0;\n"
+                end
+
+                when_read do
+                end
+
+                when_write do
+                    "if (port == #{count_port}) io_#{name}_count = value;\n" +
+                    "else if (port == #{control_port}) io_#{name}_running = value;\n"
+                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"
+                end
+            end
+
+            # Valid parameters for a Timer, along with those defined in
+            # [Zemu::Config::IOPort].
+            def params
+                super + %w(count_port control_port)
+            end
+        end
+
         # Gets a binding for this object.
         def get_binding
             return binding

data/lib/zemu/instance.rb

@@ -37,6 +37,21 @@ module Zemu
             "L'" => 19
         }
 
+        # States that the emulated machine can be in.
+        class RunState
+            # Currently executing an instruction.
+            RUNNING = 0
+
+            # Executed a HALT instruction in the previous cycle.
+            HALTED = 1
+
+            # Hit a breakpoint in the previous cycle.
+            BREAK = 2
+
+            # Undefined. Emulated machine has not yet reached a well-defined state.
+            UNDEFINED = -1
+        end
+
         def initialize(configuration)
             @clock = configuration.clock_speed
 
@@ -47,6 +62,10 @@ module Zemu
             @instance = @wrapper.zemu_init
             @wrapper.zemu_power_on(@instance)
             @wrapper.zemu_reset(@instance)
+
+            @state = RunState::UNDEFINED
+
+            @breakpoints = []
         end
 
         # Returns the clock speed of this instance in Hz.
@@ -124,7 +143,32 @@ module Zemu
         #
         # Returns the number of cycles executed.
         def continue(run_cycles=-1)
-            return @wrapper.zemu_debug_continue(@instance, run_cycles)
+            # Return immediately if we're HALTED.
+            return if @state == RunState::HALTED
+
+            cycles_executed = 0
+
+            @state = RunState::RUNNING
+
+            # Run as long as:
+            #   We haven't hit a breakpoint
+            #   We haven't halted
+            #   We haven't hit the number of cycles we've been told to execute for.
+            while (run_cycles == -1 || cycles_executed < run_cycles) && (@state == RunState::RUNNING)
+                cycles_executed += @wrapper.zemu_debug_step(@instance)
+
+                pc = @wrapper.zemu_debug_pc(@instance)
+
+                # If the PC is now pointing to one of our breakpoints,
+                # we're in the BREAK state.
+                if (@breakpoints.select { |b| b == pc }.size) > 0
+                    @state = RunState::BREAK
+                elsif @wrapper.zemu_debug_halted()
+                    @state = RunState::HALTED
+                end
+            end
+
+            return cycles_executed
         end
 
         # Set a breakpoint of the given type at the given address.
@@ -133,17 +177,26 @@ module Zemu
         # @param type The type of breakpoint:
         #   * :program => Break when the program counter hits the address given. 
         def break(address, type)
-            @wrapper.zemu_debug_set_breakpoint(address)
+            @breakpoints << address
+        end
+
+        # Remove a breakpoint of the given type at the given address.
+        # Does nothing if no breakpoint previously existed at that address.
+        #
+        # @param address The address of the breakpoint to be removed.
+        # @param type The type of breakpoint. See Instance#break.
+        def remove_break(address, type)
+            @breakpoints.reject! { |b| b == address }
         end
 
         # Returns true if the CPU has halted, false otherwise.
         def halted?
-            return @wrapper.zemu_debug_halted
+            return @state == RunState::HALTED
         end
 
         # Returns true if a breakpoint has been hit, false otherwise.
         def break?
-            return @wrapper.zemu_debug_break
+            return @state == RunState::BREAK
         end
 
         # Powers off the emulated CPU and destroys this instance.
@@ -168,14 +221,12 @@ module Zemu
 
             wrapper.attach_function :zemu_reset, [:pointer], :void
 
-            wrapper.attach_function :zemu_debug_continue, [:pointer, :int64], :uint64
+            wrapper.attach_function :zemu_debug_step, [:pointer], :uint64
 
             wrapper.attach_function :zemu_debug_halted, [], :bool
-            wrapper.attach_function :zemu_debug_break, [], :bool
-
-            wrapper.attach_function :zemu_debug_set_breakpoint, [:uint16], :void
 
             wrapper.attach_function :zemu_debug_register, [:pointer, :uint16], :uint16
+            wrapper.attach_function :zemu_debug_pc, [:pointer], :uint16
 
             wrapper.attach_function :zemu_debug_get_memory, [:uint16], :uint8
 

data/src/debug.c

@@ -1,69 +1,16 @@
 #include "debug.h"
 
-RunState zemu_debug_state = UNDEFINED;
-
-/* Currently, the number of breakpoints is defined statically.
- * Perhaps in future there will be an unlimited number.
- */
-zuint16 breakpoints[ZEMU_DEBUG_MAX_BREAKPOINTS];
-unsigned int breakpoint_count = 0;
-
-zusize zemu_debug_continue(Z80 * instance, zinteger run_cycles)
-{
-    /* Return if we've halted. */
-    if (zemu_debug_state == HALTED) return 0;
- 
-    zusize cycles = 0;
-
-    zemu_debug_state = RUNNING;
-
-    /* Run as long as:
-     * We don't hit a breakpoint
-     * We haven't run for more than the number of cycles given
-     */
-    while (zemu_debug_state == RUNNING && (run_cycles < 0 || cycles < run_cycles))
-    {
-        cycles += zemu_debug_step(instance);
-
-        /* See if the Program Counter now matches any address
-         * in the breakpoint array.
-         */
-        for (unsigned int b = 0; b < breakpoint_count; b++)
-        {
-            if (instance->state.pc == breakpoints[b])
-            {
-                zemu_debug_state = BREAK;
-            }
-        }
-    }
-
-    return cycles;
-}
+zboolean halted = FALSE;
 
 zusize zemu_debug_step(Z80 * instance)
 {
     /* Will run for at least one cycle. */
     zusize cycles = z80_run(instance, 1);
 
-    return cycles;
-}
-
-void zemu_debug_halt(void * context, zboolean state)
-{
-    if (state)
-    {
-        zemu_debug_state = HALTED;
-    }
-    else
-    {
-        zemu_debug_state = RUNNING;
-    }
-}
+    /* Execute the per-cycle behaviour of the peripheral devices. */
+    for (zusize i = 0; i < cycles; i++) zemu_io_clock(instance);
 
-void zemu_debug_set_breakpoint(zuint16 address)
-{
-    breakpoints[breakpoint_count] = address;
-    breakpoint_count++;
+    return cycles;
 }
 
 zuint16 zemu_debug_register(Z80 * instance, zuint16 r)
@@ -106,14 +53,19 @@ zuint16 zemu_debug_register(Z80 * instance, zuint16 r)
     }
 }
 
-zboolean zemu_debug_halted(void)
+zuint16 zemu_debug_pc(Z80 * instance)
+{
+    return instance->state.pc;
+}
+
+void zemu_debug_halt(void * context, zboolean state)
 {
-    return (zemu_debug_state == HALTED);
+    halted = state;
 }
 
-zboolean zemu_debug_break(void)
+zboolean zemu_debug_halted(void)
 {
-    return (zemu_debug_state == BREAK);
+    return (halted);
 }
 
 zuint8 zemu_debug_get_memory(zuint16 address)

data/src/debug.h

@@ -3,28 +3,16 @@
 #include <stdio.h>
 
 #include "memory.h"
-
-/* Define number of breakpoints, if not done so already. */
-#ifndef ZEMU_DEBUG_MAX_BREAKPOINTS
-#define ZEMU_DEBUG_MAX_BREAKPOINTS 256
-#endif
-
-typedef enum RunState
-{
-    RUNNING,
-    HALTED,
-    BREAK,
-    UNDEFINED
-} RunState;
-
-zusize zemu_debug_continue(Z80 * instance, zinteger run_cycles);
+#include "io.h"
 
 zusize zemu_debug_step(Z80 * instance);
 
 void zemu_debug_halt(void * context, zboolean state);
 
 zboolean zemu_debug_halted(void);
-
-void zemu_debug_set_breakpoint(zuint16 address);
+zboolean zemu_debug_break(void);
+zboolean zemu_debug_running(void);
 
 zuint16 zemu_debug_register(Z80 * instance, zuint16 r);
+
+zuint16 zemu_debug_pc(Z80 * instance);

data/src/io.c.erb

@@ -28,3 +28,15 @@ void zemu_io_out(void * context, zuint16 port, zuint8 value)
 <%= device.write %>
 <% end %>
 }
+
+void zemu_io_nmi(Z80 * instance)
+{
+    z80_nmi(instance);
+}
+
+void zemu_io_clock(Z80 * instance)
+{
+<% io.each do |device| %>
+<%= device.clock %>
+<% end %>
+}

data/src/io.h.erb

@@ -1,3 +1,6 @@
+#ifndef _ZEMU_IO_H
+#define _ZEMU_IO_H
+
 #include "emulation/CPU/Z80.h"
 
 #ifndef ZEMU_IO_SERIAL_BUFFER_SIZE
@@ -16,3 +19,7 @@ zusize zemu_io_serial_buffer_size(void);
 
 zuint8 zemu_io_in(void * context, zuint16 port);
 void zemu_io_out(void * context, zuint16 port, zuint8 value);
+void zemu_io_nmi(Z80 * instance);
+void zemu_io_clock(Z80 * instance);
+
+#endif

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: zemu
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.0
 platform: ruby
 authors:
 - Jay Valentine
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-02-29 00:00:00.000000000 Z
+date: 2020-03-05 00:00:00.000000000 Z
 dependencies: []
 description: |2
       Zemu is a gem which allows the user to configure a Z80-based system