badline 0.10.1 → 0.11.1

data/lib/badline/c128/bus.rb

@@ -0,0 +1,347 @@
+# frozen_string_literal: true
+
+module Badline
+  class C128
+    # The 8502's bus over the 128K of RAM, as the MMU maps it.
+    #
+    # In C128 mode CR picks what the CPU sees: BASIC at $4000-$BFFF, the
+    # screen editor, the character ROM and the KERNAL at $C000-$FFFF, an
+    # empty function ROM socket, or RAM, and I/O at $D000-$DFFF. The MMU's
+    # registers sit at $D500 and its configuration registers at
+    # $FF00-$FF04.
+    #
+    # In C64 mode the 8721 PLA decodes $01's LORAM, HIRAM and CHAREN and the
+    # cartridge's EXROM and GAME as a C64's does (AddressBus::PLA), and the
+    # MMU answers nowhere.
+    #
+    # In both modes the RAM is the bank CR picks, with common RAM in bank 0,
+    # and a page that page 0 or page 1 moves to reaches page 0 or page 1 of
+    # that bank. C128 mode also moves page 0 and page 1 there. The I/O area:
+    #
+    # $D000-$D3FF - the VIC-IIe
+    # $D400-$D4FF - the SID, with no mirrors above it
+    # $D500-$D5FF - the MMU in C128 mode, nothing in C64 mode
+    # $D600-$D6FF - the VDC
+    # $D700-$D7FF - nothing, but for VICE's debug register at $D7FF
+    # $D800-$DBFF - colour RAM
+    # $DC00-$DCFF - CIA 1
+    # $DD00-$DDFF - CIA 2
+    # $DE00-$DFFF - I/O 1 and 2, for cartridges
+    #
+    # An empty page reads the byte the VIC fetched in the preceding phi1
+    # half-cycle, as I/O 1 and 2 do on the C64.
+    #
+    # Colour RAM has two 1K banks (ColorLines).
+    class Bus
+      include Addressable
+      include AddressBus::PLA
+      include AddressBus::ROMs
+      include MMUPages
+      include SavedState
+
+      # The 8502's port has seven pins. P0-P5 are the 6510's, and P6 senses
+      # the CAPS LOCK key, high while it is up. Bit 7 has no pin, and holds
+      # the charge last driven onto it, as the 6510's floating bits do.
+      PORT_PULLUPS  = 0b0001_0111
+      PORT_FLOATING = 0b1000_1000
+      CAPS_LOCK     = 0b0100_0000
+      TAPE_SENSE    = 0b0001_0000
+
+      # The C64's power-on pattern (AddressBus::RAM_POWER_ON) in both 64K
+      # banks. The C128's own DRAMs' pattern is unmeasured.
+      RAM_POWER_ON = Array.new(2**17) { |addr| AddressBus::RAM_POWER_ON[addr & 0xffff] }.freeze
+
+      # The VIC's write side: a write to $D02F also drives the extra
+      # keyboard lines K0-K2 onto the keyboard's rows 8-10.
+      class VICWrites
+        def initialize(vic, control_ports)
+          @vic = vic
+          @control_ports = control_ports
+        end
+
+        def peek(addr) = @vic.peek(addr)
+
+        def poke(addr, value)
+          @vic.poke(addr, value)
+          @control_ports.extra_rows = 0xf8 | @vic.extra_keyboard_lines if (addr & 0x3f) == 0x2f
+        end
+      end
+
+      # The $D7xx page with VICE's debug register at $D7FF: a write there
+      # hands the handler its byte, and the rest of the page is empty.
+      class DebugPage
+        ADDRESS = 0xd7ff
+
+        def initialize(open_bus, &handler)
+          @open_bus = open_bus
+          @handler = handler
+        end
+
+        def peek(addr) = @open_bus.peek(addr)
+
+        def poke(addr, value)
+          @handler.call(value) if addr == ADDRESS
+        end
+      end
+
+      # RAM seen somewhere else: the address's bits in +mask+ from +base+
+      # on. Bank 1 is the whole 64K from $10000, and a relocated page the
+      # low byte from the page it moved to.
+      class RAMWindow
+        attr_accessor :base
+
+        def initialize(ram, base, mask)
+          @ram = ram
+          @base = base
+          @mask = mask
+        end
+
+        def peek(addr) = @ram.peek(@base | (addr & @mask))
+        def poke(addr, value) = @ram.poke(@base | (addr & @mask), value)
+      end
+
+      # The page at $FF00 in C128 mode: CR and the LCRs at $FF00-$FF04, and
+      # whatever CR maps there above them.
+      class ConfigurationPage
+        attr_accessor :below
+
+        def initialize(mmu, below)
+          @mmu = mmu
+          @below = below
+        end
+
+        def peek(addr) = addr < 0xff05 ? @mmu.peek_configuration(addr) : @below.peek(addr)
+
+        def poke(addr, value)
+          addr < 0xff05 ? @mmu.poke_configuration(addr, value) : @below.poke(addr, value)
+        end
+      end
+
+      attr_reader :io_port, :ram, :mmu, :vic, :sid, :vdc, :color_ram, :cia1, :cia2, :keyboard, :joystick1,
+                  :joystick2, :control_ports, :cartridge, :ultimax, :phi1_ultimax, :datasette, :region
+
+      # The C128 mode ROMs: BASIC's two halves, the screen editor, the
+      # KERNAL and the character ROM's C128 set.
+      attr_reader :basic_low_rom, :basic_high_rom, :editor_rom, :c128_kernal_rom, :c128_character_rom
+
+      # Whether CAPS LOCK is down, holding P6 low.
+      attr_reader :caps_lock
+
+      # The chips +model+, a Model::Profile, names, with the SID
+      # +sid_model+. +mode+ is the mode the MMU resets into.
+      def initialize(model, sid_model: model.sid_model, mode: :c64)
+        @region = model.region
+        @ram = Memory.new(RAM_POWER_ON, length: 2**17, start: 0)
+        @bank1 = RAMWindow.new(@ram, 0x10000, 0xffff)
+        @relocated = Array.new(4) { RAMWindow.new(@ram, 0, 0xff) }
+        @mmu = MMU.new(mode)
+        @cartridge = nil
+        @debug_page = nil
+        @caps_lock = false
+
+        load_roms
+        load_c128_roms
+        @banks = Banks.new(@ram, @mmu, @c128_kernal_rom)
+        @c64_mode = @mmu.c64_mode?
+        @on_mode_change = nil
+        plug_chips(model, sid_model)
+
+        @datasette = Datasette.new
+        @datasette.on_flag { @cia1.flag! }
+        @datasette.on_sense_change { @io_port.value = port_value }
+
+        @color_lines = ColorLines.new(@vic, @cia2, character_rom, @c128_character_rom)
+        @color_ram = @color_lines.color_ram(1)
+        @vic_writes = VICWrites.new(@vic, @control_ports)
+        @open_bus = AddressBus::OpenBus.new(@vic)
+        @configuration_reads = ConfigurationPage.new(@mmu, @open_bus)
+        @configuration_writes = ConfigurationPage.new(@mmu, @open_bus)
+
+        @port_ddr = 0x00
+        @port_out = 0x00
+        @port_floating = 0x00
+        @io_port = PortStatus.new(%i[basic kernal io tape_out tape_switch tape_motor], value: port_value)
+
+        @read_pages = Array.new(256)
+        @write_pages = Array.new(256)
+        @address = 0
+        @data = 0
+        @io_mapped = false
+        @mmu.on_change { update_overlays! }
+        update_overlays!
+      end
+
+      def attach_cartridge(cartridge)
+        @cartridge = cartridge
+        cartridge.connect(ram: @ram, open_bus: @open_bus)
+        cartridge.on_change { update_overlays! }
+        update_overlays!
+      end
+
+      # Takes the cartridge out of the expansion port.
+      def detach_cartridge
+        @cartridge = nil
+        update_overlays!
+      end
+
+      def power_on!
+        @ram.clear!(RAM_POWER_ON)
+      end
+
+      # The RES line clears the port's direction and output registers and
+      # resets the MMU. The port's floating bit keeps its charge.
+      def reset!
+        @port_ddr = 0x00
+        @port_out = 0x00
+        @mmu.reset!
+        update_port!
+      end
+
+      # Holds CAPS LOCK down, or lets it up.
+      def caps_lock=(down)
+        @caps_lock = down
+        @io_port.value = port_value
+      end
+
+      # Calls the block whenever MCR bit 6 takes the machine into C64 mode or
+      # a reset brings it back to C128 mode.
+      def on_mode_change(&block)
+        @on_mode_change = block
+      end
+
+      # Whether the CPU sees the C128 KERNAL, in C128 mode with CR's system
+      # ROM at $C000-$FFFF.
+      def system_rom_mapped? = !@mmu.c64_mode? && @mmu.cr.nobits?(0x30)
+
+      # The RAM the C128 KERNAL's bank number +bank+ reaches (Banks).
+      def peek_bank(bank, addr) = @banks.peek(bank, addr)
+
+      def write_bank(bank, addr, bytes) = @banks.write(bank, addr, bytes)
+
+      def install_debug_register(&)
+        @debug_page = DebugPage.new(@open_bus, &)
+        update_overlays!
+      end
+
+      # The address and the byte of the CPU's last access, which a VIC-IIe
+      # in FAST mode fetches in place of its own, and which tells the
+      # machine when an access reached I/O.
+      attr_reader :address, :data
+
+      def peek(addr)
+        @address = addr
+        @data = if addr > 0x01
+                  @read_pages[addr >> 8].peek(addr)
+                else
+                  addr.zero? ? @port_ddr : @io_port.value
+                end
+      end
+
+      # Whether the last access went to a chip at $D000-$DFFF, which runs
+      # at 1 MHz.
+      def io_access? = @io_mapped && (@address & 0xf000) == 0xd000
+
+      # Whether the last access went to the VIC's registers.
+      def vic_access? = @io_mapped && (@address & 0xfc00) == 0xd000
+
+      # A write to $00 or $01 goes to the port, and the RAM below takes the
+      # byte the VIC fetched in the phi1 half of the cycle.
+      def poke(addr, value)
+        @address = addr
+        @data = value
+        if addr < 0x02
+          @write_pages[0].poke(addr, @vic.phi1_data)
+          addr.zero? ? @port_ddr = value : @port_out = value
+          update_port!
+        else
+          @write_pages[addr >> 8].poke(addr, value)
+        end
+      end
+
+      def inspect
+        "#<#{self.class.name} mode=#{@mmu.mode} port=#{format('0x%02x', @io_port.value)} " \
+          "cartridge=#{@cartridge ? @cartridge.class.name : 'none'} " \
+          "ultimax=#{@ultimax}>"
+      end
+
+      private
+
+      def load_c128_roms
+        basic = ROM.read("c128/basic.rom")
+        kernal = ROM.read("c128/kernal.rom")
+        @basic_low_rom = ROM.new(basic[0, 0x4000], length: 0x4000, start: 0x4000)
+        @basic_high_rom = ROM.new(basic[0x4000, 0x4000], length: 0x4000, start: 0x8000)
+        @editor_rom = ROM.new(kernal[0, 0x1000], length: 0x1000, start: 0xc000)
+        @c128_kernal_rom = ROM.new(kernal[0x2000, 0x2000], length: 0x2000, start: 0xe000)
+        characters = ROM.read("c128/character.rom")
+        @c128_character_rom = ROM.new(characters[0x1000, 0x1000], length: 0x1000, start: 0xd000)
+      end
+
+      def plug_chips(model, sid_model)
+        @keyboard = Keyboard.new(matrix: KEYBOARD_MATRIX)
+        @joystick1 = Joystick.new
+        @joystick2 = Joystick.new
+        @control_ports = ControlPorts.new(keyboard: @keyboard, joystick1: @joystick1, joystick2: @joystick2)
+        @vic = VIC.new(model: model.vic_model, region: @region)
+        @cia1 = CIA.new(start: 0xdc00, peripheral: @control_ports, model: model.cia_model, region: @region)
+        @cia2 = CIA.new(start: 0xdd00, model: model.cia_model, region: @region)
+        @control_ports.port_a_source = @cia1
+        @cia1.on_port_b4_change { |high| @vic.lightpen_level(high) }
+        @sid = SID.new(model: sid_model, pots: @control_ports)
+        @vdc = VDC.new(model: model.vdc_model, ram_kb: model.vdc_ram_kb, clock_hz: @region.clock_hz)
+      end
+
+      def update_port!
+        driven = @port_ddr & PORT_FLOATING
+        @port_floating = (@port_floating & ~driven) | (@port_out & driven)
+        @io_port.value = port_value
+        @datasette.motor = !@io_port.tape_motor?
+        update_overlays!
+      end
+
+      def port_value
+        input = PORT_PULLUPS | (@port_floating & PORT_FLOATING)
+        input |= CAPS_LOCK unless @caps_lock
+        input &= ~TAPE_SENSE if @datasette.sense_low?
+        (@port_out & @port_ddr) | (input & ~@port_ddr & 0xff)
+      end
+
+      def update_overlays!
+        @ultimax = @cartridge ? @cartridge.ultimax? : false
+        @phi1_ultimax = @cartridge ? @cartridge.phi1_ultimax? : false
+        @mmu.game = @cartridge ? @cartridge.game : 1
+        @mmu.exrom = @cartridge ? @cartridge.exrom : 1
+        c64_mode = @mmu.c64_mode?
+        port = @io_port.value
+        @color_lines.push(c64_mode, port)
+        @vic.vic_bank.map(@ram, base: @mmu.vic_bank << 16, phi1_ultimax: @phi1_ultimax, ultimax: @ultimax,
+                                romh: @cartridge&.romh)
+        @color_ram = @color_lines.cpu_color_ram(c64_mode, port)
+        c64_mode ? map_pla_pages : map_c128_pages
+        mode_changed if c64_mode != @c64_mode
+      end
+
+      def mode_changed
+        @c64_mode = !@c64_mode
+        @on_mode_change&.call
+      end
+
+      def map_io_pages
+        @io_mapped = true
+        @read_pages.fill(@vic, 0xd0, 4)
+        @write_pages.fill(@vic_writes, 0xd0, 4)
+        @read_pages[0xd4] = @write_pages[0xd4] = @sid
+        @read_pages[0xd5] = @write_pages[0xd5] = @mmu.c64_mode? ? @open_bus : @mmu
+        @read_pages[0xd6] = @write_pages[0xd6] = @vdc
+        @read_pages[0xd7] = @write_pages[0xd7] = @debug_page || @open_bus
+        @read_pages.fill(@color_ram, 0xd8, 4)
+        @write_pages.fill(@color_ram, 0xd8, 4)
+        @read_pages[0xdc] = @write_pages[0xdc] = @cia1
+        @read_pages[0xdd] = @write_pages[0xdd] = @cia2
+        @read_pages.fill(@open_bus, 0xde, 2)
+        @write_pages.fill(@open_bus, 0xde, 2)
+        map_cartridge_io if @cartridge
+      end
+    end
+  end
+end

