badline 0.16.1 → 0.18.0

data/lib/badline/kim1.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+require "badline/kim1/cpu"
+require "badline/kim1/rriots"
+require "badline/kim1/tape"
+require "badline/kim1/panel"
+require "badline/kim1/key_entry"
+require "badline/kim1/bus"
+require "badline/kim1/sound"
+require "badline/kim1/teletype"
+require "badline/kim1/host_terminal"
+
+module Badline
+  # The MOS KIM-1: a 6502 at 1 MHz, 1K of RAM and two 6530 RRIOTs, U2
+  # with the monitor in its ROM and U3 with the tape routines (KIM1::Bus).
+  # U2's ports drive the keypad and the six LED digits (Panel), and its PB7
+  # the audio output (Sound) and the cassette (Tape). Nothing pulls IRQ
+  # unless U3's PB7 is wired to it, as the User Manual's appendix H has the
+  # user do for U3's timer.
+  #
+  # RS resets the CPU and both 6530s, and ST pulls NMI, which the monitor
+  # leaves to the vector at $17FA: $1C00 there saves the registers and
+  # shows the PC. With the SST switch on, every instruction outside the
+  # monitor ends in an NMI (CPU#single_step). With the TTY/KB jumper
+  # fitted, the monitor talks to a teletype (Teletype) in place of the
+  # keypad and display. It runs headless.
+  class KIM1
+    include Machine::Clocking
+    include Machine::Settling
+    include KeyEntry
+
+    # The cycle by which the monitor is scanning the display, with a
+    # margin.
+    BOOT_CYCLES = 10_000
+
+    attr_reader :bus, :cpu, :u2, :u3, :panel, :teletype, :cycles, :init_threshold
+
+    # Whether the SST switch is on.
+    attr_accessor :sst
+
+    # Whether U3's PB7, its timer's interrupt, is wired to IRQ.
+    attr_accessor :irq_wired
+
+    # The 1 MHz clock. With no video, a frame is nominal: 64 by 260
+    # cycles, some 60 a second.
+    TIMING = Timing.new(clock_hz: 1_000_000, cycles_per_line: 64, lines_per_frame: 260, crop: [0, 0, 0, 0],
+                        pixel_width: 1, dots: 1)
+
+    def family = :kim1
+
+    def ram = @bus.ram
+
+    # Reads and writes memory as the CPU sees it, through the bus.
+    def peek(addr) = @bus.peek(addr)
+
+    def poke(addr, value) = @bus.poke(addr, value)
+
+    # With +tty+ the TTY/KB jumper is fitted, and the monitor talks to a
+    # teletype at +baud+ (Teletype::BAUDS) in place of the keypad and
+    # display. +ram+ names the RAM, one of Bus::RAM_CONFIGURATIONS, or
+    # nil for the stock 1K.
+    def initialize(tty: false, baud: 9600, ram: nil)
+      @cycles = 0
+      @panel = Panel.new(self)
+      @panel.tty = tty
+      @u2 = MonitorRRIOT.new(rom: ROM.read("kim1/6530-002.rom"), peripheral: @panel)
+      @u3 = UserRRIOT.new(rom: ROM.read("kim1/6530-003.rom"))
+      @panel.connect(@u2)
+      @bus = Bus.new(@u2, @u3, ram: ram || :"1k")
+      @cpu = CPU.new(@bus)
+      @sst = false
+      @irq_wired = false
+      @sound = Sound.new(@u2, @u3)
+      @teletype = Teletype.new(@panel, baud:)
+      @teletype.reset!(0) if tty
+      @init_handlers = []
+      @init_threshold = BOOT_CYCLES
+      @pending_keys = nil
+      @key_down = false
+      @next_key_at = 0
+    end
+
+    # Whether the TTY/KB jumper is fitted.
+    def tty? = @panel.tty
+
+    # Fits or takes out the TTY/KB jumper.
+    def tty=(fitted)
+      @panel.tty = fitted
+    end
+
+    def timing = TIMING
+
+    # Types `text` on the teletype with the jumper fitted, and otherwise
+    # presses the keys it names (KeyEntry#type_keys).
+    def type_text(text)
+      return type_keys(text) unless @panel.tty
+
+      @teletype.type(text)
+    end
+
+    # What the teletype has printed: #output holds it all.
+    def capture_output = @teletype
+
+    # What a front end plays: U2's PB7 or the speaker (Sound), which
+    # answers #record and #drain_samples.
+    def sound_source = @sound
+
+    # Whether the speaker on U3's PA0 is wired, and plays in place of PB7.
+    def speaker? = @sound.speaker
+
+    def speaker=(wired)
+      @sound.speaker = wired
+    end
+
+    # The machine as the pause menu names it.
+    def model_label = "KIM-1, #{ram_kb}K RAM"
+
+    # The RAM in K (Bus#ram_kb).
+    def ram_kb = @bus.ram_kb
+
+    # No drive plugs into the KIM-1, and nothing is mounted.
+    def true_drive = nil
+
+    def mounted? = false
+
+    def mounted_path = ""
+
+    # The 6530s count ahead of the CPU. With SST on, the board pulls NMI
+    # ahead of an opcode fetch outside the monitor.
+    def cycle!
+      handle_init if @cycles == @init_threshold
+      feed_keys unless @pending_keys.nil?
+
+      @u2.cycle!
+      @u3.cycle!
+      @sound.cycle! if @sound.recording?
+      @teletype.cycle!(@cycles, @u2.port_b_output.anybits?(0x01) && @teletype.line_high?) if @panel.tty
+      @cpu.irq = @irq_wired && @u3.irq?
+      @cpu.single_step if @sst
+      @cpu.cycle!
+
+      @cycles += 1
+    end
+
+    # RS: the RST line resets the CPU and both 6530s. RAM keeps what it
+    # holds. A teletype then sends RUBOUT for the monitor to time.
+    def reset!
+      @u2.reset!
+      @u3.reset!
+      @cpu.reset!
+      @teletype.reset!(@cycles) if @panel.tty
+    end
+
+    alias press_reset reset!
+
+    # Switches the machine off and on: RAM starts cleared, and RS resets
+    # everything else.
+    def power_cycle!
+      @bus.power_on!
+      reset!
+    end
+
+    # ST: an edge on NMI.
+    def press_stop
+      @cpu.nmi = true
+    end
+
+    # Holds down the key Panel::KEYS names `name`.
+    def press_key(name)
+      @panel.press(name)
+    end
+
+    def release_key
+      @panel.release
+    end
+
+    # The segments each LED digit shows (Panel#display).
+    def display = @panel.display
+
+    # The display as text, such as "0200 A9" (Panel#display_text).
+    def display_text = @panel.display_text
+
+    # The cassette deck on U2's PB7.
+    def tape = @panel.tape
+  end
+end
+
+require "badline/snapshot/kim1_setup"
+require "badline/kim1/keyed_state"
+require "badline/kim1/keyed_modules"

