badline 0.9.0 → 0.10.0

data/lib/badline/vic20/vic/text_window.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Badline
+  class Vic20
+    class VIC
+      # The text window's rows: where it opens and closes, the video matrix
+      # counter and the character line, and the registers that place the
+      # window and its memory.
+      module TextWindow
+        private
+
+        def new_frame
+          @window_open = @window_done = false
+          @row_start = @matrix = @char_line = @text_rows = 0
+        end
+
+        def open_window
+          @window_open = true
+          @char_line = 0
+          @matrix = @row_start
+        end
+
+        # Steps to the next line of the text row, or past the row's last line
+        # to the next row, closing the window after the last.
+        def next_text_line
+          @char_line += 1
+          if @char_line < (1 << @char_shift)
+            @matrix = @row_start
+            return
+          end
+
+          @char_line = 0
+          @row_start = @matrix
+          @text_rows += 1
+          return if @text_rows < @rows
+
+          @window_open = false
+          @window_done = true
+        end
+
+        # $9000 and $9002 move the window's fetches on the line, or only where
+        # they end once they've started.
+        def window_written
+          @origin_x = @registers[0] & 0x7f
+          @columns = @registers[2] & 0x7f
+          bases_written
+          return unless @window_open
+
+          if @column < @fetch_from
+            place_fetches
+          else
+            fetches_end
+          end
+          schedule
+        end
+
+        def rows_written(value)
+          @rows = (value >> 1) & 0x3f
+          @char_shift = value.anybits?(0x01) ? 4 : 3
+        end
+
+        # The video matrix at $9005 bits 7-4 and $9002 bit 7, address bits
+        # 13-9, and the characters at $9005 bits 3-0, bits 13-10.
+        def bases_written
+          @screen_base = ((@registers[5] & 0xf0) << 6) | ((@registers[2] & 0x80) << 2)
+          @char_base = (@registers[5] & 0x0f) << 10
+        end
+      end
+    end
+  end
+end

data/lib/badline/vic20/vic.rb

