badline 0.10.1 → 0.11.0

data/lib/badline/c128/mmu_pages.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Badline
+  class C128
+    class Bus
+      # What the MMU maps. For the CPU: the RAM bank, common RAM and the
+      # pages page 0 and page 1 move to in both modes, and CR's ROMs and I/O
+      # in C128 mode. C64 mode lays the PLA's ROMs and I/O over the same RAM
+      # (AddressBus::PLA).
+      module MMUPages
+        private
+
+        # CR's ROMs and I/O over the RAM, with the configuration registers on
+        # top at $FF00.
+        def map_c128_pages
+          cr = @mmu.cr
+          map_ram_pages
+          @read_pages.fill(@basic_low_rom, 0x40, 0x40) if cr.nobits?(0x02)
+          map_rom_block((cr >> 2) & 0x03, 0x80)
+          map_rom_block((cr >> 4) & 0x03, 0xc0)
+          map_io_pages if cr.nobits?(0x01)
+          @configuration_reads.below = @read_pages[0xff]
+          @configuration_writes.below = @write_pages[0xff]
+          @read_pages[0xff] = @configuration_reads
+          @write_pages[0xff] = @configuration_writes
+        end
+
+        # A 16K block's two CR bits pick the system ROM, the internal or the
+        # external function ROM, neither of which is fitted, or RAM.
+        def map_rom_block(select, first_page)
+          case select
+          when 0 then map_system_rom(first_page)
+          when 1, 2 then @read_pages.fill(@open_bus, first_page, 0x40)
+          end
+        end
+
+        # BASIC's high half at $8000, or the screen editor, the character ROM
+        # and the KERNAL at $C000.
+        def map_system_rom(first_page)
+          if first_page == 0x80
+            @read_pages.fill(@basic_high_rom, 0x80, 0x40)
+          else
+            @read_pages.fill(@editor_rom, 0xc0, 0x10)
+            @read_pages.fill(@c128_character_rom, 0xd0, 0x10)
+            @read_pages.fill(@c128_kernal_rom, 0xe0, 0x20)
+          end
+        end
+
+        # The bank CR picks, with common RAM in bank 0, then the pages page 0
+        # and page 1 move to.
+        def map_ram_pages
+          @io_mapped = false
+          bank_ram = @mmu.cpu_bank.zero? ? @ram : @bank1
+          @read_pages.fill(bank_ram)
+          @write_pages.fill(bank_ram)
+          map_common_ram
+          relocate_pages
+        end
+
+        def map_common_ram
+          low = @mmu.common_low_pages
+          high = @mmu.common_high_start
+          @read_pages.fill(@ram, 0, low)
+          @write_pages.fill(@ram, 0, low)
+          @read_pages.fill(@ram, high, 256 - high)
+          @write_pages.fill(@ram, high, 256 - high)
+        end
+
+        # In C128 mode page 0 and page 1 go to the pages P0 and P1 name, in
+        # bank 0 if common RAM holds them. In both modes, the page each moved
+        # to reaches back to page 0 or page 1, in the bank it named, if the
+        # CPU sees that bank there. Page 1's takes the page they both name.
+        # C64 mode moves neither page 0 nor page 1 forward, so either can be
+        # the page that reaches back.
+        def relocate_pages
+          mmu = @mmu
+          forward = !mmu.c64_mode?
+          if forward
+            map_relocated(0, @relocated[0], bank_of(0, mmu.p0_bank), mmu.p0_page)
+            map_relocated(1, @relocated[1], bank_of(1, mmu.p1_bank), mmu.p1_page)
+          end
+          reach_back(@relocated[2], mmu.p0_page, mmu.p0_bank, 0, forward)
+          reach_back(@relocated[3], mmu.p1_page, mmu.p1_bank, 1, forward)
+        end
+
+        def reach_back(window, page, bank, home, forward)
+          return if forward && page < 2
+          return unless bank_of(page, @mmu.cpu_bank) == bank
+
+          map_relocated(page, window, bank, home)
+        end
+
+        def map_relocated(page, window, bank, target)
+          window.base = (bank << 16) | (target << 8)
+          @read_pages[page] = @write_pages[page] = window
+        end
+
+        # The bank +page+ reaches when the CPU or a pointer asks for +bank+.
+        def bank_of(page, bank)
+          page < @mmu.common_low_pages || page >= @mmu.common_high_start ? 0 : bank
+        end
+      end
+    end
+  end
+end

