badline 0.2.0 → 0.3.0

data/lib/badline/kernal_trap/drive.rb

@@ -1,5 +1,11 @@
 # frozen_string_literal: true
 
+require "badline/kernal_trap/drive/block_commands"
+require "badline/kernal_trap/drive/channels"
+require "badline/kernal_trap/drive/memory"
+require "badline/kernal_trap/drive/parameters"
+require "badline/kernal_trap/drive/status"
+
 module Badline
   module KernalTrap
     # The CBM DOS side of the serial bus. Keeps the open channels, the
@@ -7,6 +13,8 @@ module Badline
     # buffer channel, which is how block-access loaders bypass the KERNAL's
     # LOAD.
     class Drive
+      include BlockCommands
+
       COMMAND_CHANNEL = 15
       BLOCK_SIZE = 256
 
@@ -14,96 +22,119 @@ module Badline
       WRITE_PROTECT_ON = 26
       SYNTAX_ERROR = 30
       FILE_NOT_FOUND = 62
+      FILE_EXISTS = 63
       ILLEGAL_TRACK_OR_SECTOR = 66
       NO_CHANNEL = 70
+      DOS_VERSION = 73
       DRIVE_NOT_READY = 74
 
-      MESSAGES = {
-        OK => " OK",
-        20 => "READ ERROR",
-        21 => "READ ERROR",
-        22 => "READ ERROR",
-        23 => "READ ERROR",
-        24 => "READ ERROR",
-        25 => "WRITE ERROR",
-        WRITE_PROTECT_ON => "WRITE PROTECT ON",
-        27 => "READ ERROR",
-        28 => "WRITE ERROR",
-        29 => "DISK ID MISMATCH",
-        SYNTAX_ERROR => "SYNTAX ERROR",
-        FILE_NOT_FOUND => "FILE NOT FOUND",
-        ILLEGAL_TRACK_OR_SECTOR => "ILLEGAL TRACK OR SECTOR",
-        NO_CHANNEL => "NO CHANNEL",
-        DRIVE_NOT_READY => "DRIVE NOT READY"
-      }.freeze
-
       MEMORY_COMMANDS = { "M-W" => :memory_write, "M-R" => :memory_read }.freeze
 
-      RAM_SIZE = 0x800
-
-      # The job queue: a job code for each of five buffers at $00, their
-      # track and sector pairs from $06, and the buffers from $0300. A job
-      # code is replaced by its result, 1 for success or an error table
-      # code: the DOS error less 18, or 15 for DRIVE NOT READY.
-      JOBS = 5
-      READ_JOB = 0x80
-      JOB_OK = 1
-      HEADER_NOT_FOUND = 20
+      # A U command jumps through the user table at $FFEA, indexed by the
+      # low nibble of its second character less one, so UA and UQ are U1.
+      # U1 and U2 read and write a block. U3 to U8 run code in the buffer
+      # at $0500, and the five entries past the table's end take vectors
+      # from the job queue. Neither runs here, so they report OK as a
+      # routine that returns does. U9 (UI) takes the NMI vector and U; the
+      # IRQ one, which restart the DOS with its RAM intact, except that a
+      # + or - after U9 only switches the bus speed. U: takes the reset
+      # vector, which runs the RAM test. U0 restores the table.
+      USER_TABLE = [:block_read, :block_write, *[:initialized] * 6,
+                    :warm_reset, :cold_reset, :warm_reset, *[:initialized] * 5].freeze
 
       COMMANDS = {
-        /\AU[1A]\s*:?\s*(.*)/i => :block_read,
+        /\AU[9IY)][+-]/i => :initialized,
+        /\AU.\s*:?\s*(.*)/i => :user,
         /\AB-R\s*:?\s*(.*)/i => :counted_block_read,
         /\AB-P\s*:?\s*(.*)/i => :buffer_pointer,
-        /\A[IV]/i => :initialized,
-        /\A(?:U[2B]|B-[WAF])/i => :write_protected
+        /\AB-W\s*:?\s*(.*)/i => :counted_block_write,
+        /\AI/i => :initialize_disk,
+        /\AV/i => :initialized,
+        /\AB-[AF]/i => :write_protected
       }.freeze
 
-      def initialize(storage)
+      # A drive powers on reporting its DOS version, as a reset does. It
+      # takes the RAM of the drive it replaces when the disk changes, and
+      # initializes the new disk.
+      def initialize(storage, memory = Memory.new)
         @storage = storage
