badline 0.12.1 → 0.14.0

data/lib/badline/drives/model1541/disk.rb

@@ -0,0 +1,318 @@
+# frozen_string_literal: true
+
+require "badline/media/extensions"
+require "badline/drives/model1541/sector_reader"
+
+module Badline
+  module Drives
+    class Model1541
+      # A disk as the head sees it: a Track for each half track that holds
+      # data, numbered from 2 (track 1) to MAX_HALF_TRACK (track 42), and
+      # nothing between them. A .d64 image fills the whole tracks; a .g64
+      # can fill any of them, with tracks of any length.
+      #
+      # The disk has a second side, for the 1571's second head, its half
+      # tracks numbered from SIDE on. A .d71 fills both sides, its tracks
+      # 36-70 being tracks 1-35 of the second, and a .g71 holds 84 half
+      # tracks a side. A 1541 reads the first side only.
+      #
+      # The head writes into the tracks' bytes, and a write to a half track
+      # without data gives it a blank Track first. A disk made from an image
+      # remembers it: flush reads the sectors back off the tracks written
+      # since the last flush and stores them in the image, which writes its
+      # host file. The disk is write-protected when the image won't take
+      # writes.
+      class Disk
+        # Whether the image is a .g64 or .g71, by its name.
+        def self.g64?(path) = Media::Extensions.kind(path) == :gcr
+
+        MAX_HALF_TRACK = 84
+
+        # Where the second side's half tracks start: its track 1 is SIDE + 2.
+        SIDE = MAX_HALF_TRACK + 1
+
+        # The tracks a side of a .d71 holds.
+        D71_SIDE_TRACKS = 35
+
+        # The half track entries a side of a .g71 holds.
+        G71_SIDE_ENTRIES = 84
+
+        # GCR bytes around a track in each speed zone (Storage::D64Image.zone):
+        # 200 ms of rotation at 300 rpm, in bytes of 32, 30, 28 and 26 µs.
+        TRACK_LENGTHS = [6250, 6666, 7142, 7692].freeze
+
+        # How far round the DOS's N: starts each track from the one before,
+        # in each zone, in 1/10000 of a turn: it steps in and starts writing
+        # the next track that long after it started the last.
+        SKEWS = [2916, 897, 8915, 6869].freeze
+        SKEW_TURN = 10_000
+
+        SYNC_LENGTH = 5
+        HEADER_GAP = 9
+        GAP = 0x55
+        HEADER_ID = 0x08
+        DATA_ID = 0x07
+
+        # A sector: SYNC, the 10-byte GCR header, the header gap, SYNC and
+        # the 325-byte GCR data block. The gap after it takes up the rest.
+        SECTOR_LENGTH = SYNC_LENGTH + 10 + HEADER_GAP + SYNC_LENGTH + 325
+
+        # A disk from the image at +path+: a .g64 or .g71 as its tracks are,
+        # a .d71 formatted on both sides, and anything else as a .d64,
+        # formatted. `read_only` opens the image write-protected.
+        def self.open(path, read_only: false)
+          image = image_for(path, read_only)
+          (Disk.g64?(path) ? from_g64(image) : from_d64(image)).opened(path, read_only)
+        end
+
+        # The image at +path+, by its name: a .g64 or .g71, a .d71, and
+        # anything else a .d64. `bytes` stands in for the file's contents.
+        def self.image_for(path, read_only, bytes = nil)
+          return Storage::G64Image.new(path, read_only:, bytes:) if Disk.g64?(path)
+          return Storage::D71Image.new(path, read_only:, bytes:) if File.extname(path).casecmp?(".d71")
+
+          Storage::D64Image.new(path, read_only:, bytes:)
+        end
+
+        # A disk from a G64 or G71 image, each half track as the image stores
+        # it, with its speed map. Flushing it writes the tracks back as they
+        # are.
+        def self.from_g64(image)
+          disk = new(image)
+          image.half_tracks.times do |entry|
+            track = image.track(entry)
+            disk.write(half_track_of(entry), Track.new(*track, image.speeds(entry))) if track
+          end
+          disk
+        end
+
+        # The half track a G64 or G71 table entry holds: entry 0 is track 1,
+        # and a .g71's entries from G71_SIDE_ENTRIES on are the second
+        # side's.
+        def self.half_track_of(entry)
+          side = entry / G71_SIDE_ENTRIES
+          (side * SIDE) + (entry % G71_SIDE_ENTRIES) + Mechanism::MIN_HALF_TRACK
+        end
+
+        # The table entry of a half track, or nil for one a G64 or G71 has
+        # no entry for.
+        def self.entry_of(half_track)
+          side = half_track / SIDE
+          entry = (half_track % SIDE) - Mechanism::MIN_HALF_TRACK
+          (side * G71_SIDE_ENTRIES) + entry if entry.between?(0, G71_SIDE_ENTRIES - 1)
+        end
+
+        # The half track an image's track number is on: a .d71's tracks past
+        # D71_SIDE_TRACKS are on the second side.
+        def self.d64_half_track(image, track)
+          return track * 2 unless image.sides == 2 && track > D71_SIDE_TRACKS
+
+          SIDE + ((track - D71_SIDE_TRACKS) * 2)
+        end
+
+        # The image's track number a half track holds, or nil for a half
+        # track or one past the image's last.
+        def self.d64_track(image, half_track)
+          side = half_track / SIDE
+          return unless (half_track % SIDE).even?
+
+          track = (half_track % SIDE) / 2
+          track += D71_SIDE_TRACKS if side == 1
+          track if track.positive? && track <= image.track_count && side < image.sides
+        end
+
+        # A disk formatted from a D64 image, each sector laid out as the DOS
+        # formats it, with the disk ID from the header block. A block the
+        # image's error table marks 20, 21, 22, 23, 27 or 29 is written the
+        # way that DOS error would read. The table's other codes, 24, 25, 26
+        # and 28, describe write or decoding faults the layout can't carry,
+        # so their blocks are written good and read without an error.
+        #
+        # Each track starts sector 0 at the angle the DOS's N: leaves it: track
+        # 1 at the index angle, and each track after it SKEWS[zone] of a turn
+        # round from the last. A .d71's second side starts over at the index
+        # angle.
+        def self.from_d64(image)
+          track, sector = image.header_block
+          header = image.read_block(track, sector)
+          id = [header[0xa2], header[0xa3]]
+          disk = new(image)
+          angle = 0
+          (1..image.track_count).each do |track|
+            half_track = d64_half_track(image, track)
+            zone = Storage::D64Image.zone((half_track % SIDE) / 2)
+            angle = half_track == SIDE + 2 ? 0 : (angle + SKEWS[zone]) % SKEW_TURN if track > 1
+            bytes = format_track(image, track, id, zone)
+            disk.write(half_track, Track.new(bytes.rotate(-(bytes.length * angle / SKEW_TURN)), zone))
+          end
+          disk
+        end
+
+        def self.format_track(image, track, id, zone = Storage::D64Image.zone(track))
+          sectors = image.sectors_in(track)
+          length = TRACK_LENGTHS[zone]
+          gap = (length - (sectors * SECTOR_LENGTH)) / sectors
+          bytes = []
+          sectors.times do |sector|
+            format_sector(bytes, image, track, sector, id)
+            gap.times { bytes << GAP }
+          end
+          bytes << GAP while bytes.length < length
+          bytes
+        end
+
+        # Error 21 leaves the block without SYNC marks, and 29 writes its
+        # header with the wrong first ID byte.
+        def self.format_sector(bytes, image, track, sector, id)
+          error = image.block_error(track, sector)
+          sync = error == 21 ? GAP : 0xff
+          id = [id[0] ^ 0xff, id[1]] if error == 29
+          SYNC_LENGTH.times { bytes << sync }
+          bytes.concat(GCR.encode(header(track, sector, id, error)))
+          HEADER_GAP.times { bytes << GAP }
+          SYNC_LENGTH.times { bytes << sync }
+          bytes.concat(GCR.encode(data_block(image.read_block(track, sector), error)))
+        end
+
+        # ID, checksum, sector, track, the second ID byte, the first and two
+        # $0F fillers. Error 20 hides the block's ID and 27 spoils its
+        # checksum.
+        def self.header(track, sector, id, error)
+          checksum = sector ^ track ^ id[1] ^ id[0]
+          checksum ^= 0xff if error == 27
+          [error == 20 ? 0x00 : HEADER_ID, checksum, sector, track, id[1], id[0], 0x0f, 0x0f]
+        end
+
+        # ID, 256 data bytes, their checksum and two $00 fillers. Error 22
+        # hides the block's ID and 23 spoils its checksum.
+        def self.data_block(data, error)
+          checksum = 0
+          data.each { |byte| checksum ^= byte }
+          checksum ^= 0xff if error == 23
+          block = [error == 22 ? 0x00 : DATA_ID]
+          block.concat(data)
+          block << checksum << 0x00 << 0x00
+        end
+
+        attr_reader :image
+
+        def initialize(image = nil)
+          @image = image
+          @tracks = Array.new(SIDE * 2)
+          @written = {}
+          @path = nil
+          @read_only = false
+        end
+
+        # The Track at the half track, or nil where there's no data.
+        def track(half_track) = @tracks[half_track]
+
+        def write(half_track, track)
+          @tracks[half_track] = track
+        end
+
+        # Whether the write-protect notch is covered: the disk's image won't
+        # take writes, or a disk without an image was opened read-only. A
+        # disk without an image keeps what it takes only in its tracks.
+        def write_protected? = @image.nil? ? @read_only : !@image.writable?
+
+        # A half track the head writes to, blank to begin with: no flux, and
+        # as many bytes as a turn holds at the bit rate of the +zone+ it's
+        # written in.
+        def writable_track(half_track, zone)
+          @tracks[half_track] ||= Track.new(Array.new(TRACK_LENGTHS[zone], 0), zone)
+        end
+
+        # The head wrote to the half track.
+        def written(half_track)
+          @written[half_track] = true
+        end
+
+        # Whether any track was written since the last flush.
+        def written? = !@written.empty?
+
+        # Stores each track written since the last flush in the image, all
+        # in one write to its host file. A G64 image takes the tracks as they
+        # are. A D64 image takes the sectors read back off them, and keeps
+        # whole tracks only, so a half track, or a track past its last, stays
+        # on the disk alone. A sector that no longer reads back keeps its old
+        # data, and the flush warns once, naming the tracks that lost one.
+        def flush
+          return flush_tracks if @image.respond_to?(:store_tracks)
+
+          tracks = @written.keys.filter_map do |half|
+            track = @image && Disk.d64_track(@image, half)
+            [half, track] if track
+          end
+          @written.clear
+          return if tracks.empty?
+
+          sectors = tracks.to_h { |half, track| [track, SectorReader.read(@tracks[half].bytes, track)] }
+          id = disk_id(sectors)
+          warn_lost(sectors)
+          @image.store_blocks(sectors.flat_map do |track, found|
+            Array.new(@image.sectors_in(track)) { |sector| stored_block(track, sector, found[sector], id) }
+          end)
+        end
+
+        private
+
+        def flush_tracks
+          tracks = @written.keys.sort.filter_map do |half|
+            entry = Disk.entry_of(half)
+            [entry, [@tracks[half].bytes, @tracks[half].zone]] if entry
+          end.to_h
+          @written.clear
+          @image.store_tracks(tracks) unless tracks.empty?
+        end
+
+        def warn_lost(sectors)
+          lost = sectors.keys.select do |track|
+            Array.new(@image.sectors_in(track)) { |sector| lost?(track, sector, sectors[track][sector]) }.any?
+          end
+          return if lost.empty?
+
+          warn "1541: tracks written that no longer read back whole: #{lost.join(', ')}. The .d64 keeps the old " \
+               "data of the sectors lost, and a .g64 image keeps tracks as the drive writes them."
+        end
+
+        # A sector the head no longer finds, which the image doesn't already
+        # hold as unreadable.
+        def lost?(track, sector, found)
+          found.nil? && ![20, 21].include?(@image.block_error(track, sector))
+        end
+
+        # The disk ID the headers must carry, from the header block's $A2 and
+        # $A3 as Disk.from_d64 takes it: as just read back, or as the image
+        # holds it.
+        def disk_id(sectors)
+          track, sector = @image.header_block
+          header = sectors.dig(track, sector)&.data
+          data = header ? header[1, 256] : @image.read_block(track, sector)
+          [data[0xa2], data[0xa3]]
+        end
+
+        # [track, sector, data, error] for DiskImage#store_blocks: the data as
+        # read, nil where it can't be, and the DOS error a read of it would
+        # raise, the way Disk.from_d64 writes each one. A sector whose header
+        # isn't found keeps its data, and reads as error 20, or 21 where the
+        # image already has it so.
+        def stored_block(track, sector, found, id)
+          return [track, sector, nil, @image.block_error(track, sector) == 21 ? 21 : 20] unless found
+
+          header = found.header
+          data = found.data
+          [track, sector, data && data[1, 256], block_error(header, data, id)]
+        end
+
+        def block_error(header, data, id)
+          if header[1] != header[2] ^ header[3] ^ header[4] ^ header[5] then 27
+          elsif header[5] != id[0] || header[4] != id[1] then 29
+          elsif data.nil? || data[0] != DATA_ID then 22
+          elsif data[257] != data[1, 256].reduce(:^) then 23
+          end
+        end
+      end
+    end
+  end
+end

