badline 0.11.1 → 0.12.0

data/lib/badline/cartridge.rb

@@ -63,11 +63,7 @@ module Badline
       end
 
       def from_crt(crt, **)
-        mapper = HARDWARE_TYPES.fetch(crt.hardware_type) do
-          raise UnsupportedTypeError,
-                "Unsupported cartridge hardware type #{crt.hardware_type}"
-        end
-        mapper.new(crt, **)
+        mapper_for(crt).new(crt, **)
       end
 
       # A cartridge built afresh from what save_setup wrote, before
@@ -76,9 +72,21 @@ module Badline
         return GeoRAM.new(size: input.int) if input.int == GEO_RAM_SETUP
 
         crt = Storage::CRTFile.new(bytes: input.string)
-        return RetroReplay.new(crt, flash_jumper: input.boolean?, bank_jumper: input.boolean?) if input.boolean?
+        mapper_for(crt).from_jumpers(crt, input)
+      end
 
-        from_crt(crt)
+      # A cartridge from its image and what save_jumpers wrote: whether
+      # there are jumpers, then their settings on a mapper that has them.
+      def from_jumpers(crt, input)
+        input.boolean?
+        new(crt)
+      end
+
+      def mapper_for(crt)
+        HARDWARE_TYPES.fetch(crt.hardware_type) do
+          raise UnsupportedTypeError,
+                "Unsupported cartridge hardware type #{crt.hardware_type}"
+        end
       end
     end
 
@@ -95,6 +103,7 @@ module Badline
       @exrom = crt.exrom
       @game = crt.game
       @roml = @romh = nil
+      @banks = nil
       @on_change = nil
       @on_nmi_change = nil
       @nmi = false
@@ -193,9 +202,22 @@ module Badline
       out.boolean(false)
     end
 
-    def save_mapper(_out); end
+    # The mapper's own state: where its windows point, for a mapper that
+    # moves them, and whatever a mapper adds after calling super.
+    def save_mapper(out)
+      save_windows(out, windows) if windows
+    end
 
-    def load_mapper(_input); end
+    def load_mapper(input)
+      load_windows(input, windows) if windows
+    end
+
+    # The banks and views ROML and ROMH can point at, which a snapshot
+    # names them by: the mapper's banks, or nothing for a mapper whose
+    # windows stay where install_chips put them.
+    def windows
+      [*@banks, EMPTY_BANK] if @banks
+    end
 
     # Where the ROML and ROMH windows point, as their places in `windows`,
     # the banks and views the mapper picks them from, or -1 for none.
@@ -232,6 +254,12 @@ module Badline
       @exrom, @game = MODES.fetch(mode)
     end
 
+    # Sets the lines and tells the machine to map the cartridge again.
+    def select_mode(mode)
+      self.mode = mode
+      changed!
+    end
+
     def open_bus(addr)
       @open_bus ? @open_bus.peek(addr) : 0xff
     end

data/lib/badline/cia/fast_forward.rb

@@ -4,6 +4,9 @@ module Badline
   class CIA
     # Running a CIA a stretch of cycles at once, for Drive::Idle.
     module FastForward
+      # quiet_cycles for a CIA whose counters will never set a flag.
+      QUIET = 1 << 40
+
       # Whether fast_forward can run the CIA: timer B stopped with nothing
       # in its pipeline, no interrupt or acknowledge on its way, CNT where it
       # was, the TOD clock stopped, and timer A either stopped, or free
@@ -16,11 +19,24 @@ module Badline
         @ta.idle? ? @serial.idle : timer_a_free_running?
       end
 
-      # Runs +cycles+ cycles at once while quiet?, as cycle! would: timer A's
-      # underflows flag in the ICR, and reach the serial port's underflow
-      # line.
+      # How many cycles the CIA can run with nothing but its counters
+      # moving: as quiet? allows, but with timer B free running too, up to
+      # the cycle before it underflows. The 1581's DOS leaves timer B
+      # interrupting every 10 ms.
+      def quiet_cycles
+        return 0 unless @icr.quiet && @tod.quiet? && cnt_steady? && timer_a_quiet?
+        return QUIET if @tb.idle?
+        return 0 unless @tb.free_running? && @control_b.value.nobits?(0x60)
+
+        @tb.counter - 1
+      end
+
+      # Runs +cycles+ cycles at once while quiet? or for quiet_cycles, as
+      # cycle! would: timer A's underflows flag in the ICR, and reach the
+      # serial port's underflow line.
       def fast_forward(cycles)
         @tod.fast_forward(cycles)