data/lib/badline/machine/ieee_drives.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+require "badline/drives/ieee_models"
+require "badline/drives/model2031"
+require "badline/drives/model8050"
+require "badline/drives/model9060"
+require "badline/drives/model1001"
+require "badline/drives/model4040"
+
+module Badline
+  module Machine
+    # A machine's true drive on its IEEE-488 bus, one at a time, of a model
+    # Drives::IEEEModels names: a Drives::Model2031, Model8050, Model8250,
+    # Model1001, Model4040, Model3040, Model2040, Model9060 or Model9090. It
+    # is clocked after the CPU each cycle at the machine's clock
+    # (ieee_host_clock_hz) and reset with it, as the machine's RES line
+    # reaches IFC. The traps on the KERNAL's primitives leave device 8 to
+    # the drive while it is device 8 (trap_device). The PET (PET::IEEEDrive) and the CBM-II
+    # (CBM2::IEEEDrive) include it.
+    #
+    # The machine's @ieee is its side of the bus: #bus, the
+    # Drives::IEEEBus, #push_lines, which shows the drives the lines the
+    # machine pulls now, and #cycle_lines, which does so once a cycle if
+    # the machine doesn't push them as its chips are written.
+    module IEEEDrives
+      # The true drive on the bus, or nil.
+      attr_reader :true_drive
+
+      # The model plug_true_drive plugs in, one Drives::IEEEModels names.
+      attr_reader :true_drive_model
+
+      # Plugs in the drive, in place of the drive there.
+      def attach_ieee_drive(drive)
+        detach_ieee_drive
+        drive.host_clock_hz = ieee_host_clock_hz
+        drive.connect(@ieee.bus)
+        @ieee.push_lines
+        @true_drive = drive
+        @ieee_trap&.device = trap_device
+        @init_threshold = [@init_threshold, drive.boot_cycles].max if @cycles < @init_threshold
+      end
+
+      # Unplugs the true drive, leaving it on a bus of its own.
+      def detach_ieee_drive
+        drive = @true_drive
+        return unless drive
+
+        drive.connect(Badline::Drives::IEEEBus.new)
+        @true_drive = nil
+        @ieee_trap&.device = trap_device
+      end
+
+      # Plugs in the model as +device+, in place of the drive there, and
+      # returns it.
+      def plug_ieee_drive(model, device: 8)
+        build_ieee_drive(model, device).tap { |drive| attach_ieee_drive(drive) }
+      end
+
+      # The drive of a dual unit a disk image given on its own goes in
+      # (Media::TrueDrive): drive 0.
+      def disk_drive_number = 0
+
+      # Plugs in the model true_drive_model names as device 8, in place of
+      # the drive there, and returns it.
+      def plug_true_drive = plug_ieee_drive(@true_drive_model)
+
+      # Settles for a snapshot, then runs on until the true drive is where
+      # VICE saves it (the drive's settled_for_vice?) between instructions
+      # with the machine's, or for so many cycles, then on to the machine's
+      # next instruction. It stands in for Machine::Settling's, which the
+      # machines include first.
+      def settle_for_vice!
+        ran = settle_for_snapshot!
+        drive = @true_drive
+        return ran if drive.nil?
+
+        until ran >= Machine::Settling::LIMIT || (drive.settled_for_vice? && settled_for_snapshot?)
+          cycle!
+          ran += 1
+        end
+        ran + settle_for_snapshot!
+      end
+
+      private
+
+      def init_ieee_drives(true_drive_model)
+        unless Badline::Drives::IEEEModels::NAMES.include?(true_drive_model)
+          raise ArgumentError, "no true drive model #{true_drive_model} for the IEEE-488 bus"
+        end
+
+        @true_drive_model = true_drive_model
+        @true_drive = nil
+      end
+
+      # A new drive of the model as +device+.
+      def build_ieee_drive(model, device)
+        case model
+        when "8050" then Badline::Drives::Model8050.new(device:)
+        when "8250" then Badline::Drives::Model8250.new(device:)
+        when "1001" then Badline::Drives::Model1001.new(device:)
+        when "4040" then Badline::Drives::Model4040.new(device:)
+        when "3040" then Badline::Drives::Model3040.new(device:)
+        when "2040" then Badline::Drives::Model2040.new(device:)
+        when "9060" then Badline::Drives::Model9060.new(device:)
+        when "9090" then Badline::Drives::Model9090.new(device:)
+        else Badline::Drives::Model2031.new(device:)
+        end
+      end
+
+      # The true drive's cycles for one of the machine's, after the lines
+      # it pulls.
+      def clock_ieee_drives
+        drive = @true_drive
+        return unless drive
+
+        @ieee.cycle_lines
+        drive.host_cycle!
+      end
+
+      # The RES line reaches the true drive as IFC.
+      def reset_ieee_drives
+        @true_drive&.reset!
+      end
+
+      def save_ieee_drive_fields(out)
+        out.text("host.ieee_drive_model", @true_drive_model)
+      end
+
+      def load_ieee_drive_fields(input)
+        @true_drive_model = input.choice("host.ieee_drive_model", Badline::Drives::IEEEModels::NAMES,
+                                         @true_drive_model)
+      end
+
+      # The true drive as keyed snapshot modules named from its device
+      # number: BL-D8, BL-D8-CPU and so on for device 8.
+      def save_drive_modules(sections)
+        drive = @true_drive
+        drive&.save_modules(sections, "BL-D#{drive.device}")
+        sections
+      end
+
+      # The true drive a snapshot's modules hold, of the model they name,
+      # built afresh unless the same model is on the bus as the same
+      # device, or none when they hold no drive. The bus then carries the
+      # machine's lines as its chips left them.
+      def load_drive_modules(modules)
+        device = 8
+        input = modules.optional("BL-D8")
+        while input.nil? && device < 15
+          device += 1
+          input = modules.optional("BL-D#{device}")
+        end
+        if input
+          load_ieee_drive_modules(modules, input, device)
+        else
+          detach_ieee_drive
+        end
+        @ieee.push_lines
+      end
+
+      def load_ieee_drive_modules(modules, input, device)
+        model = input.text("model", Badline::Drives::IEEEModels::DEFAULT)
+        model = Badline::Drives::IEEEModels::DEFAULT unless Badline::Drives::IEEEModels::NAMES.include?(model)
+        drive = @true_drive
+        detach_ieee_drive if drive && (drive.device != device || drive.model_name != model)
+        drive = @true_drive || plug_ieee_drive(model, device:)
+        drive.load_modules(modules, input, "BL-D#{device}")
+      end
+    end
+  end
+end

