badline 0.12.1 → 0.13.0

data/lib/badline/c64/cartridge/geo_ram.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Badline
+  class C64
+    class Cartridge
+      # GEO-RAM: a RAM expansion on the expansion port, seen through a 256-byte
+      # window at $DE00-$DEFF. Two write-only registers pick the page the
+      # window shows: $DFFE selects one of the 64 pages of a 16K block, and
+      # $DFFF selects the block. As in VICE, the registers answer at every
+      # address from $DF80 up, even for $DFFE and odd for $DFFF, and the block
+      # number wraps at the number of blocks the RAM holds. Reads of I/O 2 are
+      # open bus. It leaves EXROM and GAME high, and RES clears both
+      # registers.
+      class GeoRAM < Cartridge
+        SIZES = [64, 128, 256, 512, 1024, 2048, 4096].freeze
+        BLOCK_SIZE = 0x4000
+        PAGE_MASK = 0x3f
+
+        attr_reader :size
+
+        # size is the RAM in kilobytes.
+        def initialize(size: 512)
+          raise ArgumentError, "Unsupported GEO-RAM size #{size}K" unless SIZES.include?(size)
+
+          @size = size
+          @block_mask = ((size * 1024) / BLOCK_SIZE) - 1
+          super(Storage::CRTFile::Image.new(hardware_type: nil, subtype: 0, exrom: 1, game: 1,
+                                            name: "GEO-RAM", chips: []))
+        end
+
+        def readable_io_pages
+          [0xde]
+        end
+
+        def peek(addr)
+          @ram_data[@window + (addr & 0xff)]
+        end
+
+        def poke(addr, value)
+          if addr <= 0xdeff
+            @ram_data[@window + (addr & 0xff)] = value
+          elsif addr >= 0xdf80
+            if addr.odd?
+              @block = value & @block_mask
+            else
+              @page = value & PAGE_MASK
+            end
+            @window = (@block * BLOCK_SIZE) + (@page * 0x100)
+          end
+        end
+
+        def reset
+          @block = @page = @window = 0
+        end
+
+        # A GEO-RAM is built from its size alone.
+        def save_setup(out)
+          out.int(GEO_RAM_SETUP).int(@size)
+        end
+
+        private
+
+        def save_mapper(out)
+          out.blob(@ram_data).int(@block).int(@page).int(@window)
+        end
+
+        def load_mapper(input)
+          input.blob_into(@ram_data)
+          @block = input.int
+          @page = input.int
+          @window = input.int
+        end
+
+        def install_chips(_chips)
+          @ram_data = Array.new(@size * 1024, 0)
+          reset
+        end
+      end
+    end
+  end
+end

data/lib/badline/c64/cartridge/kcs_power.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Badline
+  class C64
+    class Cartridge
+      # The KCS Power Cartridge: 16K of ROM, 128 bytes of RAM and a freeze
+      # button. It boots in 16K mode, and any access to I/O 1 sets the lines
+      # from address bit 1 and the direction:
+      #
+      #   read,  bit 1 clear  8K
+      #   read,  bit 1 set    off
+      #   write, bit 1 clear  16K
+      #   write, bit 1 set    Ultimax
+      #
+      # A read of I/O 1 returns the second last page of ROML. I/O 2 holds the
+      # RAM in its lower half, and the upper half reads the EXROM line in bit 7
+      # and GAME in bit 6, which the freezer checks to find the mode it
+      # interrupted. A freeze switches to Ultimax and lets go of NMI.
+      class KCSPower < Cartridge
+        include Freezer
+
+        IO1_ROM_PAGE = 0x1e00
+
+        def readable_io_pages
+          [0xde, 0xdf]
+        end
+
+        def peek(addr)
+          if addr < 0xdf00
+            select_mode(addr.anybits?(0x02) ? :off : :rom8k)
+            @roml.peek(IO1_ROM_PAGE | (addr & 0xff))
+          elsif addr.anybits?(0x80)
+            (@exrom << 7) | (@game << 6) | (open_bus(addr) & 0x3f)
+          else
+            @io_ram[addr & 0x7f]
+          end
+        end
+
+        def poke(addr, value)
+          if addr < 0xdf00
+            select_mode(addr.anybits?(0x02) ? :ultimax : :rom16k)
+          elsif addr.nobits?(0x80)
+            @io_ram[addr & 0x7f] = value
+          end
+        end
+
+        def reset
+          self.nmi = false
+          select_mode(:rom16k)
+        end
+
+        def freeze!
+          self.nmi = false
+          select_mode(:ultimax)
+        end
+
+        private
+
+        def save_mapper(out)
+          out.blob(@io_ram)
+        end
+
+        def load_mapper(input)
+          input.blob_into(@io_ram)
+        end
+
+        def install_chips(chips)
+          roml, romh = banks_from(chips)
+          @roml = roml.first || EMPTY_BANK
+          @romh = romh.first || EMPTY_BANK
+          @io_ram = Array.new(0x80, 0xff)
+          reset
+        end
+      end
+    end
+  end
+end

