badline 0.17.0 → 0.18.0

data/lib/badline/pet/superpet/board.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+module Badline
+  class PET
+    class SuperPET < PET
+      # The Waterloo board, after Levak's PET-Interfaces.txt, André
+      # Fachat's SuperPET page and Commodore's 324037 schematic: 64K of
+      # RAM in 16 banks of 4K, one at a time at $9000-$9FFF, and the I/O
+      # page at $EF00 (IOPage), which both CPUs reach.
+      #
+      # The bank latch at $EFFC-$EFFD picks the bank with bits 0-3, and its
+      # bit 7 lets writes reach the system latch at $EFF8-$EFFB:
+      #
+      #   bit 0  the CPU while SW2 is at PROG: 1 the 6502, 0 the 6809
+      #   bit 1  the bank RAM while SW1 is at PROG: 1 read/write, 0 read only
+      #   bit 3  pulls the user port's diagnostic sense, PIA 1's PA7, low
+      #
+      # Bit 0 of $EFFE-$EFFF puts the board's own ROM socket at $9000 in
+      # place of the RAM, which badline leaves empty, while the 6502 runs.
+      # All three are write-only, and the RES line clears them, so the
+      # board starts at bank 0, and with SW2 at PROG with the 6809.
+      #
+      # SW1 is READ, R/W or PROG, the bank RAM's write protect, and SW2
+      # PROG, 6502 or 6809, the CPU. A write to the bank RAM while it is
+      # protected goes nowhere.
+      #
+      # While the 6809 runs, the 8032's ROMs step aside through its NO ROM
+      # line, and the Waterloo ROMs answer at $A000-$E7FF and $F000-$FFFF,
+      # the $E000 one with the CRTC table for the frame rate.
+      class Board
+        CPU_SWITCH = %w[6502 6809 prog].freeze
+
+        RAM_SWITCH = %w[rw read prog].freeze
+
+        # $EF00-$EFFF: the 6702 at $EFE0-$EFE3, the ACIA at $EFF0-$EFF3
+        # and the latches above. A read of a latch finds the last byte on
+        # the bus, and below $EFF0, where neither chip answers, $FF.
+        class IOPage
+          def initialize(board, bus, dongle, acia)
+            @board = board
+            @bus = bus
+            @dongle = dongle
+            @acia = acia
+          end
+
+          def peek(addr)
+            low = addr & 0xff
+            return @bus.data if low >= 0xf4
+            return @acia.peek(addr) if low >= 0xf0
+            return @dongle.peek(addr) if low >= 0xe0 && low < 0xe4
+
+            0xff
+          end
+
+          def poke(addr, value)
+            low = addr & 0xff
+            if low >= 0xfe
+              @board.socket = value
+            elsif low >= 0xfc
+              @board.bank_latch = value
+            elsif low >= 0xf8
+              @board.system_latch = value
+            elsif low >= 0xf0
+              @acia.poke(addr, value) if low < 0xf4
+            elsif low >= 0xe0
+              @dongle.poke(addr, value) if low < 0xe4
+            end
+          end
+        end
+
+        attr_reader :cells, :bank_latch, :system_latch, :cpu_switch, :ram_switch
+
+        # Bit 0 of $EFFE: 1 for the ROM socket at $9000.
+        attr_reader :socket
+
+        # +bus+ is the PET's, whose pages the board maps, and
+        # +keyboard_ports+ PIA 1's, whose PA7 the diagnostic sense is.
+        # +cpu_switch+ and +ram_switch+ are SW2's and SW1's positions, one
+        # of CPU_SWITCH's and RAM_SWITCH's, and +refresh_hz+ picks the
+        # Waterloo $E000 ROM, 50 or 60.
+        def initialize(bus, dongle:, acia:, keyboard_ports:, cpu_switch: "6502", ram_switch: "rw",
+                       refresh_hz: 50)
+          raise ArgumentError, "the CPU switch has no position #{cpu_switch}" unless CPU_SWITCH.include?(cpu_switch)
+          raise ArgumentError, "the RAM switch has no position #{ram_switch}" unless RAM_SWITCH.include?(ram_switch)
+
+          @bus = bus
+          @dongle = dongle
+          @keyboard_ports = keyboard_ports
+          @cpu_switch = cpu_switch
+          @ram_switch = ram_switch
+          @cells = Array.new(0x10000, 0)
+          @banks = Array.new(16) { |bank| Bus::Expansion::Window.new(@cells, bank << 12, 0x9000) }
+          @io = IOPage.new(self, bus, dongle, acia)
+          @bank_latch = 0
+          @system_latch = 0
+          @socket = 0
+          @rom_a = ROM.load("pet/superpet-a000.rom", 0xa000)
+          @rom_c = ROM.load("pet/superpet-c000.rom", 0xc000)
+          @rom_e = ROM.load(refresh_hz == 50 ? "pet/superpet-e000-50hz.rom" : "pet/superpet-e000.rom", 0xe000)
+          @m6809 = m6809_selected?
+          @select_handler = nil
+        end
+
+        # Calls the block when the CPU the switch and the system latch pick
+        # changes.
+        def on_select(&handler)
+          @select_handler = handler
+        end
+
+        # Whether the 6809 has the bus.
+        def m6809? = @m6809
+
+        def bank = @bank_latch & 0x0f
+
+        def bank_latch=(value)
+          @bank_latch = value
+          @bus.map_pages
+        end
+
+        def system_latch=(value)
+          return if @bank_latch.nobits?(0x80)
+
+          @system_latch = value
+          @keyboard_ports.diagnostic_low = value.anybits?(0x08)
+          select
+        end
+
+        def socket=(value)
+          @socket = @m6809 ? 0 : value & 0x01
+          @bus.map_pages
+        end
+
+        # Moves SW2, which picks the CPU at the next RES.
+        def cpu_switch=(position)
+          raise ArgumentError, "the CPU switch has no position #{position}" unless CPU_SWITCH.include?(position)
+
+          @cpu_switch = position
+        end
+
+        # Moves SW1, which protects the bank RAM from the next write on.
+        def ram_switch=(position)
+          raise ArgumentError, "the RAM switch has no position #{position}" unless RAM_SWITCH.include?(position)
+
+          @ram_switch = position
+          @bus.map_pages
+        end
+
+        # Whether writes to the bank RAM go nowhere.
+        def write_protected?
+          case @ram_switch
+          when "read" then true
+          when "rw" then false
+          else @system_latch.nobits?(0x02)
+          end
+        end
+
+        # Whether the CPU switch, or the system latch with it at PROG,
+        # picks the 6809.
+        def m6809_selected?
+          case @cpu_switch
+          when "6502" then false
+          when "6809" then true
+          else @system_latch.nobits?(0x01)
+          end
+        end
+
+        # The RES line clears the latches, and the 6702.
+        def reset!
+          @bank_latch = 0
+          @system_latch = 0
+          @socket = 0
+          @keyboard_ports.diagnostic_low = false
+          @dongle.reset!
+          select
+        end
+
+        def power_on!
+          @cells.fill(0)
+        end
+
+        # Lays the bank, or the empty socket, over $9000-$9FFF, the I/O
+        # page over $EF00, and the Waterloo ROMs over the 8032's while the
+        # 6809 runs.
+        def map(reads, writes)
+          if @socket.zero?
+            window = @banks[bank]
+            window.read_only = write_protected?
+            reads.fill(window, 0x90, 0x10)
+            writes.fill(window, 0x90, 0x10)
+          else
+            reads.fill(@bus.open_bus, 0x90, 0x10)
+            writes.fill(@bus.open_bus, 0x90, 0x10)
+          end
+          reads[0xef] = @io
+          writes[0xef] = @io
+          map_waterloo(reads) if @m6809
+        end
+
+        private
+
+        # Picks the CPU again, and hands the bus over if that changed it.
+        # The 6809 taking over clears the socket bit.
+        def select
+          m6809 = m6809_selected?
+          changed = m6809 != @m6809
+          @m6809 = m6809
+          @socket = 0 if m6809
+          @bus.map_pages
+          @select_handler&.call if changed
+        end
+
+        def map_waterloo(reads)
+          reads.fill(@rom_a, 0xa0, 0x20)
+          reads.fill(@rom_c, 0xc0, 0x20)
+          reads.fill(@rom_e, 0xe0, 0x08)
+          reads.fill(@rom_e, 0xf0, 0x10)
+        end
+      end
+    end
+  end
+end

