badline 0.14.0 → 0.15.1

data/lib/badline/drives/model1551/cpu.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Badline
+  module Drives
+    class Model1551
+      # The drive's 6510T, a 6510 with an 8-bit port (Port), on the drive's
+      # Bus.
+      class CPU
+        include Badline::Chips::CPU::Core
+        include Engine::IdleCPU
+      end
+    end
+  end
+end

data/lib/badline/drives/model1551/keyed_state.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Badline
+  module Drives
+    class Model1551
+      # The drive's own fields in a keyed snapshot module (BL-D8): its
+      # model, its clock phase, its cycle count, the 555's count to its
+      # next pulse and the byte the gate array latched. A save settles the
+      # drive first, so it is awake; a load forgets its orbits.
+      module KeyedState
+        def save_fields(out)
+          settle!
+          out.text("model", model_name).int("phase", @phase).int("cycles", @cycles).int("irq_timer", @irq_timer)
+          out.int("latched_byte", @mechanism.latched_byte)
+        end
+
+        def load_fields(input)
+          settle!
+          input.choice("model", [model_name], model_name)
+          @phase = input.int("phase", @phase)
+          @cycles = input.int("cycles", @cycles)
+          @irq_timer = input.int("irq_timer", @irq_timer).clamp(1, IRQ_PERIOD)
+          @mechanism.latched_byte = input.byte("latched_byte", @mechanism.latched_byte)
+        end
+
+        # The drive as modules of its own, named from `name` (BL-D8 for
+        # device 8): its own fields, its RAM, the CPU's port, the drive's
+        # TIA, its interface's TIA in the computer, the CPU, the mechanism
+        # and the disk, when one is in.
+        def save_modules(sections, name)
+          sections << Snapshot::Keyed.section(name) { |out| save_fields(out) }
+          sections << Snapshot::Keyed.section("#{name}-RAM") { |out| @bus.save_fields(out) }
+          sections << Snapshot::Keyed.section("#{name}-PORT") { |out| @port.save_fields(out) }
+          sections << Snapshot::Keyed.section("#{name}-TIA") { |out| @tia.save_fields(out) }
+          sections << Snapshot::Keyed.section("#{name}-HOSTTIA") { |out| @host_tia.save_fields(out) }
+          sections << Snapshot::Keyed.section("#{name}-CPU") { |out| @cpu.save_fields(out) }
+          sections << Snapshot::Keyed.section("#{name}-MECH") { |out| @mechanism.save_fields(out) }
+          disk = @mechanism.disk
+          sections << Snapshot::Keyed.section("#{name}-DISK") { |out| disk.save_fields(out) } if disk
+          sections
+        end
+
+        # The drive from its modules, `input` being its own. No disk module
+        # means no disk in the drive. The cable's lines and the mechanism's
+        # mode follow the TIAs once both are loaded.
+        def load_modules(modules, input, name)
+          load_fields(input)
+          @bus.load_fields(modules.required("#{name}-RAM"))
+          @port.load_fields(modules.required("#{name}-PORT"))
+          @tia.load_fields(modules.required("#{name}-TIA"))
+          @host_tia.load_fields(modules.required("#{name}-HOSTTIA"))
+          @cpu.load_fields(modules.required("#{name}-CPU"))
+          disk_input = modules.optional("#{name}-DISK")
+          disk = disk_input.nil? ? nil : Model1541::Disk.from_fields(disk_input, detached: modules.detached?)
+          @mechanism.load_fields(modules.required("#{name}-MECH"), disk)
+          @cable.relatch
+          @cpu.restored!
+          forget_orbits
+        end
+      end
+
+      include KeyedState
+    end
+  end
+end

