badline 0.12.0 → 0.13.0

data/lib/badline/drives/model1581/bus.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module Badline
+  module Drives
+    class Model1581
+      # The drive CPU's bus, as the 74LS139 decodes A13-A15 (1581 Service
+      # Manual, memory map and schematic sheet 1):
+      #
+      # $0000-$1FFF - 8 KB of RAM
+      # $2000-$3FFF - nothing: open bus
+      # $4000-$5FFF - the 8520, its sixteen registers mirrored
+      # $6000-$7FFF - the WD1772, its four registers mirrored
+      # $8000-$FFFF - the DOS ROM
+      #
+      # Writes to the ROM and to open bus go nowhere, and a read from open
+      # bus finds the last byte on the data bus, as on the 1541. A write to
+      # either of the 8520's ports or their direction registers moves the
+      # drive's lines (Drives::Model1581#ports_written).
+      #
+      # While Idle records a pass of the DOS's idle loop, the bus watches it
+      # (watch!): the RAM it reads and writes, and whether it touched the
+      # 8520 or the WD1772, either of which makes the pass volatile. While
+      # Idle looks for an orbit, the bus guards the drive (guard!), and any
+      # access to either chip taints it.
+      class Bus
+        include Addressable
+
+        attr_reader :ram, :rom, :cia, :fdc, :data, :volatile, :touched, :tainted, :touched_timers
+
+        def initialize(rom:, cia:, fdc:, drive:)
+          addressable_at(0, length: 2**16)
+          @ram = Memory.new([], length: 0x2000, start: 0)
+          @rom = rom
+          @cia = cia
+          @fdc = fdc
+          @drive = drive
+          @data = 0
+          @recording = @guarding = @watching = false
+          @volatile = @tainted = false
+          @touched = {}
+          @touched_timers = 0
+        end
+
+        # The last byte on the data bus and the RAM. What a watched stretch
+        # touched is Idle's, and a restored bus isn't watching.
+        def save_state(out)
+          out.int(@data)
+          @ram.save_state(out)
+        end
+
+        def load_state(input)
+          @data = input.int
+          @ram.load_state(input)
+          @watching = false
+        end
+
+        def peek(addr)
+          return @data = @rom.peek(addr) if addr >= 0x8000
+          return @data = chip_peek(addr) if addr >= 0x2000
+
+          touch(addr) if @recording
+          @data = @ram.peek(addr)
+        end
+
+        def poke(addr, value)
+          @data = value
+          return if addr >= 0x8000
+          return chip_poke(addr, value) if addr >= 0x2000
+
+          touch(addr) if @recording
+          @ram.poke(addr, value)
+        end
+
+        # Starts watching: see volatile and touched.
+        def watch!
+          @recording = true
+          @volatile = false
+          @touched = {}
+          watching!
+        end
+
+        def unwatch!
+          @recording = false
+          watching!
+        end
+
+        # Starts guarding: see tainted.
+        def guard!
+          @guarding = true
+          @tainted = false
+          watching!
+        end
+
+        private
+
+        def chip_peek(addr)
+          watch_chip if @watching
+          if addr >= 0x6000
+            @fdc.peek(addr & 0x03)
+          elsif addr >= 0x4000
+            @cia.peek(0x4000 | (addr & 0x0f))
+          else
+            @data
+          end
+        end
+
+        def chip_poke(addr, value)
+          watch_chip if @watching
+          if addr >= 0x6000
+            @fdc.poke(addr & 0x03, value)
+          elsif addr >= 0x4000
+            @cia.poke(0x4000 | (addr & 0x0f), value)
+            @drive.ports_written if addr.nobits?(0x0c)
+          end
+        end
+
+        def touch(addr)
+          @touched[addr] = @ram.peek(addr) unless @touched.key?(addr)
+        end
+
+        def watching!
+          @watching = @recording || @guarding
+        end
+
+        def watch_chip
+          if @recording
+            @volatile = true
+            @recording = false
+          end
+          if @guarding
+            @tainted = true
+            @guarding = false
+          end
+          watching!
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Badline
+  module Drives
+    class Model1581
+      # The drive's 6502, on the drive's Bus.
+      class CPU
+        include Badline::Chips::CPU::Core
+        include Engine::IdleCPU
+      end
+    end
+  end
+end