@@ -0,0 +1,267 @@
+# frozen_string_literal: true
+
+require "badline/vic20/vic/painter"
+require "badline/vic20/vic/text_window"
+require "badline/vic20/vic/saved_state"
+
+module Badline
+  class Vic20
+    # The VIC-I, the 6561 on PAL machines: its sixteen registers, the
+    # raster, the text window's fetches over the V-bus and the picture. The
+    # writes to the sound's registers, $900A-$900E, go on to the Sound
+    # attached as #sound.
+    #
+    # The registers repeat through $9000-$90FF. $9003 bit 7 and $9004 read
+    # the raster line, its bit 0 and bits 8-1. $9006 and $9007 read the
+    # light pen, which nothing triggers yet, and $9008 and $9009 the two
+    # pots, which read $FF with nothing plugged in. The other registers
+    # read back what was written to them.
+    #
+    # The text window opens on the line where the raster's bits 8-1 match
+    # $9001, and closes after the number of text rows in $9003, each 8 lines
+    # of a character, or 16 with $9003 bit 0 set. On each of its lines the
+    # VIC fetches two bytes a character, $9002's count of them: the
+    # character code from the video matrix, with the colour nibble beside it
+    # on the colour bus, then the character's pattern byte for the line.
+    # The first code is fetched four cycles after the column in $9000, so
+    # the window starts 16 cycles into the line with the KERNAL's origin of
+    # 12, and none is fetched past the end of the line. The fetches go to a
+    # 14-bit address, the VIC's own (see Bus#video_fetch), and the byte each
+    # one reads is the V-bus's last byte. Outside the window the 6561E
+    # fetches nothing and the V-bus keeps the CPU's last byte there.
+    #
+    # The video matrix counter steps once a character. It starts each line
+    # of a text row where the row started, and the next row starts where
+    # the last line of the row left it. It starts the frame at zero.
+    #
+    # The picture is 4 pixels a cycle, so 284 a line. A character's 8
+    # pixels come out in the two cycles after its pattern fetch. The
+    # display's lines start 6 cycles after the raster count moves, as
+    # xvic's view of the frame does, so the character fetched 16 cycles
+    # into the line lands 48 pixels in. Lines 0-27 are blanked.
+    class VIC
+      include TextWindow
+      include SavedState
+
+      # What a VIC-I sets for the machine: the clock, the raster's cycles
+      # per line and lines per frame, and how many lines at the top of the
+      # frame it blanks. The 6560 of NTSC machines, with its half lines and
+      # the interlace of $9000 bit 7, would be another.
+      Profile = Data.define(:clock_hz, :cycles_per_line, :lines_per_frame, :blanked_lines)
+
+      # The 6561: 71 cycles by 312 lines, lines 0-27 blanked (Marko
+      # Mäkelä's VIC-I.txt).
+      PAL = Profile.new(clock_hz: 1_108_405, cycles_per_line: 71, lines_per_frame: 312, blanked_lines: 28)
+
+      PIXELS_PER_CYCLE = 4
+
+      # The column whose pixels start a line of the display.
+      FIRST_PIXEL_COLUMN = 6
+
+      # How many cycles after the column in $9000 the first code is fetched.
+      FETCH_DELAY = 4
+
+      # The colours, as RGB, each from its luma and chroma: luma in five
+      # levels from black to white, and chroma at one strength in a phase
+      # that steps by 22.5 degrees from blue's. The levels and phases are
+      # the VIC-I's table on Wikipedia's "MOS Technology VIC" (Y, Pb, Pr),
+      # turned into RGB with the BT.601 matrix and the chroma scaled by 0.2.
+      PALETTE = [
+        0x000000, 0xffffff, 0x82251d, 0x7ddae2, 0xb259bf, 0x4da640, 0x402e9a, 0xbfd165,
+        0xb27240, 0xf2b27f, 0xc2655d, 0xbdffff, 0xf299ff, 0x8de57f, 0x806eda, 0xffffa5
+      ].freeze
+
+      attr_reader :rasterline, :column, :profile
+      attr_accessor :sound
+
+      def initialize(profile = PAL)
+        @profile = profile
+        @cycles_per_line = profile.cycles_per_line
+        @lines_per_frame = profile.lines_per_frame
+        @painter = Painter.new(@lines_per_frame, @cycles_per_line * PIXELS_PER_CYCLE, profile.blanked_lines)
+        @patterns = @painter.patterns
+        @colors = @painter.colors
+        @counts = @painter.counts
+        @starts = @painter.starts
+        @stale = @painter.stale
+        @bus = nil
+        @sound = nil
+        @color_cells = Array.new(0x400, 0)
+        power_on!
+      end
+
+      # The bus the VIC fetches from, the machine's, and the colour RAM
+      # whose cells come in on the colour bus beside each code.
+      def connect(bus)
+        @bus = bus
+        @color_cells = bus.color_ram.cells
+      end
+
+      # The power-on state: the registers cleared and the raster at the top
+      # of the frame. The VIC has no RES pin, so only power reaches it.
+      def power_on!
+        @registers = Array.new(16, 0)
+        @rasterline = 0
+        @column = 0
+        @origin_x = @origin_y = @columns = @rows = 0
+        @char_shift = 3
+        @screen_base = @char_base = 0
+        new_frame
+        @fetch_from = @fetch_to = 0
+        @fetched = @slot = 0
+        @code = 0
+        @painter.power_on!(@lines_per_frame - 1)
+        schedule
+      end
+
+      def cycle!
+        column = @column + 1
+        @column = column
+        return unless column == @next_event
+
+        if column > FIRST_PIXEL_COLUMN && column < @fetch_to && column >= @fetch_from
+          access(column)
+          column += 1
+          @next_event = column < @fetch_to ? column : @cycles_per_line
+        else
+          event(column)
+        end
+      end
+
+      # The sixteen registers as written.
+      def register_file = @registers.dup
+
+      # The display, a palette index a pixel, 284 to a line and every line
+      # of the frame.
+      def display = @painter.display
+
+      def width = @painter.width
+
+      def height = @lines_per_frame
+
+      # Whether each line of the display has changed since the front end
+      # last cleared them.
+      def dirty_lines = @painter.dirty_lines
+
+      def clear_dirty_lines! = @painter.clear_dirty_lines!
+
+      def palette = PALETTE
+
+      # Whether the VIC paints its display. It fetches either way.
+      def render = @painter.render
+
+      def render=(value)
+        @painter.render = value
+      end
+
+      def peek(addr)
+        register = addr & 0x0f
+        case register
+        when 0x03 then ((@rasterline & 0x01) << 7) | (@registers[3] & 0x7f)
+        when 0x04 then @rasterline >> 1
+        when 0x06, 0x07 then 0
+        when 0x08, 0x09 then 0xff
+        else @registers[register]
+        end
+      end
+
+      def poke(addr, value)
+        register = addr & 0x0f
+        @registers[register] = value
+        case register
+        when 0x00, 0x02 then window_written
+        when 0x01 then @origin_y = value
+        when 0x03 then rows_written(value)
+        when 0x05 then bases_written
+        when 0x0a, 0x0b, 0x0c, 0x0d then @sound&.write(register, value)
+        when 0x0e
+          @painter.aux_written(pixel_position, value >> 4)
+          @sound&.write(register, value)
+        when 0x0f then @painter.colors_written(pixel_position, value)
+        end
+      end
+
+      private
+
+      def event(column)
+        if column == @cycles_per_line
+          column = @column = 0
+          start_line
+        end
+        @painter.finish_line(@rasterline) if column == FIRST_PIXEL_COLUMN
+        access(column) if column >= @fetch_from && column < @fetch_to
+        schedule
+      end
+
+      # The next column with something to do: the end of the line, the
+      # start of a display line, or a fetch.
+      def schedule
+        column = @column
+        upcoming = column < FIRST_PIXEL_COLUMN ? FIRST_PIXEL_COLUMN : @cycles_per_line
+        fetch = column < @fetch_from ? @fetch_from : column + 1
+        upcoming = fetch if fetch < @fetch_to && fetch < upcoming
+        @next_event = upcoming
+      end
+
+      def start_line
+        line = @rasterline + 1
+        if line == @lines_per_frame
+          line = 0
+          new_frame
+        end
+        @rasterline = line
+        next_text_line if @window_open
+        open_window if !@window_open && !@window_done && (line >> 1) == @origin_y && @rows.positive?
+        place_fetches
+      end
+
+      def place_fetches
+        line = @rasterline
+        @slot = line * Painter::SLOTS
+        @fetched = @counts[line] = 0
+        @starts[line] = @origin_x * PIXELS_PER_CYCLE
+        unless @window_open
+          @fetch_from = @fetch_to = 0
+          return
+        end
+
+        @fetch_from = @origin_x + FETCH_DELAY
+        fetches_end
+      end
+
+      def fetches_end
+        last = @fetch_from + (2 * @columns)
+        @fetch_to = [last, @cycles_per_line].min
+      end
+
+      def access(column)
+        slot = @slot + @fetched
+        if (column - @fetch_from).even?
+          address = (@screen_base + @matrix) & 0x3fff
+          @code = @bus.video_fetch(address)
+          color = @color_cells[address & 0x3ff]
+          return if @colors[slot] == color
+
+          @colors[slot] = color
+        else
+          pattern = @bus.video_fetch((@char_base + (@code << @char_shift) + @char_line) & 0x3fff)
+          @matrix += 1
+          @fetched += 1
+          @counts[@rasterline] = @fetched
+          return if @patterns[slot] == pattern
+
+          @patterns[slot] = pattern
+        end
+        @stale[@rasterline] = true
+      end
+
+      # The pixel of the display line a register write in this cycle takes
+      # hold from: the second of the cycle's four.
+      def pixel_position
+        column = @column - FIRST_PIXEL_COLUMN
+        column += @cycles_per_line if column.negative?
+        (column * PIXELS_PER_CYCLE) + 1
+      end
+    end
+  end
+end