data/lib/badline/drives/model1551/port.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Badline
+  module Drives
+    class Model1551
+      # The 6510T's port at $00 (direction) and $01 (data), wired to the
+      # mechanism in the bits of the 1541's VIA 2 port B (zimmers.net's 1551
+      # memory map, schematic 251860):
+      #
+      #   P0-1  stepper phase (out)       P4    write protect (in, 1 = writable)
+      #   P2    motor on (out)            P5-6  bit rate, speed zone 0-3 (out)
+      #   P3    activity LED (out)        P7    BYTE LATCHED (in)
+      #
+      # An output pin reads back what it drives, and a pin left as an input
+      # drives nothing into the mechanism.
+      class Port
+        WRITE_PROTECT = 0x10
+        BYTE_LATCHED = 0x80
+
+        attr_reader :ddr, :data
+
+        def initialize(mechanism)
+          @mechanism = mechanism
+          @ddr = 0
+          @data = 0
+        end
+
+        def reset!
+          @ddr = 0
+          @data = 0
+          changed
+        end
+
+        def peek(addr)
+          return @ddr if addr.zero?
+
+          ddr = @ddr
+          (@data & ddr) | (inputs & ~ddr & 0xff)
+        end
+
+        def poke(addr, value)
+          if addr.zero?
+            @ddr = value
+          else
+            @data = value
+          end
+          changed
+        end
+
+        # The registers, in a keyed snapshot module (BL-D8-PORT).
+        def save_fields(out)
+          out.int("ddr", @ddr).int("data", @data)
+        end
+
+        def load_fields(input)
+          @ddr = input.byte("ddr", @ddr)
+          @data = input.byte("data", @data)
+        end
+
+        private
+
+        def inputs
+          mechanism = @mechanism
+          value = (mechanism.read_b(0xff) & WRITE_PROTECT) | (0xff & ~(WRITE_PROTECT | BYTE_LATCHED))
+          mechanism.byte_latched? ? value | BYTE_LATCHED : value
+        end
+
+        def changed
+          @mechanism.port_b_written(@data & @ddr)
+        end
+      end
+    end
+  end
+end

data/lib/badline/drives/model1551/tia.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Badline
+  module Drives
+    class Model1551
+      # The drive's 6523 TIA at $4000-$7FFF, its eight registers mirrored
+      # (zimmers.net's 1551 memory map, schematic 251860), a Chips::TIA
+      # with what the drive's side wires to it:
+      #
+      # - Port A carries the cable's eight data lines, pulled up.
+      # - Port B reads the GCR byte the gate array latched at BYTE READY
+      #   and drives the byte the head writes.
+      # - Port C drives STATUS0 and STATUS1 (PC0-1), DEV (PC2), which picks
+      #   where the computer's TIA answers, ACK (PC3) and the head's MODE
+      #   (PC4, low to write), and reads the device number jumper (PC5,
+      #   high for device 9), SYNC (PC6, low in a SYNC mark) and DAV (PC7).
+      #
+      # The DOS sets port C's directions to $1F. The cable's lines are
+      # pulled up, so an input nothing drives reads 1.
+      #
+      # Any access to the TIA clears BYTE LATCHED.
+      class TIA
+        DAV = 0x80
+        SYNC = 0x40
+        JUMPER = 0x20
+        MODE = 0x10
+
+        # The chip, whose inputs the drive's side sets before each read.
+        attr_reader :chip
+
+        def initialize(mechanism, device:)
+          @mechanism = mechanism
+          @jumper = device == 9 ? JUMPER : 0
+          @chip = Chips::TIA.new
+          inputs = @chip.inputs
+          inputs[0] = 0xff
+          inputs[1] = 0xff
+          inputs[2] = 0xff
+          mechanism.tia = self
+          mode_written
+        end
+
+        def ports = @chip.ports
+
+        def directions = @chip.directions
+
+        def inputs = @chip.inputs
+
+        def reset!
+          @chip.reset!
+          mode_written
+        end
+
+        def peek(addr)
+          mechanism = @mechanism
+          mechanism.release_byte_latch
+          chip = @chip
+          inputs = chip.inputs
+          case addr & 0x07
+          when 1 then inputs[1] = mechanism.latched_byte
+          when 2 then inputs[2] = (inputs[2] & DAV) | (mechanism.sync? ? 0 : SYNC) | @jumper | 0x1f
+          end
+          chip.peek(addr)
+        end
+
+        def poke(addr, value)
+          @mechanism.release_byte_latch
+          @chip.poke(addr, value)
+          register = addr & 0x07
+          mode_written if [2, 5].include?(register)
+        end
+
+        # What port B drives onto the head's write shift register.
+        def port_b_output = @chip.output(1)
+
+        # The chip's registers, in a keyed snapshot module (BL-D8-TIA).
+        def save_fields(out) = @chip.save_fields(out)
+
+        def load_fields(input)
+          @chip.load_fields(input)
+        end
+
+        private
+
+        # MODE selects reading while high, as the 1541's CB2 does.
+        def mode_written
+          @mechanism.cb2_written(@chip.output(2).anybits?(MODE))
+        end
+      end
+    end
+  end
+end