data/lib/badline/drives/model1541/disk_via.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Badline
+  module Drives
+    class Model1541
+      # VIA 2, the one facing the disk mechanism. Its port B drives the
+      # Mechanism, and CB2 selects its read or write mode. The mechanism
+      # hears both after every write and reset, since ORB, DDRB, the ACR and
+      # the PCR can all change them.
+      class DiskVIA < Chips::VIA
+        attr_reader :mechanism
+
+        def initialize(start:, mechanism:)
+          @mechanism = mechanism
+          mechanism.via = self
+          super(start:, peripheral: mechanism)
+        end
+
+        def reset!
+          super
+          tell_mechanism
+        end
+
+        def poke(addr, value)
+          super
+          tell_mechanism
+        end
+
+        private
+
+        def tell_mechanism
+          @mechanism.port_b_written(port_b_output)
+          @mechanism.cb2_written(cb2_output)
+        end
+      end
+    end
+  end
+end

data/lib/badline/drives/model1541/gcr.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Badline
+  module Drives
+    class Model1541
+      # Group code recording, the 1541's on-disk code. Each nibble becomes
+      # five bits, chosen so that no code has more than two 0 bits in a row
+      # and no run of codes has ten 1 bits in a row, which only a SYNC mark
+      # has. Four bytes become five.
+      module GCR
+        CODES = [0x0a, 0x0b, 0x12, 0x13, 0x0e, 0x0f, 0x16, 0x17,
+                 0x09, 0x19, 0x1a, 0x1b, 0x0d, 0x1d, 0x1e, 0x15].freeze
+
+        # Five-bit code => nibble, nil for the codes that aren't GCR.
+        NIBBLES = Array.new(32) { |code| CODES.index(code) }.freeze
+
+        module_function
+
+        # Encodes a whole number of four-byte groups.
+        def encode(bytes)
+          out = []
+          i = 0
+          while i < bytes.length
+            bits = 0
+            4.times do |n|
+              byte = bytes[i + n]
+              bits = (bits << 10) | (CODES[byte >> 4] << 5) | CODES[byte & 0x0f]
+            end
+            4.downto(0) { |n| out << ((bits >> (n * 8)) & 0xff) }
+            i += 4
+          end
+          out
+        end
+
+        # Decodes a whole number of five-byte groups, nil when any code
+        # isn't GCR.
+        def decode(bytes)
+          out = []
+          i = 0
+          while i < bytes.length
+            bits = 0
+            5.times { |n| bits = (bits << 8) | bytes[i + n] }
+            n = 7
+            while n.positive?
+              high = NIBBLES[(bits >> (n * 5)) & 0x1f]
+              low = NIBBLES[(bits >> ((n - 1) * 5)) & 0x1f]
+              return nil if high.nil? || low.nil?
+
+              out << ((high << 4) | low)
+              n -= 2
+            end
+            i += 5
+          end
+          out
+        end
+      end
+    end
+  end
+end