-        @channels = {}
-        @status = Channel.new
-        @ram = Array.new(RAM_SIZE, 0)
-        report(OK)
+        @channels = Channels.new
+        @status = Status.new
+        @memory = memory
+        memory.storage = storage
+        memory.read_bam
+        report(DOS_VERSION)
       end
 
       # A name on the command channel is a command, "#" opens a block
       # buffer, anything else opens a file for reading. The name comes as
       # the bytes sent, because a memory command's arguments are binary.
+      # Opening a data channel initializes a disk a reset left uninitialized.
       def open(secondary, name)
+        @memory.read_bam unless @memory.bam? || secondary == COMMAND_CHANNEL
         if secondary == COMMAND_CHANNEL
           command(name.bytes) unless name.empty?
         elsif name.start_with?("#")
-          @channels[secondary] = Channel.new(Array.new(BLOCK_SIZE, 0))
-          report(OK)
+          opened = @channels.open_buffer(secondary, Parameters.parse(name[1..]).first, @memory)
+          report(opened ? OK : NO_CHANNEL)
         else
-          open_file(secondary, Storage.ascii(name.bytes))
+          open_file(secondary, Storage.ascii(without_return(name.bytes)))
         end
       end
 
       # Closing the command channel closes every other channel with it.
       def close(secondary)
-        secondary == COMMAND_CHANNEL ? @channels.clear : @channels.delete(secondary)
+        secondary == COMMAND_CHANNEL ? @channels.clear : @channels.close(secondary)
       end
 
+      # A buffer channel takes the bytes into its block. A file channel is
+      # open for reading, so writing to it fails as the disk is protected.
       def write(secondary, bytes)
-        return report(WRITE_PROTECT_ON) unless secondary == COMMAND_CHANNEL
+        return command(bytes) if secondary == COMMAND_CHANNEL
 
-        command(bytes)
+        channel = @channels[secondary]
+        return unless channel
+
+        channel.writable? ? channel.write(bytes) : report(WRITE_PROTECT_ON)
+      end
+
+      # A SAVE the trap hands over whole, to storage that can write files.
+      # A write the host refuses fails as a write-protected disk does.
+      # Returns whether the file was written.
+      def save(name, bytes)
+        saved = @storage.write_file(name, bytes)
+        saved ? report(OK) : report(WRITE_PROTECT_ON)
+        saved
       end
 
+      # Whether data sent on the channel reaches the drive. The command
+      # channel always listens, other channels once they are open.
+      def listening?(secondary)
+        secondary == COMMAND_CHANNEL || @channels.open?(secondary)
+      end
+
+      # The serial bus's RESET line restarts the DOS through its reset
+      # vector, as U: does.
+      def reset! = reset(cold: true)
+
       # Returns the next byte and whether it is the channel's last, or nil
       # when there is nothing left to send.
       def read(secondary)
-        secondary == COMMAND_CHANNEL ? read_status : @channels[secondary]&.read
+        return @status.read if secondary == COMMAND_CHANNEL
+
+        channel = @channels[secondary]
+        result = channel&.read
+        report(*channel.error) if result && channel.error && channel.exhausted?
+        result
       end
 
       private
 
-      def read_status
-        result = @status.read
-        report(OK) if result&.last
-
-        result
+      # The DOS cuts a name of two or more bytes at a carriage return in
+      # its last or second-to-last byte, as PRINT# ends a line with one.
+      def without_return(bytes)
+        cut = bytes.rindex(0x0d)
+        cut && bytes.length > 1 && cut >= bytes.length - 2 ? bytes[0, cut] : bytes
       end
 
       # Secondary addresses 0 and 1 are LOAD and SAVE, which look for a PRG
@@ -112,83 +143,90 @@ module Badline
       def open_file(secondary, name)
         file, type = Storage.parse_name(name)
         type ||= :prg if secondary < 2
-        data = @storage.read_file(file, type:)
-        @channels[secondary] = Channel.new(data || [])
-        report(data ? OK : FILE_NOT_FOUND)
-      end
+        return refuse_write(secondary, name, file) if secondary == 1 || mode?(name, "W")
+        return refuse_append(secondary, file, type) if mode?(name, "A")
 
-      def execute(text)
-        command = text.strip
-        pattern, action = COMMANDS.find { |candidate, _| candidate.match?(command) }
-        return report(SYNTAX_ERROR) unless action
+        channel = @channels.open_file(secondary, Channel.for_name(@storage, @memory, secondary, name, type))
+        return report(NO_CHANNEL) unless channel
 