+        @tb.fast_forward(cycles) unless @tb.idle?
         return if @ta.idle?
 
         @icr.flag(:timer_a) if @ta.fast_forward(cycles).positive?
@@ -29,6 +45,8 @@ module Badline
 
       private
 
+      def timer_a_quiet? = @ta.idle? ? @serial.idle : timer_a_free_running?
+
       # Timer A free running with its interrupt masked, and the serial port
       # an idle input it only clocks.
       def timer_a_free_running?

data/lib/badline/cia.rb

@@ -61,14 +61,16 @@ module Badline
       @tb.latch = value
     end
 
-    def initialize(start: 0, peripheral: nil, model: :mos6526, region: Region::PAL)
+    # +tod_hz+ is the rate of the pulses on the TOD pin, the region's mains
+    # unless a machine feeds it otherwise, and 0 for a pin held still.
+    def initialize(start: 0, peripheral: nil, model: :mos6526, region: Region::PAL, tod_hz: nil)
       raise ArgumentError, "unknown CIA model #{model}" unless MODELS.include?(model)
 
       addressable_at(start, length: 2**8)
 
       @model = model
       @clock_hz = region.clock_hz
-      @mains_hz = region.mains_hz
+      @mains_hz = tod_hz || region.mains_hz
 
       @peripheral = peripheral
       @port_b4_handler = nil
@@ -139,9 +141,10 @@ module Badline
 
     # Port A as driven by the data/direction registers alone, without
     # peripheral pulldown. Cheap path for the VIC bank lookup.
-    def port_a_lines
-      driven_lines(@data_port_a, @data_dir_a)
-    end
+    def port_a_lines = driven_lines(@data_port_a, @data_dir_a)
+
+    # Port B as driven by the data/direction registers alone.
+    def port_b_lines = driven_lines(@data_port_b, @data_dir_b)
 
     def read_port_b
       lines = driven_lines(@data_port_b, @data_dir_b)

data/lib/badline/computer/attachments.rb

@@ -3,9 +3,11 @@
 module Badline
   class Computer
     # What plugs into the machine besides its chips, the cartridge, the
-    # disk device 8 serves through the traps, a true 1541 and an REU, and
-    # their state for a snapshot.
+    # disk device 8 serves through the traps, its true drives (TrueDrives)
+    # and an REU, and their state for a snapshot.
     module Attachments
+      include TrueDrives
+
       # Puts the cartridge in the expansion port and wires its clock and NMI
       # line to the machine, leaving the machine's state as it is. A
       # restored snapshot's cartridge comes back through here.
@@ -44,42 +46,8 @@ module Badline
       # it.
       attr_reader :iec_bus
 
-      # Plugs in a Drive1541, which then runs alongside the C64 on its own
-      # clock and talks to it over the serial bus. The serial traps stop
-      # answering the drive's device number, so the KERNAL's TALK, LISTEN and
-      # byte transfers reach the drive. The LOAD and SAVE traps stay, and
-      # still serve a mounted image.
-      def attach_drive1541(drive)
-        @iec_bus.detach(@drive1541) if @drive1541
-        drive.host_clock_hz = region.clock_hz
-        @drive1541 = drive
-        drive.connect(iec_bus)
-        @serial_trap&.device = serial_trap_device
-      end
-
-      # The true drive on the serial bus: the Drive1541, or nil.
-      def true_drive = @drive1541
-
-      # Plugs a Drive1541 in as device 8, and returns it.
-      def plug_true_drive = Drive1541.new.tap { |drive| attach_drive1541(drive) }
-
-      # Unplugs the Drive1541, leaving the serial bus with nothing on it.
-      def detach_drive1541
-        return unless @drive1541
-
-        @iec_bus.detach(@drive1541)
-        @drive1541 = nil
-        @serial_trap&.device = serial_trap_device
-      end
-
       private
 