data/lib/badline/drives/model1541/keyed_state.rb

@@ -0,0 +1,251 @@
+# frozen_string_literal: true
+
+module Badline
+  module Drives
+    class Model1541
+      class Disk
+        # The kinds of image a disk embeds, by name.
+        IMAGE_KINDS = %w[none d64 d71 g64].freeze
+
+        # A disk's fields in a keyed snapshot module (BL-D8-DISK): the image
+        # file's path and how it was opened, the image as last flushed,
+        # embedded under image and image.kind, each half track that differs
+        # from what the image decodes to, as track<H>.zone, track<H>.speeds
+        # and track<H>.gcr, raw GCR as the head sees it, and the half tracks
+        # written since the last flush.
+        module KeyedState
+          # The image's path, expanded, and whether it was opened read-only,
+          # for a disk from Disk.open. Nil for a disk made another way.
+          attr_reader :path, :read_only
+
+          # Notes the image's path and how it was opened.
+          def opened(path, read_only)
+            @path = File.expand_path(path)
+            @read_only = read_only
+            self
+          end
+
+          def save_fields(out)
+            path = @path
+            out.text("path", path) if path
+            out.bool("read_only", @read_only == true)
+            image = @image
+            decoded = nil
+            if image
+              out.text("image.kind", Disk.image_kind(image)).text("image.path", image.path.to_s)
+              out.bytes("image", image.contents)
+              decoded = Disk.decode(image)
+            end
+            @tracks.each_with_index { |track, half| save_track_fields(out, half, track, decoded) }
+            out.ints("written", @written.keys)
+          end
+
+          def load_track_fields(input)
+            @tracks.each_index do |half|
+              zone = input.optional_int("track#{half}.zone")
+              next if zone.nil?
+
+              speeds = input.ints("track#{half}.speeds", [])
+              gcr = input.bytes("track#{half}.gcr", "".b).bytes
+              @tracks[half] = Track.new(gcr, zone, speeds.empty? ? nil : speeds.dup)
+            end
+            @written.clear
+            input.ints("written", []).each { |half| @written[half] = true }
+            self
+          end
+
+          private
+
+          def save_track_fields(out, half, track, decoded)
+            return if track.nil?
+
+            original = decoded&.track(half)
+            return if original && original.zone == track.zone && original.speeds == track.speeds &&
+                      original.bytes == track.bytes
+
+            out.int("track#{half}.zone", track.zone)
+            speeds = track.speeds
+            out.ints("track#{half}.speeds", speeds) if speeds
+            out.bytes("track#{half}.gcr", track.bytes)
+          end
+        end
+
+        include KeyedState
+
+        # The kind of `image`, by name.
+        def self.image_kind(image)
+          return "g64" if image.is_a?(Storage::G64Image)
+          return "d71" if image.is_a?(Storage::D71Image)
+
+          "d64"
+        end
+
+        # The tracks `image` holds, as an insert decodes them.
+        def self.decode(image) = image.is_a?(Storage::G64Image) ? from_g64(image) : from_d64(image)
+
+        # The disk a keyed snapshot module describes: its embedded image
+        # decoded, with the tracks the module holds laid over it. The image
+        # takes writes back to its file only while that file is there and
+        # the reader isn't `detached`. With no image, the disk is the
+        # tracks alone, write-protected.
+        def self.from_fields(input, detached: false)
+          path = input.text("path", "")
+          read_only = input.bool("read_only", false)
+          kind = input.choice("image.kind", IMAGE_KINDS, "none")
+          image_path = input.text("image.path", "")
+          disk = kind == "none" ? Disk.new : from_image(input, kind, image_path, read_only || detached)
+          disk.opened(path, read_only || kind == "none") unless path.empty?
+          disk.load_track_fields(input)
+        end
+
+        def self.from_image(input, kind, path, read_only)
+          bytes = input.bytes("image", "".b).bytes
+          writable_path = path.empty? || !File.file?(path) ? "" : path
+          image = case kind
+                  when "g64" then Storage::G64Image.new(writable_path, read_only:, bytes:)
+                  when "d71" then Storage::D71Image.new(writable_path, read_only:, bytes:)
+                  else Storage::D64Image.new(writable_path, read_only:, bytes:)
+                  end
+          decode(image)
+        end
+      end
+
+      class Mechanism
+        # The head, the motor, the stepper and the read and write
+        # electronics in a keyed snapshot module (BL-D8-MECH): where the
+        # head is, the disk's place in its turn, the read clock's next
+        # clock in cycles from now, the shift registers and the flags. The
+        # cell under the head, its width and the next event come from the
+        # track and the time on load, the cell period from the zone, and
+        # the write protection from the disk.
+        module KeyedState
+          def save_fields(out)
+            out.int("half_track", @half_track).int("slip", @slip).int("side", @side_base).int("zone", @zone)
+            out.int("time", @time).int("read_clock_in", @clock_at - @time).int("clocks", @clocks)
+            out.int("shift", @shift).int("ones", @ones).int("bits", @bits).int("write_shift", @write_shift)
+            out.bool("motor", @motor).bool("led", @led).bool("sync", @sync).bool("byte_ready", @byte_ready)
+            out.bool("byte_latched", @byte_latched).bool("writing", @writing).bool("write_gate", @write_gate)
+            out.bool("track_written", @track_written).optional_int("write_index", @write_index)
+          end
+
+          # Puts `disk` under the head without flushing the one there, as a
+          # snapshot load replaces it.
+          def load_fields(input, disk)
+            @disk = disk
+            load_head_fields(input)
+            load_flag_fields(input)
+            @clock = Track.cell(@zone)
+            @protected = disk&.write_protected? || false
+            track_written = input.bool("track_written", false)
+            write_index = input.optional_int("write_index")
+            load_track(@time)
+            @track_written = track_written
+            @write_index = write_index
+          end
+
+          private
+
+          def load_head_fields(input)
+            @half_track = input.int("half_track", @half_track)
+            @slip = input.masked("slip", @slip, 0x03)
+            @side_base = input.int("side", @side_base)
+            @zone = input.masked("zone", @zone, 0x03)
+            @time = input.int("time", @time)
+            @clock_at = @time + input.int("read_clock_in", @clock_at - @time)
+            @clocks = input.int("clocks", @clocks)
+            @shift = input.int("shift", @shift)
+            @ones = input.int("ones", @ones)
+            @bits = input.int("bits", @bits)
+            @write_shift = input.int("write_shift", @write_shift)
+          end
+
+          def load_flag_fields(input)
+            @motor = input.bool("motor", @motor)
+            @led = input.bool("led", @led)
+            @sync = input.bool("sync", @sync)
+            @byte_ready = input.bool("byte_ready", @byte_ready)
+            @byte_latched = input.bool("byte_latched", @byte_latched)
+            @writing = input.bool("writing", @writing)
+            @write_gate = input.bool("write_gate", @write_gate)
+          end
+        end
+
+        include KeyedState
+      end
+
+      class Bus
+        # The drive's RAM and the byte last on its data bus, in a keyed
+        # snapshot module (BL-D8-RAM).
+        def save_fields(out)
+          out.int("data", @data).bytes("ram", @ram.read(0, @ram.length))
+        end
+
+        def load_fields(input)
+          @data = input.byte("data", @data)
+          ram = @ram.read(0, @ram.length)
+          @ram.write(0, input.bytes_into("ram", ram))
+          @watching = false
+        end
+      end
+
+      # The drive's own fields in a keyed snapshot module (BL-D8): its model,
+      # its clock phase and cycle count, the SO pulse due, and the host's
+      # lines as the serial port latched them. A save settles the drive first, so it is awake;
+      # a load forgets its orbits.
+      module KeyedState
+        def save_fields(out)
+          settle!
+          out.text("model", model_name).int("phase", @phase).int("cycles", @cycles)
+          out.bool("so_pending", @mechanism.so_pending)
+          @serial_port.save_fields(out, "serial.")
+          out
+        end
+
+        def load_fields(input)
+          settle!
+          input.choice("model", [model_name], model_name)
+          @phase = input.int("phase", @phase)
+          @cycles = input.int("cycles", @cycles)
+          @mechanism.so_pending = input.bool("so_pending", @mechanism.so_pending)
+          @serial_port.load_fields(input, "serial.")
+        end
+
+        def restored! = forget_orbits
+
+        # The drive as modules of its own, named from `name` (BL-D8 for
+        # device 8): its own fields, its RAM, each VIA, the CPU, the
+        # mechanism and the disk, when one is in.
+        def save_modules(sections, name)
+          sections << Snapshot::Keyed.section(name) { |out| save_fields(out) }
+          sections << Snapshot::Keyed.section("#{name}-RAM") { |out| @bus.save_fields(out) }
+          sections << Snapshot::Keyed.section("#{name}-VIA1") { |out| @via1.save_fields(out) }
+          sections << Snapshot::Keyed.section("#{name}-VIA2") { |out| @via2.save_fields(out) }
+          sections << Snapshot::Keyed.section("#{name}-CPU") { |out| @cpu.save_fields(out) }
+          sections << Snapshot::Keyed.section("#{name}-MECH") { |out| @mechanism.save_fields(out) }
+          disk = @mechanism.disk
+          sections << Snapshot::Keyed.section("#{name}-DISK") { |out| disk.save_fields(out) } if disk
+          sections
+        end
+
+        # The drive from its modules, `input` being its own. No disk module
+        # means no disk in the drive.
+        def load_modules(modules, input, name)
+          load_fields(input)
+          @bus.load_fields(modules.required("#{name}-RAM"))
+          @via1.load_fields(modules.required("#{name}-VIA1"))
+          @via2.load_fields(modules.required("#{name}-VIA2"))
+          @cpu.load_fields(modules.required("#{name}-CPU"))
+          disk = modules.optional("#{name}-DISK")
+          mechanism = modules.required("#{name}-MECH")
+          @mechanism.load_fields(mechanism, disk.nil? ? nil : Disk.from_fields(disk, detached: modules.detached?))
+          @via1.restored!
+          @via2.restored!
+          @cpu.restored!
+          restored!
+        end
+      end
+
+      include KeyedState
+    end
+  end
+end