data/lib/badline/c128/model.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Badline
+  class C128
+    # The C128s badline builds by name: the chips each board has, and its
+    # video standard. The plastic C128D is a "c128" board with a 1571 built
+    # in. A VDC on either board can have 16K or 64K of RAM.
+    module Model
+      Profile = Data.define(:name, :vic_model, :cia_model, :sid_model, :region, :vdc_model, :vdc_ram_kb)
+
+      # The C128 and the plastic C128D, PAL: the 8566 VIC-IIe, 6526 CIAs,
+      # the 6581 SID and the 8563 VDC with 16K.
+      C128 = Profile.new(name: "c128", vic_model: :mos8566, cia_model: :mos6526, sid_model: :mos6581,
+                         region: Region::PAL, vdc_model: :mos8563, vdc_ram_kb: 16)
+
+      # The NTSC C128, with the 8564.
+      C128_NTSC = Profile.new(name: "c128ntsc", vic_model: :mos8564, cia_model: :mos6526, sid_model: :mos6581,
+                              region: Region::NTSC, vdc_model: :mos8563, vdc_ram_kb: 16)
+
+      # The metal C128DCR, PAL: 6526A CIAs, the 8580 SID and the 8568 VDC
+      # with 64K.
+      DCR = Profile.new(name: "c128dcr", vic_model: :mos8566, cia_model: :mos6526a, sid_model: :mos8580,
+                        region: Region::PAL, vdc_model: :mos8568, vdc_ram_kb: 64)
+
+      # The NTSC C128DCR, with the 8564.
+      DCR_NTSC = Profile.new(name: "c128dcrntsc", vic_model: :mos8564, cia_model: :mos6526a, sid_model: :mos8580,
+                             region: Region::NTSC, vdc_model: :mos8568, vdc_ram_kb: 64)
+
+      ALL = [C128, C128_NTSC, DCR, DCR_NTSC].freeze
+
+      def self.named(name)
+        model = ALL.find { |candidate| candidate.name == name }
+        raise ArgumentError, "no C128 model named #{name}" if model.nil?
+
+        model
+      end
+    end
+  end
+end

data/lib/badline/c128/modes.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Badline
+  class C128
+    # Following the MMU between C128 and C64 mode: the KERNAL traps go to
+    # the KERNAL the machine runs, C= held from power-on starts it in C64
+    # mode through the C128 KERNAL, and #active_screen tells a front end
+    # which screen the mode's editor prints to.
+    module Modes
+      # Holds C= down from power-on until the C128 KERNAL has taken the
+      # machine to C64 mode, as a user does to start a C128 in C64 mode.
+      # #on_init's handlers then wait for the C64 KERNAL's boot.
+      def hold_commodore_key
+        keyboard.press(:cbm)
+        @holding_commodore = true
+      end
+
+      # The screen the machine prints to: in C128 mode the screen editor's,
+      # :vdc while bit 7 of its 40/80 flag at $D7 is set, as GRAPHIC 5,
+      # ESC X and a reset with 40/80 DISPLAY down leave it, or :vic. C64
+      # mode has the VIC-IIe's alone.
+      def active_screen = mode == :c128 && ram.peek(0xd7).anybits?(0x80) ? :vdc : :vic
+
+      private
+
+      # The KERNAL the traps stand in for: the C128's in C128 mode, the C64's
+      # in C64 mode.
+      def trap_layout = mode == :c128 ? KernalTrap::C128_LAYOUT : KernalTrap::C64_LAYOUT
+
+      # The machine went to C64 mode or came back: the traps move to the
+      # KERNAL it now runs. C= held from power-on lets go, and #on_init's
+      # handlers wait for the C64 KERNAL to boot.
+      def mode_changed
+        layout = trap_layout
+        @capture_output&.layout = layout
+        if @drive
+          remove_kernal_traps
+          install_kernal_traps(layout)
+        end
+        return unless @holding_commodore && mode == :c64
+
+        keyboard.release(:cbm)
+        @holding_commodore = false
+        @init_threshold = @cycles + Computer::INIT_THRESHOLD if @cycles < @init_threshold
+      end
+    end
+  end
+end

