badline 0.15.0 → 0.15.1

data/lib/badline/drives/model1551/tia.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Badline
+  module Drives
+    class Model1551
+      # The drive's 6523 TIA at $4000-$7FFF, its eight registers mirrored
+      # (zimmers.net's 1551 memory map, schematic 251860), a Chips::TIA
+      # with what the drive's side wires to it:
+      #
+      # - Port A carries the cable's eight data lines, pulled up.
+      # - Port B reads the GCR byte the gate array latched at BYTE READY
+      #   and drives the byte the head writes.
+      # - Port C drives STATUS0 and STATUS1 (PC0-1), DEV (PC2), which picks
+      #   where the computer's TIA answers, ACK (PC3) and the head's MODE
+      #   (PC4, low to write), and reads the device number jumper (PC5,
+      #   high for device 9), SYNC (PC6, low in a SYNC mark) and DAV (PC7).
+      #
+      # The DOS sets port C's directions to $1F. The cable's lines are
+      # pulled up, so an input nothing drives reads 1.
+      #
+      # Any access to the TIA clears BYTE LATCHED.
+      class TIA
+        DAV = 0x80
+        SYNC = 0x40
+        JUMPER = 0x20
+        MODE = 0x10
+
+        # The chip, whose inputs the drive's side sets before each read.
+        attr_reader :chip
+
+        def initialize(mechanism, device:)
+          @mechanism = mechanism
+          @jumper = device == 9 ? JUMPER : 0
+          @chip = Chips::TIA.new
+          inputs = @chip.inputs
+          inputs[0] = 0xff
+          inputs[1] = 0xff
+          inputs[2] = 0xff
+          mechanism.tia = self
+          mode_written
+        end
+
+        def ports = @chip.ports
+
+        def directions = @chip.directions
+
+        def inputs = @chip.inputs
+
+        def reset!
+          @chip.reset!
+          mode_written
+        end
+
+        def peek(addr)
+          mechanism = @mechanism
+          mechanism.release_byte_latch
+          chip = @chip
+          inputs = chip.inputs
+          case addr & 0x07
+          when 1 then inputs[1] = mechanism.latched_byte
+          when 2 then inputs[2] = (inputs[2] & DAV) | (mechanism.sync? ? 0 : SYNC) | @jumper | 0x1f
+          end
+          chip.peek(addr)
+        end
+
+        def poke(addr, value)
+          @mechanism.release_byte_latch
+          @chip.poke(addr, value)
+          register = addr & 0x07
+          mode_written if [2, 5].include?(register)
+        end
+
+        # What port B drives onto the head's write shift register.
+        def port_b_output = @chip.output(1)
+
+        # The chip's registers, in a keyed snapshot module (BL-D8-TIA).
+        def save_fields(out) = @chip.save_fields(out)
+
+        def load_fields(input)
+          @chip.load_fields(input)
+        end
+
+        private
+
+        # MODE selects reading while high, as the 1541's CB2 does.
+        def mode_written
+          @mechanism.cb2_written(@chip.output(2).anybits?(MODE))
+        end
+      end
+    end
+  end
+end