data/lib/badline/pet/superpet/dongle.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Badline
+  class PET
+    class SuperPET < PET
+      # The 6702 at $EFE0-$EFE3, the protection chip the Waterloo languages
+      # check for. Its behaviour comes from David Roberts' Visual 6702, a
+      # switch-level simulation of the decapped chip's netlist, driven a
+      # bus cycle at a time.
+      #
+      # Each data line has a shift register of its own, LENGTHS long, whose
+      # first stage the line reads, inverted where INVERTED has the bit
+      # set. A latch keeps the last byte written, all ones from the RES
+      # line. A write that sets D0 where the last one left it clear shifts
+      # every register one stage at the end of the next cycle, whichever
+      # cycle that is, so a read in it still finds the old byte. Each
+      # register takes in its first stage XORed with the latch's bit,
+      # inverted where FEEDBACK has the bit clear, the latch as that cycle
+      # leaves it. The RES line clears the registers.
+      class Dongle
+        LENGTHS = [6, 3, 7, 8, 1, 3, 5, 2].freeze
+
+        INVERTED = 0xd6
+
+        FEEDBACK = 0x29
+
+        # No shift waiting.
+        NONE = -1
+
+        # The registers, bit 0 of each the stage its line reads, the latch,
+        # and the cycle at whose end the registers shift, or NONE.
+        attr_reader :registers, :latch, :shift_at
+
+        # +clock+ answers #cycles, the cycle the CPU's access falls in.
+        def initialize(clock)
+          @clock = clock
+          @registers = Array.new(8, 0)
+          reset!
+        end
+
+        def reset!
+          @registers.fill(0)
+          @latch = 0xff
+          @shift_at = NONE
+        end
+
+        def peek(_addr)
+          now = @clock.cycles
+          shift if @shift_at != NONE && @shift_at < now
+          value = 0
+          8.times { |bit| value |= (@registers[bit] & 1) << bit }
+          value ^ INVERTED
+        end
+
+        def poke(_addr, value)
+          now = @clock.cycles
+          shift if @shift_at != NONE && @shift_at < now
+          raising = value.anybits?(0x01) && @latch.nobits?(0x01)
+          @latch = value
+          if @shift_at == now
+            shift
+          elsif raising
+            @shift_at = now + 1
+          end
+        end
+
+        private
+
+        def shift
+          @shift_at = NONE
+          incoming = @latch ^ FEEDBACK ^ 0xff
+          8.times do |bit|
+            register = @registers[bit]
+            stage = (register ^ (incoming >> bit)) & 1
+            @registers[bit] = (register >> 1) | (stage << (LENGTHS[bit] - 1))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/badline/pet/superpet/keyed_modules.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Badline
+  class PET
+    class SuperPET < PET
+      # The SuperPET as keyed snapshot modules: the 8032's (PET::KeyedModules),
+      # then BL-SUPERPET with the board and the 6702 under dongle.*, BL-ACIA
+      # and BL-M6809. The traps on the Waterloo ROM's routines go in
+      # BL-TRAPDOS under waterloo.*, beside the KERNAL's. Without BL-ACIA or
+      # BL-M6809, as from xpet, the unit stays as it is. The CPU switch and
+      # the latches say which CPU has the bus, and the CPU that has it
+      # settles on its instruction boundary, or in SYNC or CWAI.
+      module KeyedModules
+        def settled_for_snapshot?
+          return super unless @m6809_running
+
+          @m6809.boundary? || @m6809.waiting?
+        end
+
+        def save_modules
+          sections = super
+          board = @board
+          dongle = @dongle
+          sections << Snapshot::Keyed.section("BL-SUPERPET") do |out|
+            board.save_fields(out)
+            dongle.save_fields(out, "dongle.")
+          end
+          sections << Snapshot::Keyed.section("BL-ACIA") { |out| @acia.save_fields(out) }
+          sections << Snapshot::Keyed.section("BL-M6809") { |out| @m6809.save_fields(out) }
+          sections
+        end
+
+        def load_modules(modules)
+          super
+          board = modules.required("BL-SUPERPET")
+          @board.load_fields(board)
+          @dongle.load_fields(board, "dongle.")
+          acia = modules.optional("BL-ACIA")
+          @acia.load_fields(acia) if acia
+          m6809 = modules.optional("BL-M6809")
+          @m6809.load_fields(m6809) if m6809
+          @m6809_running = @board.m6809?
+          @board.restored!
+          @acia.restored!
+          @m6809.restored!
+          self
+        end
+
+        def save_trap_dos_fields(out)
+          super
+          @waterloo_traps&.save_fields(out, "waterloo.")
+        end
+
+        def load_trap_dos_fields(input, detached: false)
+          super
+          @waterloo_traps&.load_fields(input, "waterloo.")
+        end
+      end
+
+      include KeyedModules
+    end
+  end
+end

