badline 0.11.1 → 0.12.0

data/lib/badline/drive1581/wd1772/sectors.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module Badline
+  class Drive1581
+    class WD1772
+      # The type II commands and read address, which find an ID field on
+      # the track under the head:
+      #
+      #   100mhE00  read sector    the data field after the ID that carries
+      #                            the track and sector registers
+      #   101mhEPa  write sector   a data field after that ID, deleted with a
+      #   11000hE00 read address   the next ID field's six bytes, the track
+      #                            going into the sector register
+      #
+      # The search reads each ID field as it passes. One that matches but
+      # whose CRC doesn't read back sets CRC_ERROR and the search goes on;
+      # after five index pulses it gives up with NOT_FOUND. Each byte of a
+      # field passes in BYTE cycles and sets DRQ as it lands in the data
+      # register, and LOST_DATA where the last one was still unread. With m
+      # the command goes on to the next sector until one isn't found. E
+      # lets the head settle first. SectorWrites writes the data field.
+      module Sectors
+        private
+
+        def start_type2
+          start_search(@command < 0xa0 ? READ : WRITE)
+        end
+
+        def start_read_address
+          start_search(ADDRESS)
+        end
+
+        def start_search(mode)
+          @type1 = false
+          @status = 0
+          @drq = false
+          @mode = mode
+          resume_type2 unless spinning_up?(SEARCH)
+        end
+
+        def resume_type2
+          if @mode == WRITE && @mechanism.write_protected?
+            @status |= PROTECTED
+            return finish
+          end
+          return begin_search if @command.nobits?(SETTLE_DELAY)
+
+          @phase = SETTLE_SEARCH
+          @due = @now + SETTLE
+        end
+
+        # Searches for five index pulses from now.
+        def begin_search
+          index = next_index
+          @deadline = index == NEVER ? NEVER : index + (4 * Mechanism::REVOLUTION)
+          search
+        end
+
+        # Waits for the next ID field to pass under the head.
+        def search
+          @phase = SEARCH
+          track = @mechanism.track
+          sector = track&.next_id((@mechanism.angle(@now) / BYTE) + 1)
+          @found = sector ? track.sectors.index(sector) : -1
+          @id_at = sector ? byte_end(sector.id.mark) : NEVER
+          @due = [@id_at, @deadline].min
+        end
+
+        def found = @mechanism.track&.sectors&.[](@found)
+
+        def id_passed
+          return not_found unless @now == @id_at
+
+          sector = found
+          return search if sector.nil?
+
+          id = sector.id
+          return id_read(id) if @mode == ADDRESS
+          return search unless matches?(id.bytes)
+          return crc_mismatch unless id.good
+
+          @status &= ~CRC_ERROR
+          @mode == VERIFY_TRACK ? finish : sector_found(sector)
+        end
+
+        def matches?(id)
+          id[0] == @track && (@mode == VERIFY_TRACK || id[2] == @sector)
+        end
+
+        def crc_mismatch
+          @status |= CRC_ERROR
+          search
+        end
+
+        def not_found
+          @status |= NOT_FOUND
+          finish
+        end
+
+        def sector_found(sector)
+          return write_sector(sector) if @mode == WRITE
+
+          data = sector.data
+          return search if data.nil? || data.mark > sector.id.mark + 7 + Track::DATA_MARK_WINDOW
+
+          @status |= DELETED if data.deleted
+          transfer(data.bytes, data.mark, READ_DATA)
+          @crc_good = data.good
+        end
+
+        # Read address: the ID's bytes and its CRC.
+        def id_read(id)
+          @status |= CRC_ERROR unless id.good
+          transfer(id.bytes + Track.field_crc(Track::ID_MARK, id.bytes), id.mark, READ_ADDRESS)
+        end
+
+        def transfer(bytes, mark, phase)
+          @bytes = bytes
+          @index = 0
+          @phase = phase
+          @due = byte_end(mark + 1)
+        end
+
+        # A byte of the field lands in the data register. After the last,
+        # the CRC passes.
+        def byte_read
+          return field_read if @index == @bytes.length
+
+          @status |= LOST_DATA if @drq
+          @data = @bytes[@index]
+          @drq = true
+          @index += 1
+          @due += @index == @bytes.length && @phase == READ_DATA ? 2 * BYTE : BYTE
+        end
+
+        def field_read
+          if @phase == READ_ADDRESS
+            @sector = @bytes[0]
+          elsif !@crc_good
+            @status |= CRC_ERROR
+          elsif @command.anybits?(MULTIPLE)
+            @sector = (@sector + 1) & 0xff
+            return begin_search
+          end
+          finish
+        end
+      end
+    end
+  end
+end