-      # The device number the serial traps answer: device 8, unless a true
-      # drive is on the bus as device 8.
-      def serial_trap_device
-        @drive1541&.device == KernalTrap::Routine::DEVICE ? nil : KernalTrap::Routine::DEVICE
-      end
-
       # CIA 2's port A drives the serial bus, which reads CLK and DATA back
       # into it.
       def plug_serial_bus
@@ -132,26 +100,6 @@ module Badline
         @save_trap.load_state(input)
       end
 
-      # A true 1541 on the serial bus. The leading flag is the bus itself,
-      # which every machine now has, kept so older snapshots still load.
-      def save_serial_bus(out)
-        out.boolean(true).boolean(!@drive1541.nil?)
-        return unless @drive1541
-
-        out.int(@drive1541.device)
-        @drive1541.save_state(out)
-      end
-
-      def load_serial_bus(input)
-        input.boolean?
-        return detach_drive1541 unless input.boolean?
-
-        device = input.int
-        detach_drive1541 if @drive1541 && @drive1541.device != device
-        attach_drive1541(Drive1541.new(device:)) unless @drive1541
-        @drive1541.load_state(input)
-      end
-
       # The REU, which the setup says the machine has, and whether it has
       # asked for the bus. Its IRQ line reaches the CPU as it was.
       def save_reu(out)

data/lib/badline/computer/true_drives.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Badline
+  class Computer
+    # The true drives on the C64's serial bus: a Drive1541, and a Drive1581
+    # (Drive1581::Slot), each in a field of its own, and their state for a
+    # snapshot.
+    module TrueDrives
+      include Drive1581::Slot
+
+      # Plugs in a Drive1541, which then runs alongside the C64 on its own
+      # clock and talks to it over the serial bus. The serial traps stop
+      # answering the drive's device number, so the KERNAL's TALK, LISTEN and
+      # byte transfers reach the drive. The LOAD and SAVE traps stay, and
+      # still serve a mounted image.
+      def attach_drive1541(drive)
+        @iec_bus.detach(@drive1541) if @drive1541
+        drive.host_clock_hz = region.clock_hz
+        @drive1541 = drive
+        drive.connect(iec_bus)
+        @serial_trap&.device = serial_trap_device
+      end
+
+      # The true drive on the serial bus: the Drive1581 ahead of the
+      # Drive1541, or nil.
+      def true_drive = @drive1581 || @drive1541
+
+      # Plugs a Drive1541 in as device 8, in place of a 1581 there, and
+      # returns it.
+      def plug_true_drive
+        detach_drive1581 if drive1581_on_device8?
+        Drive1541.new.tap { |drive| attach_drive1541(drive) }
+      end
+
+      # Unplugs the Drive1541, leaving the serial bus with nothing on it.
+      def detach_drive1541
+        return unless @drive1541
+
+        @iec_bus.detach(@drive1541)
+        @drive1541 = nil
+        @serial_trap&.device = serial_trap_device
+      end
+
+      private
+
+      # The device number the serial traps answer: device 8, unless a true
+      # drive is on the bus as device 8.
+      def serial_trap_device
+        device = KernalTrap::Routine::DEVICE
+        @drive1541&.device == device || drive1581_on_device8? ? nil : device
+      end
+
+      # A true 1541 on the serial bus, then a 1581. The leading flag is the
+      # bus itself, which every machine now has.
+      def save_serial_bus(out)
+        out.boolean(true).boolean(!@drive1541.nil?)
+        if @drive1541
+          out.int(@drive1541.device)
+          @drive1541.save_state(out)
+        end
+        save_drive1581(out)
+      end
+
+      def load_serial_bus(input)
+        input.boolean?
+        load_drive1541(input)
+        load_drive1581(input)
+      end
+
+      def load_drive1541(input)
+        return detach_drive1541 unless input.boolean?
+
+        device = input.int
+        detach_drive1541 if @drive1541 && @drive1541.device != device
+        attach_drive1541(Drive1541.new(device:)) unless @drive1541
+        @drive1541.load_state(input)
+      end
+    end
+  end
+end

data/lib/badline/computer.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "badline/computer/true_drives"
 require "badline/computer/attachments"
 require "badline/computer/kernal_traps"
 require "badline/computer/saved_state"
@@ -77,6 +78,7 @@ module Badline
       @serial_trap = nil
       @save_trap = nil
       @drive1541 = nil
