badline 0.13.0 → 0.15.0

data/doc/snapshots.md

@@ -28,41 +28,74 @@ and `$XDG_DATA_HOME/badline` or `~/.local/share/badline` elsewhere.
 
 Both executables do this, and both open a `.vsf` given as the media,
 in a machine built as the saved one was, whatever `--model` says.
-`--save-snapshot FILE` saves one to `FILE` after the last frame. A
-snapshot that fails to open leaves the machine running as it was.
+`--save-snapshot FILE` saves one to `FILE` after the last frame, and
+`--vice` adds VICE's modules to it (see [VICE](#vice)). A snapshot that
+fails to open leaves the machine running as it was.
+
+## Which snapshots load
+
+Snapshots from badline 0.14.0 on load in that version and every later
+one. Each part of the machine is saved as named fields, so a later
+badline skips a field it no longer needs, and a field an earlier one
+didn't save starts as it does when the machine is switched on. What a
+restore leaves out or changes is printed, such as a module missing from
+the file. [snapshot-format.md](snapshot-format.md) lists every field.
+
+Snapshots from badline 0.13 and earlier are refused, with a message
+naming the version that saved them, which still opens them. No snapshot
+loaded across releases before 0.14.0, and none converts.
 
 ## From Ruby
 
 `computer.save_snapshot(path)` saves, `computer.restore_snapshot(path)`
 takes a machine back to a snapshot, and `Badline::Snapshot.load(path)`
 builds a new machine as the saved one was built and restores it.
-`computer.snapshot` and `computer.restore(state)` do the same in memory,
-without a file. A restore that fails leaves the machine as it was.
+`computer.snapshot` returns a `Badline::Snapshot::Image` in memory,
+without a file, and `computer.restore(image)` takes the machine back to
+it; `image.load` builds a new machine from it. A restore that fails
+leaves the machine as it was. `computer.export_snapshot(path)` saves with
+VICE's modules too.
+
+Saving first runs the machine on to the next instruction boundary, and
+to the end of an REU transfer under way, so it advances the machine by a
+few cycles: usually under a hundred, and up to about 262,000 for an REU
+swapping 64K. `computer.cycles` afterwards says where it was saved. A
+save straight after another runs no cycles and writes the same file. In
+the window this happens between frames, and the cycles fold into the
+next frame. `computer.snapshot` in memory saves the same way.
 
 ## What a snapshot holds
 
-A snapshot holds the machine as it was on the cycle it was saved: the
-chips down to the instruction step and the pixel pipeline, the RAM and
+A snapshot holds the machine as it was at the instruction boundary it
+was saved at: the chips down to the pixel pipeline, the RAM and
 any +60K or +256K expansion, the cartridge with its RAM and flash, a
 GEO-RAM, a true 1541 with its RAM, its VIAs and the disk under the head,
 a disk or directory mounted through the traps with its open channels,
 and the tape with its place on it. A restored machine runs on exactly
 as the saved one would have.
 
-A tape, a `.t64` archive and a disk image mounted through the traps come
-back with their contents from the snapshot, so they need no file to
-restore. A true drive's disk opens again from its image's path, with its
-tracks as the drive last saw them. When that file is gone, the disk
-comes back from the tracks alone, write-protected. A directory mounted
-as device 8 opens again from its path. What the host holds stays the
+A tape, a `.t64` archive, a disk image mounted through the traps and a
+true drive's disk come back with their contents from the snapshot, so
+they need no file to restore. A true drive's disk holds its image as last
+written to its file, with the tracks the drive has written since, and
+writes back to that file while it is there. When the file is gone, the
+disk comes back write-protected. A directory mounted as device 8 opens
+again from its path. What the host holds stays the
 host's: the keyboard, the joysticks, the mouse and paddles, sound, and
 blocks given to `on_init` that hadn't run yet, which a restore reports.
 
 Every model saves this way, PAL, NTSC, old NTSC and Drean alike, and so
-does a machine with an REU, with its RAM, its registers and a transfer
-part way through. A snapshot only restores in the badline version that
-wrote it, into a machine with the same chip models, region, RAM
-expansion, REU, KERNAL, datasette and board.
+does a machine with an REU, with its RAM and its registers. A snapshot
+restores into a machine with the same chip models, region, RAM
+expansion, REU, KERNAL, datasette and board. The second and third SIDs
+the SID player fits for a stereo tune are saved too, each with its
+address and model, and a restore fits them.
+
+Text typed with `type_text` that the machine hasn't taken yet, such as
+autostart's `RUN`, carries over, and so do the keys a C128 is typing on
+its key matrix. The VIC-II's line in progress carries over to a badline
+that draws lines the same way. A later badline that draws them another
+way starts the rest of that line afresh, and says so.
 
 ## The VIC-20
 