data/lib/badline/pet/superpet/keyed_parts.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Badline
+  class PET
+    class SuperPET < PET
+      class Board
+        # The latches, the socket bit and the 64K of bank RAM, in a keyed
+        # snapshot module (BL-SUPERPET). The switches come with the setup
+        # (Snapshot::PETSetup). Which CPU has the bus, and the diagnostic
+        # sense line, follow from the latches once loaded, and the pages
+        # are laid out again (#restored!).
+        module KeyedState
+          def save_fields(out)
+            out.int("bank_latch", @bank_latch).int("system_latch", @system_latch).int("socket", @socket)
+            out.bytes("ram", @cells)
+          end
+
+          def load_fields(input)
+            @bank_latch = input.byte("bank_latch", 0)
+            @system_latch = input.byte("system_latch", 0)
+            @socket = input.int("socket", 0) & 0x01
+            input.bytes_into("ram", @cells)
+            @m6809 = m6809_selected?
+            @keyboard_ports.diagnostic_low = @system_latch.anybits?(0x08)
+          end
+
+          def restored! = @bus.map_pages
+        end
+
+        include KeyedState
+      end
+
+      class Dongle
+        # The shift registers, the latch and a shift waiting, as the cycles
+        # from now to the one it ends, under `prefix`.
+        module KeyedState
+          def save_fields(out, prefix)
+            out.ints("#{prefix}registers", @registers).int("#{prefix}latch", @latch)
+            out.optional_int("#{prefix}shift_in", @shift_at == NONE ? nil : @shift_at - @clock.cycles)
+          end
+
+          def load_fields(input, prefix)
+            input.ints_into("#{prefix}registers", @registers)
+            @latch = input.byte("#{prefix}latch", 0xff)
+            shift_in = input.optional_int("#{prefix}shift_in")
+            @shift_at = shift_in.nil? ? NONE : @clock.cycles + shift_in
+          end
+        end
+
+        include KeyedState
+      end
+
+      class WaterlooTraps
+        # Whether a served device listens or talks, the channel and the
+        # command it was addressed with, and the bytes sent it so far,
+        # under `prefix`.
+        module KeyedState
+          def save_fields(out, prefix)
+            out.bool("#{prefix}listening", @listening).bool("#{prefix}talking", @talking)
+            out.int("#{prefix}channel", @channel).int("#{prefix}frame", @frame).ints("#{prefix}buffer", @buffer)
+          end
+
+          def load_fields(input, prefix)
+            @listening = input.bool("#{prefix}listening", false)
+            @talking = input.bool("#{prefix}talking", false)
+            @channel = input.int("#{prefix}channel", 0) & 0x0f
+            @frame = input.byte("#{prefix}frame", 0)
+            @buffer = input.ints("#{prefix}buffer", []).map { |byte| byte & 0xff }
+          end
+        end
+
+        include KeyedState
+      end
+    end
+  end
+end