data/lib/badline/vic20.rb

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+require "badline/vic20/attachments"
+require "badline/vic20/bus"
+require "badline/vic20/cpu"
+require "badline/vic20/keyboard_via_ports"
+require "badline/vic20/port_wiring"
+require "badline/vic20/user_via_ports"
+require "badline/vic20/vic"
+require "badline/vic20/sound"
+require "badline/vic20/saved_state"
+
+module Badline
+  # The Commodore VIC-20 with the PAL 6561: a 6502 at the VIC's clock, the
+  # VIC-I and two 6522 VIAs. VIA 1, at $9110, pulls NMI, and VIA 2, at
+  # $9120, pulls IRQ. Nothing else interrupts the CPU, and nothing halts
+  # it: the VIC fetches in the half of the cycle the CPU leaves alone.
+  #
+  # It runs in the window, as `badline vic20`, with the VIC's picture and
+  # sound. The keyboard, the joystick and RESTORE reach the VIAs, the
+  # datasette and the serial bus hang off them (PortWiring), and device 8
+  # serves disks through the KERNAL traps or a true 1541.
+  class Vic20
+    include IntegerHelper
+    include KeyboardBuffer
+    include Attachments
+    include PortWiring
+    include SavedState
+
+    attr_reader :bus, :cpu, :vic, :via1, :via2, :keyboard, :joystick1, :cycles, :init_threshold, :sound,
+                :drive1541, :iec_bus, :datasette
+
+    # The RAM expansion it was built with, a key of Bus::RAM_CONFIGURATIONS.
+    attr_reader :ram_configuration
+
+    # The path of the disk or directory device 8 serves through the traps
+    # (Attachments), or an empty one.
+    def mounted_path = @drive.nil? ? "" : @drive.path
+
+    def ram = @bus.ram
+
+    def family = :vic20
+
+    # The one control port's joystick, which the front end's second
+    # joystick drives too.
+    def joystick2 = @joystick1
+
+    # No pot device plugs in yet.
+    def control_ports = nil
+
+    # +ram+ names the RAM expansion, one of Bus::RAM_CONFIGURATIONS.
+    def initialize(ram: :unexpanded, debug: false)
+      @ram_configuration = ram
+      @vic = VIC.new
+      @keyboard = Keyboard.new(matrix: KeyboardVIAPorts::MATRIX)
+      @joystick1 = Joystick.new
+      @iec_bus = IECBus.new
+      @datasette = Datasette.new
+      @via1 = VIA.new(start: 0x9000, peripheral: UserVIAPorts.new(joystick: @joystick1, serial_bus: @iec_bus,
+                                                                  datasette: @datasette))
+      keyboard_ports = KeyboardVIAPorts.new(keyboard: @keyboard, joystick: @joystick1)
+      @via2 = VIA.new(start: 0x9000, peripheral: keyboard_ports)
+      keyboard_ports.connect(@via2)
+      @bus = Bus.new(vic: @vic, via1: @via1, via2: @via2, blocks: Bus::RAM_CONFIGURATIONS.fetch(ram))
+      @vic.connect(@bus)
+      @cpu = CPU.new(@bus, debug:)
+      @cycles = 0
+      @sound = Sound.new(self, @vic.profile.clock_hz)
+      @vic.sound = @sound
+      @nmi_asserted = false
+      @init_handlers = []
+      @pending_keys = nil
+      @drive = nil
+      @serial_trap = nil
+      @save_trap = nil
+      @capture_output = nil
+      @drive1541 = nil
+      @init_threshold = boot_cycles
+      wire_ports
+    end
+
+    # The VIC and the VIAs clock ahead of the CPU, as the C64's chips do,
+    # so a register write lands on the cycle after the one it was issued
+    # on.
+    def cycle!
+      handle_init if @cycles == @init_threshold
+      feed_keyboard if @pending_keys
+
+      @vic.cycle!
+      @via1.cycle!
+      @via2.cycle!
+      @datasette.cycle!
+      @cpu.irq = @via2.irq?
+      drive_nmi
+      @cpu.cycle!
+      @drive1541&.host_cycle!
+
+      @cycles += 1
+    end
+
+    # Runs `count` cycles, one #cycle! after another.
+    def run_cycles(count)
+      i = 0
+      while i < count
+        cycle!
+        i += 1
+      end
+    end
+
+    # Runs cycles until the block returns true or the cycle count passes
+    # `limit`, checking before each cycle.
+    def run_until(limit)
+      cycle! until yield || @cycles > limit
+    end
+
+    # Runs the block once the KERNAL has booted (see init_threshold), or
+    # now if it has.
+    def on_init(&block)
+      if @cycles < @init_threshold
+        @init_handlers << block
+      else
+        block.call
+      end
+    end
+
+    # The chip whose #display a front end shows.
+    def video = @vic
+
+    # What a front end plays: the VIC's sound, which answers #record and
+    # #drain_samples.
+    def sound_source = @sound
+
+    # The PAL clock and raster, and the part of the display xvic shows: all
+    # 284 pixels of a line, from line 28, below the VIC's vertical blank.
+    # The VIC draws 4 pixels a cycle, half as many as the C64's VIC-II on
+    # about the same clock, so each pixel shows two window pixels wide, as
+    # xvic draws them.
+    def timing
+      profile = @vic.profile
+      width = profile.cycles_per_line * VIC::PIXELS_PER_CYCLE
+      blanked = profile.blanked_lines
+      Timing.new(clock_hz: profile.clock_hz, cycles_per_line: profile.cycles_per_line,
+                 lines_per_frame: profile.lines_per_frame,
+                 crop: [0, blanked, width, profile.lines_per_frame - blanked], pixel_width: 2)
+    end
+
+    # The RESTORE key pulls VIA 1's CA1 low while it is held. The KERNAL
+    # sets CA1 to interrupt on that falling edge, and its NMI handler
+    # ($FEAD) warm-starts BASIC if RUN/STOP is down too.
+    def press_restore
+      @via1.ca1 = false
+    end
+
+    def release_restore
+      @via1.ca1 = true
+    end
+
+    # Calls the block with the exit code a VICE testprog writes to $910F.
+    def install_debug_register(&) = @bus.install_debug_register(&)
+
+    # Stores a PRG's bytes from its load address on, as the CPU would, so
+    # bytes for an empty block go nowhere, and returns that address.
+    def load_prg(data)
+      load_addr = uint16(data[0], data[1])
+      bytes = data[2..] || []
+      bytes = bytes[0, 0x10000 - load_addr] if load_addr + bytes.length > 0x10000
+      bytes.each_with_index { |byte, i| @bus.poke(load_addr + i, byte) }
+      load_addr
+    end
+
+    # The RES line reaches the CPU and both VIAs, and through the serial
+    # bus's RESET line, the drive. The VIC has no reset pin.
+    def reset!
+      @via1.reset!
+      @via2.reset!
+      via_written
+      @drive&.reset!
+      @drive1541&.reset!
+      @nmi_asserted = false
+      @cpu.reset!
+    end
+
+    # Switches the machine off and on: RAM and the VIC start from their
+    # power-on state, and the RES line resets everything else.
+    def power_cycle!
+      @bus.power_on!
+      @vic.power_on!
+      @sound.power_on!
+      reset!
+    end
+
+    def inspect
+      "#<#{self.class.name} cycles=#{@cycles} cpu=(#{@cpu.inspect})>"
+    end
+
+    private
+
+    # The cycle by which the KERNAL has booted and BASIC printed READY,
+    # with a margin. The KERNAL's RAM test takes most of it, and runs up
+    # from $1000 until it finds no RAM, so each 8K block on from BLK1
+    # adds about 615,000 cycles. Unexpanded, READY is up by about 557,000.
+    def boot_cycles
+      tested = 0
+      tested += 1 while tested < 3 && @bus.ram?(%i[blk1 blk2 blk3][tested])
+      700_000 + (650_000 * tested)
+    end
+
+    # VIA 1's IRQ output drives NMI, and the CPU takes an interrupt on its
+    # falling edge.
+    def drive_nmi
+      nmi = @via1.irq?
+      @cpu.nmi = true if nmi && !@nmi_asserted
+      @nmi_asserted = nmi
+    end
+
+    def handle_init
+      @init_handlers.each(&:call)
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: badline
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.10.0
 platform: ruby
 authors:
 - Inge Jørgensen
