badline 0.12.1 → 0.13.0

data/lib/badline/cpu_port.rb

@@ -1,112 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  # The I/O port of the 6510 and the 8502 at $00 (direction) and $01
-  # (data). An input pin reads its pull-up, P4 reads the datasette's sense
-  # line, and a pin without a pull-up holds the charge last driven onto
-  # it. P5 drives the datasette motor through an inverter: low runs it.
-  #
-  # The 6510 has pull-ups on P0-P2 and P4 and leaves P3, P6 and P7
-  # floating. The 8502 adds a CAPS LOCK pin on P6, high while the key is
-  # up.
-  class CPUPort
-    TAPE_SENSE = 0b0001_0000
-
-    # The direction and output registers, and the charge on the floating
-    # pins.
-    attr_reader :ddr, :data, :floating
-
-    # The port as the banking logic reads it (PortStatus).
-    attr_reader :status
-
-    # Whether CAPS LOCK is down, holding its pin low.
-    attr_reader :caps_lock
-
-    # +pullups+ and +floating+ are the masks of the pins with a pull-up and
-    # of the floating ones, and +caps_lock+ the CAPS LOCK pin's, 0 where
-    # there is none.
-    def initialize(datasette, pullups:, floating:, caps_lock: 0)
-      @datasette = datasette
-      @pullups = pullups
-      @floating_mask = floating
-      @caps_lock_pin = caps_lock
-      @caps_lock = false
-      @ddr = 0x00
-      @data = 0x00
-      @floating = 0x00
-      @change_handler = nil
-      @status = PortStatus.new(%i[basic kernal io tape_out tape_switch tape_motor], value: input_value)
-    end
-
-    # Calls the block after every write to the port, for the bus to remap
-    # its banks.
-    def on_change(&handler)
-      @change_handler = handler
-    end
-
-    # What a read of $01 sees.
-    def value = @status.value
-
-    def write_ddr(value)
-      @ddr = value
-      update
-    end
-
-    def write_data(value)
-      @data = value
-      update
-    end
-
-    # The RES line clears the direction and output registers. The floating
-    # pins keep their charge.
-    def reset!
-      @ddr = 0x00
-      @data = 0x00
-      update
-    end
-
-    # Sets the registers and the charge, as a snapshot restores them, and
-    # drives the motor and calls the change handler as a write does.
-    def restore(ddr, data, floating)
-      load(ddr, data, floating)
-      update
-    end
-
-    # Sets the registers and the charge, as a snapshot loads them, without
-    # driving the motor or calling the change handler.
-    def load(ddr, data, floating)
-      @ddr = ddr
-      @data = data
-      @floating = floating
-      refresh
-    end
-
-    # Holds CAPS LOCK down, or lets it up.
-    def caps_lock=(down)
-      @caps_lock = down
-      refresh
-    end
-
-    # Reads the inputs again, after the datasette's sense line changes.
-    def refresh
-      @status.value = input_value
-    end
-
-    private
-
-    def update
-      driven = @ddr & @floating_mask
-      @floating = (@floating & ~driven) | (@data & driven)
-      refresh
-      @datasette.motor = !@status.tape_motor?
-      @change_handler&.call
-    end
-
-    def input_value
-      input = @pullups | (@floating & @floating_mask)
-      input |= @caps_lock_pin unless @caps_lock
-      input &= ~TAPE_SENSE if @datasette.sense_low?
-      (@data & @ddr) | (input & ~@ddr & 0xff)
-    end
-  end
-end

data/lib/badline/datasette.rb