data/lib/badline/c128/bus_state.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Badline
+  class C128
+    class Bus
+      # The bus's state for a snapshot, as AddressBus::SavedState is the
+      # C64's.
+      module SavedState
+        # The machine's memory, the last access and everything on the bus but
+        # the keyboard, the joysticks, the pot devices and CAPS LOCK, which the
+        # host holds. A cartridge is already in the port, built from its setup.
+        def save_state(out)
+          out.marker("C128 BUS")
+          out.int(@port_ddr).int(@port_out).int(@port_floating).int(@address).int(@data)
+          @mmu.save_state(out)
+          @ram.save_state(out)
+          @color_lines.color_ram(0).save_state(out)
+          @color_lines.color_ram(1).save_state(out)
+          @cartridge&.save_state(out)
+          @datasette.save_state(out)
+          @vic.save_state(out)
+          @cia1.save_state(out)
+          @cia2.save_state(out)
+          @sid.save_state(out)
+          @vdc.save_state(out)
+        end
+
+        def load_state(input)
+          input.marker("C128 BUS")
+          @port_ddr = input.int
+          @port_out = input.int
+          @port_floating = input.int
+          @address = input.int
+          @data = input.int
+          @mmu.load_state(input)
+          @ram.load_state(input)
+          @color_lines.color_ram(0).load_state(input)
+          @color_lines.color_ram(1).load_state(input)
+          @cartridge&.load_state(input)
+          @datasette.load_state(input)
+          @io_port.value = port_value
+          update_overlays!
+          @vic.load_state(input)
+          @control_ports.extra_rows = 0xf8 | @vic.extra_keyboard_lines
+          @cia1.load_state(input)
+          @cia2.load_state(input)
+          @sid.load_state(input)
+          @vdc.load_state(input)
+        end
+      end
+    end
+  end
+end

