badline 0.15.0 → 0.16.0

data/lib/badline/options/validation.rb

@@ -8,6 +8,18 @@ module Badline
     module Validation
       private
 
+      def sid_card_for(value)
+        raise Error, "invalid argument: --sid-card #{value}" unless SID_MODELS.key?(value)
+
+        SID_MODELS[value]
+      end
+
+      def sid_card_address_for(value)
+        raise Error, "invalid argument: --sid-card-address #{value}" unless SID_CARD_ADDRESSES.key?(value.downcase)
+
+        SID_CARD_ADDRESSES[value.downcase]
+      end
+
       def sid_model_for(value)
         return if value == "auto"
         raise Error, "invalid argument: --sid #{value}" unless SID_MODELS.key?(value)
@@ -27,6 +39,24 @@ module Badline
         PLUS4_RAM[value]
       end
 
+      def pet_ram(value)
+        raise Error, "invalid argument: --ram #{value}" unless PET_RAM.key?(value)
+
+        PET_RAM[value]
+      end
+
+      def plus4_ram_expansion(value)
+        raise Error, "invalid argument: --ram-expansion #{value}" unless PLUS4_RAM_EXPANSIONS.key?(value)
+
+        PLUS4_RAM_EXPANSIONS[value]
+      end
+
+      def drive_type_for(value)
+        raise Error, "invalid argument: --drive-type #{value}" unless PLUS4_DRIVE_TYPES.include?(value)
+
+        value
+      end
+
       def reu_size(value)
         raise Error, "invalid argument: --reu #{value}" unless REU_SIZES.include?(value)
 
@@ -47,6 +77,8 @@ module Badline
 
       def validate
         validate_family
+        raise Error, "--drive-type needs plus4" unless @drive_type.nil? || @family == :plus4
+
         validate_mode
         validate_models
         validate_numbers
@@ -56,6 +88,7 @@ module Badline
       def validate_mode
         if headless?
           raise Error, "#{@window_only.first} needs the window" unless @window_only.empty?
+          raise Error, "#{@any_window_only.first} needs the window" unless player_window? || @any_window_only.empty?
           raise Error, "no tune given" if tune_paths.empty? && !player_window?
 
           tune_paths.each { |path| validate_tune(path) }
@@ -65,16 +98,10 @@ module Badline
       end
 
       def validate_family
-        if @family == :vic20
-          validate_vic20
-        elsif !@ram.nil?
-          raise Error, "--ram needs vic20 or plus4"
-        end
-        if @family == :plus4
-          validate_plus4
-        elsif !@cartridges.empty?
-          raise Error, "--#{@cartridges.keys.first} needs plus4"
-        end
+        ram_option
+        validate_vic20 if @family == :vic20
+        @family == :plus4 ? validate_plus4 : refuse_plus4_options
+        @family == :pet ? validate_pet : refuse_pet_options
         if @family == :c128
           validate_c128
         elsif @c64_mode
@@ -82,6 +109,19 @@ module Badline
         end
       end
 
+      # --ram names the VIC-20's RAM expansion, or the Plus/4's or the PET's
+      # RAM.
+      def ram_option
+        return if @ram_name.nil?
+
+        case @family
+        when :vic20 then @ram = ram_configuration(@ram_name)
+        when :plus4 then @ram_kb = plus4_ram(@ram_name)
+        when :pet then @ram_kb = pet_ram(@ram_name)
+        else raise Error, "--ram needs vic20, plus4 or pet"
+        end
+      end
+
       # The C128 runs in the window, without an REU, and its NTSC models
       # have names of their own.
       def validate_c128
@@ -100,19 +140,82 @@ module Badline
         raise Error, "the VIC-20 needs the window" if headless?
       end
 