data/lib/badline/drives/model1551.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+require "badline/chips/tia"
+require "badline/drives/model1541"
+require "badline/drives/model1551/cpu"
+require "badline/drives/model1551/port"
+require "badline/drives/model1551/tia"
+require "badline/drives/model1551/bus"
+require "badline/drives/model1551/cable"
+require "badline/drives/model1551/keyed_state"
+
+module Badline
+  module Drives
+    # The 1551 disk drive of the 264 series: a 6510T at 2 MHz running DOS
+    # 2.6 from 16 KB of ROM, with 2 KB of RAM, the 1541's GCR mechanism
+    # behind a gate array, and a 6523 TIA facing the computer over TCBM, a
+    # parallel cable to a second 6523 in the computer's expansion port
+    # (Commodore schematic 251860; zimmers.net's 1551 memory map).
+    #
+    # The 6510T's port drives the mechanism as the 1541's VIA 2 port B does
+    # and reads the write-protect sensor and the gate array's BYTE LATCHED
+    # (Port). The TIA's port B reads the GCR byte the gate array latched and
+    # drives the byte to write, and its port C selects reading or writing
+    # and reads SYNC (TIA).
+    #
+    # The drive comes with its interface for the computer's expansion port,
+    # a second 6523 (#host_tia), which the cable joins to the drive's
+    # (Cable). The computer puts it at $FEE0 for device 8 and at $FEC0 for
+    # device 9.
+    #
+    # A 555 timer pulls IRQ low for about 7 µs every 8.3 ms, its R1 120K,
+    # R2 100R and C1 0.1 µF, which runs the DOS's job loop. Nothing
+    # acknowledges it: the line lets go on its own.
+    #
+    # Drives::Engine::Core clocks it against the host and sleeps through
+    # the DOS's idle loop, which counts its passes in $61 (Engine::Idle's
+    # pass counter), until the 555 is due to pull IRQ, the count wraps or
+    # the computer moves the cable's lines.
+    class Model1551
+      include Engine::Core
+
+      CLOCK_HZ = 2_000_000
+
+      # The 555's cycle in drive cycles: high for 0.693 (R1 + R2) C and low,
+      # pulling IRQ, for 0.693 R2 C.
+      IRQ_PERIOD = 16_660
+      IRQ_LOW = 14
+
+      # The host cycles, at about 1 MHz, by which a 1551 switched on with the
+      # machine has run its DOS's reset, the RAM test and the ROM checksum,
+      # and answers TCBM: half a second, with a margin.
+      BOOT_CYCLES = 600_000
+
+      # Where the DOS's idle loop starts over, polling the TIA's port A for
+      # a command from the computer.
+      IDLE_LOOP = 0xeabd
+
+      # The byte the idle loop increments on each pass.
+      PASS_COUNTER = 0x61
+
+      def port
+        settle!
+        @port
+      end
+
+      def tia
+        settle!
+        @tia
+      end
+
+      # The TIA in the computer's expansion port, which the computer reads
+      # and writes without waking the drive.
+      attr_reader :host_tia
+
+      # The cable between the two TIAs.
+      def cable
+        settle!
+        @cable
+      end
+
+      def model_name = "1551"
+
+      # +rom+ covers $C000-$FFFF, and defaults to the DOS image in the ROM
+      # path. +device+ is 8 or 9, as the jumper on the TIA's PC5 sets it.
+      def initialize(rom: nil, host_clock_hz: CLOCK_HZ, device: 8, debug: false)
+        raise ArgumentError, "a 1551 is device 8 or 9, not #{device}" unless [8, 9].include?(device)
+
+        @device = device
+        @clock_hz = CLOCK_HZ
+        @mechanism = Model1541::Mechanism.new
+        @mechanism.clock_hz = CLOCK_HZ
+        @port = Port.new(@mechanism)
+        @tia = TIA.new(@mechanism, device:)
+        @host_tia = Chips::TIA.new
+        @bus = Bus.new(rom: rom || ROM.load("dos1551.rom", 0xc000), port: @port, tia: @tia)
+        @cpu = CPU.new(@bus, debug:)
+        @idle_loop = IDLE_LOOP
+        @host_clock_hz = host_clock_hz
+        @phase = 0
+        @cycles = 0
+        @irq_timer = IRQ_PERIOD
+        init_idle(debug)
+        @pass_counter = PASS_COUNTER
+        @cable = Cable.new(@host_tia, @tia.chip, self)
+        @serial_port = @cable
+      end
+
+      # Puts in a Disk from the .d64 or .g64 image at +path+, write-protected
+      # with `read_only`.
+      def insert_image(path, read_only: false)
+        insert(Model1541::Disk.open(path, read_only:))
+      end
+
+      # The computer's RESET line reaches the interface's TIA and, through
+      # the cable, the CPU, its port and the drive's TIA. RAM keeps its
+      # contents, and the 555 runs on.
+      def reset!
+        settle!
+        @host_tia.reset!
+        @port.reset!
+        @tia.reset!
+        @cpu.reset!
+      end
+
+      private
+
+      # One drive cycle: the mechanism turns the disk ahead of the CPU, and
+      # the 555 pulls IRQ while its output is low.
+      def step
+        @mechanism.cycle!
+        timer = @irq_timer - 1
+        timer = IRQ_PERIOD if timer.zero?
+        @irq_timer = timer
+        @cpu.irq = timer <= IRQ_LOW
+        @cpu.cycle!
+        @cycles += 1
+      end
+
+      # A pass of the idle loop reads the TIA's port A, which holds still
+      # until the computer moves the cable's lines, and RAM. It repeats
+      # while the motor is off and the 555 leaves IRQ alone, for as long as
+      # the 555 leaves room (see Engine::Idle).
+      def busy_for_pass? = @mechanism.motor_on? || @irq_timer <= IRQ_LOW
+
+      def quiet_cycles
+        quiet = @irq_timer - IRQ_LOW - 1
+        quiet.negative? ? 0 : quiet
+      end
+
+      def idle_state
+        chip = @tia.chip
+        [*@cpu.counting_state, @bus.data, *@mechanism.idle_state, *chip.ports, *chip.directions, *chip.inputs,
+         @port.ddr, @port.data]
+      end
+
+      def fast_forward_chips(cycles)
+        @irq_timer -= cycles
+      end
+
+      # Every 555 pulse runs the job loop, which reads the port and the TIA,
+      # so no orbit (Engine::Orbit) comes round, and the drive keeps no
+      # anchors.
+      def anchor = nil
+
+      def counter_state(_touched) = []
+
+      def skip_chip_orbits(_cycles, _touched) = nil
+    end
+  end
+end