@@ -70,10 +103,10 @@ expansion, REU, KERNAL, datasette and board.
 slots and pause menu page. A VIC-20 snapshot holds its RAM and colour
 RAM, a cartridge's ROM, the VIC with its picture and sound, both VIAs,
 the CPU, the tape with its place on it, the disk or directory device 8
-serves through the traps and a true 1541, and restores into a VIC-20
-with the same RAM expansion. Its file names its machine `VIC20`, as
-xvic's do, and holds only the `BADLINE` module, so xvic doesn't open
-it, and badline doesn't open xvic's. Restoring a
+serves through the traps and a true 1541 or 1581, and restores into a
+VIC-20 with the same RAM expansion. Its file names its machine `VIC20`,
+as xvic's do, and holds only badline's modules, so xvic doesn't open it,
+and badline doesn't open xvic's. Restoring a
 VIC-20 snapshot while a C64 runs, or a C64 one while a VIC-20 runs,
 swaps the machine in the window.
 
@@ -82,30 +115,47 @@ swaps the machine in the window.
 `badline c128` saves and restores the same way too. A C128 snapshot
 holds its 128K of RAM, both colour RAM banks, the CPU port, the MMU's
 registers and the page pointer writes it holds, the VIC-IIe, both CIAs,
-the SID, the VDC with its RAM and registers, the CPU, a cartridge, the
-tape, the disk device 8 serves through the traps and a true 1541, and
-restores into a C128 of the same model with the same SID, built for the
-same mode. The VDC's picture is left out and painted again while the
-window shows it, and the window shows the VIC-IIe after a restore. Its
-file names its machine `C128`, as x128's do, and holds only the
-`BADLINE` module, so x128 doesn't open it, and badline doesn't open
-x128's. Restoring a C128 snapshot while another machine runs swaps the
+the SID, the VDC with its RAM and registers, the 8502 and the Z80, a
+cartridge, the tape, the disk device 8 serves through the traps and a
+true 1541, 1571 or 1581, and restores into a C128 of the same model with
+the same SID, built for the same mode. The VDC's picture is left out and
+painted again while the window shows it, and the window shows the
+VIC-IIe after a restore. Its file names its machine `C128`, as x128's
+do, and holds only badline's modules, so x128 doesn't open it, and
+badline doesn't open x128's. Restoring a C128 snapshot while another machine runs swaps the
 machine in the window, as for the VIC-20.
 
+## The Plus/4
+
+The Plus/4, the C16 and the C116 save and restore the same way. A
+snapshot of one holds its RAM with the ROM bank latch and whether ROM or
+RAM is selected, the cartridges' ROMs in each slot, the CPU with its
+port, the TED with its timers, its counters and its picture, the TED's
+sound, the keyboard's 6529, the Plus/4's user port 6529 and ACIA, a TCBM
+interface's TIAs, the tape with its place on it, the disk or directory
+device 8 serves through the traps and a true 1541 or 1581. It restores
+into a machine of the same model with the same RAM, and the BASIC,
+KERNAL and function ROMs come with the model. Its file names its machine
+`PLUS4`, as xplus4's do, and holds only badline's modules, so xplus4
+doesn't open it, and badline doesn't open xplus4's. `--vice` and
+`computer.export_snapshot(path)` refuse a Plus/4.
+
 ## VICE
 