@@ -1,161 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  # The 1530 datasette. Plays a pulse stream into CIA 1's FLAG pin while the
-  # motor runs with a key pressed, and reports the keys through the cassette
-  # sense line on the $01 port. With RECORD down too, it records the
-  # machine's write line onto the tape instead.
-  class Datasette
-    # What inserting a tape raises on a machine without a cassette port.
-    class Missing < ArgumentError; end
-
-    attr_reader :tape
-    attr_writer :motor
-
-    def initialize(tape = nil)
-      @tape = tape
-      @connected = true
-      @playing = false
-      @recording = false
-      @write_high = true
-      @since = 0
-      @motor = false
-      @countdown = 0
-      @flag_handler = nil
-      @sense_handler = nil
-    end
-
-    # Falling edges on the tape read line.
-    def on_flag(&handler)
-      @flag_handler = handler
-    end
-
-    # The cassette sense line, which the $01 port reads back.
-    def on_sense_change(&handler)
-      @sense_handler = handler
-    end
-
-    # Whether the machine has a datasette at its cassette port. The SX-64
-    # has none: its keys stay up and it takes no tape.
-    def connected? = @connected
-
-    def disconnect!
-      eject
-      @connected = false
-    end
-
-    def insert(tape)
-      raise Missing, "this machine has no datasette" unless @connected
-
-      @tape = tape
-      rewind
-    end
-
-    def eject
-      stop!
-      @tape = nil
-    end
-
-    def rewind
-      @tape&.rewind
-      @countdown = 0
-    end
-
-    def play! = press(true)
-    def stop! = press(false)
-
-    # Presses RECORD and PLAY together.
-    def record!
-      return if !@connected || @tape.nil?
-
-      press(true)
-      @recording = true
-      @since = 0
-    end
-
-    def recording? = @recording
-
-    # The machine's tape write line. While the deck records with its motor
-    # running, each rising edge ends a pulse on the tape, as long as the
-    # time since the edge before, and plays back as a falling edge on the
-    # read line.
-    def write_line=(high)
-      rose = high && !@write_high
-      @write_high = high
-      return unless rose && @recording && running?
-
-      @tape.record_pulse(@since)
-      @since = 0
-    end
-
-    def playing? = @playing
-
-    # Sense reads low while a key is down on the deck.
-    def sense_low? = @playing
-
-    def motor? = @motor
-
-    def running? = @playing && @motor && !@tape.nil?
-
-    # The keys, the motor, the countdown to the next pulse and the tape:
-    # its path, its bytes and how far it has played.
-    def save_state(out)
-      out.marker("DATASETTE")
-      out.boolean(@playing).boolean(@motor).int(@countdown).boolean(!@tape.nil?)
-      return unless @tape
-
-      out.string(@tape.path).blob(@tape.bytes).int(@tape.position)
-    end
-
-    # The tape goes back in from the bytes the state holds, without its
-    # host file, unless the tape in is the same one. The sense and flag
-    # handlers don't fire.
-    def load_state(input)
-      input.marker("DATASETTE")
-      @playing = input.boolean?
-      @motor = input.boolean?
-      @countdown = input.int
-      return @tape = nil unless input.boolean?
-
-      path = input.string
-      bytes = input.blob
-      position = input.int
-      @tape = Storage::TAP.new(path, bytes:) unless @tape&.path&.b == path && @tape.bytes == bytes
-      @tape.position = position
-    end
-
-    def cycle!
-      return unless running?
-      return @since += 1 if @recording
-
-      @countdown = @tape.next_pulse.to_i if @countdown.zero?
-      return if @countdown.zero?
-
-      @countdown -= 1
-      @flag_handler&.call if @countdown.zero?
-    end
-
-    def inspect
-      "#<#{self.class.name} tape=#{@tape ? @tape.class.name : 'none'} " \
-        "playing=#{@playing} motor=#{@motor}>"
-    end
-
-    private
-
-    def press(down)
-      return if down == @playing || !@connected
-
-      finish_recording unless down
-      @playing = down
-      @sense_handler&.call
-    end
-
-    # Releasing the keys ends a recording, and writes the tape out.
-    def finish_recording
-      return unless @recording
-
-      @recording = false
-      @tape.save
-    end
-  end
-end

data/lib/badline/drive/core.rb

