badline 0.12.1 → 0.14.0

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

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

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

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

data/lib/badline/drive1581/wd1772.rb

@@ -1,216 +0,0 @@
-# frozen_string_literal: true
-
-require "badline/drive1581/wd1772/registers"
-require "badline/drive1581/wd1772/turn"
-require "badline/drive1581/wd1772/stepping"
-require "badline/drive1581/wd1772/sectors"
-require "badline/drive1581/wd1772/sector_writes"
-require "badline/drive1581/wd1772/tracks"
-require "badline/drive1581/wd1772/state"
-
-module Badline
-  class Drive1581
-    # 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
-      include State
-
-      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