badline 0.1.0 → 0.2.1

data/lib/badline/kernal_trap/serial.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+module Badline
+  module KernalTrap
+    # PC traps on the KERNAL's serial bus primitives. Frames addressed to
+    # device 8 go to a virtual drive instead of out over the IEC lines, so
+    # OPEN/CHKIN/CHRIN reach a CBM DOS, and so do the block reads that
+    # loaders make through them. Other devices fall through to the ROM.
+    class Serial < Routine
+      ROUTINES = {
+        0xed09 => :talk,
+        0xed0c => :listen,
+        0xedb9 => :second,
+        0xedc7 => :tksa,
+        0xeddd => :ciout,
+        0xedef => :untalk,
+        0xedfe => :unlisten,
+        0xee13 => :acptr
+      }.freeze
+
+      # Frame type in the high nibble of the secondary address
+      OPEN = 0xf0
+      CLOSE = 0xe0
+
+      # ST bits at $90
+      DEVICE_NOT_PRESENT = 0x80
+      EOI = 0x40
+      READ_TIMEOUT = 0x02
+
+      NO_DATA = [0x0d, EOI | READ_TIMEOUT].freeze
+
+      def initialize(cpu:, bus:, drive:)
+        super(cpu:, bus:)
+        @drive = drive
+        @listening = false
+        @talking = false
+        @listen_channel = nil
+        @talk_channel = nil
+        @frame = OPEN
+        @buffer = []
+      end
+
+      def install
+        ROUTINES.each do |address, routine|
+          @cpu.install_trap(address) { call_routine(routine) if kernal? }
+        end
+        self
+      end
+
+      private
+
+      def call_routine(routine)
+        case routine
+        when :talk then talk
+        when :listen then listen
+        when :second then second
+        when :tksa then tksa
+        when :ciout then ciout
+        when :untalk then untalk
+        when :unlisten then unlisten
+        when :acptr then acptr
+        end
+      end
+
+      # Addressing the bus starts a new frame. The channel number arrives
+      # in the secondary address that follows.
+      def talk
+        @talk_channel = nil
+        @talking = @cpu.a == DEVICE
+        return_to_caller if @talking
+      end
+
+      def listen
+        @listen_channel = nil
+        @listening = @cpu.a == DEVICE
+        return_to_caller if @listening
+      end
+
+      def second
+        return unless @listening
+
+        @frame = @cpu.a & 0xf0
+        @listen_channel = @cpu.a & 0x0f
+        @buffer = []
+        return_to_caller
+      end
+
+      def tksa
+        return unless @talking
+
+        @talk_channel = @cpu.a & 0x0f
+        return_to_caller
+      end
+
+      def ciout
+        return unless @listening
+
+        @buffer << @cpu.a
+        update_status(DEVICE_NOT_PRESENT) unless accepted?
+        @cpu.status.carry = false
+        return_to_caller
+      end
+
+      # The drive acknowledges every byte of an open or close frame, but
+      # takes data only on a channel it has open. Otherwise nothing holds
+      # the data line when a byte starts, so the KERNAL finds no device.
+      def accepted?
+        [OPEN, CLOSE].include?(@frame) || @drive.listening?(@listen_channel)
+      end
+
+      def unlisten
+        return unless @listening
+
+        @listening = false
+        deliver_frame
+        release_bus
+      end
+
+      def untalk
+        return unless @talking
+
+        @talking = false
+        release_bus
+      end
+
+      # UNLSN and UNTLK end by releasing ATN, the clock and the data line on
+      # CIA 2's port A, and leave the port's last read in the accumulator.
+      def release_bus
+        @bus.poke(0xdd00, @bus.peek(0xdd00) & 0xc7)
+        @cpu.a = @bus.peek(0xdd00) & 0xdf
+        @cpu.status.negative = @cpu.a.anybits?(0x80)
+        @cpu.status.zero = @cpu.a.zero?
+        return_to_caller
+      end
+
+      def acptr
+        return unless @talking
+
+        byte, status = received
+        @cpu.a = byte
+        update_status(status)
+        @cpu.status.carry = false
+        return_to_caller
+      end
+
+      def deliver_frame
+        return unless @listen_channel
+
+        case @frame
+        when OPEN then @drive.open(@listen_channel, @buffer.pack("C*"))
+        when CLOSE then @drive.close(@listen_channel)
+        else @drive.write(@listen_channel, @buffer)
+        end
+        @buffer = []
+      end
+
+      def received
+        byte, eoi = @drive.read(@talk_channel)
+        return NO_DATA unless byte
+
+        [byte, eoi ? EOI : 0]
+      end
+
+      def update_status(bits)
+        return if bits.zero?
+
+        @bus.poke(0x90, @bus.peek(0x90) | bits)
+      end
+    end
+  end
+end

data/lib/badline/kernal_trap.rb

@@ -1,5 +1,9 @@
 # frozen_string_literal: true
 