@@ -50,10 +50,10 @@ files:
 - lib/badline.rb
 - lib/badline/address_bus.rb
 - lib/badline/address_bus/extra_sids.rb
+- lib/badline/address_bus/pla.rb
 - lib/badline/address_bus/roms.rb
 - lib/badline/address_bus/saved_state.rb
 - lib/badline/address_bus/sid_slots.rb
-- lib/badline/address_bus/ultimax_pages.rb
 - lib/badline/addressable.rb
 - lib/badline/audio.rb
 - lib/badline/audio/aiff.rb
@@ -155,9 +155,11 @@ files:
 - lib/badline/frontend/gamepads.rb
 - lib/badline/frontend/info_view.rb
 - lib/badline/frontend/keys.rb
+- lib/badline/frontend/machine_window.rb
 - lib/badline/frontend/menu_dialogs.rb
 - lib/badline/frontend/menu_media.rb
 - lib/badline/frontend/menu_pages.rb
+- lib/badline/frontend/menu_ports.rb
 - lib/badline/frontend/name_field.rb
 - lib/badline/frontend/pacer.rb
 - lib/badline/frontend/pad_port.rb
@@ -206,17 +208,22 @@ files:
 - lib/badline/kernal_trap/drive/write_file.rb
 - lib/badline/kernal_trap/drive/writes.rb
 - lib/badline/kernal_trap/file.rb
