badline 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ee3a30a07439b0a0dbffe352b5667945721a7bc84fc594b62e79e007d255b801
+  data.tar.gz: 2737e2a0dc04a81d264506aa406dc9cb3a661f37fdc3ec5135976ce5a654d558
+SHA512:
+  metadata.gz: d450522ea11e666044fceff4d1c0ab24f3bfb384c04d71914c3eb8a4bd62319911da97873101a6e1a759b053cdac2a7c421aaa4d7d16a55dc30eb05e5ce01a8d
+  data.tar.gz: 4cc7bdaa7cfdc414b0e1e8e5104115a8d5ff465428492165ca9880222cbbd56d06e45db9625f51b18f57956c5a9b86e51e442d42504b70c63ba2058c6bc1a091

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2016 Inge Jørgensen
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,40 @@
+![Build](https://github.com/elektronaut/badline/workflows/Build/badge.svg)
+[![Code Climate](https://codeclimate.com/github/elektronaut/badline/badges/gpa.svg)](https://codeclimate.com/github/elektronaut/badline)
+[![Code Climate](https://codeclimate.com/github/elektronaut/badline/badges/coverage.svg)](https://codeclimate.com/github/elektronaut/badline)
+
+# Badline
+
+Badline is a Commodore 64 emulator in written in Ruby. It is cycle accurate,
+utilizing Fibers to emulate cycles.
+
+Currently the memory map and 6510 CPU is working.
+
+## TODO
+
+- VIC-II emulation
+- CIA 1/2
+- C1541 emulation
+- SID emulation?
+
+## License
+
+Copyright 2016 Inge Jørgensen
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/exe/badline

@@ -0,0 +1,55 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+lib = File.expand_path("../lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require "optparse"
+
+options = { autostart: true, jit: true }
+
+parser = OptionParser.new do |opts|
+  opts.banner = <<~BANNER
+    Usage: badline [options] [media]
+
+    Media can be a .prg/.p00 program, a .d64/.d71/.d81 disk image,
+    a .crt cartridge, or a directory to mount as device 8.
+
+    Options:
+  BANNER
+
+  opts.on("--no-autostart", "Boot to READY. instead of running the program") do
+    options[:autostart] = false
+  end
+
+  opts.on("--disable-jit", "Run without enabling YJIT") do
+    options[:jit] = false
+  end
+
+  opts.on("-h", "--help", "Show this help") do
+    puts opts
+    exit
+  end
+end
+
+begin
+  parser.parse!
+rescue OptionParser::ParseError => e
+  warn "badline: #{e.message}"
+  warn "Try 'badline --help' for more information."
+  exit 1
+end
+
+media_path = ARGV[0]
+if media_path && !File.exist?(media_path)
+  warn "badline: no such file or directory: #{media_path}"
+  exit 1
+end
+
+jit_available = defined?(RubyVM::YJIT) && !RubyVM::YJIT.enabled?
+RubyVM::YJIT.enable if options[:jit] && jit_available
+
+require "badline"
+require "badline/gui"
+
+Badline::GUI::Application.new(media_path:, autostart: options[:autostart]).run

data/lib/badline/address_bus.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+module Badline
+  # Memory layout:
+  #
+  # 0x0000-0x00FF - Page 0       - Zeropage
+  # 0x0100-0x01FF - Page 1       - Stack
+  # 0x0200-0x02FF - Page 2       - OS/BASIC pointers
+  # 0x0300-0x03FF - Page 3       - OS/BASIC pointers
+  # 0x0400-0x07FF - Page 4-7     - Screen memory
+  # 0x0800-0x9FFF - Page 8-159   - BASIC program storage area
+  # 0xA000-0xBFFF - Page 160-191 - Machine code program storage (ROM overlay)
+  # 0xC000-0xCFFF - Page 192-207 - Machine code program storage
+  # 0xD000-0xD3FF - Page 208-211 - VIC II registers
+  # 0xD400-0xD7FF - Page 212-215 - SID registers
+  # 0xD800-0xDBFF - Page 216-219 - Color memory
+  # 0xDC00-0xDCFF - Page 220     - CIA 1
+  # 0xDD00-0xDDFF - Page 221     - CIA 2
+  # 0xDE00-0xDEFF - Page 222     - I/O 1
+  # 0xDF00-0xDFFF - Page 223     - I/O 2
+  # 0xE000-0xFFFF - Page 224-255 - Machine code program storage (ROM overlay)
+
+  # Overlays:
+  #
+  # 0x8000-0x9FFF - Cartridge ROM (low) - 8kb
+  # 0xA000-0xBFFF - BASIC ROM / Cartridge ROM (high) - 8kb
+  # 0xD000-0xDFFF - Character ROM / I/O - 4kb
+  # 0xE000-0xFFFF - KERNAL ROM / Cartridge ROM (high) - 8kb
+  class AddressBus
+    include Addressable
+
+    # Unmapped address space for Ultimax cartridges.
+    module OpenSpace
+      module_function
+
+      def peek(_addr) = 0xff
+      def poke(_addr, _value); end
+    end
+
+    PORT_PULLUPS  = 0b0001_0111
+    PORT_FLOATING = 0b1100_1000
+
+    attr_reader :io_port, :ram, :basic_rom, :character_rom, :kernal_rom,
+                :vic, :sid, :color_ram, :cia1, :cia2, :keyboard, :joystick2,
+                :cartridge, :ultimax
+
+    def initialize
+      @ram = Memory.new([0xff, 0x07], length: 2**16, start: 0)
+      @cartridge = nil
+
+      @basic_rom     = ROM.load("basic.rom",     0xa000)
+      @character_rom = ROM.load("character.rom", 0xd000)
+      @kernal_rom    = ROM.load("kernal.rom",    0xe000)
+
+      @keyboard = Keyboard.new
+      @joystick2 = Joystick.new
+      @vic  = VIC.new(self)
+      @cia1 = CIA.new(
+        start: 0xdc00,
+        peripheral: ControlPorts.new(keyboard: @keyboard, joystick2: @joystick2)
+      )
+      @cia2 = CIA.new(start: 0xdd00)
+      @sid  = SID.new
+
+      @color_ram = ColorMemory.new(start: 0xd800, length: 2**10)
+
+      @port_ddr = 0x2f
+      @port_out = 0x37
+      @port_floating = 0x00
+      @io_port = Status.new(%i[basic kernal io tape_out tape_switch tape_motor], value: port_value)
+
+      @read_pages = Array.new(256)
+      @write_pages = Array.new(256)
+      update_overlays!
+    end
+
+    def attach_cartridge(cartridge)
+      @cartridge = cartridge
+      cartridge.on_change { update_overlays! }
+      update_overlays!
+    end
+
+    def disable_overlays!
+      poke(1, 0)
+    end
+
+    def peek(addr)
+      return @port_ddr if addr.zero?
+      return @io_port.value if addr == 0x01
+
+      @read_pages[addr >> 8].peek(addr)
+    end
+
+    def poke(addr, value)
+      if addr < 0x02
+        addr.zero? ? @port_ddr = value : @port_out = value
+        update_port!
+      else
+        @write_pages[addr >> 8].poke(addr, value)
+      end
+    end
+
+    def inspect
+      "#<#{self.class.name} port=#{format('0x%02x', @io_port.value)} " \
+        "cartridge=#{@cartridge ? @cartridge.class.name : 'none'} " \
+        "ultimax=#{@ultimax}>"
+    end
+
+    private
+
+    def update_port!
+      driven = @port_ddr & PORT_FLOATING
+      @port_floating = (@port_floating & ~driven) | (@port_out & driven)
+      @io_port.value = port_value
+      update_overlays!
+    end
+
+    def port_value
+      input = PORT_PULLUPS | (@port_floating & PORT_FLOATING)
+      (@port_out & @port_ddr) | (input & ~@port_ddr & 0xff)
+    end
+
+    # Banking changes only on $01 writes and cartridge line/bank changes,
+    # so reads and writes dispatch through per-page handler tables instead
+    # of range checks.
+    def update_overlays!
+      @ultimax = @cartridge ? @cartridge.ultimax? : false
+      @read_pages.fill(@ram)
+      @write_pages.fill(@ram)
+
+      @ultimax ? map_ultimax_pages : map_banked_pages
+    end
+
+    def map_banked_pages
+      map_rom_overlays
+
+      if io?
+        map_io_pages
+      elsif character?
+        @read_pages.fill(character_rom, 0xd0, 0x10)
+      end
+    end
+
+    def map_rom_overlays
+      @read_pages.fill(@cartridge.roml, 0x80, 0x20) if roml?
+      if romh?
+        @read_pages.fill(@cartridge.romh, 0xa0, 0x20)
+      elsif basic?
+        @read_pages.fill(basic_rom, 0xa0, 0x20)
+      end
+      @read_pages.fill(kernal_rom, 0xe0, 0x20) if kernal?
+    end
+
+    # Ultimax cartridges ignore the $01 lines: 4K of RAM, ROML/ROMH windows,
+    # I/O always visible and open address space everywhere else.
+    def map_ultimax_pages
+      @read_pages.fill(OpenSpace, 0x10, 0xf0)
+      @write_pages.fill(OpenSpace, 0x10, 0xf0)
+      @read_pages.fill(@cartridge.roml, 0x80, 0x20) if @cartridge.roml
+      @read_pages.fill(@cartridge.romh, 0xe0, 0x20) if @cartridge.romh
+      map_io_pages
+    end
+
+    def map_io_pages
+      {
+        vic => 0xd0..0xd3, sid => 0xd4..0xd7, color_ram => 0xd8..0xdb,
+        cia1 => 0xdc..0xdc, cia2 => 0xdd..0xdd
+        # 0xde/0xdf are open I/O unless a cartridge claims them
+      }.each do |chip, pages|
+        pages.each { |p| @read_pages[p] = @write_pages[p] = chip }
+      end
+      return unless @cartridge
+
+      @read_pages.fill(@cartridge, 0xde, 2)
+      @write_pages.fill(@cartridge, 0xde, 2)
+    end
+
+    def basic?
+      io_port.kernal? && io_port.basic? && game_high?
+    end
+
+    def game_high?
+      @cartridge.nil? || @cartridge.game == 1
+    end
+
+    def roml?
+      @cartridge&.roml && @cartridge.exrom.zero? && io_port.kernal? && io_port.basic?
+    end
+
+    def romh?
+      @cartridge&.romh && @cartridge.exrom.zero? && @cartridge.game.zero? && io_port.kernal?
+    end
+
+    def character?
+      (io_port.basic? || io_port.kernal?) && !io_port.io?
+    end
+
+    def io?
+      (io_port.basic? || io_port.kernal?) && io_port.io?
+    end
+
+    def kernal?
+      io_port.kernal?
+    end
+  end
+end

data/lib/badline/addressable.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Badline
+  module Addressable
+    include IntegerHelper
+
+    class ReadOnlyMemoryError < StandardError; end
+    class OutOfBoundsError < StandardError; end
+
+    attr_reader :start, :length, :end
+
+    def addressable_at(start = 0, length: 2**16)
+      @start = start
+      @length = length
+      @end = start + length
+    end
+
+    def range
+      start..(start + (length - 1))
+    end
+
+    def in_range?(addr)
+      addr >= @start && addr < @end
+    end
+
+    def peek(_addr)
+      raise NoMethodError
+    end
+
+    def peek16(addr)
+      uint16(peek(addr), peek(addr + 1))
+    end
+
+    def poke(_addr, _value)
+      raise NoMethodError
+    end
+
+    def poke16(addr, value)
+      poke(addr, low_byte(value))
+      poke(addr + 1, high_byte(value))
+      value
+    end
+
+    def [](addr)
+      peek(addr)
+    end
+
+    def []=(addr, value)
+      poke(addr, value)
+    end
+
+    private
+
+    def index(addr)
+      i = addr - @start
+      raise OutOfBoundsError, "#{addr.inspect} (#{range})" unless i >= 0 && i < @length
+
+      i
+    end
+  end
+end

data/lib/badline/cartridge/magic_desk.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Badline
+  class Cartridge
+    class MagicDesk < Cartridge
+      def poke(addr, value)
+        return if addr > 0xdeff
+
+        @exrom = value.anybits?(0x80) ? 1 : 0
+        @roml = @banks[(value & 0x3f) % @banks.length]
+        changed!
+      end
+
+      private
+
+      def install_chips(chips)
+        @banks = []
+        chips.each { |chip| @banks[chip.bank] = rom_bank(chip.data, ROML_START) }
+        @roml = @banks.first
+      end
+    end
+  end
+end

data/lib/badline/cartridge/ocean.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Badline
+  class Cartridge
+    class Ocean < Cartridge
+      def poke(addr, value)
+        return if addr > 0xdeff
+
+        select_bank((value & 0x3f) % @roml_banks.length)
+        changed!
+      end
+
+      private
+
+      def select_bank(number)
+        @roml = @roml_banks[number]
+        @romh = @romh_banks[number] if @romh_banks
+      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
+      end
+    end
+  end
+end

data/lib/badline/cartridge/standard.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Badline
+  class Cartridge
+    class Standard < Cartridge
+      private
+
+      def install_chips(chips)
+        chips.each { |chip| install_chip(chip) }
+      end
+
+      def install_chip(chip)
+        if chip.address >= ULTIMAX_ROMH_START
+          @romh = rom_bank(chip.data, ULTIMAX_ROMH_START)
+        elsif chip.address >= ROMH_START
+          @romh = rom_bank(chip.data, ROMH_START)
+        elsif chip.data.length > BANK_SIZE
+          install_split_chip(chip)
+        else
+          @roml = rom_bank(chip.data, ROML_START)
+        end
+      end
+
+      def install_split_chip(chip)
+        # A single 16K chip at $8000 spans both ROML and ROMH.
+        @roml = rom_bank(chip.data[0, BANK_SIZE], ROML_START)
+        @romh = rom_bank(chip.data[BANK_SIZE, BANK_SIZE], ROMH_START)
+      end
+    end
+  end
+end

data/lib/badline/cartridge.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "badline/cartridge/standard"
+require "badline/cartridge/ocean"
+require "badline/cartridge/magic_desk"
+
+module Badline
+  class Cartridge
+    class UnsupportedTypeError < StandardError; end
+
+    ROML_START = 0x8000
+    ROMH_START = 0xa000
+    ULTIMAX_ROMH_START = 0xe000
+    BANK_SIZE = 0x2000
+
+    HARDWARE_TYPES = { 0 => :Standard, 5 => :Ocean, 19 => :MagicDesk }.freeze
+
+    attr_reader :name, :exrom, :game, :roml, :romh
+
+    class << self
+      def from_file(path)
+        from_crt(Storage::CRTFile.new(path))
+      end
+
+      def from_crt(crt)
+        type = HARDWARE_TYPES.fetch(crt.hardware_type) do
+          raise UnsupportedTypeError,
+                "Unsupported cartridge hardware type #{crt.hardware_type}"
+        end
+        const_get(type).new(crt)
+      end
+    end
+
+    def initialize(crt)
+      @name = crt.name
+      @exrom = crt.exrom
+      @game = crt.game
+      @roml = @romh = nil
+      @on_change = nil
+      install_chips(crt.chips)
+    end
+
+    def on_change(&block)
+      @on_change = block
+    end
+
+    def ultimax?
+      @game.zero? && @exrom == 1
+    end
+
+    # IO1/IO2 reads are open bus unless a mapper says otherwise.
+    def peek(_addr)
+      0xff
+    end
+
+    def poke(_addr, _value); end
+
+    private
+
+    def changed!
+      @on_change&.call
+    end
+
+    def install_chips(_chips)
+      raise NotImplementedError
+    end
+
+    # Chips smaller than 8K (e.g. 4K Ultimax ROMs) have unconnected upper
+    # address lines and mirror across the full bank.
+    def rom_bank(data, start)
+      data *= BANK_SIZE / data.length if data.length < BANK_SIZE
+      ROM.new(data, length: data.length, start:)
+    end
+  end
+end

data/lib/badline/chrout_trap.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Badline
+  # Observe-only PC trap on the KERNAL CHROUT routine ($FFD2). Records each
+  # character written while the KERNAL is banked in, then lets execution fall
+  # through to the ROM, so the screen output is unaffected. Used for headless
+  # capture of program output.
+  class ChroutTrap
+    ADDRESS = 0xffd2
+
+    attr_reader :output
+
+    def initialize(cpu:, bus:)
+      @cpu = cpu
+      @bus = bus
+      @output = +""
+    end
+
+    def call
+      @output << ascii(@cpu.a) if @bus.io_port.kernal?
+    end
+
+    def inspect
+      "#<#{self.class.name} output=#{@output.inspect}>"
+    end
+
+    private
+
+    def ascii(byte)
+      case byte
+      when 0x0d then "\n"
+      when 0x41..0x5a then (byte + 0x20).chr
+      when 0xc1..0xda then (byte - 0x80).chr
+      when 0x20..0x7e then byte.chr
+      else ""
+      end
+    end
+  end
+end