-Snapshots use VICE's `.vsf` format. badline writes VICE's modules for
-the CPU, RAM and CPU port, both CIAs, the SID and the VIC-II, and an
-REU's `REU1764`, plus the ones x64sc needs to open the file, with
-nothing else attached to the cartridge port, nothing on the tape or user
-ports and no true drive. The VIC-II module names the chip as VICE does:
-the 6569 or 8565 on PAL, the 6567R8 or 8562 on NTSC, the 6567R56A on old
-NTSC and the 6572 on PAL-N. A `BADLINE` module, which VICE skips, holds
-the whole machine, and badline restores its own snapshots from it.
-
-x64sc 3.10 opens badline's snapshots, taken at the end of the
-instruction the CPU was in, and of an REU transfer under way, as long
-as its VIC-II model matches: `-model c64`, `c64c`, `ntsc`, `newntsc`,
+Snapshots use VICE's `.vsf` format, and badline's own modules are named
+`BL-` and something, which VICE skips. A C64 snapshot saved with
+`--vice`, or `computer.export_snapshot(path)`, also holds VICE's
+modules for the CPU, RAM and CPU port, both CIAs, the SID and the
+VIC-II, and an REU's `REU1764`, plus the ones x64sc needs to open the
+file, with nothing else attached to the cartridge port, nothing on the
+tape or user ports and no true drive. The VIC-II module names the chip
+as VICE does: the 6569 or 8565 on PAL, the 6567R8 or 8562 on NTSC, the
+6567R56A on old NTSC and the 6572 on PAL-N. badline restores such a
+snapshot from its own modules, and leaves VICE's alone.
+
+x64sc 3.10 opens those snapshots, which are saved between
+instructions with no REU transfer under way, as long as its VIC-II
+model matches: `-model c64`, `c64c`, `ntsc`, `newntsc`,
 `oldntsc` or `drean`, as `--model` names the machine. It takes the REU
 from the snapshot, keeps its own drives and leaves out the cartridge,
 the other expansions and the tape. A program x64sc runs on from badline's

data/lib/badline/audio/bare_player.rb

@@ -74,26 +74,38 @@ module Badline
         settle
       end
 
-      # The rig between frames: the bus and its chips, the extra SIDs, the
-      # CPU, and the call waiting for the idle loop.
-      def save_state(out)
-        out.marker("BARE PLAYER")
-        @bus.save_state(out)
-        @extras.each { |sid| sid.save_state(out) }
-        @cpu.save_state(out)
-        out.optional_int(@pending).int(@argument).boolean(@idle)
+      # The rig between frames as keyed snapshot modules: the call waiting
+      # for the idle loop in BL-PLAYER, the memories, the CPU and its port,
+      # the chips and the extra SIDs, as BL-SID2 and BL-SID3.
+      def save_modules
+        bus = @bus
+        cpu = @cpu
+        sections = [Snapshot::Keyed.section("BL-PLAYER") do |out|
+          out.optional_int("pending", @pending).int("argument", @argument).bool("idle", @idle)
+        end]
+        sections << Snapshot::Keyed.section("BL-RAM") { |out| bus.ram.save_fields(out, "ram") }
+        sections << Snapshot::Keyed.section("BL-COLORRAM") { |out| bus.color_ram.save_fields(out, "ram") }
+        sections << Snapshot::Keyed.section("BL-CPU") do |out|
+          cpu.save_fields(out)
+          bus.save_port_fields(out)
+        end
+        sections << Snapshot::Keyed.section("BL-VIC") { |out| bus.vic.save_fields(out) }
+        sections << Snapshot::Keyed.section("BL-CIA1") { |out| bus.cia1.save_fields(out) }
+        sections << Snapshot::Keyed.section("BL-CIA2") { |out| bus.cia2.save_fields(out) }
+        sections << Snapshot::Keyed.section("BL-SID") { |out| bus.sid.save_fields(out) }
+        bus.save_extra_sid_modules(sections)
       end
 
-      # Takes a rig that hasn't started to where #save_state found one, in
+      # Takes a rig that hasn't started to where #save_modules found one, in
       # place of #start.
-      def load_state(input)
-        input.marker("BARE PLAYER")
-        @bus.load_state(input)
-        @extras.each { |sid| sid.load_state(input) }
-        @cpu.load_state(input)
-        @pending = input.optional_int
-        @argument = input.int
-        @idle = input.boolean?
+      def load_modules(modules)
+        load_bus_modules(modules)
+        @cpu.load_fields(modules.required("BL-CPU"))
+        @cpu.restored!
+        player = modules.required("BL-PLAYER")
+        @pending = player.optional_int("pending")
+        @argument = player.int("argument", 0)
+        @idle = player.bool("idle", false)
         @stereo.synthesize!
         install_dispatch
       end
@@ -128,6 +140,23 @@ module Badline
         @bus.cia1.timer_a_latch + 1
       end
 
