badline 0.16.0 → 0.16.1

data/lib/badline/snapshot/vice/pet_mem.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Badline
+  module Snapshot
+    module Vice
+      module PET
+        # PETMEM 1.3: the board, the RAM below $8000 in K and the 8096's
+        # control register at $FFF0, then the RAM, the screen RAM, 1K or 2K
+        # as the board has, or on the 8296 its 32K from $8000, an 8096's or
+        # 8296's 64K board, and 24 bytes of xpet's own settings, which name
+        # the 2001.
+        #
+        # The board is 0 for the discrete video, 1 for a 40-column CRTC, 2
+        # for an 80-column one, 3 for the SuperPET, 4 for the 8096 and 5 for
+        # the 8296. xpet's ROMs aren't in the snapshot.
+        module PETMem
+          NAME = "PETMEM"
+          MAJOR = 1
+          MINOR = 3
+          DISCRETE = 0
+          CRTC40 = 1
+          CRTC80 = 2
+          SUPERPET = 3
+          CBM8096 = 4
+          CBM8296 = 5
+          # The byte after the header's control register, as xpet writes it.
+          HEADER_END = 0x05
+          # xpet's settings at the end, but for the second byte, which is
+          # SETTINGS_2001 on a 2001.
+          SETTINGS = [0x00, 0x00, 0x00, 0x00, 0xd6, 0x01, 0x00, 0x20, 0x00, 0x04, 0x00, 0x40, 0x00, 0x00, 0x00,
+                      0x01, 0x00, 0x00, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00].freeze
+          SETTINGS_2001 = 0x03
+          EXPANSION = 0x10000
+
+          module_function
+
+          def reads?(section) = section.major == MAJOR && section.minor == MINOR
+
+          def board(model)
+            return CBM8296 if model.cbm8296?
+            return CBM8096 if model.expansion
+
+            case model.video
+            when :crtc40 then CRTC40
+            when :crtc80 then CRTC80
+            else DISCRETE
+            end
+          end
+
+          def export(machine)
+            bus = machine.bus
+            expansion = bus.expansion
+            fields = FieldWriter.new.byte(board(machine.model)).byte(0).byte(machine.ram_kb)
+            fields.byte(expansion ? expansion.control : 0).byte(HEADER_END)
+            fields.bytes(machine.ram.snapshot).bytes(bus.screen.cells)
+            fields.bytes(expansion.cells) if expansion
+            settings = SETTINGS.dup
+            settings[1] = SETTINGS_2001 if machine.model.basic1?
+            fields.bytes(settings).section(NAME, MAJOR, MINOR)
+          end
+
+          # The board's number in the header.
+          def board_of(section) = FieldReader.new(section).byte
+
+          def ram_kb(section) = FieldReader.new(section).skip(2).byte
+
+          # Whether xpet's settings at the end name a 2001.
+          def pet2001?(section)
+            data = section.data
+            data.bytesize >= SETTINGS.length && data.getbyte(data.bytesize - SETTINGS.length + 1).to_i.anybits?(0x01)
+          end
+
+          # The RAM, the screen RAM and an 8096's or 8296's board and control
+          # register
+          # by their BL-RAM keys, in a keyed module's writer, for a machine
+          # with `screen_bytes` of screen RAM.
+          def import(section, out, screen_bytes)
+            fields = FieldReader.new(section)
+            board = fields.byte
+            fields.skip(1)
+            ram_kb = fields.byte
+            control = fields.byte
+            fields.skip(1)
+            out.bytes("ram", fields.string(ram_kb * 1024)).bytes("screen", fields.string(screen_bytes))
+            return unless [CBM8096, CBM8296].include?(board)
+
+            out.int("expansion.control", control).bytes("expansion.ram", fields.string(EXPANSION))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/badline/snapshot/vice/pet_pias.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Badline
+  module Snapshot
+    module Vice
+      module PET
+        # PIA1 and PIA2 1.0: port A's output and direction registers and
+        # its control register as read, with the CA1 and CA2 flags in bits 7
+        # and 6, the same for port B, and the levels on CA2 and CB2 in bits
+        # 7 and 6 of the last byte, high while a line is an input.
+        #
+        # Read: each side's flags come from its control register, and a
+        # handshake under way from the level its C2 output is at. The levels
+        # outside on CA1 and CB1 aren't saved: they stay as the machine has
+        # them, with PIA 1's CB1 on the vertical drive line.
+        module PIAs
+          NAMES = %w[PIA1 PIA2].freeze
+          MAJOR = 1
+          MINOR = 0
+          CA2_HIGH = 0x80
+          CB2_HIGH = 0x40
+          HANDSHAKE = 0x20
+
+          module_function
+
+          def reads?(section) = section.major == MAJOR && section.minor == MINOR
+
+          # The PIA's module, from its BL-PIA1 or BL-PIA2 fields in `input`.
+          def export(name, pia, input)
+            fields = FieldWriter.new.byte(input.int("ora", 0)).byte(input.int("ddra", 0)).byte(pia.cra)
+            fields.byte(input.int("orb", 0)).byte(input.int("ddrb", 0)).byte(pia.crb)
+            fields.byte((pia.ca2_output ? CA2_HIGH : 0) | (pia.cb2_output ? CB2_HIGH : 0))
+            fields.section(name, MAJOR, MINOR)
+          end
+
+          # The registers and the control lines by their BL-PIA keys, in a
+          # keyed module's writer.
+          def import(section, out)
+            ora, ddra, cra, orb, ddrb, crb, lines = FieldReader.new(section).bytes(7)
+            out.int("ora", ora).int("ddra", ddra).int("orb", orb).int("ddrb", ddrb)
+            control_lines(out, "ca.", cra, lines.anybits?(CA2_HIGH))
+            control_lines(out, "cb.", crb, lines.anybits?(CB2_HIGH))
+          end
+
+          def control_lines(out, prefix, register, c2_high)
+            control = register & 0x3f
+            out.int("#{prefix}control", control).bool("#{prefix}c1_flag", register.anybits?(0x80))
+            out.bool("#{prefix}c2_flag", register.anybits?(0x40)).int("#{prefix}pulse", 0)
+            out.bool("#{prefix}handshake_low", control & 0x38 == HANDSHAKE && !c2_high)
+            out.bool("#{prefix}c2_high", c2_high) if control.nobits?(0x20)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/badline/snapshot/vice/pet_restore.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module Badline
+  module Snapshot
+    module Vice
+      module PET
+        # Restores a PET from a snapshot xpet wrote. The modules badline
+        # reads become the PET's own keyed modules (Keyed), which it loads
+        # as it loads its own snapshot. Whatever they don't set stays as the
+        # machine has it at power-on, and the datasettes' tapes and the
+        # disk device 8 serves stay as they are.
+        module Restore
+          # MAINCPU and PETMEM hold the machine itself, so a version badline
+          # doesn't read fails the restore. The others are left out and
+          # reported.
+          READ = [MainCPU::NAME, PETMem::NAME, CRTC::NAME, "PIA1", "PIA2", VIA::NAME].freeze
+          # The host's media, which a restore keeps.
+          KEPT = %w[BL-TAPE1 BL-TAPE2 BL-TRAPDOS].freeze
+
+          module_function
+
+          # Applies the modules badline reads to `computer`, and returns a
+          # Report. The snapshot goes into a new machine first, so one that
+          # fails leaves `computer` as it was, and one of a machine built
+          # another way fails too.
+          def import(container, computer)
+            unless computer.family == :pet
+              raise FormatError, "the snapshot is of a PET, not a #{Image::FAMILIES.fetch(computer.family.to_s)}"
+            end
+
+            setup = PET.setup(container)
+            ours = PETSetup.of(computer)
+            raise FormatError, "the snapshot is of a #{setup}, not a #{ours}" unless setup == ours
+
+            apply(container, setup.build)
+            computer.power_cycle!
+            report = apply(container, computer)
+            kept = computer.mounted? ? ["the disk mounted in device 8 stays mounted"] : []
+            Report.new(applied: report.applied, ignored: report.ignored + kept)
+          end
+
+          # Applies the modules badline reads to `computer`, a machine built
+          # as the snapshot's was, and returns the Report.
+          def apply(container, computer)
+            applied = []
+            ignored = []
+            sections = []
+            READ.each do |name|
+              section = container[name]
+              next if section.nil?
+
+              if reads?(section)
+                applied << name
+              else
+                raise FormatError, "#{section}: badline doesn't read this version" if required?(name)
+
+                ignored << "#{section}: badline doesn't read this version, left out"
+              end
+            end
+            computer.save_modules.each { |section| sections << section if KEPT.include?(section.name) }
+            computer.load_modules(Keyed::Modules.new(modules(container, computer, applied) + sections))
+            Report.new(applied:, ignored: ignored + left_out(container))
+          end
+
+          def required?(name) = [MainCPU::NAME, PETMem::NAME].include?(name)
+
+          def reads?(section)
+            case section.name
+            when MainCPU::NAME then MainCPU.reads?(section)
+            when PETMem::NAME then PETMem.reads?(section)
+            when CRTC::NAME then CRTC.reads?(section)
+            when VIA::NAME then VIA.reads?(section)
+            else PIAs.reads?(section)
+            end
+          end
+
+          # The PET's keyed modules from the ones `applied` names.
+          def modules(container, computer, applied)
+            model = computer.model
+            crtc = applied.include?(CRTC::NAME) ? container[CRTC::NAME] : nil
+            video = video(crtc, computer)
+            drive = driving?(crtc, video, model)
+            sections = [Keyed.section("BL-MACHINE") { |out| machine(out, container, computer, drive) },
+                        Keyed.section("BL-RAM") do |out|
+                          PETMem.import(container[PETMem::NAME], out, model.screen_bytes)
+                        end]
+            sections << Keyed.section("BL-CPU") { |out| MainCPU.import(container[MainCPU::NAME], out) }
+            %w[PIA1 PIA2].each do |name|
+              next unless applied.include?(name)
+
+              sections << Keyed.section("BL-#{name}") do |out|
+                PIAs.import(container[name], out)
+                out.bool("cb.c1_high", drive) if name == "PIA1"
+              end
+            end
+            if applied.include?(VIA::NAME)
+              sections << Keyed.section("BL-VIA") { |out| VIA.import(container[VIA::NAME], out) }
+            end
+            sections + video
+          end
+
+          def machine(out, container, computer, drive)
+            out.text("family", "pet")
+            PETSetup.of(computer).write_fields(out)
+            out.int("cycles", FieldReader.new(container[MainCPU::NAME]).qword).bool("vertical_drive", drive)
+          end
+
+          # The vertical drive line, low in the CRTC's vertical sync or past
+          # the discrete video's rows, as the video's module, `video`, has it.
+          def driving?(crtc, video, model)
+            return true if crtc.nil?
+
+            fields = Keyed::Reader.parse(video.first)
+            if model.video == :discrete
+              fields.int("line", 0) < Badline::PET::DiscreteVideo::DISPLAYED_LINES
+            else
+              fields.int("vsync_lines", 0).zero?
+            end
+          end
+
+          # The discrete video's module, or the CRTC's, run on from xpet's
+          # counters to where badline's drops the vertical drive line on the
+          # cycle xpet's does (CRTC::CRTC_LEAD). The CRTC runs on from the
+          # start of the beam's line, or for a beam in the first cycles of
+          # its line, a frame less those cycles on, which lands on the same
+          # counters while the registers stood through the frame as they
+          # stand.
+          def video(crtc, computer)
+            return [] if crtc.nil?
+
+            model = computer.model
+            return [Keyed.section("BL-VIDEO") { |out| CRTC.import_discrete(crtc, out) }] if model.video == :discrete
+
+            counters = Keyed.section("BL-CRTC") do |out|
+              CRTC.import(crtc, out, CRTC.columns(model), CRTC.attributes(model))
+            end
+            cycles = (CRTC::CRTC_LEAD + CRTC.column_of(crtc)) % CRTC.frame_cycles(CRTC.registers(crtc))
+            fields = CRTC.run_on(computer, Keyed::Reader.parse(counters), cycles)
+            [Keyed.section("BL-CRTC") { |out| CRTC.copy(fields, out) }]
+          end
+
+          def left_out(container)
+            container.sections.reject { |section| READ.include?(section.name) }
+                     .map { |section| "#{section}: badline doesn't read this module, left out" }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/badline/snapshot/vice/pet_via.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+module Badline
+  module Snapshot
+    module Vice
+      module PET
+        # VIA 2.2, the 6522 at $E840: port A's and port B's output and
+        # direction registers, timer 1's latch and counter, timer 2's low
+        # and high latch, the value it was last loaded with and its counter,
+        # which timers will set their interrupt flag (timer 1 in bit 7,
+        # timer 2 in bit 6 while it counts cycles), the shift register, the
+        # ACR, the PCR, the interrupt flags and enable mask, timer 1's level
+        # on PB7 in bit 7, the shift register's clock ticks into its byte,
+        # CA2's level in bit 7, and whether timer 2's next underflow sets
+        # its flag. xpet saves each counter as a read on the next cycle
+        # finds it, where badline's holds it before that cycle counts.
+        #
+        # Written: timer 2's high latch and the value it was loaded with,
+        # which badline doesn't keep, as xpet has them before a program
+        # loads it, or while the shift register clocks off it, as its low
+        # byte reloads. Free-running, the shift register's ticks are only
+        # whether CB1 is low.
+        #
+        # Read: the registers and both timers with their latches, as they
+        # count from the next cycle, and the shift register where its clock
+        # ticks are. A load or reload under way, a shift clock tick due off
+        # timer 2 and the latched ports start afresh, and CB2's level
+        # follows from the PCR.
+        module VIA
+          NAME = "VIA"
+          MAJOR = 2
+          MINOR = 2
+          T1_ARMED = 0x80
+          T2_TIMED = 0x40
+          LEVELS = 0x60
+          # The shift register's clock ticks a byte takes, which an idle
+          # register's count stands at.
+          TICKS = 16
+          SIZE = 28
+          # The shift register's modes that clock off timer 2.
+          T2_SHIFTS = [1, 4, 5].freeze
+
+          module_function
+
+          def reads?(section) = section.major == MAJOR && section.minor == MINOR
+
+          # The VIA's module, from its BL-VIA fields in `input`.
+          def export(input)
+            fields = FieldWriter.new
+            %w[ora ddra orb ddrb].each { |key| fields.byte(input.int(key, 0)) }
+            fields.word(input.int("t1.latch", 0xffff)).word(timer1(input))
+            t2 = timer2(input)
+            latch_low = input.int("t2.latch_low", 0xff)
+            fields.byte(latch_low).byte(0xff).word(shifting?(input) ? (t2 & 0xff00) | latch_low : 0xffff).word(t2)
+            fields.byte(armed(input)).byte(input.int("sr.data", 0))
+            fields.byte(input.int("acr", 0)).byte(input.int("pcr", 0))
+            fields.byte(input.int("ifr.flags", 0)).byte(input.int("ifr.enable", 0))
+            fields.byte(input.bool("t1.pb7", true) ? 0x80 : 0)
+            fields.byte(ticks(input))
+            fields.byte(LEVELS | (input.bool("ca.c2_output", true) ? 0x80 : 0)).zeros(2)
+            fields.byte(input.bool("t2.armed", false) ? 1 : 0).zeros(2).section(NAME, MAJOR, MINOR)
+          end
+
+          # Timer 1's counter as a read on the next cycle finds it: as it
+          # stands while a load holds it, the latch while it reloads, and one
+          # less otherwise.
+          def timer1(input)
+            counter = input.int("t1.counter", 0xffff)
+            return counter if input.bool("t1.hold", false)
+            return input.int("t1.latch", 0xffff) if input.bool("t1.reload", false)
+
+            (counter - 1) & 0xffff
+          end
+
+          # Timer 2's counter as a read on the next cycle finds it: as it
+          # stands while it counts pulses or a load holds it, and one less
+          # otherwise.
+          def timer2(input)
+            counter = input.int("t2.counter", 0xffff)
+            return counter if input.bool("t2.hold", false) || input.bool("t2.counting_pulses", false)
+
+            (counter - 1) & 0xffff
+          end
+
+          # The shift register's clock ticks into its byte: two a bit, the
+          # first one dropping CB1, TICKS when idle. Free-running, its bits
+          # never run out, and only whether CB1 is low counts.
+          def ticks(input)
+            bits = input.int("sr.bits", 0)
+            return TICKS if bits.zero?
+
+            low = input.bool("sr.clock", true) ? 0 : 1
+            return low if input.int("sr.mode", 0) == 4
+
+            ((8 - bits) * 2) + low
+          end
+
+          # The shift register from its mode, data and the ticks into its
+          # byte (#ticks), with the last bit put out on CB2.
+          def shift_register(out, mode, data, ticks)
+            ticks = [ticks, TICKS].min
+            bits = ticks == TICKS ? 0 : 8 - (ticks / 2)
+            bits = 8 if mode == 4 && ticks < TICKS
+            out.int("sr.mode", mode).int("sr.data", data).int("sr.bits", bits).int("sr.delay", 0)
+            out.bool("sr.clock", ticks.even?).bool("sr.cb2", ticks.zero? || data.anybits?(0x01))
+          end
+
+          # Whether the shift register clocks off timer 2.
+          def shifting?(input) = T2_SHIFTS.include?((input.int("acr", 0) >> 2) & 0x07)
+
+          # Timer 2 sets its flag, or clocks the shift register, while it
+          # counts cycles.
+          def armed(input)
+            pulses = input.bool("t2.count_pulses", false)
+            timed = !pulses && (input.bool("t2.armed", false) || shifting?(input))
+            (input.bool("t1.armed", false) ? T1_ARMED : 0) | (timed ? T2_TIMED : 0)
+          end
+
+          # The registers, the timers and the control lines by their BL-VIA
+          # keys, in a keyed module's writer.
+          def import(section, out)
+            bytes = FieldReader.new(section).bytes(SIZE)
+            acr = bytes[0x10]
+            pcr = bytes[0x11]
+            out.int("ora", bytes[0]).int("ddra", bytes[1]).int("orb", bytes[2]).int("ddrb", bytes[3])
+            out.int("acr", acr).int("pcr", pcr)
+            timers(out, bytes, acr)
+            shift_register(out, (acr >> 2) & 0x07, bytes[0x0f], bytes[0x15])
+            out.int("ifr.flags", bytes[0x12] & 0x7f).int("ifr.enable", bytes[0x13] & 0x7f)
+            control_lines(out, "ca.", pcr & 0x0f, bytes[0x16].anybits?(0x80))
+            control_lines(out, "cb.", pcr >> 4, true)
+          end
+
+          def timers(out, bytes, acr)
+            out.int("t1.latch", bytes[4] | (bytes[5] << 8)).int("t1.counter",
+                                                                ((bytes[6] | (bytes[7] << 8)) + 1) & 0xffff)
+            out.bool("t1.hold", false)
+            out.bool("t1.reload", false).bool("t1.armed", bytes[0x0e].anybits?(T1_ARMED))
+            out.bool("t1.pb7", bytes[0x14].anybits?(0x80))
+            pulses = acr.anybits?(0x20)
+            t2 = bytes[0x0c] | (bytes[0x0d] << 8)
+            out.int("t2.latch_low", bytes[8]).int("t2.counter", pulses ? t2 : (t2 + 1) & 0xffff).bool("t2.hold", false)
+            out.bool("t2.low_reload", false).bool("t2.low_underflowed", false)
+            out.bool("t2.armed", bytes[0x19].anybits?(0x01))
+            out.bool("t2.count_pulses", pulses).bool("t2.counting_pulses", pulses)
+          end
+
+          # A handshake under way holds C2 low.
+          def control_lines(out, prefix, control, c2_high)
+            mode = control >> 1
+            handshake_low = mode == 4 && !c2_high
+            output = case mode
+                     when 4 then !handshake_low
+                     when 6 then false
+                     else true
+                     end
+            out.int("#{prefix}control", control).bool("#{prefix}handshake_low", handshake_low)
+            out.int("#{prefix}pulse", 0).bool("#{prefix}c2_output", output)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/badline/snapshot/vice.rb