data/lib/badline/pet/superpet/m6809.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Badline
+  class PET
+    class SuperPET < PET
+      # The board's 6809E, on the PET's bus, as the 6502 is. A trap
+      # installed on an address runs as the 6809 is about to fetch an
+      # opcode there, and may move the PC on.
+      class M6809
+        include Chips::M6809::Core
+
+        def initialize(bus)
+          super
+          @traps = nil
+        end
+
+        def install_trap(addr, &handler)
+          (@traps ||= {})[addr] = handler
+        end
+
+        def remove_trap(addr)
+          @traps&.delete(addr)
+        end
+
+        def cycle!
+          @traps[@pc]&.call if @traps && boundary?
+          super
+        end
+      end
+    end
+  end
+end

data/lib/badline/pet/superpet/waterloo_traps.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+module Badline
+  class PET
+    class SuperPET < PET
+      # The traps on the Waterloo 6809 ROM's IEEE-488 routines, which serve
+      # device 8 from the virtual drive (KernalTrap::DOS) the 6502's traps
+      # serve it from, after the ROM's source as Mike Naberezny hosts it
+      # (opsys-all-clean-20101210-src.txt). Other devices fall through to
+      # the ROM, which drives the bus.
+      #
+      # The routines take their argument in D and return with RTS: SetLstnr
+      # and SetTalkr a file control block, whose byte 9 is the device, byte
+      # 10 the secondary address and byte 0 the status, 3 after a timeout,
+      # SetLstnr with the command's offset pushed before the call ($F0 to
+      # open, $E0 to close, $60 for data), ByteOut_ the byte to send and
+      # the byte-in routine none, returning the byte in D and setting bit 0
+      # of the block's byte 12 at EOI. Each keeps the block's address at
+      # $02 and the bus at $77-$7A: $20 listening or $40 talking, the
+      # offset, the device and the secondary address. A language that hooks
+      # a routine through its flag at $0580 gets the ROM's routine, which
+      # calls the hook.
+      #
+      # The menu loads from "disk/1.", drive 1 of a dual drive. The virtual
+      # drive has one, so a name on drive 1 opens the file on drive 0.
+      class WaterlooTraps
+        BYTE_OUT = 0xbe6f
+        BYTE_IN = 0xbefb
+        SET_LISTENER = 0xc072
+        UNLISTEN = 0xc0d0
+        SET_TALKER = 0xc0dd
+        UNTALK = 0xc13c
+
+        # The routines' user hook numbers, whose flags sit at $0580 on.
+        HOOKS = { BYTE_OUT => 23, BYTE_IN => 24, SET_LISTENER => 27, UNLISTEN => 28, SET_TALKER => 29,
+                  UNTALK => 30 }.freeze
+
+        BLOCK = 0x02
+        ACTIVE = 0x77
+        LISTENING = 0x20
+        TALKING = 0x40
+        TIMED_OUT = 3
+
+        OPEN = 0xf0
+        CLOSE = 0xe0
+
+        # The device the traps serve, or nil to serve none.
+        attr_accessor :device
+
+        def initialize(cpu:, bus:, dos:)
+          @cpu = cpu
+          @bus = bus
+          @dos = dos
+          @device = KernalTrap::Routine::DEVICE
+          @listening = false
+          @talking = false
+          @channel = 0
+          @frame = 0
+          @buffer = []
+        end
+
+        def install
+          HOOKS.each_key { |address| @cpu.install_trap(address) { call(address) } }
+          self
+        end
+
+        def uninstall
+          HOOKS.each_key { |address| @cpu.remove_trap(address) }
+        end
+
+        # Whether a served device listens and talks, the channel and the
+        # command, and the bytes sent so far, for a checkpoint.
+        def state = [@listening ? 1 : 0, @talking ? 1 : 0, @channel, @frame, *@buffer]
+
+        private
+
+        def call(address)
+          return unless @bus.peek(0x0580 + HOOKS.fetch(address)).zero?
+
+          case address
+          when SET_LISTENER then set_listener
+          when BYTE_OUT then byte_out
+          when UNLISTEN then unlisten
+          when SET_TALKER then set_talker
+          when BYTE_IN then byte_in
+          else untalk
+          end
+        end
+
+        def served?(block) = !@device.nil? && @bus.peek(block + 9) == @device
+
+        def set_listener
+          block = @cpu.d
+          return unless served?(block)
+
+          offset = @bus.peek(@cpu.s + 3)
+          select(block, LISTENING, offset)
+          @listening = true
+          @frame = offset & 0xf0
+          @buffer = []
+          @dos.close(@channel) if @frame == CLOSE
+          return_from_routine
+        end
+
+        def set_talker
+          block = @cpu.d
+          return unless served?(block)
+
+          select(block, TALKING, 0x60)
+          @talking = true
+          return_from_routine
+        end
+
+        # Ends what the bus was doing, then addresses the block's device as
+        # the routine does.
+        def select(block, active, offset)
+          finish_listening if @listening
+          @talking = false
+          @bus.poke(BLOCK, block >> 8)
+          @bus.poke(BLOCK + 1, block & 0xff)
+          @bus.poke(ACTIVE, active)
+          @bus.poke(ACTIVE + 1, offset)
+          @bus.poke(ACTIVE + 2, @bus.peek(block + 9))
+          secondary = @bus.peek(block + 10)
+          @bus.poke(ACTIVE + 3, secondary)
+          @channel = secondary & 0x0f
+        end
+
+        def byte_out
+          return unless @listening
+
+          block = current_block
+          if @bus.peek(block).zero?
+            @buffer << (@cpu.d & 0xff)
+            @bus.poke(block, TIMED_OUT) unless accepted?
+          end
+          @cpu.d = 0x00ff
+          return_from_routine
+        end
+
+        def accepted? = [OPEN, CLOSE].include?(@frame) || @dos.listening?(@channel)
+
+        def unlisten
+          return unless @listening
+
+          finish_listening
+          @bus.poke(ACTIVE, 0)
+          return_from_routine
+        end
+
+        def finish_listening
+          @listening = false
+          case @frame
+          when OPEN then @dos.open(@channel, on_drive_zero(@buffer.pack("C*")))
+          when CLOSE then nil
+          else @dos.write(@channel, @buffer)
+          end
+          @buffer = []
+        end
+
+        def on_drive_zero(name) = name.start_with?("1:") ? "0:#{name[2..]}" : name
+
+        def byte_in
+          return unless @talking
+
+          block = current_block
+          byte = 0x0d
+          if @bus.peek(block).zero?
+            read, eoi = @dos.read(@channel)
+            if read.nil?
+              @bus.poke(block, TIMED_OUT)
+            else
+              byte = read
+              @bus.poke(block + 12, @bus.peek(block + 12) | 0x01) if eoi
+            end
+          end
+          @cpu.d = byte
+          return_from_routine
+        end
+
+        def untalk
+          return unless @talking
+
+          @talking = false
+          @bus.poke(ACTIVE, 0)
+          return_from_routine
+        end
+
+        def current_block = (@bus.peek(BLOCK) << 8) | @bus.peek(BLOCK + 1)
+
+        def return_from_routine
+          s = @cpu.s
+          @cpu.pc = (@bus.peek(s) << 8) | @bus.peek(s + 1)
+          @cpu.s = (s + 2) & 0xffff
+        end
+      end
+    end
+  end
+end