data/lib/badline/machine/keyboard_buffer.rb

@@ -28,13 +28,30 @@ module Badline
       # The PET's under BASIC 1, outside the zero page.
       PET_BASIC1_LAYOUT = Layout.new(address: 0x020f, count: 0x020d, capacity: 10)
 
-      def type_text(text)
-        codes = text.bytes.map { |b| ascii_to_petscii(b) }
-        on_init { @pending_keys = codes }
+      def type_text(text) = type_on_init(text.bytes.map { |b| ascii_to_petscii(b) })
+
+      # The keys type_text left for the KERNAL to boot first, under
+      # host.init_keys, so that a machine restored before then types them.
+      def save_init_keys(out)
+        keys = @init_keys
+        out.ints("host.init_keys", keys) if keys
+      end
+
+      def load_init_keys(input)
+        keys = input.ints("host.init_keys", [])
+        type_on_init(keys.dup) unless keys.empty?
       end
 
       private
 
+      def type_on_init(codes)
+        @init_keys = codes if booting?
+        on_init do
+          @init_keys = nil
+          @pending_keys = codes
+        end
+      end
+
       def feed_keyboard
         buffer = keyboard_buffer
         return unless ram.peek(buffer.count).zero?

data/lib/badline/machine/line_sound.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module Badline
+  module Machine
+    # The sound of one logic line a machine drives into its speaker or
+    # audio output, such as the PET's CB2 or the KIM-1's PB7. The class
+    # that includes it answers #line_high?, the line's level this cycle.
+    #
+    # The machine calls #cycle! once a cycle while #recording?, from #record
+    # on, so a sound nobody records costs only that check. Each sample is
+    # the share of its cycles the line spent high, through the output
+    # stage: a one-pole low-pass at 5 kHz and a one-pole high-pass at
+    # 100 Hz, so a line left high or low settles to silence.
+    module LineSound
+      LOW_PASS_HZ = 5_000
+      HIGH_PASS_HZ = 100
+
+      # A swing from the line low to the line high, as a signed 16-bit
+      # sample.
+      SCALE = 24_000.0
+
+      attr_reader :recording
+      alias recording? recording
+
+      # Starts collecting the output, averaged down to `rate` samples a
+      # second at `clock_hz` cycles a second, for #drain_samples. The
+      # output stage takes the line's level now as settled.
+      def record(rate:, clock_hz: 1_000_000)
+        @rate = rate
+        @clock_hz = clock_hz
+        @remainder = 0
+        @window = next_window
+        @left = @window
+        @sum = 0
+        @high = line_high?
+        @run = 0
+        @low = @drift = @high ? 1.0 : 0.0
+        @low_pass = 1.0 - Math.exp(-2.0 * Math::PI * LOW_PASS_HZ / rate)
+        @high_pass = 1.0 - Math.exp(-2.0 * Math::PI * HIGH_PASS_HZ / rate)
+        @samples = []
+        @recording = true
+      end
+
+      # Takes the line's level for this cycle, while recording.
+      def cycle!
+        high = line_high?
+        if high == @high
+          @run += 1
+        else
+          hold(@high, @run)
+          @high = high
+          @run = 1
+        end
+      end
+
+      # The samples closed since the last drain.
+      def drain_samples
+        return [] unless @recording
+
+        hold(@high, @run)
+        @run = 0
+        samples = @samples
+        @samples = []
+        samples
+      end
+
+      private
+
+      def init_line_sound
+        @recording = false
+        @high = true
+        @run = 0
+        @rate = 0
+        @clock_hz = 0
+        @remainder = 0
+        @window = 0
+        @left = 0
+        @sum = 0
+        @low = 0.0
+        @drift = 0.0
+        @low_pass = 0.0
+        @high_pass = 0.0
+        @samples = []
+      end
+
+      # Adds `cycles` cycles with the line high or low, closing every
+      # sample they finish.
+      def hold(high, cycles)
+        left = @left
+        while cycles >= left
+          @sum += left if high
+          cycles -= left
+          close
+          left = @left
+        end
+        @sum += cycles if high
+        @left = left - cycles
+      end
+
+      def close
+        @low += @low_pass * (@sum.fdiv(@window) - @low)
+        @drift += @high_pass * (@low - @drift)
+        sample = ((@low - @drift) * SCALE).round
+        sample = 32_767 if sample > 32_767
+        sample = -32_768 if sample < -32_768
+        @samples << sample
+        @sum = 0
+        @window = next_window
+        @left = @window
+      end
+
+      # Each window is a whole number of cycles, and they add up to the
+      # clock's cycles over a second.
+      def next_window
+        @remainder += @clock_hz
+        cycles = @remainder / @rate
+        @remainder -= cycles * @rate
+        cycles
+      end
+    end
+  end
+end