-      # The Plus/4 runs in the window, without the C64's SID and REU, its
-      # NTSC models have names of their own, and its cartridge slots take
-      # raw ROM images.
+      # Only the Plus/4 has cartridge slots for raw ROM images and takes a
+      # SID card and a RAM expansion.
+      def refuse_plus4_options
+        raise Error, "--#{@cartridges.keys.first} needs plus4" unless @cartridges.empty?
+        raise Error, "--sid-card needs plus4" unless @sid_card.nil?
+        raise Error, "--sid-card-address needs plus4" unless @sid_card_address.nil?
+        raise Error, "--ram-expansion needs plus4" unless @ram_expansion.nil?
+      end
+
+      # The Plus/4 runs in the window, without the C64's SID and REU but
+      # with a SID card if asked, its NTSC models have names of their own,
+      # and its cartridge slots take raw ROM images.
       def validate_plus4
         raise Error, "--ntsc needs the C64; the NTSC Plus/4 is --model plus4ntsc" if @models.include?("ntsc")
-        raise Error, "--sid needs the C64" unless @sid_model.nil?
+        raise Error, "--sid needs the C64; the Plus/4's is --sid-card" unless @sid_model.nil?
         raise Error, "--reu needs the C64" unless @reu.nil?
         raise Error, "the Plus/4 needs the window" if headless?
 
+        validate_plus4_expansions
         image = @cartridges.values.find { |path| !File.extname(path).casecmp?(".bin") }
         raise Error, "not a .bin ROM image: #{image}" unless image.nil?
       end
 
+      # A RAM expansion goes over 64K, and a SID card's address needs a
+      # card.
+      def validate_plus4_expansions
+        raise Error, "--ram-expansion needs 64k" unless @ram_expansion.nil? || [nil, 64].include?(@ram_kb)
+        raise Error, "--sid-card-address needs --sid-card" unless @sid_card_address.nil? || @sid_card
+      end
+
+      # Only the PET has a frame rate to pick and BASIC and editor ROMs to
+      # fit.
+      def refuse_pet_options
+        raise Error, "--60hz needs pet" unless @refresh_hz.nil?
+        raise Error, "--basic needs pet" unless @basic.nil?
+        raise Error, "--editor needs pet" unless @editor.nil?
+      end
+
+      # The PET runs in the window, without the C64's SID and REU or a true
+      # drive, at the frame rate its editor sets.
+      def validate_pet
+        raise Error, "--ntsc needs the C64; a CRTC PET's 60 Hz editor is --60hz" if @models.include?("ntsc")
+        raise Error, "--sid needs the C64" unless @sid_model.nil?
+        raise Error, "--reu needs the C64" unless @reu.nil?
+        raise Error, "the PET has no true drive yet" if @true_drive
+        raise Error, "the PET needs the window" if headless?
+
+        validate_pet_roms if PET_MODELS.include?(model)
+      end
+
+      # --basic and --editor name ROMs the model's board takes
+      # (PET::ROMSets), and an editor named sets the frame rate.
+      def validate_pet_roms
+        raise Error, "invalid argument: --basic #{@basic}" unless @basic.nil? || PET::ROMSets::BASICS.key?(@basic)
+        raise Error, "invalid argument: --editor #{@editor}" unless @editor.nil? || PET::ROMSets::EDITORS.key?(@editor)
+
+        basic = @basic || PET::ROMSets.stock_basic(model)
+        fitting = PET::ROMSets.editors(model, basic)
+        raise Error, "the #{model} takes no BASIC #{basic}" if fitting.empty?
+        return if @editor.nil?
+        raise Error, "the #{model} with BASIC #{basic} takes no editor #{@editor}" unless fitting.include?(@editor)
+
+        editor_rate(fitting)
+      end
+
+      # The frame rate of the editor named, on a CRTC board, which has a 50
+      # Hz and a 60 Hz one.
+      def editor_rate(fitting)
+        return if fitting.size == 1
+
+        editor_hz = @editor == fitting.last ? 60 : 50
+        raise Error, "--60hz takes a 60 Hz editor, not #{@editor}" if @refresh_hz == 60 && editor_hz == 50
+
+        @refresh_hz = editor_hz
+      end
+
       # `sid` takes directories as well as tunes.
       def validate_tune(path)
         return if !File.exist?(path) || File.extname(path).casecmp?(".sid")