+      @drive1581 = nil
       plug_serial_bus
       @reu = reu ? plug_reu(reu) : nil
     end
@@ -101,6 +103,7 @@ module Badline
       watch_freeze if @freezing
       clock_cpu
       @drive1541&.host_cycle!
+      @drive1581&.host_cycle!
 
       @cycles += 1
     end
@@ -174,6 +177,7 @@ module Badline
       @dma = false
       @drive&.reset!
       @drive1541&.reset!
+      @drive1581&.reset!
       @freezing = false
       @nmi_asserted = false
       cpu.reset!

data/lib/badline/core.rb

@@ -38,6 +38,8 @@ require "badline/vic"
 require "badline/keyboard_buffer"
 require "badline/iec_bus"
 require "badline/drive1541"
+require "badline/drive1581"
+require "badline/drive1581/slot"
 require "badline/snapshot/state"
 require "badline/snapshot/setup"
 require "badline/computer"

data/lib/badline/drive/core.rb

@@ -3,8 +3,8 @@
 module Badline
   module Drive
     # What every Commodore disk drive here shares: a 6502 running the DOS
-    # ROM with two VIAs on its bus, VIA 1 facing the serial bus and VIA 2
-    # the disk mechanism, on a clock of its own.
+    # ROM, with chips on its bus facing the serial bus and the disk
+    # mechanism, on a clock of its own.
     #
     # The drive runs on its own crystal, so it clocks against the host's
     # clock through a fractional accumulator: each host cycle adds the
@@ -14,8 +14,7 @@ module Badline
     # every 67. The host sets its clock on attaching the drive, and until
     # then a 1 MHz drive runs one cycle per host cycle.
     #
-    # VIA 2's port B runs the Mechanism, which reads a Disk put in with
-    # insert.
+    # The Mechanism reads a Disk put in with insert.
     #
     # While the DOS idles, host_cycle! skips the drive's cycles and catches
     # up on them later, exactly (see Idle). The readers of the drive's parts
@@ -24,7 +23,10 @@ module Badline
     # sleeps through them too (see Orbit).
     #
     # A model includes Core and builds its parts, sets @clock_hz and
-    # @idle_loop, and runs one drive cycle in step.
+    # @idle_loop, and runs one drive cycle in step. It hears ATN on
+    # connecting (hear_atn), drives the serial bus (serial_output), and
+    # answers Idle's and Orbit's questions about its chips, as VIAs does
+    # for the 1541 and the 1571.
     module Core
       include Sleep
       include Idle
@@ -42,16 +44,6 @@ module Badline
         @bus
       end
 
-      def via1
-        settle!
-        @via1
-      end
-
-      def via2
-        settle!
-        @via2
-      end
-
       def mechanism
         settle!
         @mechanism
@@ -77,7 +69,7 @@ module Badline
         @serial_bus = serial_bus
         @serial_port.bus = serial_bus
         serial_bus.attach(self)
-        @via1.ca1 = @serial_port.atn_low?
+        hear_atn
       end
 
       # Puts a Disk in the drive (Disk.from_d64 makes one from an image).
@@ -93,10 +85,6 @@ module Badline
       # is the same at the end of every pass the drive sleeps through.
       def led_on? = @mechanism.led_on?
 
-      # VIA 1's port B as it drives the serial bus. It holds still while the
-      # drive sleeps, so reading it leaves the drive asleep.
-      def serial_output = @via1.port_b_output
-
       # Stores what the head wrote since the motor last stopped in the
       # disk's image, as the motor stopping does.
       def flush
@@ -104,15 +92,6 @@ module Badline
         @mechanism.flush
       end
 
-      # The serial bus's RESET line reaches the CPU and both VIAs. RAM keeps
-      # its contents.
-      def reset!
-        settle!
-        @via1.reset!
-        @via2.reset!
-        @cpu.reset!
-      end
-
       # Runs the drive cycles that fall in one host cycle: none, one or two.
       # The host has run this cycle already, and the drive sees what it did
       # from the next one on (see SerialPort). Asleep, the drive owes the
@@ -158,10 +137,6 @@ module Badline
 
       private
 
