badline 0.12.1 → 0.13.0

data/lib/badline/drive1581/bus.rb

@@ -1,137 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  class Drive1581
-    # The drive CPU's bus, as the 74LS139 decodes A13-A15 (1581 Service
-    # Manual, memory map and schematic sheet 1):
-    #
-    # $0000-$1FFF - 8 KB of RAM
-    # $2000-$3FFF - nothing: open bus
-    # $4000-$5FFF - the 8520, its sixteen registers mirrored
-    # $6000-$7FFF - the WD1772, its four registers mirrored
-    # $8000-$FFFF - the DOS ROM
-    #
-    # Writes to the ROM and to open bus go nowhere, and a read from open
-    # bus finds the last byte on the data bus, as on the 1541. A write to
-    # either of the 8520's ports or their direction registers moves the
-    # drive's lines (Drive1581#ports_written).
-    #
-    # While Idle records a pass of the DOS's idle loop, the bus watches it
-    # (watch!): the RAM it reads and writes, and whether it touched the
-    # 8520 or the WD1772, either of which makes the pass volatile. While
-    # Idle looks for an orbit, the bus guards the drive (guard!), and any
-    # access to either chip taints it.
-    class Bus
-      include Addressable
-
-      attr_reader :ram, :rom, :cia, :fdc, :data, :volatile, :touched, :tainted, :touched_timers
-
-      def initialize(rom:, cia:, fdc:, drive:)
-        addressable_at(0, length: 2**16)
-        @ram = Memory.new([], length: 0x2000, start: 0)
-        @rom = rom
-        @cia = cia
-        @fdc = fdc
-        @drive = drive
-        @data = 0
-        @recording = @guarding = @watching = false
-        @volatile = @tainted = false
-        @touched = {}
-        @touched_timers = 0
-      end
-
-      # The last byte on the data bus and the RAM. What a watched stretch
-      # touched is Idle's, and a restored bus isn't watching.
-      def save_state(out)
-        out.int(@data)
-        @ram.save_state(out)
-      end
-
-      def load_state(input)
-        @data = input.int
-        @ram.load_state(input)
-        @watching = false
-      end
-
-      def peek(addr)
-        return @data = @rom.peek(addr) if addr >= 0x8000
-        return @data = chip_peek(addr) if addr >= 0x2000
-
-        touch(addr) if @recording
-        @data = @ram.peek(addr)
-      end
-
-      def poke(addr, value)
-        @data = value
-        return if addr >= 0x8000
-        return chip_poke(addr, value) if addr >= 0x2000
-
-        touch(addr) if @recording
-        @ram.poke(addr, value)
-      end
-
-      # Starts watching: see volatile and touched.
-      def watch!
-        @recording = true
-        @volatile = false
-        @touched = {}
-        watching!
-      end
-
-      def unwatch!
-        @recording = false
-        watching!
-      end
-
-      # Starts guarding: see tainted.
-      def guard!
-        @guarding = true
-        @tainted = false
-        watching!
-      end
-
-      private
-
-      def chip_peek(addr)
-        watch_chip if @watching
-        if addr >= 0x6000
-          @fdc.peek(addr & 0x03)
-        elsif addr >= 0x4000
-          @cia.peek(0x4000 | (addr & 0x0f))
-        else
-          @data
-        end
-      end
-
-      def chip_poke(addr, value)
-        watch_chip if @watching
-        if addr >= 0x6000
-          @fdc.poke(addr & 0x03, value)
-        elsif addr >= 0x4000
-          @cia.poke(0x4000 | (addr & 0x0f), value)
-          @drive.ports_written if addr.nobits?(0x0c)
-        end
-      end
-
-      def touch(addr)
-        @touched[addr] = @ram.peek(addr) unless @touched.key?(addr)
-      end
-
-      def watching!
-        @watching = @recording || @guarding
-      end
-
-      def watch_chip
-        if @recording
-          @volatile = true
-          @recording = false
-        end
-        if @guarding
-          @tainted = true
-          @guarding = false
-        end
-        watching!
-      end
-    end
-  end
-end

data/lib/badline/drive1581/cpu.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  class Drive1581
-    # The drive's 6502, on the drive's Bus.
-    class CPU
-      include Badline::CPU::Core
-      include Drive::IdleCPU
-    end
-  end
-end