data/lib/badline/options.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "badline/pet/rom_sets"
 require "badline/options/option"
 require "badline/options/event"
 require "badline/options/table"
@@ -12,10 +13,12 @@ module Badline
   # Either opens the window for any media, or with --headless or
   # --audio-out plays or renders a .sid tune without one. `sid`, given
   # first, plays .sid tunes and directories of them in the terminal.
-  # `c64`, `vic20`, `c128` or `plus4`, given first, names the machine
-  # family, and without one the family is the C64, or the C128 for a program
-  # that loads where C128 BASIC starts. The native build adds --no-sound and
-  # --version, and badline-ruby adds --disable-jit.
+  # `c64`, `vic20`, `c128`, `plus4` or `pet`, given first, names the
+  # machine family, and without one the family is the C64, the C128 for a
+  # program that loads where C128 BASIC starts, or the PET for an 8050's
+  # or 8250's disk or a PET tape.
+  # The native build adds --no-sound and --version, and badline-ruby adds
+  # --disable-jit.
   #
   # TABLE lists the options, and both the parser and the help read it. It
   # parses by hand, inside the subset of Ruby Spinel compiles. Values come
@@ -51,6 +54,15 @@ module Badline
     # The Plus/4's RAM sizes as --ram names them, in K.
     PLUS4_RAM = { "16k" => 16, "32k" => 32, "64k" => 64 }.freeze
 
+    # The PET's, below $8000.
+    PET_RAM = { "4k" => 4, "8k" => 8, "16k" => 16, "32k" => 32 }.freeze
+
+    # Where --sid-card-address puts the Plus/4's SID card.
+    SID_CARD_ADDRESSES = { "fd40" => 0xfd40, "fe80" => 0xfe80 }.freeze
+
+    # The Plus/4's RAM expansions as --ram-expansion names them.
+    PLUS4_RAM_EXPANSIONS = { "hannes256" => :hannes256, "hannes1m" => :hannes1m, "csory256" => :csory256 }.freeze
+
     # The Plus/4's cartridge slots, by the options that fill them and
     # xplus4's names (Media::Plus4Media::SLOTS).
     CARTRIDGE_SLOTS = { "--c1lo" => "c1lo", "--c1hi" => "c1hi", "--c2lo" => "c2lo", "--c2hi" => "c2hi" }.freeze
@@ -64,22 +76,38 @@ module Badline
     attr_reader :program, :media_path, :tune_paths, :subtune, :sid_model, :reu, :frames, :screenshot, :save_snapshot,
                 :audio_out, :seconds, :songlengths, :filter_chunk, :timeline
 
-    # The machine family to build (Badline::Machine), :c64, :vic20, :c128
-    # or :plus4.
+    # The machine family to build (Badline::Machine), :c64, :vic20, :c128,
+    # :plus4 or :pet.
     attr_reader :family
 
+    # The ROMs --basic and --editor fit a PET with, keys of
+    # PET::ROMSets::BASICS and PET::ROMSets::EDITORS, or nil for its own.
+    attr_reader :basic, :editor
+
     # The VIC-20's RAM expansion --ram names, a key of
     # Vic20::Bus::RAM_CONFIGURATIONS, or nil without --ram.
     attr_reader :ram
 
-    # The Plus/4's RAM in K --ram names, one of PLUS4_RAM's, or nil without
-    # --ram.
+    # The Plus/4's or the PET's RAM in K --ram names, one of PLUS4_RAM's or
+    # PET_RAM's, or nil without --ram.
     attr_reader :ram_kb
 
     # The Plus/4's cartridge ROM images --c1lo, --c1hi, --c2lo and --c2hi
     # name, by slot: { "c1lo" => path }.
     attr_reader :cartridges
 