data/lib/badline/c128/color_lines.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Badline
+  class C128
+    # The C128's two 1K colour RAM banks, and the colour RAM and character
+    # ROM it pushes into the VIC's bank. In C128 mode the 8502's port picks
+    # them: P0 the colour RAM bank the CPU sees, P1 the one the VIC sees,
+    # and P2 low shows the VIC the character ROM's C128 set. In C64 mode
+    # both see colour RAM bank 1, and the VIC the C64 set.
+    class ColorLines
+      def initialize(vic, cia2, c64_characters, c128_characters)
+        @vic_bank = vic.vic_bank
+        @cia2 = cia2
+        @c64_characters = c64_characters
+        @c128_characters = c128_characters
+        @bank0 = ColorMemory.new(vic)
+        @bank1 = ColorMemory.new(vic)
+      end
+
+      # Colour RAM bank +number+, 0 or 1.
+      def color_ram(number) = number.zero? ? @bank0 : @bank1
+
+      # The colour RAM bank the CPU sees.
+      def cpu_color_ram(c64_mode, port) = c64_mode ? @bank1 : color_ram(port & 0x01)
+
+      # Pushes the colour RAM and the character ROM the VIC sees into its
+      # bank.
+      def push(c64_mode, port)
+        if c64_mode
+          @vic_bank.connect(cia2: @cia2, color_ram: @bank1)
+          @vic_bank.map_character_rom(@c64_characters)
+        else
+          @vic_bank.connect(cia2: @cia2, color_ram: color_ram((port >> 1) & 0x01))
+          @vic_bank.map_character_rom(@c128_characters, shadow: port.nobits?(0x04))
+        end
+      end
+    end
+  end
+end