data/lib/badline/drives/model1581/disk/saved_state.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Badline
+  module Drives
+    class Model1581
+      class Disk
+        # Saving and restoring a Disk for a snapshot: the image by its path,
+        # and every track the head wrote since the disk went in, with those
+        # written since the last flush. The rest come from the image, read
+        # again from its host file where there still is one.
+        module SavedState
+          # The image's path, expanded, and whether it was opened read-only,
+          # for a disk from Disk.open. Nil for a disk made another way.
+          attr_reader :path, :read_only
+
+          # The disk a state from save_state describes: +current+ when it was
+          # opened from the same image the same way, and otherwise a disk for
+          # the image at the path the state names. Where no file is at that
+          # path, the disk has no image and is write-protected, and a
+          # detached reader always gets one without an image.
+          def self.load(input, current)
+            path = input.optional_string
+            read_only = input.boolean?
+            disk = current if current && !path.nil? && current.path == path && current.read_only == read_only
+            disk ||= fresh(path, read_only, input.detached?)
+            disk.load_tracks(input)
+            disk
+          end
+
+          def self.fresh(path, read_only, detached)
+            return Disk.new if path.nil? || detached
+            return Disk.new.opened(path, true) unless File.file?(path)
+
+            Disk.open(path, read_only:)
+          end
+
+          # Notes the image's path and how it was opened.
+          def opened(path, read_only)
+            @path = File.expand_path(path)
+            @read_only = read_only
+            self
+          end
+
+          def save_state(out)
+            out.optional_string(@path).boolean(@read_only)
+            changed = @changed.keys.sort
+            out.ints(changed)
+            changed.each { |index| save_track(@tracks[index], out) }
+            out.ints(@written.keys)
+          end
+
+          def load_tracks(input)
+            @changed.clear
+            input.ints.each do |index|
+              @tracks[index] = load_track(input)
+              @changed[index] = true
+            end
+            @written.clear
+            input.ints.each { |index| @written[index] = true }
+          end
+
+          private
+
+          def save_track(track, out)
+            out.int(track.sectors.length)
+            track.sectors.each do |sector|
+              save_field(sector.id, out)
+              out.boolean(!sector.data.nil?)
+              save_field(sector.data, out) if sector.data
+            end
+          end
+
+          def save_field(field, out)
+            out.int(field.mark).ints(field.bytes).boolean(field.good).boolean(field.deleted)
+          end
+
+          def load_track(input)
+            Track.new(Array.new(input.int) do
+              id = load_field(input)
+              Track::Sector.new(id, input.boolean? ? load_field(input) : nil)
+            end)
+          end
+
+          def load_field(input) = Track::Field.new(input.int, input.ints, input.boolean?, input.boolean?)
+        end
+      end
+    end
+  end
+end