+    # The SID model of the Plus/4's SID card --sid-card names, :mos6581 or
+    # :mos8580, or nil without one.
+    attr_reader :sid_card
+
+    # Where --sid-card-address puts the Plus/4's SID card, $FD40 without
+    # it.
+    attr_reader :sid_card_address
+
+    # The Plus/4's RAM expansion --ram-expansion names, a key of
+    # Plus4::RAMExpansion::KINDS, or nil without one.
+    attr_reader :ram_expansion
+
     def self.parse(argv, native: false) = new(native:).parse(argv)
 
     # The native build plays the SID in the window unless --no-sound says
@@ -96,10 +124,17 @@ module Badline
       @tune_paths = []
       @subtune = nil
       @sid_model = nil
+      @sid_card = nil
+      @sid_card_address = nil
+      @ram_expansion = nil
       @models = []
       @reu = nil
       @ram = nil
       @ram_kb = nil
+      @ram_name = nil
+      @refresh_hz = nil
+      @basic = nil
+      @editor = nil
       @cartridges = {}
       @autostart = true
       @writable = false
@@ -109,6 +144,7 @@ module Badline
       @vsync = true
       @verbose = false
       @true_drive = false
+      @drive_type = nil
       @screenshot = ""
       @save_snapshot = ""
       @vice = false
@@ -126,6 +162,7 @@ module Badline
       @tui = true
       @all_subtunes = false
       @window_only = []
+      @any_window_only = []
       @headless_only = []
     end
 
@@ -187,7 +224,10 @@ module Badline
 
     def verbose? = @verbose
 
-    def true_drive? = @true_drive
+    def true_drive? = @true_drive || !@drive_type.nil?
+
+    # The Plus/4's true drive --drive-type names, "1551" without it.
+    def drive_type = @drive_type || "1551"
 
     # Whether --save-snapshot adds VICE's modules, so x64sc opens it.
     def vice? = @vice
@@ -203,6 +243,10 @@ module Badline
     # power-on.
     def c64_mode? = @c64_mode
 
+    # The frame rate of a CRTC PET's editor: 60 with --60hz or a 60 Hz
+    # --editor, else 50.
+    def refresh_hz = @refresh_hz || 50
+
     def help? = @help
 
     def version? = @version
@@ -218,7 +262,7 @@ module Badline
     # A .sid on its own plays in the SID player, as `sid` would, unless an
     # option of the emulator's window asks for the machine.
     def play_lone_tune
-      return if @sid_command || %i[vic20 plus4].include?(@family) || headless? || !@window_only.empty?
+      return if @sid_command || %i[vic20 plus4 pet].include?(@family) || headless? || !@window_only.empty?
       return if @media_path.nil?
 
       @sid_command = File.extname(@media_path).casecmp?(".sid")
@@ -254,9 +298,11 @@ module Badline
       option
     end
 
-    # Notes an option only the window or only the headless player takes.
+    # Notes an option only the window, only a window of either kind, or
+    # only the headless player takes.
     def restrict(option, flag)
       @window_only << flag if option.needs == :window
+      @any_window_only << flag if option.needs == :any_window
       @headless_only << flag if option.needs == :headless
     end
 
@@ -270,9 +316,15 @@ module Badline
       case name
       when "--subtune" then @subtune = number(flag, value)
       when "--sid" then @sid_model = sid_model_for(value)
+      when "--sid-card" then @sid_card = sid_card_for(value)
+      when "--sid-card-address" then @sid_card_address = sid_card_address_for(value)
+      when "--ram-expansion" then @ram_expansion = plus4_ram_expansion(value)
       when "--model" then @models << value
       when "--reu" then @reu = reu_size(value)