data/lib/badline/drive1581/disk.rb

@@ -1,135 +0,0 @@
-# frozen_string_literal: true
-
-require "badline/drive1581/disk_state"
-
-module Badline
-  class Drive1581
-    # A 3.5" double-sided disk as the WD1772 sees it: a Track on each side
-    # of 80 cylinders, or none where it was never formatted.
-    #
-    # A .d81 image holds the 1581 DOS's logical blocks in order, 40 of 256
-    # bytes on each logical track 1 to 80 (1581 Service Manual, format
-    # organization). Logical track t is cylinder t - 1, and the DOS puts
-    # its sectors 0 to 19 on side 0 and 20 to 39 on side 1, two to each
-    # 512-byte physical sector, numbered from 1. So physical sector s on
-    # side h of cylinder c holds logical sectors 20h + 2(s - 1) and the one
-    # after it, and every cylinder of the image is a standard Track
-    # (Track.standard) on both sides. A block the image's error table
-    # marks 20 or 21 loses its sector's ID field, 27 spoils the ID's CRC,
-    # 22 loses the data field and 23 spoils its CRC.
-    #
-    # The WD1772 writes into the tracks, and flush stores the standard
-    # sectors of each one written back in the image, which writes its host
-    # file. A track formatted another way stays on the disk alone. The disk
-    # is write-protected when the image won't take writes.
-    class Disk
-      include State
-
-      CYLINDERS = 80
-      SIDES = 2
-
-      # Logical blocks a side of a cylinder holds.
-      SIDE_BLOCKS = 20
-
-      # A logical block's bytes, and how many a physical sector holds.
-      BLOCK_SIZE = 256
-      BLOCKS = Track::SECTOR_SIZE / BLOCK_SIZE
-
-      # A disk from the .d81 image at +path+. `read_only` opens the image
-      # write-protected.
-      def self.open(path, read_only: false)
-        new(Storage::D81Image.new(path, read_only:)).opened(path, read_only)
-      end
-
-      attr_reader :image
-
-      def initialize(image = nil)
-        @image = image
-        @tracks = Array.new(CYLINDERS * SIDES)
-        @written = {}
-        @changed = {}
-        @path = nil
-        @read_only = false
-      end
-
-      # The Track on +side+ of +cylinder+, or nil where there is none: past
-      # the image's cylinders, or on a disk without an image that the head
-      # never formatted.
-      def track(cylinder, side)
-        index = (cylinder * SIDES) + side
-        return @tracks[index] if @tracks[index] || !@image || cylinder >= CYLINDERS
-
-        @tracks[index] = image_track(cylinder, side)
-      end
-
-      # A write track laid +track+ down on +side+ of +cylinder+, or a write
-      # sector changed it.
-      def write(cylinder, side, track)
-        return if cylinder >= CYLINDERS
-
-        index = (cylinder * SIDES) + side
-        @tracks[index] = track
-        @written[index] = true
-        @changed[index] = true
-      end
-
-      # Whether the write-protect hole is open: the disk's image won't take
-      # writes, or a disk without an image was opened read-only.
-      def write_protected? = @image.nil? ? @read_only : !@image.writable?
-
-      # Whether any track was written since the last flush.
-      def written? = !@written.empty?
-
-      # Stores the standard sectors of each track written since the last
-      # flush in the image, all in one write to its host file.
-      def flush
-        written = @written.keys.sort
-        @written.clear
-        return if @image.nil? || written.empty?
-
-        @image.store_blocks(written.flat_map { |index| track_blocks(index / SIDES, index % SIDES) })
-      end
-
-      private
-
-      def image_track(cylinder, side)
-        track = Track.standard(cylinder, side) { |sector| physical_block(cylinder, side, sector) }
-        track.sectors.each { |sector| mark_errors(cylinder, side, sector) }
-        track.sectors.reject! { |sector| sector.id.nil? }
-        track
-      end
-
-      # The logical track and first sector physical sector +sector+ holds.
-      def logical(cylinder, side, sector) = [cylinder + 1, (side * SIDE_BLOCKS) + ((sector - 1) * BLOCKS)]
-
-      def physical_block(cylinder, side, sector)
-        track, first = logical(cylinder, side, sector)
-        Array.new(BLOCKS) { |i| @image.read_block(track, first + i) || [] }.flatten
-      end
-
-      def mark_errors(cylinder, side, sector)
-        track, first = logical(cylinder, side, sector.id.bytes[2])
-        errors = Array.new(BLOCKS) { |i| @image.block_error(track, first + i) }
-        sector.id.good = false if errors.include?(27)
-        sector.data.good = false if errors.include?(23)
-        sector.data = nil if errors.include?(22)
-        sector.id = nil if errors.include?(20) || errors.include?(21)
-      end
-
-      # [track, sector, data, nil] for DiskImage#store_blocks, for each
-      # logical block a standard sector of the track holds.
-      def track_blocks(cylinder, side)
-        track = @tracks[(cylinder * SIDES) + side]
-        Track::SECTORS.times.flat_map do |index|
-          data = track.sector([cylinder, side, index + 1, Track::SIZE_CODE])&.data
-          next [] unless data
-
-          logical_track, first = logical(cylinder, side, index + 1)
-          Array.new(BLOCKS) do |i|
-            [logical_track, first + i, data.bytes[i * BLOCK_SIZE, BLOCK_SIZE], nil]
-          end
-        end
-      end
-    end
-  end
-end