-      # Runs the model's chips beyond the VIAs +cycles+ quiet cycles at once
-      # (see quiet_cycles). The 1541 has none.
-      def fast_forward_chips(_cycles) = nil
-
       # A drive cycle from host_cycle!, which may find the idle loop.
       def run_cycle
         step

data/lib/badline/drive/fast_serial.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Badline
+  module Drive
+    # Fast serial on a drive with a CIA, the 1571's 6526 or the 1581's
+    # 8520: through buffers a port line turns round, the CIA's CNT drives
+    # SRQ and its SP drives DATA, or it hears them. The drive pushes its
+    # pins into the bus as they move, and hears the host's as the host
+    # pushes them, pin by pin, so each byte goes through both shift
+    # registers bit by bit. The CIA takes no part in a pass of the idle
+    # loop, and any access to it, or the host moving its fast serial pins,
+    # wakes the drive.
+    #
+    # A model includes it beside Core, and calls turn_fast_serial when its
+    # direction line moves and drive_fast_serial each cycle the buffers
+    # face out. Its serial_output carries @fast_output above its port.
+    module FastSerial
+      # Whether the buffers face out, the drive's CIA driving DATA and SRQ.
+      attr_reader :fast_serial_out
+
+      # The host moved its fast serial pins: the CIA hears SRQ on CNT and
+      # DATA on SP while the buffers face in.
+      def fast_lines_moved
+        settle!
+        hear_fast_serial unless @fast_serial_out
+      end
+
+      private
+
+      def init_fast_serial
+        @fast_serial_out = false
+        @fast_output = 0
+      end
+
+      # The buffers turned round: outwards the CIA's pins drive the lines,
+      # and inwards they let go and hear them.
+      def turn_fast_serial(out)
+        @fast_serial_out = out
+        return unless @serial_bus
+
+        push_fast_output(out ? fast_pins : 0)
+        hear_fast_serial unless out
+      end
+
+      def drive_fast_serial
+        low = fast_pins
+        push_fast_output(low) if low != @fast_output
+      end
+
+      # The lines the CIA's CNT and SP pull while its serial port drives
+      # them.
+      def fast_pins
+        serial = @cia.serial
+        return 0 unless serial.output?
+
+        low = serial.cnt ? 0 : IECBus::DRIVE_FAST_SRQ
+        serial.sp_out ? low : low | IECBus::DRIVE_FAST_DATA
+      end
+
+      def push_fast_output(low)
+        @fast_output = low
+        @serial_bus&.drives_fast_moved!
+      end
+
+      def hear_fast_serial
+        low = @serial_bus.low_lines
+        serial = @cia.serial
+        serial.cnt_in = low.nobits?(IECBus::SRQ)
+        serial.sp_in = low.nobits?(IECBus::DATA)
+      end
+    end
+  end
+end

data/lib/badline/drive/idle.rb

@@ -81,7 +81,7 @@ module Badline
       end
 
       def start_recording
-        return if @mechanism.motor_on? || @via1.irq? || @via2.irq? || @cpu.trapped?
+        return if busy_for_pass? || @cpu.trapped?
 
         @recording = true
         @record_state = idle_state
@@ -116,20 +116,10 @@ module Badline
         anchor
       end
 
-      def quiet_cycles
-        [@via1.quiet_cycles, @via2.quiet_cycles].min
-      end
-
       def ram_as_found?
         ram = @bus.ram
         @bus.touched.all? { |addr, value| ram.peek(addr) == value }
       end
-
-      def idle_state
-        mechanism = @mechanism
-        [*@cpu.idle_state, *@via1.idle_state, *@via2.idle_state, @bus.data, mechanism.so_pending,
-         *mechanism.idle_state, mechanism.read_a(0xff), mechanism.read_b(0xff)]
-      end
     end
   end
 end

data/lib/badline/drive/orbit.rb

@@ -63,9 +63,7 @@ module Badline
         cycles = orbits * @orbit_cycles
         touched = @bus.touched_timers
         @cpu.fast_forward(cycles, orbits * @orbit_instructions)
-        @via1.skip_orbits(cycles, touched & 0x03)
-        @via2.skip_orbits(cycles, touched >> 2)
-        fast_forward_chips(cycles)
+        skip_chip_orbits(cycles, touched)
         @cycles += cycles
         cycles
       end