data/lib/badline/machine/settling.rb

@@ -24,6 +24,10 @@ module Badline
         settle_chips_for_snapshot
         ran
       end
+
+      # Settles as #settle_for_snapshot! does, for a snapshot VICE opens,
+      # which a machine with a drive VICE runs settles further.
+      def settle_for_vice! = settle_for_snapshot!
     end
   end
 end

data/lib/badline/machine.rb

@@ -2,6 +2,7 @@
 
 require "badline/machine/clocking"
 require "badline/machine/keyboard_buffer"
+require "badline/machine/line_sound"
 require "badline/machine/settling"
 
 module Badline
@@ -58,6 +59,11 @@ module Badline
   # and +capture_output+, and besides +model_label+, +cartridge_slots+ and
   # +detach_cartridges+ for its two cartridges.
   #
+  # The KIM-1 answers the identity, clocking, lifecycle and sound parts,
+  # with no video chip: a front end draws its panel (KIM1::Panel), and
+  # #true_drive is nil. Its keys are the panel's, through +press_key+,
+  # +release_key+, +type_keys+, +press_stop+ and +press_reset+.
+  #
   # The PET answers the identity, clocking, lifecycle, video, sound and
   # keyboard parts, with no joysticks, RESTORE or control ports, and of
   # the rest +ram+, +load_prg+, +type_text+, +mount+, +unmount+,