@@ -13,6 +13,7 @@ require "badline/snapshot/vice/peripherals"
 require "badline/snapshot/vice/vicii"
 require "badline/snapshot/vice/vicii_import"
 require "badline/snapshot/vice/restore"
+require "badline/snapshot/vice/pet"
 
 module Badline
   module Snapshot

data/lib/badline/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Badline
-  VERSION = "0.16.0"
+  VERSION = "0.16.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: badline
 version: !ruby/object:Gem::Version
-  version: 0.16.0
+  version: 0.16.1
 platform: ruby
 authors:
 - Inge Jørgensen
@@ -314,6 +314,10 @@ files:
 - lib/badline/drives/model1581/wd1772/stepping.rb
 - lib/badline/drives/model1581/wd1772/tracks.rb
 - lib/badline/drives/model1581/wd1772/turn.rb
+- lib/badline/drives/model2031.rb
+- lib/badline/drives/model2031/ieee_port.rb
+- lib/badline/drives/model2031/keyed_state.rb
+- lib/badline/drives/model2031/parts.rb
 - lib/badline/drives/serial_bus.rb
 - lib/badline/ffi.rb
 - lib/badline/frontend.rb
@@ -428,6 +432,7 @@ files:
 - lib/badline/pet/cpu.rb
 - lib/badline/pet/crtc_video.rb
 - lib/badline/pet/discrete_video.rb