+      def load_bus_modules(modules)
+        bus = @bus
+        bus.ram.load_fields(modules.required("BL-RAM"), "ram")
+        bus.color_ram.load_fields(modules.required("BL-COLORRAM"), "ram")
+        bus.load_port_fields(modules.required("BL-CPU"))
+        bus.restored!
+        bus.vic.load_fields(modules.required("BL-VIC"))
+        bus.cia1.load_fields(modules.required("BL-CIA1"))
+        bus.cia2.load_fields(modules.required("BL-CIA2"))
+        bus.sid.load_fields(modules.required("BL-SID"))
+        bus.load_extra_sid_modules(modules)
+        @stereo.sids.each(&:restored!)
+        bus.vic.restored!
+        bus.cia1.restored!
+        bus.cia2.restored!
+      end
+
       def stub_address = @stub_address ||= @tune.driver_address
 
       def idle_address = stub_address + 3

data/lib/badline/audio/machine_player.rb

@@ -39,18 +39,14 @@ module Badline
 
       def clock_hz = @computer.region.clock_hz
 
-      # The whole machine, as C64#snapshot takes it, and the extra SIDs,
-      # once it plays.
-      def save_state(out)
-        @computer.save_state(out)
-        @extras.each { |sid| sid.save_state(out) }
-      end
+      # The whole machine as its keyed snapshot modules, as it stands between
+      # frames, with the extra SIDs as BL-SID2 and BL-SID3, once it plays.
+      def save_modules = @computer.save_modules
 
-      # Takes a machine that hasn't started to where #save_state found one,
+      # Takes a machine that hasn't started to where #save_modules found one,
       # in place of #start.
-      def load_state(input)
-        @computer.load_state(input)
-        @extras.each { |sid| sid.load_state(input) }
+      def load_modules(modules)
+        @computer.load_modules(modules)
         @stereo.synthesize!
         @started = true
       end

data/lib/badline/audio/renderer.rb

@@ -136,17 +136,17 @@ module Badline
       # or before `cycles` if there is one, and returns the cycles into the
       # subtune it starts at.
       def start(cycles)
-        state = @checkpoints&.latest(cycles)
-        return start_afresh if state.nil?
+        sections = @checkpoints&.latest(cycles)
+        return start_afresh if sections.nil?
 
-        input = Snapshot::StateReader.new(state)
-        played = input.int
-        restore_player(input)
+        modules = Snapshot::Keyed::Modules.new(sections)
+        audio = modules.required("BL-AUDIO")
+        restore_player(modules, audio)
         record
-        player.stereo.sids.each { |sid| sid.load_recording(input) }
-        @level = input.int
-        @still = input.int
-        played
+        player.stereo.sids.each_with_index { |sid, index| sid.load_recording_fields(audio, "sid#{index + 1}.rec.") }
+        @level = audio.int("level", 0)
+        @still = audio.int("still", 0)
+        audio.int("played", 0)
       end
 
       def start_afresh
@@ -157,13 +157,17 @@ module Badline
 
       def record = player.stereo.record(rate: @rate, filter_chunk: @filter_chunk, clock_hz: player.clock_hz)
 
-      # Restores the player as it was, then puts back the SID models chosen
-      # for this renderer.
-      def restore_player(input)
+      # Restores the player as it was, on the SID models it was saved on,
+      # then puts back the SID models chosen for this renderer.
+      def restore_player(modules, audio)
         sids = player.stereo.sids
         chosen = sids.map(&:model)
-        sids.each { |sid| refit(sid, Snapshot::C64Setup::SID_MODELS.fetch(input.int)) }
-        player.load_state(input)
+        names = Snapshot::C64Setup::SID_MODELS.map(&:to_s)
+        sids.each_with_index do |sid, index|
+          name = audio.choice("sid#{index + 1}.model", names, sid.model.to_s)
+          refit(sid, Snapshot::C64Setup::SID_MODELS.find { |model| model.to_s == name } || sid.model)
+        end
+        player.load_modules(modules)
         sids.each_with_index { |sid, index| refit(sid, chosen[index]) }
       end
 
@@ -171,18 +175,25 @@ module Badline
         sid.model = model unless sid.model == model
       end
 
+      # The player's modules, after a BL-AUDIO module with the cycles into
+      # the subtune, each SID's model and how far its recording has got,
+      # and the silence count. The SIDs have caught up as the frame drained
+      # them, so they leave no samples behind.
       def save_checkpoint(played, clock_hz)
         checkpoints = @checkpoints
         return if checkpoints.nil? || !checkpoints.due?(played, clock_hz)
 
         sids = player.stereo.sids