@@ -69,20 +75,28 @@ module Badline
     # Media the machine named doesn't take.
     class Unsupported < ArgumentError; end
 
-    # A new machine of `family`, :c64, :vic20, :c128, :plus4 or :pet, the
-    # model of it `model` names. A C64's model is one of Model::ALL, with its SID
-    # `sid_model` when not nil and an REU of `reu` K when not nil. A
-    # VIC-20's is "pal", with the RAM expansion `ram` names
+    # A new machine of `family`, :c64, :vic20, :c128, :plus4, :pet, :cbm2 or :kim1, the
+    # model of it `model` names. A C64's model is one of Model::ALL, with
+    # its SID `sid_model` when not nil and an REU of `reu` K when not nil.
+    # A VIC-20's is "pal" or "ntsc", with the RAM expansion `ram` names
     # (Vic20::Bus::RAM_CONFIGURATIONS), unexpanded when nil. A C128's is
     # one of C128::Model::ALL, with its SID `sid_model` when not nil, built
     # for C64 mode. A Plus/4's is one of Plus4::Model::ALL or c116, with
     # the model's own RAM. A PET's is one of PET::Model::ALL, with its own
-    # RAM and ROMs, its CRTC's editor the 50 Hz one.
+    # RAM and ROMs, its CRTC's editor the 50 Hz one, the superpet a
+    # PET::SuperPET with its CPU switch at 6502. A CBM-II's is one of
+    # CBM2::Model::ALL, with VICE's KERNAL, 901244-04a, at 50 Hz, or a 510,
+    # one of CBM2::P500::Model::ALL, with its region's mains. A KIM-1 is
+    # the one model, with the RAM `ram` names
+    # (KIM1::Bus::RAM_CONFIGURATIONS), 1K when nil.
     def self.build(family, model:, sid_model: nil, reu: nil, ram: nil)