data/lib/badline/c128/saved_state.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Badline
+  class C128
+    MARKER = "C128"
+
+    # The model, the SID and the mode it resets into of the machine a State
+    # from #snapshot was taken of, the arguments C128.new takes.
+    def self.setup(state)
+      input = Snapshot::StateReader.new(state)
+      input.marker(MARKER)
+      input.check_stamp
+      SavedState.read_setup(input)
+    end
+
+    # A new machine, built as the one a State from #snapshot was taken of,
+    # at that state.
+    def self.restored(state)
+      setup = setup(state)
+      new(model: setup[0], sid_model: setup[1], mode: setup[2]).apply_state(state)
+    end
+
+    # The whole machine's state for a snapshot, as Computer's: the
+    # machine's own latches, FAST and TEST as they last took hold, the bus with its RAM, the MMU, the chips and
+    # the VDC, the CPU, the cartridge, the disk device 8 serves through the
+    # traps and a true 1541. The serial lines go back into the bus from the
+    # restored CIA 2. What the host holds stays out: the keyboard, the
+    # joysticks, CAPS LOCK and 40/80 DISPLAY, the traps and callbacks, and
+    # which chip renders.
+    module SavedState
+      SID_MODELS = %i[mos6581 mos8580].freeze
+      MODES = %i[c64 c128].freeze
+
+      # The model's name, the SID's model and the mode.
+      def self.read_setup(input)
+        name = input.string
+        known = Model::ALL.any? { |model| model.name == name }
+        raise Snapshot::FormatError, "the state names a C128 model badline doesn't know" unless known
+
+        sid_model = SID_MODELS.fetch(input.int)
+        [name, sid_model, MODES.fetch(input.int)]
+      rescue IndexError
+        raise Snapshot::FormatError, "the state names a SID or a mode badline doesn't know"
+      end
+
+      # How many more on_init handlers the machine a State was taken of had
+      # yet to run than this one has. Nil until the machine is restored.
+      attr_reader :init_handlers_lost
+
+      def snapshot
+        out = Snapshot::StateWriter.new
+        save_state(out)
+        out.state
+      end
+
+      # Takes the machine back to a State from #snapshot, trying it on a new
+      # machine first, so one that fails leaves this machine as it was.
+      # Raises Snapshot::FormatError for a state of another model or SID.
+      def restore(state)
+        check_setup(C128.setup(state))
+        C128.restored(state)
+        apply_state(state)
+      end
+
+      # Puts a State into the machine without trying it on a new one first.
+      def apply_state(state)
+        input = Snapshot::StateReader.new(state)
+        load_state(input)
+        raise Snapshot::FormatError, "the state goes on past the machine" unless input.finished?
+
+        self
+      end
+
+      def save_state(out)
+        out.marker(MARKER).stamp
+        out.string(@model.name).int(SID_MODELS.index(@sid.model)).int(@c64_built ? 0 : 1)
+        out.int(@cycles).int(@clock_bits).boolean(@nmi_asserted).boolean(@cartridge_nmi).boolean(@restore_pulse)
+        out.boolean(!@pending_keys.nil?)
+        out.ints(@pending_keys) if @pending_keys
+        out.int(@cycles <= init_threshold ? @init_handlers.length : 0)
+        save_cartridge(out)
+        @bus.save_state(out)
+        @cpu.save_state(out)
+        save_trap_drive(out)
+        save_serial_bus(out)
+      end
+
+      def load_state(input)
+        input.marker(MARKER)
+        input.check_stamp
+        check_setup(SavedState.read_setup(input))
+        @cycles = input.int
+        @clock_bits = input.int
+        @nmi_asserted = input.boolean?
+        @cartridge_nmi = input.boolean?
+        @restore_pulse = input.boolean?
+        @pending_keys = nil
+        @pending_keys = input.ints if input.boolean?
+        @init_handlers_lost = [input.int - @init_handlers.length, 0].max
+        load_cartridge(input)
+        @bus.load_state(input)
+        push_serial_lines
+        @cpu.load_state(input)
+        load_trap_drive(input)
+        load_serial_bus(input)
+      end
+
+      private
+
+      def check_setup(setup)
+        ours = [@model.name, @sid.model, @c64_built ? :c64 : :c128]
+        return if setup == ours
+
+        raise Snapshot::FormatError, "the state is of a #{setup.join(' with a ')}, not a #{ours.join(' with a ')}"
+      end
+    end
+
+    include SavedState
+  end
+end