-        out = Snapshot::StateWriter.new
-        out.int(played)
-        sids.each { |sid| out.int(Snapshot::C64Setup::SID_MODELS.index(sid.model) || 0) }
-        player.save_state(out)
-        sids.each { |sid| sid.save_recording(out) }
-        out.int(@level).int(@still)
-        checkpoints.keep(played, out.state)
+        sections = player.save_modules
+        audio = Snapshot::Keyed.section("BL-AUDIO") do |out|
+          out.int("played", played)
+          sids.each_with_index do |sid, index|
+            out.text("sid#{index + 1}.model", sid.model.to_s)
+            sid.save_recording_fields(out, "sid#{index + 1}.rec.")
+          end
+          out.int("level", @level).int("still", @still)
+        end
+        checkpoints.keep(played, [audio, *sections])
       end
 
       # Counts the samples since the output last strayed more than QUIET

data/lib/badline/c128/banks.rb

@@ -5,8 +5,8 @@ module Badline
     # The RAM the C128 KERNAL's bank numbers 0-15 reach, as its INDFET and
     # INDSTA reach it for LOAD, SAVE and the file name: the RAM bank of the
     # CR value the KERNAL's table at $F7F0 holds for the bank, with common
-    # RAM in bank 0. The ROMs and I/O some of those CR values map are left
-    # out.
+    # RAM in bank 0. The Bus lays the ROMs and I/O some of those CR values
+    # map over it.
     class Banks
       CONFIGURATIONS = 0xf7f0
 
@@ -18,16 +18,17 @@ module Badline
 
       def peek(bank, addr) = @ram.peek(physical(bank, addr))
 
-      def write(bank, addr, bytes)
-        bytes.each_with_index { |byte, i| @ram.poke(physical(bank, (addr + i) & 0xffff), byte) }
-      end
+      # The CR value the KERNAL's table holds for the bank.
+      def configuration(bank) = @kernal_rom.peek(CONFIGURATIONS + (bank & 0x0f))
+
+      def poke(bank, addr, value) = @ram.poke(physical(bank, addr), value)
 
       private
 
       def physical(bank, addr)
         page = addr >> 8
         common = page < @mmu.common_low_pages || page >= @mmu.common_high_start
-        ram_bank = common ? 0 : (@kernal_rom.peek(CONFIGURATIONS + (bank & 0x0f)) >> 6) & 0x01
+        ram_bank = common ? 0 : (configuration(bank) >> 6) & 0x01
         (ram_bank << 16) | addr
       end
     end

data/lib/badline/c128/bus/keyed_state.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Badline
+  class C128
+    class Bus
+      # The last access on the bus, which FAST mode's VIC and open bus read,
+      # in a keyed snapshot module (Snapshot::Keyed) under `prefix`, and
+      # what is worked out once the memories, the MMU and the chips are
+      # loaded: the banks each side sees and the keyboard's extra rows.
+      module KeyedState
+        def save_fields(out, prefix)
+          out.int("#{prefix}address", @address).int("#{prefix}data", @data)
+        end
+
+        def load_fields(input, prefix)
+          @address = input.word("#{prefix}address", @address)
+          @data = input.byte("#{prefix}data", @data)
+        end
+
+        # Both banks of colour RAM as bank0 and bank1.
+        def save_color_fields(out)
+          @color_lines.color_ram(0).save_fields(out, "bank0")
+          @color_lines.color_ram(1).save_fields(out, "bank1")
+        end
+
+        def load_color_fields(input)
+          @color_lines.color_ram(0).load_fields(input, "bank0")
+          @color_lines.color_ram(1).load_fields(input, "bank1")
+        end
+
+        # The 8502's port, as the C64's (C64::Bus::KeyedState).
+        def save_port_fields(out) = @cpu_port.save_fields(out, "port.")
+
+        def load_port_fields(input) = @cpu_port.load_fields(input, "port.")
+
+        def restored!
+          update_overlays!
+          @control_ports.extra_rows = 0xf8 | @vic.extra_keyboard_lines
+        end
+      end
+
+      include KeyedState
+    end
+  end
+end

data/lib/badline/c128/bus.rb

@@ -39,7 +39,6 @@ module Badline
       include MMUPages
       include IOPages
       include Z80Pages
