badline 0.12.1 → 0.14.0

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Badline
+  module Drives
+    class Model1581
+      # What the 8520's ports read from outside the chip (1581 Service
+      # Manual, schematic sheet 3; the DOS's I/O definitions):
+      #
+      #   PA0  side select (out)           PB0  DATA IN (in)
+      #   PA1  /RDY from the mechanism     PB1  DATA OUT (out)
+      #   PA2  /MOTOR (out)                PB2  CLK IN (in)
+      #   PA3  device number switch 1      PB3  CLK OUT (out)
+      #   PA4  device number switch 2      PB4  ATN ACK (out)
+      #   PA5  power LED (out)             PB5  fast serial direction (out)
+      #   PA6  activity LED (out)          PB6  /WPRT from the mechanism
+      #   PA7  /DISK CHNG from the mech.   PB7  ATN IN (in)
+      #
+      # DATA IN, CLK IN and ATN IN come through inverters, so a pulled line
+      # reads 1, as on the 1541 (Drives::Engine::SerialLines). A closed switch pulls
+      # its line low, and both closed make device 8. The ports' outputs
+      # read back as driven: the peripheral pulls only the inputs.
+      class SerialPort
+        include Engine::SerialLines
+
+        READY = 0x02
+        SWITCHES = 0x18
+        DISK_CHANGE = 0x80
+        PROTECT = 0x40
+
+        def initialize(mechanism, device: 8, bus: SerialBus.new)
+          @mechanism = mechanism
+          @switches = (0xff & ~SWITCHES) | (((device - 8) & 0x03) << 3)
+          init_serial_lines(device, bus)
+        end
+
+        def read_a(_port_a, _port_b)
+          value = @switches
+          value &= ~READY if @mechanism.ready?
+          value &= ~DISK_CHANGE if @mechanism.disk_changed?
+          value
+        end
+
+        def read_b(_port_a, _port_b)
+          low = @bus.low_lines(@host)
+          value = 0xff & ~(SERIAL_INPUTS | PROTECT)
+          value |= DATA_IN if low.anybits?(SerialBus::DATA)
+          value |= CLK_IN if low.anybits?(SerialBus::CLK)
+          value |= ATN_IN if low.anybits?(SerialBus::ATN)
+          @mechanism.write_protected? ? value : value | PROTECT
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Badline
+  module Drives
+    class Model1581
+      # A machine's place for a Drives::Model1581 on its serial bus, in a field of
+      # its own beside its other true drives, so none of them makes another's
+      # per-cycle call a union. The C64, the VIC-20 and the C128 include it,
+      # and run the drive from their cycle as they run a 1541.
+      #
+      # A 1581 reads only .d81 images and the others none, so a .d81 put in
+      # device 8 swaps the true drive there for a 1581, and any other disk
+      # swaps a 1581 back for the machine's own true drive
+      # (Media::TrueDrive).
+      module Slot
+        attr_reader :drive1581
+
+        # Plugs in a Drives::Model1581, which then runs alongside the machine on its
+        # own clock and talks to it over the serial bus, as a 1541 does.
+        def attach_drive1581(drive)
+          @iec_bus.detach(@drive1581) if @drive1581
+          drive.host_clock_hz = timing.clock_hz
+          @drive1581 = drive
+          drive.connect(@iec_bus)
+          @serial_trap&.device = serial_trap_device
+          drive1581_attached
+        end
+
+        # Unplugs the Drives::Model1581.
+        def detach_drive1581
+          return unless @drive1581
+
+          @iec_bus.detach(@drive1581)
+          @drive1581 = nil
+          @serial_trap&.device = serial_trap_device
+        end
+
+        # Plugs in a 1581 as device 8, in place of the true drive there, and
+        # returns it.
+        def plug_drive1581
+          unplug_device8
+          Model1581.new.tap { |drive| attach_drive1581(drive) }
+        end
+
+        private
+
+        # Unplugs the 1541 if it is device 8, for a 1581 to take its place.
+        def unplug_device8
+          detach_drive1541 if @drive1541&.device == KernalTrap::Routine::DEVICE
+        end
+
+        # What the machine does as a 1581 goes on its bus. The VIC-20 waits
+        # for its DOS to boot before typing.
+        def drive1581_attached = nil
+
+        # Whether the 1581 is device 8.
+        def drive1581_on_device8? = @drive1581&.device == KernalTrap::Routine::DEVICE
+      end
+    end
+  end
+end

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