data/lib/badline/c128/vdc/memory.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Badline
+  class C128
+    class VDC
+      # The VDC's own DRAM: 16K of two 4416s (16K by 4) or 64K of 4164s or
+      # 4464s, behind the 16-bit addresses the VDC computes.
+      #
+      # The VDC drives an address onto the DRAM's pins as a row and a
+      # column, and R28 bit 4 picks the order (Programmer's Reference Guide,
+      # R28): set, for 64K parts, the row is A0-A7 and the column A8-A15;
+      # clear, for 4416s, the column pins carry A8, A8, A9-A13 and A15, and
+      # A14 goes nowhere. A 4416 has only six column lines and ignores the
+      # first and the last column pin. That gives the four layouts
+      # VDC/vdcdump's patterns.txt records from real machines: a 16K VDC in
+      # 64K mode sees A9-A14, so pages p, p ^ 1 and p ^ $80 are one page,
+      # and a 64K VDC in 16K mode sees page p at page
+      # (p & $80) | (p & $3E) << 1 | (p & 1) * 3.
+      class Memory
+        attr_reader :ram
+
+        def initialize(ram_kb)
+          @ram = Array.new(ram_kb * 1024, 0)
+          @layouts = [false, true].map { |mode64| Array.new(256) { |page| page_base(page, mode64) }.freeze }
+          @pages = @layouts[0]
+        end
+
+        # Selects 64K mode, R28 bit 4, or 16K mode.
+        def mode64=(on)
+          @pages = @layouts[on ? 1 : 0]
+        end
+
+        def fetch(addr) = @ram[@pages[(addr >> 8) & 0xff] | (addr & 0xff)]
+
+        def store(addr, value)
+          @ram[@pages[(addr >> 8) & 0xff] | (addr & 0xff)] = value
+        end
+
+        def clear!
+          @ram.fill(0)
+        end
+
+        private
+
+        def page_base(page, mode64)
+          pins = mode64 ? page : (page & 0x80) | ((page & 0x3e) << 1) | ((page & 1) * 3)
+          return pins << 8 if @ram.length == 0x10000
+
+          ((pins >> 1) & 0x3f) << 8
+        end
+      end
+    end
+  end
+end