-        send(action, arguments(pattern.match(command)[1]))
+        channel.failed? ? report(*channel.error) : report(OK)
       end
 
-      def arguments(text)
-        text.to_s.scan(/\d+/).map(&:to_i)
+      def mode?(name, mode)
+        name.split(",").drop(1).any? { |field| field.strip[0]&.upcase == mode }
       end
 
-      def command(bytes)
-        action = MEMORY_COMMANDS[bytes[0, 3].pack("C*")]
-        action ? send(action, bytes[3..]) : execute(Storage.ascii(bytes))
-      end
+      # The disk is write-protected, so an open for writing fails and leaves
+      # the channel closed. A name already on the disk fails as FILE EXISTS
+      # unless @ asks to replace it, anything else as WRITE PROTECT ON.
+      def refuse_write(secondary, name, file)
+        @channels.close(secondary)
+        return report(FILE_EXISTS) if !name.start_with?("@") && @storage.read_file(file, type: nil)
 
-      def block_read(arguments, counted: false)
-        channel, _drive, track, sector = arguments
-        buffer = @channels[channel]
-        return report(NO_CHANNEL) unless buffer
-        return report(DRIVE_NOT_READY) unless @storage.respond_to?(:read_block)
+        report(WRITE_PROTECT_ON, *protected_block(secondary))
+      end
 
-        data = sector && @storage.read_block(track, sector)
-        return report(ILLEGAL_TRACK_OR_SECTOR, track, sector) unless data
+      # An A mode open needs the file on the disk. It fails at the file's
+      # last block, the first one an append writes back.
+      def refuse_append(secondary, file, type)
+        @channels.close(secondary)
+        return report(FILE_NOT_FOUND) unless @storage.read_file(file, type:)
 
-        buffer.replace(counted ? data[0, data[0] + 1] : data)
-        buffer.pointer = 1 if counted
-        report_block_error(track, sector)
+        report(WRITE_PROTECT_ON, *(@storage.last_block(file, type:) if @storage.respond_to?(:last_block)))
       end
 
-      # A block the image's error table marks bad still fills the buffer,
-      # but the read reports its error, which copy protection checks for.
-      def report_block_error(track, sector)
-        error = @storage.block_error(track, sector)
-        error ? report(error, track, sector) : report(OK)
-      end
+      # SAVE's channel fails at the directory block its entry would go to,
+      # a W mode open at the disk's header block.
+      def protected_block(secondary)
+        return [] unless @storage.respond_to?(:header_block)
 
-      # B-R takes the block's first byte as the index of its last one, and
-      # hands out the bytes from the second up to there.
-      def counted_block_read(arguments)
-        block_read(arguments, counted: true)
+        secondary == 1 ? @storage.new_entry_block : @storage.header_block
       end
 
-      def buffer_pointer(arguments)
-        channel, position = arguments
-        buffer = @channels[channel]
-        return report(NO_CHANNEL) unless buffer
+      def execute(text)
+        command = text.strip
+        pattern, action = COMMANDS.find { |candidate, _| candidate.match?(command) }
+        return report(SYNTAX_ERROR) unless action
 
-        buffer.pointer = position.to_i
-        report(OK)
+        action = USER_TABLE[(command.getbyte(1) - 1) & 0x0f] if action == :user
+        run_command(action, Parameters.parse(pattern.match(command)[1]))
       end
 
-      # M-W takes an address, a count and that many bytes. Writes past the
-      # RAM are dropped, since the rest of the address space is I/O and ROM.
-      def memory_write(arguments)
-        address = word(arguments)
-        arguments[3, arguments[2].to_i].to_a.each.with_index(address) do |byte, target|
-          @ram[target] = byte if target < RAM_SIZE
+      def command(bytes)
+        action = MEMORY_COMMANDS[bytes[0, 3].pack("C*")]
+        action ? run_command(action, bytes[3..]) : execute(Storage.ascii(bytes))
+      end
+
+      def run_command(action, arguments)
+        case action
+        when :block_read then block_read(arguments)
+        when :block_write then block_write(arguments)
+        when :counted_block_write then counted_block_write(arguments)
+        when :counted_block_read then counted_block_read(arguments)
+        when :buffer_pointer then buffer_pointer(arguments)
+        when :initialized then report(OK)
+        when :initialize_disk then initialize_disk
+        when :write_protected then write_protected(arguments)
+        when :cold_reset then reset(cold: true)
+        when :warm_reset then reset(cold: false)
+        when :memory_write then memory_write(arguments)
+        when :memory_read then memory_read(arguments)
         end