data/lib/badline/drives/model1551.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+require "badline/chips/tia"
+require "badline/drives/model1541"
+require "badline/drives/model1551/cpu"
+require "badline/drives/model1551/port"
+require "badline/drives/model1551/tia"
+require "badline/drives/model1551/bus"
+require "badline/drives/model1551/cable"
+require "badline/drives/model1551/keyed_state"
+
+module Badline
+  module Drives
+    # The 1551 disk drive of the 264 series: a 6510T at 2 MHz running DOS
+    # 2.6 from 16 KB of ROM, with 2 KB of RAM, the 1541's GCR mechanism
+    # behind a gate array, and a 6523 TIA facing the computer over TCBM, a
+    # parallel cable to a second 6523 in the computer's expansion port
+    # (Commodore schematic 251860; zimmers.net's 1551 memory map).
+    #
+    # The 6510T's port drives the mechanism as the 1541's VIA 2 port B does
+    # and reads the write-protect sensor and the gate array's BYTE LATCHED
+    # (Port). The TIA's port B reads the GCR byte the gate array latched and
+    # drives the byte to write, and its port C selects reading or writing
+    # and reads SYNC (TIA).
+    #
+    # The drive comes with its interface for the computer's expansion port,
+    # a second 6523 (#host_tia), which the cable joins to the drive's
+    # (Cable). The computer puts it at $FEE0 for device 8 and at $FEC0 for
+    # device 9.
+    #
+    # A 555 timer pulls IRQ low for about 7 µs every 8.3 ms, its R1 120K,
+    # R2 100R and C1 0.1 µF, which runs the DOS's job loop. Nothing
+    # acknowledges it: the line lets go on its own.
+    #
+    # Drives::Engine::Core clocks it against the host and sleeps through
+    # the DOS's idle loop, which counts its passes in $61 (Engine::Idle's
+    # pass counter), until the 555 is due to pull IRQ, the count wraps or
+    # the computer moves the cable's lines.
+    class Model1551
+      include Engine::Core
+
+      CLOCK_HZ = 2_000_000
+
+      # The 555's cycle in drive cycles: high for 0.693 (R1 + R2) C and low,
+      # pulling IRQ, for 0.693 R2 C.
+      IRQ_PERIOD = 16_660
+      IRQ_LOW = 14
+
+      # The host cycles, at about 1 MHz, by which a 1551 switched on with the
+      # machine has run its DOS's reset, the RAM test and the ROM checksum,
+      # and answers TCBM: half a second, with a margin.
+      BOOT_CYCLES = 600_000
+
+      # Where the DOS's idle loop starts over, polling the TIA's port A for
+      # a command from the computer.
+      IDLE_LOOP = 0xeabd
+
+      # The byte the idle loop increments on each pass.
+      PASS_COUNTER = 0x61
+
+      def port
+        settle!
+        @port
+      end
+
+      def tia
+        settle!
+        @tia
+      end
+
+      # The TIA in the computer's expansion port, which the computer reads
+      # and writes without waking the drive.
+      attr_reader :host_tia
+
+      # The cable between the two TIAs.
+      def cable
+        settle!
+        @cable
+      end
+
+      def model_name = "1551"
+
+      # +rom+ covers $C000-$FFFF, and defaults to the DOS image in the ROM
+      # path. +device+ is 8 or 9, as the jumper on the TIA's PC5 sets it.
+      def initialize(rom: nil, host_clock_hz: CLOCK_HZ, device: 8, debug: false)
+        raise ArgumentError, "a 1551 is device 8 or 9, not #{device}" unless [8, 9].include?(device)
+
+        @device = device
+        @clock_hz = CLOCK_HZ
+        @mechanism = Model1541::Mechanism.new
+        @mechanism.clock_hz = CLOCK_HZ
+        @port = Port.new(@mechanism)
+        @tia = TIA.new(@mechanism, device:)
+        @host_tia = Chips::TIA.new
+        @bus = Bus.new(rom: rom || ROM.load("dos1551.rom", 0xc000), port: @port, tia: @tia)
+        @cpu = CPU.new(@bus, debug:)
+        @idle_loop = IDLE_LOOP
+        @host_clock_hz = host_clock_hz
+        @phase = 0
+        @cycles = 0
+        @irq_timer = IRQ_PERIOD
+        init_idle(debug)
+        @pass_counter = PASS_COUNTER
+        @cable = Cable.new(@host_tia, @tia.chip, self)
+        @serial_port = @cable
+      end
+
+      # Puts in a Disk from the .d64 or .g64 image at +path+, write-protected
+      # with `read_only`.
+      def insert_image(path, read_only: false)
+        insert(Model1541::Disk.open(path, read_only:))
+      end
+
+      # The computer's RESET line reaches the interface's TIA and, through
+      # the cable, the CPU, its port and the drive's TIA. RAM keeps its
+      # contents, and the 555 runs on.
+      def reset!
+        settle!
+        @host_tia.reset!
+        @port.reset!
+        @tia.reset!
+        @cpu.reset!
+      end
+
+      private
+
+      # One drive cycle: the mechanism turns the disk ahead of the CPU, and
+      # the 555 pulls IRQ while its output is low.
+      def step
+        @mechanism.cycle!
+        timer = @irq_timer - 1
+        timer = IRQ_PERIOD if timer.zero?
+        @irq_timer = timer
+        @cpu.irq = timer <= IRQ_LOW
+        @cpu.cycle!
+        @cycles += 1
+      end
+
+      # A pass of the idle loop reads the TIA's port A, which holds still
+      # until the computer moves the cable's lines, and RAM. It repeats
+      # while the motor is off and the 555 leaves IRQ alone, for as long as
+      # the 555 leaves room (see Engine::Idle).
+      def busy_for_pass? = @mechanism.motor_on? || @irq_timer <= IRQ_LOW
+
+      def quiet_cycles
+        quiet = @irq_timer - IRQ_LOW - 1
+        quiet.negative? ? 0 : quiet
+      end
+
+      def idle_state
+        chip = @tia.chip
+        [*@cpu.counting_state, @bus.data, *@mechanism.idle_state, *chip.ports, *chip.directions, *chip.inputs,
+         @port.ddr, @port.data]
+      end
+
+      def fast_forward_chips(cycles)
+        @irq_timer -= cycles
+      end
+
+      # Every 555 pulse runs the job loop, which reads the port and the TIA,
+      # so no orbit (Engine::Orbit) comes round, and the drive keeps no
+      # anchors.
+      def anchor = nil
+
+      def counter_state(_touched) = []
+
+      def skip_chip_orbits(_cycles, _touched) = nil
+    end
+  end
+end

