badline 0.12.1 → 0.14.0

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

@@ -0,0 +1,126 @@
+# 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
+
+        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.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+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
+        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/keyed_state.rb

@@ -0,0 +1,280 @@
+# frozen_string_literal: true
+
+module Badline
+  module Drives
+    class Model1581
+      class WD1772
+        PHASE_NAMES = %w[idle spin_up stepped settled search read_data write_gate write_data read_track track_index
+                         write_track motor_idle index_interrupt settle_search read_address write_track_start
+                         starting].freeze
+        MODE_NAMES = %w[read write address verify_track].freeze
+
+        # The controller in a keyed snapshot module (BL-D8-FDC): its own
+        # cycle count, the step of the command running and what the search
+        # is for by name, the registers and lines, the command's counters,
+        # and when its next step, its deadline and the next ID field fall,
+        # in its cycles from now, each absent when it never does.
+        def save_fields(out)
+          out.int("now", @now).text("phase", PHASE_NAMES.fetch(@phase)).text("mode", MODE_NAMES.fetch(@mode))
+          [["due_in", @due], ["deadline_in", @deadline], ["id_in", @id_at]].each do |key, at|
+            out.int(key, at - @now) unless at == NEVER
+          end
+          out.int("command", @command).int("track", @track).int("sector", @sector).int("data", @data)
+          out.int("status", @status).int("steps", @steps).int("count", @count).int("after_spin_up", @after_spin_up)
+          out.int("found", @found).int("index", @index).int("crc", @crc).int("write_id", @write_id).int("size", @size)
+          save_flag_fields(out)
+          out.bytes("bytes", @bytes).ints("syncs", @syncs.map { |sync| sync ? 1 : 0 })
+        end
+
+        def load_fields(input)
+          @now = input.int("now", @now)
+          @phase = PHASE_NAMES.index(input.choice("phase", PHASE_NAMES, "idle")).to_i
+          @mode = MODE_NAMES.index(input.choice("mode", MODE_NAMES, "read")).to_i
+          @due = at_fields(input, "due_in")
+          @deadline = at_fields(input, "deadline_in")
+          @id_at = at_fields(input, "id_in")
+          load_register_fields(input)
+          load_flag_fields(input)
+          @bytes = input.bytes("bytes", "".b).bytes
+          @syncs = input.ints("syncs", []).map { |sync| sync == 1 }
+        end
+
+        private
+
+        def at_fields(input, key)
+          cycles = input.optional_int(key)
+          cycles.nil? ? NEVER : @now + cycles
+        end
+
+        def load_register_fields(input)
+          @command = input.byte("command", @command)
+          @track = input.byte("track", @track)
+          @sector = input.byte("sector", @sector)
+          @data = input.byte("data", @data)
+          @status = input.byte("status", @status)
+          @steps = input.int("steps", @steps)
+          @count = input.int("count", @count)
+          @after_spin_up = input.int("after_spin_up", @after_spin_up)
+          @found = input.int("found", @found)
+          @index = input.int("index", @index)
+          @crc = input.int("crc", @crc)
+          @write_id = input.int("write_id", @write_id)
+          @size = input.int("size", @size)
+        end
+
+        def save_flag_fields(out)
+          out.bool("type1", @type1).bool("drq", @drq).bool("intrq", @intrq).bool("motor_on", @motor_on)
+          out.bool("inward", @inward).bool("crc_good", @crc_good).bool("gate_open", @gate_open).bool("late", @late)
+          out.bool("settling", @settling)
+        end
+
+        def load_flag_fields(input)
+          @type1 = input.bool("type1", @type1)
+          @drq = input.bool("drq", @drq)
+          @intrq = input.bool("intrq", @intrq)
+          @motor_on = input.bool("motor_on", @motor_on)
+          @inward = input.bool("inward", @inward)
+          @crc_good = input.bool("crc_good", @crc_good)
+          @gate_open = input.bool("gate_open", @gate_open)
+          @late = input.bool("late", @late)
+          @settling = input.bool("settling", @settling)
+        end
+      end
+
+      class Mechanism
+        # The head, the motor and the disk-change switch in a keyed snapshot
+        # module (BL-D8-MECH), with the disk's angle as it stands `now`, on
+        # the controller's clock.
+        def save_fields(out, now)
+          out.int("cylinder", @cylinder).int("side", @side).int("angle", angle(now)).bool("motor", @motor)
+          out.bool("changed", @changed)
+        end
+
+        # Puts `disk` under the head without flushing the one there, as a
+        # snapshot load replaces it.
+        def load_fields(input, disk, now)
+          @disk = disk
+          @cylinder = input.int("cylinder", @cylinder)
+          @side = input.masked("side", @side, 1)
+          @angle = input.int("angle", @angle)
+          @since = now
+          @motor = input.bool("motor", @motor)
+          @changed = input.bool("changed", @changed)
+        end
+      end
+
+      class Disk
+        # A disk's fields in a keyed snapshot module (BL-D8-DISK): the image
+        # file's path and how it was opened, the image as last flushed,
+        # embedded, each track the head wrote since the disk went in, sector
+        # by sector as the WD1772 sees them, and the tracks written since the
+        # last flush.
+        module KeyedState
+          # 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
+
+          # 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_fields(out)
+            path = @path
+            out.text("path", path) if path
+            out.bool("read_only", @read_only == true)
+            image = @image
+            out.text("image.path", image.path.to_s).bytes("image", image.contents) if image
+            changed = @changed.keys.sort
+            out.ints("changed", changed)
+            changed.each { |index| save_track_fields(out, "track#{index}.", @tracks[index]) }
+            out.ints("written", @written.keys)
+          end
+
+          def load_track_fields(input)
+            @changed.clear
+            input.ints("changed", []).each do |index|
+              @tracks[index] = load_track_sectors(input, "track#{index}.")
+              @changed[index] = true
+            end
+            @written.clear
+            input.ints("written", []).each { |index| @written[index] = true }
+            self
+          end
+
+          private
+
+          def save_track_fields(out, prefix, track)
+            out.int("#{prefix}sectors", track.sectors.length)
+            track.sectors.each_with_index do |sector, number|
+              save_field_fields(out, "#{prefix}sector#{number}.id.", sector.id)
+              data = sector.data
+              save_field_fields(out, "#{prefix}sector#{number}.data.", data) if data
+            end
+          end
+
+          def save_field_fields(out, prefix, field)
+            out.int("#{prefix}mark", field.mark).bytes("#{prefix}bytes", field.bytes)
+            out.bool("#{prefix}good", field.good).bool("#{prefix}deleted", field.deleted)
+          end
+
+          def load_track_sectors(input, prefix)
+            Track.new(Array.new(input.int("#{prefix}sectors", 0)) do |number|
+              id = load_field_fields(input, "#{prefix}sector#{number}.id.")
+              data = input.optional_int("#{prefix}sector#{number}.data.mark")
+              Track::Sector.new(id, data.nil? ? nil : load_field_fields(input, "#{prefix}sector#{number}.data."))
+            end)
+          end
+
+          def load_field_fields(input, prefix)
+            Track::Field.new(input.int("#{prefix}mark", 0), input.bytes("#{prefix}bytes", "".b).bytes,
+                             input.bool("#{prefix}good", true), input.bool("#{prefix}deleted", false))
+          end
+        end
+
+        include KeyedState
+
+        # The disk a keyed snapshot module describes: its embedded image,
+        # with the tracks the module holds laid over it. The image takes
+        # writes back to its file only while that file is there and the
+        # reader isn't `detached`. With no image, the disk is the tracks
+        # alone.
+        def self.from_fields(input, detached: false)
+          path = input.text("path", "")
+          read_only = input.bool("read_only", false)
+          bytes = input.bytes("image", "".b).bytes
+          image_path = input.text("image.path", "")
+          disk = bytes.empty? ? Disk.new : Disk.new(image_from(image_path, bytes, read_only || detached))
+          disk.opened(path, read_only || bytes.empty?) unless path.empty?
+          disk.load_track_fields(input)
+        end
+
+        def self.image_from(path, bytes, read_only)
+          Storage::D81Image.new(File.file?(path) ? path : "", read_only:, bytes:)
+        end
+      end
+
+      class Bus
+        # The drive's RAM and the byte last on its data bus, in a keyed
+        # snapshot module (BL-D8-RAM).
+        def save_fields(out)
+          out.int("data", @data).bytes("ram", @ram.read(0, @ram.length))
+        end
+
+        def load_fields(input)
+          @data = input.byte("data", @data)
+          ram = @ram.read(0, @ram.length)
+          @ram.write(0, input.bytes_into("ram", ram))
+          @watching = false
+        end
+      end
+
+      # The drive's own fields in a keyed snapshot module (BL-D8): its
+      # model, its clock phase and cycle count, the ATN level it last saw
+      # and the host's lines as the serial port latched them. The fast
+      # serial direction and the ports' lines come from the 8520 once it
+      # is loaded.
+      module KeyedState
+        def save_fields(out)
+          settle!
+          out.text("model", model_name).int("phase", @phase).int("cycles", @cycles).bool("atn", @atn)
+          @serial_port.save_fields(out, "serial.")
+          out
+        end
+
+        def load_fields(input)
+          settle!
+          input.choice("model", [model_name], model_name)
+          @phase = input.int("phase", @phase)
+          @cycles = input.int("cycles", @cycles)
+          @atn = input.bool("atn", @atn)
+          @serial_port.load_fields(input, "serial.")
+        end
+
+        def restored!
+          @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
+
+        # The drive as modules of its own, as the 1541's, with the 8520 and
+        # the WD1772 in place of the VIAs.
+        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}-CIA") { |out| @cia.save_fields(out) }
+          sections << Snapshot::Keyed.section("#{name}-CPU") { |out| @cpu.save_fields(out) }
+          sections << Snapshot::Keyed.section("#{name}-FDC") { |out| @fdc.save_fields(out) }
+          now = @fdc.now
+          sections << Snapshot::Keyed.section("#{name}-MECH") { |out| @mechanism.save_fields(out, now) }
+          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. The mechanism
+        # takes the disk's angle on the WD1772's clock, so it loads after
+        # the controller.
+        def load_modules(modules, input, name)
+          load_fields(input)
+          @bus.load_fields(modules.required("#{name}-RAM"))
+          @cia.load_fields(modules.required("#{name}-CIA"))
+          @cpu.load_fields(modules.required("#{name}-CPU"))
+          @fdc.load_fields(modules.required("#{name}-FDC"))
+          disk = modules.optional("#{name}-DISK")
+          mechanism = modules.required("#{name}-MECH")
+          @mechanism.load_fields(mechanism, disk.nil? ? nil : Disk.from_fields(disk, detached: modules.detached?),
+                                 @fdc.now)
+          @cia.restored!
+          @cpu.restored!
+          restored!
+        end
+      end
+
+      include KeyedState
+    end
+  end
+end

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

@@ -0,0 +1,98 @@
+# 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
+      end
+    end
+  end
+end