data/lib/badline/drive1581/wd1772/state.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Badline
+  class Drive1581
+    class WD1772
+      # Saving and restoring the WD1772 for a snapshot: its registers and
+      # lines, and the command running, down to the byte it is at.
+      module State
+        def save_state(out)
+          [@now, @due, @phase, @command, @track, @sector, @data, @status, @steps, @count, @after_spin_up, @mode,
+           @deadline, @id_at, @found, @index, @crc, @write_id, @size].each { |value| out.int(value) }
+          [@type1, @drq, @intrq, @motor_on, @inward, @crc_good, @gate_open, @late,
+           @settling].each { |flag| out.boolean(flag) }
+          out.ints(@bytes).ints(@syncs.map { |sync| sync ? 1 : 0 })
+        end
+
+        def load_state(input)
+          load_registers(input)
+          load_command(input)
+          load_flags(input)
+          @bytes = input.ints
+          @syncs = input.ints.map { |sync| sync == 1 }
+        end
+
+        private
+
+        def load_registers(input)
+          @now = input.int
+          @due = input.int
+          @phase = input.int
+          @command = input.int
+          @track = input.int
+          @sector = input.int
+          @data = input.int
+          @status = input.int
+        end
+
+        def load_command(input)
+          @steps = input.int
+          @count = input.int
+          @after_spin_up = input.int
+          @mode = input.int
+          @deadline = input.int
+          @id_at = input.int
+          @found = input.int
+          @index = input.int
+          @crc = input.int
+          @write_id = input.int
+          @size = input.int
+        end
+
+        def load_flags(input)
+          @type1 = input.boolean?
+          @drq = input.boolean?
+          @intrq = input.boolean?
+          @motor_on = input.boolean?
+          @inward = input.boolean?
+          @crc_good = input.boolean?
+          @gate_open = input.boolean?
+          @late = input.boolean?
+          @settling = input.boolean?
+        end
+      end
+    end
+  end
+end

data/lib/badline/drive1581/wd1772/stepping.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Badline
+  class Drive1581
+    class WD1772
+      # The type I commands, which move the head:
+      #
+      #   0000hVrr  restore    step out to track 0, the track register to 0
+      #   0001hVrr  seek       step until the track register holds the data
+      #                        register's track
+      #   001uhVrr  step       one step the way the last one went
+      #   010uhVrr  step in    one step towards the hub
+      #   011uhVrr  step out   one step towards the rim
+      #
+      # Each step waits out the step rate rr picks (STEP_RATES), and u has
+      # a step update the track register, as restore and seek always do.
+      # With V the head settles and the command reads IDs until one carries
+      # the track register's track, or sets NOT_FOUND after five turns.
+      module Stepping
+        private
+
+        def start_type1
+          @type1 = true
+          @status = 0
+          @drq = false
+          @phase = STEPPED
+          @steps = 0
+          if @command < 0x10
+            @track = 0xff
+            @data = 0
+          elsif @command >= 0x40
+            @inward = @command < 0x60
+          end
+          step_done unless spinning_up?(STEPPED)
+        end
+
+        def spun_up
+          @status |= SPUN_UP
+          @phase = @after_spin_up
+          case @after_spin_up
+          when STEPPED then step_done
+          when SEARCH then resume_type2
+          else resume_track
+          end
+        end
+
+        # The step rate has passed: the next step, or the end of the moves.
+        def step_done
+          return next_step if @steps.zero? || @command < 0x20
+
+          moved
+        end
+
+        # Restore and seek step until the track register matches, restore
+        # also stopping at track 0. The others step once.
+        def next_step
+          return single_step if @command >= 0x20
+          return seek_restore if @command < 0x10 && restored?
+
+          if @track == @data
+            moved
+          else
+            @inward = @data > @track
+            @track = (@track + (@inward ? 1 : -1)) & 0xff
+            pulse
+          end
+        end
+
+        def restored?
+          return false unless @mechanism.track0? || @steps >= 255
+
+          @status |= NOT_FOUND if !@mechanism.track0? && @command.anybits?(VERIFY)
+          true
+        end
+
+        def seek_restore
+          @track = 0 if @mechanism.track0?
+          moved
+        end
+
+        def single_step
+          @track = (@track + (@inward ? 1 : -1)) & 0xff if @command.anybits?(UPDATE)
+          pulse
+        end
+
+        def pulse
+          @steps += 1
+          @mechanism.step(@inward)
+          @phase = STEPPED
+          @due = @now + STEP_RATES[@command & 0x03]
+        end
+
+        # The head is there: with V it settles, and the command ends
+        # otherwise.
+        def moved
+          return finish unless @command.anybits?(VERIFY) && @status.nobits?(NOT_FOUND)
+
+          @phase = SETTLED
+          @due = @now + SETTLE
+        end
+
+        def verify_track
+          @mode = VERIFY_TRACK
+          begin_search
+        end
+      end
+    end
+  end
+end