data/lib/badline/drives/model1571.rb

@@ -26,6 +26,7 @@ module Badline
     # (CIA#quiet?).
     class Model1571
       include Engine::Core
+      include Engine::SerialConnection
       include Engine::VIAs
       include Engine::FastSerial
 

data/lib/badline/drives/model1581.rb

@@ -39,6 +39,7 @@ module Badline
     # on either chip: the drive's CIA gets no TOD pulses (CIA's tod_hz).
     class Model1581
       include Engine::Core
+      include Engine::SerialConnection
       include Engine::FastSerial
 
       CLOCK_HZ = 2_000_000

data/lib/badline/frontend/boot.rb

@@ -17,7 +17,11 @@ module Badline
       end
 
       computer = nil
-      problem = media_problem { computer = boot(options) }
+      problem = if cartridge?(options)
+                  cartridge_problem { computer = boot(options) }
+                else
+                  media_problem { computer = boot(options) }
+                end
       unless problem.empty?
         warn "#{options.program}: #{options.media_path}: #{problem}"
         return 1
@@ -40,6 +44,21 @@ module Badline
       e.message
     end
 
+    # Runs the block that puts a cartridge in, as media_problem does, and
+    # also returns the message of the ArgumentError a machine raises over a
+    # cartridge with a chip in a bank or slot it doesn't map.
+    def self.cartridge_problem(&)
+      media_problem(&)
+    rescue ArgumentError => e
+      e.message
+    end
+
+    # Whether the media the options start is a .crt.
+    def self.cartridge?(options)
+      media = options.media_path
+      !media.nil? && Media::Extensions.kind(media) == :cartridge
+    end
+
     # The machine a .vsf snapshot holds, built as the saved one was, or a
     # new one built from the options with the media attached.
     def self.boot(options)