-        run_jobs
+      end
+
+      # M-W takes an address, a count and that many bytes.
+      def memory_write(arguments)
+        @memory.write(word(arguments), arguments[3, arguments[2].to_i].to_a)
         report(OK)
       end
 
       # M-R takes an address and a count, and answers on the command
       # channel. Without a count, or with only the carriage return PRINT#
-      # ends a line with, it reads one byte. Only the RAM reads back.
+      # ends a line with, it reads one byte.
       def memory_read(arguments)
-        address = word(arguments)
         count = arguments[2..] == ["\r".ord] ? 1 : arguments.fetch(2, 1)
         count = BLOCK_SIZE if count.zero?
-        @status.replace(Array.new(count) { |i| @ram.fetch(address + i, 0) })
+        @status.replace(@memory.read(word(arguments), count))
         nil
       end
 
@@ -196,44 +234,22 @@ module Badline
         arguments[0].to_i | (arguments[1].to_i << 8)
       end
 
-      def run_jobs
-        JOBS.times do |job|
-          next unless @ram[job] == READ_JOB
-
-          track, sector = @ram[6 + (job * 2), 2]
-          @ram[job] = read_job(0x300 + (job * BLOCK_SIZE), track, sector)
-        end
-      end
-
-      def read_job(buffer, track, sector)
-        data = @storage.respond_to?(:read_block) && @storage.read_block(track, sector)
-        return job_result(HEADER_NOT_FOUND) unless data
-
-        @ram[buffer, BLOCK_SIZE] = data
-        job_result(@storage.block_error(track, sector))
-      end
-
-      def job_result(error)
-        return JOB_OK unless error
+      def write_protected(_arguments) = report(WRITE_PROTECT_ON)
 
-        error == DRIVE_NOT_READY ? 15 : error - 18
+      def reset(cold:)
+        @memory.clear if cold
+        @channels.clear
+        report(DOS_VERSION)
       end
 
-      def initialized(_arguments)
+      # I closes the data channels and reads the BAM again.
+      def initialize_disk
+        @channels.clear
+        @memory.read_bam
         report(OK)
       end
 
-      def write_protected(_arguments)
-        report(WRITE_PROTECT_ON)
-      end
-
-      def report(code, track = 0, sector = 0)
-        message = format("%<code>02d,%<message>s,%<track>02d,%<sector>02d\r",
-                         code:, message: MESSAGES.fetch(code),
-                         track: track.to_i, sector: sector.to_i)
-        @status.replace(message.bytes)
-        nil
-      end
+      def report(...) = @status.report(...)
     end
   end
 end

data/lib/badline/kernal_trap/file.rb

@@ -5,11 +5,6 @@ module Badline
     class File < Routine
       MISSING_FILENAME = 0x08
 
-      def initialize(cpu:, bus:, storage:)
-        super(cpu:, bus:)
-        @storage = storage
-      end
-
       private
 
       def active?

data/lib/badline/kernal_trap/load.rb

@@ -3,41 +3,118 @@
 module Badline
   module KernalTrap
     # PC trap on the KERNAL serial LOAD routine ($F4A5, the default ILOAD
-    # vector target). Serves device 8 requests from a storage backend and
-    # returns to the caller with the routine's register/zeropage contract;
-    # other devices fall through to the ROM.
+    # vector target). Reads device 8 requests from the virtual drive's
+    # channel 0, then hands over to the ROM's own tail so it prints
+    # SEARCHING FOR and LOADING (or VERIFYING) in direct mode, reports
+    # errors and returns with the routine's register/zeropage contract;
+    # other devices fall through to the ROM. So does a load that reaches
+    # below $0334, into the zero page, the stack or the KERNAL vectors: the
+    # ROM's byte loop then loads it through the serial traps, and a loader
+    # that overwrites ISTOP takes over mid-load as it does on a real drive.
     class Load < File
       ADDRESS = 0xf4a5
 