@@ -1,147 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  module Drive
-    # What every Commodore disk drive here shares: a 6502 running the DOS
-    # ROM, with chips on its bus facing the serial bus and the disk
-    # mechanism, on a clock of its own.
-    #
-    # The drive runs on its own crystal, so it clocks against the host's
-    # clock through a fractional accumulator: each host cycle adds the
-    # drive's clock rate worth of phase, and every whole host period in it
-    # runs a drive cycle. Against the PAL C64's 985,248 Hz a drive at
-    # 1 MHz runs one drive cycle per host cycle and a second one about
-    # every 67. The host sets its clock on attaching the drive, and until
-    # then a 1 MHz drive runs one cycle per host cycle.
-    #
-    # The Mechanism reads a Disk put in with insert.
-    #
-    # While the DOS idles, host_cycle! skips the drive's cycles and catches
-    # up on them later, exactly (see Idle). The readers of the drive's parts
-    # catch up first, so they find the drive as running every cycle would
-    # have left it. Once the DOS's timer interrupts come round, the drive
-    # sleeps through them too (see Orbit).
-    #
-    # A model includes Core and builds its parts, sets @clock_hz and
-    # @idle_loop, and runs one drive cycle in step. It hears ATN on
-    # connecting (hear_atn), drives the serial bus (serial_output), and
-    # answers Idle's and Orbit's questions about its chips, as VIAs does
-    # for the 1541 and the 1571.
-    module Core
-      include Sleep
-      include Idle
-      include Orbit
-
-      attr_reader :device, :serial_bus
-
-      def cpu
-        settle!
-        @cpu
-      end
-
-      def bus
-        settle!
-        @bus
-      end
-
-      def mechanism
-        settle!
-        @mechanism
-      end
-
-      def cycles
-        settle!
-        @cycles
-      end
-
-      def ram = bus.ram
-
-      def host_clock_hz=(clock_hz)
-        settle!
-        @host_clock_hz = clock_hz
-      end
-
-      # Plugs the drive into a serial bus, leaving the one it was on. A drive
-      # starts out on a bus of its own, with nothing else on it.
-      def connect(serial_bus)
-        settle!
-        @serial_bus&.detach(self)
-        @serial_bus = serial_bus
-        @serial_port.bus = serial_bus
-        serial_bus.attach(self)
-        hear_atn
-      end
-
-      # Puts a Disk in the drive (Disk.from_d64 makes one from an image).
-      # Nil takes the disk out.
-      def insert(disk)
-        settle!
-        @mechanism.insert(disk)
-      end
-
-      def disk = mechanism.disk
-
-      # Whether the LED is lit. Reading it leaves the drive asleep: the LED
-      # is the same at the end of every pass the drive sleeps through.
-      def led_on? = @mechanism.led_on?
-
-      # Stores what the head wrote since the motor last stopped in the
-      # disk's image, as the motor stopping does.
-      def flush
-        settle!
-        @mechanism.flush
-      end
-
-      # Runs the drive cycles that fall in one host cycle: none, one or two.
-      # The host has run this cycle already, and the drive sees what it did
-      # from the next one on (see SerialPort). Asleep, the drive owes the
-      # cycles instead, until ATN moves or its counters are due (see Idle).
-      # It looks at ATN only after the machine pushed its lines into the bus
-      # (see host_written!).
-      def host_cycle!
-        if @asleep
-          return if (@slept += 1) != @wake_at && @host_still
-
-          return doze
-        end
-
-        phase = @phase + @clock_hz
-        while phase >= @host_clock_hz
-          @asleep ? @owed += 1 : run_cycle
-          phase -= @host_clock_hz
-        end
-        @phase = phase
-        settle! if @serial_port.atn_moved?
-        @serial_port.latch_host
-        plan_wake if @asleep
-      end
-
-      # The machine pushed its lines into the bus, so ATN may have moved.
-      def host_written!
-        @host_still = false
-      end
-
-      # The host moved its fast serial pins, which a 1541 has none to hear.
-      def fast_lines_moved = nil
-
-      # Runs one drive cycle, catching up first on any the drive owes (see
-      # step).
-      def cycle!
-        settle!
-        step
-      end
-
-      def inspect
-        "#<#{self.class.name} cycles=#{cycles} cpu=(#{cpu.inspect})>"
-      end
-
-      private
-
-      # A drive cycle from host_cycle!, which may find the idle loop.
-      def run_cycle
-        step
-        idle_loop_reached if @cpu.program_counter == @idle_loop && @idle_skip
-      end
-    end
-  end
-end