data/lib/badline/drives/model1581/disk.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require "badline/drives/model1581/disk/saved_state"
+
+module Badline
+  module Drives
+    class Model1581
+      # A 3.5" double-sided disk as the WD1772 sees it: a Track on each side
+      # of 80 cylinders, or none where it was never formatted.
+      #
+      # A .d81 image holds the 1581 DOS's logical blocks in order, 40 of 256
+      # bytes on each logical track 1 to 80 (1581 Service Manual, format
+      # organization). Logical track t is cylinder t - 1, and the DOS puts
+      # its sectors 0 to 19 on side 0 and 20 to 39 on side 1, two to each
+      # 512-byte physical sector, numbered from 1. So physical sector s on
+      # side h of cylinder c holds logical sectors 20h + 2(s - 1) and the one
+      # after it, and every cylinder of the image is a standard Track
+      # (Track.standard) on both sides. A block the image's error table
+      # marks 20 or 21 loses its sector's ID field, 27 spoils the ID's CRC,
+      # 22 loses the data field and 23 spoils its CRC.
+      #
+      # The WD1772 writes into the tracks, and flush stores the standard
+      # sectors of each one written back in the image, which writes its host
+      # file. A track formatted another way stays on the disk alone. The disk
+      # is write-protected when the image won't take writes.
+      class Disk
+        include SavedState
+
+        CYLINDERS = 80
+        SIDES = 2
+
+        # Logical blocks a side of a cylinder holds.
+        SIDE_BLOCKS = 20
+
+        # A logical block's bytes, and how many a physical sector holds.
+        BLOCK_SIZE = 256
+        BLOCKS = Track::SECTOR_SIZE / BLOCK_SIZE
+
+        # A disk from the .d81 image at +path+. `read_only` opens the image
+        # write-protected.
+        def self.open(path, read_only: false)
+          new(Storage::D81Image.new(path, read_only:)).opened(path, read_only)
+        end
+
+        attr_reader :image
+
+        def initialize(image = nil)
+          @image = image
+          @tracks = Array.new(CYLINDERS * SIDES)
+          @written = {}
+          @changed = {}
+          @path = nil
+          @read_only = false
+        end
+
+        # The Track on +side+ of +cylinder+, or nil where there is none: past
+        # the image's cylinders, or on a disk without an image that the head
+        # never formatted.
+        def track(cylinder, side)
+          index = (cylinder * SIDES) + side
+          return @tracks[index] if @tracks[index] || !@image || cylinder >= CYLINDERS
+
+          @tracks[index] = image_track(cylinder, side)
+        end
+
+        # A write track laid +track+ down on +side+ of +cylinder+, or a write
+        # sector changed it.
+        def write(cylinder, side, track)
+          return if cylinder >= CYLINDERS
+
+          index = (cylinder * SIDES) + side
+          @tracks[index] = track
+          @written[index] = true
+          @changed[index] = true
+        end
+
+        # Whether the write-protect hole is open: the disk's image won't take
+        # writes, or a disk without an image was opened read-only.
+        def write_protected? = @image.nil? ? @read_only : !@image.writable?
+
+        # Whether any track was written since the last flush.
+        def written? = !@written.empty?
+
+        # Stores the standard sectors of each track written since the last
+        # flush in the image, all in one write to its host file.
+        def flush
+          written = @written.keys.sort
+          @written.clear
+          return if @image.nil? || written.empty?
+
+          @image.store_blocks(written.flat_map { |index| track_blocks(index / SIDES, index % SIDES) })
+        end
+
+        private
+
+        def image_track(cylinder, side)
+          track = Track.standard(cylinder, side) { |sector| physical_block(cylinder, side, sector) }
+          track.sectors.each { |sector| mark_errors(cylinder, side, sector) }
+          track.sectors.reject! { |sector| sector.id.nil? }
+          track
+        end
+
+        # The logical track and first sector physical sector +sector+ holds.
+        def logical(cylinder, side, sector) = [cylinder + 1, (side * SIDE_BLOCKS) + ((sector - 1) * BLOCKS)]
+
+        def physical_block(cylinder, side, sector)
+          track, first = logical(cylinder, side, sector)
+          Array.new(BLOCKS) { |i| @image.read_block(track, first + i) || [] }.flatten
+        end
+
+        def mark_errors(cylinder, side, sector)
+          track, first = logical(cylinder, side, sector.id.bytes[2])
+          errors = Array.new(BLOCKS) { |i| @image.block_error(track, first + i) }
+          sector.id.good = false if errors.include?(27)
+          sector.data.good = false if errors.include?(23)
+          sector.data = nil if errors.include?(22)
+          sector.id = nil if errors.include?(20) || errors.include?(21)
+        end
+
+        # [track, sector, data, nil] for DiskImage#store_blocks, for each
+        # logical block a standard sector of the track holds.
+        def track_blocks(cylinder, side)
+          track = @tracks[(cylinder * SIDES) + side]
+          Track::SECTORS.times.flat_map do |index|
+            data = track.sector([cylinder, side, index + 1, Track::SIZE_CODE])&.data
+            next [] unless data
+
+            logical_track, first = logical(cylinder, side, index + 1)
+            Array.new(BLOCKS) do |i|
+              [logical_track, first + i, data.bytes[i * BLOCK_SIZE, BLOCK_SIZE], nil]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/badline/drives/model1581/mechanism.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Badline
+  module Drives
+    class Model1581
+      # The 1581's 3.5" mechanism: the spindle motor, the head on one of
+      # its cylinders and sides, the index sensor, and the lines it reports
+      # on the drive connector (1581 Service Manual, schematic sheet 2).
+      #
+      # The motor runs while /MOTOR is low and turns a disk at 300 rpm, a
+      # turn every REVOLUTION drive cycles at 2 MHz. The index sensor pulses
+      # for INDEX_PULSE cycles at the start of each turn, which is where a
+      # Track's bytes start. /RDY is low while the motor turns a disk. The
+      # WD1772 steps the head, and /TR00 is low while it sits on cylinder 0.
+      # /WPRT is low while the disk's write-protect hole is open, or without
+      # a disk.
+      #
+      # /DISK CHNG goes low as a disk comes out, and at power-on, and goes
+      # high again at a step pulse with a disk in, as on any Shugart-style
+      # drive with a disk change line. The DOS steps in and out after
+      # spinning the motor up to find out whether a disk is in.
+      #
+      # Times are the WD1772's cycle count (WD1772#now), which the drive
+      # passes in: the angle under the head follows from how long the disk
+      # has turned.
+      class Mechanism
+        REVOLUTION = 400_000
+        INDEX_PULSE = 4_000
+        LAST_CYLINDER = 83
+
+        attr_reader :disk, :cylinder
+        attr_accessor :side
+
+        def initialize
+          @disk = nil
+          @cylinder = 0
+          @side = 0
+          @motor = false
+          @changed = true
+          @angle = 0
+          @since = 0
+        end
+
+        # Puts a Disk in, or with nil takes it out. Whatever was in is
+        # flushed first, and the disk change line goes low.
+        def insert(disk, now)
+          @angle = angle(now)
+          @since = now
+          flush
+          @disk = disk
+          @changed = true
+        end
+
+        def flush = @disk&.flush
+
+        def motor_on? = @motor
+
+        # Turns the motor on or off at +now+.
+        def motor(on, now)
+          @angle = angle(now)
+          @since = now
+          @motor = on
+        end
+
+        # Whether a disk turns.
+        def spinning? = @motor && !@disk.nil?
+
+        # How far into its turn the disk is at +now+, in cycles from the
+        # index.
+        def angle(now) = spinning? ? (@angle + now - @since) % REVOLUTION : @angle
+
+        def index?(now) = spinning? && angle(now) < INDEX_PULSE
+
+        def ready? = spinning?
+
+        def track0? = @cylinder.zero?
+
+        def disk_changed? = @changed
+
+        def write_protected? = @disk.nil? || @disk.write_protected?
+
+        # A step pulse, towards the hub with +inward+.
+        def step(inward)
+          @cylinder = (@cylinder + (inward ? 1 : -1)).clamp(0, LAST_CYLINDER)
+          @changed = false if @disk
+        end
+
+        # The Track under the head, or nil.
+        def track = @disk&.track(@cylinder, @side)
+
+        # Stores a track the WD1772 laid down under the head.
+        def write(track)
+          @disk&.write(@cylinder, @side, track)
+        end
+
+        # The disk (Disk#save_state) and the motor, the head and the turn.
+        def save_state(out)
+          out.boolean(!@disk.nil?)
+          @disk&.save_state(out)
+          out.int(@cylinder).int(@side).int(@angle).int(@since).boolean(@motor).boolean(@changed)
+        end
+
+        # Puts the state back, reusing the disk in when it's the one the state
+        # names (Disk::SavedState.load). A disk taken out is flushed.
+        def load_state(input)
+          disk = input.boolean? ? Disk::SavedState.load(input, @disk) : nil
+          flush unless disk.equal?(@disk)
+          @disk = disk
+          @cylinder = input.int
+          @side = input.int
+          @angle = input.int
+          @since = input.int
+          @motor = input.boolean?
+          @changed = input.boolean?
+        end
+      end
+    end
+  end
+end

