badline 0.11.1 → 0.12.0

data/lib/badline/drive1581/mechanism.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module Badline
+  class Drive1581
+    # The 1581's 3.5" mechanism: the spindle motor, the head on one of
+    # its cylinders and sides, the index sensor, and the lines it reports
+    # on the drive connector (1581 Service Manual, schematic sheet 2).
+    #
+    # The motor runs while /MOTOR is low and turns a disk at 300 rpm, a
+    # turn every REVOLUTION drive cycles at 2 MHz. The index sensor pulses
+    # for INDEX_PULSE cycles at the start of each turn, which is where a
+    # Track's bytes start. /RDY is low while the motor turns a disk. The
+    # WD1772 steps the head, and /TR00 is low while it sits on cylinder 0.
+    # /WPRT is low while the disk's write-protect hole is open, or without
+    # a disk.
+    #
+    # /DISK CHNG goes low as a disk comes out, and at power-on, and goes
+    # high again at a step pulse with a disk in, as on any Shugart-style
+    # drive with a disk change line. The DOS steps in and out after
+    # spinning the motor up to find out whether a disk is in.
+    #
+    # Times are the WD1772's cycle count (WD1772#now), which the drive
+    # passes in: the angle under the head follows from how long the disk
+    # has turned.
+    class Mechanism
+      REVOLUTION = 400_000
+      INDEX_PULSE = 4_000
+      LAST_CYLINDER = 83
+
+      attr_reader :disk, :cylinder
+      attr_accessor :side
+
+      def initialize
+        @disk = nil
+        @cylinder = 0
+        @side = 0
+        @motor = false
+        @changed = true
+        @angle = 0
+        @since = 0
+      end
+
+      # Puts a Disk in, or with nil takes it out. Whatever was in is
+      # flushed first, and the disk change line goes low.
+      def insert(disk, now)
+        @angle = angle(now)
+        @since = now
+        flush
+        @disk = disk
+        @changed = true
+      end
+
+      def flush = @disk&.flush
+
+      def motor_on? = @motor
+
+      # Turns the motor on or off at +now+.
+      def motor(on, now)
+        @angle = angle(now)
+        @since = now
+        @motor = on
+      end
+
+      # Whether a disk turns.
+      def spinning? = @motor && !@disk.nil?
+
+      # How far into its turn the disk is at +now+, in cycles from the
+      # index.
+      def angle(now) = spinning? ? (@angle + now - @since) % REVOLUTION : @angle
+
+      def index?(now) = spinning? && angle(now) < INDEX_PULSE
+
+      def ready? = spinning?
+
+      def track0? = @cylinder.zero?
+
+      def disk_changed? = @changed
+
+      def write_protected? = @disk.nil? || @disk.write_protected?
+
+      # A step pulse, towards the hub with +inward+.
+      def step(inward)
+        @cylinder = (@cylinder + (inward ? 1 : -1)).clamp(0, LAST_CYLINDER)
+        @changed = false if @disk
+      end
+
+      # The Track under the head, or nil.
+      def track = @disk&.track(@cylinder, @side)
+
+      # Stores a track the WD1772 laid down under the head.
+      def write(track)
+        @disk&.write(@cylinder, @side, track)
+      end
+
+      # The disk (Disk#save_state) and the motor, the head and the turn.
+      def save_state(out)
+        out.boolean(!@disk.nil?)
+        @disk&.save_state(out)
+        out.int(@cylinder).int(@side).int(@angle).int(@since).boolean(@motor).boolean(@changed)
+      end
+
+      # Puts the state back, reusing the disk in when it's the one the state
+      # names (Disk::State.load). A disk taken out is flushed.
+      def load_state(input)
+        disk = input.boolean? ? Disk::State.load(input, @disk) : nil
+        flush unless disk.equal?(@disk)
+        @disk = disk
+        @cylinder = input.int
+        @side = input.int
+        @angle = input.int
+        @since = input.int
+        @motor = input.boolean?
+        @changed = input.boolean?
+      end
+    end
+  end
+end

data/lib/badline/drive1581/serial_port.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Badline
+  class Drive1581
+    # 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 (Drive::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 Drive::SerialLines
+
+      READY = 0x02
+      SWITCHES = 0x18
+      DISK_CHANGE = 0x80
+      PROTECT = 0x40
+
+      def initialize(mechanism, device: 8, bus: IECBus.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?(IECBus::DATA)
+        value |= CLK_IN if low.anybits?(IECBus::CLK)
+        value |= ATN_IN if low.anybits?(IECBus::ATN)
+        @mechanism.write_protected? ? value : value | PROTECT
+      end
+    end
+  end
+end

data/lib/badline/drive1581/slot.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Badline
+  class Drive1581
+    # A machine's place for a Drive1581 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 Drive1581, 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 Drive1581.
+      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
+        Drive1581.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
+
+      # The 1581 on the serial bus, with its device number.
+      def save_drive1581(out)
+        out.boolean(!@drive1581.nil?)
+        return unless @drive1581
+
+        out.int(@drive1581.device)
+        @drive1581.save_state(out)
+      end
+
+      # Layouts before 8 have no 1581.
+      def load_drive1581(input)
+        return detach_drive1581 if input.schema < 8 || !input.boolean?
+
+        device = input.int
+        detach_drive1581 if @drive1581 && @drive1581.device != device
+        attach_drive1581(Drive1581.new(device:)) unless @drive1581
+        @drive1581.load_state(input)
+      end
+    end
+  end
+end

data/lib/badline/drive1581/track.rb

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

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

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

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