data/lib/badline/drive/fast_serial.rb

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  module Drive
-    # Fast serial on a drive with a CIA, the 1571's 6526 or the 1581's
-    # 8520: through buffers a port line turns round, the CIA's CNT drives
-    # SRQ and its SP drives DATA, or it hears them. The drive pushes its
-    # pins into the bus as they move, and hears the host's as the host
-    # pushes them, pin by pin, so each byte goes through both shift
-    # registers bit by bit. The CIA takes no part in a pass of the idle
-    # loop, and any access to it, or the host moving its fast serial pins,
-    # wakes the drive.
-    #
-    # A model includes it beside Core, and calls turn_fast_serial when its
-    # direction line moves and drive_fast_serial each cycle the buffers
-    # face out. Its serial_output carries @fast_output above its port.
-    module FastSerial
-      # Whether the buffers face out, the drive's CIA driving DATA and SRQ.
-      attr_reader :fast_serial_out
-
-      # The host moved its fast serial pins: the CIA hears SRQ on CNT and
-      # DATA on SP while the buffers face in.
-      def fast_lines_moved
-        settle!
-        hear_fast_serial unless @fast_serial_out
-      end
-
-      private
-
-      def init_fast_serial
-        @fast_serial_out = false
-        @fast_output = 0
-      end
-
-      # The buffers turned round: outwards the CIA's pins drive the lines,
-      # and inwards they let go and hear them.
-      def turn_fast_serial(out)
-        @fast_serial_out = out
-        return unless @serial_bus
-
-        push_fast_output(out ? fast_pins : 0)
-        hear_fast_serial unless out
-      end
-
-      def drive_fast_serial
-        low = fast_pins
-        push_fast_output(low) if low != @fast_output
-      end
-
-      # The lines the CIA's CNT and SP pull while its serial port drives
-      # them.
-      def fast_pins
-        serial = @cia.serial
-        return 0 unless serial.output?
-
-        low = serial.cnt ? 0 : IECBus::DRIVE_FAST_SRQ
-        serial.sp_out ? low : low | IECBus::DRIVE_FAST_DATA
-      end
-
-      def push_fast_output(low)
-        @fast_output = low
-        @serial_bus&.drives_fast_moved!
-      end
-
-      def hear_fast_serial
-        low = @serial_bus.low_lines
-        serial = @cia.serial
-        serial.cnt_in = low.nobits?(IECBus::SRQ)
-        serial.sp_in = low.nobits?(IECBus::DATA)
-      end
-    end
-  end
-end

data/lib/badline/drive/idle.rb