+- lib/badline/kernal_trap/layout.rb
 - lib/badline/kernal_trap/load.rb
 - lib/badline/kernal_trap/routine.rb
 - lib/badline/kernal_trap/save.rb
 - lib/badline/kernal_trap/serial.rb
 - lib/badline/keyboard.rb
 - lib/badline/keyboard_buffer.rb
+- lib/badline/machine.rb
 - lib/badline/media.rb
 - lib/badline/media/disk_list.rb
 - lib/badline/media/disk_set.rb
 - lib/badline/media/queue.rb
 - lib/badline/media/true_drive.rb
+- lib/badline/media/vic20_basic.rb
+- lib/badline/media/vic20_cartridge.rb
+- lib/badline/media/vic20_media.rb
 - lib/badline/memory.rb
 - lib/badline/model.rb
 - lib/badline/options.rb
@@ -247,6 +254,10 @@ files:
 - lib/badline/roms/eapi/eapi-am29f040-14
 - lib/badline/roms/kernal-sx64.rom
 - lib/badline/roms/kernal.rom
+- lib/badline/roms/vic20/basic.rom
+- lib/badline/roms/vic20/character.rom
+- lib/badline/roms/vic20/kernal-ntsc.rom
+- lib/badline/roms/vic20/kernal-pal.rom
 - lib/badline/sdl.rb
 - lib/badline/sid.rb
 - lib/badline/sid/catch_up.rb
