badline 0.12.0 → 0.13.0

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

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Badline
+  module Drives
+    class Model1581
+      # One side of a cylinder as the WD1772 finds it: its sectors, each an
+      # ID field and a data field at a place round the turn, counted in
+      # bytes from the index pulse. The disk turns at 300 rpm and the bits
+      # pass at 250 kbit/s, so a turn is LENGTH bytes of 32 µs. The bytes
+      # between the fields, the gaps and the sync marks, are not kept: a
+      # read track lays them out again (raw).
+      #
+      # A standard track is the one the 1581 DOS formats (its format routine,
+      # and the 1581 Service Manual's per-sector organization): 32 bytes of
+      # $4E after the index, then ten 512-byte sectors numbered from 1, each
+      #
+      #   12 x $00, 3 x $A1, $FE, track, side, sector, size code, CRC,
+      #   22 x $4E, 12 x $00, 3 x $A1, $FB, 512 data bytes, CRC,
+      #   35 x $4E
+      #
+      # and $4E to the index. A write track lays down whatever the CPU sends,
+      # and parse finds its fields again.
+      class Track
+        LENGTH = 6250
+        GAP = 0x4e
+        SYNC = 0xa1
+        ID_MARK = 0xfe
+        DATA_MARK = 0xfb
+        DELETED_MARK = 0xf8
+
+        SECTORS = 10
+        SECTOR_SIZE = 512
+        SIZE_CODE = 2
+
+        # Where the first sector's ID mark lies, and how far apart the
+        # sectors are.
+        FIRST_ID = 32 + 15
+        SECTOR_SPACING = 574 + 35
+
+        # From an ID mark to its data mark.
+        DATA_OFFSET = 44
+
+        # How far after an ID field's CRC a data mark still belongs to it
+        # (WD177x data sheet).
+        DATA_MARK_WINDOW = 43
+
+        # An ID or data field: its mark's place, its bytes, whether its CRC
+        # reads back, and for a data field whether its mark is the deleted
+        # one.
+        Field = Struct.new(:mark, :bytes, :good, :deleted)
+
+        # A sector: its ID field and its data field, or nil where none
+        # follows the ID.
+        Sector = Struct.new(:id, :data)
+
+        # The CRC-CCITT the WD1772 writes after each field, over the field
+        # from its first $A1: x^16 + x^12 + x^5 + 1 from $FFFF.
+        def self.crc(bytes, crc = 0xffff)
+          bytes.each do |byte|
+            crc ^= byte << 8
+            8.times { crc = crc.anybits?(0x8000) ? ((crc << 1) ^ 0x1021) & 0xffff : (crc << 1) & 0xffff }
+          end
+          crc
+        end
+
+        # A field's CRC as the two bytes written after it: the mark and
+        # +bytes+, behind three $A1s.
+        def self.field_crc(mark, bytes)
+          crc = crc([SYNC, SYNC, SYNC, mark] + bytes)
+          [crc >> 8, crc & 0xff]
+        end
+
+        # A standard track for +cylinder+ and +side+, each sector's data the
+        # block yields for its number, 1 to 10.
+        def self.standard(cylinder, side)
+          sectors = Array.new(SECTORS) do |index|
+            mark = FIRST_ID + (index * SECTOR_SPACING)
+            id = Field.new(mark, [cylinder, side, index + 1, SIZE_CODE], true, false)
+            Sector.new(id, Field.new(mark + DATA_OFFSET, yield(index + 1), true, false))
+          end
+          new(sectors)
+        end
+
+        attr_reader :sectors
+
+        def initialize(sectors)
+          @sectors = sectors
+        end
+
+        # The first sector whose ID mark lies at or after +position+, round
+        # from the index if none does, or nil on a track without IDs.
+        def next_id(position)
+          @sectors.find { |sector| sector.id.mark >= position } || @sectors.first
+        end
+
+        # The sector with the ID field +id+, track, side, sector and size
+        # code, or nil.
+        def sector(id) = @sectors.find { |sector| sector.id.bytes == id }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Badline
+  module Drives
+    class Model1581
+      class Track
+        # A Track as the bytes going round under the head, for the WD1772's
+        # read track: its fields with their gaps and sync marks.
+        module Bytes
+          # The track's LENGTH bytes from the index: $4E gaps, and before each
+          # field 12 x $00 and three $A1 sync marks, its mark, its bytes and
+          # its CRC, spoiled where the field's CRC doesn't read back.
+          def raw
+            bytes = Array.new(LENGTH, GAP)
+            @sectors.each do |sector|
+              lay(bytes, sector.id, ID_MARK)
+              data = sector.data
+              lay(bytes, data, data.deleted ? DELETED_MARK : DATA_MARK) if data
+            end
+            bytes
+          end
+
+          private
+
+          def lay(bytes, field, mark)
+            start = field.mark - 15
+            crc = Track.field_crc(mark, field.bytes)
+            crc[1] ^= 0xff unless field.good
+            [*Array.new(12, 0), SYNC, SYNC, SYNC, mark, *field.bytes, *crc].each_with_index do |byte, i|
+              bytes[start + i] = byte if start + i < LENGTH
+            end
+          end
+        end
+
+        # Finding the fields in the bytes a write track laid down.
+        module Parse
+          # Every sector in +bytes+, a turn as a write track laid it down,
+          # where +syncs+ marks the $A1s written as sync marks: an ID mark
+          # behind three of them, its four bytes and CRC, and the data field
+          # that follows it within DATA_MARK_WINDOW bytes, its length from
+          # the ID's size code.
+          def parse(bytes, syncs)
+            sectors = []
+            position = 0
+            while (mark = find_mark(bytes, syncs, position...bytes.length, ID_MARK..ID_MARK))
+              id = read_field(bytes, mark, 4)
+              position = mark + 7
+              data_mark = find_mark(bytes, syncs, position...(position + DATA_MARK_WINDOW), DELETED_MARK..DATA_MARK)
+              sectors << Sector.new(id, data_mark && read_field(bytes, data_mark, 128 << (id.bytes[3] & 3)))
+            end
+            new(sectors)
+          end
+
+          private
+
+          # The first place in +range+ that holds one of +marks+ behind three
+          # sync marks.
+          def find_mark(bytes, syncs, range, marks)
+            ([range.first, 3].max...[range.end, bytes.length].min).find do |at|
+              marks.cover?(bytes[at]) && syncs[at - 1] && syncs[at - 2] && syncs[at - 3]
+            end
+          end
+
+          def read_field(bytes, mark, length)
+            field = bytes[mark + 1, length] || []
+            field += Array.new(length - field.length, 0)
+            crc = bytes[mark + 1 + length, 2] || []
+            Field.new(mark, field, crc == Track.field_crc(bytes[mark], field), bytes[mark] < 0xfa)
+          end
+        end
+
+        include Bytes
+        extend Parse
+      end
+    end
+  end
+end

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

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Badline
+  module Drives
+    class Model1581
+      class WD1772
+        # The four registers as the CPU reaches them, and a command written
+        # to the command register.
+        module Registers
+          # Register +offset+, 0 to 3.
+          def peek(offset)
+            case offset
+            when 0 then status
+            when 1 then @track
+            when 2 then @sector
+            else read_data
+            end
+          end
+
+          def poke(offset, value)
+            case offset
+            when 0 then write_command(value)
+            when 1 then @track = value unless busy?
+            when 2 then @sector = value unless busy?
+            else write_data(value)
+            end
+          end
+
+          # The status register, which clears INTRQ: after a type I command
+          # bits 1, 2, 5 and 6 follow the index sensor, the track 0 sensor, the
+          # spin-up and the write-protect line as they are now.
+          def status
+            @intrq = false
+            value = @status | (@motor_on ? MOTOR_ON : 0) | (busy? ? BUSY : 0)
+            return value | (@drq ? DATA_REQUEST : 0) unless @type1
+
+            value |= PROTECTED if @mechanism.write_protected?
+            value |= TRACK0 if @mechanism.track0?
+            value | (@mechanism.index?(@now) ? INDEX : 0)
+          end
+
+          private
+
+          def read_data
+            @drq = false
+            @data
+          end
+
+          def write_data(value)
+            @drq = false
+            @data = value
+          end
+
+          # A command while busy goes nowhere, but for a force interrupt.
+          def write_command(value)
+            @intrq = false
+            return force_interrupt(value) if value & 0xf0 == 0xd0
+            return if busy?
+
+            @command = value
+            @phase = STARTING
+            @due = @now + START
+          end
+
+          def start_command
+            if @command < 0x80 then start_type1
+            elsif @command < 0xc0 then start_type2
+            elsif @command & 0xf0 == 0xc0 then start_read_address
+            else start_type3
+            end
+          end
+
+          # Stops a command where it is, leaving its status but for BUSY, or
+          # with none running switches the status to type I. I3 interrupts at
+          # once and I2 at the next index pulse.
+          def force_interrupt(value)
+            @type1 = true unless busy?
+            @drq = false
+            idle
+            @intrq = true if value.anybits?(0x08)
+            return unless value.anybits?(0x04)
+
+            @phase = INDEX_INTERRUPT
+            @count = 1
+            count_index
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Badline
+  module Drives
+    class Model1581
+      class WD1772
+        # Write sector, once Sectors has found the ID: it asks for the first
+        # byte 2 bytes after the ID's CRC and gives up at 22 with LOST_DATA,
+        # then writes the data field where a format puts it, behind 12 x $00
+        # and three $A1s, its mark deleted with a, a byte of 0 for each one
+        # the CPU missed, and the CRC and a $FF after the last.
+        module SectorWrites
+          WRITE_REQUEST = 2
+          WRITE_DEADLINE = 22
+
+          private
+
+          def write_sector(sector)
+            @write_id = sector.id.mark
+            @size = 128 << (sector.id.bytes[3] & 0x03)
+            @gate_open = false
+            @phase = WRITE_GATE
+            @due = byte_end(@write_id + 6 + WRITE_REQUEST)
+          end
+
+          # Two bytes after the ID's CRC, DRQ asks for the first byte, and
+          # twenty bytes on it has to be there.
+          def write_gate
+            unless @gate_open
+              @gate_open = true
+              @drq = true
+              return @due += (WRITE_DEADLINE - WRITE_REQUEST) * BYTE
+            end
+            return lost if @drq
+
+            @bytes = []
+            @phase = WRITE_DATA
+            @due = byte_end(@write_id + Track::DATA_OFFSET)
+          end
+
+          # The next byte goes under the head from the data register, a 0
+          # where DRQ went unanswered, and DRQ asks for the one after it.
+          # After the last come the CRC and a $FF.
+          def byte_written
+            return sector_written if @bytes.length == @size
+
+            @status |= LOST_DATA if @drq && !@bytes.empty?
+            @bytes << (@drq && !@bytes.empty? ? 0 : @data)
+            @drq = @bytes.length < @size
+            @due += @bytes.length == @size ? 3 * BYTE : BYTE
+          end
+
+          def sector_written
+            sector = found
+            if sector
+              sector.data = Track::Field.new(@write_id + Track::DATA_OFFSET, @bytes, true,
+                                             @command.anybits?(DELETED_MARK))
+              @mechanism.write(@mechanism.track)
+            end
+            return finish if @command.nobits?(MULTIPLE)
+
+            @sector = (@sector + 1) & 0xff
+            begin_search
+          end
+
+          def lost
+            @status |= LOST_DATA
+            @drq = false
+            finish
+          end
+        end
+      end
+    end
+  end
+end

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

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

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