data/lib/badline/drives/model1571.rb

@@ -26,6 +26,7 @@ module Badline
     # (CIA#quiet?).
     class Model1571
       include Engine::Core
+      include Engine::SerialConnection
       include Engine::VIAs
       include Engine::FastSerial
 

data/lib/badline/drives/model1581.rb

@@ -39,6 +39,7 @@ module Badline
     # on either chip: the drive's CIA gets no TOD pulses (CIA's tod_hz).
     class Model1581
       include Engine::Core
+      include Engine::SerialConnection
       include Engine::FastSerial
 
       CLOCK_HZ = 2_000_000

data/lib/badline/frontend/boot.rb

@@ -17,7 +17,11 @@ module Badline
       end
 
       computer = nil
-      problem = media_problem { computer = boot(options) }
+      problem = if cartridge?(options)
+                  cartridge_problem { computer = boot(options) }
+                else
+                  media_problem { computer = boot(options) }
+                end
       unless problem.empty?
         warn "#{options.program}: #{options.media_path}: #{problem}"
         return 1
@@ -40,6 +44,21 @@ module Badline
       e.message
     end
 
+    # Runs the block that puts a cartridge in, as media_problem does, and
+    # also returns the message of the ArgumentError a machine raises over a
+    # cartridge with a chip in a bank or slot it doesn't map.
+    def self.cartridge_problem(&)
+      media_problem(&)
+    rescue ArgumentError => e
+      e.message
+    end
+
+    # Whether the media the options start is a .crt.
+    def self.cartridge?(options)
+      media = options.media_path
+      !media.nil? && Media::Extensions.kind(media) == :cartridge
+    end
+
     # The machine a .vsf snapshot holds, built as the saved one was, or a
     # new one built from the options with the media attached.
     def self.boot(options)

data/lib/badline/frontend/menu/menu_dialogs.rb

@@ -37,7 +37,11 @@ module Badline
       # :program, or :snapshot, which starts in the saves folder.
       def browse(kind)
         @browsing = kind
-        extensions = kind == :cartridge ? @media.cartridge_extensions : EXTENSIONS.fetch(kind)
+        extensions = case kind
+                     when :cartridge then @media.cartridge_extensions
+                     when :program then programs
+                     else EXTENSIONS.fetch(kind)
+                     end
         @browser.open(kind == :snapshot ? Badline.data_folder("saves") : @browse_from, extensions)
       end
 
@@ -56,15 +60,15 @@ module Badline
       def ask_remove = @confirmation.ask(:remove, @media.cartridge_name)
 
       # Puts a dropped disk or tape in its device, or asks before a
-      # cartridge or a program starts, and says whether it asks. Other
-      # files are left alone.
+      # cartridge, a Plus/4's raw ROM image among them, or a program
+      # starts, and says whether it asks. Other files are left alone.
       def drop(path)
         extension = File.extname(path).downcase
         return @media.insert(:disk, path) && false if EXTENSIONS[:disk].include?(extension)
         return @media.insert(:tape, path) && false if EXTENSIONS[:tape].include?(extension)
-        return false unless EXTENSIONS[:program].include?(extension)
+        return false unless programs.include?(extension)
 
-        @confirmation.ask(extension == ".crt" ? :cartridge : :start, path)
+        @confirmation.ask(@media.cartridge_extensions.include?(extension) ? :cartridge : :start, path)
         true
       end
 
