badline 0.12.1 → 0.14.0

data/lib/badline/drives/model1581/wd1772/stepping.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Badline
+  module Drives
+    class Model1581
+      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
+end

data/lib/badline/drives/model1581/wd1772/tracks.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module Badline
+  module Drives
+    class Model1581
+      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
+end

data/lib/badline/drives/model1581/wd1772/turn.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Badline
+  module Drives
+    class Model1581
+      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
+end

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

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+require "badline/drives/model1581/wd1772/registers"
+require "badline/drives/model1581/wd1772/turn"
+require "badline/drives/model1581/wd1772/stepping"
+require "badline/drives/model1581/wd1772/sectors"
+require "badline/drives/model1581/wd1772/sector_writes"
+require "badline/drives/model1581/wd1772/tracks"
+
+module Badline
+  module Drives
+    class Model1581
+      # The WD1772 floppy disk controller at $6000, as the WD177x data sheet
+      # describes it, working on the Mechanism's Track at sector level: it
+      # finds ID and data fields where they lie round the turn and moves
+      # their bytes at the MFM double-density rate, a byte every 32 µs, but
+      # keeps no flux or bitstream.
+      #
+      #   $6000  status (read), command (write)
+      #   $6001  track
+      #   $6002  sector
+      #   $6003  data
+      #
+      # It runs on the drive's clock, 2 MHz here, so the data sheet's times,
+      # given for 8 MHz on the chip's clock pin, come out as BYTE cycles a
+      # byte, STEP_RATES between steps and SETTLE for the head to settle.
+      #
+      # A command runs as a chain of phases, each due at a cycle (@due): a
+      # step, an index pulse, the end of a byte under the head. Between them
+      # nothing happens, so cycle! only counts. BUSY sets as the command is
+      # written, and the chip takes it up START cycles later, 16 µs, so a
+      # command with nothing to do, such as a seek to the track the head is
+      # on, still shows BUSY to the DOS, which polls for it before waiting
+      # for it to clear.
+      #
+      # The 1581 leaves INTRQ and DRQ unconnected and polls the status
+      # register instead (schematic sheet 2), but both are here (intrq?,
+      # drq?). Its DOS sets h in every command, so the motor spin-up wait
+      # never runs; the spindle follows the 8520's /MOTOR line instead.
+      class WD1772
+        include Registers
+        include Turn
+        include Stepping
+        include Sectors
+        include SectorWrites
+        include Tracks
+
+        BYTE = 64
+        START = 32
+        STEP_RATES = [12_000, 24_000, 4_000, 6_000].freeze
+        SETTLE = 30_000
+
+        NEVER = 1 << 60
+
+        # Status bits. Bits 1 and 2 report the index pulse and track 0 after
+        # a type I command, and DRQ and lost data after the others; bit 5
+        # reports spin-up after a type I command and a deleted data mark
+        # after a read.
+        BUSY = 0x01
+        INDEX = 0x02
+        DATA_REQUEST = 0x02
+        TRACK0 = 0x04
+        LOST_DATA = 0x04
+        CRC_ERROR = 0x08
+        NOT_FOUND = 0x10
+        SPUN_UP = 0x20
+        DELETED = 0x20
+        PROTECTED = 0x40
+        MOTOR_ON = 0x80
+
+        # Command flags.
+        NO_SPIN_UP = 0x08
+        VERIFY = 0x04
+        SETTLE_DELAY = 0x04
+        MULTIPLE = 0x10
+        UPDATE = 0x10
+        DELETED_MARK = 0x01
+
+        # Phases.
+        IDLE = 0
+        SPIN_UP = 1
+        STEPPED = 2
+        SETTLED = 3
+        SEARCH = 4
+        READ_DATA = 5
+        WRITE_GATE = 6
+        WRITE_DATA = 7
+        READ_TRACK = 8
+        TRACK_INDEX = 9
+        WRITE_TRACK = 10
+        MOTOR_IDLE = 11
+        INDEX_INTERRUPT = 12
+        SETTLE_SEARCH = 13
+        READ_ADDRESS = 14
+        WRITE_TRACK_START = 15
+        STARTING = 16
+
+        # What a search for an ID field is for.
+        READ = 0
+        WRITE = 1
+        ADDRESS = 2
+        VERIFY_TRACK = 3
+
+        attr_reader :now, :track, :sector, :data, :command
+
+        def initialize(mechanism)
+          @mechanism = mechanism
+          @now = 0
+          @due = NEVER
+          @phase = IDLE
+          reset!
+        end
+
+        # The MR line: the registers as the data sheet leaves them, $03 in
+        # the command register and 1 in the sector register, and no command
+        # running.
+        def reset!
+          @command = 0x03
+          @track = 0
+          @sector = 1
+          @data = 0
+          @status = 0
+          @type1 = true
+          @drq = false
+          @intrq = false
+          @motor_on = false
+          @inward = true
+          clear_command
+          idle
+        end
+
+        def cycle!
+          @now += 1
+          advance if @now == @due
+        end
+
+        # How many cycles can go by before the next phase is due.
+        def quiet_cycles = @due - @now - 1
+
+        # Runs +cycles+ cycles at once, as many as quiet_cycles allows.
+        def fast_forward(cycles)
+          @now += cycles
+        end
+
+        def busy? = @phase != IDLE && @phase != MOTOR_IDLE && @phase != INDEX_INTERRUPT
+
+        def drq? = @drq
+
+        def intrq? = @intrq
+
+        def motor_on? = @motor_on
+
+        private
+
+        # A command ends: INTRQ, and the motor turns off after nine more
+        # index pulses unless a command comes first.
+        def finish
+          @intrq = true
+          @phase = MOTOR_IDLE
+          @count = 9
+          count_index
+        end
+
+        # What a command keeps between its phases.
+        def clear_command
+          @steps = 0
+          @count = 0
+          @after_spin_up = IDLE
+          @mode = 0
+          @deadline = NEVER
+          @id_at = NEVER
+          @found = -1
+          @bytes = []
+          @syncs = []
+          @index = 0
+          @crc = 0xffff
+          @crc_good = true
+          @write_id = 0
+          @size = 0
+          @gate_open = false
+          @late = false
+          @settling = false
+        end
+
+        def idle
+          @phase = IDLE
+          @due = NEVER
+        end
+
+        def advance
+          case @phase
+          when STARTING then start_command
+          when SPIN_UP, MOTOR_IDLE, INDEX_INTERRUPT then index_counted
+          when STEPPED then step_done
+          when SETTLED then verify_track
+          when SETTLE_SEARCH then begin_search
+          when SEARCH then id_passed
+          when READ_DATA, READ_ADDRESS then byte_read
+          else advance_write
+          end
+        end
+
+        def advance_write
+          case @phase
+          when WRITE_GATE then write_gate
+          when WRITE_DATA then byte_written
+          when READ_TRACK then track_byte_read
+          when TRACK_INDEX then track_index
+          when WRITE_TRACK_START then write_track_start
+          when WRITE_TRACK then track_byte_written
+          end
+        end
+      end
+    end
+  end
+end