badline 0.12.0 → 0.13.0

data/lib/badline/drive1581/track.rb

@@ -1,100 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  class Drive1581
-    # 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

data/lib/badline/drive1581/track_bytes.rb

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

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

@@ -1,89 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  class Drive1581
-    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

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

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  class Drive1581
-    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

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

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

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

@@ -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