badline 0.4.2 → 0.5.1

data/lib/badline/reu.rb

@@ -0,0 +1,276 @@
+# frozen_string_literal: true
+
+require "badline/reu/ram"
+require "badline/reu/dma"
+require "badline/reu/trigger"
+
+module Badline
+  # A RAM Expansion Unit: the Commodore 1700 (128K), 1764 (256K) and 1750
+  # (512K), and the bigger units built around the same 8726 RAM Expansion
+  # Controller (REC), such as the CMD 1750XL, up to 16M.
+  #
+  # The REC's eleven registers sit in I/O 2 from $DF00, repeated every 32
+  # bytes up to $DFFF, as the 1764 and 1750 manuals map them. It moves
+  # bytes between the C64 and its RAM by DMA, one bus cycle each, with the
+  # CPU held off the bus. A command with the execute bit set starts a
+  # transfer, or with bit 4 clear arms the REC to start one on the next
+  # write to $FF00, so a program can bank the ROMs out first. A transfer
+  # waits for the CPU's next read cycle with BA high, and Computer then
+  # clocks it through #dma_cycle! until it hands the bus back.
+  class REU
+    SIZES_KB = [128, 256, 512, 1024, 2048, 4096, 8192, 16_384].freeze
+
+    # The registers, by offset.
+    STATUS = 0x00
+    COMMAND = 0x01
+    C64_LOW = 0x02
+    C64_HIGH = 0x03
+    EXPANSION_LOW = 0x04
+    EXPANSION_HIGH = 0x05
+    EXPANSION_BANK = 0x06
+    LENGTH_LOW = 0x07
+    LENGTH_HIGH = 0x08
+    INTERRUPT_MASK = 0x09
+    ADDRESS_CONTROL = 0x0a
+
+    # Status: an interrupt is pending, the block ended, a verify found a
+    # difference (the manual's fault bit), and the unit is built from 256K
+    # chips, which only the 1700 isn't. Reading the status clears the top
+    # three.
+    INTERRUPT_PENDING = 0x80
+    END_OF_BLOCK = 0x40
+    FAULT = 0x20
+    CHIPS_256K = 0x10
+
+    # Command: execute, reload the registers after the transfer, don't wait
+    # for $FF00, and the transfer type in the bottom two bits.
+    EXECUTE = 0x80
+    AUTOLOAD = 0x20
+    NO_FF00_TRIGGER = 0x10
+    TRANSFER_TYPE = 0x03
+
+    # Interrupt mask: interrupts on at all, then on the end of a block and
+    # on a fault. The low five bits aren't there and read as 1.
+    INTERRUPTS_ON = 0x80
+    INTERRUPT_ON_END = 0x40
+    INTERRUPT_ON_FAULT = 0x20
+
+    # Address control: hold the C64 address or the expansion address where
+    # it is. The low six bits aren't there and read as 1.
+    FIX_C64 = 0x80
+    FIX_EXPANSION = 0x40
+
+    # The REC's bank register has three bits, and the other five read as
+    # 1. A unit past 512K latches all eight onto its own address lines.
+    BANK_STUCK = 0xf8
+
+    attr_reader :trigger
+
+    # bus is the bus the REC reaches C64 memory through, and vic the VIC,
+    # whose phi1 fetch is what a register read finds on the bus during a
+    # transfer.
+    def initialize(size_kb, bus:, vic:)
+      raise ArgumentError, "No #{size_kb}K REU. Pick one of #{SIZES_KB.join(', ')}." unless SIZES_KB.include?(size_kb)
+
+      # The 1700's REC counts 17 address bits, the others' 19.
+      span = size_kb == 128 ? 0x20000 : 0x80000
+      size = size_kb * 1024
+      @address_mask = [size, span].max - 1
+      @bank_bits = size > span ? 0xff : 0x07
+      @chips = size_kb == 128 ? 0 : CHIPS_256K
+      @ram = RAM.new(size, span)
+      @dma = DMA.new(@ram, span, bus)
+      @trigger = Trigger.new(self)
+      @vic = vic
+      @on_irq_change = nil
+      @on_dma = nil
+      @irq = false
+      reset!
+    end
+
+    def on_irq_change(&block)
+      @on_irq_change = block
+    end
+
+    # Called when the REC asks for the bus.
+    def on_dma(&block)
+      @on_dma = block
+    end
+
+    def irq? = @irq
+
+    # From the moment the REC asks for the bus until it hands it back.
+    def dma? = @requested || @running
+
+    # Whether the REC held the bus on the last cycle clocked. The CPU keeps
+    # it while the REC waits to start, and has it back from the cycle the
+    # REC lets go.
+    def holds_bus? = @running
+
+    def reset!
+      @status = @chips
+      @command = NO_FF00_TRIGGER
+      @c64 = @c64_start = 0
+      @expansion = @expansion_start = 0
+      @bank = @bank_start = 0
+      @length = @length_start = 0xffff
+      @interrupt_mask = 0x1f
+      @address_control = 0x3f
+      @armed = @requested = @running = false
+      interrupt(false)
+    end
+
+    def peek(addr)
+      return @vic.phi1_data if @running
+
+      register = addr & 0x1f
+      value = register_value(register)
+      read_status if register == STATUS
+      value
+    end
+
+    def poke(addr, value)
+      return if @running
+
+      register = addr & 0x1f
+      case register
+      when COMMAND then write_command(value)
+      when C64_LOW, C64_HIGH then @c64 = @c64_start = with_byte(@c64_start, value, register == C64_HIGH)
+      when EXPANSION_LOW, EXPANSION_HIGH
+        @expansion = @expansion_start = with_byte(@expansion_start, value, register == EXPANSION_HIGH)
+      when EXPANSION_BANK then @bank = @bank_start = value & @bank_bits
+      when LENGTH_LOW, LENGTH_HIGH
+        @length = @length_start = with_byte(@length_start, value, register == LENGTH_HIGH)
+      when INTERRUPT_MASK then write_interrupt_mask(value)
+      when ADDRESS_CONTROL then @address_control = value | 0x3f
+      end
+    end
+
+    # A write to $FF00 starts the transfer the command register armed.
+    def ff00_written
+      return unless @armed
+
+      @armed = false
+      request_bus
+    end
+
+    # Clocks the REC for a cycle, given the VIC's BA line and whether the
+    # CPU writes on it. A requested transfer starts on the first cycle the
+    # CPU reads with BA high.
+    def dma_cycle!(ba_low, cpu_writing)
+      if @requested
+        return if cpu_writing || ba_low
+
+        start_transfer
+      end
+      @dma.cycle!(ba_low)
+      end_transfer unless @dma.holds_bus?
+    end
+
+    # The REU's RAM, at an address as the REC's registers give it.
+    def ram_peek(addr) = @ram.peek(addr)
+
+    def ram_poke(addr, value) = @ram.poke(addr, value)
+
+    private
+
+    def register_value(register)
+      case register
+      when STATUS then @status
+      when COMMAND then @command
+      when C64_LOW then @c64 & 0xff
+      when C64_HIGH then @c64 >> 8
+      when EXPANSION_LOW then @expansion & 0xff
+      when EXPANSION_HIGH then @expansion >> 8
+      when EXPANSION_BANK then @bank | BANK_STUCK
+      when LENGTH_LOW then @length & 0xff
+      when LENGTH_HIGH then @length >> 8
+      when INTERRUPT_MASK then @interrupt_mask
+      when ADDRESS_CONTROL then @address_control
+      else 0xff
+      end
+    end
+
+    def read_status
+      @status &= CHIPS_256K
+      interrupt(false)
+    end
+
+    # Writing either byte of an address or the length sets the value the
+    # transfer starts from, and puts the counter back to it.
+    def with_byte(word, value, high)
+      high ? (word & 0x00ff) | (value << 8) : (word & 0xff00) | value
+    end
+
+    def write_command(value)
+      @command = value
+      return if value.nobits?(EXECUTE)
+
+      @armed = value.nobits?(NO_FF00_TRIGGER)
+      request_bus unless @armed
+    end
+
+    # An interrupt enabled over a block that already ended, or a fault
+    # already found, fires at once.
+    def write_interrupt_mask(value)
+      @interrupt_mask = value | 0x1f
+      interrupt_on(@status)
+    end
+
+    def interrupt_on(events)
+      return unless @interrupt_mask.anybits?(INTERRUPTS_ON)
+      return unless (events.anybits?(END_OF_BLOCK) && @interrupt_mask.anybits?(INTERRUPT_ON_END)) ||
+                    (events.anybits?(FAULT) && @interrupt_mask.anybits?(INTERRUPT_ON_FAULT))
+
+      @status |= INTERRUPT_PENDING
+      interrupt(true)
+    end
+
+    def interrupt(level)
+      return if @irq == level
+
+      @irq = level
+      @on_irq_change&.call(level)
+    end
+
+    def request_bus
+      @requested = true
+      @on_dma&.call
+    end
+
+    def start_transfer
+      @requested = false
+      @running = true
+      @dma.start(@command & TRANSFER_TYPE, @c64, @expansion | (@bank << 16), @length, @address_control)
+    end
+
+    # The execute bit drops and the $FF00 trigger turns off. With autoload
+    # the addresses and the length go back to where the transfer started,
+    # and otherwise they stay where it stopped.
+    def end_transfer
+      @running = false
+      @command = (@command & ~EXECUTE & 0xff) | NO_FF00_TRIGGER
+      events = @dma.events
+      @status |= events
+      @command.anybits?(AUTOLOAD) ? reload : keep_counters
+      interrupt_on(events)
+    end
+
+    def reload
+      @c64 = @c64_start
+      @expansion = @expansion_start
+      @bank = @bank_start
+      @length = @length_start
+    end
+
+    def keep_counters
+      @c64 = @dma.c64 if @address_control.nobits?(FIX_C64)
+      @length = @dma.length & 0xffff
+      return if @address_control.anybits?(FIX_EXPANSION)
+
+      address = @dma.expansion & @address_mask
+      @expansion = address & 0xffff
+      @bank = (address >> 16) & 0xff
+    end
+  end
+end