data/lib/badline/c64/cartridge/mach5.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Badline
+  class C64
+    class Cartridge
+      # 8K. Writing I/O 1 switches the ROM in, writing I/O 2 switches it out.
+      # Both I/O pages read the last 512 bytes of the ROM.
+      class Mach5 < Cartridge
+        def readable_io_pages
+          [0xde, 0xdf]
+        end
+
+        def peek(addr)
+          @roml.peek(addr)
+        end
+
+        def poke(addr, _value)
+          select_mode(addr < 0xdf00 ? :rom8k : :off)
+        end
+
+        def reset
+          select_mode(:rom8k)
+        end
+
+        private
+
+        def install_chips(chips)
+          @roml = banks_from(chips).first.compact.first || EMPTY_BANK
+          reset
+        end
+      end
+    end
+  end
+end

data/lib/badline/c64/cartridge/magic_desk.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Badline
+  class C64
+    class Cartridge
+      # Magic Desk: up to 128 8K banks. A write to I/O 1 selects the bank from
+      # bits 0-6, masked to the size of the ROM and at least four banks, and
+      # switches the ROM out with bit 7.
+      class MagicDesk < Cartridge
+        def poke(addr, value)
+          return if addr > 0xdeff
+
+          @exrom = value.anybits?(0x80) ? 1 : 0
+          @roml = bank(@banks, value & @bank_mask)
+          changed!
+        end
+
+        def reset
+          poke(0xde00, 0)
+        end
+
+        private
+
+        def install_chips(chips)
+          @banks = banks_from(chips).first
+          @bank_mask = (bank_mask(@banks) | 0x03) & 0x7f
+          reset
+        end
+      end
+    end
+  end
+end

data/lib/badline/c64/cartridge/ocean.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Badline
+  class C64
+    class Cartridge
+      # Ocean: up to 64 8K banks. A write to I/O 1 selects the bank from bits
+      # 0-5, masked to the size of the ROM.
+      class Ocean < Cartridge
+        def poke(addr, value)
+          return if addr > 0xdeff
+
+          select_bank(value & @bank_mask)
+          changed!
+        end
+
+        def reset
+          select_bank(0)
+          changed!
+        end
+
+        private
+
+        # In 16K mode the selected bank shows through ROMH as well.
+        def select_bank(number)
+          @roml = bank(@banks, number)
+          @romh = @roml if game.zero?
+        end
+
+        def install_chips(chips)
+          @banks = banks_from(chips).first
+          @bank_mask = bank_mask(@banks) & 0x3f
+          reset
+        end
+      end
+    end
+  end
+end

data/lib/badline/c64/cartridge/pagefox.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Badline
+  class C64
+    class Cartridge
+      # Pagefox: two 32K EPROMs and 32K of RAM, seen 16K at a time. A write to
+      # $DE80-$DEFF selects the half with bit 1 and the chip with bits 2-3
+      # (EPROM, EPROM, RAM, nothing), and switches the cartridge out with
+      # bit 4. Writes to the RAM land in the C64's RAM as well.
+      class Pagefox < Cartridge
+        RAM_CHIP = 2
+        EMPTY_CHIP = 3
+
+        def connect(ram:, open_bus:)
+          super
+          @ram_banks.each { |b| b.backing = ram }
+        end
+
+        def poke(addr, value)
+          return if addr < 0xde80 || addr > 0xdeff
+
+          select(value)
+          changed!
+        end
+
+        def reset
+          select(0)
+          changed!
+        end
+
+        private
+
+        def save_mapper(out)
+          super
+          @ram_banks.each { |ram| out.blob(ram.data) }
+        end
+
+        def load_mapper(input)
+          super
+          @ram_banks.each { |ram| input.blob_into(ram.data) }
+        end
+
+        def windows = [*@roml_banks, *@romh_banks, *@ram_banks, @open_bus || EMPTY_BANK, EMPTY_BANK]
+
+        def select(value)
+          half = (value >> 1) & 0x01
+          chip = (value >> 2) & 0x03
+          @roml, @romh = window(chip, half)
+          self.mode = value.anybits?(0x10) ? :off : :rom16k
+        end
+
+        def window(chip, half)
+          case chip
+          when RAM_CHIP then @ram_banks[half * 2, 2]
+          when EMPTY_CHIP then [@open_bus || EMPTY_BANK] * 2
+          else
+            number = (chip << 1) | half
+            [bank(@roml_banks, number), bank(@romh_banks, number)]
+          end
+        end
+
+        def install_chips(chips)
+          @roml_banks, @romh_banks = banks_from(chips)
+          @ram_banks = Array.new(4) { RAMBank.new }
+          reset
+        end
+      end
+    end
+  end
+end