data/lib/badline/drives/model1581/saved_state.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Badline
+  module Drives
+    class Model1581
+      # The drive's state for a snapshot.
+      module SavedState
+        # The drive's whole state, as the 1541's (Drives::Model1541#save_state), with
+        # the 8520 and the WD1772 in place of the VIAs.
+        def save_state(out)
+          settle!
+          out.marker("DRIVE1581")
+          out.int(@phase).int(@cycles).boolean(@atn)
+          @serial_port.save_state(out)
+          @cia.save_state(out)
+          @fdc.save_state(out)
+          @bus.save_state(out)
+          @cpu.save_state(out)
+          @mechanism.save_state(out)
+        end
+
+        def load_state(input)
+          settle!
+          input.marker("DRIVE1581")
+          @phase = input.int
+          @cycles = input.int
+          @atn = input.boolean?
+          @serial_port.load_state(input)
+          @cia.load_state(input)
+          @fdc.load_state(input)
+          @bus.load_state(input)
+          @cpu.load_state(input)
+          @mechanism.load_state(input)
+          @fast_serial_out = @cia.port_b_lines.anybits?(FAST_SERIAL_OUT)
+          ports_written
+          push_fast_output(@fast_serial_out ? fast_pins : 0)
+          forget_orbits
+        end
+      end
+    end
+  end
+end