@@ -303,6 +314,7 @@ files:
 - lib/badline/storage/tap.rb
 - lib/badline/storage/unavailable.rb
 - lib/badline/time_of_day.rb
+- lib/badline/timing.rb
 - lib/badline/traps.rb
 - lib/badline/version.rb
 - lib/badline/via.rb
@@ -333,6 +345,20 @@ files:
 - lib/badline/vic/sprite/timing.rb
 - lib/badline/vic/sprites.rb
 - lib/badline/vic/sprites_state.rb
+- lib/badline/vic20.rb
+- lib/badline/vic20/attachments.rb
+- lib/badline/vic20/bus.rb
+- lib/badline/vic20/cpu.rb
+- lib/badline/vic20/keyboard_via_ports.rb
+- lib/badline/vic20/port_wiring.rb
+- lib/badline/vic20/saved_state.rb
+- lib/badline/vic20/sound.rb
+- lib/badline/vic20/sound/output.rb
+- lib/badline/vic20/user_via_ports.rb
+- lib/badline/vic20/vic.rb
+- lib/badline/vic20/vic/painter.rb
+- lib/badline/vic20/vic/saved_state.rb
+- lib/badline/vic20/vic/text_window.rb
 - packaging/homebrew/badline.rb
 homepage: https://github.com/elektronaut/badline
 licenses:

data/lib/badline/address_bus/ultimax_pages.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  class AddressBus
-    # The page tables of an Ultimax cartridge, which AddressBus lays out
-    # in place of the $01 banking while the cartridge holds GAME low and
-    # EXROM high.
-    module UltimaxPages
-      private
-
-      # Ultimax cartridges ignore the $01 lines: 4K of RAM, ROML/ROMH windows,
-      # I/O always visible and open address space everywhere else. The ROML
-      # and ROMH selects fire on writes as well, so cartridge RAM or flash in
-      # either window takes the writes there.
-      def map_ultimax_pages
-        @read_pages.fill(@open_bus, 0x10, 0xf0)
-        @write_pages.fill(@open_bus, 0x10, 0xf0)
-        @read_pages.fill(@cartridge.roml, 0x80, 0x20) if @cartridge.roml
-        map_ultimax_writes(@cartridge.roml, 0x80)
-        @read_pages.fill(@cartridge.romh, 0xe0, 0x20) if @cartridge.romh
-        map_ultimax_writes(@cartridge.romh, 0xe0)
-        map_ultimax_a000
-        map_io_pages
-      end
-
-      def map_ultimax_writes(bank, first_page)
-        @write_pages.fill(bank, first_page, 0x20) if bank.respond_to?(:poke)
-      end
-
-      def map_ultimax_a000
-        return unless (window = @cartridge.ultimax_a000)
-
-        @read_pages.fill(window, 0xa0, 0x20)
-        @write_pages.fill(window, 0xa0, 0x20)
-      end
-    end
-  end
-end