bump version to 2.11.0

By patching the ELF we insert the filename at a time where the file
format itself already tracks it (through the symbol .stage2_filename).

CMakeLists.txt

@@ -1,7 +1,7 @@
 # Build system for the gint unikernel
 
 cmake_minimum_required(VERSION 3.15)
-project(Gint VERSION 2.10.0 LANGUAGES C ASM)
+project(Gint VERSION 2.11.0 LANGUAGES C ASM)
 
 include(GitVersionNumber)
 include(Fxconv)
@@ -22,7 +22,7 @@ else()
 endif()
 configure_file(include/gint/config.h.in include/gint/config.h)
 
-set(SOURCES_COMMON
+set(SOURCES
   # Clock Pulse Generator driver
   src/cpg/cpg.c
   src/cpg/overclock.c
@@ -70,70 +70,9 @@ set(SOURCES_COMMON
   src/fs/fugue/fugue_rmdir.c
   src/fs/fugue/fugue_unlink.c
   src/fs/fugue/util.c
-  # Interrupt Controller driver
-  src/intc/intc.c
-  src/intc/inth.s
-  # Kernel
-  src/kernel/exch.c
-  src/kernel/exch.s
-  src/kernel/hardware.c
-  src/kernel/inth.S
-  src/kernel/kernel.c
-  src/kernel/osmenu.c
-  src/kernel/start.c
-  src/kernel/syscalls.S
-  src/kernel/tlbh.S
-  src/kernel/world.c
-  # Key Scan Interface driver
-  src/keysc/getkey.c
-  src/keysc/iokbd.c
-  src/keysc/keycodes.c
-  src/keysc/keydev.c
-  src/keysc/keydev_idle.c
-  src/keysc/keydev_process_key.c
-  src/keysc/keydown_all.c
-  src/keysc/keydown_any.c
-  src/keysc/keysc.c
-  src/keysc/scan_frequency.c
-  # Memory allocator
-  src/kmalloc/arena_gint.c
-  src/kmalloc/arena_osheap.c
-  src/kmalloc/kmalloc.c
-  # MMU driver
-  src/mmu/mmu.c
-  # Rendering
-  src/render/dhline.c
-  src/render/dimage.c
-  src/render/dline.c
-  src/render/dprint.c
-  src/render/drect_border.c
-  src/render/dtext.c
-  src/render/dupdate_hook.c
-  src/render/dvline.c
-  src/render/dwindow.c
-  src/render/topti.c
-  # RTC driver
-  src/rtc/rtc.c
-  src/rtc/rtc_ticks.c
-  # Sound Processing Unit driver
-  src/spu/spu.c
-  # Timer Unit driver
-  src/tmu/inth-etmu.s
-  src/tmu/inth-tmu.s
-  src/tmu/sleep.c
-  src/tmu/tmu.c
-  # USB driver
-  src/usb/asyncio.c
-  src/usb/classes/ff-bulk.c
-  src/usb/configure.c
-  src/usb/pipes.c
-  src/usb/read4.S
-  src/usb/setup.c
-  src/usb/string.c
-  src/usb/usb.c
-  src/usb/write4.S
-)
-set(SOURCES_FX
+  # GDB remote serial protocol
+  src/gdb/gdb.c
+  src/gdb/gdb.S
   # Gray engine
   src/gray/engine.c
   src/gray/gclear.c
@@ -143,30 +82,6 @@ set(SOURCES_FX
   src/gray/grect.c
   src/gray/gsubimage.c
   src/gray/gtext.c
-  # Rendering
-  src/render-fx/bopti-asm-gray-scsp.s
-  src/render-fx/bopti-asm-gray.s
-  src/render-fx/bopti-asm-mono-scsp.s
-  src/render-fx/bopti-asm.s
-  src/render-fx/bopti.c
-  src/render-fx/dclear.c
-  src/render-fx/dgetpixel.c
-  src/render-fx/dpixel.c
-  src/render-fx/drect.c
-  src/render-fx/dsubimage.c
-  src/render-fx/dupdate.c
-  src/render-fx/gint_dline.c
-  src/render-fx/masks.c
-  src/render-fx/topti-asm.s
-  src/render-fx/topti.c
-  # T6K11 driver
-  src/t6k11/t6k11.c
-
-  src/usb/classes/ff-bulk-gray.c
-)
-set(SOURCES_CG
-  # R61524 driver
-  src/r61524/r61524.c
   # Image library
   src/image/image_alloc.c
   src/image/image_alloc_palette.c
@@ -198,7 +113,57 @@ set(SOURCES_CG
   src/image/image_valid.c
   src/image/image_vflip.c
   src/image/image_vflip_alloc.c
-  # Rendering
+  # Interrupt Controller driver
+  src/intc/intc.c
+  src/intc/inth.s
+  # Kernel
+  src/kernel/exch.c
+  src/kernel/exch.s
+  src/kernel/hardware.c
+  src/kernel/inth.S
+  src/kernel/kernel.c
+  src/kernel/osmenu.c
+  src/kernel/start.c
+  src/kernel/start.S
+  src/kernel/syscalls.S
+  src/kernel/tlbh.S
+  src/kernel/world.c
+  # Key Scan Interface driver
+  src/keysc/getkey.c
+  src/keysc/iokbd.c
+  src/keysc/keycodes.c
+  src/keysc/keydev.c
+  src/keysc/keydev_idle.c
+  src/keysc/keydev_process_key.c
+  src/keysc/keydown_all.c
+  src/keysc/keydown_any.c
+  src/keysc/keysc.c
+  src/keysc/scan_frequency.c
+  # Memory allocator
+  src/kmalloc/arena_gint.c
+  src/kmalloc/arena_osheap.c
+  src/kmalloc/kmalloc.c
+  # MMU driver
+  src/mmu/mmu.c
+  # R61523 display driver
+  src/r61523/r61523.c
+  # R61524 display driver
+  src/r61524/r61524.c
+  # Format-agnostic rendering
+  src/render/dcircle.c
+  src/render/dellipse.c
+  src/render/dhline.c
+  src/render/dimage.c
+  src/render/dline.c
+  src/render/dpoly.c
+  src/render/dprint.c
+  src/render/drect_border.c
+  src/render/dtext.c
+  src/render/dupdate_hook.c
+  src/render/dvline.c
+  src/render/dwindow.c
+  src/render/topti.c
+  # RGB Rendering
   src/render-cg/dclear.c
   src/render-cg/dgetpixel.c
   src/render-cg/dpixel.c
@@ -206,10 +171,11 @@ set(SOURCES_CG
   src/render-cg/dsubimage.c
   src/render-cg/dupdate.c
   src/render-cg/dvram.c
+  src/render-cg/dvram.S
   src/render-cg/gint_dline.c
-  src/render-cg/topti-asm.s
+  src/render-cg/topti-asm.S
   src/render-cg/topti.c
-  # Fast image renderer
+  # Fast RGB image renderer
   src/render-cg/image/image.c
   src/render-cg/image/image_rgb16.S
   src/render-cg/image/image_rgb16_normal.S
@@ -226,7 +192,7 @@ set(SOURCES_CG
   src/render-cg/image/image_p4_clearbg_alt.S
   src/render-cg/image/image_p4_swapcolor.S
   src/render-cg/image/image_p4_dye.S
-  # Interface to the fast image renderer
+  # Interface to the fast RGB image renderer
   src/render-cg/image/image_rgb16.c
   src/render-cg/image/image_rgb16_effect.c
   src/render-cg/image/image_rgb16_swapcolor.c
@@ -240,24 +206,68 @@ set(SOURCES_CG
   src/render-cg/image/image_p4_effect.c
   src/render-cg/image/image_p4_swapcolor.c
   src/render-cg/image/image_p4_dye.c
+  # Mono rendering
+  src/render-fx/bopti-asm-gray-scsp.S
+  src/render-fx/bopti-asm-gray.S
+  src/render-fx/bopti-asm-mono-scsp.S
+  src/render-fx/bopti-asm.S
+  src/render-fx/bopti.c
+  src/render-fx/dclear.c
+  src/render-fx/dgetpixel.c
+  src/render-fx/dpixel.c
+  src/render-fx/drect.c
+  src/render-fx/dsubimage.c
+  src/render-fx/dupdate.c
+  src/render-fx/gint_dline.c
+  src/render-fx/masks.c
+  src/render-fx/topti-asm.S
+  src/render-fx/topti.c
+  # RTC driver
+  src/rtc/rtc.c
+  src/rtc/rtc_ticks.c
+  # Sound Processing Unit driver
+  src/spu/spu.c
+  # T6K11 display driver
+  src/t6k11/t6k11.c
+  # Timer Unit driver
+  src/tmu/inth-etmu.s
+  src/tmu/inth-tmu.s
+  src/tmu/sleep.c
+  src/tmu/tmu.c
+  # UBC driver
+  src/ubc/ubc.c
+  src/ubc/ubc.S
+  # USB driver
+  src/usb/asyncio.c
+  src/usb/classes/ff-bulk.c
+  src/usb/classes/ff-bulk-gray.c
+  src/usb/configure.c
+  src/usb/pipes.c
+  src/usb/read4.S
+  src/usb/setup.c
+  src/usb/string.c
+  src/usb/usb.c
+  src/usb/write4.S
+  # Video driver interface
+  src/video/video.c
 )
 
-set(ASSETS_FX src/font5x7.png)
-set(ASSETS_CG src/font8x9.png)
+set(ASSETS_FX src/font5x7.png src/gdb/icons-i1msb.png)
+set(ASSETS_CG src/font8x9.png src/gdb/icons-rgb565.png)
+set(ASSETS_CP ${ASSETS_CG})
 fxconv_declare_assets(${ASSETS_FX} ${ASSETS_CG})
 
 include_directories(
   "${PROJECT_SOURCE_DIR}/include"
   "${PROJECT_BINARY_DIR}/include")
-add_compile_options(-Wall -Wextra -std=c11 -Os -fstrict-volatile-bitfields -mtas)
+add_compile_options(-Wall -Wextra -std=c11 -Os -g -fstrict-volatile-bitfields -mtas -flto)
 
 if("${FXSDK_PLATFORM_LONG}" STREQUAL fx9860G)
   add_compile_definitions(FX9860G)
   set(NAME "gint-fx")
   set(LINKER_SCRIPTS
     "${CMAKE_CURRENT_BINARY_DIR}/fx9860g.ld")
-  add_library(gint-fx STATIC ${SOURCES_COMMON} ${SOURCES_FX} ${ASSETS_FX}
-    ${LINKER_SCRIPTS})
+  add_library(${NAME} STATIC ${SOURCES} ${ASSETS_FX} ${LINKER_SCRIPTS})
 endif()
 
 if("${FXSDK_PLATFORM_LONG}" STREQUAL fxCG50)
@@ -266,12 +276,34 @@ if("${FXSDK_PLATFORM_LONG}" STREQUAL fxCG50)
   set(LINKER_SCRIPTS
     "${CMAKE_CURRENT_BINARY_DIR}/fxcg50.ld"
     "${CMAKE_CURRENT_BINARY_DIR}/fxcg50_fastload.ld")
-  add_library(gint-cg STATIC ${SOURCES_COMMON} ${SOURCES_CG} ${ASSETS_CG}
-    ${LINKER_SCRIPTS})
+  add_library(${NAME} STATIC ${SOURCES} ${ASSETS_CG} ${LINKER_SCRIPTS})
+endif()
+
+if("${FXSDK_PLATFORM_LONG}" STREQUAL fx9860G_G3A)
+  add_compile_definitions(FX9860G_G3A)
+  set(NAME "gint-fxg3a")
+  set(LINKER_SCRIPTS
+    "${CMAKE_CURRENT_BINARY_DIR}/fxcg50.ld"
+    "${CMAKE_CURRENT_BINARY_DIR}/fxcg50_fastload.ld")
+  add_library(${NAME} STATIC ${SOURCES} ${ASSETS_FX} ${LINKER_SCRIPTS})
+endif()
+
+if("${FXSDK_PLATFORM_LONG}" STREQUAL fxCP)
+  add_compile_definitions(FXCP)
+  set(NAME "gint-cp")
+  set(LINKER_SCRIPTS
+    "${CMAKE_CURRENT_BINARY_DIR}/fxcp_hh2.ld")
+  add_library(${NAME} STATIC ${SOURCES} ${ASSETS_CP} ${LINKER_SCRIPTS})
 endif()
 
 set_target_properties("${NAME}" PROPERTIES OUTPUT_NAME "${NAME}")
 
+# Generate the archive with gcc-ar instead of ar as it will load the LTO plugin
+# which is required to generate a usable archive.
+set(CMAKE_C_ARCHIVE_CREATE "${CMAKE_C_COMPILER_AR} qcs <TARGET> <OBJECTS>")
+# Also the ranlib rule (useless because ar is passed the s flag anyway)
+set(CMAKE_C_ARCHIVE_FINISH "${CMAKE_C_COMPILER_RANLIB} <TARGET>")
+
 # Generate linker scripts
 macro(generate_linker_script OUTPUT INPUT OPTIONS)
   add_custom_command(
@@ -283,6 +315,7 @@ endmacro()
 generate_linker_script("fx9860g.ld" "fx9860g.ld.c" "")
 generate_linker_script("fxcg50.ld" "fxcg50.ld.c" "")
 generate_linker_script("fxcg50_fastload.ld" "fxcg50.ld.c" "-DFXCG50_FASTLOAD")
+generate_linker_script("fxcp_hh2.ld" "fxcp_hh2.ld.c" "")
 
 # Library file
 install(TARGETS "${NAME}" DESTINATION "${FXSDK_LIB}")

README.md

@@ -105,6 +105,17 @@ The available options are:
 % fxsdk build-cg install
 ```
 
+**"Cross-Building" a fx-9860G II project for fx-CG 50**
+
+Programs written for fx-9860G can also be built to run on the fx-CG series,
+provided no low-level function or hardware-specific behavior (like syscalls) is
+used by the program.
+
+```
+% fxsdk build-fxg3a
+% fxsdk build-fxg3a install
+```
+
 ## Using in CMake-based add-ins
 
 Find the `Gint` module and link against `Gint::Gint`. gint declares the include
@@ -121,10 +132,16 @@ target_link_libraries(<target_name> Gint::Gint)
 Projects created with the fxSDK link with gint out-of-the-box. If you're not
 using the fxSDK, you will need to:
 
-* Build with `-ffreestanding -fstrict-volatile-bitfields`;
+* Build with `-ffreestanding -fstrict-volatile-bitfields` and either
+  `-DFX9860G` or `-DFXGC50`;
 * Link with `-T fx9860g.ld -lgint-fx -lopenlibm -lc` on fx-9860G;
 * Link with `-T fxcg50.ld -lgint-cg -lopenlibm -lc` on fx-CG 50.
 
+To manually build the fx-CG executable for an fx-9860G program, mix as follows:
+
+* Use platform flags `-DFXCG50 -DFX9860G_G3A`;
+* Link with `-T fxcg50.ld -lgint-fxg3a -lopenlibm -lc`.
+
 If you don't have a standard library such as
 [Memallox's port of newlib](/PlaneteCasio/libc), you also need `-nostdlib`. I
 typically use `-m3 -mb` or `-m4-nofpu -mb` to specify the platform, but that

TODO

@@ -3,7 +3,7 @@ Bugs to fix:
 
 Extensions on existing code:
 * clock:     mono support
-* usb:       add PC->calc reading, and interrupt pipes
+* usb:       and interrupt pipes
 * fs:        support RAM files
 * fs:        support USB streams as generic file descriptors
 * fugue:     support glob() to abstract away BFile entirely
@@ -17,10 +17,66 @@ Extensions on existing code:
 * core:      run destructors when a task-switch results in leaving the app
 * fs:        support read-only files backed with GetBlockAddress() on fx-CG
 * kernel:    SH4- or G-III-specific linker scripts?
-* keysc:     global shortcut SHIFT+0+EXIT for abort() as an infinite loop break
+* render:    Properly document bopti fx. Also make it faster maybe?
 
 Future directions:
 * Audio playback using TSWilliamson's libsnd method
 * Serial communication
 * Make fx9860g projects work out of the box on fxcg50
 * Base for Yatis' threads library
+
+Bits that need to abstract out into APIs:
+- display: Toggle backlight (or set level)
+  -> Have a backlight property with min/max values
+  @ getkey
+  @ justui jscene
+- os: OS interface to access OS info, like in fxos
+  @ usb/setup.c set_strings
+  @ usb/classes/ff-bulk.c identify command
+- render: current video mode
+  @ usb/classes/ff-bulk.c capture_vram
+- gray: make gray engine a subset of t6k11 which then supports two modes
+
+Video formats:
+- i1msb
+- 2i1msb
+- rgb565
+
+T6K11:
+  mode 0 :   i1msb   128x64   @64 Hz
+  mode 1 :   2i1msb  128x64   @64 Hz
+R61524:
+  mode 0 :   rgb565  396x224  @? Hz
+  mode 1 :   i3???   396x224  @? Hz
+  mode 2 :   i1msb   128x64   @? Hz # <- for g1a emulation :)
+  mode 3 :   2i1msb  128x64   @? Hz # <- for g1a emulation :)
+
+enum {
+    /* Indexed 1-bit, 0 is white, 1 is black. Row-major, left-to-right, each
+       row a set of 4-byte values with leftmost pixel on the MSB. */
+    IMAGE_FORMAT_I1MSB,
+    /* Indexed 2-bit: white, light gray, dark gray, black. Represented as a
+       pair of I1MSB buffers, the first being bit #0, the second bit #1. */
+    IMAGE_FORMAT_2I1MSB,
+};
+
+fx-CP port progress.
+DONE:
+- kernel can start add-ins, take over interrupts (but no interrupt sources yet)
+- panic handler works (no interactive choices, only RESET)
+- no OS menu (likely never) and poweroff (maybe later)
+- memory: 64 kB total + OS heap (no gint arena, no MMU)
+- r61523: prototype display driver
+- can use the rendering pipeline with no DMA acceleration
+IN-PROGRESS:
+- unification of the image/video interface
+TODO:
+- hardware info: rom and fs type
+- quit handler
+- DMA acceleration for dclear and dupdate
+- keyboard and touch screen input
+- drivers: cpg, dma, intc, rtc, tmu
+- find more memory, 64 kB is not enough
+- benchmark memory and display performance
+- improve API and performance of display driver
+- way off: filesystem, remote debugging, usb

cmake/FindGint.cmake

@@ -1,12 +1,30 @@
+macro(get_linker_script_path OUTVAR NAME)
+  execute_process(
+    COMMAND ${CMAKE_C_COMPILER} -print-file-name=${NAME}
+    OUTPUT_VARIABLE ${OUTVAR}
+    OUTPUT_STRIP_TRAILING_WHITESPACE)
+endmacro()
+
 # Determine platform Code
 if("${FXSDK_PLATFORM_LONG}" STREQUAL fxCG50)
   set(PC cg)
   set(INTF_DEFN FXCG50)
-  set(INTF_LINK "-T;$<IF:$<CONFIG:FastLoad>,fxcg50_fastload.ld,fxcg50.ld>")
+  get_linker_script_path(LS1 fxcg50_fastload.ld)
+  get_linker_script_path(LS2 fxcg50.ld)
+  set(INTF_LINKER_SCRIPT
+    "$<IF:$<CONFIG:FastLoad>,${LS1},${LS2}>")
 elseif("${FXSDK_PLATFORM_LONG}" STREQUAL fx9860G)
   set(PC fx)
   set(INTF_DEFN FX9860G)
-  set(INTF_LINK "-T;fx9860g.ld")
+  get_linker_script_path(INTF_LINKER_SCRIPT "fx9860g.ld")
+elseif("${FXSDK_PLATFORM_LONG}" STREQUAL fx9860G_G3A)
+  set(PC fxg3a)
+  set(INTF_DEFN FX9860G_G3A)
+  get_linker_script_path(INTF_LINKER_SCRIPT "fxcg50.ld")
+elseif("${FXSDK_PLATFORM_LONG}" STREQUAL fxCP)
+  set(PC cp)
+  set(INTF_DEFN FXCP)
+  get_linker_script_path(INTF_LINKER_SCRIPT "fxcp_hh2.ld")
 else()
   message(FATAL_ERROR "gint: unknown fxSDK platform '${FXSDK_PLATFORM}'")
 endif()
@@ -65,7 +83,8 @@ if(Gint_FOUND)
     INTERFACE_COMPILE_OPTIONS -fstrict-volatile-bitfields
     INTERFACE_COMPILE_DEFINITIONS "${INTF_DEFN}"
     INTERFACE_LINK_LIBRARIES "-lopenlibm;-lgcc"
-    INTERFACE_LINK_OPTIONS "${INTF_LINK}")
+    INTERFACE_LINK_OPTIONS "-T;${INTF_LINKER_SCRIPT}"
+    INTERFACE_LINK_DEPENDS "${INTF_LINKER_SCRIPT}")
 
   target_link_libraries(Gint::Gint INTERFACE Gint::Fxlibc)
   target_link_libraries(Gint::Fxlibc INTERFACE Gint::Gint)

fx9860g.ld.c

@@ -61,19 +61,19 @@ SECTIONS
 		*(.text.entry)
 
 		_bctors = . ;
-		*(.ctors .ctors.*)
+		KEEP(*(.ctors .ctors.*))
 		_ectors = . ;
 
 		_bdtors = . ;
-		*(.dtors .dtors.*)
+		KEEP(*(.dtors .dtors.*))
 		_edtors = . ;
 
 		_gint_exch_start = . ;
-		*(.gint.exch)
+		KEEP(*(.gint.exch))
 		_gint_exch_size = ABSOLUTE(. - _gint_exch_start);
 
 		_gint_tlbh_start = . ;
-		*(.gint.tlbh)
+		KEEP(*(.gint.tlbh))
 		_gint_tlbh_size = ABSOLUTE(. - _gint_tlbh_start);
 
 		*(.text .text.*)

fxcg50.ld.c

@@ -50,19 +50,19 @@ SECTIONS
 		*(.text.entry)
 
 		_bctors = . ;
-		*(.ctors .ctors.*)
+		KEEP(*(.ctors .ctors.*))
 		_ectors = . ;
 
 		_bdtors = . ;
-		*(.dtors .dtors.*)
+		KEEP(*(.dtors .dtors.*))
 		_edtors = . ;
 
 		_gint_exch_start = . ;
-		*(.gint.exch)
+		KEEP(*(.gint.exch))
 		_gint_exch_size = ABSOLUTE(. - _gint_exch_start);
 
 		_gint_tlbh_start = . ;
-		*(.gint.tlbh)
+		KEEP(*(.gint.tlbh))
 		_gint_tlbh_size = ABSOLUTE(. - _gint_tlbh_start);
 
 		*(.text .text.*)
@@ -161,6 +161,11 @@ SECTIONS
 	_silram = SIZEOF(.ilram);
 	_sxyram = SIZEOF(.xyram);
 
+	_lgmapped = ABSOLUTE(0);
+	_sgmapped = ABSOLUTE(0);
+	_lreloc = ABSOLUTE(0);
+	_sreloc = ABSOLUTE(0);
+
 	/* gint's uninitialized BSS section, going to static RAM. All the large
 	   data arrays will be located here */
 	.gint.bss (NOLOAD) : {

fxcp_hh2.ld.c

@@ -0,0 +1,206 @@
+/*
+	Linker script for fxCP add-ins linking with HollyHock2.
+*/
+
+OUTPUT_ARCH(sh4)
+OUTPUT_FORMAT(elf32-sh)
+ENTRY(_start_header)
+
+MEMORY
+{
+	/* VRAM backup - our main fixed area to load code, size 320x528x2 */
+	ram (rwx): o = 0x8c052800, l = 337920
+	/* End-of-RAM area, 104 kB are safe to use according to experience. What
+	   happens is HollyHock itself is loaded at 0x8cfe0000 (128 kB before the
+	   end) so we have to fit after it. CPBoy uses 0x8cfe6000, follow that. */
+	eram (rwx): o = 0x8cfe6000, l = 102144 /* 104k - 0x1100 */
+	/* Space for the vbr */
+	vbr (rwx): o = 0x8cffef00, l = 0x1100
+	/* On-chip IL memory */
+	ilram (rwx):  o = 0xe5200000, l = 4k
+	/* On-chip X and Y memory */
+	xyram (rwx):  o = 0xe500e000, l = 16k
+	/* Flat binary space, used to have everything in the correct order in the
+	   binary. This is just for the bin file layout. */
+	bin (rwx): o = 0x00000000, l = 1M
+}
+
+SECTIONS
+{
+	/*
+	**  ROM sections
+	*/
+
+	/* First address to be mapped to ROM */
+	_brom = ORIGIN(ram);
+	/* Size of ROM mappings */
+	_srom = SIZEOF(.text) + SIZEOF(.rodata)
+	      + SIZEOF(.gint.drivers) + SIZEOF(.gint.blocks);
+
+	/* Machine code going to ROM:
+	   - Entry function (.text.entry)
+	   - Compiler-provided constructors (.ctors) and destructors (.dtors)
+	   - All text from .text and .text.* (including user code) */
+	.hh2 : {
+		KEEP(*(.hh2.header))
+		KEEP(*(.hh2.info))
+		KEEP(*(.hh2.stage2))
+		. = ALIGN(16);
+	} > eram AT> bin
+
+	_gint_hh2_stage2_offset = SIZEOF(.hh2);
+	_gint_hh2_stage2_load = ORIGIN(ram);
+
+	.text : {
+		*(.text.entry)
+
+		_bctors = . ;
+		*(.ctors .ctors.*)
+		_ectors = . ;
+
+		_bdtors = . ;
+		*(.dtors .dtors.*)
+		_edtors = . ;
+
+		. = ALIGN(0x10);
+		_gint_exch_start = . ;
+		*(.gint.exch)
+		_gint_exch_size = ABSOLUTE(. - _gint_exch_start);
+
+		. = ALIGN(0x10);
+		_gint_tlbh_start = . ;
+		*(.gint.tlbh)
+		_gint_tlbh_size = ABSOLUTE(. - _gint_tlbh_start);
+
+		*(.text .text.*)
+	} > ram AT> bin
+
+	/* gint's interrupt handler blocks (.gint.blocks)
+	   Although gint's blocks end up in VBR space, they are relocated at
+	   startup by the library/drivers, so we store them here for now */
+	.gint.blocks ALIGN(4) : ALIGN(4) {
+		KEEP(*(.gint.blocks));
+	} > ram AT> bin
+
+	/* Exposed driver interfaces (.gint.drivers)
+	   The driver information is required to start and configure the
+	   driver, even if the symbols are not referenced */
+	.gint.drivers ALIGN(4) : ALIGN(4) {
+		_gint_drivers = . ;
+		KEEP(*(SORT_BY_NAME(.gint.drivers.*)));
+		_gint_drivers_end = . ;
+	} > ram AT> bin
+
+	/* Read-only data going to ROM:
+	   - Resources or assets from fxconv or similar converters
+	   - Data marked read-only by the compiler (.rodata and .rodata.*) */
+	.rodata ALIGN(4) : ALIGN(4) SUBALIGN(4) {
+		/* Put these first, they need to be 4-aligned */
+		*(.rodata.4)
+
+		*(.rodata .rodata.*)
+	} > ram AT> bin
+
+
+
+	/*
+	**  RAM sections
+	*/
+
+	/* Read-write data sections going to RAM (.data and .data.*) */
+	.data ALIGN(4) : ALIGN(4) {
+		_ldata = LOADADDR(.data);
+		_rdata = . ;
+
+		*(.data .data.*)
+		/* Code that must remain mapped; no MMU on HH2, so fine */
+		*(.gint.mapped)
+		/* References to mapped code - no relocation needed */
+		*(.gint.mappedrel)
+
+		. = ALIGN(16);
+	} > ram AT> bin
+
+	/* Read-write data sub-aligned to 4 bytes (mainly from fxconv) */
+	.data.4 ALIGN(4) : ALIGN(4) SUBALIGN(4) {
+		*(.data.4)
+		. = ALIGN(16);
+	} > ram AT> bin
+
+	_sdata = SIZEOF(.data) + SIZEOF(.data.4);
+
+	/* On-chip memory sections: IL, X and Y memory */
+
+	. = ORIGIN(ilram);
+	.ilram ALIGN(4) : ALIGN(4) {
+		_lilram = ABSOLUTE(LOADADDR(.ilram) + ORIGIN(ram));
+		_rilram = . ;
+
+		*(.ilram)
+
+		. = ALIGN(16);
+	} > ilram AT> bin
+
+	. = ORIGIN(xyram);
+	.xyram ALIGN(4) : ALIGN(4) {
+		_lxyram = ABSOLUTE(LOADADDR(.xyram) + ORIGIN(ram));
+		_rxyram = . ;
+
+		*(.xram .yram .xyram)
+
+		. = ALIGN(16);
+
+	} > xyram AT> bin
+
+	/* .text and .xyram are the first and last section in the stage-2 load. */
+	_gint_hh2_stage2_size = LOADADDR(.xyram) + SIZEOF(.xyram) - LOADADDR(.text);
+
+	_silram = SIZEOF(.ilram);
+	_sxyram = SIZEOF(.xyram);
+
+	_lgmapped = ABSOLUTE(0);
+	_sgmapped = ABSOLUTE(0);
+	_lreloc = ABSOLUTE(0);
+	_sreloc = ABSOLUTE(0);
+	_gint_region_vbr = ORIGIN(vbr);
+
+	/* BSS data going to RAM. The BSS section is to be stripped from the
+	   ELF file later, and wiped at startup */
+	.bss (NOLOAD) : {
+		_rbss = . ;
+
+		*(.bss .bss.* COMMON)
+
+		. = ALIGN(16);
+	} > ram :NONE
+
+	_sbss = SIZEOF(.bss);
+
+	/* gint's uninitialized BSS section, going to static RAM. All the large
+	   data arrays will be located here */
+	.gint.bss (NOLOAD) : {
+		*(.gint.bss)
+		. = ALIGN(16);
+
+		/* End of user RAM */
+		_euram = . ;
+	} > ram :NONE
+
+	_sgbss = SIZEOF(.gint.bss);
+
+	/*
+	**  Unused sections
+	*/
+
+	/DISCARD/ : {
+		/* SH3-only data sections */
+		*(.gint.rodata.sh3 .gint.data.sh3 .gint.bss.sh3)
+		/* Java class registration (why are they even here?!) */
+		*(.jcr)
+		/* Asynchronous unwind tables: no C++ exception handling */
+		*(.eh_frame_hdr)
+		*(.eh_frame)
+		/* Comments or anything the compiler might generate */
+		*(.comment)
+	}
+}

giteapc.make

@@ -5,14 +5,17 @@
 configure:
 	@ fxsdk build-fx -c $(GINT_CMAKE_OPTIONS)
 	@ fxsdk build-cg -c $(GINT_CMAKE_OPTIONS)
+	@ fxsdk build-fxg3a -c $(GINT_CMAKE_OPTIONS)
 
 build:
 	@ fxsdk build-fx
 	@ fxsdk build-cg
+	@ fxsdk build-fxg3a
 
 install:
 	@ fxsdk build-fx install
 	@ fxsdk build-cg install
+	@ fxsdk build-fxg3a install
 
 uninstall:
 	@ if [ -e build-fx/install_manifest.txt ]; then \
@@ -21,5 +24,8 @@ uninstall:
 	@ if [ -e build-cg/install_manifest.txt ]; then \
 	     xargs rm -f < build-cg/install_manifest.txt; \
           fi
+	@ if [ -e build-fxg3a/install_manifest.txt ]; then \
+	     xargs rm -f < build-fxg3a/install_manifest.txt; \
+          fi
 
 .PHONY: configure build install uninstall

include/gint/config.h.in

@@ -5,8 +5,6 @@
 #ifndef GINT_CONFIG
 #define GINT_CONFIG
 
-#include <gint/defs/types.h>
-
 /* GINT_VERSION: Latest tag and number of additional commits
      "2.1.0"   = Release 2.1.0
      "2.1.1-5" = 5 commits after release 2.1.1 */
@@ -16,6 +14,38 @@
      0x03f7c0a0 = Commit 3f7c0a0 */
 #define GINT_HASH 0x@GINT_GIT_HASH@
 
+/* GINT_HW_{FX,CG}: Identifies the type of hardware running the program. */
+#if defined(FX9860G)
+# define GINT_HW_FX 1
+# define GINT_HW_CG 0
+# define GINT_HW_CP 0
+# define GINT_HW_SWITCH(FX,CG,CP) (FX)
+#elif defined(FXCG50)
+# define GINT_HW_FX 0
+# define GINT_HW_CG 1
+# define GINT_HW_CP 0
+# define GINT_HW_SWITCH(FX,CG,CP) (CG)
+#elif defined(FXCP)
+# define GINT_HW_FX 0
+# define GINT_HW_CG 0
+# define GINT_HW_CP 1
+# define GINT_HW_SWITCH(FX,CG,CP) (CP)
+#endif
+
+/* Shorthand to simplify definitions below. Won't be needed for long. */
+#if defined(FX9860G_G3A)
+# define GINT_FX9860G_G3A 1
+#else
+# define GINT_FX9860G_G3A 0
+#endif
+
+/* GINT_OS_{FX,CG}: Identifies the type of OS API we're assuming. Currently I
+   see no reason this would be different from hardware, but who knows. */
+#define GINT_OS_FX GINT_HW_FX
+#define GINT_OS_CG GINT_HW_CG
+#define GINT_OS_CP GINT_HW_CP
+#define GINT_OS_SWITCH GINT_HW_SWITCH
+
 /* GINT_NO_OS_STACK: Disables using a chunk of the OS stack as a heap. The top
    section covering 355/512 ko is otherwise used. (fx-CG 50) */
 #cmakedefine GINT_NO_OS_STACK
@@ -41,4 +71,13 @@
 /* GINT_USB_DEBUG: Selects whether USB debug functions are enabled */
 #cmakedefine GINT_USB_DEBUG
 
+/* GINT_RENDER_DMODE: Selects whether the dmode override is available on
+   rendering functions. */
+#define GINT_RENDER_DMODE (GINT_HW_FX || GINT_FX9860G_G3A)
+
+/* GINT_RENDER_{MONO,RGB}: Enable the mono/rgb rendering API.
+   Currently these are exclusive. */
+#define GINT_RENDER_MONO (GINT_HW_FX || GINT_FX9860G_G3A)
+#define GINT_RENDER_RGB ((GINT_HW_CG || GINT_HW_CP) && !GINT_FX9860G_G3A)
+
 #endif /* GINT_CONFIG */

include/gint/defs/attributes.h

@@ -34,6 +34,9 @@
 /* Transparent unions */
 #define GTRANSPARENT	__attribute__((transparent_union))
 
+/* Functions and globals that are visible through whole-program optimization */
+#define GVISIBLE  __attribute__((externally_visible))
+
 /* Weak symbols */
 #define GWEAK		__attribute__((weak))
 

include/gint/defs/call.h

@@ -144,6 +144,19 @@ typedef struct {
 /* GINT_CALL_NULL: Empty function call */
 #define GINT_CALL_NULL ((gint_call_t){ .function = NULL, .args = {} })
 
+/* GINT_CALL_FLAG(): Build an indirect call to an odd address
+
+   This is used as a workaround to have an extra flag in gint_call_t structures
+   without altering their size and exploits the fact that SuperH code has to be
+   aligned on even addresses.
+   It is up to the caller to notice the presence of the flag and realign the
+   address properly.
+
+   This flag is currently only checked by gint_inth_callback to specify that the
+   called function will take the interrupt context as its first argument. */
+#define GINT_CALL_FLAG(func, ...) \
+	GINT_CALL((void*)((uint32_t)(func) | 1), __VA_ARGS__)
+
 /* gint_call(): Perform an indirect call */
 static GINLINE int gint_call(gint_call_t cb)
 {

include/gint/defs/types.h

@@ -21,6 +21,20 @@
 /* Fixed-width types for bit fields are quite meaningless */
 typedef unsigned int uint;
 
+//---
+//  Short types
+//---
+
+typedef unsigned int uint;
+typedef uint8_t u8;
+typedef uint16_t u16;
+typedef uint32_t u32;
+typedef uint64_t u64;
+typedef int8_t i8;
+typedef int16_t i16;
+typedef int32_t i32;
+typedef int64_t i64;
+
 //---
 //	Structure elements
 //----

include/gint/display-cg.h

@@ -15,7 +15,7 @@
 #ifndef GINT_DISPLAY_CG
 #define GINT_DISPLAY_CG
 
-#ifdef FXCG50
+#if GINT_RENDER_RGB
 
 #ifdef __cplusplus
 extern "C" {
@@ -25,8 +25,13 @@ extern "C" {
 #include <gint/image.h>
 
 /* Dimensions of the VRAM */
+#if GINT_HW_CG
 #define DWIDTH 396
 #define DHEIGHT 224
+#elif GINT_HW_CP
+#define DWIDTH 320
+#define DHEIGHT 528
+#endif
 
 /* gint VRAM address. This value must always point to a 32-aligned buffer of
    size 177408. Any function can use it freely to perform rendering or store
@@ -94,16 +99,49 @@ typedef image_t bopti_image_t;
 
    @main       Main VRAM area, used alone if [secondary] is NULL
    @secondary  Additional VRAM area, enables triple buffering if non-NULL */
+// TODO: In gint 3 the triple buffering mechanism will be removed. Applications
+// that want to change VRAMs in-between every frame will be able to do so by
+// talking directly to the video interface to set VRAM, and wrapping dupdate.
+// Basically it will just no longer be handled by gint itself.
 void dsetvram(uint16_t *main, uint16_t *secondary);
 
 /* dgetvram() - Get VRAM addresses
    Returns the VRAM buffer addresses used to render on fx-CG 50. */
 void dgetvram(uint16_t **main, uint16_t **secondary);
 
+
+//---
+// VRAM backup
+// On the fx-CP gint backs up the VRAM when loading and restores it when
+// leaving. While this is a transparent mechanism, the following parts of the
+// implementation are exposed at the internal API level.
+//---
+
+/* Encode the VRAM contents between [in_start] and [in_end] at [output]. While
+   [*in_end] is excluded from the encoding, it will be modified temporarily to
+   serve as bounds check, so it must not be accessed asynchronously during the
+   encoding. The size of the output is not known but is at most the distance
+   between in_end and in_start in bytes. Setting output = in_start to compress
+   in-place is supported. Returns the end pointer after encoding. */
+uint8_t *gint_vrambackup_encode(
+   uint8_t *output, uint16_t *in_start, uint16_t *in_end);
+
+/* Predefine palette based on the GUI at the Hollyhock loading screen. Contains
+   109 entries plus a 110th dummy entry used internally as bounds check. */
+extern uint16_t gint_vrambackup_palette[110];
+
+/* Get the pointer to the encoded VRAM backup created at load time. If [size]
+   is not NULL, sets the size in [*size]. The pointer is heap allocated and
+   remains owned by gint. */
+void *gint_vrambackup_get(int *size);
+
+/* Decode the load-time VRAM backup back to VRAM. */
+void gint_vrambackup_show(void);
+
 #ifdef __cplusplus
 }
 #endif
 
-#endif /* FXCG50 */
+#endif /* GINT_RENDER_RGB */
 
 #endif /* GINT_DISPLAY_CG */

include/gint/display-fx.h

@@ -9,7 +9,7 @@
 #ifndef GINT_DISPLAY_FX
 #define GINT_DISPLAY_FX
 
-#ifdef FX9860G
+#if GINT_RENDER_MONO
 
 #ifdef __cplusplus
 extern "C" {
@@ -83,14 +83,33 @@ typedef struct
 	uint height	:12;
 
 	/* Raw layer data */
-	uint8_t data[];
+	uint8_t *data;
 
 } GPACKED(4) bopti_image_t;
 
+/* Image formats ("profiles") */
+enum {
+	/* MONO: black/white, 1 layer (bw) */
+	IMAGE_MONO = 0,
+	/* MONO_ALPHA: black/white/transparent, 2 layers (alpha+bw) */
+	IMAGE_MONO_ALPHA = 1,
+	/* GRAY: black/dark/light/white, 2 layers (light+dark) */
+	IMAGE_GRAY = 2,
+	/* GRAY_ALPHA: black/dark/light/white/transparent, 3 layres
+	   (alpha+light+dark) */
+	IMAGE_GRAY_ALPHA = 3,
+};
+
+/* Number of layers in the image. */
+GINLINE static int image_layer_count(int profile)
+{
+	return profile + (profile <= 1);
+}
+
 #ifdef __cplusplus
 }
 #endif
 
-#endif /* FX9860G */
+#endif /* GINT_RENDER_MONO */
 
 #endif /* GINT_DISPLAY_FX */

include/gint/display.h

@@ -15,15 +15,16 @@ extern "C" {
 
 #include <gint/defs/types.h>
 #include <gint/defs/call.h>
+#include <gint/config.h>
 
 /* Platform-specific functions include VRAM management and the definition of
    the color_t type. */
 
-#ifdef FX9860G
+#if GINT_RENDER_MONO
 #include <gint/display-fx.h>
 #endif
 
-#ifdef FXCG50
+#if GINT_RENDER_RGB
 #include <gint/display-cg.h>
 #endif
 
@@ -212,6 +213,53 @@ void dhline(int y, int color);
    @color  Line color (same values as dline() are allowed) */
 void dvline(int x, int color);
 
+//---
+// Other geometric shapes
+//---
+
+/* dcircle(): Circle with border
+
+   This function renders a circle defined by its middle point (xm, ym) and a
+   radius r. The border and fill can be set separately. This function uses
+   Bresenham's algorithm and only renders circles of odd diameter; if you want
+   an even diameter, use dellipse() with a bounding box.
+
+   @xm @ym        Coordinates of center
+   @r             Radius (integer, >= 0)
+   @fill_color    Color of the disc inside the circle, C_NONE to disable
+   @border_color  Color of the circle itself, C_NONE to disable */
+void dcircle(int xm, int ym, int r, int fill_color, int border_color);
+
+/* dellipse(): Ellipse with border
+
+   This function renders a non-rotated ellipse, defined by its bounding box.
+   The border and fill can be set separately. The border is as 1-pixel thin
+   border given by Bresenham's algorithm.
+
+   To render an ellipse from its center coordinates (x,y) and semi-major/minor
+   axes a/b, use dellipse(x-a, y-b, x+a, y+b, fill_color, border_color).
+
+   @x1 @y1 @x2 @y2  Ellipse's bounding box (both bounds included, like drect())
+   @fill_color      Color of the surface inside the ellipse, C_NONE to disable
+   @border_color    Color of the ellipse itself, C_NONE to disable */
+void dellipse(int x1, int y1, int x2, int y2, int fill_color,
+   int border_color);
+
+/* dpoly(): Render an arbitrary polygon
+
+   Renders the polygon defined by vertices (x[i], y[i]) for 0 < i < N. A fill
+   color and border color can be specified separately. For filling, N must be
+   at least 3. For border, N must be at least 2.
+
+   Note: this is a fairly slow function, not designed for rendering triangles
+   in 3D games. There are faster methods for that.
+
+   @x @y          Arrays of vertex coordinates
+   @N             Number of vertices (length of x and y)
+   @fill_color    Color of the polygon's interior, C_NONE to disable
+   @border_color  Color of the polygon's border, C_NONE to disable */
+void dpoly(int const *x, int const *y, int N, int fill_color, int border_color);
+
 //---
 //	Text rendering (topti)
 //---
@@ -413,6 +461,28 @@ void dprint_opt(int x, int y, int fg, int bg, int halign, int valign,
    Calls dprint_opt() with bg=C_NONE, halign=DTEXT_LEFT and valign=DTEXT_TOP */
 void dprint(int x, int y, int fg, char const *format, ...);
 
+//---
+// Text rendering utilities
+//---
+
+/* dfont_glyph_index(): Obtain the glyph index of a Unicode code point
+
+   Returns the position of code_point in the character table of the given font,
+   or -1 if code_point is not part of that set. */
+int dfont_glyph_index(font_t const *font, uint32_t code_point);
+
+/* topti_glyph_offset(): Use a font index to find the location of a glyph
+
+   The provided glyph value (usuall obtained by dfont_glyph_index()) must be
+   nonnegative. Returns the offset the this glyph's data in the font's data
+   array. When using a proportional font, the size array is ignored. */
+int dfont_glyph_offset(font_t const *font, uint glyph_number);
+
+/* dtext_utf8_next(): Read the next UTF-8 code point of a string
+   Returns the next code point and advances the string. Returns 0 (NUL) at the
+   end of the string. */
+uint32_t dtext_utf8_next(uint8_t const **str_pointer);
+
 //---
 //	Image rendering (bopti)
 //---

include/gint/drivers.h

@@ -267,7 +267,7 @@ typedef void **gint_world_t;
    the section name and the linker then sorts by name. If your driver has a
    level lower than 10, you must add a leading 0. */
 #define GINT_DECLARE_DRIVER(level, name) \
-	GSECTION(".gint.drivers." #level) extern gint_driver_t name;
+	GSECTION(".gint.drivers." #level) GVISIBLE extern gint_driver_t name;
 
 //---
 // Internal driver control

include/gint/drivers/keydev.h

@@ -158,7 +158,7 @@ typedef struct {
 	int8_t queue_next;
 	int8_t queue_end;
 	/* Number of events lost because of missing queue space */
-	uint events_lost;
+	uint16_t events_lost;
 
 	/* Event transforms */
 	keydev_transform_t tr;
@@ -183,9 +183,9 @@ typedef struct {
 	// <Repeats>
 
 	/* Candidate key for repeats (or 0 if no key is candidate yet) */
-	int rep_key;
+	int16_t rep_key;
 	/* Number of repeats already sent */
-	int rep_count;
+	int16_t rep_count;
 	/* Time since key was first pressed (us) */
 	int rep_time;
 	/* Delay until next repeat, set by the repeat planner (us) */
@@ -207,6 +207,9 @@ typedef struct {
 	/* Parameters for the standard repeat function */
 	int rep_standard_first, rep_standard_next;
 
+   /* State of keys that have changes since the last flip monitoring reset. */
+   GALIGNED(4) uint8_t state_flips[12];
+
 } keydev_t;
 
 /* keydev_std(): Standard keyboard input device
@@ -274,6 +277,17 @@ void keydev_set_async_filter(keydev_t *d, keydev_async_filter_t filter);
 /* keydev_keydown(): Check if a key is down according to generated events */
 bool keydev_keydown(keydev_t *d, int key);
 
+/* keydev_keypressed(): Check if a key was pressed
+   This compares to the state at the time of the last keydev_clear_flips(). */
+bool keydev_keypressed(keydev_t *d, int key);
+
+/* keydev_keyreleased(): Check if a key was released
+   This compares to the state at the time of the last keydev_clear_flips(). */
+bool keydev_keyreleased(keydev_t *d, int key);
+
+/* keydev_clear_flips(): Reset flip info used by keypressed()/keyreleased() */
+void keydev_clear_flips(keydev_t *d);
+
 /* keydev_transform(): Obtain current transform parameters */
 keydev_transform_t keydev_transform(keydev_t *d);
 

include/gint/drivers/r61523.h

@@ -0,0 +1,26 @@
+//---
+//  gint:drivers:r61523 - Reneses R61523 driver
+//
+//  This driver is used to control the 16-bit color LCD of the fx-CP 400.
+//---
+
+#ifndef GINT_DRIVERS_R61523
+#define GINT_DRIVERS_R61523
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <gint/defs/types.h>
+
+/* r61523_display(): Update the entire display (320x528) */
+void r61523_display(uint16_t *vram);
+
+/* r61523_win_set(): Set the display window */
+void r61523_win_set(int x1, int x2, int y1, int y2);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* GINT_DRIVERS_R61523 */

include/gint/drivers/r61524.h

@@ -49,6 +49,18 @@ void r61524_display(uint16_t *vram, int start, int height, int method);
 void r61524_display_rect(uint16_t *vram, int xmin, int xmax, int ymin,
    int ymax);
 
+/* r61524_display_mono_128x64(): Display a mono-style VRAM
+   This experimental function updates the display with the contents of a 128x64
+   VRAM, used with the fxg3a compilation target.
+   TODO: Make that a video mode. */
+void r61524_display_mono_128x64(uint32_t *vram);
+
+/* r61524_display_mono_128x64(): Display a gray-style VRAM
+   This experimental function updates the display with the contents of a 128x64
+   gray VRAM pair, used with the fxg3a compilation target.
+   TODO: Make that a video mode. */
+void r61524_display_gray_128x64(uint32_t *light, uint32_t *dark);
+
 /* r61524_start_frame(): Prepare the display for a region update
 
    This function sets up the display driver to receive graphics data to update

include/gint/drivers/states.h

@@ -28,6 +28,7 @@ typedef struct {
 	uint32_t SR;
 	uint32_t VBR;
 	uint32_t CPUOPM;
+	uint32_t rN_bank[8];
 } cpu_state_t;
 
 /* Direct Memory Access controller (see dma/dma.c) */

include/gint/fs.h

@@ -78,7 +78,7 @@ void fs_free_descriptor(int fd);
    exact file descriptor reuse_fd is used. (This is useful to reopen standard
    streams.) In this case, the only possible return values are -1 and reuse_fd
    itself. */
-int open_generic(fs_descriptor_type_t *type, void *data, int reuse_fd);
+int open_generic(fs_descriptor_type_t const *type, void *data, int reuse_fd);
 
 /* fs_path_normalize(): Normalize a path to eliminate ., .. and redundant /
 

include/gint/gdb.h

@@ -0,0 +1,105 @@
+//---
+// gint:gdb - GDB remote serial protocol
+//---
+
+#ifndef GINT_GDB
+#define GINT_GDB
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+/* gdb_cpu_state_t: State of the CPU when breaking
+   This struct keep the same register indices as those declared by GDB to allow
+   easy R/W without needing a "translation" table.
+   See : https://sourceware.org/git/?p=binutils-gdb.git;a=blob;f=gdb/sh-tdep.c;
+         h=c402961b80a0b4589243023ea5362d43f644a9ec;hb=4f3e26ac6ee31f7bc4b04abd
+         8bdb944e7f1fc5d2#l361
+ */
+// TODO : Should we expose r*b*, ssr, spc ? are they double-saved when breaking
+//        inside an interrupt handler ?
+typedef struct {
+	union {
+		struct {
+			uint32_t r0;
+			uint32_t r1;
+			uint32_t r2;
+			uint32_t r3;
+			uint32_t r4;
+			uint32_t r5;
+			uint32_t r6;
+			uint32_t r7;
+			uint32_t r8;
+			uint32_t r9;
+			uint32_t r10;
+			uint32_t r11;
+			uint32_t r12;
+			uint32_t r13;
+			uint32_t r14;
+			uint32_t r15;
+			uint32_t pc;
+			uint32_t pr;
+			uint32_t gbr;
+			uint32_t vbr;
+			uint32_t mach;
+			uint32_t macl;
+			uint32_t sr;
+		} reg;
+		uint32_t regs[23];
+	};
+} gdb_cpu_state_t;
+
+/* gdb_start(): Start the GDB remote serial protocol server
+
+   This function starts the GDB stub (program that communicates with GDB). It
+   takes over USB, and returns once communication is established with a GDB
+   instance on the computer. Normally this is called by the panic handler after
+   a crash. It can also be called manually, in which case it should be followed
+   by a call to gdb_main() with the current state (NULL if you don't have any).
+
+   If the GDB stub is already started, this is a no-op. Returns 0 on success
+   and a negative value if the USB setup fails. */
+int gdb_start(void);
+
+/* gdb_main(): Main GDB loop
+   Main loop for when the program is in a paused state. Communicates with GDB
+   over USB and mutates the cpu_state struct, memory and the UBC configuration
+   accordingly. Returns once the program should resume. */
+void gdb_main(gdb_cpu_state_t *cpu_state);
+
+/* gdb_start_on_exception(): Set the GDB stub to autostart on crashes
+   This function sets a crash handler that starts the GDB stub whenever a
+   System ERROR occurs. */
+// TODO: Get some visible signal on-screen when that happens
+void gdb_start_on_exception(void);
+
+/* gdb_redirect_streams(): Select whether to redirect stdout/stderr
+
+   This function specifies whether stdout and stderr shall be redirected when
+   debugging. If redirected, stdout and stderr will change from their default
+   implementation (or the one supplied by the user via open_generic()) to a
+   stubcall that prints text in the GDB console. This setting must be set
+   before GDB starts, so usually just after gdb_start_on_exception().
+
+   This is intended to be used with debug methods that print text. For example,
+   if the program has a status() function that prints information useful when
+   debugging, one might want to invoke it from GDB with "call status()". With
+   default stdout/stderr this would be at best impractical to read the output
+   on the calculator, at worst buggy due to the program being interrupted.
+   Redirecting stdout/stderr allows the result to be printed in GDB.
+
+   The default is to not redirect stdout/stderr. */
+void gdb_redirect_streams(bool redirect_stdout, bool redirect_stderr);
+
+/** Stubcalls **/
+
+/* Write to a file descriptor on the remote debugger. */
+void gdb_stubcall_write(int fd, void const *buf, size_t size);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* GINT_GDB */

include/gint/gint.h

@@ -80,6 +80,56 @@ void gint_osmenu_native(void);
    @restart  0 to exit, 1 to restart by using gint_osmenu() */
 void gint_setrestart(int restart);
 
+/* gint_poweroff(): World switch and power off the calculator
+   Shows the CASIO logo / poweroff screen if show_logo is true. The program
+   will resume execution normally after powering on again. Don't call this
+   function with show_logo=false as a result of pressing AC/ON because the
+   calculator will restart immediately unless the user releases the AC/ON key
+   extremely quickly. */
+void gint_poweroff(bool show_logo);
+
+/* gint_set_onchip_save_mode(): Specify memory save policy for world switches
+
+   World switches can cause corruption in on-chip memory in two ways. First, if
+   the calculator powers off while in the OS world, on-chip memory will be
+   wiped because it's not powered when the calculator is off. Second, the OS
+   may run code that overwrites on-chip memory (we don't have any examples of
+   that but it's not part of the add-in interface).
+
+   As a result, the best option is to backup on-chip memory and restore it when
+   loading back into the add-in. The issue is that there's 20 kB of on-chip
+   memory (4 kB ILRAM + 16 kB XYRAM) and on some machines (fx-9860G-like) or in
+   some applications we don't have that much memory lying around.
+
+   This function selects between three modes for handling this save:
+
+   * [Reinitialization mode]
+     Don't save on-chip memory at all, instead just reinitialize the globals
+     and leave the rest corrupted. This is useful if on-chip memory is used
+     only for temporaries (e.g. frames in Azur), for which we don't care if
+     they're corrupted, or code (e.g gint interrupt handling code), which will
+     be reloaded and is otherwise a constant.
+
+   * [Backup mode]
+     Save on-chip memory to a user-provided buffer of size GINT_ONCHIP_BUFSIZE.
+
+   * [Nothing mode]
+     Don't do anything, and let the world switch function choose its preferred
+     saving method. This allows application-specific compromises.
+
+   This is not a problem on SH3 because on-chip memory is only used on SH4. */
+enum {
+   GINT_ONCHIP_REINITIALIZE = 0,
+   GINT_ONCHIP_BACKUP = 1,
+   GINT_ONCHIP_NOTHING = 2,
+};
+#define GINT_ONCHIP_BUFSIZE (20 << 10)
+
+void gint_set_onchip_save_mode(int mode, void *ptr);
+
+/* gint_get_onchip_save_mode(): Get the current on-chip memory save policy */
+int gint_get_onchip_save_mode(void **ptr);
+
 /* This function has been moved to the INTC driver */
 __attribute__((deprecated("Use intc_handler() instead")))
 static GINLINE void *gint_inthandler(int code, void const *h, size_t size) {
@@ -105,10 +155,29 @@ static GINLINE void *gint_inthandler(int code, void const *h, size_t size) {
    .callback:
         .long	_gint_inth_callback
 
+   The gint_call_t object can be built with GINT_CALL_FLAG to specify that the
+   called function should get a pointer to a gint_inth_callback_context_t
+   strcture as its first argument.
+
    @call  Address of a gint_call_t object
    Returns the return value of the callback. */
 extern int (*gint_inth_callback)(gint_call_t const *call);
 
+/* gint_inth_callback_context_t: Context of the interrupted function when an
+   interrupt is handled by gint_inth_callback. */
+typedef struct {
+	uint32_t ssr;
+	uint32_t spc;
+	uint32_t r7;
+	uint32_t r6;
+	uint32_t r5;
+	uint32_t r4;
+	uint32_t r3;
+	uint32_t r2;
+	uint32_t r1;
+	uint32_t r0;
+} gint_inth_callback_context_t;
+
 /* gint_set_quit_handler(): Setup a call to be invoked when leaving the add-in
 
    This function sets up the provided GINT_CALL() to be invoked when the

include/gint/hardware.h

@@ -18,6 +18,8 @@
 extern "C" {
 #endif
 
+#include <gint/config.h>
+
 /* For compatibility with ASM, include the following bits only in C code */
 #ifndef CPP_ASM
 
@@ -40,20 +42,14 @@ void hw_detect(void);
    dual-platform version for libraries.
    Warning: this macro is also used hardcoded in exch.s. */
 
-#if defined(FX9860G) || (!defined(FX9860G) && !defined(FXCG50))
-#define isSH3() (gint[HWMPU] & 1)
-#define isSH4() (!isSH3())
-#endif
-
-#if defined(FX9860G)
-#define isSlim() (gint[HWCALC] == HWCALC_FX9860G_SLIM)
-#else
-#define isSlim() 0
-#endif
-
-#ifdef FXCG50
-#define isSH3() 0
-#define isSH4() 1
+#if GINT_HW_FX
+# define isSH3() (gint[HWMPU] & 1)
+# define isSH4() (!isSH3())
+# define isSlim() (gint[HWCALC] == HWCALC_FX9860G_SLIM)
+#elif GINT_HW_CG || GINT_HW_CP
+# define isSH3() 0
+# define isSH4() 1
+# define isSlim() 0
 #endif
 
 /* This bit should be set in all data longwords except HWMPU, HWCPUVR, HWCPUPR
@@ -113,6 +109,8 @@ void hw_detect(void);
 #define HWCALC_FXCG_MANAGER  6
 /* fx-9860G Slim, SH-3-based fx-9860G with hardware differences */
 #define HWCALC_FX9860G_SLIM  7
+/* fx-CP 400 */
+#define HWCALC_FXCP400       8
 
 /*
 **  Keyboard

include/gint/image.h

@@ -34,10 +34,7 @@
 extern "C" {
 #endif
 
-#ifndef FXCG50
-#error <gint/image.h> is only supported on FXCG50
-#else
-
+#include <gint/config.h>
 #include <gint/defs/attributes.h>
 #include <gint/defs/types.h>
 
@@ -169,6 +166,8 @@ enum {
 // Image creation and destruction
 //---
 
+#if GINT_RENDER_RGB
+
 /* image_alloc(): Create a new (uninitialized) image
 
    This function allocates a new image of the specified dimensions and format.
@@ -414,7 +413,7 @@ image_t *image_sub(image_t const *src, int x, int y, int w, int h,
 
 /* Make the last parameter optional */
 #define image_sub1(src, x, y, w, h, dst, ...) image_sub(src, x, y, w, h, dst)
-#define image_sub(...) image_sub(__VA_ARGS__, NULL)
+#define image_sub(...) image_sub1(__VA_ARGS__, NULL)
 
 /* image_at(): Build a reference to a position within a sub-image */
 #define image_at(img, x, y) image_sub(img, x, y, -1, -1)
@@ -434,9 +433,9 @@ image_t *image_sub(image_t const *src, int x, int y, int w, int h,
 // that allocation can fail, so you need to check whether the returned image is
 // valid.
 //
-// (You can still pass an invalid image to libimg functions when chaining
-//  transforms. The invalid image will be ignored or returned unchanged, so you
-//  can check for it at the end of any large chain.)
+// (You can still pass invalid images to transform functions. The invalid image
+//  will be ignored or returned unchanged, so you can chain calls and check for
+//  validity at the end of the chain.)
 //
 // Some functions support in-place transforms. This means they can be called
 // with the source as destination, and will transform the image without needing
@@ -838,7 +837,7 @@ bool image_target(image_t const *src, image_t *dst, ...);
 #define image_alpha_2(fmt, copy_alpha) \
         ((copy_alpha) ? 0x10000 : image_alpha(fmt))
 
-#endif /* FXCG50 */
+#endif /* GINT_RENDER_RGB */
 
 #ifdef __cplusplus
 }

include/gint/intc.h

@@ -41,6 +41,8 @@ enum {
 	INTC_DMA_DEI4,
 	INTC_DMA_DEI5,
 	INTC_DMA_DADERR,
+	/* Serial Communication Interface with FIFO (SCIF0) */
+	INTC_SCIF0,
 	/* Real-Time Clock [RTC]; a single IPR covers all 3 interrupts */
 	INTC_RTC_ATI,
 	INTC_RTC_PRI,
@@ -130,6 +132,11 @@ void *intc_handler(int event_code, void const *handler, size_t size);
    the numerous constraints of intc_handler(), at the cost of always going back
    to userspace and a small time overhead.
 
+   Since gint_inth_callback is used to do the heavy lifting of setting up a sane
+   context for C code, the gint_call_t object can be built with GINT_CALL_FLAG
+   if the called function expects a gint_inth_callback_context_t structure as its
+   first argument.
+
    @event_code  Identifier of the interrupt block
    @function    Function to use as a handler
    Returns true on success, false if the event code is invalid. */

include/gint/keyboard.h

@@ -60,6 +60,24 @@ extern "C" {
 
    * clearevents() reads all pending events from the input queue.
 
+   Games are often also interested in whether keys were pressed or released
+   _since the last frame_. gint doesn't know what a frame is, but you can track
+   key state flips by using cleareventflips() before reading events and
+   keypressed() and keyreleased() afterwards.
+
+   * keypressed() checks if the specified key is currently down and was up at
+     the time of the last cleareventflips().
+   * keyreleased() checks if the specified key is currently up and was down at
+     the time of the last cleareventflips().
+
+   A typical game loop might look like. cleareventflips() must be called
+   _before_ clearevents().
+
+     cleareventflips();
+     clearevents(); // or pollevent(), waitevent()
+     if(keydown(KEY_RIGHT)) move();
+     if(keypressed(KEY_F6)) open_inventory();
+
    The previous functions are quite low-level. GUI programs that look like the
    system applications will prefer using a GetKey()-like functions that return
    a single key press at a time, heeds for releases, for SHIFT and ALPHA
@@ -98,13 +116,13 @@ typedef struct
 {
 	uint time	:16;	/* Time of event, unique over short periods */
 
-	uint		:3;	/* Reserved for future use */
+	uint		:2;	/* Reserved for future use */
 
 	uint mod	:1;	/* Whether modifiers are used */
 	uint shift	:1;	/* If mod=1, whether SHIFT was pressed */
 	uint alpha	:1;	/* If mod=1, whether ALPHA was pressed */
 
-	uint type	:2;	/* Type of key event */
+	uint type	:3;	/* Type of key event */
 	uint key	:8;	/* Hit key */
 
 } GPACKED(4) key_event_t;
@@ -112,10 +130,11 @@ typedef struct
 /* Keyboard event types, as in the [type] field of key_event_t */
 enum
 {
-	KEYEV_NONE = 0,		/* No event available (poll() only) */
-	KEYEV_DOWN = 1,		/* Key was pressed */
-	KEYEV_UP   = 2,		/* Key was released */
-	KEYEV_HOLD = 3,		/* A key that was pressed has been held down */
+	KEYEV_NONE   = 0,	/* No event available (poll() only) */
+	KEYEV_DOWN   = 1,	/* Key was pressed */
+	KEYEV_UP     = 2,	/* Key was released */
+	KEYEV_HOLD   = 3,	/* A key that was pressed has been held down */
+	KEYEV_OSMENU = 4,	/* We went to the main menu and back */
 };
 
 /* Keyboard frequency analysis is a runtime setting since gint 2.4. This macro
@@ -162,6 +181,12 @@ key_event_t waitevent(volatile int *timeout);
 /* clearevents(): Read all events waiting in the queue */
 void clearevents(void);
 
+/* cleareventflips(): Set the time reference for keypressed()/keyreleased()
+   The two functions keypressed() and keyreleased() will use the keyboard state
+   at the time this function was called to determine whether any given key was
+   just pressed or jut released. */
+void cleareventflips(void);
+
 //---
 //	Key state functions
 //---
@@ -181,6 +206,16 @@ int keydown_all(int key1, ...);
    sequence should be terminated by a 0 integer. */
 int keydown_any(int key1, ...);
 
+/* keypressed(): Check if a key was just pressed
+   This function returns non-zero if the specified key is currently down, *and*
+   it was up at the time of the last call to cleareventflips(). */
+int keypressed(int key);
+
+/* keyreleased(): Check if a key was just released
+   This function returns non-zero if the specified key is currently up, *and*
+   it was down at the time of the last call to cleareventflips(). */
+int keyreleased(int key);
+
 //---
 //	High-level functions
 //---
@@ -205,24 +240,30 @@ key_event_t getkey(void);
 /* The following are the option bits for getkey_opt(). */
 enum {
 	/* Enable modifiers keys */
-	GETKEY_MOD_SHIFT   = 0x01,
-	GETKEY_MOD_ALPHA   = 0x02,
+	GETKEY_MOD_SHIFT      = 0x0001,
+	GETKEY_MOD_ALPHA      = 0x0002,
 	/* SHIFT + OPTN (requires GETKEY_MOD_SHIFT) or LIGHT toggles backlight */
-	GETKEY_BACKLIGHT   = 0x04,
+	GETKEY_BACKLIGHT      = 0x0004,
 	/* MENU triggers a task switch and displays the main menu */
-	GETKEY_MENU        = 0x08,
+	GETKEY_MENU           = 0x0008,
 	/* Repeat arrow keys, or even all keys */
-	GETKEY_REP_ARROWS  = 0x10,
-	GETKEY_REP_ALL     = 0x20,
+	GETKEY_REP_ARROWS     = 0x0010,
+	GETKEY_REP_ALL        = 0x0020,
 	/* Enable custom repeat profiles; see getkey_set_repeat_profile() */
-	GETKEY_REP_PROFILE = 0x40,
+	GETKEY_REP_PROFILE    = 0x0040,
 	/* Enable application shortcuts; see getkey_set_feature_function() */
-	GETKEY_FEATURES    = 0x80,
+	GETKEY_FEATURES       = 0x0080,
+	/* After coming back from the main menu, redraw the screen with dupdate */
+	GETKEY_MENU_DUPDATE   = 0x0100,
+	/* After coming back from the main menu, send a KEYEV_OSMENU event */
+	GETKEY_MENU_EVENT     = 0x0200,
+	/* Enable power off with SHIFT + AC/ON */
+	GETKEY_POWEROFF       = 0x0400,
 
 	/* No modifiers */
-	GETKEY_NONE        = 0x00,
+	GETKEY_NONE           = 0x0000,
 	/* Default settings of getkey() */
-	GETKEY_DEFAULT     = 0xdf,
+	GETKEY_DEFAULT        = 0x05df,
 };
 
 /* getkey_feature_t: Custom feature function

include/gint/keycodes.h

@@ -79,6 +79,14 @@ enum {
 	KEY_HELP	= 0x20, /* fx-9860G Slim: 0x75 */
 	KEY_LIGHT	= 0x10, /* fx-9860G Slim: 0x76 */
 
+	/* Key codes for the CP-400 */
+	KEY_KBD		= 0xa1,
+	KEY_X		= 0xa2,
+	KEY_Y		= 0xa3,
+	KEY_Z		= 0xa4,
+	KEY_EQUALS	= 0xa5,
+	KEY_CLEAR       = KEY_EXIT,
+
 	/* Key aliases (handle with care =D) */
 	KEY_X2		= KEY_SQUARE,
 	KEY_CARET	= KEY_POWER,

include/gint/kmalloc.h

@@ -108,6 +108,11 @@ void kmalloc_init_arena(kmalloc_arena_t *a, bool enable_statistics);
    success, false if the maximum number of arenas has been reached. */
 bool kmalloc_add_arena(kmalloc_arena_t *arena);
 
+/* kmalloc_remove_arena(): Remove an arena from the heap source
+   Removes an arena from the heap source. The arena should certainly be empty,
+   although this function will not check that. */
+void kmalloc_remove_arena(kmalloc_arena_t *arena);
+
 //---
 // Internal functions
 //---

include/gint/mpu/ubc.h

@@ -0,0 +1,90 @@
+//---
+// gint:mpu:ubc - User Break Controller
+//---
+
+#ifndef GINT_MPU_UBC
+#define GINT_MPU_UBC
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <gint/defs/types.h>
+
+typedef volatile struct
+{
+	lword_union(CBR0, /* Match condition setting 0 */
+		uint32_t MFE	:1; /* Match Flag Enable */
+		uint32_t AIE	:1; /* ASID Enable */
+		uint32_t MFI	:6; /* Match Flag Specify */
+		uint32_t AIV	:8; /* ASID Specify */
+		uint32_t	:1;
+		uint32_t SZ	:3; /* Operand Size Select */
+		uint32_t	:4;
+		uint32_t CD	:2; /* Bus Select */
+		uint32_t ID	:2; /* Ins. Fetch / Operand Access Select */
+		uint32_t	:1;
+		uint32_t RW	:2; /* Bus Command Select */
+		uint32_t CE	:1; /* Channel Enable */
+	);
+	lword_union(CRR0, /* Match operation setting 0 */
+		uint32_t	:18;
+		uint32_t _1	:1; /* Always set to 1 */
+		uint32_t	:11;
+		uint32_t PCB	:1; /* PC Break Select */
+		uint32_t BIE	:1; /* Break Enable */
+	);
+	uint32_t CAR0; /* Match address setting 0 */
+	uint32_t CAMR0; /* Match address mask setting 0 */
+	pad(0x10);
+
+	lword_union(CBR1, /* Match condition setting 1 */
+		uint32_t MFE	:1; /* Match Flag Enable */
+		uint32_t AIE	:1; /* ASID Enable */
+		uint32_t MFI	:6; /* Match Flag Specify */
+		uint32_t AIV	:8; /* ASID Specify */
+		uint32_t DBE	:1; /* Data Value Enable */
+		uint32_t SZ	:3; /* Operand Size Select */
+		uint32_t ETBE	:1; /* Execution Count Value Enable */
+		uint32_t	:3;
+		uint32_t CD	:2; /* Bus Select */
+		uint32_t ID	:2; /* Ins. Fetch / Operand Access Select */
+		uint32_t	:1;
+		uint32_t RW	:2; /* Bus Command Select */
+		uint32_t CE	:1; /* Channel Enable */
+	);
+	lword_union(CRR1, /* Match operation setting 1 */
+		uint32_t	:18;
+		uint32_t _1	:1; /* Always set to 1 */
+		uint32_t	:11;
+		uint32_t PCB	:1; /* PC Break Select */
+		uint32_t BIE	:1; /* Break Enable */
+	);
+	uint32_t CAR1; /* Match address setting 1 */
+	uint32_t CAMR1; /* Match address mask setting 1 */
+	uint32_t CDR1; /* Match data setting 1 */
+	uint32_t CDMR1; /* Match data mask setting 1 */
+	lword_union(CETR1, /* Execution count break 1 */
+		uint32_t	:20;
+		uint32_t CET	:12; /* Execution Count */
+	);
+	pad(0x5c4);
+
+	lword_union(CCMFR, /* Channel match flag */
+		uint32_t	:30;
+		uint32_t MF1	:1; /* Channel 1 Condition Match Flag */
+		uint32_t MF0	:1; /* Channel 0 Condition Match Flag */
+	);
+	pad(0x1c);
+	lword_union(CBCR, /* Break control */
+		uint32_t	:31;
+		uint32_t UBDE	:1; /* User Break Debugging Support Function Enable */
+	);
+} GPACKED(4) sh7305_ubc_t;
+#define SH7305_UBC (*(sh7305_ubc_t *)0xff200000)
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* GINT_MPU_UBC */

include/gint/ubc.h

@@ -0,0 +1,58 @@
+//---
+// gint:ubc - User Break Controller driver
+//---
+
+#ifndef GINT_UBC
+#define GINT_UBC
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <gint/gdb.h>
+
+/* Read and write the DBR register */
+void ubc_setDBR(void* DBR);
+void* ubc_getDBR(void);
+
+/* ubc_dbh(): Low level UBC debug handler
+   The handler will backup the current CPU state and call ubc_debug_handler(). */
+void ubc_dbh(void);
+/* ubc_debug_handler(): C level UBC debug handler
+   The execution will be redirected to the handler set by the user or the break
+   will be ignored in case no handler has been set. */
+void ubc_debug_handler(gdb_cpu_state_t* cpu_state);
+/* ubc_set_debug_handler(): Set user debug handler
+   Set a custom debug handler that will be called when a break condition from
+   the UBC is reached. */
+void ubc_set_debug_handler(void (*h)(gdb_cpu_state_t*));
+
+/* ubc_dbh_lock: Lock set by ubc_dbh() when a UBC break is currently being
+   handled. */
+extern uint8_t ubc_dbh_lock;
+
+/* UBC Breakpoint types */
+typedef enum {
+	UBC_BREAK_BEFORE, /* Break before the instruction is executed */
+	UBC_BREAK_AFTER,  /* Break after the instruction is executed :
+                             at this point PC will point to the next instruction. */
+} ubc_break_mode_t;
+
+/* ubc_set_breakpoint(): Set a breakpoint in a UBC channel and enable it
+   Return false when an invalid channel number is provided, true if the
+   breakpoint was correctly set up. */
+bool ubc_set_breakpoint(int channel, void* break_address, ubc_break_mode_t break_mode);
+/* ubc_get_break_address(): Get a breakpoint address if it's enabled
+   If the channel is disabled the function will return false and *break_address
+   will not be updated. */
+bool ubc_get_break_address(int channel, void** break_address);
+/* ubc_disable_channel(): Disable a UBC channel
+   Return true on success. If an invalid channel number is provided, it will
+   return false. */
+bool ubc_disable_channel(int channel);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* GINT_UBC */

include/gint/usb-ff-bulk.h

@@ -32,6 +32,7 @@ extern "C" {
 #endif
 
 #include <gint/usb.h>
+#include <gint/config.h>
 struct usb_fxlink_header;
 
 /* This bulk transfer interface with class code 0xff/0x77 implements a simple
@@ -74,7 +75,7 @@ void usb_fxlink_screenshot(bool onscreen);
    automatically send new frames to fxlink. */
 void usb_fxlink_videocapture(bool onscreen);
 
-#ifdef FX9860G
+#if GINT_RENDER_MONO
 /* Similar to usb_fxlink_screenshot(), but takes a gray screenshot if the gray
    engine is currently running. */
 void usb_fxlink_screenshot_gray(bool onscreen);

include/gint/usb.h

@@ -90,6 +90,9 @@ void usb_open_wait(void);
 /* usb_is_open(): Check whether the USB link is active */
 bool usb_is_open(void);
 
+/* usb_is_open_interface(): Check whether a particular interface is open */
+bool usb_is_open_interface(usb_interface_t const *interface);
+
 /* usb_close(): Close the USB link
 
    This function closes the link opened by usb_open(), and notifies the host of
@@ -517,6 +520,14 @@ uint16_t usb_dc_string(uint16_t const *literal, size_t len);
    This is mostly used by the driver to answer GET_DESCRIPTOR requests. */
 usb_dc_string_t *usb_dc_string_get(uint16_t id);
 
+//---
+// USB interrupts
+//---
+
+/* usb_interrupt_context: Context of the function interrupted by a USB interrupt
+   The pointer is set back to NULL when the interrupt is finished being handled. */
+extern gint_inth_callback_context_t* usb_interrupt_context;
+
 #ifdef __cplusplus
 }
 #endif

include/gint/video.h

@@ -0,0 +1,93 @@
+//---
+// gint:video - Generic video interface
+//
+// This header defines the interface for video (display) drivers. It allows
+// high-level code to manipulate the display independently of the underlying
+// hardware.
+//---
+
+#ifndef GINT_VIDEO
+#define GINT_VIDEO
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <gint/defs/types.h>
+#include <gint/drivers.h>
+#include <gint/image.h>
+
+/* Video mode offered by a driver for rendering. */
+typedef struct {
+    /* Mode size */
+    uint16_t width;
+    uint16_t height;
+    /* Pixel format */
+    int16_t format;
+    /* Refresh frequency, -1 if unknown */
+    int16_t freq;
+} video_mode_t;
+
+/* Flags for the update function of the interface. */
+#define VIDEO_UPDATE_NONE           0x00
+#define VIDEO_UPDATE_ENABLE_DMA     0x01
+#define VIDEO_UPDATE_ATOMIC         0x02
+#define VIDEO_UPDATE_FOREIGN_WORLD  0x04
+
+/* Video driver interface. */
+typedef struct {
+    /* Associated driver (NULL if there's none). */
+    gint_driver_t const *driver;
+
+    /* List of modes (terminated by an all-0 element). The first mode is the
+       default mode and it should always be available. */
+    video_mode_t const *modes;
+    /* Get current video mode. */
+    uint (*mode_get)(void);
+    /* Set a video mode. */
+    bool (*mode_set)(uint id);
+
+    /* Minimum and maximum brightness settings. */
+    int brightness_min;
+    int brightness_max;
+    /* Set a brightness setting. */
+    bool (*brightness_set)(int setting);
+
+    /* Implements video_update(); bounds are checked befoer calling. */
+    bool (*update)(int x, int y, image_t const *framebuffer, int flags);
+
+} video_interface_t;
+
+/* Get the video interface currently in use. This can be NULL if the program is
+   being linked without a display driver. */
+video_interface_t const *video_get_current_interface(void);
+
+/* Get the index of the current video mode. This can be -1 if there is no
+   interface; however, if there is an interface, this is always >= 0. */
+int video_get_current_mode_index(void);
+
+/* Get the a pointer to the current video mode's definition. */
+video_mode_t const *video_get_current_mode(void);
+
+/* Update the contents of the display from a framebuffer image. A combination
+   of `VIDEO_UPDATE_*` flags can be specified to select the update method:
+   - `ENABLE_DMA` allows the driver to copy using DMA, when applicable;
+   - `ATOMIC` requires the driver to use an interrupt-less method.
+   Returns true on success.
+
+   Update flags will be ignored if not applicable (e.g. `ENABLE_DMA` for a
+   video interface that doesn't support DMA) but will result in an error if
+   applicable and the specified method fails (e.g. DMA transfer error).
+
+   This function is usually called with (x,y) = (0,0) and a contiguous
+   framebuffer whose size is the video mode size. Specifying images with other
+   sizes, positions and strides is allowed only when they result in data
+   transfers that are byte-aligned. DMA support is only guaranteed for
+   contiguous input and output. The implied rectangle must be in-bounds. */
+bool video_update(int x, int y, image_t const *fb, int flags);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* GINT_VIDEO */

src/cpg/cpg.c

@@ -5,6 +5,7 @@
 #include <gint/drivers.h>
 #include <gint/drivers/states.h>
 #include <gint/clock.h>
+#include <gint/config.h>
 
 #include <gint/hardware.h>
 #include <gint/mpu/cpg.h>
@@ -26,7 +27,7 @@ const clock_frequency_t *clock_freq(void)
 //	SH7705 Clock signals
 //---
 
-#if defined(FX9860G) || (!defined(FX9860G) && !defined(FXCG50))
+#if GINT_HW_FX
 
 void sh7705_probe(void)
 {
@@ -57,7 +58,7 @@ void sh7705_probe(void)
 	freq.Pphi_f = (ckio * pll1) / freq.Pphi_div;
 }
 
-#endif /* FX9860G and platform-agnostic */
+#endif
 
 //---
 //	SH7305 clock signals
@@ -111,7 +112,7 @@ void cpg_compute_freq(void)
 {
 	/* This avoids warnings about sh7705_probe() being undefined when
 	   building for fxcg50 */
-	#if defined(FX9860G) || (!defined(FX9860G) && !defined(FXCG50))
+	#if GINT_HW_FX
 	isSH3() ? sh7705_probe() :
 	#endif
 	sh7305_probe();

src/cpg/overclock.c

@@ -141,7 +141,7 @@ void cpg_set_overclock_setting(struct cpg_overclock_setting const *s)
     cpu_atomic_end();
 }
 
-#ifdef FX9860G
+#if GINT_HW_FX
 
 static struct cpg_overclock_setting const settings_fx9860g_sh3[5] = {
     /* CLOCK_SPEED_F1 */
@@ -312,9 +312,9 @@ static struct cpg_overclock_setting const settings_g35pe2[5] = {
       .CS5aWCR = 0x00031B40 },
 };
 
-#endif /* FX9860G */
+#endif
 
-#ifdef FXCG50
+#if GINT_HW_CG
 
 static struct cpg_overclock_setting const settings_prizm[5] = {
     /* CLOCK_SPEED_F1 */
@@ -432,25 +432,25 @@ static struct cpg_overclock_setting const settings_fxcg50[5] = {
       .CS5aWCR = 0x000203C1 },
 };
 
-#endif /* FXCG50 */
+#endif
 
 static struct cpg_overclock_setting const *get_settings(void)
 {
-#ifdef FX9860G
+#if GINT_HW_FX
     if(gint[HWCALC] == HWCALC_FX9860G_SH3)
         return settings_fx9860g_sh3;
     if(gint[HWCALC] == HWCALC_FX9860G_SH4)
         return settings_fx9860g_sh4;
     if(gint[HWCALC] == HWCALC_G35PE2)
         return settings_g35pe2;
-#endif /* FX9860G */
+#endif
 
-#ifdef FXCG50
+#if GINT_HW_CG
     if(gint[HWCALC] == HWCALC_PRIZM)
         return settings_prizm;
     if(gint[HWCALC] == HWCALC_FXCG50)
         return settings_fxcg50;
-#endif /* FXCG50 */
+#endif
 
     return NULL;
 }

src/cpu/cpu.c

@@ -45,6 +45,15 @@ static void hsave(cpu_state_t *s)
 		s->CPUOPM = cpu_getCPUOPM();
 		s->SR = cpu_getSR().lword;
 	}
+
+	__asm__("stc r0_bank, %0" : "=r"(s->rN_bank[0]));
+	__asm__("stc r1_bank, %0" : "=r"(s->rN_bank[1]));
+	__asm__("stc r2_bank, %0" : "=r"(s->rN_bank[2]));
+	__asm__("stc r3_bank, %0" : "=r"(s->rN_bank[3]));
+	__asm__("stc r4_bank, %0" : "=r"(s->rN_bank[4]));
+	__asm__("stc r5_bank, %0" : "=r"(s->rN_bank[5]));
+	__asm__("stc r6_bank, %0" : "=r"(s->rN_bank[6]));
+	__asm__("stc r7_bank, %0" : "=r"(s->rN_bank[7]));
 }
 
 static void hrestore(cpu_state_t const *s)
@@ -55,6 +64,15 @@ static void hrestore(cpu_state_t const *s)
 		cpu_setCPUOPM(s->CPUOPM);
 		cpu_setSR((cpu_sr_t)s->SR);
 	}
+
+	__asm__("ldc %0, r0_bank" :: "r"(s->rN_bank[0]));
+	__asm__("ldc %0, r1_bank" :: "r"(s->rN_bank[1]));
+	__asm__("ldc %0, r2_bank" :: "r"(s->rN_bank[2]));
+	__asm__("ldc %0, r3_bank" :: "r"(s->rN_bank[3]));
+	__asm__("ldc %0, r4_bank" :: "r"(s->rN_bank[4]));
+	__asm__("ldc %0, r5_bank" :: "r"(s->rN_bank[5]));
+	__asm__("ldc %0, r6_bank" :: "r"(s->rN_bank[6]));
+	__asm__("ldc %0, r7_bank" :: "r"(s->rN_bank[7]));
 }
 
 gint_driver_t drv_cpu = {

src/fs/fs.c

@@ -42,7 +42,7 @@ void fs_free_descriptor(int fd)
 	fdtable[fd].data = NULL;
 }
 
-int open_generic(fs_descriptor_type_t *type, void *data, int fd)
+int open_generic(fs_descriptor_type_t const *type, void *data, int fd)
 {
 	if(!fdtable) {
 		errno = ENOMEM;
@@ -79,7 +79,7 @@ int open_generic(fs_descriptor_type_t *type, void *data, int fd)
 
 /* Standard streams */
 
-static fs_descriptor_type_t devnull = {
+static fs_descriptor_type_t const devnull = {
 	.read   = NULL,
 	.write  = NULL,
 	.lseek  = NULL,

src/fs/fugue/fugue_dir.c

@@ -93,6 +93,8 @@ void *fugue_dir_explore(char const *path)
 	struct BFile_FileInfo info;
 	char *wildcard=NULL;
 	uint16_t *fc_path=NULL, *search=NULL;
+	/* We allocate by batches of 8 */
+	int sd=-1, rc, allocated=0;
 
 	dir_t *dp = malloc(sizeof *dp);
 	if(!dp) goto alloc_failure;
@@ -100,8 +102,6 @@ void *fugue_dir_explore(char const *path)
 	dp->count = 0;
 	dp->entries = NULL;
 	dp->pos = 0;
-	/* We allocate by batches of 8 */
-	int sd=-1, rc, allocated=0;
 
 	fc_path = malloc(512 * sizeof *fc_path);
 	if(!fc_path) goto alloc_failure;
@@ -118,7 +118,7 @@ void *fugue_dir_explore(char const *path)
 	if(rc < 0) {
 		if(rc != BFile_EntryNotFound)
 			errno = bfile_error_to_errno(rc);
-		goto end;
+		goto error;
 	}
 
 	do {
@@ -148,7 +148,9 @@ void *fugue_dir_explore(char const *path)
 
 alloc_failure:
 	errno = ENOMEM;
+error:
 	fugue_dir_close(dp);
+	dp = NULL;
 end:
 	free(wildcard);
 	free(search);

src/fs/fugue/fugue_open.c

@@ -63,6 +63,10 @@ int fugue_open(char const *path, int flags, GUNUSED mode_t mode)
 	/* If the entry is a directory, open it as such */
 	if(type == BFile_Type_Directory) {
 		void *dp = fugue_dir_explore(path);
+		if(!dp) {
+			rc = -1;
+			goto end;
+		}
 		fs_descriptor_t data = {
 			.type = &fugue_dir_descriptor_type,
 			.data = dp,

src/gdb/fxconv-metadata.txt

@@ -0,0 +1,9 @@
+icons-i1msb.png:
+  type: bopti-image
+  profile: mono
+  name: gint_gdb_icons_i1msb
+
+icons-rgb565.png:
+  type: bopti-image
+  profile: rgb565
+  name: gint_gdb_icons_rgb565

src/gdb/gdb.S

@@ -0,0 +1,7 @@
+.global _gdb_stubcall_write
+
+_gdb_stubcall_write:
+	mov	#64, r3
+	trapa	#33
+	rts
+	nop

src/gdb/gdb.c

@@ -0,0 +1,881 @@
+#include <gint/cpu.h>
+#include <gint/exc.h>
+#include <gint/gdb.h>
+#include <gint/ubc.h>
+#include <gint/usb-ff-bulk.h>
+#include <gint/usb.h>
+#include <gint/video.h>
+#include <gint/display.h>
+#include <gint/config.h>
+#include <gint/hardware.h>
+#include <gint/fs.h>
+
+#include <ctype.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#define GDB_VISUAL_FEEDBACK 1
+#define GDB_BRIDGE_LOGS 0
+
+/* Note about trap numbers:
+   - trapa #16...#23 were historically used for Linux's syscall
+     interface for syscalls with up to 0...7 arguments.
+   - trapa #31 is unified syscall interface (Linux)
+   - trapa #32 is GDB software breakpoint
+   - trapa #33 shall thus be our stubcall. */
+#define TRA_SWBREAK 32
+#define TRA_STUBCALL 33
+
+#if GDB_VISUAL_FEEDBACK
+
+enum { ICON_WORKING, ICON_ERROR, ICON_COMM, ICON_IDLE };
+
+static void gdb_show_stub_status(int icon)
+{
+// TODO[3]: Use normal way for both fx and cg (and remove display.h include)
+#if GINT_RENDER_MONO
+	extern bopti_image_t gint_gdb_icons_i1msb;
+	dsubimage(120, 0, &gint_gdb_icons_i1msb, 8*icon, 0, 8, 5, DIMAGE_NONE);
+	dupdate();
+#else
+	video_mode_t const *M = video_get_current_mode();
+	if(!M)
+		return;
+
+	extern image_t gint_gdb_icons_rgb565;
+
+	if(M->format == IMAGE_RGB565) {
+		image_t sub;
+		image_sub(&gint_gdb_icons_rgb565, 6*icon, 0, 7, 7, &sub);
+		if(!video_update(M->width-7, 0, &sub, 0))
+			abort();
+	}
+#endif
+}
+
+#else
+# define gdb_show_stub_status(...) ((void)0)
+#endif
+
+static void gdb_hexlify(char* output_string, const uint8_t* input_buffer, size_t input_size)
+{
+	const char* hex = "0123456789ABCDEF";
+	for (size_t i = 0; i < input_size; i++) {
+		uint8_t byte = input_buffer[i];
+		output_string[i*2 + 0] = hex[(byte & 0xF0) >> 4];
+		output_string[i*2 + 1] = hex[byte & 0x0F];
+	}
+}
+
+// TODO : bug in fxlibc ? strtoul doesn't support uppercase
+static uint32_t gdb_unhexlify_sized(const char* input_string, size_t input_length)
+{
+	uint32_t ret = 0;
+	for (size_t i = 0; i < input_length; i++) {
+		uint8_t nibble_hex = tolower(input_string[i]);
+		uint8_t nibble = nibble_hex >= 'a' && nibble_hex <= 'f' ? nibble_hex - 'a' + 10 :
+				 nibble_hex >= '0' && nibble_hex <= '9' ? nibble_hex - '0' : 0;
+		ret = (ret << 4) | nibble;
+	}
+	return ret;
+}
+
+static uint32_t gdb_unhexlify(const char* input_string)
+{
+	return gdb_unhexlify_sized(input_string, strlen(input_string));
+}
+
+static bool gdb_started = false;
+
+static void gdb_send(const char *data, size_t size)
+{
+	usb_fxlink_header_t header;
+	usb_fxlink_fill_header(&header, "gdb", "remote", size);
+
+	int pipe = usb_ff_bulk_output();
+	usb_write_sync(pipe, &header, sizeof(header), false);
+	usb_write_sync(pipe, data, size, false);
+	usb_commit_sync(pipe);
+}
+
+static void gdb_send_start(void)
+{
+	usb_fxlink_header_t header;
+	usb_fxlink_fill_header(&header, "gdb", "start", 0);
+
+	int pipe = usb_ff_bulk_output();
+	usb_write_sync(pipe, &header, sizeof(header), false);
+	usb_commit_sync(pipe);
+}
+
+static char *gdb_recv_buffer = NULL;
+static const size_t gdb_recv_buffer_capacity = 256;
+static size_t gdb_recv_buffer_size = 0;
+static ssize_t gdb_recv(char *buffer, size_t buffer_size)
+{
+	if (gdb_recv_buffer_size >= buffer_size) {
+		memcpy(buffer, gdb_recv_buffer, buffer_size);
+		memmove(gdb_recv_buffer, &gdb_recv_buffer[buffer_size], gdb_recv_buffer_size - buffer_size);
+		gdb_recv_buffer_size -= buffer_size;
+		return buffer_size;
+	}
+
+	usb_fxlink_header_t header;
+	while (!usb_fxlink_handle_messages(&header)) {
+		sleep();
+	}
+
+	// TODO : should we abort or find a way to gracefully shutdown the debugger ?
+	if (strncmp(header.application, "gdb", 16) == 0
+	     && strncmp(header.type, "remote", 16) == 0) {
+		if (header.size > gdb_recv_buffer_capacity - gdb_recv_buffer_size) {
+			abort();
+		}
+		usb_read_sync(usb_ff_bulk_input(), &gdb_recv_buffer[gdb_recv_buffer_size], header.size, false);
+		gdb_recv_buffer_size += header.size;
+		return gdb_recv(buffer, buffer_size);
+	} else {
+		abort();
+	}
+}
+
+static ssize_t gdb_recv_packet(char* buffer, size_t buffer_size)
+{
+	char read_char;
+
+	// Waiting for packet start '$'
+	do {
+		if (gdb_recv(&read_char, 1) != 1) {
+			return -1;
+		}
+	} while (read_char != '$');
+
+	uint8_t checksum = 0;
+	size_t packet_len = 0;
+	while (true) {
+		if (gdb_recv(&read_char, 1) != 1) {
+			return -1;
+		}
+
+		if (read_char != '#') {
+			// -1 to ensure space for a NULL terminator
+			if (packet_len >= (buffer_size - 1)) {
+				return -1;
+			}
+			buffer[packet_len++] = read_char;
+			checksum += read_char;
+		} else {
+			break;
+		}
+	}
+	buffer[packet_len] = '\0';
+
+	char read_checksum_hex[3];
+	if (gdb_recv(read_checksum_hex, 2) != 2) {
+		return -1;
+	}
+	read_checksum_hex[2] = '\0';
+	uint8_t read_checksum = gdb_unhexlify(read_checksum_hex);
+
+	if (read_checksum != checksum) {
+		read_char = '-';
+		gdb_send(&read_char, 1);
+		return -1;
+	} else {
+		read_char = '+';
+		gdb_send(&read_char, 1);
+		return packet_len;
+	}
+}
+
+static ssize_t gdb_send_packet(const char* packet, size_t packet_length)
+{
+	if (packet == NULL || packet_length == 0) {
+		// Empty packet
+		gdb_send("$#00", 4);
+		return 4;
+	}
+
+	size_t buffer_length = packet_length + 1 + 4;
+	// TODO : find if it's more efficient to malloc+copy on each packet or send 3 small fxlink messages
+	char* buffer = malloc(buffer_length);
+
+	uint8_t checksum = 0;
+	for (size_t i = 0; i < packet_length; i++) {
+		checksum += packet[i];
+	}
+
+	buffer[0] = '$';
+	memcpy(&buffer[1], packet, packet_length);
+	snprintf(&buffer[buffer_length - 4], 4, "#%02X", checksum);
+
+	// -1 to not send the NULL terminator of snprintf
+	gdb_send(buffer, buffer_length - 1);
+	free(buffer);
+	return buffer_length;
+}
+
+#if GDB_BRIDGE_LOGS
+static void gdb_send_bridge_log(const char* fmt, ...)
+{
+	char str[256];
+	va_list args;
+	va_start(args, fmt);
+	vsnprintf(str, sizeof str, fmt, args);
+	va_end(args);
+	usb_fxlink_text(str, strlen(str));
+}
+#else
+# define gdb_send_bridge_log(...)
+#endif
+
+static int gdb_signal_number = 0;
+static int gdb_trap_number = 0;
+
+static void gdb_send_stop_reply(void)
+{
+	char str[4] = "S00";
+	uint8_t num = gdb_signal_number ? gdb_signal_number : 5 /* SIGTRAP */;
+	gdb_hexlify(str+1, &num, 1);
+	gdb_send_packet(str, 3);
+}
+
+static void gdb_handle_qXfer_packet(const char* packet, const char* data, size_t data_size)
+{
+	char offset_hex[16] = {0}, length_hex[16] = {0};
+	for (size_t i = 0; i < sizeof(offset_hex); i++) {
+		offset_hex[i] = *(packet++); // consume offset
+		if (*packet == ',') break;
+	}
+	packet++; // consume ','
+	for (size_t i = 0; i < sizeof(length_hex); i++) {
+		length_hex[i] = *(packet++); // consume length
+		if (*packet == '\0') break;
+	}
+
+	size_t offset = (size_t)gdb_unhexlify(offset_hex);
+	size_t length = (size_t)gdb_unhexlify(length_hex);
+
+	if (offset >= data_size) {
+		gdb_send_packet("l", 1);
+	} else if (offset + length >= data_size) {
+		char *reply_buffer = malloc(data_size - offset + 1);
+		reply_buffer[0] = 'l';
+		memcpy(&reply_buffer[1], &data[offset], data_size - offset);
+		gdb_send_packet(reply_buffer, data_size - offset + 1);
+		free(reply_buffer);
+	} else {
+		char *reply_buffer = malloc(length + 1);
+		reply_buffer[0] = 'm';
+		memcpy(&reply_buffer[1], &data[offset], length);
+		gdb_send_packet(reply_buffer, length + 1);
+		free(reply_buffer);
+	}
+}
+
+/* We implement the memory-map qXfer extension to mark add-in memory as read-only
+ * and enforce hardware breakpoints.
+ * See : https://sourceware.org/gdb/onlinedocs/gdb/Memory-Map-Format.html
+ *       https://sourceware.org/gdb/onlinedocs/gdb/Set-Breaks.html
+ */
+// TODO : Should we mark other regions as ROM ?
+static const char gdb_memory_map_xml[] = "<?xml version=\"1.0\"?>"
+"<!DOCTYPE memory-map PUBLIC \"+//IDN gnu.org//DTD GDB Memory Map V1.0//EN\" \"http://sourceware.org/gdb/gdb-memory-map.dtd\">"
+"<memory-map>"
+	// P0 mapping of add-in file
+	"<memory type=\"rom\" start=\"0x00300000\" length=\"0x00200000\"/>"
+	// P0 mapping of user RAM area
+	"<memory type=\"ram\" start=\"0x08100000\" length=\"0x00080000\"/>"
+	// Physical mapping of RAM chip (fx-CG 50)
+	"<memory type=\"ram\" start=\"0x8c000000\" length=\"0x01000000\"/>"
+	// Physical mapping of RAM chip (fx-CG 10/20 + emulator)
+	"<memory type=\"ram\" start=\"0x88000000\" length=\"0x01000000\"/>"
+"</memory-map>";
+
+static void gdb_handle_query_packet(const char* packet)
+{
+	if (strncmp("qSupported", packet, 10) == 0) {
+		const char* qsupported_ans = "PacketSize=255;qXfer:memory-map:read+";
+		gdb_send_packet(qsupported_ans, strlen(qsupported_ans));
+	} else if (strncmp("qXfer:memory-map:read::", packet, 23) == 0) {
+		// -1 to not send the NULL terminator
+		gdb_handle_qXfer_packet(&packet[23], gdb_memory_map_xml, sizeof(gdb_memory_map_xml) - 1);
+	} else {
+		gdb_send_packet(NULL, 0);
+	}
+}
+
+static void gdb_handle_read_general_registers(gdb_cpu_state_t* cpu_state)
+{
+	char reply_buffer[23*8];
+	if (!cpu_state) {
+		memset(reply_buffer, 'x', sizeof(reply_buffer));
+		memcpy(&reply_buffer[offsetof(gdb_cpu_state_t, reg.pc)*2],
+		       "A0000000", 8); // pc needs to be set to make GDB happy
+	} else {
+		gdb_hexlify(reply_buffer, (uint8_t*)cpu_state->regs,
+			    sizeof(cpu_state->regs));
+	}
+	gdb_send_packet(reply_buffer, sizeof(reply_buffer));
+}
+
+static void gdb_handle_read_register(gdb_cpu_state_t* cpu_state, const char* packet)
+{
+	uint8_t register_id = gdb_unhexlify(&packet[1]);
+	char reply_buffer[8];
+	if (!cpu_state || register_id >= sizeof(cpu_state->regs)/sizeof(uint32_t)) {
+		memset(reply_buffer, 'x', sizeof(reply_buffer));
+	} else {
+		gdb_hexlify(reply_buffer, (uint8_t*)&cpu_state->regs[register_id],
+			    sizeof(cpu_state->regs[register_id]));
+	}
+	gdb_send_packet(reply_buffer, sizeof(reply_buffer));
+}
+
+static void gdb_handle_write_general_registers(gdb_cpu_state_t* cpu_state, const char* packet)
+{
+	if (!cpu_state) {
+		gdb_send_packet(NULL, 0);
+		return;
+	}
+
+	packet++; // consume 'G'
+
+	// Let's not handle incomplete 'G' packets as they're rarely used anyway
+	if (strlen(packet) != sizeof(cpu_state->regs)*2) {
+		gdb_send_packet(NULL, 0);
+		return;
+	}
+
+	for (size_t i = 0; i < sizeof(cpu_state->regs)/sizeof(uint32_t); i++) {
+		cpu_state->regs[i] = gdb_unhexlify_sized(&packet[i * sizeof(uint32_t) * 2],
+							 sizeof(uint32_t) * 2);
+	}
+	gdb_send_packet("OK", 2);
+}
+
+static void gdb_handle_write_register(gdb_cpu_state_t* cpu_state, const char* packet)
+{
+	if (!cpu_state) {
+		gdb_send_packet(NULL, 0);
+		return;
+	}
+
+	char register_id_hex[16] = {0}, value_hex[16] = {0};
+
+	packet++; // consume 'P'
+	for (size_t i = 0; i < sizeof(register_id_hex); i++) {
+		register_id_hex[i] = *(packet++); // consume register id
+		if (*packet == '=') break;
+	}
+	packet++; // consume '='
+	for (size_t i = 0; i < sizeof(value_hex); i++) {
+		value_hex[i] = *(packet++); // consume register value
+		if (*packet == '\0') break;
+	}
+
+	uint32_t register_id = gdb_unhexlify(register_id_hex);
+	uint32_t value = gdb_unhexlify(value_hex);
+
+	if (register_id >= sizeof(cpu_state->regs)/sizeof(uint32_t)) {
+		gdb_send_packet(NULL, 0);
+	} else {
+		cpu_state->regs[register_id] = value;
+		gdb_send_packet("OK", 2);
+	}
+}
+
+static volatile bool gdb_tlbh_enable = false;
+static volatile bool gdb_tlbh_caught = false;
+
+static void gdb_handle_read_memory(const char* packet)
+{
+	char address_hex[16] = {0}, size_hex[16] = {0};
+	uint8_t* read_address;
+	size_t read_size;
+
+	packet++; // consume 'm'
+	for (size_t i = 0; i < sizeof(address_hex); i++) {
+		address_hex[i] = *(packet++); // consume address
+		if (*packet == ',') break;
+	}
+	packet++; // consume ','
+	for (size_t i = 0; i < sizeof(size_hex); i++) {
+		size_hex[i] = *(packet++); // consume size
+		if (*packet == '\0') break;
+	}
+
+	read_address = (uint8_t*) gdb_unhexlify(address_hex);
+	read_size = (size_t) gdb_unhexlify(size_hex);
+
+	char *reply_buffer = malloc(read_size * 2);
+
+	gdb_tlbh_enable = true;
+	gdb_tlbh_caught = false;
+	for (size_t i = 0; i < read_size && !gdb_tlbh_caught; i++) {
+		gdb_hexlify(&reply_buffer[i * 2], &read_address[i], 1);
+	}
+	gdb_tlbh_enable = false;
+
+	if (gdb_tlbh_caught) {
+		gdb_send_packet("E22", 3); // EINVAL
+		gdb_tlbh_caught = false;
+	} else {
+		gdb_send_packet(reply_buffer, read_size * 2);
+	}
+	free(reply_buffer);
+}
+
+static void cache_ocbwb(void *start, void *end)
+{
+	/* Cache lines are 32-aligned */
+	void *p = (void *)((uintptr_t)start & -32);
+
+	while(p < end) {
+		__asm__("ocbwb @%0":: "r"(p));
+		p += 32;
+	}
+}
+
+static void cache_icbi(void *start, void *end)
+{
+	/* Cache lines are 32-aligned */
+	void *p = (void *)((uintptr_t)start & -32);
+
+	while(p < end) {
+		__asm__("icbi @%0":: "r"(p));
+		p += 32;
+	}
+}
+
+static void gdb_handle_write_memory(const char* packet)
+{
+	char address_hex[16] = {0}, size_hex[16] = {0};
+	uint8_t* read_address;
+	size_t read_size;
+
+	packet++; // consume 'M'
+	for (size_t i = 0; i < sizeof(address_hex); i++) {
+		address_hex[i] = *(packet++); // consume address
+		if (*packet == ',') break;
+	}
+	packet++; // consume ','
+	for (size_t i = 0; i < sizeof(size_hex); i++) {
+		size_hex[i] = *(packet++); // consume size
+		if (*packet == ':') break;
+	}
+	packet++; // consume ':'
+
+	read_address = (uint8_t*) gdb_unhexlify(address_hex);
+	read_size = (size_t) gdb_unhexlify(size_hex);
+
+	gdb_tlbh_enable = true;
+	gdb_tlbh_caught = false;
+	for (size_t i = 0; i < read_size && !gdb_tlbh_caught; i++) {
+		read_address[i] = (uint8_t)gdb_unhexlify_sized(&packet[i * 2], 2);
+	}
+	gdb_tlbh_enable = false;
+
+	cache_ocbwb(read_address, read_address + read_size);
+	cache_icbi(read_address, read_address + read_size);
+
+	if (gdb_tlbh_caught) {
+		gdb_send_packet("E22", 3); // EINVAL
+		gdb_tlbh_caught = false;
+	} else {
+		gdb_send_packet("OK", 2);
+	}
+}
+
+static bool gdb_parse_hardware_breakpoint_packet(const char* packet, void** read_address)
+{
+	packet++; // consume 'z' or 'Z'
+	if (*packet != '1') { // hardware breakpoint
+		return false;
+	}
+	packet++; // consume '1'
+	packet++; // consume ','
+
+	char address_hex[16] = {0}, kind_hex[16] = {0};
+	for (size_t i = 0; i < sizeof(address_hex); i++) {
+		address_hex[i] = *(packet++); // consume address
+		if (*packet == ',') break;
+	}
+	packet++; // consume ','
+	for (size_t i = 0; i < sizeof(kind_hex); i++) {
+		kind_hex[i] = *(packet++); // consume kind
+		if (*packet == '\0' || *packet == ';') break;
+	}
+
+	*read_address = (void*) gdb_unhexlify(address_hex);
+	uint32_t read_kind = gdb_unhexlify(kind_hex);
+
+	if (read_kind != 2) { // SuperH instructions are 2 bytes long
+		return false;
+	}
+
+	return true;
+}
+
+static void gdb_handle_insert_hardware_breakpoint(const char* packet)
+{
+	void* read_address;
+	if (!gdb_parse_hardware_breakpoint_packet(packet, &read_address)) {
+		gdb_send_bridge_log("bad Z packet\n");
+		gdb_send_packet(NULL, 0);
+		return;
+	}
+
+	void *channel0_addr, *channel1_addr;
+	bool channel0_used = ubc_get_break_address(0, &channel0_addr);
+	bool channel1_used = ubc_get_break_address(1, &channel1_addr);
+
+	/* As stated by GDB doc : "the operations should be implemented in an idempotent way."
+	 * Thus we first check if the breakpoint is already placed in one of the UBC channel.
+	 */
+	if ((channel0_used && channel0_addr == read_address) ||
+	    (channel1_used && channel1_addr == read_address)) {
+		gdb_send_bridge_log("hb %p: already exists\n", read_address);
+		gdb_send_packet("OK", 2);
+	} else if (!channel0_used) {
+		ubc_set_breakpoint(0, read_address, UBC_BREAK_BEFORE);
+		gdb_send_bridge_log("hb %p: using channel 0\n", read_address);
+		gdb_send_packet("OK", 2);
+	} else if (!channel1_used) {
+		ubc_set_breakpoint(1, read_address, UBC_BREAK_BEFORE);
+		gdb_send_bridge_log("hb %p: using channel 1\n", read_address);
+		gdb_send_packet("OK", 2);
+	} else {
+		/* TODO : We should find a proper way to inform GDB that we are
+		 *        limited by the number of UBC channels.
+		 */
+		gdb_send_bridge_log("hb %p: channels used (%p, %p)\n", read_address,
+			channel0_addr, channel1_addr);
+		gdb_send_packet(NULL, 0);
+	}
+}
+
+static void gdb_handle_remove_hardware_breakpoint(const char* packet)
+{
+	void* read_address;
+	if (!gdb_parse_hardware_breakpoint_packet(packet, &read_address)) {
+		gdb_send_packet(NULL, 0);
+		return;
+	}
+
+	void *channel0_addr, *channel1_addr;
+	bool channel0_used = ubc_get_break_address(0, &channel0_addr);
+	bool channel1_used = ubc_get_break_address(1, &channel1_addr);
+
+	if (channel0_used && channel0_addr == read_address) {
+		ubc_disable_channel(0);
+	}
+	if (channel1_used && channel1_addr == read_address) {
+		ubc_disable_channel(1);
+	}
+	gdb_send_packet("OK", 2);
+}
+
+static void gdb_handle_continue_with_signal(gdb_cpu_state_t* cpu_state,
+	const char* packet)
+{
+	packet++; // consume 'C'
+	int signal = gdb_unhexlify_sized(packet, 2);
+	char exit[4] = { 'X', packet[0], packet[1], 0 };
+	packet += 2;
+
+	if(*packet == ';')
+		cpu_state->reg.pc = gdb_unhexlify(packet + 1);
+
+	// TODO: This is a heuristic replacing the normal signal system
+	uint32_t kills =
+		  (1 << 4) /* SIGILL */
+		+ (1 << 6) /* SIGABRT */
+		+ (1 << 7) /* SIGEMT */
+		+ (1 << 8) /* SIGFPE */
+		+ (1 << 9) /* SIGKILL */
+		+ (1 << 11) /* SIGSEGV */
+		+ (1 << 15); /* SIGTERM */
+	// Abort if the signal is kill by default
+	if((uint)signal < 32 && (kills >> signal) & 1) {
+		gdb_send_packet(exit, 3);
+		abort();
+	}
+}
+
+static struct {
+	bool single_stepped;
+	bool channel0_used;
+	bool channel1_used;
+	void* channel0_addr;
+	void* channel1_addr;
+} gdb_single_step_backup = { false };
+static void gdb_handle_single_step(uint32_t pc, ubc_break_mode_t break_mode)
+{
+	gdb_single_step_backup.channel0_used = ubc_get_break_address(0, &gdb_single_step_backup.channel0_addr);
+	gdb_single_step_backup.channel1_used = ubc_get_break_address(1, &gdb_single_step_backup.channel1_addr);
+
+	ubc_disable_channel(0);
+	ubc_set_breakpoint(1, (void*)pc, break_mode);
+
+	gdb_single_step_backup.single_stepped = true;
+}
+
+static bool gdb_handle_stubcall(gdb_cpu_state_t* cpu_state)
+{
+	char str[30];
+	int sc_num = cpu_state->reg.r3;
+
+	if(sc_num == 64) { /* write */
+		int len = snprintf(str, sizeof str, "Fwrite,%x,%08x,%x",
+			cpu_state->reg.r4,
+			cpu_state->reg.r5,
+			cpu_state->reg.r6);
+		gdb_send_packet(str, len);
+		return true;
+	}
+
+	return false;
+}
+
+void gdb_main(gdb_cpu_state_t* cpu_state)
+{
+	if (!gdb_started && gdb_start()) {
+		gdb_show_stub_status(ICON_ERROR);
+		return;
+	}
+
+	gdb_show_stub_status(ICON_IDLE);
+
+	if (gdb_single_step_backup.single_stepped) {
+		if (gdb_single_step_backup.channel0_used) {
+			ubc_set_breakpoint(0, gdb_single_step_backup.channel0_addr, UBC_BREAK_BEFORE);
+		} else {
+			ubc_disable_channel(0);
+		}
+		if (gdb_single_step_backup.channel1_used) {
+			ubc_set_breakpoint(1, gdb_single_step_backup.channel1_addr, UBC_BREAK_BEFORE);
+		} else {
+			ubc_disable_channel(1);
+		}
+
+		gdb_single_step_backup.single_stepped = false;
+	}
+
+	if (cpu_state != NULL) {
+		/* Ajust PC after a software breakpoint */
+		if (gdb_trap_number == TRA_SWBREAK)
+			cpu_state->reg.pc -= 2;
+
+		/* Handle stubcall but fallback to normal stop if it fails */
+		if (gdb_trap_number != TRA_STUBCALL || !gdb_handle_stubcall(cpu_state))
+			gdb_send_stop_reply();
+	}
+
+	while (1) {
+		gdb_show_stub_status(ICON_COMM);
+
+		char packet_buffer[256];
+		ssize_t packet_size = gdb_recv_packet(packet_buffer, sizeof(packet_buffer));
+		if (packet_size <= 0) {
+			// TODO : Should we break or log on recv error ?
+			continue;
+		}
+
+		gdb_show_stub_status(ICON_WORKING);
+
+		switch (packet_buffer[0]) {
+			case '?': // Halt reason
+				gdb_send_stop_reply();
+				break;
+			case 'q':
+				gdb_handle_query_packet(packet_buffer);
+				break;
+
+			case 'g':
+				gdb_handle_read_general_registers(cpu_state);
+				break;
+			case 'p':
+				gdb_handle_read_register(cpu_state, packet_buffer);
+				break;
+			case 'm':
+				gdb_handle_read_memory(packet_buffer);
+				break;
+			case 'G':
+				gdb_handle_write_general_registers(cpu_state, packet_buffer);
+				break;
+			case 'P':
+				gdb_handle_write_register(cpu_state, packet_buffer);
+				break;
+			case 'M':
+				gdb_handle_write_memory(packet_buffer);
+				break;
+
+			case 'k': // Kill request
+				abort();
+
+			case 'Z':
+				gdb_handle_insert_hardware_breakpoint(packet_buffer);
+				break;
+			case 'z':
+				gdb_handle_remove_hardware_breakpoint(packet_buffer);
+				break;
+
+			case 's':
+				gdb_handle_single_step(cpu_state->reg.pc, UBC_BREAK_AFTER);
+				goto ret;
+			case 'c': // Continue
+				goto ret;
+			case 'C': // Continue with signal
+				gdb_handle_continue_with_signal(cpu_state, packet_buffer);
+				// We'll often abort() at the signal rather than continuing
+				goto ret;
+			case 'F': // Continue after File I/O call response
+				// TODO: parse 'F' response packets.
+				goto ret;
+
+			default: // Unsupported packet
+				gdb_send_packet(NULL, 0);
+				break;
+		}
+
+		gdb_show_stub_status(ICON_IDLE);
+	}
+
+ret:
+	// We're started after the first round of exchanges
+	gdb_started = true;
+
+	gdb_signal_number = 0;
+	gdb_trap_number = 0;
+}
+
+static void gdb_notifier_function(void)
+{
+	// We ignore fxlink notifications when we're already inside GDB code.
+	if (ubc_dbh_lock || !gdb_started)
+		return;
+
+	// We make sure we are called during a USB interrupt.
+	if (usb_interrupt_context == NULL)
+		return;
+
+	// And we make sure an other step break is not already set up.
+	if (gdb_single_step_backup.single_stepped)
+		return;
+
+	gdb_handle_single_step(usb_interrupt_context->spc, UBC_BREAK_AFTER);
+}
+
+static int gdb_panic_handler(uint32_t code)
+{
+	// Catch memory access errors from GDB trying to read/print stuff
+	if (gdb_tlbh_enable) {
+		// We only handle TLB miss reads (0x040) and writes (0x060)
+		if (code != 0x040 && code != 0x060)
+			return 1;
+
+		gdb_tlbh_caught = true;
+
+		// We skip the offending instruction and continue
+		gint_exc_skip(1);
+		return 0;
+	}
+	// If we are in user code, let's break
+	else if (!ubc_dbh_lock) {
+		// We make sure an other step break is not already set up
+		if (gdb_single_step_backup.single_stepped)
+			return 1;
+
+		// TODO: This only works for re-execution type exceptions
+		uint32_t spc;
+		__asm__("stc spc, %0" : "=r"(spc));
+		gdb_handle_single_step(spc, UBC_BREAK_BEFORE);
+
+		// Break reason
+		if(code == 0x040 || code == 0x060 || code == 0x0e0 || code == 0x100)
+			gdb_signal_number = 11; /* SIGSEGV */
+		if(code == 0x160)
+			gdb_signal_number = 5; /* SIGTRAP */
+		if(code == 0x180 || code == 0x1a0)
+			gdb_signal_number = 4; /* SIGILL */
+		if(code >= 0x1000 && code != 0x10a0)
+			gdb_signal_number = 5; /* SIGTRAP */
+		if(code == 0x10a0)
+			gdb_signal_number = 7; /* SIGEMT (used here for bad UBC breaks) */
+
+		// Specific stop reasons
+		if(code == 0x160) {
+			uint32_t TRA = isSH3() ? 0xffffffd0 : 0xff000020;
+			gdb_trap_number = *(uint32_t volatile *)TRA >> 2;
+		}
+
+		return 0;
+	}
+	return 1;
+}
+
+static bool gdb_redirect_stdout = false;
+static bool gdb_redirect_stderr = false;
+
+static fs_descriptor_type_t const redirect_type = {
+    .read = NULL,
+    .write = (void *)gdb_stubcall_write,
+    .lseek = NULL,
+    .close = NULL,
+};
+
+int gdb_start(void)
+{
+	if (gdb_started)
+		return 0;
+
+	gdb_show_stub_status(ICON_WORKING);
+
+	if(usb_is_open() && !usb_is_open_interface(&usb_ff_bulk))
+		usb_close();
+
+	if(!usb_is_open()) {
+		usb_interface_t const *interfaces[] = { &usb_ff_bulk, NULL };
+		if(usb_open(interfaces, GINT_CALL_NULL) < 0)
+			return -1;
+		usb_open_wait();
+	}
+
+	usb_fxlink_set_notifier(gdb_notifier_function);
+	gdb_send_start();
+
+	if (!gdb_recv_buffer) {
+		gdb_recv_buffer = malloc(gdb_recv_buffer_capacity);
+	}
+
+	// Redirect standard streams
+	if(gdb_redirect_stdout) {
+		close(STDOUT_FILENO);
+		open_generic(&redirect_type, (void *)STDOUT_FILENO, STDOUT_FILENO);
+	}
+	if(gdb_redirect_stderr) {
+		close(STDERR_FILENO);
+		open_generic(&redirect_type, (void *)STDERR_FILENO, STDERR_FILENO);
+	}
+
+	// TODO : Should we detect if other panic or debug handlers are setup ?
+	gint_exc_catch(gdb_panic_handler);
+	ubc_set_debug_handler(gdb_main);
+
+	return 0;
+}
+
+void gdb_start_on_exception(void)
+{
+	gint_exc_catch(gdb_panic_handler);
+	ubc_set_debug_handler(gdb_main);
+}
+
+void gdb_redirect_streams(bool stdout, bool stderr)
+{
+	gdb_redirect_stdout = stdout;
+	gdb_redirect_stderr = stderr;
+}

src/gray/engine.c

@@ -11,6 +11,15 @@
 #include <stdlib.h>
 
 #include "../render-fx/render-fx.h"
+#include "../render/render.h"
+#include <gint/config.h>
+
+#if GINT_HW_CG
+#include <gint/drivers/r61524.h>
+#endif
+
+// TODO: Move the gray "engine" part into the T6K11 driver.
+#if GINT_RENDER_MONO
 
 /* Three additional video RAMS, allocated statically if --static-gray was set
    at configure time, or with malloc() otherwise. */
@@ -21,6 +30,8 @@ GBSS static uint32_t gvrams[3][256];
 /* Four VRAMs: two to draw and two to display */
 static uint32_t *vrams[4] = { NULL, NULL, NULL, NULL };
 
+#if GINT_HW_FX
+
 /* Current VRAM pair used for drawing; the value can either be 0 (draws to
    VRAMs 0 and 1) or 2 (draws to VRAMs 2 and 3). */
 static int volatile st = 0;
@@ -35,6 +46,10 @@ static int runs = 0;
 /* Delays of the light and dark frames for the above setting */
 GBSS static int delays[2];
 
+static int gray_int(void);
+
+#endif
+
 /* The alternate rendering mode structure used to override d*() */
 static struct rendering_mode const gray_mode = {
 	.dupdate      = gupdate,
@@ -63,13 +78,16 @@ static struct rendering_mode const gray_exit_mode = {
 //	Engine control (init/quit and start/stop)
 //---
 
-static int gray_int(void);
 static void gray_quit(void);
 
 /* gray_isinit(): Check whether the engine is initialized and ready to run */
 static int gray_isinit(void)
 {
-	return (vrams[0] && vrams[1] && vrams[2] && vrams[3] && timer >= 0);
+	return (vrams[0] && vrams[1] && vrams[2] && vrams[3]
+#if GINT_HW_FX
+		&& timer >= 0
+#endif
+		);
 }
 
 /* gray_init(): Initialize the engine
@@ -90,6 +108,7 @@ GCONSTRUCTOR static void gray_init(void)
 	vrams[3] = malloc(1024);
 	#endif /* GINT_STATIC_GRAY */
 
+#if GINT_HW_FX
 	/* Default delays from Graph 35+E II are different from other models */
 	if(gint[HWCALC] == HWCALC_G35PE2)
 	{
@@ -105,6 +124,7 @@ GCONSTRUCTOR static void gray_init(void)
 	/* Try to obtain the timer right away */
 	timer = timer_configure(GRAY_TIMER | GRAY_CLOCK, 1000,
 		GINT_CALL(gray_int));
+#endif
 
 	/* On failure, release the resources that we obtained */
 	if(!gray_isinit()) gray_quit();
@@ -123,10 +143,13 @@ GDESTRUCTOR static void gray_quit(void)
 	vrams[3] = NULL;
 	#endif /* GINT_STATIC_GRAY */
 
+#if GINT_HW_FX
 	if(timer >= 0) timer_stop(timer);
 	timer = -1;
+#endif
 }
 
+#if GINT_HW_FX
 /* gray_start(): Start the gray engine */
 static void gray_start(void)
 {
@@ -143,6 +166,7 @@ static void gray_stop(void)
 	runs = 0;
 	st = 0;
 }
+#endif
 
 //---
 //	Dynamic udpate and rendering mode
@@ -196,6 +220,7 @@ int dgray(int mode)
 	return 0;
 }
 
+#if GINT_HW_FX
 /* gray_int(): Interrupt handler */
 int gray_int(void)
 {
@@ -227,6 +252,19 @@ int gupdate(void)
 	st ^= 2;
 	return 0;
 }
+#elif GINT_HW_CG
+int gupdate(void)
+{
+	if(dmode == &gray_exit_mode)
+	{
+		dmode = NULL;
+		return 1;
+	}
+
+	r61524_display_gray_128x64(vrams[0], vrams[1]);
+	return 0;
+}
+#endif
 
 //---
 //	Query and configuration functions
@@ -238,6 +276,7 @@ int dgray_enabled(void)
 	return (dmode == &gray_mode);
 }
 
+#if GINT_HW_FX
 /* dgray_setdelays(): Set the gray engine delays */
 void dgray_setdelays(uint32_t light, uint32_t dark)
 {
@@ -269,3 +308,12 @@ void dgray_getscreen(uint32_t **light, uint32_t **dark)
 	if(light) *light = vrams[base & 2];
 	if(dark) *dark = vrams[base | 1];
 }
+#elif GINT_HW_CG
+void dgray_getvram(uint32_t **light, uint32_t **dark)
+{
+	*light = vrams[0];
+	*dark = vrams[1];
+}
+#endif
+
+#endif /* GINT_RENDER_MONO && GINT_HW_FX */

src/gray/gclear.c

@@ -1,4 +1,7 @@
 #include <gint/gray.h>
+#include <gint/config.h>
+
+#if GINT_RENDER_MONO
 
 /* gclear(): Fill the screen with a single color */
 void gclear(color_t color)
@@ -35,3 +38,5 @@ void gclear(color_t color)
 		dark += 8;
 	}
 }
+
+#endif /* GINT_RENDER_MONO */

src/gray/ggetpixel.c

@@ -1,5 +1,8 @@
 #include <gint/gray.h>
 #include <gint/defs/types.h>
+#include <gint/config.h>
+
+#if GINT_RENDER_MONO
 
 int ggetpixel(int x, int y)
 {
@@ -13,3 +16,5 @@ int ggetpixel(int x, int y)
 	bool d = (dark [offset] & mask) != 0;
 	return (d << 1) | l;
 }
+
+#endif /* GINT_RENDER_MONO */

src/gray/gint_gline.c

@@ -1,5 +1,8 @@
 #include <gint/display.h>
 #include <gint/defs/util.h>
+#include <gint/config.h>
+
+#if GINT_RENDER_MONO
 
 /* gint_ghline(): Optimized horizontal line, but not actually optimized */
 void gint_ghline(int x1, int x2, int y, int color)
@@ -14,3 +17,5 @@ void gint_gvline(int y1, int y2, int x, int color)
 	if(y1 > y2) swap(y1, y2);
 	for(int y = y1; y <= y2; y++) dpixel(x, y, color);
 }
+
+#endif /* GINT_RENDER_MONO */

src/gray/gpixel.c

@@ -1,5 +1,8 @@
 #include <gint/gray.h>
 #include <gint/defs/types.h>
+#include <gint/config.h>
+
+#if GINT_RENDER_MONO
 
 /* gpixel(): Change a pixel's color */
 void gpixel(int x, int y, color_t color)
@@ -55,3 +58,5 @@ void gpixel(int x, int y, color_t color)
 		break;
 	}
 }
+
+#endif /* GINT_RENDER_MONO */

src/gray/grect.c

@@ -1,6 +1,9 @@
 #include <gint/defs/util.h>
 #include <gint/gray.h>
 #include "../render-fx/render-fx.h"
+#include <gint/config.h>
+
+#if GINT_RENDER_MONO
 
 /* grect(): Fill a rectangle on the screen */
 void grect(int x1, int y1, int x2, int y2, color_t color)
@@ -112,3 +115,5 @@ void grect(int x1, int y1, int x2, int y2, color_t color)
 		light++, dark++;
 	}
 }
+
+#endif /* GINT_RENDER_MONO */

src/gray/gsubimage.c

@@ -1,6 +1,8 @@
 #include <gint/gray.h>
 #include "../render-fx/render-fx.h"
-#include "../render-fx/bopti-asm.h"
+#include <gint/config.h>
+
+#if GINT_RENDER_MONO
 
 #pragma GCC optimize("O3")
 
@@ -37,3 +39,5 @@ void gsubimage(bopti_image_t const *img, struct rbox *r, GUNUSED int flags)
 		bopti_render(img, r, light, dark);
 	}
 }
+
+#endif /* GINT_RENDER_MONO */

src/gray/gtext.c

@@ -1,6 +1,9 @@
 #include <gint/gray.h>
 #include "../render/render.h"
-#include "../render-fx/topti-asm.h"
+#include "../render-fx/render-fx.h"
+#include <gint/config.h>
+
+#if GINT_RENDER_MONO
 
 /* gtext_opt(): Display a string of text */
 void gtext_opt(int x, int y, int fg, int bg, int halign, int valign,
@@ -23,3 +26,5 @@ void gtext_opt(int x, int y, int fg, int bg, int halign, int valign,
 	topti_render(x, y, str, topti_font, topti_asm_text[fg],
 		topti_asm_text[bg], light, dark, size);
 }
+
+#endif /* GINT_RENDER_MONO */

src/image/fixed.h

@@ -5,6 +5,8 @@
 #ifndef GINT_IMAGE_FIXED
 #define GINT_IMAGE_FIXED
 
+#include <stdint.h>
+
 /* Constants */
 #define fconst(x) ((x) * 65536)
 

src/image/image_alloc.c

@@ -1,6 +1,8 @@
 #include <gint/image.h>
 #include <stdlib.h>
 #include <gint/defs/util.h>
+#include <gint/config.h>
+#if GINT_RENDER_RGB
 
 image_t *image_alloc(int width, int height, int format)
 {
@@ -25,3 +27,5 @@ image_t *image_alloc(int width, int height, int format)
     img->flags |= IMAGE_FLAGS_DATA_ALLOC;
     return img;
 }
+
+#endif

src/image/image_alloc_palette.c

@@ -3,6 +3,9 @@
 #include <stdlib.h>
 #include <string.h>
 
+#include <gint/config.h>
+#if GINT_RENDER_RGB
+
 bool image_alloc_palette(image_t *img, int size)
 {
     if(!img || !IMAGE_IS_INDEXED(img->format))
@@ -29,3 +32,5 @@ bool image_alloc_palette(image_t *img, int size)
     img->flags |= IMAGE_FLAGS_PALETTE_ALLOC;
     return true;
 }
+
+#endif

src/image/image_alpha.c

@@ -1,4 +1,6 @@
 #include <gint/image.h>
+#include <gint/config.h>
+#if GINT_RENDER_RGB
 
 int image_alpha(int format)
 {
@@ -14,3 +16,5 @@ int image_alpha(int format)
         return 0x10000;
     }
 }
+
+#endif

src/image/image_clear.c

@@ -1,4 +1,6 @@
 #include <gint/image.h>
+#include <gint/config.h>
+#if GINT_RENDER_RGB
 
 void image_clear(image_t *img)
 {
@@ -7,3 +9,5 @@ void image_clear(image_t *img)
 
     image_fill(img, image_alpha(img->format));
 }
+
+#endif

src/image/image_copy.c

@@ -1,5 +1,7 @@
 #include <gint/image.h>
 #include <gint/defs/util.h>
+#include <gint/config.h>
+#if GINT_RENDER_RGB
 
 void image_copy(image_t const *src, image_t *dst, bool copy_alpha)
 {
@@ -120,3 +122,5 @@ void image_copy(image_t const *src, image_t *dst, bool copy_alpha)
         } while(--h > 0);
     }
 }
+
+#endif

src/image/image_copy_alloc.c

@@ -2,6 +2,9 @@
 #include <gint/defs/util.h>
 #include <string.h>
 
+#include <gint/config.h>
+#if GINT_RENDER_RGB
+
 image_t *image_copy_alloc(image_t const *src, int new_format)
 {
     if(!image_valid(src))
@@ -18,3 +21,5 @@ image_t *image_copy_alloc(image_t const *src, int new_format)
     image_copy(src, dst, true);
     return dst;
 }
+
+#endif

src/image/image_copy_palette.c

@@ -2,6 +2,9 @@
 #include <gint/defs/util.h>
 #include <string.h>
 
+#include <gint/config.h>
+#if GINT_RENDER_RGB
+
 bool image_copy_palette(image_t const *src, image_t *dst, int size)
 {
     if(!image_valid(src) || !dst)
@@ -18,3 +21,5 @@ bool image_copy_palette(image_t const *src, image_t *dst, int size)
     memcpy(dst->palette, src->palette, 2*N);
     return true;
 }
+
+#endif

src/image/image_create.c

@@ -1,6 +1,9 @@
 #include <gint/image.h>
 #include <stdlib.h>
 
+#include <gint/config.h>
+#if GINT_RENDER_RGB
+
 image_t *image_create(int width, int height, int format)
 {
     if(!IMAGE_IS_RGB16(format) && !IMAGE_IS_P8(format) && !IMAGE_IS_P4(format))
@@ -23,3 +26,5 @@ image_t *image_create(int width, int height, int format)
 
     return img;
 }
+
+#endif

src/image/image_create_vram.c

@@ -1,5 +1,7 @@
 #include <gint/image.h>
 #include <gint/display.h>
+#include <gint/config.h>
+#if GINT_RENDER_RGB
 
 image_t *image_create_vram(void)
 {
@@ -11,3 +13,5 @@ image_t *image_create_vram(void)
     img->data = gint_vram;
     return img;
 }
+
+#endif

src/image/image_data_size.c

@@ -1,6 +1,10 @@
 #include <gint/image.h>
+#include <gint/config.h>
+#if GINT_RENDER_RGB
 
 int image_data_size(image_t const *img)
 {
     return img->stride * img->height;
 }
+
+#endif

src/image/image_decode_pixel.c

@@ -1,4 +1,6 @@
 #include <gint/image.h>
+#include <gint/config.h>
+#if GINT_RENDER_RGB
 
 int image_decode_pixel(image_t const *img, int pixel)
 {
@@ -10,3 +12,5 @@ int image_decode_pixel(image_t const *img, int pixel)
         return img->palette[pixel];
     return -1;
 }
+
+#endif

src/image/image_fill.c

@@ -1,4 +1,6 @@
 #include <gint/image.h>
+#include <gint/config.h>
+#if GINT_RENDER_RGB
 
 void image_fill(image_t *img, int value)
 {
@@ -24,3 +26,5 @@ void image_fill(image_t *img, int value)
         }
     }
 }
+
+#endif

src/image/image_free.c

@@ -2,6 +2,9 @@
 #include <gint/mmu.h>
 #include <stdlib.h>
 
+#include <gint/config.h>
+#if GINT_RENDER_RGB
+
 void image_free(image_t *img)
 {
     if(!img || mmu_is_rom(img))
@@ -14,3 +17,5 @@ void image_free(image_t *img)
 
     free(img);
 }
+
+#endif

src/image/image_get_pixel.c

@@ -1,4 +1,6 @@
 #include <gint/image.h>
+#include <gint/config.h>
+#if GINT_RENDER_RGB
 
 int image_get_pixel(image_t const *img, int x, int y)
 {
@@ -23,3 +25,5 @@ int image_get_pixel(image_t const *img, int x, int y)
     }
     return 0;
 }
+
+#endif

src/image/image_hflip.c

@@ -1,4 +1,6 @@
 #include <gint/image.h>
+#include <gint/config.h>
+#if GINT_RENDER_RGB
 
 void image_hflip(image_t const *src, image_t *dst, bool copy_alpha)
 {
@@ -45,3 +47,5 @@ void image_hflip(image_t const *src, image_t *dst, bool copy_alpha)
         }
     }
 }
+
+#endif

src/image/image_hflip_alloc.c

@@ -1,4 +1,6 @@
 #include <gint/image.h>
+#include <gint/config.h>
+#if GINT_RENDER_RGB
 
 image_t *image_hflip_alloc(image_t const *src)
 {
@@ -14,3 +16,5 @@ image_t *image_hflip_alloc(image_t const *src)
     image_hflip(src, dst, true);
     return dst;
 }
+
+#endif

src/image/image_linear.S

@@ -1,3 +1,6 @@
+#include <gint/config.h>
+#if GINT_RENDER_RGB
+
 .global _image_linear_rgb16
 .global _image_linear_p8
 
@@ -124,3 +127,5 @@ _image_linear_rgb16:
 
 _image_linear_p8:
 	GEN_LINEAR_LOOP mov.b, 1
+
+#endif

src/image/image_linear.c

@@ -2,6 +2,9 @@
 #include <gint/defs/util.h>
 #include "fixed.h"
 
+#include <gint/config.h>
+#if GINT_RENDER_RGB
+
 void image_linear_rgb16(void *src, void *dst, struct image_linear_map *map);
 void image_linear_p8(void *src, void *dst, struct image_linear_map *map);
 
@@ -32,3 +35,5 @@ void image_linear(image_t const *src, image_t *dst,
     else if(IMAGE_IS_P8(src->format))
         image_linear_p8(src->data, dst->data, map);
 }
+
+#endif

src/image/image_linear_alloc.c

@@ -1,4 +1,6 @@
 #include <gint/image.h>
+#include <gint/config.h>
+#if GINT_RENDER_RGB
 
 image_t *image_linear_alloc(image_t const *src, struct image_linear_map *map)
 {
@@ -18,3 +20,5 @@ image_t *image_linear_alloc(image_t const *src, struct image_linear_map *map)
     image_linear(src, dst, map);
     return dst;
 }
+
+#endif

src/image/image_rotate.c

@@ -1,4 +1,6 @@
 #include <gint/image.h>
+#include <gint/config.h>
+#if GINT_RENDER_RGB
 
 void image_rotate(image_t const *src, float angle, bool resize,
     struct image_linear_map *map)
@@ -11,3 +13,5 @@ void image_rotate(image_t const *src, float angle, bool resize,
 
     image_rotate_around(src, angle, resize, &center_x, &center_y, map);
 }
+
+#endif

src/image/image_rotate_around.c

@@ -1,9 +1,14 @@
 #include <gint/image.h>
 #include "fixed.h"
 
+#include <gint/config.h>
+#if GINT_RENDER_RGB
+
 void image_rotate_around(image_t const *src, float angle, bool resize,
     int *center_x, int *center_y, struct image_linear_map *map)
 {
     image_rotate_around_scale(src, angle, fconst(1.0), resize, center_x,
         center_y, map);
 }
+
+#endif

src/image/image_rotate_around_scale.c

@@ -2,6 +2,9 @@
 #include <math.h>
 #include "fixed.h"
 
+#include <gint/config.h>
+#if GINT_RENDER_RGB
+
 void image_rotate_around_scale(image_t const *src, float alpha, int gamma,
     bool resize, int *center_x, int *center_y, struct image_linear_map *map)
 {
@@ -58,3 +61,5 @@ void image_rotate_around_scale(image_t const *src, float alpha, int gamma,
     *center_x = new_center_x;
     *center_y = new_center_y;
 }
+
+#endif

src/image/image_scale.c

@@ -1,6 +1,9 @@
 #include <gint/image.h>
 #include "fixed.h"
 
+#include <gint/config.h>
+#if GINT_RENDER_RGB
+
 void image_scale(image_t const *src, int gamma_x, int gamma_y,
     struct image_linear_map *map)
 {
@@ -22,3 +25,5 @@ void image_scale(image_t const *src, int gamma_x, int gamma_y,
     map->dst_w = fround(src->width * gamma_x);
     map->dst_h = fround(src->height * gamma_y);
 }
+
+#endif

src/image/image_set_palette.c

@@ -1,6 +1,9 @@
 #include <gint/image.h>
 #include <stdlib.h>
 
+#include <gint/config.h>
+#if GINT_RENDER_RGB
+
 void image_set_palette(image_t *img, uint16_t *palette, int size, bool owns)
 {
     if(!img || !IMAGE_IS_INDEXED(img->format))
@@ -16,3 +19,5 @@ void image_set_palette(image_t *img, uint16_t *palette, int size, bool owns)
     else
         img->flags &= ~IMAGE_FLAGS_PALETTE_ALLOC;
 }
+
+#endif

src/image/image_set_pixel.c

@@ -1,4 +1,6 @@
 #include <gint/image.h>
+#include <gint/config.h>
+#if GINT_RENDER_RGB
 
 void image_set_pixel(image_t const *img, int x, int y, int value)
 {
@@ -24,3 +26,5 @@ void image_set_pixel(image_t const *img, int x, int y, int value)
             data_u8[x >> 1] = (data_u8[x >> 1] & 0x0f) | (value << 4);
     }
 }
+
+#endif

src/image/image_sub.c

@@ -3,6 +3,9 @@
 #include <string.h>
 #undef image_sub
 
+#include <gint/config.h>
+#if GINT_RENDER_RGB
+
 static image_t image_sub_default;
 
 image_t *image_sub(image_t const *src, int left, int top, int w, int h,
@@ -39,3 +42,5 @@ image_t *image_sub(image_t const *src, int left, int top, int w, int h,
     dst->palette = src->palette;
     return dst;
 }
+
+#endif

src/image/image_target.c

@@ -1,6 +1,9 @@
 #include <gint/image.h>
 #undef image_target
 
+#include <gint/config.h>
+#if GINT_RENDER_RGB
+
 bool image_target(image_t const *src, image_t *dst, ...)
 {
     if(!image_valid(src) || !image_valid(dst))
@@ -37,3 +40,5 @@ bool image_target(image_t const *src, image_t *dst, ...)
     va_end(args);
     return true;
 }
+
+#endif

src/image/image_valid.c

@@ -1,4 +1,6 @@
 #include <gint/image.h>
+#include <gint/config.h>
+#if GINT_RENDER_RGB
 
 bool image_valid(image_t const *img)
 {
@@ -16,3 +18,5 @@ bool image_valid(image_t const *img)
     /* Invalid format */
     return false;
 }
+
+#endif

src/image/image_vflip.c

@@ -1,6 +1,8 @@
 #include <gint/image.h>
 #include <stdlib.h>
 #include <string.h>
+#include <gint/config.h>
+#if GINT_RENDER_RGB
 
 static void copy_row_rgb16(uint16_t *src, uint16_t *dst, int src_alpha,
     int dst_alpha, int width)
@@ -60,3 +62,5 @@ void image_vflip(image_t const *src, image_t *dst, bool copy_alpha)
 
     free(row);
 }
+
+#endif

src/image/image_vflip_alloc.c

@@ -1,4 +1,6 @@
 #include <gint/image.h>
+#include <gint/config.h>
+#if GINT_RENDER_RGB
 
 image_t *image_vflip_alloc(image_t const *src)
 {
@@ -14,3 +16,5 @@ image_t *image_vflip_alloc(image_t const *src)
     image_vflip(src, dst, true);
     return dst;
 }
+
+#endif

src/intc/intc.c

@@ -60,6 +60,8 @@ static struct info {
 	{ IPRF, 0x0f00, IMR5,  0x10, _ },
 	{ IPRF, 0x0f00, IMR5,  0x20, _ },
 	{ IPRF, 0x0f00, IMR5,  0x40, _ },
+	/* SCIF */
+	{ IPRG, 0xf000, IMR5,  0x01, _ /* Driver not SH3-compatible yet */ },
 	/* RTC */
 	{ IPRK, 0xf000, IMR10, 0x04, IPRA, 0x000f },
 	{ IPRK, 0xf000, IMR10, 0x02, IPRA, 0x000f },

src/kernel/exch.c

@@ -6,6 +6,7 @@
 #include <gint/defs/attributes.h>
 #include <gint/hardware.h>
 #include <gint/gint.h>
+#include <gint/config.h>
 #include <stdlib.h>
 #include <string.h>
 
@@ -59,7 +60,7 @@ GNORETURN static void gint_default_panic(GUNUSED uint32_t code)
 
 	dfont(NULL);
 
-	#ifdef FX9860G
+	#if GINT_RENDER_MONO
 	memset(gint_vram, 0, 1024);
 	dtext(1, 0, "Exception! (SysERROR)");
 	for(int i = 0; i < 32; i++) gint_vram[i] = ~gint_vram[i];
@@ -78,6 +79,7 @@ GNORETURN static void gint_default_panic(GUNUSED uint32_t code)
 	if(code == 0x1040) name = "Add-in too large";
 	if(code == 0x1060) name = "Memory init failed";
 	if(code == 0x1080) name = "Stack overflow";
+	if(code == 0x10a0) name = "UBC in bank 1 code";
 
 	if(name[0]) dtext(1, 9, name);
 	else dprint(1, 9, "%03x", code);
@@ -96,13 +98,13 @@ GNORETURN static void gint_default_panic(GUNUSED uint32_t code)
 	}
 	#endif
 
-	#ifdef FXCG50
+	#if GINT_RENDER_RGB
 	/* Don't require the DMA driver just for a clear */
 	memset(gint_vram, 0xff, DWIDTH*DHEIGHT*2);
 	dtext(6, 3, "An exception occured! (System ERROR)");
 
 	uint32_t *long_vram = (void *)gint_vram;
-	for(int i = 0; i < 198 * 16; i++) long_vram[i] = ~long_vram[i];
+	for(int i = 0; i < (DWIDTH/2) * 16; i++) long_vram[i] = ~long_vram[i];
 
 	char const *name = "";
 	if(code == 0x040) name = "TLB miss (nonexisting address) on read";
@@ -118,25 +120,31 @@ GNORETURN static void gint_default_panic(GUNUSED uint32_t code)
 	if(code == 0x1040) name = "Add-in not fully mapped (too large)";
 	if(code == 0x1060) name = "Memory initialization failed (heap)";
 	if(code == 0x1080) name = "Stack overflow during world switch";
+	if(code == 0x10a0) name = "UBC break in register bank 1 code";
 
 	dprint(6, 25, "%03x %s", code, name);
 
 	dtext(6, 45, "PC");
 	dprint(38, 45, "= %08x", PC);
-	dtext(261, 45, "(Error location)");
+	dtext(DWIDTH-135, 45, "(Error location)");
 
 	dtext(6, 60, "TEA");
 	dprint(38, 60, "= %08x", TEA);
-	dtext(234, 60, "(Offending address)");
+	dtext(DWIDTH-162, 60, "(Offending address)");
 
 	dtext(6, 75, "TRA");
 	dprint(38, 75, "= %#x", TRA);
-	dtext(281, 75, "(Trap number)");
+	dtext(DWIDTH-115, 75, "(Trap number)");
 
 	dtext(6, 95,  "The add-in crashed!");
 	if(kd == NULL) {
+#if GINT_HW_CG
 		dtext(6, 108, "Please press the RESET button to restart the");
 		dtext(6, 121, "calculator.");
+#else
+		dtext(6, 108, "Please press the RESET button to");
+		dtext(6, 121, "restart the calculator.");
+#endif
 	}
 	else {
 		dtext(6, 121, "[EXIT]: Exit the program with abort()");

src/kernel/hardware.c

@@ -8,6 +8,7 @@
 #include <gint/defs/types.h>
 #include <gint/defs/util.h>
 #include <gint/mpu/pfc.h>
+#include <gint/config.h>
 
 #include <string.h>
 
@@ -19,7 +20,7 @@ GBSS uint32_t gint[HW_KEYS];
 /* Product Register */
 #define PRR (*((volatile uint32_t *)0xff000044))
 
-#if defined(FX9860G) || (!defined(FX9860G) && !defined(FXCG50))
+#if GINT_HW_FX
 
 /* mpu_detect() - detect the underlying MPU
    Many thanks to Simon Lothar for relevant documentation.
@@ -116,9 +117,7 @@ void hw_detect(void)
 	else utlb_mapped_memory(NULL, NULL);
 }
 
-#endif /* FX9860G and platform-agnostic */
-
-#ifdef FXCG50
+#elif GINT_HW_CG
 
 /* hw_detect(): Basic hardware detection */
 void hw_detect(void)
@@ -146,4 +145,25 @@ void hw_detect(void)
 	utlb_mapped_memory(NULL, NULL);
 }
 
-#endif /* FXCG50 */
+#elif GINT_HW_CP
+
+/* hw_detect(): Basic hardware detection */
+void hw_detect(void)
+{
+	gint[HWMPU] = HWMPU_SH7305;
+	gint[HWCPUVR] = PVR;
+	gint[HWCPUPR] = PRR;
+	gint[HWCALC] = HWCALC_FXCP400;
+	// TODO: What filesystem implementation on the fx-CP 400?
+	gint[HWFS] = HWFS_NONE;
+	gint[HWRAM] = 16 << 20;
+	// TOOD: How much ROM on the fx-CP 400?
+	gint[HWROM] = 0;
+
+	/* There is no userspace so not MMU being used */
+	gint[HWURAM] = 0;
+}
+
+#else
+#error unknown hardware type for hw_detect
+#endif

src/kernel/inth.S

@@ -7,10 +7,11 @@
 
 #define CPP_ASM
 #include <gint/hardware.h>
+#include <gint/config.h>
 
 .global _gint_inth_7305
 
-#ifdef FX9860G
+#if GINT_HW_FX
 .global _gint_inth_7705
 #endif
 
@@ -100,7 +101,7 @@ _gint_inth_7305:
 1:	.long	0xff000028
 .first_entry:
 
-#ifdef FX9860G
+#if GINT_HW_FX
 
 /* SH7705-TYPE INTERRUPT HANDLER ENTRY - 56 BYTES */
 
@@ -209,11 +210,15 @@ _gint_inth_callback_reloc:
 	stc.l	r7_bank, @-r15
 	stc.l	spc, @-r15
 	stc.l	ssr, @-r15
+	/* We backup the address of the gint_inth_callback_context_t built on
+	   the stack to the user bank. */
+	ldc	r15, r4_bank
+
 	stc.l	sr, @-r15
 
 	/* Save some values to user bank; once we enable interrupts, the kernel
 	   bank might be overwritten at any moment. */
-	ldc	r4, r0_bank
+	ldc	r4, r3_bank
 
 	/* Enable interrupts and go back to user bank. On SH4, SR.IMASK is set
 	   to the level of the current interrupt, which makes sure we can only
@@ -243,15 +248,25 @@ _gint_inth_callback_reloc:
 .load_sr:
 	ldc	r1, sr
 
-	/* We are now in the user bank with r0 set. Perform the call. We want
+	/* We are now in the user bank with r3 set. Perform the call. We want
 	   to forward the return value to kernel bank, but this bank can be
 	   changed at any moment since interrupts are enabled. */
 	sts.l	pr, @-r15
-	mov.l	@(4, r0), r4
-	mov.l	@(8, r0), r5
-	mov.l	@(12, r0), r6
-	mov.l	@(16, r0), r7
-	mov.l	@r0, r0
+
+	/* We only set r4 to the value of the first argument in the gint_call_t
+	   if the address is even (i.e. GINT_CALL_FLAG() was not used). */
+	mov.l	@r3, r0
+	tst	#1, r0
+	bf	.do_not_set_r4
+	mov.l	@(4, r3), r4
+.do_not_set_r4:
+	/* And we make sure to realign the address in case it was odd. */
+	mov	#0xfe, r2
+	and	r2, r0
+
+	mov.l	@(8, r3), r5
+	mov.l	@(12, r3), r6
+	mov.l	@(16, r3), r7
 	jsr	@r0
 	nop
 	lds.l	@r15+, pr

src/kernel/kernel.c

@@ -40,9 +40,7 @@ void *gint_stack_top = NULL;
 /* kinit(): Install and start gint */
 void kinit(void)
 {
-	uint32_t VBR = 0;
-
-	#ifdef FX9860G
+	#if GINT_HW_FX
 	/* On fx-9860G, VBR is loaded at the end of the user RAM. On SH4, the
 	   end of the user RAM hosts the stack, for which we leave 12 kB
 	   (0x3000 bytes). The VBR space takes about 0x600 bytes on SH3 due to
@@ -59,19 +57,24 @@ void kinit(void)
 
 	/* VBR is advanced 0x100 bytes because of an unused gap */
 	uram_end -= (isSH3() ? 0x600 : 0x1100);
-	VBR = uram_end - 0x100;
-	#endif /* FX9860G */
+	uint32_t VBR = uram_end - 0x100;
+	#endif
 
-	#ifdef FXCG50
+	#if GINT_HW_CG
 	/* On fx-CG 50, VBR is loaded at the start of the user RAM; the linker
 	   script leaves 5 kB (0x1400 bytes) before the start of the data
 	   segment. The stack is again placed at the end of the region, and we
 	   leave 16 kB. */
-	VBR = (uint32_t)mmu_uram();
+	uint32_t VBR = (uint32_t)mmu_uram();
 	uint32_t uram_end = (uint32_t)mmu_uram() + mmu_uram_size() - 0x4000;
 	gint_stack_top = (void *)uram_end;
 	#endif
 
+	#if GINT_HW_CP
+	extern char gint_region_vbr;
+	uint32_t VBR = (uint32_t)&gint_region_vbr - 0x100;
+	#endif
+
 	/* Event handler entry points */
 	void *inth_entry = isSH3() ? gint_inth_7705 : gint_inth_7305;
 	uint32_t exch_size = (uint32_t)&gint_exch_size;
@@ -85,6 +88,7 @@ void kinit(void)
 	/* Initialize memory allocators */
 	kmalloc_init();
 
+	#if !GINT_HW_CP
 	/* Create an allocation arena with unused static RAM */
 	static kmalloc_arena_t static_ram = { 0 };
 	extern uint32_t euram;
@@ -94,9 +98,10 @@ void kinit(void)
 	static_ram.end = (void *)uram_end;
 	kmalloc_init_arena(&static_ram, true);
 	kmalloc_add_arena(&static_ram);
+	#endif
 
 	/* Create an arena in the OS stack as well, for VRAM and more data */
-	#if defined(FXCG50) && !defined(GINT_NO_OS_STACK)
+	#if GINT_HW_CG && !defined(GINT_NO_OS_STACK)
 	static kmalloc_arena_t os_stack = { 0 };
 	os_stack.name = "_ostk";
 	os_stack.is_default = true;
@@ -107,19 +112,18 @@ void kinit(void)
 	os_stack.end = os_stack.start + (350 * 1024);
 	kmalloc_init_arena(&os_stack, true);
 	kmalloc_add_arena(&os_stack);
-	#endif /* FXCG50 && !GINT_NO_OS_STACK */
+	#endif
 
 	/* Allocate world buffers for the OS and for gint */
 	gint_world_os = gint_world_alloc();
 	gint_world_addin = gint_world_alloc();
 	gint_driver_flags = malloc(gint_driver_count());
 
-	#ifdef FXCG50
 	/* Allocate VRAMs, which is important for panic screens */
 	extern bool dvram_init(void);
+	// TODO: Cannot _Exit() yet, the gint_exitbuf isn't setup!
 	if(!dvram_init())
 		abort();
-	#endif
 
 	if(!gint_world_os || !gint_world_addin || !gint_driver_flags)
 		gint_panic(0x1060);
@@ -145,6 +149,11 @@ void kquit(void)
 {
 	gint_world_switch_out(gint_world_addin, gint_world_os);
 
+#if !GINT_OS_FX
+	extern void dvram_quit(void);
+	dvram_quit();
+#endif
+
 	gint_world_free(gint_world_os);
 	gint_world_free(gint_world_addin);
 	free(gint_driver_flags);

src/kernel/kernel.h

@@ -5,6 +5,13 @@
 #ifndef GINT_CORE_KERNEL
 #define GINT_CORE_KERNEL
 
+/* gint_load_onchip_sections(): Initialize on-chip memory sections */
+void gint_load_onchip_sections(void);
+
+/* gint_copy_vram(): Copy gint's VRAM to the OS to avoid flickering during
+   certain world switches. */
+void gint_copy_vram(void);
+
 /* kinit(): Install and start gint */
 void kinit(void);
 

src/kernel/osmenu.c

@@ -1,6 +1,8 @@
 #include <gint/gint.h>
 #include <gint/display.h>
 #include <gint/hardware.h>
+#include <gint/keyboard.h>
+#include "kernel.h"
 
 #include <string.h>
 
@@ -11,10 +13,10 @@ int   __Timer_Deinstall(int id);
 int   __PutKeyCode(int row, int column, int keycode);
 int   __GetKeyWait(int *col,int *row,int type,int time,int menu,uint16_t *key);
 void  __ClearKeyBuffer(void); /* ? */
-void *__GetVRAMAddress(void);
 void  __ConfigureStatusArea(int mode);
 void __SetQuitHandler(void (*callback)(void));
 
+#if !GINT_OS_CP
 static int __osmenu_id;
 
 static void __osmenu_handler(void)
@@ -27,30 +29,96 @@ static void __osmenu_handler(void)
 	__Timer_Stop(__osmenu_id);
 	__Timer_Deinstall(__osmenu_id);
 }
+#endif
+
+#if GINT_OS_CG
+typedef void (os_menu_function_t)(void);
+
+/* This method is possible thanks to reverse-engineering by Dr-Carlos.
+   <https://www.cemetech.net/forum/viewtopic.php?t=18944> */
+static os_menu_function_t *find_os_menu_function(void)
+{
+	/* Get syscall table address */
+	uint32_t addr = *(uint32_t *)0x8002007c;
+	if(addr < 0x80020070 || addr >= 0x81000000 - 0x1e58 * 4)
+		return NULL;
+
+	/* Get pointer to %1e58 SwitchToMainMenu() */
+	uint16_t const *insns = *(uint16_t const **)(addr + 0x1e58 * 4);
+	if(addr < 0x80020070 || addr >= 0x81000000)
+		return NULL;
+
+	/* Check up to 150 instructions to find the call to the internal function
+	   SaveAndOpenMainMenu(). This call is in a widget of the shape
+
+	     mov.l	GetkeyToMainFunctionReturnFlag, rX
+	     mov	#3, rY
+	     bsr	SaveAndOpenMainMenu
+	     mov.b	rY, @rX
+	     bra	<start of widget>
+	     nop */
+	for(int i = 0; i < 150; i++) {
+		/* Match: mov.l @(disp, pc), rX */
+		if((insns[i] & 0xf000) != 0xd000)
+			continue;
+		int rX = (insns[i] >> 8) & 0x0f;
+
+		/* Match: mov #3, rY */
+		if((insns[i+1] & 0xf0ff) != 0xe003)
+			continue;
+		int rY = (insns[i+1] >> 8) & 0x0f;
+
+		/* Match: bsr @(disp, pc) */
+		if((insns[i+2] & 0xf000) != 0xb000)
+			continue;
+		int disp = (insns[i+2] & 0x0fff);
+
+		/* Match: mov.b rX, @rY */
+		if((insns[i+3] != 0x2000 + (rX << 8) + (rY << 4)))
+			continue;
+
+		/* Match: bra @(_, pc) */
+		if((insns[i+4] & 0xf000) != 0xa000)
+			continue;
+
+		/* Match: nop */
+		if(insns[i+5] != 0x0009)
+			continue;
+
+		/* Return the target of the bsr instruction */
+		uint32_t fun_addr = (uint32_t)&insns[i+2] + 4 + disp * 2;
+		return (os_menu_function_t *)fun_addr;
+	}
+
+	return NULL;
+}
+#endif
 
 void gint_osmenu_native(void)
 {
+// TODO: OS menu on fx-CP
+#if !GINT_OS_CP
 	__ClearKeyBuffer();
+	gint_copy_vram();
 
-	#ifdef FX9860G
-	memcpy(__GetVRAMAddress(), gint_vram, 1024);
-	#endif
-
-	#ifdef FXCG50
+	#if GINT_OS_CG
 	/* Unfortunately ineffective (main menu probably reenables it)
 	__ConfigureStatusArea(3); */
 
-	/* TODO: Improve copied VRAM behavior in gint_osmenu() on fxcg50 */
-	uint16_t *vram1, *vram2;
-	dgetvram(&vram1, &vram2);
+	/* Try to use the internal function directly if we could figure out its
+	   address by dynamically disassembling */
+	os_menu_function_t *fun = find_os_menu_function();
+	if(fun) {
+		fun();
 
-	uint16_t *dst = __GetVRAMAddress();
-	uint16_t *src = (gint_vram == vram1) ? vram2 + 6 : vram1 + 6;
+		/* Run an immediate keyboard update, and clear the events so that the
+		   key pressed in order to re-enter the add-in is not also processed in
+		   the application */
+		extern int keysc_tick(void);
+		keysc_tick();
+		clearevents();
 
-	for(int y = 0; y < 216; y++, dst+=384, src+=396)
-	for(int x = 0; x < 384; x++)
-	{
-		dst[x] = src[x];
+		return;
 	}
 	#endif
 
@@ -70,6 +138,7 @@ void gint_osmenu_native(void)
 		1 /* Delay in seconds */,
 		0 /* Enable return to main menu */,
 		&keycode);
+#endif
 }
 
 /* gint_osmenu() - switch out of gint and call the calculator's main menu */
@@ -93,7 +162,11 @@ static void __handler()
 
 static void __sethandler()
 {
+	(void)__handler;
+// TODO: Quit handler on fx-CP
+#if !GINT_OS_CP
 	__SetQuitHandler((void *)__handler);
+#endif
 }
 
 void gint_set_quit_handler(gint_call_t gcall, bool do_world_switch)

src/kernel/start.S

@@ -0,0 +1,125 @@
+#include <gint/config.h>
+#if GINT_OS_CP
+
+/*
+Binary format for HollyHock-2. HH2 requires the following header layout:
+  0x00 (12 bytes): Entry point
+  0x0c  (4 bytes): Load address
+  0x10 (variable): Metadata as NUL-terminated strings
+
+Additionally, HH2 only loads up to 128 kB, so we need a second-stage loader to
+handle larger programs. We'll generally want to load these to the VRAM backup,
+i.e. not the default.
+
+Since we need a stage-2 loader, we might as well (1) let HH2 do the short
+stage-1 load to the end of the RAM, (2) use the stage-2 loader to load the rest
+of the add-in into the VRAM backup, and (3) scrap the end-of-RAM area and use
+it as buffer/heap.
+
+The only subtlety is that the stage-2 loader must know the binary file's path
+to load from the filesystem, and HollyHock doesn't (yet) give it to us. We
+write the path in the final binary with the fxsdk/scripts/patch_hh2_filename.py
+script from the fxSDK. This is fragile (i.e. not renaming-proof), but a start.
+We find the filename by looking up the .stage2_filename symbol in the ELF.
+*/
+
+/* 16-byte header */
+.section .hh2.header, "ax"
+.global _start_header
+.align 2
+
+_start_header:
+	mov.l	1f, r0
+	jmp	@r0
+	nop
+	nop
+
+	/* Address of stage-2 */
+1:	.long	_stage2
+	/* Stage-1 load address at end of RAM (specified in linker script) */
+	.long	_start_header
+
+/* Note: User-provided, variable-size app metadata is linked in-between the
+   .hh2.header and the .hh2.stage2 sections */
+
+/* Stage-2 loader */
+.section .hh2.stage2, "ax"
+.align 2
+
+_stage2:
+	mov.l	r8, @-r15
+	sts.l	pr, @-r15
+
+	/* Open the binary file in read mode */
+	mov.l	.open, r1
+	mov.l	.path, r4
+	jsr	@r1
+	mov	#1, r5 /* OPEN_READ */
+
+	cmp/pz	r0
+	bf	.end
+	mov	r0, r8
+
+	/* Seek to required offset */
+	mov.l	.lseek, r1
+	mov	r8, r4
+	mov.l	.off, r5
+	jsr	@r1
+	mov	#0, r6 /* SEEK_SET */
+
+	/* Load the binary */
+	mov.l	.read, r1
+	mov.l	.load, r5
+	mov.l	.size, r6
+	jsr	@r1
+	mov	r8, r4
+
+	/* Close the file regardless of read result */
+	mov.l	r0, @-r15
+	mov.l	.close, r1
+	jsr	@r1
+	mov	r8, r4
+
+	mov.l	.size, r1
+	mov.l	@r15+, r0
+	cmp/eq	r0, r1
+	bf	.end
+
+	lds.l	@r15+, pr
+	mov.l	1f, r0
+	jmp	@r0
+	mov.l	@r15+, r8
+
+.end:
+	lds.l	@r15+, pr
+	rts
+	mov.l	@r15+, r8
+
+.balign 4
+
+1:	.long	_start
+
+	/* Filepath */
+.path:	.long .stage2_path
+	/* Offset of segment in file */
+.off:	.long _gint_hh2_stage2_offset
+	/* Segment size */
+.size:	.long _gint_hh2_stage2_size
+	/* Load address */
+.load:	.long _gint_hh2_stage2_load
+
+.open:	.long 0x80057854
+.lseek:	.long 0x80057a96
+.read:	.long 0x800578a2
+.close:	.long 0x80057912
+
+.align 2
+	.zero 2
+.stage2_path:
+	.ascii "\\fls0\\"
+.stage2_filename:
+	/* Recognizable pattern so the patching script can double-check that
+	   it's overriding the correct location. */
+	.long 1, 2, 3, 4, 5, 6, 7, 8
+
+#endif /* GINT_OS_CP */

src/kernel/start.c

@@ -11,6 +11,7 @@
 #include <gint/exc.h>
 #include <setjmp.h>
 #include <stdlib.h>
+#include <string.h>
 
 #include "kernel.h"
 
@@ -24,34 +25,32 @@ extern uint32_t
 	ldata,  sdata,  rdata,		/* User's data section */
 	lilram, silram, rilram,		/* IL memory section */
 	lxyram, sxyram, rxyram,		/* X and Y memory section */
-	sbss, rbss;			/* User's BSS section */
-#ifdef FX9860G
-extern uint32_t
+	sbss, rbss,			/* User's BSS section */
 	lgmapped, sgmapped,		/* Permanently mapped functions */
 	lreloc, sreloc;			/* Relocatable references */
-#endif
 
 /* Constructor and destructor arrays */
 extern void (*bctors)(void), (*ectors)(void);
 extern void (*bdtors)(void), (*edtors)(void);
 
 /* User-provided main() function */
-int main(int isappli, int optnum);
+int main(void);
 
 /* Whether to restart main through the OS menu rather than returning */
-int gint_restart = 0;
+int8_t gint_restart = 0;
 
 /* gint_setrestart(): Set whether to restart the add-in after exiting */
 void gint_setrestart(int restart)
 {
-	gint_restart = restart;
+	/* There is now return-to-menu so no restart on CP */
+	gint_restart = restart && !GINT_OS_CP;
 }
 
+/* Return value of main() */
+static int8_t gint_exitcode;
 /* Jumping there will properly unwind and leave the add-in (CASIOWIN does not
    have an exit syscall and simply wants you to return from main()) */
 jmp_buf gint_exitbuf;
-/* Return value of main() */
-static int gint_exitcode;
 
 /* regcpy(): Copy a memory region using symbol information
    @l  Source pointer (load address)
@@ -94,6 +93,21 @@ static void callarray(void (**f)(void), void (**l)(void))
 	while(f < l) (*(*f++))();
 }
 
+void gint_load_onchip_sections(void)
+{
+	/* Do not load data to ILRAM, XRAM or YRAM on SH3 - the areas don't
+	   exist. If you use them, you're responsible! */
+	if(!isSH3())
+	{
+		/* Clear the areas so that we have less to save in case of a
+		   return to menu leading to a poweroff. */
+		memset((void *)0xe5200000, 0, 4096);
+		regcpy(&lilram, &silram, &rilram);
+		memset((void *)0xe500e000, 0, 16384);
+		regcpy(&lxyram, &sxyram, &rxyram);
+	}
+}
+
 static int start2(int isappli, int optnum)
 {
 	/* We are currently in a dynamic userspace mapping of an add-in run
@@ -120,7 +134,7 @@ static int start2(int isappli, int optnum)
 	   1.00 and the fx-9860G emulator) is not clear yet, so gint can't load
 	   pages dynamically. Load everything preventively (works only if the
 	   add-in is small enough) */
-	#ifdef FX9860G
+	#if GINT_OS_FX
 	if(isSH3())
 	{
 		/* Try to map every ROM address up to _srom */
@@ -138,20 +152,16 @@ static int start2(int isappli, int optnum)
 
 	/* Load data sections and wipe the bss section. This has to be done
 	   first for static and global variables to be initialized */
-	regcpy(&ldata,  &sdata,  &rdata);
+	#if !GINT_OS_CP
+	regcpy(&ldata, &sdata, &rdata);
+	#endif
 	regclr(&rbss, &sbss);
 
-	/* Do not load data to ILRAM, XRAM or YRAM on SH3 - the areas don't
-	   exist. If you use them, you're responsible! */
-	if(!isSH3())
-	{
-		regcpy(&lilram, &silram, &rilram);
-		regcpy(&lxyram, &sxyram, &rxyram);
-	}
+	gint_load_onchip_sections();
 
-	#ifdef FX9860G
-	/* Copy permanently-mapped code to start of user RAM (on fx-CG 50 it
-	   is loaded along ILRAM contents) */
+	#if !GINT_OS_CP
+	/* Copy permanently-mapped code to start of user RAM (this section is
+	   only used on fx-9860G; on fx-CG 50 it's fixed in ILRAM) */
 	void *rgmapped = mmu_uram();
 	regcpy(&lgmapped, &sgmapped, rgmapped);
 
@@ -179,7 +189,10 @@ static int start2(int isappli, int optnum)
 	   what it wants in exit() after main() finishes executing */
 	if(!setjmp(gint_exitbuf)) {
 		callarray(&bctors, &ectors);
-		exit(main(isappli, optnum));
+		// TODO: record isappli and optnum in globals
+		(void)isappli;
+		(void)optnum;
+		exit(main());
 	}
 	else {
 		callarray(&bdtors, &edtors);

src/kernel/syscalls.S

@@ -9,6 +9,8 @@
 **	* File system, because it's a mess and we might ruin the ROM.
 */
 
+#include <gint/config.h>
+
 .text
 
 /* Dynamic allocation */
@@ -43,8 +45,12 @@
 .global ___GetVRAMAddress
 .global ___ConfigureStatusArea
 .global ___SetQuitHandler
+/* VRAM backup on fx-CP */
+.global ___VRAMBackup
+.global ___VRAMRestore
 
 /* Reset */
+.global ___PowerOff
 .global ___Reset
 
 #define syscall_(id, syscall_table)	\
@@ -52,12 +58,19 @@
 	mov.l	1f, r0			;\
 	jmp	@r2			;\
 	nop				;\
-.align 4				;\
+.balign 4				;\
 1:	.long	id
 
 #define syscall(id) syscall_(id, syscall_table)
 
-#ifdef FX9860G
+#define fixed(address)			\
+	mov.l	1f, r0			;\
+	jmp	@r0			;\
+	nop				;\
+.balign 4				;\
+1:	.long	address
+
+#if GINT_OS_FX
 
 /* Dynamic allocation */
 
@@ -120,15 +133,17 @@ ___SetQuitHandler:
 
 /* Reset */
 
+___PowerOff:
+	syscall(0x3f4)
 ___Reset:
 	syscall(0x236)
 
 syscall_table:
 	.long	0x80010070
 
-#endif /* FX9860G */
+#endif /* GINT_OS_FX */
 
-#ifdef FXCG50
+#if GINT_OS_CG
 
 /* Dynamic allocation */
 
@@ -198,10 +213,35 @@ ___SpecialMatrixCodeProcessing:
 
 /* Reset */
 
+___PowerOff:
+	syscall(0x1839)
 ___Reset:
 	syscall(0x1187)
 
 syscall_table:
 	.long	0x80020070
 
-#endif /* FXCG50 */
+#endif /* GINT_OS_CG */
+
+#if GINT_OS_CP
+
+___malloc:
+	fixed(0x800cfb00)
+___realloc:
+	// TODO: realloc for fx-CP?
+	rts
+	mov	#0, r0
+___free:
+	fixed(0x800a76fc)
+
+___GetVRAMAddress:
+	fixed(0x8002e154)
+___VRAMBackup:
+	fixed(0x8002d3fa)
+___VRAMRestore:
+	fixed(0x8002d41a)
+
+___Reset:
+	fixed(0xa0000000)
+
+#endif /* GINT_OS_CP */

src/kernel/tlbh.S

@@ -1,8 +1,23 @@
+#include <gint/config.h>
+
 .global _gint_tlbh
 .section .gint.tlbh, "ax"
 .align 4
 
+#if GINT_OS_FX
+# define SYSCALL_TABLE 0x80010070
+# define SYSCALL_TLBH 3
+#elif GINT_OS_CG
+# define SYSCALL_TABLE 0x80020070
+# define SYSCALL_TLBH 12
+#elif GINT_OS_CP
+# define NOMMU 1
+#else
+# error Unknown HW for tlbh.S!
+#endif
+
 _gint_tlbh:
+#if ! NOMMU
 	sts.l	pr, @-r15
 	stc.l	gbr, @-r15
 	sts.l	mach, @-r15
@@ -28,16 +43,9 @@ test_tea:
 
 map:
 	/* If TEA is mappable, map a page and return */
-	#ifdef FX9860G
-	mov	#3, r0
-	#endif
-	#ifdef FXCG50
-	mov	#12, r0
-	#endif
-
 	mov.l	.syscall, r2
 	jsr	@r2
-	nop
+	mov	#SYSCALL_TLBH, r0
 
 	lds.l	@r15+, macl
 	lds.l	@r15+, mach
@@ -45,10 +53,12 @@ map:
 	lds.l	@r15+, pr
 	rte
 	nop
+#endif
 
 panic:
-	/* Otherwise, panic by defaulting to the exception handler (the TLB
-	   miss may still be resolved by a panic handler) */
+	/* Otherwise, or if there is no MMU, panic by defaulting to the
+	   exception handler (the TLB miss may still be resolved by a panic
+	   handler) */
 	lds.l	@r15+, macl
 	lds.l	@r15+, mach
 	ldc.l	@r15+, gbr
@@ -61,6 +71,7 @@ panic:
 	jmp	@r0
 	nop
 
+#if ! NOMMU
 .align 4
 
 .gint:
@@ -73,12 +84,6 @@ panic:
 	.long	0x00300000
 .max_mapped_rom:
 	.long	0x00300000 + _srom
-
-#ifdef FX9860G
 .syscall:
-	.long	0x80010070
-#endif
-#ifdef FXCG50
-.syscall:
-	.long	0x80020070
+	.long	SYSCALL_TABLE
 #endif

src/kernel/world.c

@@ -3,8 +3,12 @@
 #include <gint/gint.h>
 #include <gint/exc.h>
 #include <gint/defs/call.h>
+#include <gint/hardware.h>
+#include <gint/display.h>
+#include "kernel.h"
 
 #include <stdlib.h>
+#include <string.h>
 
 //---
 // World buffer
@@ -56,6 +60,9 @@ void gint_world_sync(void)
 // World switch with driver state saves
 //---
 
+static int onchip_save_mode = GINT_ONCHIP_REINITIALIZE;
+static void *onchip_save_buffer = NULL;
+
 void gint_world_switch_in(gint_world_t world_os, gint_world_t world_addin)
 {
 	/* Unbind from the OS driver and complete foreign asynchronous tasks */
@@ -144,13 +151,41 @@ int gint_world_switch(gint_call_t call)
 	extern void *gint_stack_top;
 	gint_world_switch_out(gint_world_addin, gint_world_os);
 
+	void *ILRAM = (void *)0xe5200000;
+	void *XRAM  = (void *)0xe500e000;
+	void *YRAM  = (void *)0xe5010000;
+
 	/* Watch out for stack overflows */
 	uint32_t *canary = gint_stack_top;
 	if(canary)
 		*canary = 0xb7c0ffee;
 
+	/* Save on-chip memory if requested */
+	if(!isSH3() && onchip_save_mode == GINT_ONCHIP_BACKUP) {
+		void *ptr = onchip_save_buffer;
+		memcpy(ptr, ILRAM, 4096);
+		ptr += 4096;
+		memcpy(ptr, XRAM, 8192);
+		ptr += 8192;
+		memcpy(ptr, YRAM, 8192);
+		ptr += 8192;
+	}
+
 	int rc = gint_call(call);
 
+	/* Restore or reinitialize on-chip memory */
+	if(!isSH3() && onchip_save_mode == GINT_ONCHIP_BACKUP) {
+		void *ptr = onchip_save_buffer;
+		memcpy(ILRAM, ptr, 4096);
+		ptr += 4096;
+		memcpy(XRAM, ptr, 8192);
+		ptr += 8192;
+		memcpy(YRAM, ptr, 8192);
+		ptr += 8192;
+	}
+	else if(!isSH3() && onchip_save_mode == GINT_ONCHIP_REINITIALIZE)
+		gint_load_onchip_sections();
+
 	/* The canary check needs to occur before switching in the gint world;
 	   otherwise we just crash due to the overflow. gint_panic() isn't
 	   really designed to work from the OS world, but it does fine on the
@@ -167,3 +202,54 @@ void gint_switch(void (*function)(void))
 {
 	gint_world_switch(GINT_CALL(function));
 }
+
+void gint_set_onchip_save_mode(int mode, void *ptr)
+{
+	onchip_save_mode = mode;
+	onchip_save_buffer = ptr;
+}
+
+int gint_get_onchip_save_mode(void **ptr)
+{
+	if(ptr)
+		*ptr = onchip_save_buffer;
+	return onchip_save_mode;
+}
+
+void gint_copy_vram(void)
+{
+	void *__GetVRAMAddress(void);
+
+	#if GINT_OS_FX
+	memcpy(__GetVRAMAddress(), gint_vram, 1024);
+	#endif
+
+	#if GINT_OS_CG && GINT_RENDER_RGB
+	/* TODO: Improve copied VRAM behavior in gint_osmenu() on fxcg50 */
+	uint16_t *vram1, *vram2;
+	dgetvram(&vram1, &vram2);
+
+	uint16_t *dst = __GetVRAMAddress();
+	uint16_t *src = (gint_vram == vram1) ? vram2 + 6 : vram1 + 6;
+
+	for(int y = 0; y < 216; y++, dst+=384, src+=396)
+	for(int x = 0; x < 384; x++)
+	{
+		dst[x] = src[x];
+	}
+	#endif
+
+	#if GINT_OS_CG && GINT_RENDER_MONO
+	// TODO: VRAM save mechanism for mono video mode on R61524
+	#endif
+}
+
+void gint_poweroff(GUNUSED bool show_logo)
+{
+// TODO: Power off on fx-CP
+#if !GINT_OS_CP
+	void __PowerOff(int show_logo);
+	gint_copy_vram();
+	gint_world_switch(GINT_CALL(__PowerOff, (int)show_logo));
+#endif
+}

src/keysc/getkey.c

@@ -4,10 +4,11 @@
 
 #include <gint/keyboard.h>
 #include <gint/drivers/keydev.h>
+#include <gint/display.h>
 #include <gint/gint.h>
 #include <gint/defs/types.h>
 
-#ifdef FX9860G
+#if GINT_HW_FX
 #include <gint/drivers/t6k11.h>
 #endif
 
@@ -48,7 +49,7 @@ key_event_t getkey_opt(int opt, volatile int *timeout)
 				continue;
 		}
 
-		#ifdef FX9860G
+		#if GINT_HW_FX
 		/* Backlight toggle */
 		if((opt & GETKEY_BACKLIGHT) && e.type == KEYEV_DOWN &&
 			((e.key == KEY_LIGHT) ||
@@ -64,10 +65,25 @@ key_event_t getkey_opt(int opt, volatile int *timeout)
 			e.key == KEY_MENU && !e.shift && !e.alpha)
 		{
 			gint_osmenu();
+			if(opt & GETKEY_MENU_DUPDATE)
+				dupdate();
+
+			if(!(opt & GETKEY_MENU_EVENT))
+				continue;
+			e.type = KEYEV_OSMENU;
+		}
+
+		/* Poweroff */
+		if((opt & GETKEY_POWEROFF) && e.type == KEYEV_DOWN &&
+			e.key == KEY_ACON && e.shift && !e.alpha)
+		{
+			gint_poweroff(true);
+			if(opt & GETKEY_MENU_DUPDATE)
+				dupdate();
 			continue;
 		}
 
-		if(e.type == KEYEV_DOWN || e.type == KEYEV_HOLD)
+		if(e.type != KEYEV_NONE || e.type != KEYEV_UP)
 		{
 			/* Custom global features */
 			bool accepted = false;

src/keysc/iokbd.c

@@ -5,9 +5,10 @@
 #include <gint/defs/types.h>
 #include <gint/mpu/pfc.h>
 #include <gint/hardware.h>
+#include <gint/config.h>
 
 /* This file is SH7705-only. */
-#ifdef FX9860G
+#if GINT_HW_FX
 #define PFC SH7705_PFC
 
 /* iokbd_delay() - wait a bit so that I/O can keep up
@@ -162,4 +163,4 @@ void iokbd_scan(uint8_t *scan)
 	}
 }
 
-#endif /* FX9860G */
+#endif /* GINT_HW_FX */

src/keysc/keydev.c

@@ -2,6 +2,7 @@
 //	gint:keydev - Generic input handling on keyboard devices
 //---
 
+#include <gint/config.h>
 #include <gint/keyboard.h>
 #include <gint/cpu.h>
 #include <gint/drivers/keydev.h>
@@ -11,6 +12,50 @@
 #include <string.h>
 #include <stdarg.h>
 
+#if GINT_HW_CP
+static uint8_t const CP_translation_table[] = {
+	KEY_SHIFT,   KEY_DIV,    KEY_MUL,    KEY_MINUS,   KEY_PLUS,   KEY_EXE,
+	KEY_DEL,     KEY_POWER,  KEY_9,      KEY_6,       KEY_3,      KEY_EXP,
+	KEY_RIGHT,   KEY_LEFT,   KEY_Z,      0,           0,          0,
+	KEY_UP,      KEY_DOWN,   KEY_8,      KEY_5,       KEY_2,      KEY_DOT,
+	KEY_KBD,     KEY_Y,      KEY_7,      KEY_4,       KEY_1,      KEY_0,
+	KEY_EQUALS,  KEY_X,      KEY_LEFTP,  KEY_RIGHTP,  KEY_COMMA,  KEY_NEG,
+};
+static int keymatrix_to_keycode(int row, int col)
+{
+	if(row == 0 && col == 1)
+		return KEY_CLEAR;
+	return CP_translation_table[6 * (row-1) + (7-col)];
+}
+static void keycode_to_keymatrix(int keycode, int *row, int *col)
+{
+	if(keycode == KEY_CLEAR) {
+		*row = 0;
+		*col = 1;
+		return;
+	}
+	for(int i = 0; i < (int)sizeof(CP_translation_table); i++) {
+		if(CP_translation_table[i] == keycode) {
+			*row = i / 6 + 1;
+			*col = 7 - (i % 6);
+			return;
+		}
+	}
+	*row = 0;
+	*col = 0;
+}
+#else
+static GINLINE int keymatrix_to_keycode(int row, int col)
+{
+	return (row << 4) + (7 - col);
+}
+static GINLINE void keycode_to_keymatrix(int keycode, int *row, int *col)
+{
+	*row = keycode >> 4;
+	*col = 7 - (keycode & 7);
+}
+#endif
+
 void keydev_init(keydev_t *d)
 {
 	memset(d, 0, sizeof *d);
@@ -78,16 +123,14 @@ void keydev_process_state(keydev_t *d, uint8_t scan[12])
 				: d->state_now[row] & ~scan[row];
 			if(!diff) continue;
 
-			ev.key = (row << 4);
-
-			for(int mask = 0x80; mask != 0; mask >>= 1)
+			for(int mask = 0x80, col = 7; mask; mask >>= 1, col--)
 			{
+				ev.key = keymatrix_to_keycode(row, col);
 				/* Update state only if the push succeeds */
 				if((diff & mask) && keydev_queue_push(d, ev))
 					d->state_now[row] = mode
 					? d->state_now[row] | mask
 					: d->state_now[row] & ~mask;
-				ev.key++;
 			}
 		}
 
@@ -142,6 +185,22 @@ void keydev_tick(keydev_t *d, uint us)
 
 	d->time++;
 
+	/* Disable repeat if the repeating key was released */
+	if(d->rep_key != 0)
+	{
+		int row, col;
+		keycode_to_keymatrix(d->rep_key, &row, &col);
+		if(!(d->state_now[row] & (1 << col)))
+		{
+			d->rep_key = 0;
+			d->rep_count = -1;
+			d->rep_time = -1;
+			d->rep_delay = -1;
+			d->delayed_shift = 0;
+			d->delayed_alpha = 0;
+		}
+	}
+
 	if(d->rep_key != 0)
 	{
 		if(d->rep_delay >= 0)
@@ -173,12 +232,14 @@ key_event_t keydev_unqueue_event(keydev_t *d)
 		return ev;
 
 	/* Update the event state accordingly */
-	int row = (ev.key >> 4);
-	int col = 0x80 >> (ev.key & 0x7);
+	int row, col;
+	keycode_to_keymatrix(ev.key, &row, &col);
+	int mask = 1 << col;
 
 	if(ev.type == KEYEV_DOWN)
 	{
-		d->state_queue[row] |= col;
+		d->state_queue[row] |= mask;
+		d->state_flips[row] ^= mask;
 		/* Mark this key as the currently repeating one */
 		if(d->rep_key == 0 && can_repeat(d, ev.key))
 		{
@@ -190,17 +251,8 @@ key_event_t keydev_unqueue_event(keydev_t *d)
 	}
 	else if(ev.type == KEYEV_UP)
 	{
-		d->state_queue[row] &= ~col;
-		/* End the current repeating streak */
-		if(d->rep_key == ev.key)
-		{
-			d->rep_key = 0;
-			d->rep_count = -1;
-			d->rep_time = -1;
-			d->rep_delay = -1;
-			d->delayed_shift = 0;
-			d->delayed_alpha = 0;
-		}
+		d->state_queue[row] &= ~mask;
+		d->state_flips[row] ^= mask;
 	}
 
 	return ev;
@@ -211,14 +263,38 @@ key_event_t _WEAK_keydev_unqueue_event(keydev_t *d);
 /* keydev_keydown(): Check if a key is down according to generated events */
 bool keydev_keydown(keydev_t *d, int key)
 {
-	int row = (key >> 4);
-	int col = 0x80 >> (key & 0x7);
+	int row, col;
+	keycode_to_keymatrix(key, &row, &col);
+	int mask = 1 << col;
 
-	return (d->state_queue[row] & col) != 0;
+	return (d->state_queue[row] & mask) != 0;
 }
 __attribute__((alias("keydev_keydown")))
 bool _WEAK_keydev_keydown(keydev_t *d, int key);
 
+bool keydev_keypressed(keydev_t *d, int key)
+{
+	int row, col;
+	keycode_to_keymatrix(key, &row, &col);
+	int mask = 1 << col;
+
+	return (d->state_queue[row] & mask) && (d->state_flips[row] & mask);
+}
+
+bool keydev_keyreleased(keydev_t *d, int key)
+{
+	int row, col;
+	keycode_to_keymatrix(key, &row, &col);
+	int mask = 1 << col;
+
+	return !(d->state_queue[row] & mask) && (d->state_flips[row] & mask);
+}
+
+void keydev_clear_flips(keydev_t *d)
+{
+	memset(d->state_flips, 0, sizeof d->state_flips);
+}
+
 //---
 // Event transforms
 //---

src/keysc/keysc.c

@@ -17,18 +17,18 @@
 #include <string.h>
 #include <stdlib.h>
 
+/* Keyboard input device for this Key Scan Interface */
+static keydev_t keysc_dev;
+/* Keyboard scanner timer */
+int16_t keysc_tid = -1;
+
 /* Keyboard scan frequency in Hertz. Start with 128 Hz, this frequency *must
    be high* for the keyboard to work! Reading at low frequencies produces a lot
    of artifacts. See https://www.casiopeia.net/forum/viewtopic.php?p=20592. */
-int keysc_scan_Hz = 128;
+int16_t keysc_scan_Hz = 128;
 /* Approximation in microseconds, used by the timer and repeat delays */
 uint32_t keysc_scan_us = 7812; /* 1000000 / keysc_scan_Hz */
 
-/* Keyboard scanner timer */
-int keysc_tid = -1;
-/* Keyboard input device for this Key Scan Interface */
-static keydev_t keysc_dev;
-
 /* keydev_std(): Standard keyboard input device */
 keydev_t *keydev_std(void)
 {
@@ -56,7 +56,7 @@ static void keysc_scan(uint8_t *scan)
 }
 
 /* keysc_tick(): Update the keyboard to the next state */
-static int keysc_tick(void)
+int keysc_tick(void)
 {
 	uint8_t scan[12] = { 0 };
 	keysc_scan(scan);
@@ -102,12 +102,26 @@ void clearevents(void)
 	while(pollevent().type != KEYEV_NONE);
 }
 
-/* keydown(): Current key state */
+void cleareventflips(void)
+{
+	keydev_clear_flips(&keysc_dev);
+}
+
 int keydown(int key)
 {
 	return keydev_keydown(&keysc_dev, key);
 }
 
+int keypressed(int key)
+{
+	return keydev_keypressed(&keysc_dev, key);
+}
+
+int keyreleased(int key)
+{
+	return keydev_keyreleased(&keysc_dev, key);
+}
+
 //---
 // Driver initialization
 //---