badline 0.12.1 → 0.14.0

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

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module Badline
+  class C64
+    class Cartridge
+      # EasyFlash: two Am29F040B flash chips, one for ROML and one for ROMH,
+      # each 64 banks of 8K, and 256 bytes of RAM at $DF00. $DE00 selects the
+      # bank. $DE02 sets the memory configuration: bit 2 hands the GAME line
+      # to bit 0 (otherwise the boot jumper holds it low), bit 1 pulls EXROM
+      # low and bit 7 drives the LED.
+      #
+      # The flash takes writes in Ultimax mode, at $8000 for ROML and $E000
+      # for ROMH, which is how EAPI programs and erases it. The writes stay in
+      # memory; #save_crt writes the flash out as a new image.
+      #
+      # An image built for EasyFlash carries an EAPI, the flash driver, at $B800
+      # in bank 0 of ROMH. On attach, as in VICE, the bundled Am29F040 EAPI
+      # (roms/eapi) takes its place, so the image drives the flash emulated here.
+      class EasyFlash < Cartridge
+        BANKS = 64
+        EAPI_OFFSET = 0x1800
+
+        def self.eapi
+          @eapi ||= ROM.read("eapi/eapi-am29f040-14").drop(2).freeze
+        end
+
+        attr_reader :low_flash, :high_flash
+
+        def clock=(clock)
+          super
+          [@low_flash, @high_flash].each { |flash| flash.clock = clock }
+        end
+
+        def readable_io_pages
+          [0xdf]
+        end
+
+        def peek(addr)
+          @io_ram[addr & 0xff]
+        end
+
+        def poke(addr, value)
+          if addr >= 0xdf00
+            @io_ram[addr & 0xff] = value
+          elsif addr.nobits?(0x02)
+            @bank = value & 0x3f
+            select_bank
+          else
+            @control = value & 0x87
+            apply_control
+            changed!
+          end
+        end
+
+        def led?
+          @control.anybits?(0x80)
+        end
+
+        # Reset clears both registers, and leaves the flash and the RAM.
+        def reset
+          @bank = 0
+          @control = 0
+          apply_control
+          select_bank
+        end
+
+        # Writes every bank that isn't blank to a CRT image at path.
+        def save_crt(path)
+          chips = (0...BANKS).flat_map do |number|
+            [[@low_flash, 0x8000], [@high_flash, 0xa000]].filter_map do |flash, address|
+              data = flash.data[number * BANK_SIZE, BANK_SIZE]
+              Storage::CRTFile::Chip.new(chip_type: 2, bank: number, address:, data:) if data.any?(0..0xfe)
+            end
+          end
+          image = Storage::CRTFile::Image.new(hardware_type: 32, subtype: 0, exrom: 1, game: 0, name:, chips:)
+          Storage::CRTFile.write(path, image)
+        end
+
+        private
+
+        def select_bank
+          map_bank
+          changed!
+        end
+
+        def map_bank
+          @roml = @low_flash.window(@bank * BANK_SIZE)
+          @romh = @high_flash.window(@bank * BANK_SIZE)
+        end
+
+        def apply_control
+          game = @control.nobits?(0x04) || @control.anybits?(0x01)
+          exrom = @control.anybits?(0x02)
+          @game = game ? 0 : 1
+          @exrom = exrom ? 0 : 1
+        end
+
+        def install_chips(chips)
+          low = Array.new(BANKS * BANK_SIZE, 0xff)
+          high = Array.new(BANKS * BANK_SIZE, 0xff)
+          chips.each do |chip|
+            offset = (chip.bank & 0x3f) * BANK_SIZE
+            if chip.address >= ROMH_START
+              place(high, offset, chip.data)
+            else
+              place(low, offset, chip.data)
+              place(high, offset, chip.data[BANK_SIZE..]) if chip.data.length > BANK_SIZE
+            end
+          end
+          install_eapi(high)
+          @low_flash = Flash.new(low)
+          @high_flash = Flash.new(high)
+          [@low_flash, @high_flash].each { |flash| flash.on_change { select_bank } }
+          @io_ram = Array.new(0x100, 0xff)
+          reset
+        end
+
+        def install_eapi(high)
+          return unless high[EAPI_OFFSET, 4] == "eapi".bytes
+
+          eapi = EasyFlash.eapi
+          high[EAPI_OFFSET, eapi.length] = eapi
+        end
+
+        def place(flash_data, offset, bytes)
+          bytes = bytes.first(BANK_SIZE)
+          flash_data[offset, bytes.length] = bytes
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Badline
+  class C64
+    class Cartridge
+      # Epyx FastLoad: 8K. A capacitor holds the ROM in for 512 cycles after
+      # it was last discharged, by reset, a read through ROML or a read of
+      # I/O 1; once it charges, $8000-$9FFF reads RAM. I/O 2 reads the last
+      # 256 bytes of the ROM.
+      class EpyxFastload < Cartridge
+        DISCHARGED_CYCLES = 512
+
+        class Window
+          def initialize(cartridge, rom)
+            @cartridge = cartridge
+            @rom = rom
+          end
+
+          def peek(addr)
+            @cartridge.rom_visible? ? @rom.peek(addr) : @cartridge.ram_peek(addr)
+          end
+        end
+
+        def clock=(clock)
+          super
+          discharge!
+        end
+
+        def readable_io_pages
+          [0xde, 0xdf]
+        end
+
+        def peek(addr)
+          return @rom.peek(addr) if addr >= 0xdf00
+
+          discharge!
+          open_bus(addr)
+        end
+
+        # True while the capacitor holds the ROM in, discharging it again.
+        def rom_visible?
+          return true unless @clock
+          return false if @clock.call - @discharged_at >= DISCHARGED_CYCLES
+
+          discharge!
+          true
+        end
+
+        def ram_peek(addr)
+          @ram.peek(addr)
+        end
+
+        # Reset discharges the capacitor, so the ROM shows.
+        def reset
+          discharge!
+        end
+
+        private
+
+        def discharge!
+          @discharged_at = @clock ? @clock.call : 0
+        end
+
+        def install_chips(chips)
+          @rom = banks_from(chips).first.compact.first || EMPTY_BANK
+          @roml = Window.new(self, @rom)
+          @discharged_at = 0
+          self.mode = :rom8k
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Badline
+  class C64
+    class Cartridge
+      # The Final Cartridge III: four 16K banks, or sixteen on the III+. I/O 1
+      # and I/O 2 show the last two pages of the selected ROML bank. A write
+      # to $DFFF sets the register:
+      #
+      #   bits 0-1 bank (0-3 on the III+)
+      #   bit 4    EXROM level
+      #   bit 5    GAME level
+      #   bit 6    NMI line, active low
+      #   bit 7    hides the register until the next freeze
+      #
+      # Clearing bit 6 pulls NMI without freezing, and setting it lets go of
+      # NMI after a freeze. A freeze keeps the bank and switches to Ultimax,
+      # which the VIC doesn't see until the register sets it again.
+      class FinalCartridge3 < Cartridge
+        include Freezer
+
+        REGISTER = 0xdfff
+
+        def readable_io_pages
+          [0xde, 0xdf]
+        end
+
+        def peek(addr)
+          @io_bank.peek(addr)
+        end
+
+        def poke(addr, value)
+          return unless addr == REGISTER && @register_visible
+
+          @register_visible = value.nobits?(0x80)
+          self.nmi = value.nobits?(0x40)
+          select(value & @bank_mask)
+          @exrom = (value >> 4) & 0x01
+          @game = (value >> 5) & 0x01
+          @phi1_ultimax = ultimax?
+          changed!
+        end
+
+        def phi1_ultimax?
+          @phi1_ultimax
+        end
+
+        def reset
+          @register_visible = true
+          @phi1_ultimax = false
+          self.nmi = false
+          select(0)
+          select_mode(:rom16k)
+        end
+
+        def freeze!
+          @register_visible = true
+          @phi1_ultimax = false
+          select_mode(:ultimax)
+        end
+
+        private
+
+        def windows = [*@roml_banks, *@romh_banks, EMPTY_BANK]
+
+        def select(number)
+          @io_bank = @roml = bank(@roml_banks, number)
+          @romh = bank(@romh_banks, number)
+        end
+
+        def install_chips(chips)
+          @roml_banks, @romh_banks = banks_from(chips)
+          @bank_mask = @roml_banks.length > 4 ? 0x0f : 0x03
+          reset
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,279 @@
+# frozen_string_literal: true
+
+module Badline
+  class C64
+    class Cartridge
+      # An AMD 29F0x0 flash chip, driven through the JEDEC command set in the
+      # AMD datasheets. Each command opens with two unlock cycles, $AA to the
+      # first unlock address and $55 to the second, and a third write picks
+      # the command:
+      #
+      #   $90 autoselect: offset 0 reads the manufacturer, 1 the device and 2
+      #       the sector protection, until a reset
+      #   $F0 reset to reading the array, which a lone $F0 also does
+      #   $A0 byte program: the next write clears bits of the array, which
+      #       only an erase sets again
+      #   $80 erase, after two more unlock cycles: $10 to the first unlock
+      #       address erases the chip, and $30 to a sector erases the sector.
+      #       Further sectors can follow within the 50 us window.
+      #
+      # While a program or erase runs, a read returns status: DQ7 the
+      # complement of the programmed bit (0 while erasing), DQ6 toggling on
+      # every read, DQ5 set when a program failed and DQ3 set once an erase
+      # has left its window. $B0 suspends a sector erase and $30 resumes it.
+      #
+      # The cartridge reads the array through windows, and the chip swaps
+      # them for status windows while it is busy or in autoselect.
+      class Flash
+        Model = Data.define(:size, :sector_size, :unlock1, :unlock2, :unlock_mask, :manufacturer, :device)
+
+        AM29F040 = Model.new(size: 0x80000, sector_size: 0x10000, unlock1: 0x5555, unlock2: 0x2aaa,
+                             unlock_mask: 0x7fff, manufacturer: 0x01, device: 0xa4)
+        AM29F040B = Model.new(size: 0x80000, sector_size: 0x10000, unlock1: 0x555, unlock2: 0x2aa,
+                              unlock_mask: 0x7ff, manufacturer: 0x01, device: 0xa4)
+        AM29F010 = Model.new(size: 0x20000, sector_size: 0x4000, unlock1: 0x5555, unlock2: 0x2aaa,
+                             unlock_mask: 0x7fff, manufacturer: 0x01, device: 0x20)
+
+        # The datasheet's typical times, in cycles at 1 MHz.
+        PROGRAM_CYCLES = 7
+        ERASE_WINDOW_CYCLES = 50
+        SECTOR_ERASE_CYCLES = 1_000_000
+        CHIP_ERASE_CYCLES = 8_000_000
+
+        # The array, read directly while the chip reads it.
+        class Window
+          def initialize(flash, base)
+            @flash = flash
+            @data = flash.data
+            @base = base
+          end
+
+          def peek(addr)
+            @data[@base | (addr & 0x1fff)]
+          end
+          alias [] peek
+
+          def poke(addr, value)
+            @flash.write(@base | (addr & 0x1fff), value)
+          end
+          alias []= poke
+        end
+
+        # Reads through the chip, for its status and autoselect codes.
+        class StatusWindow < Window
+          def peek(addr)
+            @flash.read(@base | (addr & 0x1fff))
+          end
+          alias [] peek
+        end
+
+        # The command states, which a snapshot names.
+        STATES = %i[read program_setup autoselect programming erase_window erasing suspended chip_erase
+                    program_error].freeze
+
+        attr_reader :data, :state
+        attr_writer :clock
+
+        def initialize(data, model: AM29F040B, clock: -> { 0 })
+          @model = model
+          @data = data + ([0xff] * (model.size - data.length))
+          @clock = clock
+          @windows = {}
+          @status_windows = {}
+          @on_change = nil
+          @state = :read
+          @base_state = :read
+          @cycle = 0
+          @toggle = 0
+        end
+
+        # Called when the chip starts or stops answering reads from the array.
+        def on_change(&block)
+          @on_change = block
+        end
+
+        def window(base)
+          if array_mode?
+            @windows[base] ||= Window.new(self, base)
+          else
+            @status_windows[base] ||= StatusWindow.new(self, base)
+          end
+        end
+
+        # Hands out new windows at the bases given, as #window would have.
+        def rebuild_windows(bases, status_bases)
+          @windows = {}
+          @status_windows = {}
+          bases.each { |base| @windows[base] = Window.new(self, base) }
+          status_bases.each { |base| @status_windows[base] = StatusWindow.new(self, base) }
+        end
+
+        def array_mode?
+          @state == :read || @state == :program_setup
+        end
+
+        def read(offset)
+          settle
+          case @state
+          when :read then @data[offset]
+          when :autoselect then autoselect_code(offset)
+          when :suspended then suspended_read(offset)
+          else status
+          end
+        end
+
+        def write(offset, value)
+          settle
+          case @state
+          when :program_setup then program(offset, value)
+          when :erase_window then extend_erase(offset, value)
+          when :erasing then suspend if value == 0xb0
+          when :suspended then resume if value == 0x30
+          when :program_error then enter(:read, base: :read) if value == 0xf0
+          when :programming, :chip_erase then nil
+          else command(offset, value)
+          end
+        end
+
+        private
+
+        def command(offset, value)
+          if value == 0xf0
+            @cycle = 0
+            return enter(:read, base: :read)
+          end
+
+          address = offset & @model.unlock_mask
+          @cycle = case @cycle
+                   when 0, 3 then address == @model.unlock1 && value == 0xaa ? @cycle + 1 : 0
+                   when 1, 4 then address == @model.unlock2 && value == 0x55 ? @cycle + 1 : 0
+                   when 2 then command_cycle(address, value)
+                   when 5 then erase_command(offset, address, value)
+                   end
+        end
+
+        def command_cycle(address, value)
+          return 0 unless address == @model.unlock1
+
+          case value
+          when 0x90 then enter(:autoselect, base: :autoselect)
+          when 0xa0 then @state = :program_setup
+          when 0x80 then return 3
+          end
+          0
+        end
+
+        def erase_command(offset, address, value)
+          if value == 0x10 && address == @model.unlock1
+            start_busy(:chip_erase, CHIP_ERASE_CYCLES)
+          elsif value == 0x30
+            @erasing_sectors = [sector(offset)]
+            start_busy(:erase_window, ERASE_WINDOW_CYCLES)
+          end
+          0
+        end
+
+        def program(offset, value)
+          @programmed = value
+          @data[offset] &= value
+          if @data[offset] == value
+            start_busy(:programming, PROGRAM_CYCLES)
+          else
+            enter(:program_error)
+          end
+        end
+
+        def extend_erase(offset, value)
+          case value
+          when 0x30
+            @erasing_sectors |= [sector(offset)]
+            @done_at = now + ERASE_WINDOW_CYCLES
+          when 0xb0
+            @remaining = @erasing_sectors.length * SECTOR_ERASE_CYCLES
+            enter(:suspended)
+          else
+            @erasing_sectors = nil
+            enter(@base_state)
+          end
+        end
+
+        def suspend
+          @remaining = @done_at - now
+          enter(:suspended)
+        end
+
+        def resume
+          start_busy(:erasing, @remaining)
+        end
+
+        # Moves a timed operation on once the clock has passed its end.
+        def settle
+          return unless @done_at && now >= @done_at
+
+          case @state
+          when :erase_window
+            start_busy(:erasing, @done_at - now + (@erasing_sectors.length * SECTOR_ERASE_CYCLES))
+            settle
+          when :erasing
+            @erasing_sectors.each { |s| @data.fill(0xff, s * @model.sector_size, @model.sector_size) }
+            @erasing_sectors = nil
+            finish
+          when :chip_erase
+            @data.fill(0xff)
+            finish
+          else
+            finish
+          end
+        end
+
+        def finish
+          @done_at = nil
+          enter(@base_state)
+        end
+
+        def start_busy(state, cycles)
+          @done_at = now + cycles
+          @programmed = 0xff unless state == :programming
+          enter(state)
+        end
+
+        def enter(state, base: @base_state)
+          was_array = array_mode?
+          @state = state
+          @base_state = base
+          @done_at = nil unless %i[programming erase_window erasing chip_erase].include?(state)
+          @on_change&.call if was_array != array_mode?
+        end
+
+        def status
+          @toggle ^= 0x40
+          value = (~@programmed & 0x80) | @toggle
+          value |= 0x20 if @state == :program_error
+          value |= 0x08 if @state == :erasing || @state == :chip_erase
+          value
+        end
+
+        def suspended_read(offset)
+          @erasing_sectors.include?(sector(offset)) ? 0x80 : @data[offset]
+        end
+
+        def autoselect_code(offset)
+          case offset & 0x43
+          when 0 then @model.manufacturer
+          when 1 then @model.device
+          when 2 then 0x00
+          else @data[offset]
+          end
+        end
+
+        def sector(offset)
+          offset / @model.sector_size
+        end
+
+        def now
+          @clock.call
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Badline
+  class C64
+    class Cartridge
+      # The freeze button of a freezer cartridge. A press pulls NMI, and the
+      # computer calls #freeze! once the CPU has pushed the return address and
+      # status of the interrupt, so the vector fetch that follows reads the
+      # cartridge ROM in Ultimax mode. The cartridge lets go of NMI when its
+      # software acknowledges the freeze.
+      module Freezer
+        def freezer? = true
+
+        def press_button
+          @button = true
+          self.nmi = true if freeze_allowed?
+        end
+
+        def release_button
+          @button = false
+        end
+
+        private
+
+        def freeze_allowed?
+          true
+        end
+
+        def button_pressed?
+          @button == true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Badline
+  class C64
+    class Cartridge
+      # Fun Play / Power Play: up to 16 8K banks. A write to I/O 1 selects the
+      # bank from bits 3-5 and 0, and either 8K mode ($00 in bits 7, 6, 2 and 1)
+      # or no ROM ($86 in those bits).
+      class FunPlay < Cartridge
+        def poke(addr, value)
+          return if addr > 0xdeff
+
+          @roml = bank(@banks, self.class.bank_number(value))
+          case value & 0xc6
+          when 0x00 then self.mode = :rom8k
+          when 0x86 then self.mode = :off
+          end
+          changed!
+        end
+
+        # The CRT file numbers each bank by the register value that selects it.
+        def reset
+          poke(0xde00, 0)
+        end
+
+        def self.bank_number(value)
+          ((value >> 3) & 0x07) | ((value & 0x01) << 3)
+        end
+
+        private
+
+        def install_chips(chips)
+          @banks = []
+          chips.each { |chip| @banks[self.class.bank_number(chip.bank)] = rom_bank(chip.data) }
+          reset
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Badline
+  class C64
+    class Cartridge
+      # GMod2: an Am29F040 flash chip of 64 8K banks at ROML. A write to I/O 1
+      # selects the bank from bits 0-5. Bit 6 selects the EEPROM, which
+      # switches the ROM out, and bits 6 and 7 together enable flash writes:
+      # the cartridge then asserts Ultimax on write cycles only, so reads see
+      # the C64's memory and writes to $E000-$FFFF reach the flash. The EEPROM
+      # isn't emulated.
+      class GMod2 < Cartridge
+        BANKS = 64
+
+        attr_reader :flash
+
+        def clock=(clock)
+          super
+          @flash.clock = clock
+        end
+
+        def poke(addr, value)
+          return if addr > 0xdeff
+
+          @bank = value & 0x3f
+          @flash_writes = value.allbits?(0xc0)
+          self.mode = value.anybits?(0x40) ? :off : :rom8k
+          select_bank
+        end
+
+        def romh_writes
+          @roml if @flash_writes
+        end
+
+        # Reset selects the first bank in 8K mode, and leaves the flash as it
+        # is.
+        def reset
+          @bank = 0
+          @flash_writes = false
+          self.mode = :rom8k
+          select_bank
+        end
+
+        private
+
+        def select_bank
+          @roml = @flash.window(@bank * BANK_SIZE)
+          changed!
+        end
+
+        def install_chips(chips)
+          data = Array.new(BANKS * BANK_SIZE, 0xff)
+          chips.each do |chip|
+            bytes = chip.data.first(BANK_SIZE)
+            data[(chip.bank & 0x3f) * BANK_SIZE, bytes.length] = bytes
+          end
+          @flash = Flash.new(data, model: Flash::AM29F040)
+          @flash.on_change { select_bank }
+          reset
+        end
+      end
+    end
+  end
+end