data/lib/badline/drive1581/disk_state.rb

@@ -1,87 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  class Drive1581
-    class Disk
-      # Saving and restoring a Disk for a snapshot: the image by its path,
-      # and every track the head wrote since the disk went in, with those
-      # written since the last flush. The rest come from the image, read
-      # again from its host file where there still is one.
-      module State
-        # The image's path, expanded, and whether it was opened read-only,
-        # for a disk from Disk.open. Nil for a disk made another way.
-        attr_reader :path, :read_only
-
-        # The disk a state from save_state describes: +current+ when it was
-        # opened from the same image the same way, and otherwise a disk for
-        # the image at the path the state names. Where no file is at that
-        # path, the disk has no image and is write-protected, and a
-        # detached reader always gets one without an image.
-        def self.load(input, current)
-          path = input.optional_string
-          read_only = input.boolean?
-          disk = current if current && !path.nil? && current.path == path && current.read_only == read_only
-          disk ||= fresh(path, read_only, input.detached?)
-          disk.load_tracks(input)
-          disk
-        end
-
-        def self.fresh(path, read_only, detached)
-          return Disk.new if path.nil? || detached
-          return Disk.new.opened(path, true) unless File.file?(path)
-
-          Disk.open(path, read_only:)
-        end
-
-        # Notes the image's path and how it was opened.
-        def opened(path, read_only)
-          @path = File.expand_path(path)
-          @read_only = read_only
-          self
-        end
-
-        def save_state(out)
-          out.optional_string(@path).boolean(@read_only)
-          changed = @changed.keys.sort
-          out.ints(changed)
-          changed.each { |index| save_track(@tracks[index], out) }
-          out.ints(@written.keys)
-        end
-
-        def load_tracks(input)
-          @changed.clear
-          input.ints.each do |index|
-            @tracks[index] = load_track(input)
-            @changed[index] = true
-          end
-          @written.clear
-          input.ints.each { |index| @written[index] = true }
-        end
-
-        private
-
-        def save_track(track, out)
-          out.int(track.sectors.length)
-          track.sectors.each do |sector|
-            save_field(sector.id, out)
-            out.boolean(!sector.data.nil?)
-            save_field(sector.data, out) if sector.data
-          end
-        end
-
-        def save_field(field, out)
-          out.int(field.mark).ints(field.bytes).boolean(field.good).boolean(field.deleted)
-        end
-
-        def load_track(input)
-          Track.new(Array.new(input.int) do
-            id = load_field(input)
-            Track::Sector.new(id, input.boolean? ? load_field(input) : nil)
-          end)
-        end
-
-        def load_field(input) = Track::Field.new(input.int, input.ints, input.boolean?, input.boolean?)
-      end
-    end
-  end
-end

data/lib/badline/drive1581/mechanism.rb

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

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

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