+require "badline/kernal_trap/routine"
+require "badline/kernal_trap/channel"
+require "badline/kernal_trap/drive"
 require "badline/kernal_trap/file"
 require "badline/kernal_trap/load"
 require "badline/kernal_trap/save"
+require "badline/kernal_trap/serial"

data/lib/badline/keyboard.rb

@@ -1,6 +1,13 @@
 # frozen_string_literal: true
 
 module Badline
+  # The 8x8 key matrix spanning CIA 1's two ports: rows on port A, columns on
+  # port B.
+  #
+  # A pressed key shorts its row line to its column line, so whichever side is
+  # pulled low drags the other down with it. Scanning works in either
+  # direction, and chains of keys sharing a line propagate the pulldown -- the
+  # ghost keys real hardware reports.
   class Keyboard
     include IntegerHelper
 
@@ -8,9 +15,10 @@ module Badline
 
     def initialize
       @keys = []
+      @row_masks = nil
 
       @matrix = [
-        %i[delete return cursor_h f7 f1 f3 cursor_v],
+        %i[delete return cursor_h f7 f1 f3 f5 cursor_v],
         %i[3 w a 4 z s e lshift],
         %i[5 r d 6 c f t x],
         %i[7 y g 8 b h u v],
@@ -22,35 +30,51 @@ module Badline
     end
 
     def press(key)
-      @keys << key if valid_key?(key)
+      return unless valid_key?(key)
+
+      @keys << key
+      @row_masks = nil
     end
 
-    def read_a(_port_a, _port_b)
-      0xff
+    def release(key)
+      @keys.reject! { |k| k == key }
+      @row_masks = nil
     end
 
-    def read_b(port_a, _port_b)
-      return 0xff unless keys.any?
+    # Settles the row (port A) and column (port B) lines against each other
+    # until no key contact pulls a line low any more, and returns both.
+    def scan(rows, cols)
+      return [rows, cols] if keys.empty?
 
-      output = 0xff
+      loop do
+        settled_rows = rows
+        settled_cols = cols
 
-      matrix.each_with_index do |row, a|
-        next unless port_a[a].zero?
+        row_masks.each_with_index do |mask, row|
+          bit = 1 << row
+          next if mask.zero? || (rows.allbits?(bit) && cols.allbits?(mask))
 
-        row.each_with_index do |key, b|
-          output -= (1 << b) if keys.include?(key)
+          rows &= ~bit
+          cols &= ~mask
         end
-      end
 
-      output
+        return [rows, cols] if rows == settled_rows && cols == settled_cols
+      end
     end
 
-    def release(key)
-      @keys.reject! { |k| k == key }
-    end
+    def read_a(port_a, port_b) = scan(port_a, port_b).first
+
+    def read_b(port_a, port_b) = scan(port_a, port_b).last
 
     private
 
+    # Columns held down per row, as a bit mask of port B lines.
+    def row_masks
+      @row_masks ||= matrix.map do |row|
+        row.each_with_index.sum { |key, column| keys.include?(key) ? 1 << column : 0 }
+      end
+    end
+
     def valid_key?(key)
       matrix.flatten.include?(key)
     end

data/lib/badline/media.rb

@@ -3,37 +3,75 @@
 module Badline
   module Media
     AUTOSTART = %(lO"*",8,1\rrun\r)
+    TAPE_AUTOSTART = %(lO\rrun\r)
     BASIC_START = 0x0801
 
-    DISK_TYPES = {
+    MOUNT_TYPES = {
       ".d64" => Storage::D64Image,
       ".d71" => Storage::D71Image,
-      ".d81" => Storage::D81Image
+      ".d81" => Storage::D81Image,
+      ".t64" => Storage::T64
     }.freeze
 
     class << self
-      def attach(computer, path, autostart: true)
+      # `cartridge` sets the jumpers of a .crt cartridge that has them, such
+      # as `{ flash_jumper: true }` for the Retro Replay's flash mode.
+      def attach(computer, path, autostart: true, song: nil, cartridge: {})
         if File.directory?(path)
           computer.mount(Storage::HostDirectory.new(path))
           "Mounted #{path} as device 8"
         elsif File.extname(path).downcase == ".crt"
-          attach_cartridge(computer, path)
-        elsif (image = DISK_TYPES[File.extname(path).downcase])
-          attach_disk(computer, image.new(path), path, autostart:)
+          attach_cartridge(computer, path, cartridge)
+        elsif File.extname(path).downcase == ".sid"
+          attach_sid(computer, path, autostart:, song:)
+        elsif File.extname(path).downcase == ".tap"
+          attach_tape(computer, path, autostart:)
+        elsif (storage = MOUNT_TYPES[File.extname(path).downcase])
+          attach_storage(computer, storage.new(path), path, autostart:)
         else
           attach_prg(computer, path, autostart:)
         end
       end
 
+      # The SID a machine for `path` should be built with. A .sid tune names
+      # its own; everything else gets the 6581.
+      def sid_model(path)
+        return :mos6581 unless path && File.extname(path).downcase == ".sid"
+
+        Storage::SIDFile.new(path).sid_model
+      end
+
       private
 
-      def attach_cartridge(computer, path)
-        computer.attach_cartridge(Cartridge.from_file(path))
+      def attach_cartridge(computer, path, options)
+        computer.attach_cartridge(Cartridge.from_file(path, **options))
         "Attached cartridge #{path}"
       end
 
-      def attach_disk(computer, image, path, autostart:)
-        computer.mount(image)
+      def attach_sid(computer, path, autostart:, song:)
+        tune = Storage::SIDFile.new(path)
+        song = (song || tune.start_song).clamp(1, tune.songs)
+        computer.on_init { start_tune(computer, tune, autostart:, song:) }
+        title = tune.name.empty? ? path : tune.name
+        title += " (song #{song})" if tune.songs > 1
+        autostart ? "Playing #{title}" : "Loaded #{title}"
+      end
+
+      def start_tune(computer, tune, autostart:, song:)
+        computer.ram.write(tune.load_address, tune.data)
+        computer.ram.write(tune.driver_address, tune.driver(song:))
+        computer.type_text("sys#{tune.driver_address}\r") if autostart
+      end
+
+      def attach_tape(computer, path, autostart:)
+        computer.datasette.insert(Storage::TAP.new(path))
+        computer.datasette.play!
+        computer.type_text(TAPE_AUTOSTART) if autostart
+        "Inserted #{path} in the datasette"
+      end
+
+      def attach_storage(computer, storage, path, autostart:)
+        computer.mount(storage)
         computer.type_text(AUTOSTART) if autostart
         "Mounted #{path} as device 8"
       end

data/lib/badline/memory.rb

@@ -26,6 +26,11 @@ module Badline
       Array(bytes).each_with_index { |b, i| poke(addr + i, b) }
     end
 
+    # Refills the whole memory as if newly built with `initial`
+    def clear!(initial = [])
+      @storage.replace(zero_fill(initial))
+    end
+
     private
 
     def blank_value

data/lib/badline/roms/eapi/LICENSE.md

@@ -0,0 +1,15 @@
+This software is provided 'as-is', without any express or implied
+warranty.  In no event will the authors be held liable for any damages
+arising from the use of this software.
+
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it
+freely, subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not
+   claim that you wrote the original software. If you use this software
+   in a product, an acknowledgment in the product documentation would be
+   appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be
+   misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.

data/lib/badline/roms/eapi/README

@@ -0,0 +1,41 @@
+EasyFlash EAPI for the Am29F040
+===============================
+
+eapi-am29f040-14 is the EasyFlash flash driver (EAPI) for the AMD Am29F040,
+version 1.4, by Thomas 'skoe' Giesel. It is third-party software, not part
+of badline, and is distributed under the zlib licence in LICENSE.md.
+
+It is the unaltered output of assembling the upstream source, a C64 PRG
+(a two-byte load address, $C000, then 768 bytes):
+
+  Source:   https://gitlab.com/easyflash/eapi
+  Revision: 1b4ea15d44974d18f6f82156b935f59d2f85596c
+  File:     eapi-am29f040.s (includes eapi_defs.s)
+  Built:    acme -l out/eapi-am29f040-14.labels -o out/eapi-am29f040-14 eapi-am29f040.s
+            (the repository's Makefile rule, with ACME 0.96.4)
+  SHA-256:  4c32d425d7b0a1f659e007bccad5c43603a93236974ef19743b2eefb812ab9ed
+
+The source file's notice:
+
+  (c) 2009-2010 Thomas 'skoe' Giesel
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+
+When an EasyFlash image carries an EAPI, as its "eapi" signature at $B800
+in bank 0 of ROMH shows, badline replaces those 768 bytes with this driver
+on attach, the way VICE does, so the image drives the flash chip badline
+emulates.

data/lib/badline/sid/decimator.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Badline
+  class SID
+    # Reduces the SID's one-sample-per-cycle stream to an audio rate by
+    # averaging each window. Point sampling would be cheaper, but the pulse
+    # and noise waveforms carry enough energy above the output Nyquist to
+    # alias audibly.
+    #
+    # A sample can stand for several cycles at once, when the DSP has run
+    # them as one step.
+    class Decimator
+      def initialize(clock_hz:, rate:)
+        @clock_hz = clock_hz
+        @rate = rate
+        @phase = 0
+        @sum = 0
+        @count = 0
+      end
+
+      # Cycles until the current window closes, counting the next one as 1.
+      def cycles_to_close = (@clock_hz - @phase + @rate - 1) / @rate
+
+      # Returns the averaged sample when these cycles close a window, and
+      # nil otherwise. They must not run past the window's end.
+      def push(sample, cycles = 1)
+        @sum += sample * cycles
+        @count += cycles
+        @phase += @rate * cycles
+        return unless @phase >= @clock_hz
+
+        @phase -= @clock_hz
+        average
+      end
+
+      private
+
+      def average
+        value = @sum.fdiv(@count).round
+        @sum = 0
+        @count = 0
+        value
+      end
+    end
+  end
+end