-      FILE_NOT_FOUND = 0x04
+      # ROM entry points: the SEARCHING FOR and LOADING/VERIFYING messages,
+      # the byte loop that retries a timed-out byte until RUN/STOP, the
+      # successful return (CLC, LDX $AE, LDY $AF, RTS) and the
+      # FILE NOT FOUND and MISSING FILE NAME error exits
+      SEARCHING_MESSAGE = 0xf5af
+      LOADING_MESSAGE = 0xf5d2
+      BYTE_LOOP = 0xf4f3
+      LOAD_DONE = 0xf5a9
+      FILE_NOT_FOUND_EXIT = 0xf704
+      MISSING_FILE_NAME_EXIT = 0xf710
+
+      # ST bits at $90
+      EOI = 0x40
+      VERIFY_MISMATCH = 0x10
+      READ_TIMEOUT = 0x02
+
+      # The ROM opens the file with secondary address $60 and leaves it in
+      # $B9, so a second LOAD without a SETLFS loads to the file's own
+      # address even when the first one relocated.
+      LOAD_SECONDARY = 0x60
+
+      def initialize(cpu:, bus:, drive:)
+        super(cpu:, bus:)
+        @drive = drive
+      end
 
       def call
         return unless active?
 
-        name, type = Storage.parse_name(filename)
-        if name.empty?
-          error(MISSING_FILENAME)
-        elsif (data = @storage.read_file(name, type: type || :prg))
-          deliver(data)
+        @bus.poke(0x93, @cpu.a)
+        @bus.poke(0x90, 0x00)
+        name = filename
+        return @cpu.program_counter = MISSING_FILE_NAME_EXIT if Storage.parse_name(name).first.empty?
+
+        data, complete = receive(name)
+        if low_memory?(data)
+          @drive.close(0)
         else
-          error(FILE_NOT_FOUND)
+          finish(data, complete)
         end
-        return_to_caller
       end
 
       private
 
-      # A=0 is LOAD, A=1 is VERIFY
+      # Reads the file the way the ROM's byte loop would, up to the byte
+      # flagged EOI. A read error in the file's chain stops the bytes early,
+      # with no EOI.
+      def receive(name)
+        @drive.open(0, name)
+        data = []
+        loop do
+          byte, eoi = @drive.read(0)
+          return [data, false] unless byte
+
+          data << byte
+          return [data, true] if eoi
+        end
+      end
+
+      # No first byte means the file isn't there, or its first block didn't
+      # read. A later read error leaves the ROM retrying the next byte
+      # until RUN/STOP breaks the load, as on a real drive.
+      def finish(data, complete)
+        if data.empty?
+          @bus.poke(0x90, EOI | READ_TIMEOUT)
+          continue_with(SEARCHING_MESSAGE, FILE_NOT_FOUND_EXIT)
+        else
+          deliver(data)
+          @bus.poke(0x90, @bus.peek(0x90) & ~EOI) unless complete
+          continue_with(SEARCHING_MESSAGE, LOADING_MESSAGE, complete ? LOAD_DONE : BYTE_LOOP)
+        end
+        @bus.poke(0xb9, LOAD_SECONDARY)
+      end
+
+      def low_memory?(data)
+        load? && data.length > 2 && load_address(data) < 0x0334
+      end
+
+      # A=0 is LOAD, A=1 is VERIFY, kept at $93 (VERCK)
       def load?
-        @cpu.a.zero?
+        @bus.peek(0x93).zero?
       end
 
       def deliver(data)
         addr = load_address(data)
         payload = data[2..] || []
         payload = payload[0, 0x10000 - addr] if addr + payload.length > 0x10000
-        @bus.ram.write(addr, payload) if load?
-        finish((addr + payload.length) & 0xffff)
+        if load?
+          @bus.ram.write(addr, payload)
+          @bus.poke(0x90, EOI)
+        else
+          verify(addr, payload)
+        end
+        end_addr = (addr + payload.length) & 0xffff
+        @bus.poke(0xae, low_byte(end_addr))
+        @bus.poke(0xaf, high_byte(end_addr))
+      end
+
+      def verify(addr, payload)
+        match = payload.each_with_index.all? { |byte, i| @bus.peek(addr + i) == byte }
+        @bus.poke(0x90, match ? EOI : EOI | VERIFY_MISMATCH)
       end
 
       # Secondary address $B9 zero relocates to the caller-supplied address
@@ -46,18 +123,9 @@ module Badline
         if @bus.peek(0xb9).zero?
           uint16(@bus.peek(0xc3), @bus.peek(0xc4))
         else
-          uint16(data[0], data[1])
+          uint16(data[0], data[1].to_i)
         end
       end