data/lib/badline/c128/vdc/painter.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module Badline
+  class C128
+    class VDC
+      # Paints the VDC's scan lines into its display, one line at a time,
+      # from the registers as they stand when the line ends. Each pixel of
+      # the display is one period of the 16 MHz dot clock, so a pixel of
+      # the double-width mode, R25 bit 4, covers two. Window paints the
+      # characters of the lines in the displayed rows.
+      #
+      # The horizontal counter that R2, R34 and R35 compare runs
+      # COUNTER_LEAD characters ahead of the character on screen: the soci
+      # testprogs set R34 = 6 and R35 = R1 + 8 for one character of border
+      # either side of the display, as test01.jpg shows on a real machine.
+      # The display holds each line from the end of the horizontal sync, R2
+      # plus R3 bits 0-3 on that counter, as a monitor shows it, and its
+      # rows from the end of the vertical sync, which starts R7 - 1 rows
+      # into the frame (the Programmer's Reference Guide counts R7 "plus 1")
+      # and lasts R3 bits 4-7 lines, or 16 for 0. The vertical sync and the
+      # characters outside R34 up to R35 are black, and the rest of the
+      # border is the background colour, R26 bits 0-3.
+      #
+      # The display is as wide as a line and as high as a frame, up to
+      # MAX_WIDTH by MAX_HEIGHT; lines and pixels past those are left out.
+      class Painter
+        COUNTER_LEAD = 7
+        MIN_LINE_DOTS = 128
+        MAX_WIDTH = 1024
+        MAX_HEIGHT = 320
+
+        attr_reader :display, :width, :height, :dirty_lines
+
+        def initialize(registers, memory)
+          @registers = registers
+          @window = Window.new(registers, memory)
+          @line = Array.new(MAX_WIDTH, 0)
+          resize(MIN_LINE_DOTS, 1)
+        end
+
+        # Latches the start addresses, and starts the display again when
+        # the frame's size has changed.
+        def begin_frame(line_dots, frame_lines)
+          @window.latch_starts
+          width = line_dots.clamp(MIN_LINE_DOTS, MAX_WIDTH)
+          height = frame_lines.clamp(1, MAX_HEIGHT)
+          resize(width, height) if width != @width || height != @height
+        end
+
+        # The [left, top, width, height] of the display a monitor shows:
+        # all of a line but the horizontal sync, all of a frame but the
+        # vertical sync.
+        def crop(line_dots, frame_lines, sync_lines)
+          regs = @registers
+          shown = line_dots - ((regs[3] & 0x0f) * VDC.char_dots(regs))
+          [0, 0, shown.clamp(1, @width), (frame_lines - sync_lines).clamp(1, @height)]
+        end
+
+        # The display's size and the window's start addresses. The display
+        # starts again cleared, to be painted while the VDC renders.
+        def save_state(out)
+          out.int(@width).int(@height)
+          @window.save_state(out)
+        end
+
+        def load_state(input)
+          resize(input.int, input.int)
+          @window.load_state(input)
+        end
+
+        def clear_dirty_lines!
+          @dirty_lines.fill(false)
+        end
+
+        def clear!
+          @display.fill(0)
+          @dirty_lines.fill(true)
+        end
+
+        # Paints the line `line_y` lines after the vertical sync ends.
+        # `row` and `row_line` place it in the frame's character rows, or
+        # `row` is -1 in the adjust lines after the last row, and `sync` is
+        # set in the vertical sync. `frame` counts frames for the blinking.
+        def paint(line_y, row, row_line, sync, frame)
+          return if line_y >= @height
+
+          regs = @registers
+          char_dots = VDC.char_dots(regs)
+          line_dots = (regs[0] + 1) * char_dots
+          @line = Array.new(line_dots, 0) if @line.length < line_dots
+          line = @line
+          line.fill(sync ? 0 : regs[26] & 0x0f, 0, line_dots)
+          unless sync
+            @window.paint(line, row, row_line, frame) if row >= 0 && row < regs[6]
+            blank(line, line_dots, char_dots)
+          end
+          copy_out(line, line_y, line_dots, char_dots)
+        end
+
+        private
+
+        def resize(width, height)
+          @width = width
+          @height = height
+          @display = Array.new(width * height, 0)
+          @dirty_lines = Array.new(height, true)
+        end
+
+        def sync_end_chars(regs) = regs[2] + (regs[3] & 0x0f) - COUNTER_LEAD
+
+        def blank(line, line_dots, char_dots)
+          first = @registers[34]
+          last = @registers[35]
+          return if first == last
+
+          total = line_dots / char_dots
+          char = 0
+          while char < total
+            counter = (char + COUNTER_LEAD) % total
+            line.fill(0, char * char_dots, char_dots) unless enabled?(counter, first, last)
+            char += 1
+          end
+        end
+
+        def enabled?(counter, first, last)
+          return counter >= first && counter < last if first < last
+
+          counter >= first || counter < last
+        end
+
+        def copy_out(line, line_y, line_dots, char_dots)
+          origin = (sync_end_chars(@registers) * char_dots) % line_dots
+          base = line_y * @width
+          head = [line_dots - origin, @width].min
+          @display[base, head] = line[origin, head]
+          tail = [@width - head, origin].min
+          @display[base + head, tail] = line[0, tail] if tail.positive?
+          @dirty_lines[line_y] = true
+        end
+      end
+    end
+  end
+end