@@ -98,6 +102,10 @@ module Badline
 
       private
 
+      # What Quick open and a drop start: every medium, and the cartridges
+      # the machine takes.
+      def programs = (EXTENSIONS[:program] + @media.cartridge_extensions).uniq
+
       # Puts the disk or tape picked in, or asks before a cartridge or
       # Quick open power cycles the machine, and leaves the browser, as Esc
       # does.

data/lib/badline/frontend/menu/menu_media.rb

@@ -10,17 +10,29 @@ module Badline
     # wrong for the page to show.
     class MenuMedia
       attr_reader :problem
-      attr_writer :computer
 
       # Takes the disk set from the command line's `media_path` when it's a
-      # list.
-      def initialize(media_path, writable)
+      # list, and the names of the cartridges it and `cartridges`, the
+      # Plus/4's ROM images by slot (Options#cartridges), put in the first
+      # machine.
+      def initialize(media_path, writable, cartridges)
         @list = Media::DiskList.list?(media_path) ? media_path : ""
         @writable = writable
         @set_path = ""
         @set = []
         @problem = ""
         @computer = nil
+        @command_line = cartridges.map { |slot, path| [slot, path] } + [["", media_path]]
+        @names = {}
+        @named = nil
+      end
+
+      def computer=(computer)
+        @computer = computer
+        return unless @named.nil?
+
+        @command_line.each { |slot, path| note_cartridge(computer, path.dup, slot) }
+        @named = computer
       end
 
       def writable? = @writable
@@ -97,7 +109,9 @@ module Badline
       # Swaps the cartridge for the one at `path`, which power cycles the
       # machine, and says whether it went in.
       def attach_cartridge(path)
-        succeeds? { Media.attach(@computer, path) }
+        attached = cartridge_succeeds? { Media.attach(@computer, path) }
+        note_cartridge(@computer, path, "") if attached
+        attached
       end
 
       # What a save of the machine is named after: the cartridge, the disk,
@@ -122,26 +136,36 @@ module Badline
       end
 
       # The name the cartridge in the expansion port gives itself, or an
-      # empty one. A Plus/4's names the slots with a ROM in them.
+      # empty one. A VIC-20's or a Plus/4's is the name of the file it came
+      # from: a .crt's own, or else the file's. A Plus/4 names each of its
+      # cartridges with a ROM in, and a slot filled from elsewhere, such as
+      # a snapshot, by the slot.
       def cartridge_name
-        return @computer.cartridge_slots.map(&:upcase).join(", ") if @computer.family == :plus4
-
-        cartridge = @computer.address_bus.cartridge
-        cartridge.nil? ? "" : cartridge.name
+        case @computer.family
+        when :plus4 then @computer.cartridge_slots.map { |slot| slot_name(slot) }.uniq.join(", ")
+        when :vic20 then named? ? @names.fetch("", "") : ""
+        else
+          cartridge = @computer.address_bus.cartridge
+          cartridge.nil? ? "" : cartridge.name
+        end
       end
 
       # Takes the cartridge out with the power off.
-      def remove_cartridge = MediaSlots.remove_cartridge(@computer)
+      def remove_cartridge
+        @names = {}
+        MediaSlots.remove_cartridge(@computer)
+      end
 
       # A new machine started on `path`, as the command line would, or nil
       # when it won't start.
       def start(options, path)
         computer = nil
-        started = succeeds? do
-          computer = Frontend.start(options, path, @writable)
-          list(path)
+        if Media.kind(@computer, path) == :cartridge
+          cartridge_succeeds? { computer = started(options, path) }
+        else
+          succeeds? { computer = started(options, path) }
         end
-        started ? computer : nil
+        @problem.empty? ? computer : nil
       end
 
       private
@@ -153,6 +177,60 @@ module Badline
         @problem.empty?
       end
 