data/lib/badline/drives/model1581/serial_port.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Badline
+  module Drives
+    class Model1581
+      # What the 8520's ports read from outside the chip (1581 Service
+      # Manual, schematic sheet 3; the DOS's I/O definitions):
+      #
+      #   PA0  side select (out)           PB0  DATA IN (in)
+      #   PA1  /RDY from the mechanism     PB1  DATA OUT (out)
+      #   PA2  /MOTOR (out)                PB2  CLK IN (in)
+      #   PA3  device number switch 1      PB3  CLK OUT (out)
+      #   PA4  device number switch 2      PB4  ATN ACK (out)
+      #   PA5  power LED (out)             PB5  fast serial direction (out)
+      #   PA6  activity LED (out)          PB6  /WPRT from the mechanism
+      #   PA7  /DISK CHNG from the mech.   PB7  ATN IN (in)
+      #
+      # DATA IN, CLK IN and ATN IN come through inverters, so a pulled line
+      # reads 1, as on the 1541 (Drives::Engine::SerialLines). A closed switch pulls
+      # its line low, and both closed make device 8. The ports' outputs
+      # read back as driven: the peripheral pulls only the inputs.
+      class SerialPort
+        include Engine::SerialLines
+
+        READY = 0x02
+        SWITCHES = 0x18
+        DISK_CHANGE = 0x80
+        PROTECT = 0x40
+
+        def initialize(mechanism, device: 8, bus: SerialBus.new)
+          @mechanism = mechanism
+          @switches = (0xff & ~SWITCHES) | (((device - 8) & 0x03) << 3)
+          init_serial_lines(device, bus)
+        end
+
+        def read_a(_port_a, _port_b)
+          value = @switches
+          value &= ~READY if @mechanism.ready?
+          value &= ~DISK_CHANGE if @mechanism.disk_changed?
+          value
+        end
+
+        def read_b(_port_a, _port_b)
+          low = @bus.low_lines(@host)
+          value = 0xff & ~(SERIAL_INPUTS | PROTECT)
+          value |= DATA_IN if low.anybits?(SerialBus::DATA)
+          value |= CLK_IN if low.anybits?(SerialBus::CLK)
+          value |= ATN_IN if low.anybits?(SerialBus::ATN)
+          @mechanism.write_protected? ? value : value | PROTECT
+        end
+      end
+    end
+  end
+end

data/lib/badline/drives/model1581/slot.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Badline
+  module Drives
+    class Model1581
+      # A machine's place for a Drives::Model1581 on its serial bus, in a field of
+      # its own beside its other true drives, so none of them makes another's
+      # per-cycle call a union. The C64, the VIC-20 and the C128 include it,
+      # and run the drive from their cycle as they run a 1541.
+      #
+      # A 1581 reads only .d81 images and the others none, so a .d81 put in
+      # device 8 swaps the true drive there for a 1581, and any other disk
+      # swaps a 1581 back for the machine's own true drive
+      # (Media::TrueDrive).
+      module Slot
+        attr_reader :drive1581
+
+        # Plugs in a Drives::Model1581, which then runs alongside the machine on its
+        # own clock and talks to it over the serial bus, as a 1541 does.
+        def attach_drive1581(drive)
+          @iec_bus.detach(@drive1581) if @drive1581
+          drive.host_clock_hz = timing.clock_hz
+          @drive1581 = drive
+          drive.connect(@iec_bus)
+          @serial_trap&.device = serial_trap_device
+          drive1581_attached
+        end
+
+        # Unplugs the Drives::Model1581.
+        def detach_drive1581
+          return unless @drive1581
+
+          @iec_bus.detach(@drive1581)
+          @drive1581 = nil
+          @serial_trap&.device = serial_trap_device
+        end
+
+        # Plugs in a 1581 as device 8, in place of the true drive there, and
+        # returns it.
+        def plug_drive1581
+          unplug_device8
+          Model1581.new.tap { |drive| attach_drive1581(drive) }
+        end
+
+        private
+
+        # Unplugs the 1541 if it is device 8, for a 1581 to take its place.
+        def unplug_device8
+          detach_drive1541 if @drive1541&.device == KernalTrap::Routine::DEVICE
+        end
+
+        # What the machine does as a 1581 goes on its bus. The VIC-20 waits
+        # for its DOS to boot before typing.
+        def drive1581_attached = nil
+
+        # Whether the 1581 is device 8.
+        def drive1581_on_device8? = @drive1581&.device == KernalTrap::Routine::DEVICE
+
+        # The 1581 on the serial bus, with its device number.
+        def save_drive1581(out)
+          out.boolean(!@drive1581.nil?)
+          return unless @drive1581
+
+          out.int(@drive1581.device)
+          @drive1581.save_state(out)
+        end
+
+        def load_drive1581(input)
+          return detach_drive1581 unless input.boolean?
+
+          device = input.int
+          detach_drive1581 if @drive1581 && @drive1581.device != device
+          attach_drive1581(Model1581.new(device:)) unless @drive1581
+          @drive1581.load_state(input)
+        end
+      end
+    end
+  end
+end