@@ -55,11 +74,13 @@ module Badline
 
     # A new machine built from the options (Machine.for_options), with
     # `media`, if not nil, attached and started as the command line does,
-    # its disk writable if `writable`. The VIC-20 raises
+    # its disk writable if `writable`, after the Plus/4's cartridges the
+    # options put in its slots. The VIC-20 and the Plus/4 raise
     # Machine::Unsupported for a .sid tune.
     def self.start(options, media, writable)
       computer = build(options, media)
       Media::TrueDrive.plug(computer) if options.true_drive?
+      options.cartridges.each { |slot, path| puts Media.attach(computer, path, cartridge: { slot: }) }
       unless media.nil?
         puts Media.attach(computer, media, autostart: options.autostart?, subtune: options.subtune,
                                            disk: { read_only: !writable })

data/lib/badline/frontend/controls.rb

@@ -117,7 +117,11 @@ module Badline
       end
 
       def host_key(scancode)
-        @computer.family == :c128 ? Keys.c128_key(scancode, @computer.mode) : Keys.c64_key(scancode)
+        case @computer.family
+        when :c128 then Keys.c128_key(scancode, @computer.mode)
+        when :plus4 then Keys.plus4_key(scancode)
+        else Keys.c64_key(scancode)
+        end
       end
 
       # RESTORE isn't in the key matrix, so it goes to the machine instead.
@@ -196,8 +200,8 @@ module Badline
       end
 
       def release_all
-        Keys::ARROWS.each_key { |scancode| @computer.keyboard.release(Keys.c64_key(scancode)) }
-        Keys::WASD.each_key { |scancode| @computer.keyboard.release(Keys.c64_key(scancode)) }
+        Keys::ARROWS.each_key { |scancode| @computer.keyboard.release(host_key(scancode)) }
+        Keys::WASD.each_key { |scancode| @computer.keyboard.release(host_key(scancode)) }
         Keys::ARROWS.each_value do |direction|
           @computer.joystick1.release(direction)
           @computer.joystick2.release(direction)

data/lib/badline/frontend/keys.rb

@@ -3,8 +3,8 @@
 module Badline
   module Frontend
     # SDL scancodes follow key positions on a US layout. They map onto the C64
-    # keys, the C128's own keys and, in joystick mode, the joystick
-    # directions.
+    # keys, the C128's and the 264's own keys and, in joystick mode, the
+    # joystick directions.
     module Keys
       RETURN = 40
       ESCAPE = 41
@@ -56,6 +56,15 @@ module Badline
         63 => :forty_eighty, 72 => :forty_eighty, 78 => :run_stop
       }.freeze
 