+      # Runs the block as #succeeds? does, keeping a cartridge's chip in a
+      # bank or slot the machine doesn't map as the problem too.
+      def cartridge_succeeds?(&)
+        @problem = Frontend.cartridge_problem(&)
+        @problem.empty?
+      end
+
+      # The machine Frontend.start started on `path`, with the names of
+      # the cartridges in it noted.
+      def started(options, path)
+        computer = Frontend.start(options, path, @writable)
+        list(path)
+        @names = {}
+        options.cartridges.each { |slot, image| note_cartridge(computer, image.dup, slot) }
+        note_cartridge(computer, path, "")
+        @named = computer
+        computer
+      end
+
+      def named? = @computer.equal?(@named)
+
+      def slot_name(slot) = named? ? @names.fetch(slot, slot.upcase) : slot.upcase
+
+      # Keeps the name of the cartridge at `path` in `computer` by the
+      # slots it fills: a Plus/4's by xplus4's names, a raw image's in
+      # `slot` if it names one, and a VIC-20's in the one slot "". Other
+      # media, and other machines' cartridges, leave the names alone.
+      def note_cartridge(computer, path, slot)
+        case computer.family
+        when :plus4
+          return unless Media.kind(computer, path) == :cartridge
+
+          name = file_name(path)
+          Media::Plus4Media.cartridge_chips(path, slot: slot.empty? ? nil : slot).each do |chip|
+            @names["c#{chip.bank + 1}#{chip.address < 0xc000 ? 'lo' : 'hi'}"] = name
+          end
+        when :vic20 then @names[""] = file_name(path) if vic20_cartridge?(path)
+        end
+      end
+
+      def vic20_cartridge?(path)
+        case Media::Extensions.kind(path)
+        when :cartridge then true
+        when :program then File.file?(path) && !Media::Vic20Cartridge.chips(path, Media.program_bytes(path)).nil?
+        else false
+        end
+      end
+
+      # A .crt's own name, or else the file's, without its extension.
+      def file_name(path)
+        name = Media::Extensions.kind(path) == :cartridge ? Storage::CRTFile.new(path, machine: nil).name : ""
+        name.empty? ? File.basename(path, File.extname(path)) : name
+      end
+
       # Keeps `path` as the list the set comes from, if it's a list.
       def list(path)
         return unless Media::DiskList.list?(path)

data/lib/badline/frontend/menu/menu_pages.rb

@@ -29,7 +29,7 @@ module Badline
         @recent = []
         @painter = painter
         @buttons = buttons
-        @media = MenuMedia.new(media_path, options.writable?)
+        @media = MenuMedia.new(media_path, options.writable?, options.cartridges)
         @reu_kb = options.reu
         @computer = nil
         @controls = nil
@@ -122,9 +122,9 @@ module Badline
       end
 
       def draw_expansion
+        info("CARTRIDGE", @media.cartridge_name)
         return info("RAM EXPANSION", RAM_NAMES.fetch(@computer.ram_configuration)) if vic20?
 
-        info("CARTRIDGE", @media.cartridge_name)
         row("INSERT...", :insert_cartridge)
         row("REMOVE", :remove_cartridge)
         return if plus4?
@@ -137,7 +137,8 @@ module Badline
         info("RAM EXPANSION", "REU, #{@reu_kb} KB")
       end
 
-      # The SID's model is a setting, and other sound chips have none.
+      # The SID's model is a setting, the C64's SID's or a Plus/4's SID
+      # card's, and other sound chips have none.
       def draw_sound
         if @sound.on?
           toggle("OUTPUT", :output, [%w[ON MUTED], %i[sound_on mute], @sound.muted? ? 1 : 0])
@@ -147,7 +148,7 @@ module Badline
         model = @computer.sound_source.model
         return unless SID_MODELS.include?(model)
 
-        toggle("SID", :sid, [%w[6581 8580], %i[sid6581 sid8580], model == :mos8580 ? 1 : 0])
+        toggle(plus4? ? "SID CARD" : "SID", :sid, [%w[6581 8580], %i[sid6581 sid8580], model == :mos8580 ? 1 : 0])
       end
 
       # Saving now and by name, loading a named save, and the quicksaves
@@ -166,10 +167,14 @@ module Badline
       end
 
       # The C128 names its model and the mode it runs in first, and the
-      # Plus/4 its model and RAM.
+      # Plus/4 its model and RAM, and its RAM expansion if it has one.
       def draw_power
         info("MACHINE", "#{@computer.model.name.upcase}, #{@computer.mode.to_s.upcase} MODE") if c128?
-        info("MACHINE", @computer.model_label) if plus4?
+        if plus4?
+          info("MACHINE", @computer.model_label)
+          expansion = @computer.ram_expansion_label
+          info("RAM EXPANSION", expansion) if expansion
+        end
         row("RESET", :reset)
         row("POWER CYCLE", :power_cycle)
         skip