+- lib/badline/pet/ieee_drive.rb
 - lib/badline/pet/ieee_ports.rb
 - lib/badline/pet/ieee_traps.rb
 - lib/badline/pet/keyboard_ports.rb
@@ -469,6 +474,7 @@ files:
 - lib/badline/roms/dos1551.rom
 - lib/badline/roms/dos1571.rom
 - lib/badline/roms/dos1581.rom
+- lib/badline/roms/dos2031.rom
 - lib/badline/roms/eapi/LICENSE.md
 - lib/badline/roms/eapi/README
 - lib/badline/roms/eapi/eapi-am29f040-14
@@ -478,6 +484,7 @@ files:
 - lib/badline/roms/pet/basic1.rom
 - lib/badline/roms/pet/basic2.rom
 - lib/badline/roms/pet/basic4.rom
+- lib/badline/roms/pet/characters-din.rom
 - lib/badline/roms/pet/characters1.rom
 - lib/badline/roms/pet/characters2.rom
 - lib/badline/roms/pet/editor1.rom
@@ -486,6 +493,7 @@ files:
 - lib/badline/roms/pet/editor4-40-n-50hz.rom
 - lib/badline/roms/pet/editor4-40-n-60hz.rom
 - lib/badline/roms/pet/editor4-80-b-50hz-0283.rom
+- lib/badline/roms/pet/editor4-80-b-50hz-8296.rom
 - lib/badline/roms/pet/editor4-80-b-50hz.rom
 - lib/badline/roms/pet/editor4-80-b-60hz.rom
 - lib/badline/roms/pet/editor4-b.rom
@@ -535,6 +543,13 @@ files:
 - lib/badline/snapshot/vice/fields.rb
 - lib/badline/snapshot/vice/main_cpu.rb
 - lib/badline/snapshot/vice/peripherals.rb
+- lib/badline/snapshot/vice/pet.rb
+- lib/badline/snapshot/vice/pet_cpu.rb
+- lib/badline/snapshot/vice/pet_crtc.rb
+- lib/badline/snapshot/vice/pet_mem.rb
+- lib/badline/snapshot/vice/pet_pias.rb
+- lib/badline/snapshot/vice/pet_restore.rb
+- lib/badline/snapshot/vice/pet_via.rb
 - lib/badline/snapshot/vice/restore.rb
 - lib/badline/snapshot/vice/reu1764.rb
 - lib/badline/snapshot/vice/reu_fields.rb