data/lib/badline/c128/vdc/raster.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Badline
+  class C128
+    class VDC
+      # The VDC's raster: R0 + 1 characters a line, R9 + 1 lines a row,
+      # R4 + 1 rows a frame and then R5 more lines, with the frame's size
+      # and sync taken as it begins. Each line ends into the Painter while
+      # the VDC renders. Interlace, R8, is left out.
+      class Raster
+        attr_reader :frame, :frame_lines, :sync_lines
+
+        def initialize(registers, painter)
+          @registers = registers
+          @painter = painter
+          reset!
+        end
+
+        def reset!
+          @frame = 0
+          begin_frame
+        end
+
+        # The dots of a line, at least Painter::MIN_LINE_DOTS.
+        def line_dots
+          dots = (@registers[0] + 1) * VDC.char_dots(@registers)
+          [dots, Painter::MIN_LINE_DOTS].max
+        end
+
+        # Outside the displayed rows, as status bit 5 reads.
+        def vertical_blank? = @adjusting || @row >= @registers[6]
+
+        def save_state(out)
+          out.int(@frame).int(@row).int(@row_line).boolean(@adjusting).int(@frame_line).int(@frame_lines)
+          out.int(@sync_start).int(@sync_lines)
+        end
+
+        def load_state(input)
+          @frame = input.int
+          @row = input.int
+          @row_line = input.int
+          @adjusting = input.boolean?
+          @frame_line = input.int
+          @frame_lines = input.int
+          @sync_start = input.int
+          @sync_lines = input.int
+        end
+
+        def end_line(render)
+          paint_line if render
+          @frame_line += 1
+          @row_line += 1
+          if @adjusting
+            begin_frame(next_frame: true) if @row_line >= (@registers[5] & 0x1f)
+          elsif @row_line > (@registers[9] & 0x1f)
+            @row_line = 0
+            @row += 1
+            end_rows if @row > @registers[4]
+          end
+        end
+
+        private
+
+        def paint_line
+          sync = @frame_line >= @sync_start && @frame_line < @sync_start + @sync_lines
+          line_y = (@frame_line - @sync_start - @sync_lines) % @frame_lines
+          @painter.paint(line_y, @adjusting ? -1 : @row, @row_line, sync, @frame)
+        end
+
+        def end_rows
+          return begin_frame(next_frame: true) if @registers[5].nobits?(0x1f)
+
+          @adjusting = true
+          @row_line = 0
+        end
+
+        # The vertical sync starts R7 - 1 rows in, as the Programmer's
+        # Reference Guide counts R7 "plus 1", and lasts R3 bits 4-7 lines,
+        # or 16 for 0.
+        def begin_frame(next_frame: false)
+          regs = @registers
+          @frame += 1 if next_frame
+          @row = 0
+          @row_line = 0
+          @adjusting = false
+          @frame_line = 0
+          row_lines = (regs[9] & 0x1f) + 1
+          @frame_lines = ((regs[4] + 1) * row_lines) + (regs[5] & 0x1f)
+          @sync_start = ((regs[7] - 1) % (regs[4] + 1)) * row_lines
+          @sync_lines = regs[3] >> 4
+          @sync_lines = 16 if @sync_lines.zero?
+          @painter.begin_frame(line_dots, @frame_lines)
+        end
+      end
+    end
+  end
+end