badline 0.1.0 → 0.2.1

data/lib/badline/cartridge/flash.rb

@@ -0,0 +1,265 @@
+# frozen_string_literal: true
+
+module Badline
+  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
+
+      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
+
+      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

data/lib/badline/cartridge/freezer.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Badline
+  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 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

data/lib/badline/cartridge/fun_play.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Badline
+  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

data/lib/badline/cartridge/g_mod2.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Badline
+  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

data/lib/badline/cartridge/game_system.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Badline
+  class Cartridge
+    # C64 Game System / System 3: up to 64 8K banks. Any access to
+    # $DE00-$DEFF selects the bank from the low six address bits; the data
+    # is ignored.
+    class GameSystem < Cartridge
+      def readable_io_pages
+        [0xde]
+      end
+
+      def peek(addr)
+        select(addr) if addr < 0xdf00
+        open_bus(addr)
+      end
+
+      def poke(addr, _value)
+        select(addr) if addr < 0xdf00
+      end
+
+      def reset
+        select(0)
+      end
+
+      private
+
+      def select(addr)
+        @roml = bank(@banks, addr & 0x3f)
+        changed!
+      end
+
+      def install_chips(chips)
+        @banks = banks_from(chips).first
+        self.mode = :rom8k
+        reset
+      end
+    end
+  end
+end

data/lib/badline/cartridge/kcs_power.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Badline
+  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
+          switch(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
+          @ram[addr & 0x7f]
+        end
+      end
+
+      def poke(addr, value)
+        if addr < 0xdf00
+          switch(addr.anybits?(0x02) ? :ultimax : :rom16k)
+        elsif addr.nobits?(0x80)
+          @ram[addr & 0x7f] = value
+        end
+      end
+
+      def reset
+        self.nmi = false
+        switch(:rom16k)
+      end
+
+      def freeze!
+        self.nmi = false
+        switch(:ultimax)
+      end
+
+      private
+
+      def switch(mode)
+        self.mode = mode
+        changed!
+      end
+
+      def install_chips(chips)
+        roml, romh = banks_from(chips)
+        @roml = roml.first || EMPTY_BANK
+        @romh = romh.first || EMPTY_BANK
+        @ram = Array.new(0x80, 0xff)
+        reset
+      end
+    end
+  end
+end

data/lib/badline/cartridge/mach5.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Badline
+  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)
+        self.mode = addr < 0xdf00 ? :rom8k : :off
+        changed!
+      end
+
+      def reset
+        self.mode = :rom8k
+        changed!
+      end
+
+      private
+
+      def install_chips(chips)
+        @roml = banks_from(chips).first.compact.first
+        reset
+      end
+    end
+  end
+end

data/lib/badline/cartridge/magic_desk.rb

@@ -11,12 +11,15 @@ module Badline
         changed!
       end
 
+      def reset
+        poke(0xde00, 0)
+      end
+
       private
 
       def install_chips(chips)
-        @banks = []
-        chips.each { |chip| @banks[chip.bank] = rom_bank(chip.data, ROML_START) }
-        @roml = @banks.first
+        @banks = banks_from(chips).first
+        reset
       end
     end
   end

data/lib/badline/cartridge/ocean.rb

@@ -6,27 +6,26 @@ module Badline
       def poke(addr, value)
         return if addr > 0xdeff
 
-        select_bank((value & 0x3f) % @roml_banks.length)
+        select_bank((value & 0x3f) % @banks.length)
+        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 = @roml_banks[number]
-        @romh = @romh_banks[number] if @romh_banks
+        @roml = @banks[number]
+        @romh = @roml if game.zero?
       end
 
       def install_chips(chips)
-        @roml_banks = []
-        @romh_banks = game.zero? ? [] : nil
-        chips.each { |chip| install_chip(chip) }
-        select_bank(0)
-      end
-
-      def install_chip(chip)
-        @roml_banks[chip.bank] = rom_bank(chip.data, ROML_START)
-        @romh_banks[chip.bank] = rom_bank(chip.data, ROMH_START) if @romh_banks
+        @banks = banks_from(chips).first
+        reset
       end
     end
   end

data/lib/badline/cartridge/pagefox.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Badline
+  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 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