data/lib/badline/frontend/player/player_controller.rb

@@ -15,7 +15,8 @@ module Badline
     # way: #wait handles the window's clicks, keys and drops between frames
     # and redraws it at the display's pace. The SID model buttons switch
     # the chips playing on the spot, and each tune after it starts on the
-    # same choice. AUTO gives each of a tune's SIDs its own model.
+    # same choice. AUTO gives each of a tune's SIDs its own model. It
+    # quits once it has drawn `frames` frames (--frames), unless that's 0.
     class PlayerController < Audio::Terminal
       FRAME = 1.0 / 50
 
@@ -30,8 +31,10 @@ module Badline
         Keys::TAB => :view, 6 => :chip
       }.freeze
 
-      def initialize(input:, output:)
-        super
+      def initialize(input:, output:, frames: 0)
+        super(input:, output:)
+        @frame_limit = frames
+        @frames = 0
         @screen = PlayerScreen.new
         @player = nil
         @tune_file = nil
@@ -73,7 +76,10 @@ module Badline
         actions = poll
         deadline = now + seconds
         loop do
-          draw if now >= @next_draw
+          if now >= @next_draw
+            draw
+            actions << :quit if @frames == @frame_limit
+          end
           left = deadline - now
           break if left <= 0 || !actions.empty?
 
@@ -211,6 +217,7 @@ module Badline
 
       def draw
         @next_draw = now + FRAME
+        @frames += 1
         @screen.draw(@state, @player, @history, @tune_file, SIDTune::STIL::Credit.at(@credits, @state.played))
       end
 

data/lib/badline/machine.rb

@@ -93,7 +93,7 @@ module Badline
     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.model, options.ram_kb) if family == :plus4
+      return plus4_for(media, options) if family == :plus4
 
       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
@@ -127,13 +127,17 @@ module Badline
     end
     private_class_method :vic20_for
 
-    # A Plus/4 with `ram_kb` K of RAM (Plus4::Model::RAM_SIZES), or with
-    # the model's own when nil.
-    def self.plus4_for(media, model, ram_kb)
+    # A Plus/4 with the RAM --ram names (Plus4::Model::RAM_SIZES), or with
+    # the model's own without it, the true drive --drive-type names, the
+    # SID card --sid-card names, where --sid-card-address puts it, and the
+    # RAM expansion --ram-expansion names.
+    def self.plus4_for(media, options)
       unsupported = !media.nil? && Media::Vic20Media::UNSUPPORTED.include?(File.extname(media).downcase)
       raise Unsupported, "doesn't go in a Plus/4" if unsupported
 
-      Plus4.new(model:, ram: ram_kb)
+      Plus4.new(model: options.model, ram: options.ram_kb, true_drive_model: options.drive_type,
+                sid_card: options.sid_card, sid_card_address: options.sid_card_address || 0xfd40,
+                ram_expansion: options.ram_expansion)
     end
     private_class_method :plus4_for
 

data/lib/badline/media/true_drive.rb

@@ -3,9 +3,10 @@
 module Badline
   module Media
     # Device 8 as a true drive instead of the KERNAL traps: a 1541, or on
-    # the C128 its 1571, or a 1581. Once a true drive is plugged in as
-    # device 8, disk media go into it rather than into the traps, so a LOAD
-    # runs the DOS and every byte crosses the serial bus. A .g64 holds the
+    # the C128 its 1571, or on the Plus/4 a 1551 if it asks for one, or a
+    # 1581. Once a true drive is plugged in as device 8, disk media go into
+    # it rather than into the traps, so a LOAD runs the DOS and every byte
+    # crosses the serial bus or TCBM. A .g64 holds the
     # disk's raw GCR, which only a true drive reads, so it plugs one in
     # when there's none yet. The 1541 reads only .d64 and .g64 images, the
     # 1571 .d71 and .g71 as well, and the 1581 only .d81, so a .d81 swaps
@@ -52,9 +53,10 @@ module Badline
             raise Error, "#{path} is not a #{types.join(', ')} or .d81 image, which the #{name} and the 1581 read"
           end
 
-          (drive || computer.plug_true_drive).insert_image(path, read_only:)
+          drive ||= computer.plug_true_drive
+          drive.insert_image(path, read_only:)
           computer.unmount
-          "Inserted #{path} in the #{name} as device 8"
+          "Inserted #{path} in the #{drive.model_name} as device 8"
         end
 
         private