@@ -74,8 +72,7 @@ module Badline
       # the unarmed timers it hasn't touched since it was last tainted.
       def anchor_state
         touched = @bus.touched_timers
-        [*idle_state, *@via1.counter_state(touched & 0x03), *@via2.counter_state(touched >> 2),
-         @bus.ram.snapshot]
+        [*idle_state, *counter_state(touched), @bus.ram.snapshot]
       end
     end
   end

data/lib/badline/drive/sleep.rb

@@ -102,8 +102,6 @@ module Badline
       def skip_passes(passes)
         cycles = passes * @pass_cycles
         @cpu.fast_forward(cycles, passes * @pass_instructions)
-        @via1.fast_forward(cycles)
-        @via2.fast_forward(cycles)
         fast_forward_chips(cycles)
         @cycles += cycles
         @budget -= cycles

data/lib/badline/drive/vias.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Badline
+  module Drive
+    # The two VIAs the 1541 and the 1571 share: VIA 1 facing the serial
+    # bus, its CA1 on ATN, and VIA 2 running the GCR Mechanism. A model
+    # includes it beside Core, and it answers Core's, Idle's and Orbit's
+    # questions about the chips: what they hold, how long their counters
+    # leave them quiet, and how to run them a stretch at once. A model with
+    # more chips on its bus runs them in fast_forward_more.
+    module VIAs
+      def via1
+        settle!
+        @via1
+      end
+
+      def via2
+        settle!
+        @via2
+      end
+
+      # Puts in a Disk from the .d64, .g64, .d71 or .g71 image at +path+
+      # (Drive1541::Disk.open), write-protected with `read_only`.
+      def insert_image(path, read_only: false)
+        insert(Drive1541::Disk.open(path, read_only:))
+      end
+
+      # VIA 1's port B as it drives the serial bus. It holds still while the
+      # drive sleeps, so reading it leaves the drive asleep.
+      def serial_output = @via1.port_b_output
+
+      # The serial bus's RESET line reaches the CPU and both VIAs. RAM keeps
+      # its contents.
+      def reset!
+        settle!
+        @via1.reset!
+        @via2.reset!
+        @cpu.reset!
+      end
+
+      private
+
+      # ATN reaches VIA 1's CA1 as the serial port latched it.
+      def hear_atn
+        @via1.ca1 = @serial_port.atn_low?
+      end
+
+      # Whether the drive is doing anything a pass of the idle loop can't
+      # repeat: the motor on, or a VIA pulling IRQ.
+      def busy_for_pass? = @mechanism.motor_on? || @via1.irq? || @via2.irq?
+
+      def quiet_cycles
+        [@via1.quiet_cycles, @via2.quiet_cycles].min
+      end
+
+      def idle_state
+        mechanism = @mechanism
+        [*@cpu.idle_state, *@via1.idle_state, *@via2.idle_state, @bus.data, mechanism.so_pending,
+         *mechanism.idle_state, mechanism.read_a(0xff), mechanism.read_b(0xff)]
+      end
+
+      # The counters an orbit has to bring back (VIA#counter_state).
+      def counter_state(touched)
+        [*@via1.counter_state(touched & 0x03), *@via2.counter_state(touched >> 2)]
+      end
+
+      def fast_forward_chips(cycles)
+        @via1.fast_forward(cycles)
+        @via2.fast_forward(cycles)
+        fast_forward_more(cycles)
+      end
+
+      def skip_chip_orbits(cycles, touched)
+        @via1.skip_orbits(cycles, touched & 0x03)
+        @via2.skip_orbits(cycles, touched >> 2)
+        fast_forward_more(cycles)
+      end
+
+      # Runs the model's chips beyond the VIAs +cycles+ quiet cycles at once
+      # (see quiet_cycles). The 1541 has none.
+      def fast_forward_more(_cycles) = nil
+    end
+  end
+end

data/lib/badline/drive.rb

@@ -4,6 +4,8 @@ require "badline/drive/sleep"
 require "badline/drive/idle"
 require "badline/drive/orbit"
 require "badline/drive/core"
+require "badline/drive/vias"
+require "badline/drive/fast_serial"
 require "badline/drive/idle_cpu"
 require "badline/drive/watch"
 require "badline/drive/serial_lines"