-      when "--ram" then ram_option(value)
+      when "--ram" then @ram_name = value
+      when "--basic" then @basic = value
+      when "--editor" then @editor = value
+      when "--drive-type" then @drive_type = drive_type_for(value)
       when "--c1lo", "--c1hi", "--c2lo", "--c2hi" then @cartridges[CARTRIDGE_SLOTS.fetch(name)] = value
       when "--frames" then @frames = number(flag, value)
       when "--screenshot" then @screenshot = value
@@ -286,15 +338,6 @@ module Badline
       end
     end
 
-    # --ram names the VIC-20's RAM expansion, or the Plus/4's RAM.
-    def ram_option(value)
-      if @family == :plus4
-        @ram_kb = plus4_ram(value)
-      else
-        @ram = ram_configuration(value)
-      end
-    end
-
     def switch(name)
       case name
       when "--no-autostart" then @autostart = false
@@ -307,6 +350,7 @@ module Badline
       when "--vice" then @vice = true
       when "--ntsc" then @models << "ntsc"
       when "--c64" then @c64_mode = true
+      when "--60hz" then @refresh_hz = 60
       when "--unpaced" then @paced = false
       when "--disable-jit" then @jit = false
       when "--help" then @help = true

data/lib/badline/pet/bus/expansion.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Badline
+  class PET
+    class Bus
+      # The 8096's 64K board: four 16K banks, which a write-only control
+      # register at $FFF0 lays over $8000-$FFFF, two at a time:
+      #
+      #   bit 7  the board on; when clear, a plain 8032 and the rest ignored
+      #   bit 6  I/O shows through at $E800-$EFFF
+      #   bit 5  the screen shows through at $8000-$8FFF
+      #   bit 3  bank 3 at $C000-$FFFF, else bank 1
+      #   bit 2  bank 2 at $8000-$BFFF, else bank 0
+      #   bit 1  writes to $C000-$FFFF go nowhere
+      #   bit 0  writes to $8000-$BFFF go nowhere
+      #
+      # A write to $FFF0 lands where $FFF0 was before it, too. The RES line
+      # clears the register, so the 8096 starts as an 8032.
+      class Expansion
+        # A 16K bank of the board, seen from +start+.
+        class Window
+          attr_accessor :read_only
+
+          def initialize(cells, offset, start)
+            @cells = cells
+            @offset = offset - start
+            @read_only = false
+          end
+
+          def peek(addr) = @cells[addr + @offset]
+
+          def poke(addr, value)
+            @cells[addr + @offset] = value unless @read_only
+          end
+        end
+
+        # Page $FF's writes, which pass to what the page holds and set the
+        # control register at $FFF0.
+        class ControlPort
+          attr_accessor :under
+
+          def initialize(expansion, under)
+            @expansion = expansion
+            @under = under
+          end
+
+          def poke(addr, value)
+            @under.poke(addr, value)
+            @expansion.control = value if addr == 0xfff0
+          end
+        end
+
+        attr_reader :cells, :control
+
+        def initialize(bus)
+          @bus = bus
+          @cells = Array.new(0x10000, 0)
+          @banks = [0x8000, 0xc000, 0x8000, 0xc000].each_with_index.map do |start, bank|
+            Window.new(@cells, bank * 0x4000, start)
+          end
+          @port = ControlPort.new(self, @banks[1])
+          @control = 0
+        end
+
+        def control=(value)
+          @control = value
+          @bus.map_pages
+        end
+
+        def reset!
+          self.control = 0
+        end
+
+        def power_on!
+          @cells.fill(0)
+        end
+
+        # Lays the banks the register picks over the pages, and the
+        # control register over page $FF's writes.
+        def map(reads, writes)
+          map_banks(reads, writes) if @control.anybits?(0x80)
+          @port.under = writes[0xff]
+          writes[0xff] = @port
+        end
+
+        private
+
+        def map_banks(reads, writes)
+          low = @banks[@control.anybits?(0x04) ? 2 : 0]
+          high = @banks[@control.anybits?(0x08) ? 3 : 1]
+          low.read_only = @control.anybits?(0x01)
+          high.read_only = @control.anybits?(0x02)
+          first = @control.anybits?(0x20) ? 0x90 : 0x80
+          reads.fill(low, first, 0xc0 - first)
+          writes.fill(low, first, 0xc0 - first)
+          [[0xc0, 0x28], [0xe8, 0x08], [0xf0, 0x10]].each do |page, count|
+            next if page == 0xe8 && @control.anybits?(0x40)
+
+            reads.fill(high, page, count)
+            writes.fill(high, page, count)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/badline/pet/bus.rb

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+require "badline/pet/bus/expansion"
+
+module Badline
+  class PET
+    # The CPU's bus:
+    #
+    # $0000-$7FFF - RAM, 4K, 8K, 16K or 32K of it from $0000, then nothing
+    # $8000-$8FFF - screen RAM, repeated (Model), then nothing
+    # $9000-$AFFF - two empty ROM sockets
+    # $B000-$DFFF - BASIC 4, or BASIC 1 or 2 from $C000
+    # $E000-$E7FF - the screen editor ROM
+    # $E800-$E8FF - I/O (IO)
+    # $E900-$EFFF - nothing
+    # $F000-$FFFF - the KERNAL ROM
+    #
+    # The data lines hold the last byte they carried, so a read from an
+    # empty spot finds it, mostly the high byte of the address just
+    # fetched, as PET/unconnected shows on a real 3016. Writes to ROM and
+    # to empty spots go nowhere. An 8096 banks its 64K board over
+    # $8000-$FFFF (Expansion).
+    class Bus
+      include Addressable
+
+      # The last byte the CPU moved, which an empty spot reads back.
+      class OpenBus
+        def initialize(bus)
+          @bus = bus
+        end
+
+        def peek(_addr) = @bus.data
+        def poke(_addr, _value); end
+      end
+
+      # Screen RAM, repeated over the pages it answers in.
+      class ScreenRAM
+        attr_reader :cells
+
+        def initialize(size)
+          @cells = Array.new(size, 0)
+          @mask = size - 1
+        end
+
+        def peek(addr) = @cells[addr & @mask]
+
+        def poke(addr, value)
+          @cells[addr & @mask] = value
+        end
+      end
+
+      # $E800-$E8FF. Each chip answers on one address line, with its
+      # registers repeated: A4 selects PIA 1, A5 PIA 2, A6 the VIA and A7
+      # the CRTC, where there is one. Where more than one chip answers a
+      # read, each pulls the lines it drives low, so the CPU reads the AND
+      # of them, and a write reaches them all. Where none answers, as in
+      # $E800-$E80F, the CPU reads the last byte on the bus.
+      class IO
+        def initialize(bus, pia1:, pia2:, via:, crtc:, crtc_fitted:)
+          @bus = bus
+          @pia1 = pia1
+          @pia2 = pia2
+          @via = via
+          @crtc = crtc
+          @lines = crtc_fitted ? 0xf0 : 0x70
+        end
+
+        def peek(addr)
+          return @bus.data if addr.nobits?(@lines)
+
+          value = 0xff
+          value &= @pia1.peek(addr) if addr.anybits?(0x10)
+          value &= @pia2.peek(addr) if addr.anybits?(0x20)
+          value &= @via.peek(addr) if addr.anybits?(0x40)
+          value &= @crtc.peek(addr) if addr.anybits?(@lines & 0x80)
+          value
+        end
+
+        def poke(addr, value)
+          @pia1.poke(addr, value) if addr.anybits?(0x10)
+          @pia2.poke(addr, value) if addr.anybits?(0x20)
+          @via.poke(addr, value) if addr.anybits?(0x40)
+          @crtc.poke(addr, value) if addr.anybits?(@lines & 0x80)
+          @bus.io_written
+        end
+      end
+
+      # VICE's debug cartridge register at $8BFF, which a write calls the
+      # handler with, the exit code the VICE testprogs report. It answers
+      # on every model, ahead of the 2001's screen RAM there and the
+      # 8096's banks, and every other write to its page passes to what
+      # the page holds.
+      class DebugRegister
+        ADDRESS = 0x8bff
+
+        attr_accessor :under
+
+        def initialize(&handler)
+          @handler = handler
+          @under = nil
+        end
+
+        def poke(addr, value)
+          return @handler.call(value) if addr == ADDRESS
+
+          @under.poke(addr, value)
+        end
+      end
+
+      attr_reader :ram, :screen, :expansion
+
+      # The last byte the CPU read or wrote.
+      attr_reader :data
+
+      # +model+ is a Model::Profile, +ram_kb+ the RAM below $8000 and
+      # +editor+ the editor ROM's file. The CRTC answers only on a board
+      # the model fits one on.
+      def initialize(model:, ram_kb:, editor:, pia1:, pia2:, via:, crtc:)
+        addressable_at(0, length: 2**16)
+        @ram = Memory.new([], length: ram_kb * 1024, start: 0)
+        @screen = ScreenRAM.new(model.screen_bytes)
+        @screen_pages = model.screen_pages
+        basic = ROM.read(model.basic)
+        @basic_rom = ROM.new(basic, length: basic.length, start: 0xe000 - basic.length)
+        @editor_rom = ROM.load(editor, 0xe000)
+        @kernal_rom = ROM.load(model.kernal, 0xf000)
+        @io = IO.new(self, pia1:, pia2:, via:, crtc:, crtc_fitted: model.crtc?)
+        @open_bus = OpenBus.new(self)
+        @data = 0
+        @read_pages = Array.new(256, @open_bus)
+        @write_pages = Array.new(256, @open_bus)
+        @expansion = model.expansion ? Expansion.new(self) : nil
+        @debug_register = nil
+        @io_write_handler = nil
+        map_pages
+      end
+
+      # Calls the block after each write to the I/O chips, which may have
+      # moved the lines their ports drive.
+      def on_io_write(&handler)
+        @io_write_handler = handler
+      end
+
+      def io_written
+        @io_write_handler&.call
+      end
+
+      # The RES line reaches the 8096's control register.
+      def reset!
+        @expansion&.reset!
+      end
+
+      def power_on!
+        @ram.clear!
+        @screen.cells.fill(0)
+        @expansion&.power_on!
+      end
+
+      def peek(addr)
+        @data = @read_pages[addr >> 8].peek(addr)
+      end
+
+      def poke(addr, value)
+        @data = value
+        @write_pages[addr >> 8].poke(addr, value)
+      end
+
+      # Whether the CPU reads the KERNAL ROM at $F000-$FFFF, which an 8096's
+      # board covers while its control register turns it on.
+      def kernal_mapped? = @expansion.nil? || @expansion.control.nobits?(0x80)
+
+      # Calls the block with each byte written to $8BFF (DebugRegister).
+      def install_debug_register(&)
+        @debug_register = DebugRegister.new(&)
+        map_pages
+      end
+
+      # Lays the pages out again, for the 8096's control register.
+      def map_pages
+        map(@open_bus, 0x00, 0x100)
+        map(@ram, 0x00, @ram.length >> 8)
+        map(@screen, 0x80, @screen_pages)
+        @read_pages.fill(@basic_rom, @basic_rom.start >> 8, @basic_rom.length >> 8)
+        @read_pages.fill(@editor_rom, 0xe0, 0x08)
+        map(@io, 0xe8, 0x01)
+        @read_pages.fill(@kernal_rom, 0xf0, 0x10)
+        @expansion&.map(@read_pages, @write_pages)
+        map_debug_register if @debug_register
+      end
+
+      private
+
+      def map_debug_register
+        @debug_register.under = @write_pages[0x8b]
+        @write_pages[0x8b] = @debug_register
+      end
+
+      def map(chip, first, count)
+        @read_pages.fill(chip, first, count)
+        @write_pages.fill(chip, first, count)
+      end
+    end
+  end
+end