+      return KIM1.new(ram:) if family == :kim1
       return vic20(model, ram) if family == :vic20
       return c128(model, sid_model, :c64) if family == :c128
       return Plus4.new(model:) if family == :plus4
-      return PET.new(model:) if family == :pet
+      return model == "superpet" ? PET::SuperPET.new : PET.new(model:) if family == :pet
+      return CBM2::P500.new(model:) if family == :cbm2 && model.start_with?("510")
+      return CBM2.new(model:) if family == :cbm2
       raise ArgumentError, "no machine family named #{family}" unless family == :c64
 
       profile = Model.named(model)
@@ -98,12 +112,15 @@ module Badline
     # only C64 mode runs: a .sid tune or a program that loads at the C64's
     # BASIC start. A VIC-20 without RAM named gets the expansion the media
     # needs (Media::Vic20Media.ram_for) and yields a line saying so. Raises
-    # Unsupported for media a VIC-20, a Plus/4 or a PET doesn't take.
+    # Unsupported for media a VIC-20, a Plus/4, a PET or a CBM-II doesn't
+    # take.
     def self.for_options(options, media, &)
       family = options.family
       return vic20_for(media, options.model, options.ram, &) if family == :vic20
       return plus4_for(media, options) if family == :plus4
       return pet_for(media, options) if family == :pet
+      return cbm2_for(media, options) if family == :cbm2
+      return kim1_for(media, options) if family == :kim1
 
       sid_model = options.sid_model || Media.sid_model(media, otherwise: nil)
       return build(:c64, model: options.model, sid_model:, reu: options.reu) unless family == :c128
@@ -113,11 +130,7 @@ module Badline
       machine
     end
 
-    def self.vic20(model, ram)
-      raise ArgumentError, "no VIC-20 model named #{model}" unless model == "pal"
-
-      Vic20.new(ram: ram || :unexpanded)
-    end
+    def self.vic20(model, ram) = Vic20.new(ram: ram || :unexpanded, model:)
     private_class_method :vic20
 
     def self.c128(model, sid_model, mode) = C128.new(model:, sid_model:, mode:)
@@ -154,16 +167,51 @@ module Badline
     # A PET with the RAM --ram names (PET::Model::RAM_SIZES), or with the
     # model's own without it, the editor at the frame rate --60hz or
     # --editor asks for, the ROMs --basic, --editor and --characters fit it