data/lib/badline/c64/cartridge/retro_replay/saved_state.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Badline
+  class C64
+    class Cartridge
+      class RetroReplay < Cartridge
+        # A Retro Replay's registers, RAM and flash, for a snapshot.
+        module SavedState
+          private
+
+          def save_jumpers(out)
+            out.boolean(true).boolean(@flash_jumper).boolean(@bank_jumper)
+          end
+
+          def save_mapper(out)
+            [@active, @frozen, @phi1_ultimax, @ram_enabled, @ram_at_a000, @allow_bank, @no_freeze, @reu_mapping,
+             @write_once].each { |flag| out.boolean(flag) }
+            out.int(@bank).int(RetroReplay::CONTROL_MODES.index(@config))
+            @ram_data.each { |data| out.blob(data) }
+            @flash.save_state(out)
+          end
+
+          def load_mapper(input)
+            load_flags(input)
+            @bank = input.int
+            @config = RetroReplay::CONTROL_MODES.fetch(input.int)
+            @ram_data.each { |data| input.blob_into(data) }
+            @flash.load_state(input)
+            map_windows
+          end
+
+          def load_flags(input)
+            @active = input.boolean?
+            @frozen = input.boolean?
+            @phi1_ultimax = input.boolean?
+            @ram_enabled = input.boolean?
+            @ram_at_a000 = input.boolean?
+            @allow_bank = input.boolean?
+            @no_freeze = input.boolean?
+            @reu_mapping = input.boolean?
+            @write_once = input.boolean?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/badline/c64/cartridge/retro_replay.rb