data/lib/badline/roms/README

@@ -16,3 +16,13 @@ the C128's C64 mode.
 character.rom
 -------------
 The character generator ROM.
+
+dos1541.rom
+-----------
+The 1541 disk drive's DOS 2.6, 16 KB for $C000-$FFFF: 325302-01
+($C000-$DFFF) followed by 901229-05 ($E000-$FFFF). Drive1541 loads it.
+
+Both halves downloaded from
+https://www.zimmers.net/anonftp/pub/cbm/firmware/drives/new/1541/
+(1541-c000.325302-01.bin and 1541-e000.901229-05.bin) and concatenated.
+SHA-1 ab16f56989b27d89babe5f89c5a8cb3da71a82f0.

data/lib/badline/sdl/functions.rb

@@ -42,6 +42,7 @@ module Badline
     RenderSetLogicalSize = function("SDL_RenderSetLogicalSize", [POINTER, INT, INT], INT)
     SetRenderDrawColor = function("SDL_SetRenderDrawColor", [POINTER, UINT8, UINT8, UINT8, UINT8], INT)
     RenderClear = function("SDL_RenderClear", [POINTER], INT)
+    RenderFillRect = function("SDL_RenderFillRect", [POINTER, POINTER], INT)
     RenderCopy = function("SDL_RenderCopy", [POINTER, POINTER, POINTER, POINTER], INT)
     RenderPresent = function("SDL_RenderPresent", [POINTER], VOID)
     CreateRGBSurfaceFrom = function("SDL_CreateRGBSurfaceFrom",

data/lib/badline/storage/d64_image.rb

@@ -7,10 +7,28 @@ module Badline
       # (174848 bytes without one), 40 tracks (196608) and 42 tracks (205312)
       ERROR_TABLES = { 175_531 => 683, 197_376 => 768, 206_114 => 802 }.freeze
 
+      # The tracks the image holds: 35, 40 or 42.
+      def track_count
+        blocks = @bytes.length / SECTOR_SIZE
+        count = 0
+        count += 1 while count < 42 && track_offset(count + 2) <= blocks
+        count
+      end
+
+      def sectors_in(track)
+        case track
+        when 1..17 then 21
+        when 18..24 then 19
+        when 25..30 then 18
+        else 17
+        end
+      end
+
       private
 
       def error_tables = ERROR_TABLES
 
+      def header_name = 0x90
       def directory_track = 18
       def directory_sector = 1
       def directory_interleave = 3
@@ -23,15 +41,6 @@ module Badline
       def bam_tracks = 1..35
       def bam_count(track) = [18, 0, 4 * track]
       def bam_bitmap(track) = [18, 0, (4 * track) + 1]
-
-      def sectors_in(track)
-        case track
-        when 1..17 then 21
-        when 18..24 then 19
-        when 25..30 then 18
-        else 17
-        end
-      end
     end
   end
 end

data/lib/badline/storage/d81_image.rb

@@ -9,6 +9,7 @@ module Badline
 
       def error_tables = ERROR_TABLES
 
+      def header_name = 0x04
       def directory_track = 40
       def directory_sector = 3
       def directory_interleave = 1

data/lib/badline/storage/disk_image/catalog.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Badline
+  module Storage
+    class DiskImage
+      # The directory as LOAD"$" lists it: the disk name and ID from the
+      # header block, every entry with a type, and the free blocks the BAM
+      # counts outside the directory track.
+      module Catalog
+        HEADER_ID = 18
+        ID_LENGTH = 5
+        TYPE_MASK = 0x07
+
+        def directory
+          header = sector_at(*header_block)
+          Listing.new(name: header[header_name, DiskImage::Directory::NAME_LENGTH],
+                      id: header[header_name + HEADER_ID, ID_LENGTH],
+                      entries: catalog_entries,
+                      blocks_free:)
+        end
+
+        private
+
+        # A slot whose type byte is zero is empty or scratched.
+        def catalog_entries
+          list = []
+          each_sector(directory_track, directory_sector) do |data|
+            (0...ENTRIES_PER_SECTOR).each do |i|
+              entry = data[i * ENTRY_SIZE, ENTRY_SIZE]
+              list << catalog_entry(entry) unless entry[2].zero?
+            end
+          end
+          list
+        end
+
+        def catalog_entry(entry)
+          Listing::Entry.new(name: entry[5, DiskImage::Directory::NAME_LENGTH],
+                             type: entry[2] & TYPE_MASK,
+                             blocks: entry[30] | (entry[31] << 8),
+                             closed: entry[2].anybits?(DiskImage::Directory::CLOSED),
+                             locked: entry[2].anybits?(0x40))
+        end
+
+        def blocks_free
+          (bam_tracks.to_a - reserved_tracks).sum do |track|
+            block?(*bam_count(track).first(2)) ? @bytes[count_offset(track)] : 0
+          end
+        end
+      end
+    end
+  end
+end

data/lib/badline/storage/disk_image/writing.rb

@@ -57,6 +57,22 @@ module Badline
           update_image { put_sector(track, sector, data) } if block?(track, sector)
         end
 
+        # Stores blocks as a true drive read them back off its disk, in one
+        # write to the host file. Each is [track, sector, data, error]: nil
+        # data leaves the block's bytes as they were, and the error, the
+        # DOS error a read of it raises or nil, goes into the error table
+        # when the image has one.
+        def store_blocks(blocks)
+          update_image do
+            blocks.each do |track, sector, data, error|
+              next unless block?(track, sector)
+
+              put_sector(track, sector, data) if data
+              @errors[track_offset(track) + sector] = error ? DOS_ERRORS.key(error) : 1 if @errors
+            end
+          end
+        end
+
         # Marks a block in use, as B-A does.
         def allocate_block(track, sector) = update_image { mark(track, sector, false) }
 

data/lib/badline/storage/disk_image.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "badline/storage/disk_image/bam"
+require "badline/storage/disk_image/catalog"
 require "badline/storage/disk_image/directory"
 require "badline/storage/disk_image/writing"
 
@@ -12,6 +13,7 @@ module Badline
     # written.
     class DiskImage
       include Bam
+      include Catalog
       include Directory
       include Writing
 

data/lib/badline/storage/g64_image.rb

@@ -0,0 +1,222 @@
+# frozen_string_literal: true
+
+module Badline
+  module Storage
+    # A .g64 image: a 1541 disk's flux as raw GCR, track by track, for the
+    # true drive to read the way it reads a real disk, copy protection and
+    # all. It has no file system of its own, so only the true drive
+    # (Drive1541::Disk.from_g64) can use it.
+    #
+    # The header is the signature "GCR-1541", a version byte ($00), the
+    # number of half tracks the tables cover (84, tracks 1 to 42.5) and
+    # the longest track a block may hold, a little-endian word. Two tables
+    # of little-endian longs follow, one entry per half track from track
+    # 1: the file offset of each half track's block, 0 for one without
+    # data, and its speed zone. A block is the track's length in bytes, a
+    # word, and then its bytes.
+    #
+    # A speed entry of 0 to 3 is the zone the whole track was written in.
+    # A larger one is the offset of a speed map, two bits a byte, four
+    # track bytes to a map byte, the first byte's in the top two bits, for
+    # a track whose zone changes along it. The drive passes each byte
+    # under the head at its own zone's rate (Drive1541::Track).
+    #
+    # The drive writes a track at one zone, so a track written back takes
+    # that zone as its speed entry. Writing it puts it in its own block,
+    # where it fits, and otherwise appends a block to the file for it, as
+    # for a half track that had no data. A track longer than the header's longest raises
+    # it, so the header stays true of every block. A half track beyond
+    # the tables stays on the disk alone. One opened with `read_only` is a
+    # write-protected disk, and the host file is never written.
+    #
+    # Opening an image checks that its header and tables are whole, and
+    # that every block and speed map lies past the tables and inside the
+    # file, and raises FormatError where one doesn't.
+    class G64Image
+      class FormatError < StandardError; end
+
+      SIGNATURE = "GCR-1541"
+      HEADER_SIZE = 12
+      HALF_TRACKS = 84
+      MAX_TRACK_SIZE = 7928
+
+      # A new image of +tracks+, {entry => [bytes, zone]} with entry 0 for
+      # track 1 and 1 for track 1.5, laid out as VICE lays one out: every
+      # block as long as the longest track.
+      def self.create(path, tracks, half_tracks: HALF_TRACKS)
+        max = [MAX_TRACK_SIZE, *tracks.values.map { |bytes, _| bytes.length }].max
+        offsets = Array.new(half_tracks, 0)
+        zones = Array.new(half_tracks, 0)
+        blocks = +"".b
+        position = HEADER_SIZE + (half_tracks * 8)
+        tracks.keys.sort.each do |entry|
+          bytes, zones[entry] = tracks[entry]
+          offsets[entry] = position + blocks.bytesize
+          blocks << block(bytes, max)
+        end
+        header = SIGNATURE.b + [0, half_tracks, max].pack("CCv")
+        File.binwrite(path, header + offsets.pack("V*") + zones.pack("V*") + blocks)
+        new(path)
+      end
+
+      def self.block(bytes, size)
+        [bytes.length].pack("v") + bytes.pack("C*").ljust(size, "\x00".b)
+      end
+
+      attr_reader :half_tracks, :max_track_size
+
+      def initialize(path, read_only: false)
+        @path = path
+        @read_only = read_only
+        @data = File.binread(path)
+        parse
+      end
+
+      # Whether the image was opened write-protected.
+      def read_only? = @read_only
+
+      # Whether the host file takes writes.
+      def writable? = !read_only? && File.writable?(@path)
+
+      # The track at table entry +entry+ (0 for track 1) as [bytes, zone],
+      # or nil where it has no data. A speed-mapped track's zone is the one
+      # most of its bytes were written in.
+      def track(entry)
+        offset = @offsets[entry].to_i
+        return if offset.zero?
+
+        length = block_length(offset)
+        return if length.zero?
+
+        speeds = mapped_speeds(entry, length)
+        [@data.byteslice(offset + 2, length).bytes, speeds ? majority(speeds) : @speeds[entry]]
+      end
+
+      # Each byte's zone of the track at table entry +entry+, where its
+      # speed map changes along it, and nil otherwise.
+      def speeds(entry)
+        offset = @offsets[entry].to_i
+        return if offset.zero?
+
+        speeds = mapped_speeds(entry, block_length(offset))
+        speeds unless speeds.nil? || speeds.uniq.one?
+      end
+
+      # Stores tracks the drive wrote, {entry => [bytes, zone]}, in one
+      # write to the host file. Each takes its zone as its speed entry.
+      def store_tracks(tracks)
+        raise WriteError, WriteError::WRITE_PROTECT_ON unless writable?
+
+        data = @data.dup
+        tracks.each do |entry, (bytes, zone)|
+          next unless entry < @half_tracks
+
+          store_track(data, entry, bytes, zone)
+        end
+        File.binwrite(@path, data)
+        @data = data
+        parse
+      rescue SystemCallError
+        parse
+        raise WriteError, WriteError::WRITE_PROTECT_ON
+      end
+
+      private
+
+      def parse
+        raise FormatError, "Missing G64 signature" unless @data.start_with?(SIGNATURE)
+        raise FormatError, "G64 header is cut short" if @data.bytesize < HEADER_SIZE
+
+        version, @half_tracks, @max_track_size = @data.byteslice(8, 4).unpack("CCv")
+        raise FormatError, "Unsupported G64 version #{version}" unless version.zero?
+
+        tables = @data.byteslice(HEADER_SIZE, @half_tracks * 8).to_s
+        raise FormatError, "G64 track tables are cut short" if tables.bytesize < @half_tracks * 8
+
+        @offsets = tables.byteslice(0, @half_tracks * 4).unpack("V*")
+        @speeds = tables.byteslice(@half_tracks * 4, @half_tracks * 4).unpack("V*")
+        @half_tracks.times { |entry| check_block(entry) }
+      end
+
+      def tables_end = HEADER_SIZE + (@half_tracks * 8)
+
+      def block_length(offset) = @data.byteslice(offset, 2).unpack1("v")
+
+      def check_block(entry)
+        offset = @offsets[entry]
+        return if offset.zero?
+
+        problem = misplaced(offset, 2) || misplaced(offset, 2 + block_length(offset))
+        raise FormatError, "G64 track entry #{entry} #{problem}" if problem
+
+        check_speed_map(entry, block_length(offset))
+      end
+
+      def check_speed_map(entry, length)
+        speed = @speeds[entry]
+        return if speed <= 3
+
+        problem = misplaced(speed, (length + 3) / 4)
+        raise FormatError, "G64 speed map of track entry #{entry} #{problem}" if problem
+      end
+
+      # What's wrong with +size+ bytes at +offset+, or nil where they lie
+      # past the tables and inside the file.
+      def misplaced(offset, size)
+        if offset < tables_end then "points into the header or its tables"
+        elsif offset + size > @data.bytesize then "runs past the end of the image"
+        end
+      end
+
+      # Each byte's zone from the track's speed map, or nil where its speed
+      # entry is a zone.
+      def mapped_speeds(entry, length)
+        speed = @speeds[entry]
+        return if speed <= 3
+
+        map = @data.byteslice(speed, (length + 3) / 4).to_s.bytes
+        Array.new(length) { |index| (map[index >> 2] >> (6 - ((index & 3) * 2))) & 3 }
+      end
+
+      # The zone most of the bytes were written in.
+      def majority(speeds)
+        counts = [0, 0, 0, 0]
+        speeds.each { |zone| counts[zone] += 1 }
+        counts.index(counts.max)
+      end
+
+      def store_track(data, entry, bytes, zone)
+        offset = @offsets[entry]
+        if offset.zero? || bytes.length > capacity(offset)
+          offset = data.bytesize
+          grow(data, bytes.length)
+          data << self.class.block(bytes, @max_track_size)
+        else
+          data[offset, bytes.length + 2] = [bytes.length].pack("v") + bytes.pack("C*")
+        end
+        set_entry(data, entry, offset, zone)
+      end
+
+      # The most bytes the block at +offset+ holds without running into
+      # the next block or speed map, or off the end of the file.
+      def capacity(offset)
+        ends = (@offsets + @speeds.select { |speed| speed > 3 }).select { |start| start > offset }
+        ends.push(@data.bytesize).min - offset - 2
+      end
+
+      def grow(data, length)
+        return if length <= @max_track_size
+
+        @max_track_size = length
+        data[10, 2] = [length].pack("v")
+      end
+
+      def set_entry(data, entry, offset, zone)
+        @offsets[entry] = offset
+        @speeds[entry] = zone
+        data[HEADER_SIZE + (entry * 4), 4] = [offset].pack("V")
+        data[HEADER_SIZE + ((@half_tracks + entry) * 4), 4] = [zone].pack("V")
+      end
+    end
+  end
+end