badline 0.13.0 → 0.15.0

data/lib/badline/options.rb

@@ -12,9 +12,9 @@ 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` or `c128`, 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
+  # `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.
   #
   # TABLE lists the options, and both the parser and the help read it. It
@@ -48,6 +48,13 @@ module Badline
       "32k" => :"32k", "all" => :all
     }.freeze
 
+    # The Plus/4's RAM sizes as --ram names them, in K.
+    PLUS4_RAM = { "16k" => 16, "32k" => 32, "64k" => 64 }.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
+
     # A Float as OptionParser took one: digits with an optional sign,
     # fraction and exponent.
     DECIMAL = /\A[-+]?(\d+(\.\d+)?|\.\d+)([eE][-+]?\d+)?\z/
@@ -57,14 +64,22 @@ 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 or
-    # :c128.
+    # The machine family to build (Badline::Machine), :c64, :vic20, :c128
+    # or :plus4.
     attr_reader :family
 
     # 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.
+    attr_reader :ram_kb
+
+    # The Plus/4's cartridge ROM images --c1lo, --c1hi, --c2lo and --c2hi
+    # name, by slot: { "c1lo" => path }.
+    attr_reader :cartridges
+
     def self.parse(argv, native: false) = new(native:).parse(argv)
 
     # The native build plays the SID in the window unless --no-sound says
@@ -84,6 +99,8 @@ module Badline
       @models = []
       @reu = nil
       @ram = nil
+      @ram_kb = nil
+      @cartridges = {}
       @autostart = true
       @writable = false
       @sound = native
@@ -94,6 +111,7 @@ module Badline
       @true_drive = false
       @screenshot = ""
       @save_snapshot = ""
+      @vice = false
       @timeline = []
       @jit = true
       @help = false
@@ -171,11 +189,14 @@ module Badline
 
     def true_drive? = @true_drive
 
+    # Whether --save-snapshot adds VICE's modules, so x64sc opens it.
+    def vice? = @vice
+
     def jit? = @jit
 
     # The name of the model to build: a C64 Badline::Model names, a VIC-20
-    # of VIC20_MODELS or a C128 of C128_MODELS. --ntsc is short for --model
-    # ntsc.
+    # of VIC20_MODELS, a C128 of C128_MODELS or a Plus/4 of PLUS4_MODELS.
+    # --ntsc is short for --model ntsc.
     def model = @models.first || family_models.first
 
     # Whether --c64 asks the C128 to start in C64 mode, holding C= at
@@ -197,7 +218,8 @@ 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 || @family == :vic20 || headless? || !@window_only.empty? || @media_path.nil?
+      return if @sid_command || %i[vic20 plus4].include?(@family) || headless? || !@window_only.empty?
+      return if @media_path.nil?
 
       @sid_command = File.extname(@media_path).casecmp?(".sid")
     end
@@ -250,7 +272,8 @@ module Badline
       when "--sid" then @sid_model = sid_model_for(value)
       when "--model" then @models << value
       when "--reu" then @reu = reu_size(value)