@@ -1,125 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  module Drive
-    # Skipping the drive's cycles while the DOS idles, exactly.
-    #
-    # With nothing to do, the DOS goes round its idle loop from the
-    # model's @idle_loop ($EBFF in the 1541, 446 cycles a pass), until VIA
-    # 2's timer 1 interrupts it every 14,850 cycles for the job loop, or
-    # ATN interrupts it through VIA 1's CA1. A pass writes RAM and VIA 2's
-    # port B, but puts back what it found, so the drive comes round to the
-    # loop's start as it left it. Only the timers' counters and the cycle
-    # counts move.
-    #
-    # Each time the CPU comes to the loop's start, the drive records the
-    # pass that follows. At the next it checks that the pass
-    #
-    # - left the CPU, both VIAs but for their counters, the bus's last
-    #   byte, the SO pin, the mechanism (Mechanism#idle_state) and what
-    #   the ports read from it, and every byte of RAM it read or wrote as
-    #   it found them (Bus#watch!)
-    # - read nothing that changes from pass to pass: no counter, no shift
-    #   register, and not VIA 1's port B, which reads the serial bus
-    # - wrote nothing that reaches outside the drive: not VIA 1, whose port
-    #   B drives the serial bus, and not the motor on
-    # - ran while no counter could set a flag (VIA#quiet_cycles), with the
-    #   motor off, no interrupt pulled and no trap on the CPU.
-    #
-    # Such a pass runs the same way again from where it ended, for as
-    # long as ATN holds still and no counter sets a flag, so the drive
-    # sleeps: host_cycle! only counts the host cycles that go by (see
-    # Sleep). It wakes
-    # when ATN moves, when a counter is due to set a flag, or when something
-    # outside reads or changes the drive (the readers in Core call
-    # settle!). Waking counts off the whole passes it owes in bulk,
-    # moving the counters on, and runs the rest cycle by cycle.
-    #
-    # The loop reads neither CLK nor DATA, so the drive sleeps through them
-    # moving and takes the C64's lines as they stand once it wakes. Its
-    # own lines hold still while it sleeps, so the C64 reads them without
-    # waking it (serial_output).
-    #
-    # A pass starts at the loop's start, where the CPU always comes from
-    # the loop's last instruction, a JMP, so what that leaves in the CPU's
-    # working registers is the same each time round.
-    #
-    # The timer's interrupts come round too, and once they do, the drive
-    # sleeps on through them (see Orbit).
-    module Idle
-      # Whether the drive may sleep through its idle loop. On by default,
-      # but for a drive whose CPU logs each instruction.
-      attr_reader :idle_skip
-
-      def idle_skip=(on)
-        settle!
-        @idle_skip = on
-      end
-
-      private
-
-      def init_idle(debug)
-        @idle_skip = !debug
-        @recording = false
-        @pass_cycles = 0
-        @pass_instructions = 0
-        init_sleep
-        init_orbits
-      end
-
-      # The CPU is at the loop's start. At an instruction boundary, the
-      # drive sleeps if the pass it recorded can repeat, and otherwise
-      # records the next.
-      def idle_loop_reached
-        return unless @cpu.boundary?
-
-        if @recording
-          stop_recording
-          return fall_asleep if repeatable_pass? && room_for_pass?
-        end
-        start_recording
-      end
-
-      def start_recording
-        return if busy_for_pass? || @cpu.trapped?
-
-        @recording = true
-        @record_state = idle_state
-        @record_cycles = @cycles
-        @record_instructions = @cpu.instructions
-        @record_quiet = quiet_cycles
-        @bus.watch!
-      end
-
-      def stop_recording
-        @recording = false
-        @bus.unwatch!
-      end
-
-      # Whether the pass just recorded can repeat.
-      def repeatable_pass?
-        !@bus.volatile && @cycles - @record_cycles <= @record_quiet && idle_state == @record_state &&
-          ram_as_found?
-      end
-
-      # Whether the counters leave room for a whole pass.
-      def room_for_pass? = quiet_cycles >= @cycles - @record_cycles
-
-      # Sleeps through the pass just recorded, over and over.
-      def fall_asleep
-        @pass_cycles = @cycles - @record_cycles
-        @pass_instructions = @cpu.instructions - @record_instructions
-        @asleep = true
-        @host_still = false
-        @owed = 0
-        @budget = quiet_cycles
-        anchor
-      end
-
-      def ram_as_found?
-        ram = @bus.ram
-        @bus.touched.all? { |addr, value| ram.peek(addr) == value }
-      end
-    end
-  end
-end

data/lib/badline/drive/idle_cpu.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  module Drive
-    # What Idle needs of a drive's 6502, which includes it beside
-    # CPU::Core.
-    module IdleCPU
-      # Everything the CPU holds but its cycle and instruction counts: the
-      # registers, the interrupt lines and pipeline, and what the last
-      # instruction left in its working registers. Drive::Idle compares
-      # it at two instruction boundaries.
-      def idle_state
-        [@program_counter, @stack_pointer, @a, @x, @y, @status.value,
-         @irq, @nmi, @irq_sample, @irq_pending, @nmi_sample, @nmi_pending, @skip_poll,
-         @boundary_irq, @boundary_nmi, @so_high, @interrupt, @brk, @pending_write, @stalled_at, @traps,
-         @operation, @optional_dummy, @boundary_crossed, @branch_taken,
-         @address, @pointer, @dummy_address, @value, @rmw_result]
-      end
-
-      # Counts +cycles+ cycles and +instructions+ instructions that ran
-      # without changing anything idle_state holds.
-      def fast_forward(cycles, instructions)
-        @cycles += cycles
-        @instructions += instructions
-      end
-    end
-  end
-end