data/lib/badline/c128/cpu.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Badline
+  class C128
+    # The C128's 8502, on the C128::Bus, which holds its I/O port.
+    class CPU
+      include Badline::CPU::Core
+    end
+  end
+end

data/lib/badline/c128/drives.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Badline
+  class C128
+    # The true drives on the C128's serial bus: a Drive1541, or the
+    # C128D's built-in 1571 (Drive1571), each in a field of its own, so
+    # neither makes the other's per-cycle call a union.
+    module Drives
+      attr_reader :drive1571
+
+      # Plugs in a Drive1571, which then runs alongside the C128 on its own
+      # clock and talks to it over the serial bus, as attach_drive1541 does
+      # for a 1541.
+      def attach_drive1571(drive)
+        @iec_bus.detach(@drive1571) if @drive1571
+        drive.host_clock_hz = region.clock_hz
+        @drive1571 = drive
+        drive.connect(iec_bus)
+        @serial_trap&.device = serial_trap_device
+      end
+
+      # Unplugs the Drive1571.
+      def detach_drive1571
+        return unless @drive1571
+
+        @iec_bus.detach(@drive1571)
+        @drive1571 = nil
+        @serial_trap&.device = serial_trap_device
+      end
+
+      # The true drive on the bus, the 1571 ahead of a 1541.
+      def true_drive = @drive1571 || @drive1541
+
+      # Plugs in the C128D's 1571 as device 8, and returns it.
+      def plug_true_drive = Drive1571.new.tap { |drive| attach_drive1571(drive) }
+
+      private
+
+      # The serial bus, with no disk in device 8's traps and no true drive.
+      def init_drives
+        @drive = nil
+        @serial_trap = nil
+        @save_trap = nil
+        @drive1541 = nil
+        @drive1571 = nil
+        plug_serial_bus
+        plug_fast_serial
+      end
+
+      # Device 8, unless a true drive is on the bus as device 8.
+      def serial_trap_device
+        device = KernalTrap::Routine::DEVICE
+        @drive1571&.device == device || @drive1541&.device == device ? nil : device
+      end
+
+      # A true 1541 (Computer::Attachments#save_serial_bus), then a 1571.
+      def save_serial_bus(out)
+        out.boolean(true).boolean(!@drive1541.nil?)
+        if @drive1541
+          out.int(@drive1541.device)
+          @drive1541.save_state(out)
+        end
+        out.boolean(!@drive1571.nil?)
+        return unless @drive1571
+
+        out.int(@drive1571.device)
+        @drive1571.save_state(out)
+      end
+
+      def load_serial_bus(input)
+        input.boolean?
+        load_drive1541(input)
+        load_drive1571(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
+
+      def load_drive1571(input)
+        return detach_drive1571 unless input.boolean?
+
+        device = input.int
+        detach_drive1571 if @drive1571 && @drive1571.device != device
+        attach_drive1571(Drive1571.new(device:)) unless @drive1571
+        @drive1571.load_state(input)
+      end
+    end
+  end
+end

data/lib/badline/c128/fast_serial.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Badline
+  class C128
+    # Fast serial: CIA 1's CNT and SP on the serial bus's SRQ and DATA,
+    # through buffers MCR's FSDIR turns round. Outwards, the machine pushes
+    # the lines the pins pull into the bus as they move. Inwards, CIA 1
+    # hears the lines whenever a drive moves its own fast serial pins
+    # (IECBus#on_fast_change).
+    module FastSerial
+      private
+
+      def plug_fast_serial
+        @fast_serial_out = false
+        @bus.mmu.on_fast_serial_change { turn_fast_serial }
+        @iec_bus.on_fast_change { hear_fast_serial unless @fast_serial_out }
+      end
+
+      # The machine's side of the serial bus each cycle: CIA 1's pins
+      # pushed while FSDIR has them out, then the drives.
+      def clock_serial_bus
+        drive_fast_serial if @fast_serial_out
+        @drive1541&.host_cycle!
+        @drive1571&.host_cycle!
+      end
+
+      def turn_fast_serial
+        push_fast_serial
+        hear_fast_serial unless @fast_serial_out
+      end
+
+      # Pushes the lines CIA 1's pins pull while FSDIR has them out. A
+      # restored machine pushes them again, its CIA 1 hearing the lines as
+      # it last did.
+      def push_fast_serial
+        @fast_serial_out = @bus.mmu.fast_serial_out?
+        @iec_bus.host_fast_lines = @fast_serial_out ? fast_pins : 0
+      end
+
+      def drive_fast_serial
+        @iec_bus.host_fast_lines = fast_pins
+      end
+
+      # The lines CIA 1's CNT and SP pull while its serial port drives
+      # them.
+      def fast_pins
+        serial = @cia1.serial
+        return 0 unless serial.output?
+
+        low = serial.cnt ? 0 : IECBus::SRQ
+        serial.sp_out ? low : low | IECBus::DATA
+      end
+
+      def hear_fast_serial
+        low = @iec_bus.low_lines
+        serial = @cia1.serial
+        serial.cnt_in = low.nobits?(IECBus::SRQ)
+        serial.sp_in = low.nobits?(IECBus::DATA)
+      end
+    end
+  end
+end

data/lib/badline/c128/keys.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Badline
+  class C128
+    # The three keys outside the keyboard matrix: RESTORE, CAPS LOCK and
+    # 40/80 DISPLAY.
+    module Keys
+      # RESTORE pulses NMI for a cycle, as on the C64.
+      def press_restore
+        @restore_pulse = true
+      end
+
+      def release_restore; end
+
+      # CAPS LOCK locks down and up, and holds the 8502's P6 low while down.
+      def press_caps_lock
+        @bus.caps_lock = true
+      end
+
+      def release_caps_lock
+        @bus.caps_lock = false
+      end
+
+      # The 40/80 DISPLAY key locks down and up. The KERNAL reads it at reset
+      # and starts the screen editor on the VDC's 80 columns while it is down.
+      def press_display_key
+        @bus.mmu.display_key = true
+      end
+
+      def release_display_key
+        @bus.mmu.display_key = false
+      end
+    end
+  end
+end