-      when "--ram" then @ram = ram_configuration(value)
+      when "--ram" then ram_option(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
       when "--save-snapshot" then @save_snapshot = value
@@ -263,6 +286,15 @@ 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
@@ -272,6 +304,7 @@ module Badline
       when "--no-vsync" then @vsync = false
       when "--verbose" then @verbose = true
       when "--true-drive" then @true_drive = true
+      when "--vice" then @vice = true
       when "--ntsc" then @models << "ntsc"
       when "--c64" then @c64_mode = true
       when "--unpaced" then @paced = false

data/lib/badline/plus4/acia.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Badline
+  class Plus4
+    # The Plus/4's 6551 ACIA at $FD00-$FD0F, its four registers repeated,
+    # as a stub with nothing on the line: it never receives, its
+    # transmitter is always empty, and it never interrupts. The command and
+    # control registers keep what is written to them, and a write to the
+    # status register, a programmed reset, clears the command register's
+    # low five bits.
+    class ACIA
+      STATUS = 0x10
+
+      attr_reader :command, :control
+
+      def initialize
+        reset!
+      end
+
+      def reset!
+        @command = 0
+        @control = 0
+      end
+
+      def irq? = false
+
+      def peek(addr)
+        case addr & 0x03
+        when 1 then STATUS
+        when 2 then @command
+        when 3 then @control
+        else 0
+        end
+      end
+
+      def poke(addr, value)
+        case addr & 0x03
+        when 1 then @command &= 0xe0
+        when 2 then @command = value
+        when 3 then @control = value
+        end
+      end
+    end
+  end
+end

data/lib/badline/plus4/bus.rb

@@ -0,0 +1,375 @@
+# frozen_string_literal: true
+
+module Badline
+  class Plus4
+    # The CPU's bus:
+    #
+    # $0000-$0001 - the 7501's port (CPUPort), over RAM
+    # $0002-$7FFF - RAM
+    # $8000-$BFFF - the low ROM bank, or RAM
+    # $C000-$FCFF - the high ROM bank, or RAM; $FC00-$FCFF is always the
+    #               KERNAL's while ROM is selected
+    # $FD00-$FD0F - the 6551 ACIA (Plus/4 only)
+    # $FD10-$FD1F - the user port's 6529 (Plus/4 only)
+    # $FD30-$FD3F - the keyboard's 6529 (KeyboardPort)
+    # $FDD0-$FDDF - the ROM bank latch
+    # $FF00-$FF1F - the TED
+    # $FF3E/$FF3F - a write selects ROM or RAM at $8000-$FFFF
+    # $FF40-$FFFF - the high ROM bank, or RAM
+    #
+    # A write to $FF3E selects ROM and one to $FF3F RAM, everywhere in
+    # $8000-$FFFF but $FD00-$FF3F, which holds I/O either way. ROM is
+    # selected at power-on and reset. A write to ROM goes to the RAM under
+    # it. The ROM bank latch takes the address written to, not the byte:
+    # bits 0-1 pick the low bank and bits 2-3 the high bank, 0 for BASIC
+    # and the KERNAL, 1 for the Plus/4's function ROMs, 2 and 3 for the two
+    # cartridges.
+    #
+    # RAM smaller than 64K repeats through the 64K, as the C16's 16K does
+    # without A14 and A15. Where nothing answers, a read finds the last byte
+    # on the bus.
+    #
+    # The TED fetches through the same banks: the video matrix and the
+    # attributes from ROM or RAM at $8000-$FFFF as the CPU sees it, with no
+    # I/O in the way (#ted_fetch), and character and bitmap data from RAM,
+    # or from ROM with $FF12 bit 2 set, where below $8000 and in an empty
+    # bank it finds the last byte on the bus (#ted_pattern_fetch, Plus/4
+    # openmem). Each byte it fetches is left on the bus.
+    class Bus
+      include Addressable
+
+      RAM_POWER_ON = 0x00
+
+      # RAM through a size it repeats at.
+      class MirroredRAM
+        def initialize(ram, mask)
+          @ram = ram
+          @mask = mask
+        end
+
+        def peek(addr) = @ram.peek(addr & @mask)
+
+        def poke(addr, value)
+          @ram.poke(addr & @mask, value)
+        end
+      end
+
+      # 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
+
+      # Page 0: the port at $00 and $01, RAM above it.
+      class ZeroPage
+        def initialize(port, ram)
+          @port = port
+          @ram = ram
+        end
+
+        def peek(addr) = addr < 2 ? @port.peek(addr) : @ram.peek(addr)
+
+        def poke(addr, value)
+          return @port.poke(addr, value) if addr < 2
+
+          @ram.poke(addr, value)
+        end
+      end
+
+      # Page $FD: the ACIA, the user port, the keyboard port and the ROM
+      # bank latch, by the address's bits 4-7. +acia+ and +user_port+ are
+      # nil where the machine has none, and +cassette_sense+ answers in the
+      # user port's place on a machine without one (CassetteSense).
+      class IOPage
+        def initialize(keyboard_port:, acia: nil, user_port: nil, cassette_sense: nil)
+          @bus = nil
+          @acia = acia
+          @user_port = user_port
+          @cassette_sense = cassette_sense
+          @keyboard_port = keyboard_port
+        end
+
+        # The bus whose last byte an empty spot reads and whose bank latch
+        # a write to $FDD0-$FDDF sets.
+        def connect(bus)
+          @bus = bus
+        end
+
+        def peek(addr)
+          case addr & 0xf0
+          when 0x00 then @acia ? @acia.peek(addr) : @bus.data
+          when 0x10 then user_port_peek(addr)
+          when 0x30 then @keyboard_port.peek(addr)
+          else @bus.data
+          end
+        end
+
+        def poke(addr, value)
+          case addr & 0xf0
+          when 0x00 then @acia&.poke(addr, value)
+          when 0x10 then @user_port&.poke(addr, value)
+          when 0x30 then @keyboard_port.poke(addr, value)
+          when 0xd0 then @bus.select_banks(addr)
+          end
+        end
+
+        private
+
+        def user_port_peek(addr)
+          return @user_port.peek(addr) if @user_port
+          return @cassette_sense.read(@bus.data) if @cassette_sense
+
+          @bus.data
+        end
+      end
+
+      # VICE's debug cartridge register at $FDCF, a spot in the I/O page
+      # that nothing answers (plus4world forum post 31417). A write there
+      # calls the handler with the byte, the exit code the VICE testprogs
+      # report. Every other access falls through to the I/O page.
+      class DebugRegister
+        ADDRESS = 0xfdcf
+
+        def initialize(io, &handler)
+          @io = io
+          @handler = handler
+        end
+
+        def peek(addr) = @io.peek(addr)
+
+        def poke(addr, value)
+          return @handler.call(value) if addr == ADDRESS
+
+          @io.poke(addr, value)
+        end
+      end
+
+      # Page $FE with a 1551's TCBM interface plugged in: the 6523 TIA
+      # that talks to drive 9 at $FEC0-$FEDF and drive 8's at $FEE0-$FEFF.
+      # The rest of the page is open.
+      class TCBMPage
+        def initialize(bus, drive8:, drive9:)
+          @bus = bus
+          @drive8 = drive8
+          @drive9 = drive9
+        end
+
+        def peek(addr)
+          return @bus.data if addr < 0xfec0
+
+          addr < 0xfee0 ? @drive9.peek(addr) : @drive8.peek(addr)
+        end
+
+        def poke(addr, value)
+          return if addr < 0xfec0
+
+          addr < 0xfee0 ? @drive9.poke(addr, value) : @drive8.poke(addr, value)
+        end
+      end
+
+      # Page $FF: the TED in $FF00-$FF3F, its two phantom registers, and
+      # ROM or RAM above.
+      class TopPage
+        def initialize(bus, ted)
+          @bus = bus
+          @ted = ted
+        end
+
+        def peek(addr)
+          return @ted.peek(addr) if addr < 0xff40
+
+          @bus.top_memory.peek(addr)
+        end
+
+        def poke(addr, value)
+          return @bus.ram_view.poke(addr, value) if addr >= 0xff40
+
+          case addr
+          when 0xff3e then @bus.rom_selected = true
+          when 0xff3f then @bus.rom_selected = false
+          else @ted.poke(addr, value)
+          end
+        end
+      end
+
+      attr_reader :ram, :ram_view, :data, :low_bank, :high_bank
+
+      # What the top page reads above $FF3F: the high ROM bank or RAM.
+      attr_reader :top_memory
+
+      # The CPU sees ROM at $8000-$FFFF.
+      attr_reader :rom_selected
+
+      # +io+ is the IOPage, +model+ a Model profile, whose KERNAL it maps
+      # and whose function ROMs it maps where the model has them, and
+      # +ram_kb+ the RAM fitted.
+      def initialize(ted:, port:, io:, model: Model::PLUS4, ram_kb: model.ram_kb)
+        addressable_at(0, length: 2**16)
+        size = ram_kb * 1024
+        @ram = Memory.new(Array.new(size, RAM_POWER_ON), length: size, start: 0)
+        @ram_view = MirroredRAM.new(@ram, size - 1)
+        @ted = ted
+        @open_bus = OpenBus.new(self)
+        @low_roms = [ROM.load("plus4/basic.rom", 0x8000), nil, nil, nil]
+        @high_roms = [ROM.load(model.kernal, 0xc000), nil, nil, nil]
+        if model.plus4_parts
+          @low_roms[1] = ROM.load("plus4/function-low.rom", 0x8000)
+          @high_roms[1] = ROM.load("plus4/function-high.rom", 0xc000)
+        end
+        @zero_page = ZeroPage.new(port, @ram_view)
+        @io_page = io
+        io.connect(self)
+        @top_page = TopPage.new(self, ted)
+        @tcbm_page = @open_bus
+        @debug_register = nil
+        @data = 0
+        @read_pages = Array.new(256, @open_bus)
+        @write_pages = Array.new(256, @ram_view)
+        @ted_pages = Array.new(256, @ram_view)
+        @ted_rom_pages = Array.new(256, @open_bus)
+        @low_bank = @high_bank = 0
+        @rom_selected = true
+        @top_memory = @ram_view
+        map_writes
+        map_reads
+      end
+
+      def power_on!
+        @ram.clear!(Array.new(@ram.length, RAM_POWER_ON))
+        reset!
+      end
+
+      # The RESET line selects ROM and the first bank of each.
+      def reset!
+        @low_bank = @high_bank = 0
+        self.rom_selected = true
+      end
+
+      def rom_selected=(selected)
+        @rom_selected = selected
+        @ted.rom_selected = selected
+        map_reads
+      end
+
+      # Whether the CPU reads the KERNAL at $C000-$FFFF: ROM selected, with
+      # the KERNAL's bank, high bank 0.
+      def kernal_selected? = @rom_selected && @high_bank.zero?
+
+      # A write to the ROM bank latch at +addr+.
+      def select_banks(addr)
+        @low_bank = addr & 0x03
+        @high_bank = (addr >> 2) & 0x03
+        map_reads
+      end
+
+      # Calls the block with each byte written to $FDCF (DebugRegister).
+      def install_debug_register(&)
+        @debug_register = DebugRegister.new(@io_page, &)
+        map_writes
+      end
+
+      # Plugs in a 1551's TCBM interface, the TIAs at $FEC0-$FEFF.
+      def plug_tcbm(drive8:, drive9:)
+        @tcbm_page = TCBMPage.new(self, drive8:, drive9:)
+        map_writes
+        map_reads
+      end
+
+      # Puts a cartridge's ROM chips in their slots, as a PLUS4 CARTRIDGE
+      # .crt numbers them: a chip's bank picks cartridge 1 (0) or 2 (1), in
+      # ROM banks 2 and 3, and its address the low ($8000) or the high
+      # ($C000) slot. A chip shorter than 16K repeats through the slot.
+      # Slots the chips don't name keep what they held.
+      def attach_cartridge(chips)
+        chips.each do |chip|
+          raise ArgumentError, "no Plus/4 cartridge slot in bank #{chip.bank}" unless chip.bank.between?(0, 1)
+
+          rom = chip.data
+          length = rom.length
+          data = Array.new(0x4000) { |i| length.zero? ? 0xff : rom[i % length] }
+          if chip.address < 0xc000
+            @low_roms[2 + chip.bank] = ROM.new(data, length: 0x4000, start: 0x8000)
+          else
+            @high_roms[2 + chip.bank] = ROM.new(data, length: 0x4000, start: 0xc000)
+          end
+        end
+        map_reads
+      end
+
+      # Empties both cartridges' slots, ROM banks 2 and 3, which then read
+      # as the open bus.
+      def detach_cartridges
+        @low_roms[2] = @low_roms[3] = @high_roms[2] = @high_roms[3] = nil
+        map_reads
+      end
+
+      # The slots that hold a cartridge's ROM, by xplus4's names: c1lo,
+      # c1hi, c2lo and c2hi.
+      def cartridge_slots
+        slots = []
+        slots << "c1lo" unless @low_roms[2].nil?
+        slots << "c1hi" unless @high_roms[2].nil?
+        slots << "c2lo" unless @low_roms[3].nil?
+        slots << "c2hi" unless @high_roms[3].nil?
+        slots
+      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
+
+      # A TED fetch of the video matrix or the attributes.
+      def ted_fetch(addr)
+        @data = @ted_pages[addr >> 8].peek(addr)
+      end
+
+      # A TED fetch of character or bitmap data, from ROM when +rom+.
+      def ted_pattern_fetch(addr, rom)
+        @data = rom ? @ted_rom_pages[addr >> 8].peek(addr) : @ram_view.peek(addr)
+      end
+
+      private
+
+      def map_writes
+        @write_pages[0x00] = @zero_page
+        @write_pages[0xfd] = @debug_register || @io_page
+        @write_pages[0xfe] = @tcbm_page
+        @write_pages[0xff] = @top_page
+      end
+
+      def map_reads
+        @read_pages.fill(@ram_view, 0x00, 0xfd)
+        @read_pages[0x00] = @zero_page
+        map_roms(@read_pages) if @rom_selected
+        @top_memory = @rom_selected ? @high_roms[@high_bank] || @open_bus : @ram_view
+        @read_pages[0xfd] = @io_page
+        @read_pages[0xfe] = @tcbm_page
+        @read_pages[0xff] = @top_page
+        map_ted_reads
+      end
+
+      def map_ted_reads
+        @ted_pages.fill(@ram_view, 0x80, 0x80)
+        map_roms(@ted_pages) if @rom_selected
+        map_roms(@ted_rom_pages)
+        @ted_pages.fill(@high_roms[@high_bank] || @open_bus, 0xfd, 3) if @rom_selected
+        @ted_rom_pages.fill(@high_roms[@high_bank] || @open_bus, 0xfd, 3)
+      end
+
+      def map_roms(pages)
+        pages.fill(@low_roms[@low_bank] || @open_bus, 0x80, 0x40)
+        pages.fill(@high_roms[@high_bank] || @open_bus, 0xc0, 0x3c)
+        pages[0xfc] = @high_roms[0]
+      end
+    end
+  end
+end

data/lib/badline/plus4/cassette_sense.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Badline
+  class Plus4
+    # The C16's and C116's cassette sense, which has no 6529 to go through:
+    # a read of $FD10-$FD1F enables a 74LS125 that drives the sense line
+    # onto data bit 2, low while a key is down on the deck (C16 schematic
+    # 251788, sheet 1, U11). Nothing drives the other bits, which keep the
+    # last byte on the bus, and a write goes nowhere.
+    class CassetteSense
+      TAPE_SENSE = 0x04
+
+      def initialize(datasette)
+        @datasette = datasette
+      end
+
+      # The byte a read finds, from +data+, the last byte on the bus.
+      def read(data) = @datasette.sense_low? ? data & ~TAPE_SENSE : data | TAPE_SENSE
+    end
+  end
+end

data/lib/badline/plus4/cpu.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Badline
+  class Plus4
+    # The 7501 or 8501, a 6510 core without an NMI pin, on the Plus4::Bus.
+    class CPU
+      include Badline::Chips::CPU::Core
+    end
+  end
+end

data/lib/badline/plus4/cpu_port.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Badline
+  class Plus4
+    # The 7501's I/O port at $00 (direction) and $01 (data). Its seven
+    # pins carry the serial bus and the cassette port, and none of them
+    # banks memory:
+    #
+    # - P0, P1 and P2 drive the serial bus's DATA, CLK and ATN through
+    #   inverters, so a 1 pulls the line low, and P1 is the cassette write
+    #   line too.
+    # - P3 runs the cassette motor while it is low.
+    # - P4 reads the cassette read line, P6 the serial CLK line and P7 the
+    #   DATA line, 1 while the line is high.
+    # - P5 has no pin and reads 1.
+    #
+    # An output pin reads back what it drives. A pin left as an input reads
+    # what drives it from outside, and the serial outputs, P0-P2, float high
+    # there, so they pull their lines, as an output of 1 does.
+    class CPUPort
+      DATA_OUT = 0x01
+      CLK_OUT = 0x02
+      ATN_OUT = 0x04
+      MOTOR = 0x08
+      TAPE_READ = 0x10
+      CLK_IN = 0x40
+      DATA_IN = 0x80
+
+      attr_reader :ddr, :data
+
+      def initialize(serial_bus:, datasette:)
+        @serial_bus = serial_bus
+        @datasette = datasette
+        @ddr = 0
+        @data = 0
+      end
+
+      def reset!
+        @ddr = 0
+        @data = 0
+        changed
+      end
+
+      def peek(addr)
+        return @ddr if addr.zero?
+
+        (@data & @ddr) | (inputs & ~@ddr & 0xff)
+      end
+
+      def poke(addr, value)
+        if addr.zero?
+          @ddr = value
+        else
+          @data = value
+        end
+        changed
+      end
+
+      # The pins' levels as they leave the chip, inputs floating high.
+      def levels = (@data & @ddr) | (~@ddr & 0xff)
+
+      # The serial bus lines the port pulls low, as Drives::SerialBus host
+      # lines.
+      def serial_lines
+        out = levels
+        lines = 0
+        lines |= Drives::SerialBus::HOST_ATN_OUT if out.anybits?(ATN_OUT)
+        lines |= Drives::SerialBus::HOST_CLK_OUT if out.anybits?(CLK_OUT)
+        lines |= Drives::SerialBus::HOST_DATA_OUT if out.anybits?(DATA_OUT)
+        lines
+      end
+
+      private
+
+      def inputs
+        value = 0x2f
+        value |= TAPE_READ if @datasette.read_high?
+        low = @serial_bus.low_lines
+        value |= CLK_IN unless low.anybits?(Drives::SerialBus::CLK)
+        value |= DATA_IN unless low.anybits?(Drives::SerialBus::DATA)
+        value
+      end
+
+      def changed
+        lines = serial_lines
+        @serial_bus.host_lines = lines unless lines == @serial_bus.host_lines
+        out = levels
+        @datasette.motor = out.nobits?(MOTOR)
+        @datasette.write_line = out.anybits?(CLK_OUT)
+      end
+    end
+  end
+end