data/lib/badline/drive1581/wd1772/tracks.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Badline
+  class Drive1581
+    class WD1772
+      # The type III commands that take a whole turn, from one index pulse
+      # to the next:
+      #
+      #   11100hE00  read track   every byte under the head (Track#raw)
+      #   11110hEP0  write track  every byte the CPU sends, for a format
+      #
+      # Write track asks for its first byte at once and starts at the index
+      # pulse, giving up with LOST_DATA if the byte hasn't come three bytes
+      # later. $F5 writes a sync mark, an $A1, and the first of a run starts
+      # the CRC over; $F6 writes $C2; $F7 writes the CRC's two bytes. At
+      # the next index pulse the track under the head becomes the fields
+      # found in what went down (Track.parse).
+      module Tracks
+        LATE = 3
+
+        private
+
+        def start_type3
+          @type1 = false
+          @status = 0
+          @drq = false
+          @mode = @command.anybits?(0x10) ? WRITE : READ
+          resume_track unless spinning_up?(TRACK_INDEX)
+        end
+
+        def resume_track
+          if @mode == WRITE
+            if @mechanism.write_protected?
+              @status |= PROTECTED
+              return finish
+            end
+            @drq = true
+          end
+          @phase = @mode == WRITE ? WRITE_TRACK_START : TRACK_INDEX
+          return wait_index(@phase) if @command.nobits?(SETTLE_DELAY)
+
+          @due = @now + SETTLE
+          @settling = true
+        end
+
+        def wait_index(phase)
+          @settling = false
+          @phase = phase
+          @due = next_index
+        end
+
+        def track_index
+          return wait_index(TRACK_INDEX) if @settling
+
+          @bytes = (@mechanism.track || Track.new([])).raw
+          @index = 0
+          @phase = READ_TRACK
+          @due = @now + BYTE
+        end
+
+        def track_byte_read
+          @status |= LOST_DATA if @drq
+          @data = @bytes[@index]
+          @drq = true
+          @index += 1
+          @index == Track::LENGTH ? finish : @due += BYTE
+        end
+
+        def write_track_start
+          return wait_index(WRITE_TRACK_START) if @settling
+
+          @bytes = []
+          @syncs = []
+          @crc = 0xffff
+          @phase = WRITE_TRACK
+          return track_byte_written unless @drq
+
+          @late = true
+          @due = @now + (LATE * BYTE)
+        end
+
+        # The next byte from the data register goes under the head, a 0
+        # where DRQ went unanswered.
+        def track_byte_written
+          return lost if @late && @drq
+          return track_written if @bytes.length >= Track::LENGTH
+
+          @late = false
+          value = @drq ? 0 : @data
+          @status |= LOST_DATA if @drq
+          @drq = true
+          before = @bytes.length
+          lay_byte(value)
+          @due = @now + ((@bytes.length - before) * BYTE)
+        end
+
+        def lay_byte(value)
+          case value
+          when 0xf5
+            @crc = 0xffff unless @syncs.last
+            push_byte(Track::SYNC, true)
+          when 0xf6 then push_byte(0xc2, false)
+          when 0xf7
+            crc = @crc
+            push_byte(crc >> 8, false)
+            push_byte(crc & 0xff, false)
+          else push_byte(value, false)
+          end
+        end
+
+        def push_byte(value, sync)
+          @bytes << value
+          @syncs << sync
+          @crc = Track.crc([value], @crc)
+        end
+
+        def track_written
+          @drq = false
+          @mechanism.write(Track.parse(@bytes.first(Track::LENGTH), @syncs))
+          finish
+        end
+      end
+    end
+  end
+end

data/lib/badline/drive1581/wd1772/turn.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Badline
+  class Drive1581
+    class WD1772
+      # The disk turning under the head: the index pulses a phase waits
+      # for or counts, and the cycle the head comes to a place round the
+      # track.
+      module Turn
+        # The disk began or stopped turning: a phase waiting on the turn
+        # starts its wait again.
+        def spin_changed
+          case @phase
+          when SPIN_UP, MOTOR_IDLE, INDEX_INTERRUPT then count_index
+          when SEARCH then begin_search
+          when TRACK_INDEX, WRITE_TRACK_START then wait_index(@phase)
+          end
+        end
+
+        private
+
+        # The motor starts: with h clear and the motor off, the command waits
+        # out six index pulses first, and the phase comes after them.
+        def spinning_up?(phase)
+          spin_up = !@motor_on && @command.nobits?(NO_SPIN_UP)
+          @motor_on = true
+          return false unless spin_up
+
+          @after_spin_up = phase
+          @phase = SPIN_UP
+          @count = 6
+          count_index
+          true
+        end
+
+        # Waits for @count index pulses, or for the disk to turn.
+        def count_index
+          @due = next_index
+        end
+
+        def index_counted
+          @count -= 1
+          return @due += Mechanism::REVOLUTION if @count.positive?
+
+          case @phase
+          when SPIN_UP then spun_up
+          when MOTOR_IDLE
+            @motor_on = false
+            idle
+          else
+            @intrq = true
+            idle
+          end
+        end
+
+        # The cycle the next index pulse starts, or NEVER while no disk turns.
+        def next_index = at_angle(0)
+
+        # The cycle the head next comes to +angle+, from the index.
+        def at_angle(angle)
+          return NEVER unless @mechanism.spinning?
+
+          delta = (angle - @mechanism.angle(@now)) % Mechanism::REVOLUTION
+          @now + (delta.zero? ? Mechanism::REVOLUTION : delta)
+        end
+
+        # The cycle the byte at +position+ round the track has passed under
+        # the head.
+        def byte_end(position) = at_angle(((position + 1) % Track::LENGTH) * BYTE)
+      end
+    end
+  end
+end