-      include SavedState
 
       # The 8502's port has seven pins. P0-P5 are the 6510's, and P6 senses
       # the CAPS LOCK key, high while it is up. Bit 7 has no pin, and holds
@@ -161,6 +160,8 @@ module Badline
 
         @read_pages = Array.new(256)
         @write_pages = Array.new(256)
+        @bank_io_reads = Array.new(256)
+        @bank_io_writes = Array.new(256)
         @address = 0
         @data = 0
         @io_mapped = false
@@ -211,10 +212,41 @@ module Badline
       # ROM at $C000-$FFFF.
       def system_rom_mapped? = !@mmu.c64_mode? && @mmu.cr.nobits?(0x30)
 
-      # The RAM the C128 KERNAL's bank number +bank+ reaches (Banks).
-      def peek_bank(bank, addr) = @banks.peek(bank, addr)
+      # The byte the C128 KERNAL's bank number +bank+ reads at +addr+, as
+      # its INDFET does: the ROMs and I/O the bank's CR value maps, over the
+      # RAM it reaches (Banks).
+      def peek_bank(bank, addr)
+        cr = @banks.configuration(bank)
+        return @mmu.peek_configuration(addr) if addr.between?(0xff00, 0xff04)
+        return bank_io_peek(addr) if cr.nobits?(0x01) && (addr & 0xf000) == 0xd000
+        return @basic_low_rom.peek(addr) if cr.nobits?(0x02) && addr.between?(0x4000, 0x7fff)
 
-      def write_bank(bank, addr, bytes) = @banks.write(bank, addr, bytes)
+        select = addr < 0xc000 ? (cr >> 2) & 0x03 : (cr >> 4) & 0x03
+        return @banks.peek(bank, addr) if addr < 0x8000 || select == 3
+        return @open_bus.peek(addr) unless select.zero?
+
+        system_rom_peek(addr)
+      end
+
+      # Stores +bytes+ from +addr+ on in the C128 KERNAL's bank number
+      # +bank+, as its INDSTA does, with CR set to the bank's CR value for
+      # each byte and put back after it: into the chips where that value
+      # maps I/O, the MMU's at $D500 among them, into nothing at $FF00-$FF04,
+      # where the configuration registers take the byte, and otherwise into
+      # the RAM the bank reaches (Banks).
+      def write_bank(bank, addr, bytes)
+        cr = @mmu.cr
+        io = @banks.configuration(bank).nobits?(0x01)
+        bytes.each_with_index do |byte, i|
+          address = (addr + i) & 0xffff
+          if io && (address & 0xf000) == 0xd000
+            bank_io_poke(address, byte)
+          elsif !address.between?(0xff00, 0xff04)
+            @banks.poke(bank, address, byte)
+          end
+        end
+        @mmu.poke_configuration(0xff00, cr) unless @mmu.cr == cr
+      end
 
       def install_debug_register(&)
         @debug_page = DebugPage.new(@open_bus, &)

data/lib/badline/c128/drives.rb

@@ -72,35 +72,16 @@ module Badline
         detach_drive1571 if @drive1571&.device == device
       end
 
-      # A true 1541 (C64::Attachments#save_serial_bus), then a 1571 and
-      # a 1581.
-      def save_serial_bus(out)
-        out.boolean(!@drive1541.nil?)
-        if @drive1541
-          out.int(@drive1541.device)
-          @drive1541.save_state(out)
-        end
-        out.boolean(!@drive1571.nil?)
-        if @drive1571
-          out.int(@drive1571.device)
-          @drive1571.save_state(out)
-        end
-        save_drive1581(out)
+      def save_drive1571_modules(sections)
+        drive1571 = @drive1571
+        drive1571&.save_modules(sections, "BL-D#{drive1571.device}")
+        sections
       end
 
-      def load_serial_bus(input)
-        load_drive1541(input)
-        load_drive1571(input)
-        load_drive1581(input)
-      end
-
-      def load_drive1571(input)
-        return detach_drive1571 unless input.boolean?
-
-        device = input.int
+      def load_drive1571_modules(modules, input, device)
         detach_drive1571 if @drive1571 && @drive1571.device != device
         attach_drive1571(Badline::Drives::Model1571.new(device:)) unless @drive1571
-        @drive1571.load_state(input)
+        @drive1571.load_modules(modules, input, "BL-D#{device}")
       end
     end
   end