-
-      def finish(end_addr)
-        @bus.poke(0x90, 0x40)
-        @bus.poke(0xae, low_byte(end_addr))
-        @bus.poke(0xaf, high_byte(end_addr))
-        @cpu.x = low_byte(end_addr)
-        @cpu.y = high_byte(end_addr)
-        @cpu.status.carry = false
-      end
     end
   end
 end

data/lib/badline/kernal_trap/routine.rb

@@ -25,6 +25,23 @@ module Badline
         @cpu.program_counter = (uint16(pull_byte, pull_byte) + 1) & 0xffff
       end
 
+      # Runs the ROM routines in order, each returning into the next, and
+      # the last one to the trapped routine's caller
+      def continue_with(first, *rest)
+        rest.reverse_each { |address| push_address((address - 1) & 0xffff) }
+        @cpu.program_counter = first
+      end
+
+      def push_address(address)
+        push_byte(high_byte(address))
+        push_byte(low_byte(address))
+      end
+
+      def push_byte(value)
+        @bus.poke(0x0100 + @cpu.stack_pointer, value)
+        @cpu.stack_pointer = (@cpu.stack_pointer - 1) & 0xff
+      end
+
       def pull_byte
         @cpu.stack_pointer = (@cpu.stack_pointer + 1) & 0xff
         @bus.peek(0x0100 + @cpu.stack_pointer)

data/lib/badline/kernal_trap/save.rb

@@ -3,27 +3,65 @@
 module Badline
   module KernalTrap
     # PC trap on the KERNAL serial SAVE routine ($F5ED, the default ISAVE
-    # vector target). Writes device 8 saves to a storage backend as a PRG
+    # vector target). Hands device 8 saves to the virtual drive as a PRG
     # (load address followed by the memory range); other devices fall
-    # through to the ROM.
+    # through to the ROM. The ROM prints SAVING in direct mode and returns
+    # into the trap, which then writes the file and leaves through the
+    # ROM's own tail with the registers its UNLISTEN and return leave. A
+    # host write that fails ends the way a 1541 ends a SAVE it can't
+    # write: the drive stops listening, so ST reads DEVICE NOT PRESENT,
+    # and the ROM returns without an error.
     class Save < File
       ADDRESS = 0xf5ed
 
+      # ROM entry points: the SAVING message, the two line releases that
+      # end UNLISTEN (clock, then data, leaving A as read from $DD00), the
+      # successful return (CLC, RTS) and the MISSING FILE NAME error exit
+      SAVING_MESSAGE = 0xf68f
+      CLOCK_RELEASE = 0xee85
+      DATA_RELEASE = 0xee97
+      SAVE_DONE = 0xf657
+      MISSING_FILE_NAME_EXIT = 0xf710
+
+      SECONDARY = 0x61
+
+      # ST bit at $90
+      DEVICE_NOT_PRESENT = 0x80
+
+      def initialize(cpu:, bus:, drive:)
+        super(cpu:, bus:)
+        @drive = drive
+        @saving = false
+      end
+
       def call
         return unless active?
+        return finish if @saving
+
+        @bus.poke(0xb9, SECONDARY)
+        return @cpu.program_counter = MISSING_FILE_NAME_EXIT if name.empty?
 
-        name = Storage.parse_name(filename).first
-        if name.empty?
-          error(MISSING_FILENAME)
-        else
-          @storage.write_file(name, payload)
-          finish
-        end
-        return_to_caller
+        @bus.poke(0x90, 0x00)
+        @saving = true
+        continue_with(SAVING_MESSAGE, ADDRESS)
       end
 
       private
 
+      def name
+        Storage.parse_name(filename).first
+      end
+
+      def finish
+        @saving = false
+        @bus.poke(0x90, DEVICE_NOT_PRESENT) unless @drive.save(name, payload)
+        @bus.poke(0xac, @bus.peek(0xae))
+        @bus.poke(0xad, @bus.peek(0xaf))
+        @cpu.y = 0
+        @cpu.status.overflow = true
+        continue_with(CLOCK_RELEASE, DATA_RELEASE, SAVE_DONE)
+      end
+
       # Start address at $C1/$C2 (STAL), end address (exclusive) at
       # $AE/$AF (EAL)
       def payload
@@ -32,11 +70,6 @@ module Badline
         [low_byte(start), high_byte(start)] +
           Array.new(length) { |i| @bus.peek((start + i) & 0xffff) }
       end
-
-      def finish
-        @bus.poke(0x90, 0x00)
-        @cpu.status.carry = false
-      end
     end
   end
 end