-    # with, and the 8296 board's jumpers --jumpers names.
+    # with, the 8296 board's jumpers --jumpers names, and the true drive
+    # --drive-type names. The SuperPET takes the frame rate, the 8032's
+    # BASIC and editors, the true drive, the CPU --cpu names and the bank
+    # RAM switch --bank-ram sets, and with the 6809 disks alone.
     def self.pet_for(media, options)
       unsupported = !media.nil? && Media::PETMedia::UNSUPPORTED.include?(File.extname(media).downcase)
       raise Unsupported, "doesn't go in a PET" if unsupported
 
+      if options.model == "superpet"
+        disk = media.nil? || File.directory?(media) || %i[disk ieee_disk].include?(Media::Extensions.kind(media))
+        raise Unsupported, "doesn't go in the SuperPET's 6809 side" unless disk || options.cpu == "6502"
+
+        return PET::SuperPET.new(refresh_hz: options.refresh_hz, basic: options.basic, editor: options.editor,
+                                 cpu: options.cpu, bank_ram: options.bank_ram, true_drive_model: options.drive_type)
+      end
+
       PET.new(model: options.model, ram_kb: options.ram_kb, refresh_hz: options.refresh_hz, basic: options.basic,
-              editor: options.editor, characters: options.characters, jumpers: options.jumpers)
+              editor: options.editor, characters: options.characters, jumpers: options.jumpers,
+              true_drive_model: options.drive_type)
     end
     private_class_method :pet_for
 
+    # A CBM-II with the KERNAL --kernal names, on the mains --60hz asks
+    # for: a B series' 50 Hz without it, and a P500's its region's, and
+    # the true drive --drive-type names.
+    def self.cbm2_for(media, options)
+      unsupported = !media.nil? && Media::CBM2Media::UNSUPPORTED.include?(File.extname(media).downcase)
+      raise Unsupported, "doesn't go in a CBM-II" if unsupported
+
+      drive = options.drive_type
+      return CBM2::P500.new(model: options.model, mains_hz: options.mains_hz, true_drive_model: drive) if options.p500?
+
+      CBM2.new(model: options.model, kernal: options.kernal, mains_hz: options.mains_hz || 50, true_drive_model: drive)
+    end
+    private_class_method :cbm2_for
+
+    # A KIM-1 with the RAM --ram names, on a teletype at --baud with
+    # --tty, for media it takes (Media::KIM1Media).
+    def self.kim1_for(media, options)
+      raise Unsupported, "doesn't go in a KIM-1" unless media.nil? || Media::KIM1Media.takes?(media)
+
+      KIM1.new(tty: options.tty?, baud: options.baud, ram: options.ram)
+    end
+    private_class_method :kim1_for
+
     def self.c64_media?(media)
       return false if media.nil? || !File.file?(media)
 

data/lib/badline/media/cbm2_media.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Badline
+  module Media
+    # What a CBM-II does with media of its own (Media.attach). Disks of
+    # every kind, .d80 and .d82 among them, directories and .t64 archives
+    # mount on device 8 through the traps on the KERNAL's IEEE-488
+    # primitives (CBM2::IEEETraps), programs load into BASIC's text segment
+    # (Program), and a CBM2 .crt's ROMs go in at their load addresses in
+    # segment 15. There is no datasette, the SID plays no .sid tunes, and
+    # the true drives are serial ones.
+    module CBM2Media
+      # What a CBM-II doesn't take.
+      UNSUPPORTED = Extensions.of(%i[tune tape gcr])
+
+      # What loads and runs the first program on the disk in device 8.
+      AUTOSTART = %(load"*",8\rrun\r)
+
+      # Where BASIC's text starts in segment 1, and the pointers to its end
+      # and to the KERNAL's end address (EAL) in segment 15.
+      BASIC_START = 0x0003
+      TEXT_END = 0x2f
+      EAL = 0x96
+
+      # The ROM chips of a CBM2 .crt.
+      def self.cartridge_chips(path) = Storage::CRTFile.new(path, machine: :cbm2).chips
+    end
+  end
+end