@@ -0,0 +1,286 @@
+# frozen_string_literal: true
+
+require "badline/c64/cartridge/retro_replay/saved_state"
+
+module Badline
+  class C64
+    class Cartridge
+      # Retro Replay: an Am29F010 flash chip of two 64K halves, each eight 8K
+      # ROM banks, and four 8K RAM banks, with the Action Replay's register at
+      # $DE00 and an extended one at $DE01. The Nordic Replay (subtype 1) adds
+      # the Nordic Power configuration. The clock port isn't there.
+      #
+      # CRT banks 0-7 are the chip's upper half and banks 8-15 its lower half.
+      # The cartridge runs from the upper half, or from the lower one with the
+      # bank jumper set.
+      #
+      # $DE00 writes:
+      #   bit 0      pulls GAME low
+      #   bit 1      releases EXROM
+      #   bit 2      switches the registers off until the next freeze or reset
+      #   bits 3-4,7 bank
+      #   bit 5      RAM instead of ROM
+      #   bit 6      acknowledges a freeze: until then the cartridge stays in
+      #              Ultimax mode with nothing at ROML
+      #
+      # $DE01 writes the bank again, and once only AllowBank (bit 1), which
+      # banks the RAM in I/O as well, NoFreeze (bit 2) and the REU-compatible
+      # map (bit 6), which moves the I/O RAM from I/O 2 to I/O 1 above $DE01.
+      # $DE00 and $DE01 read back the bank, the write-once bits and the freeze
+      # button.
+      #
+      # The VIC sees Ultimax mode only from a freeze to the next $DE00 write.
+      #
+      # The RAM at ROML takes writes only in Ultimax mode, except on the Nordic
+      # Replay. With RAM and only EXROM released ($22) the Retro Replay maps
+      # nothing at ROML and keeps the RAM in I/O, and the Nordic Replay maps
+      # the ROM at ROML and the RAM at ROMH, as the Nordic Power does. Frozen
+      # in that configuration, the Nordic Replay maps the RAM at $A000.
+      #
+      # The flash jumper puts the cartridge in flash mode, which starts with
+      # the cartridge switched off ($02) and has no freeze. $DE00 selects 8K
+      # mode unless it switches the cartridge off, and writes to ROML reach
+      # the flash, and the C64's RAM underneath, or the RAM when selected.
+      # $DE01 isn't write-once and has no REU-compatible map, and with the
+      # bank jumper set its bit 5 clear selects the other half of the flash,
+      # until the next $DE00 write. $DE00 reads the flash jumper in bit 0 and
+      # the half in bit 5.
+      class RetroReplay < Cartridge
+        include Freezer
+        include SavedState
+
+        CONTROL_MODES = %i[rom8k rom16k off ultimax].freeze
+        IO1_PAGE = 0x1e00
+        IO2_PAGE = 0x1f00
+
+        attr_reader :flash
+
+        def self.from_jumpers(crt, input)
+          input.boolean?
+          new(crt, flash_jumper: input.boolean?, bank_jumper: input.boolean?)
+        end
+
+        def initialize(crt, flash_jumper: false, bank_jumper: false)
+          @nordic = crt.subtype == 1
+          @flash_jumper = flash_jumper
+          @bank_jumper = bank_jumper
+          super(crt)
+        end
+
+        def clock=(clock)
+          super
+          @flash.clock = clock
+        end
+
+        def connect(ram:, open_bus:)
+          super
+          @through.each { |b| b.backing = ram }
+          configure
+        end
+
+        def readable_io_pages
+          [0xde, 0xdf]
+        end
+
+        def peek(addr)
+          return open_bus(addr) unless @active
+
+          addr < 0xdf00 ? io1_peek(addr) : io2_peek(addr)
+        end
+
+        def poke(addr, value)
+          return unless @active
+
+          low = addr & 0xff
+          if addr >= 0xdf00
+            io_ram[IO2_PAGE | low] = value if io_ram_writable?(!@reu_mapping)
+          elsif low > 1
+            io_ram[IO1_PAGE | low] = value if io_ram_writable?(@reu_mapping)
+          else
+            low.zero? ? control(value) : extended_control(value)
+          end
+        end
+
+        def phi1_ultimax? = @phi1_ultimax
+
+        def ultimax_a000
+          @isolated[ram_view_bank] if @nordic && @ram_at_a000 && @frozen
+        end
+
+        # Reset leaves the write-once bits of $DE01 as they are.
+        def reset
+          @active = true
+          @frozen = false
+          self.nmi = false
+          control(@flash_jumper ? 0x02 : 0x00)
+        end
+
+        def freeze!
+          @active = @frozen = @phi1_ultimax = true
+          @ram_enabled = false
+          @bank = 0
+          @config = :ultimax
+          configure
+        end
+
+        private
+
+        def freeze_allowed? = !@no_freeze && !@flash_jumper
+
+        def status
+          ((@bank & 0x03) << 3) | ((@bank & 0x04) << 5) | ((@bank & 0x08) << 2) | (@flash_jumper ? 0x01 : 0) |
+            (@allow_bank ? 0x02 : 0) | (button_pressed? ? 0x04 : 0) | (@reu_mapping ? 0x40 : 0)
+        end
+
+        def io1_peek(addr)
+          return status if (addr & 0xff) < 2
+          return open_bus(addr) unless @reu_mapping && !@frozen
+
+          io_window(addr, IO1_PAGE)
+        end
+
+        def io2_peek(addr)
+          return open_bus(addr) if @reu_mapping || @frozen
+
+          io_window(addr, IO2_PAGE)
+        end
+
+        # The I/O RAM when selected, otherwise the ROM, which 16K and Ultimax
+        # mode leave out.
+        def io_window(addr, page)
+          if @ram_enabled || @ram_at_a000
+            io_ram[page | (addr & 0xff)]
+          elsif @config == :rom8k || @config == :off
+            @rom.peek(addr)
+          else
+            open_bus(addr)
+          end
+        end
+
+        def io_ram
+          @ram_data[ram_view_bank]
+        end
+
+        def io_ram_writable?(window)
+          window && !@frozen && (@ram_enabled || (@nordic && @ram_at_a000))
+        end
+
+        def ram_view_bank
+          @allow_bank ? @bank & 0x03 : 0
+        end
+
+        def control(value)
+          value = flash_mode_control(value)
+          @bank = bank_bits(value)
+          @phi1_ultimax = false
+          @config = CONTROL_MODES[value & 0x03]
+          @ram_at_a000 = (value & 0x67) == 0x22
+          if @nordic && @ram_at_a000
+            @config = :rom16k
+            @ram_enabled = false
+          else
+            acknowledge_freeze if value.anybits?(0x40)
+            @ram_enabled = value.anybits?(0x20)
+            @config = :off if @ram_at_a000
+          end
+          @config = :ultimax if @frozen
+          configure
+          @active = false if value.anybits?(0x04)
+        end
+
+        # Flash mode leaves 8K mode only to switch the cartridge off.
+        def flash_mode_control(value)
+          return value unless @flash_jumper && (value & 0x03) != 0x02
+
+          value & ~0x03
+        end
+
+        def acknowledge_freeze
+          @frozen = false
+          self.nmi = false
+        end
+
+        def extended_control(value)
+          unless @write_once
+            @allow_bank = value.anybits?(0x02)
+            @no_freeze = value.anybits?(0x04)
+            @reu_mapping = value.anybits?(0x40) && !@flash_jumper
+            @write_once = !@flash_jumper
+          end
+          @bank = bank_bits(value)
+          @bank |= 0x08 if @flash_jumper && @bank_jumper && value.nobits?(0x20)
+          configure
+        end
+
+        def bank_bits(value)
+          ((value >> 3) & 0x03) | ((value >> 5) & 0x04)
+        end
+
+        def configure
+          map_windows
+          changed!
+        end
+
+        def map_windows
+          self.mode = @config
+          @rom = flash_window(@bank)
+          @roml = roml_window
+          @romh = romh_window
+        end
+
+        def roml_window
+          nothing = @open_bus || EMPTY_BANK
+          return @ram_enabled ? WriteOnlyRAM.new(@ram_data[@bank & 0x03], nothing) : nothing if @frozen
+          return ram_window(@bank & 0x03) if @ram_enabled
+          return flash_writes if (@nordic && @ram_at_a000) || @config != :rom16k
+
+          nothing
+        end
+
+        # A RAM bank over the flash window takes writes for the chip and the
+        # C64's RAM alike.
+        def flash_writes
+          return @rom unless @flash_jumper
+
+          RAMBank.new(@rom).tap { |window| window.backing = @ram }
+        end
+
+        def ram_window(number)
+          if @config == :ultimax || @flash_jumper
+            @isolated[number]
+          else
+            (@nordic ? @through : @readers)[number]
+          end
+        end
+
+        def romh_window
+          nordic_ram = @nordic && @ram_at_a000
+          return @isolated[ram_view_bank] if nordic_ram && !@frozen
+          return @rom if @allow_bank || !(@ram_enabled || nordic_ram)
+
+          flash_window(@bank & ~0x03)
+        end
+
+        def flash_window(number)
+          @flash.window((@bank_jumper ? 0 : 0x10000) + (number * BANK_SIZE))
+        end
+
+        def install_chips(chips)
+          data = Array.new(0x20000, 0xff)
+          chips.each do |chip|
+            bytes = chip.data.first(BANK_SIZE)
+            data[((chip.bank & 0x0f) ^ 0x08) * BANK_SIZE, bytes.length] = bytes
+          end
+          @flash = Flash.new(data, model: Flash::AM29F010)
+          @flash.on_change { configure }
+          @ram_data = Array.new(4) { Array.new(BANK_SIZE, 0) }
+          @through = @ram_data.map { |data| RAMBank.new(data) }
+          @isolated = @ram_data.map { |data| RAMBank.new(data) }
+          @readers = @ram_data.map { |data| RAMReader.new(data) }
+          @allow_bank = @no_freeze = @reu_mapping = @write_once = false
+          reset
+        end
+      end
+    end
+  end
+end

data/lib/badline/c64/cartridge/rex_utility.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Badline
+  class C64
+    class Cartridge
+      # 8K. Reading $DF00-$DFBF switches the ROM out, reading $DFC0-$DFFF
+      # switches it back in.
+      class RexUtility < Cartridge
+        def readable_io_pages
+          [0xdf]
+        end
+
+        def peek(addr)
+          select_mode((addr & 0xff) < 0xc0 ? :off : :rom8k) if addr >= 0xdf00
+          open_bus(addr)
+        end
+
+        def reset
+          select_mode(:rom8k)
+        end
+
+        private
+
+        def install_chips(chips)
+          @roml = banks_from(chips).first.compact.first || EMPTY_BANK
+          reset
+        end
+      end
+    end
+  end
+end