+      # The 264's keys where they differ from the C64's: ESC on Esc, with
+      # RUN/STOP on Page Down as on the C128, F1-F3 on F1-F3, HELP on F4,
+      # Insert or Help, a cursor key on each arrow, and either SHIFT on the
+      # one SHIFT. Page Up, RESTORE on the C64, presses nothing.
+      PLUS4_OTHERS = {
+        41 => :esc, 78 => :run_stop, 58 => :f1, 59 => :f2, 60 => :f3, 61 => :help, 73 => :help, 117 => :help,
+        79 => :crsr_right, 80 => :crsr_left, 81 => :crsr_down, 82 => :crsr_up, 229 => :lshift, 75 => :none
+      }.freeze
+
       ARROWS = { 44 => :fire, 228 => :fire, 79 => :right, 80 => :left, 81 => :down, 82 => :up }.freeze
       WASD = { 225 => :fire, 7 => :right, 4 => :left, 22 => :down, 26 => :up }.freeze
 
@@ -77,6 +86,9 @@ module Badline
         C128_OTHERS[scancode] || c64_key(scancode)
       end
 
+      # The 264's key for the scancode: one of PLUS4_OTHERS or the C64's.
+      def self.plus4_key(scancode) = PLUS4_OTHERS[scancode] || c64_key(scancode)
+
       # The character the key types on a US layout: a letter, a capital
       # with `shift`, or a digit, and "" for any other key.
       def self.character(scancode, shift)

data/lib/badline/frontend/media_slots.rb

@@ -31,8 +31,18 @@ module Badline
           drive.nil? ? computer.unmount : drive.insert(nil)
         end
 
-        # Takes the cartridge out with the power off.
+        # Whether the expansion port has a cartridge in, on the Plus/4 in
+        # either cartridge's slots.
+        def cartridge?(computer)
+          return !computer.cartridge_slots.empty? if computer.family == :plus4
+
+          !computer.address_bus.cartridge.nil?
+        end
+
+        # Takes the cartridge out with the power off, on the Plus/4 both.
         def remove_cartridge(computer)
+          return computer.detach_cartridges if computer.family == :plus4
+
           computer.address_bus.detach_cartridge
           computer.power_cycle!
         end

data/lib/badline/frontend/menu/menu_dialogs.rb

@@ -37,7 +37,12 @@ module Badline
       # :program, or :snapshot, which starts in the saves folder.
       def browse(kind)
         @browsing = kind
-        @browser.open(kind == :snapshot ? Badline.data_folder("saves") : @browse_from, EXTENSIONS.fetch(kind))
+        extensions = case kind
+                     when :cartridge then @media.cartridge_extensions
+                     when :program then programs
+                     else EXTENSIONS.fetch(kind)
+                     end
+        @browser.open(kind == :snapshot ? Badline.data_folder("saves") : @browse_from, extensions)
       end
 
       # Asks for a save's name, starting from `name`.
@@ -55,15 +60,15 @@ module Badline
       def ask_remove = @confirmation.ask(:remove, @media.cartridge_name)
 
       # Puts a dropped disk or tape in its device, or asks before a
-      # cartridge or a program starts, and says whether it asks. Other
-      # files are left alone.
+      # cartridge, a Plus/4's raw ROM image among them, or a program
+      # starts, and says whether it asks. Other files are left alone.
       def drop(path)
         extension = File.extname(path).downcase
         return @media.insert(:disk, path) && false if EXTENSIONS[:disk].include?(extension)
         return @media.insert(:tape, path) && false if EXTENSIONS[:tape].include?(extension)
-        return false unless EXTENSIONS[:program].include?(extension)
+        return false unless programs.include?(extension)
 
-        @confirmation.ask(extension == ".crt" ? :cartridge : :start, path)
+        @confirmation.ask(@media.cartridge_extensions.include?(extension) ? :cartridge : :start, path)
         true
       end
 
@@ -97,6 +102,10 @@ module Badline
 
       private
 
+      # What Quick open and a drop start: every medium, and the cartridges
+      # the machine takes.
+      def programs = (EXTENSIONS[:program] + @media.cartridge_extensions).uniq
+
       # Puts the disk or tape picked in, or asks before a cartridge or
       # Quick open power cycles the machine, and leaves the browser, as Esc
       # does.