bump version to 2.10.0

For some reason this has a *massive* impact on read performance, like
78 ms -> 20 ms on a full-screen read (177 kB) on the CG-50.

CMakeLists.txt

@@ -1,14 +1,15 @@
 # Build system for the gint unikernel
 
 cmake_minimum_required(VERSION 3.15)
-project(Gint VERSION 2.5.3 LANGUAGES C ASM)
+project(Gint VERSION 2.10.0 LANGUAGES C ASM)
 
 include(GitVersionNumber)
 include(Fxconv)
 
-option(GINT_USER_VRAM "Put all VRAMs into the user stack (fx-CG 50 only)")
+option(GINT_NO_OS_STACK "Do not use the OS stack as a memory pool (fx-CG only)")
 option(GINT_STATIC_GRAY "Use static memory instead of malloc for gray buffers (fx-9860G only)")
 option(GINT_KMALLOC_DEBUG "Enable debug functions for kmalloc")
+option(GINT_USB_DEBUG "Enable debug functions for the USB driver")
 
 set(CMAKE_INSTALL_MESSAGE LAZY)
 
@@ -22,17 +23,57 @@ endif()
 configure_file(include/gint/config.h.in include/gint/config.h)
 
 set(SOURCES_COMMON
+  # Clock Pulse Generator driver
   src/cpg/cpg.c
+  src/cpg/overclock.c
+  # CPU driver
   src/cpu/atomic.c
   src/cpu/cpu.c
+  src/cpu/ics.s
   src/cpu/registers.s
   src/cpu/sleep.c
+  # Direct Memory Access driver
   src/dma/dma.c
   src/dma/inth.s
   src/dma/memcpy.c
   src/dma/memset.c
+  # Filesystem interface
+  src/fs/close.c
+  src/fs/closedir.c
+  src/fs/creat.c
+  src/fs/fdopendir.c
+  src/fs/fs.c
+  src/fs/lseek.c
+  src/fs/mkdir.c
+  src/fs/open.c
+  src/fs/opendir.c
+  src/fs/pread.c
+  src/fs/pwrite.c
+  src/fs/read.c
+  src/fs/readdir.c
+  src/fs/rename.c
+  src/fs/rewinddir.c
+  src/fs/rmdir.c
+  src/fs/seekdir.c
+  src/fs/stat.c
+  src/fs/telldir.c
+  src/fs/unlink.c
+  src/fs/write.c
+  # Filesystem interface to Fugue
+  src/fs/fugue/BFile_Ext_Stat.c
+  src/fs/fugue/fugue.c
+  src/fs/fugue/fugue_dir.c
+  src/fs/fugue/fugue_open.c
+  src/fs/fugue/fugue_mkdir.c
+  src/fs/fugue/fugue_stat.c
+  src/fs/fugue/fugue_rename.c
+  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
@@ -43,51 +84,73 @@ set(SOURCES_COMMON
   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
+  # Gray engine
   src/gray/engine.c
   src/gray/gclear.c
+  src/gray/ggetpixel.c
   src/gray/gint_gline.c
   src/gray/gpixel.c
   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
@@ -96,14 +159,48 @@ set(SOURCES_FX
   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
-  src/render-cg/bopti-asm.s
-  src/render-cg/bopti.c
+  # Image library
+  src/image/image_alloc.c
+  src/image/image_alloc_palette.c
+  src/image/image_alpha.c
+  src/image/image_clear.c
+  src/image/image_copy.c
+  src/image/image_copy_alloc.c
+  src/image/image_copy_palette.c
+  src/image/image_create.c
+  src/image/image_create_vram.c
+  src/image/image_data_size.c
+  src/image/image_decode_pixel.c
+  src/image/image_fill.c
+  src/image/image_free.c
+  src/image/image_get_pixel.c
+  src/image/image_hflip.c
+  src/image/image_hflip_alloc.c
+  src/image/image_linear.c
+  src/image/image_linear.S
+  src/image/image_linear_alloc.c
+  src/image/image_rotate.c
+  src/image/image_rotate_around.c
+  src/image/image_rotate_around_scale.c
+  src/image/image_scale.c
+  src/image/image_set_palette.c
+  src/image/image_set_pixel.c
+  src/image/image_sub.c
+  src/image/image_target.c
+  src/image/image_valid.c
+  src/image/image_vflip.c
+  src/image/image_vflip_alloc.c
+  # Rendering
   src/render-cg/dclear.c
+  src/render-cg/dgetpixel.c
   src/render-cg/dpixel.c
   src/render-cg/drect.c
   src/render-cg/dsubimage.c
@@ -112,6 +209,37 @@ set(SOURCES_CG
   src/render-cg/gint_dline.c
   src/render-cg/topti-asm.s
   src/render-cg/topti.c
+  # Fast image renderer
+  src/render-cg/image/image.c
+  src/render-cg/image/image_rgb16.S
+  src/render-cg/image/image_rgb16_normal.S
+  src/render-cg/image/image_rgb16_clearbg_dye.S
+  src/render-cg/image/image_rgb16_swapcolor.S
+  src/render-cg/image/image_p8.S
+  src/render-cg/image/image_p8_normal.S
+  src/render-cg/image/image_p8_clearbg.S
+  src/render-cg/image/image_p8_swapcolor.S
+  src/render-cg/image/image_p8_dye.S
+  src/render-cg/image/image_p4.S
+  src/render-cg/image/image_p4_normal.S
+  src/render-cg/image/image_p4_clearbg.S
+  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
+  src/render-cg/image/image_rgb16.c
+  src/render-cg/image/image_rgb16_effect.c
+  src/render-cg/image/image_rgb16_swapcolor.c
+  src/render-cg/image/image_rgb16_dye.c
+  src/render-cg/image/image_p8.c
+  src/render-cg/image/image_p8_effect.c
+  src/render-cg/image/image_p8_swapcolor.c
+  src/render-cg/image/image_p8_dye.c
+  src/render-cg/image/image_p4.c
+  src/render-cg/image/image_p4_clearbg_alt.c
+  src/render-cg/image/image_p4_effect.c
+  src/render-cg/image/image_p4_swapcolor.c
+  src/render-cg/image/image_p4_dye.c
 )
 
 set(ASSETS_FX src/font5x7.png)
@@ -120,37 +248,52 @@ fxconv_declare_assets(${ASSETS_FX} ${ASSETS_CG})
 
 include_directories(
   "${PROJECT_SOURCE_DIR}/include"
-  "${PROJECT_BINARY_DIR}/include"
-  "${FXSDK_COMPILER_INSTALL}/include/openlibm")
+  "${PROJECT_BINARY_DIR}/include")
 add_compile_options(-Wall -Wextra -std=c11 -Os -fstrict-volatile-bitfields -mtas)
 
 if("${FXSDK_PLATFORM_LONG}" STREQUAL fx9860G)
   add_compile_definitions(FX9860G)
-  add_library(gint-fx STATIC ${SOURCES_COMMON} ${SOURCES_FX} ${ASSETS_FX})
   set(NAME "gint-fx")
-  set(LINKER_SCRIPT "fx9860g.ld")
+  set(LINKER_SCRIPTS
+    "${CMAKE_CURRENT_BINARY_DIR}/fx9860g.ld")
+  add_library(gint-fx STATIC ${SOURCES_COMMON} ${SOURCES_FX} ${ASSETS_FX}
+    ${LINKER_SCRIPTS})
 endif()
 
 if("${FXSDK_PLATFORM_LONG}" STREQUAL fxCG50)
   add_compile_definitions(FXCG50)
-  add_library(gint-cg STATIC ${SOURCES_COMMON} ${SOURCES_CG} ${ASSETS_CG})
   set(NAME "gint-cg")
-  set(LINKER_SCRIPT "fxcg50.ld")
+  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})
 endif()
 
 set_target_properties("${NAME}" PROPERTIES OUTPUT_NAME "${NAME}")
 
+# Generate linker scripts
+macro(generate_linker_script OUTPUT INPUT OPTIONS)
+  add_custom_command(
+    OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${OUTPUT}"
+    COMMAND ${FXSDK_TOOLCHAIN}cpp "${CMAKE_CURRENT_SOURCE_DIR}/${INPUT}"
+            -P -C -traditional-cpp ${OPTIONS} -o "${OUTPUT}"
+    DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/${INPUT}")
+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")
+
 # Library file
-install(TARGETS "${NAME}" DESTINATION "${FXSDK_COMPILER_INSTALL}")
-# Linker script
-install(FILES "${CMAKE_CURRENT_SOURCE_DIR}/${LINKER_SCRIPT}"
-  DESTINATION "${FXSDK_COMPILER_INSTALL}")
+install(TARGETS "${NAME}" DESTINATION "${FXSDK_LIB}")
+# Linker scripts
+install(FILES ${LINKER_SCRIPTS} DESTINATION "${FXSDK_LIB}")
 # Headers
-install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/include"
-  DESTINATION "${FXSDK_COMPILER_INSTALL}"
+install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/include/"
+  DESTINATION "${FXSDK_INCLUDE}"
   FILES_MATCHING PATTERN "*.h")
 # Auto-generated config header
 install(FILES "${CMAKE_CURRENT_BINARY_DIR}/include/gint/config.h"
-  DESTINATION "${FXSDK_COMPILER_INSTALL}/include/gint")
+  DESTINATION "${FXSDK_INCLUDE}/gint")
 # CMake module to find gint
 install(FILES cmake/FindGint.cmake DESTINATION "${FXSDK_CMAKE_MODULE_PATH}")

README.md

@@ -32,7 +32,7 @@ The library also offers powerful higher-level features:
 
 * An enhanced version of the system's GetKey() and GetKeyWait()
 * A gray engine that works by rapidly swapping monochrome images on fx-9860G II
-* Blazingly fast rendering functions (image rendering is 10 times faster tha
+* Blazingly fast rendering functions (image rendering is 10 times faster than
   MonochromeLib)
 * Integrated font management
 
@@ -66,12 +66,6 @@ CMake environment for the calculator. gint is always installed in the
 compiler's install path (as given by `sh-elf-gcc --print-search-dirs`) which is
 detected automatically, so normally you don't need to set the install prefix.
 
-fx-CG 50 developers probably want a g3a wrapper as well; the reference
-implementation is Tari's [mkg3a](https://gitlab.com/taricorp/mkg3a). This is
-needed at the very last compilation step to create the g3a file. On Arch Linux,
-you can use the [AUR/mkg3a](https://aur.archlinux.org/packages/mkg3a) package
-maintained directly by Tari.
-
 gint depends on OpenLibm and fxlibc (linked above). Both can be installed
 easily (essentially copy-paste the command from the respective READMEs). You
 can technically use another libc but there be dragons.
@@ -89,6 +83,7 @@ Run without `-c` to build. This configures automatically.
 
 ```
 % fxsdk build-fx
+% fxsdk build-fx install
 ```
 
 The available options are:
@@ -105,6 +100,11 @@ The available options are:
 
 * `-DGINT_USER_VRAM=1`: Store all VRAMs in the user stack (takes up 350k/512k)
 
+```
+% fxsdk build-cg
+% fxsdk build-cg install
+```
+
 ## Using in CMake-based add-ins
 
 Find the `Gint` module and link against `Gint::Gint`. gint declares the include

TODO

@@ -1,22 +1,26 @@
+Bugs to fix:
+* render:    figure out why fx-CG dclear() now takes 4.1 ms instead of 2.6 ms
+
 Extensions on existing code:
+* clock:     mono support
+* usb:       add PC->calc reading, and interrupt pipes
+* fs:        support RAM files
+* fs:        support USB streams as generic file descriptors
+* fugue:     support glob() to abstract away BFile entirely
+* fugue/fs:  offer a primitive to remove recursively, which is native in Fugue
 * bfile:     implement the optimization-restart as realized by Kbd2
 * kernel:    better restore to userspace before panic (ensure BL=0 IMASK=0)
 * project:   add license file
 * kernel:    group linker script symbols in a single header file
-* bopti:     try to display fullscreen images with TLB access + DMA on fxcg50
-* core:      try to leave add-in without reset in case of panic
-* core:      use cmp/str for memchr()
 * r61524:    brightness control and clean the file
 * core:      review forgotten globals and MPU addresses not in <gint/mpu/*.h>
 * core:      run destructors when a task-switch results in leaving the app
-* core rtc:  use qdiv10 to massively improve division performance
+* 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
 
-Future directions.
-* A complete file system abstraction
-* Integrate overclock management
+Future directions:
 * Audio playback using TSWilliamson's libsnd method
 * Serial communication
-* USB communication, using Yatis' reverse-engineering of the module
 * Make fx9860g projects work out of the box on fxcg50
-* Use the DSP to enhance parallel computation
 * Base for Yatis' threads library

cmake/FindGint.cmake

@@ -2,7 +2,7 @@
 if("${FXSDK_PLATFORM_LONG}" STREQUAL fxCG50)
   set(PC cg)
   set(INTF_DEFN FXCG50)
-  set(INTF_LINK "-T;fxcg50.ld")
+  set(INTF_LINK "-T;$<IF:$<CONFIG:FastLoad>,fxcg50_fastload.ld,fxcg50.ld>")
 elseif("${FXSDK_PLATFORM_LONG}" STREQUAL fx9860G)
   set(PC fx)
   set(INTF_DEFN FX9860G)
@@ -14,13 +14,16 @@ endif()
 execute_process(
   COMMAND ${CMAKE_C_COMPILER} -print-file-name=libgint-${PC}.a
   OUTPUT_VARIABLE GINT_PATH
-  OUTPUT_STRIP_TRAILING_WHITESPACE
-)
+  OUTPUT_STRIP_TRAILING_WHITESPACE)
 execute_process(
-  COMMAND ${CMAKE_C_COMPILER} -print-file-name=include/gint/config.h
-  OUTPUT_VARIABLE GINT_CONFIG_PATH
-  OUTPUT_STRIP_TRAILING_WHITESPACE
-)
+  COMMAND ${CMAKE_C_COMPILER} -print-file-name=libc.a
+  OUTPUT_VARIABLE FXLIBC_PATH
+  OUTPUT_STRIP_TRAILING_WHITESPACE)
+execute_process(
+  COMMAND fxsdk path include
+  OUTPUT_VARIABLE FXSDK_INCLUDE
+  OUTPUT_STRIP_TRAILING_WHITESPACE)
+set(GINT_CONFIG_PATH "${FXSDK_INCLUDE}/gint/config.h")
 
 if("${GINT_PATH}" STREQUAL "libgint-${PC}.a")
   unset(PATH_TO_LIBGINT)
@@ -35,13 +38,25 @@ else()
   endif()
 endif()
 
+if("${FXLIBC_PATH}" STREQUAL "libc.a")
+  unset(PATH_TO_FXLIBC)
+else()
+  set(PATH_TO_FXLIBC TRUE)
+endif()
+
 include(FindPackageHandleStandardArgs)
 find_package_handle_standard_args(Gint
-  REQUIRED_VARS PATH_TO_LIBGINT
-  VERSION_VAR GINT_VERSION
-)
+  REQUIRED_VARS PATH_TO_FXLIBC PATH_TO_LIBGINT
+  VERSION_VAR GINT_VERSION)
 
 if(Gint_FOUND)
+  if(NOT TARGET Gint::Fxlibc)
+    add_library(Gint::Fxlibc UNKNOWN IMPORTED)
+  endif()
+  set_target_properties(Gint::Fxlibc PROPERTIES
+    IMPORTED_LOCATION "${FXLIBC_PATH}"
+    INTERFACE_LINK_OPTIONS "-lgcc")
+
   if(NOT TARGET Gint::Gint)
     add_library(Gint::Gint UNKNOWN IMPORTED)
   endif()
@@ -49,8 +64,9 @@ if(Gint_FOUND)
     IMPORTED_LOCATION "${GINT_PATH}"
     INTERFACE_COMPILE_OPTIONS -fstrict-volatile-bitfields
     INTERFACE_COMPILE_DEFINITIONS "${INTF_DEFN}"
-    INTERFACE_INCLUDE_DIRECTORIES "${FXSDK_COMPILER_INSTALL}/include/openlibm"
-    INTERFACE_LINK_LIBRARIES "-lc;-lopenlibm;-lgcc"
-    INTERFACE_LINK_OPTIONS "${INTF_LINK}"
-  )
+    INTERFACE_LINK_LIBRARIES "-lopenlibm;-lgcc"
+    INTERFACE_LINK_OPTIONS "${INTF_LINK}")
+
+  target_link_libraries(Gint::Gint INTERFACE Gint::Fxlibc)
+  target_link_libraries(Gint::Fxlibc INTERFACE Gint::Gint)
 endif()

fx9860g.ld.c

@@ -35,8 +35,7 @@ MEMORY
 	/* On-chip IL memory */
 	ilram (rwx):  o = 0xe5200000, l = 4k
 	/* On-chip X and Y memory */
-	xram  (rwx):  o = 0xe5007000, l = 8k
-	yram  (rwx):  o = 0xe5017000, l = 8k
+	xyram (rwx):  o = 0xe500e000, l = 16k
 }
 
 SECTIONS
@@ -110,6 +109,7 @@ SECTIONS
 		*(.rodata.4)
 
 		*(.rodata .rodata.*)
+		*(.gint.rodata.sh3)
 	} > rom
 
 
@@ -128,7 +128,7 @@ SECTIONS
 	.bss (NOLOAD) : {
 		_rbss = . ;
 
-		*(.bss COMMON)
+		*(.bss .bss.* COMMON)
 		*(B R)
 
 		. = ALIGN(16);
@@ -188,29 +188,18 @@ SECTIONS
 		. = ALIGN(16);
 	} > ilram AT> rom
 
-	. = ORIGIN(xram);
-	.xram ALIGN(4) : ALIGN(4) {
-		_lxram = LOADADDR(.xram);
-		_rxram = . ;
+	. = ORIGIN(xyram);
+	.xyram ALIGN(4) : ALIGN(4) {
+		_lxyram = LOADADDR(.xyram);
+		_rxyram = . ;
 
-		*(.xram)
+		*(.xram .yram .xyram)
 
 		. = ALIGN(16);
-	} > xram AT> rom
-
-	. = ORIGIN(yram);
-	.yram ALIGN(4) : ALIGN(4) {
-		_lyram = LOADADDR(.yram);
-		_ryram = . ;
-
-		*(.yram)
-
-		. = ALIGN(16);
-	} > yram AT> rom
+	} > xyram AT> rom
 
 	_silram = SIZEOF(.ilram);
-	_sxram  = SIZEOF(.xram);
-	_syram  = SIZEOF(.yram);
+	_sxyram = SIZEOF(.xyram);
 
 
 
@@ -237,9 +226,6 @@ SECTIONS
 	*/
 
 	/DISCARD/ : {
-		/* Debug sections (often from libgcc) */
-		*(.debug_info .debug_abbrev .debug_loc .debug_aranges
-		  .debug_ranges .debug_line .debug_str)
 		/* Java class registration (why are they even here?!) */
 		*(.jcr)
 		/* Asynchronous unwind tables: no C++ exception handling */

fxcg50.ld.c

@@ -10,19 +10,24 @@ OUTPUT_FORMAT(elf32-sh)
 /* Located in core/start.c */
 ENTRY(_start)
 
+#ifdef FXCG50_FASTLOAD
+# define _ROM_REGION 0x8c200000
+#else
+# define _ROM_REGION 0x00300000
+#endif
+
 MEMORY
 {
 	/* Userspace mapping of the add-in (without G3A header) */
-	rom   (rx):   o = 0x00300000, l = 2M
+	rom   (rx):   o = _ROM_REGION, l = 2M
 	/* Static RAM; stack grows down from the end of this region.
 	   The first 5k (0x1400 bytes) are reserved by gint for the VBR space,
 	   which is loaded dynamically and accessed through P1 */
-	ram   (rw):   o = 0x08101400, l = 507k
+	ram   (rw):   o = 0x08101400, l = 491k
 	/* On-chip IL memory */
 	ilram (rwx):  o = 0xe5200000, l = 4k
 	/* On-chip X and Y memory */
-	xram  (rwx):  o = 0xe5007000, l = 8k
-	yram  (rwx):  o = 0xe5017000, l = 8k
+	xyram (rwx):  o = 0xe500e000, l = 16k
 }
 
 SECTIONS
@@ -32,7 +37,7 @@ SECTIONS
 	*/
 
 	/* First address to be mapped to ROM */
-	_brom = 0x00300000;
+	_brom = ORIGIN(rom);
 	/* Size of ROM mappings */
 	_srom = SIZEOF(.text) + SIZEOF(.rodata)
 	      + SIZEOF(.gint.drivers) + SIZEOF(.gint.blocks);
@@ -102,8 +107,7 @@ SECTIONS
 	.bss (NOLOAD) : {
 		_rbss = . ;
 
-		*(.bss.vram)
-		*(.bss COMMON)
+		*(.bss .bss.* COMMON)
 
 		. = ALIGN(16);
 	} > ram :NONE
@@ -144,29 +148,18 @@ SECTIONS
 		. = ALIGN(16);
 	} > ilram AT> rom
 
-	. = ORIGIN(xram);
-	.xram ALIGN(4) : ALIGN(4) {
-		_lxram = LOADADDR(.xram);
-		_rxram = . ;
+	. = ORIGIN(xyram);
+	.xyram ALIGN(4) : ALIGN(4) {
+		_lxyram = LOADADDR(.xyram);
+		_rxyram = . ;
 
-		*(.xram)
+		*(.xram .yram .xyram)
 
 		. = ALIGN(16);
-	} > xram AT> rom
-
-	. = ORIGIN(yram);
-	.yram ALIGN(4) : ALIGN(4) {
-		_lyram = LOADADDR(.yram);
-		_ryram = . ;
-
-		*(.yram)
-
-		. = ALIGN(16);
-	} > yram AT> rom
+	} > xyram AT> rom
 
 	_silram = SIZEOF(.ilram);
-	_sxram  = SIZEOF(.xram);
-	_syram  = SIZEOF(.yram);
+	_sxyram = SIZEOF(.xyram);
 
 	/* gint's uninitialized BSS section, going to static RAM. All the large
 	   data arrays will be located here */
@@ -188,10 +181,7 @@ SECTIONS
 
 	/DISCARD/ : {
 		/* SH3-only data sections */
-		*(.gint.data.sh3 .gint.bss.sh3)
-		/* Debug sections (often from libgcc) */
-		*(.debug_info .debug_abbrev .debug_loc .debug_aranges
-		  .debug_ranges .debug_line .debug_str)
+		*(.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 */

include/gint/bfile.h

@@ -1,98 +1,235 @@
 //---
-//	gint:bfile - BFile interface
+// gint:bfile - BFile interface
 //
-//	The system's file system is a nightmare and the risk of corrupting it
-//	or the flash by driving it manually is too great to risk. This module
-//	interfaces with the BFile syscalls for file management.
+// BFile is the OS's native interface to the filesystem. It has quite a bit of
+// legacy, so it's not very easy to use. Please note that BFile cannot be used
+// from within gint, so do a gint_world_switch() (<gint/gint.h>) to call BFile
+// functions; otherwise the add-in is likely to crash.
+//
+// There are two different filesystems:
+// * An older, in-house one made by CASIO and informally called CASIOWIN (which
+//   is the name of the OS itself), which is incomplete, hard to use, and very
+//   limiting, but also very fast.
+// * A newer one, designed by Kyoto Software Research and called Fugue, which
+//   is mostly complete and behaves as a regular filesystem, though very slow.
+//
+// You can detect which one is used by querying gint[HWFS] (<gint/hardware.h>):
+// * HWFS_FUGUE is the newer one; it is found in:
+//   - The fx-CG series (in France: Prizm and Graph 90+E)
+//   - The fx G-III series (in France: Graph 35+E II)
+// * HWFS_CASIOWIN is the older one; it is found in all older black-and-white
+//   model that have a storage memory.
+//
+// Wherever Fugue is used, gint supports the Unix file API (open, read, write,
+// etc) and the C99 standard file API (fopen, fread, fwrite, etc), so there is
+// no need to call into BFile directly (you should still do a world switch
+// before using these functions).
+//
+// You should only have to use BFile if you're dealing with the CASIOWIN
+// filesystem. With Fugue, not only are the Unix/C99 APIs easier to use, but
+// the meanings of arguments and return values in BFile calls also change
+// compared to the CASIOWIN filesystem, so there's little to gain anyway.
+//
+// If you're here for the CASIOWIN filesystem, be aware of its limitations. In
+// general reading files will work fine; expect no issues with that. Modifying
+// files is where things get difficult. Keep the following in mind:
+//
+// * Non-standard meanings of arguments and return values (eg. BFile_Read()
+//   returns the number of readable bytes between the new position and EOF).
+// * Files must be created with a fixed size indicated in BFile_Create() and
+//   are initialized with 0xff.
+// * A write to a file can only replace 1's with 0's, meaning in practice a
+//   file can only be written to once. (That's why it's created with 0xff.)
+// * All writes must be of even size; writing an odd number of bytes can mess
+//   up the file and confuse the filesystem.
+// * Only one level of folders is supported; attempting to create second-level
+//   subfolders results in weird recursive directories (don't do that).
+//
+// File paths in the OS use the non-standard FONTCHARACTER encoding, which is a
+// 16-bit fixed-width encoding. Most users don't care about special characters;
+// in GCC, you can get a 16-bit literal string with the u"" prefix, eg.
+//   u"\\\\fls0\\data.bin"
+// which is what you usually supply as the [uint16_t const *path] argument.
+//
+// All functions return nonnegative values on success. If no return value is
+// described then a successful call returns 0. Unless specified otherwise, all
+// functions can also return a negative error code as documented near the end
+// of this header.
 //---
 
 #ifndef GINT_BFILE
 #define GINT_BFILE
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #include <stdint.h>
 
-/* BFile_Remove(): Remove a file
-   Also works if the file does not exist.
+//---
+// Common file access functions
+//---
 
-   @file  FONTCHARACTER file path
-   Returns a BFile error code. */
-int BFile_Remove(uint16_t const *file);
+/* Remove a file or folder (also works if the entry does not exist). */
+int BFile_Remove(uint16_t const *path);
+
+/* Rename a file (can move folders; Fugue only). */
+int BFile_Rename(uint16_t const *oldpath, uint16_t const *newpath);
+
+#define BFile_File    1
+#define BFile_Folder  5
+
+/* BFile_Create(): Create a new file or folder
 
-/* BFile_Create(): Create a new entry
    The file or directory must not exist. For a file the size pointer must point
-   to the desired file size (which is fixed), for a folder it is ignored.
+   to the desired file size (which is fixed), for a folder it is ignored. With
+   CASIOWIN this is the final size of the file. With Fugue the file can be
+   resized dynamically and is usually created with initial size 0.
 
-   @file  FONTCHARACTER file path
-   @type  Entry type
-   @size  Pointer to file size if [type = BFile_File], use NULL otherwise
-   Returns a BFile error code. */
-enum BFile_EntryType
-{
-	BFile_File	= 1,
-	BFile_Folder	= 5,
-};
-int BFile_Create(uint16_t const *file, enum BFile_EntryType type, int *size);
+   @path  FONTCHARACTER file path
+   @type  Entry type (BFile_File or BFile_Folder)
+   @size  Pointer to file size if type is BFile_File, use NULL otherwise */
+int BFile_Create(uint16_t const *path, int type, int *size);
 
-/* BFile_Open(): Open an existing file
-   The file must exist.
+#define BFile_ReadOnly        0x01
+#define BFile_WriteOnly       0x02
+#define BFile_ReadWrite       (BFile_ReadOnly | BFile_WriteOnly)
+#define BFile_Share           0x80
+#define BFile_ReadShare       (BFile_ReadOnly | BFile_Share)
+#define BFile_ReadWriteShare  (BFile_ReadWrite | BFile_Share)
 
-   @file  FONTCHARACTER file path
+/* BFile_Open(): Open a file for reading or writing
+
+   The file must exist, even when opening in writing mode. The meaning of the
+   [Share] flag isn't clear; I believe it's simply ignored in the CASIOWIN
+   filesystem.
+
+   @path  FONTCHARACTER file path
    @mode  Desired access mode
-   Returns a file descriptor on success, or a negative BFile error code. */
-enum BFile_OpenMode
-{
-	BFile_ReadOnly	= 0x01,
-	BFile_WriteOnly	= 0x02,
-	BFile_ReadWrite	= BFile_ReadOnly | BFile_WriteOnly,
-};
-int BFile_Open(uint16_t const *file, enum BFile_OpenMode mode);
+   Returns a file descriptor (or a negative error code). */
+int BFile_Open(uint16_t const *path, int mode);
 
-/* BFile_Close(): Close a file descriptor
-   @fd  Open file descriptor
-   Returns a BFile error code. */
+/* Close an open file descriptor. */
 int BFile_Close(int fd);
 
-/* BFile_Size(): Retrieve size of an open file
-   @fd  Open file descriptor
-   Returns the file size in bytes, or a negative BFile error code*/
+/* Get the size of an open file. */
 int BFile_Size(int fd);
 
 /* BFile_Write(): Write data to an open file
-   Second and third argument specify the data and length to write.
 
-   WARNING: The file systems has shown to become inconsistent if an odd number
-            of bytes is written with BFile_Write(). Keep it even!
+   WARNING: The CASIOWIN fs is known to become inconsistent if an odd number of
+            bytes is written with BFile_Write(). Always keep it even!
 
-   @fd         File descriptor open for writing
-   @data       Data to write
-   @even_size  Size to write (must be even, yes)
-   Returns a BFile error code. */
+   With CASIOWIN, returns the new file offset after writing (or an error code).
+   With Fugue, returns the amount of data written (or an error code). */
 int BFile_Write(int fd, void const *data, int even_size);
 
 /* BFile_Read(): Read data from an open file
-   The second and third argument specify where to store and how much to read.
-   The location from where the data is read depends on [whence]:
+
+   The extra argument [whence] specifies where data is read from in the style
+   of pread(2), and is supported with both filesystems.
 
    * If [whence >= 0], it is taken as an absolute location within the file;
    * If [whence == -1], BFile_Read() reads from the current position.
 
-   @fd      File descriptor open for reading
-   @data    Buffer of at least [size] bytes to store data to
-   @size    Number of bytes to read
-   @whence  Starting position of the data to read in the file
-   Returns a BFile error code. */
+   With Fugue this function can read past end of file and return the requested
+   amount of bytes even when the file does not have enough data to read that
+   much. It seems that extra bytes read as zeros. Reading past the end does
+   *not* extend the file size.
+
+   With CASIOWIN, returns how much data can be read from the updated file
+   offset (ie. how many bytes until end of file), or an error code.
+   With Fugue, returns the amount of data read (or an error code). */
 int BFile_Read(int handle, void *data, int size, int whence);
 
-/* BFile_FindFirst(): Search a directory for file with matching name
-   Doesn't work on Main memory. Only four search handle can be opened, you need
-   to close them to be able to reuse them. Search is NOT case sensitive and *
-   can be used as a wildcard.
+/* BFile_Seek(): Seek to a relative or absolute position within an open file
+
+   With CASIOWIN, moves [offset] bytes relative to the current position, and
+   returns how much data can be read from the new position. BFile_Seek(fd, 0)
+   combined with BFile_Size(fd) can be used to determine the current position.
+
+   With Fugue, moves to the absolute position [offset] within the file, and
+   returns the amount of allocated space following the new position (usually
+   larger than the amount of data until end-of-file because files are allocated
+   in units of 4096 bytes). There is no way to seek relative to the current
+   position unless the target is precomputed with BFile_GetPos(). */
+int BFile_Seek(int fd, int offset);
+
+/* BFile_GetPos(): Get the current position in an open file
+
+   This call does not exist in the CASIOWIN interface, so this function always
+   returns -1 on models with a CASIOWIN filesystem.
+
+   This call exists in Fugue, however some Fugue models have their syscall list
+   inherited from the CASIOWIN era and don't have an entry point for it (or if
+   there's one it's escape scrutiny so far).
+
+   * Prizm / Graph 90+E / fx-CG series: this function works as intended.
+   * Graph 35+E II / G-III series: the call is missing, returns -1.
+
+   For the latter models there is no easily reliable way of knowing the current
+   position within an open file! */
+int BFile_GetPos(int fd);
+
+//---
+// Error codes
+//---
+
+#define BFile_EntryNotFound       -1
+#define BFile_IllegalParam        -2
+#define BFile_IllegalPath         -3
+#define BFile_DeviceFull          -4
+#define BFile_IllegalDevice       -5
+#define BFile_IllegalFilesystem   -6
+#define BFile_IllegalSystem       -7
+#define BFile_AccessDenied        -8
+#define BFile_AlreadyLocked       -9
+#define BFile_IllegalTaskID       -10
+#define BFile_PermissionError     -11
+#define BFile_EntryFull           -12
+#define BFile_AlreadyExists       -13
+#define BFile_ReadOnlyFile        -14
+#define BFile_IllegalFilter       -15
+#define BFile_EnumerateEnd        -16
+#define BFile_DeviceChanged       -17
+//#define BFile_NotRecordFile     -18     // Not used
+#define BFile_IllegalSeekPos      -19
+#define BFile_IllegalBlockFile    -20
+//#define BFile_NoSuchDevice      -21     // Not used
+//#define BFile_EndOfFile         -22     // Not used
+#define BFile_NotMountDevice      -23
+#define BFile_NotUnmountDevice    -24
+#define BFile_CannotLockSystem    -25
+#define BFile_RecordNotFound      -26
+//#define BFile_NotDualRecordFile -27     // Not used
+#define BFile_NoAlarmSupport      -28
+#define BFile_CannotAddAlarm      -29
+#define BFile_FileFindUsed        -30
+#define BFile_DeviceError         -31
+#define BFile_SystemNotLocked     -32
+#define BFile_DeviceNotFound      -33
+#define BFile_FileTypeMismatch    -34
+#define BFile_NotEmpty            -35
+#define BFile_BrokenSystemData    -36
+#define BFile_MediaNotReady       -37
+#define BFile_TooManyAlarms       -38
+#define BFile_SameAlarmExists     -39
+#define BFile_AccessSwapArea      -40
+#define BFile_MultimediaCard      -41
+#define BFile_CopyProtection      -42
+#define BFile_IllegalFileData     -43
+
+//---
+// Search API
+//
+// The search API is described below. It's somewhat unreliable, with unclear
+// semantics and a history of breaking in seemingly reasonable programs. One
+// day probably we'll know how to use it properly and reliably.
+//
+// Note: always close search handles or trouble will ensue (eg. add-in
+// discovery failing).
+//---
 
-   @search    FONTCHARACTER file path to match
-   @shandle   Search handle to pass to BFile_FindNext or BFile_FindClose
-   @founfile  FONTCHARACTER found file path
-   @fileinfo  Structure containing a lot of information on the found file
-   Returns 0 on success, -1 if no file found, or negative value on error. */
 struct BFile_FileInfo
 {
 	uint16_t index;
@@ -105,36 +242,74 @@ struct BFile_FileInfo
 	/* Address of first fragment (do not use directly) */
 	void *address;
 };
-enum BFile_FileType
-{
-	BFile_Type_Directory  = 0x0000,
-	BFile_Type_File       = 0x0001,
-	BFile_Type_Addin      = 0x0002,
-	BFile_Type_Eact       = 0x0003,
-	BFile_Type_Language   = 0x0004,
-	BFile_Type_Bitmap     = 0x0005,
-	BFile_Type_MainMem    = 0x0006,
-	BFile_Type_Temp       = 0x0007,
-	BFile_Type_Dot        = 0x0008,
-	BFile_Type_DotDot     = 0x0009,
-	BFile_Type_Volume     = 0x000a,
-	BFile_Type_Archived   = 0x0041,
-};
-int BFile_FindFirst(uint16_t const *search, int *shandle, uint16_t *foundfile,
+
+#define BFile_Type_Directory  0x0000
+#define BFile_Type_File       0x0001
+#define BFile_Type_Addin      0x0002
+#define BFile_Type_Eact       0x0003
+#define BFile_Type_Language   0x0004
+#define BFile_Type_Bitmap     0x0005
+#define BFile_Type_MainMem    0x0006
+#define BFile_Type_Temp       0x0007
+#define BFile_Type_Dot        0x0008
+#define BFile_Type_DotDot     0x0009
+#define BFile_Type_Volume     0x000a
+#define BFile_Type_Archived   0x0041
+
+/* BFile_FindFirst(): Search the storage memory for paths matching a pattern
+
+   This if for the storage memory only. There are only four search handles;
+   make sure to close them, there is no automatic device to close them for you
+   even after the add-in exists.
+
+   Search is NOT case sensitive. '*' can be used as a wildcard, although it's
+   unclear whether more than one '*' is supported, whether '*' can match in a
+   directory name, whether multiple folders can be searched simultaneously, and
+   whether directories can be matched.
+
+   @pattern    FONTCHARACTER glob pattern
+   @shandle    Will receive search handle (to use in BFile_FindNext/FindClose)
+   @foundfile  Will receive FONTCHARACTER path of matching entry
+   @fileinfo   Will receive metadata of matching entry
+
+   On success, returns 0, stores the search handle in *shandle, and stores
+   information about the first match in foundfile and fileinfo. The negative
+   error code BFile_EntryNotFound should be interpreted as an empty result (ie.
+   no entry matched) rather than an error.
+
+   Returns 0 on success or a negative error code. BFile_EntryNotFound should be
+   interpreted as an empty result (ie. no file matched). */
+int BFile_FindFirst(uint16_t const *pattern, int *shandle, uint16_t *foundfile,
 	struct BFile_FileInfo *fileinfo);
 
-/* BFile_FindNext(): Continue a search a directory for file with matching name
+/* BFile_FindNext(): Continue a search
 
-   @shandle   Search handle from BFile_FindFirst
-   @founfile  FONTCHARACTER found file path
-   @fileinfo  Structure containing a lot of information on the found file
-   Returns 0 on success, -1 if end is reached, or negative value on error. */
+   Continues the search for matches. The search handle is the value set in
+   *shandle in BFile_FindFirst(). As before, *foundfile receives the matching
+   entry's path and *fileinfo its metadata.
+
+   Returns 0 on success. The negative error code BFile_EnumerateEnd should be
+   interpreted as the end of the search (ie. all matching files have been
+   returned) rather than an error. */
 int BFile_FindNext(int shandle, uint16_t *foundfile,
 	struct BFile_FileInfo *fileinfo);
 
-/* BFile_FindClose(): Close the specified search handle
-   @shandle  Search handle from BFile_FindFirst
-   Return 0 on success or negative value on error. */
+/* Close a search handle (with or without exhausting the matches). */
 int BFile_FindClose(int shandle);
 
+//---
+// Additional functions
+//
+// The following functions are implemented in gint using lower-level BFile
+// functions. They add abstraction/convenience to the API, but can be pretty
+// slow as they result in more BFile calls being made.
+//---
+
+/* BFile_Ext_Stat(): Stat an entry for type and size */
+int BFile_Ext_Stat(uint16_t const *path, int *type, int *size);
+
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GINT_BFILE */

include/gint/clock.h

@@ -5,6 +5,10 @@
 #ifndef GINT_CLOCK
 #define GINT_CLOCK
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #include <gint/defs/types.h>
 /* This header used to expose the sleep() function; include <gint/cpu.h> to
    ensure this is still the case */
@@ -48,11 +52,108 @@ typedef struct
    module; this address never changes. */
 const clock_frequency_t *clock_freq(void);
 
+/* cpg_compute_freq(): Compute the current clock frequency
+   This function updates the data structure returned by clock_freq() by
+   determining the current clock frequencies from the CPG. */
+void cpg_compute_freq(void);
+
 //---
 //	Overclock
 //---
 
-/* TODO: All overclock */
+/* The following enumerations define the clock speed settings supported by
+   gint. These are always the settings from Ftune/Ptune, which are the most
+   widely tested and gint treats as the standard. */
+enum {
+	/* Combinations of hardware settings that are none of Ftune's levels */
+	CLOCK_SPEED_UNKNOWN = 0,
+
+	/* Ftune's 5 default overclock levels. The main settings are listed
+	   below, though many more are involved.
+
+	   On SH3 fx-9860G-like:
+	     F1:  CPU @  29 MHz                    [Default speed]
+	     F2:  CPU @  58 MHz                    [Similar to G-III default]
+	     F3:  CPU @  88 MHz
+	     F4:  CPU @ 118 MHz                    [Fastest CPU option]
+	     F5:  CPU @ 118 MHz                    [Reduced memory wait times]
+	   On SH4 fx-9860G-like:
+	     F1:  CPU @  29 MHz,  BFC @  29 MHz    [Default speed]
+	     F2:  CPU @  58 MHz,  BFC @  29 MHz    [Similar to G-III default]
+	     F3:  CPU @  29 MHz,  BFC @  29 MHz    [SH3 default]
+	     F4:  CPU @ 118 MHz,  BFC @  59 MHz
+	     F5:  CPU @ 236 MHz,  BFC @  118 MHz   [Fastest option]
+	   On G-III / Graph 35+E II:
+	     F1:  CPU @  58 MHz,  BFC @  29 MHz    [Default speed]
+	     F2:  CPU @  58 MHz,  BFC @  29 MHz    [fx-CG 10/20 default]
+	     F3:  CPU @  29 MHz,  BFC @  29 MHz    [SH3 default]
+	     F4:  CPU @ 118 MHz,  BFC @  58 MHz
+	     F5:  CPU @ 235 MHz,  BFC @  58 MHz    [Fastest option]
+	   On fx-CG 10/20:
+	     F1:  CPU @  58 MHz,  BFC @  29 MHz    [Default speed]
+	     F2:  CPU @  58 MHz,  BFC @  29 MHz    [Improved memory speed]
+	     F3:  CPU @ 118 MHz,  BFC @  58 MHz    [Faster than F2]
+	     F4:  CPU @ 118 MHz,  BFC @ 118 MHz    [Fastest bus option]
+	     F5:  CPU @ 191 MHz,  BFC @  94 MHz    [Fastest CPU option]
+	   On fx-CG 50:
+	     F1:  CPU @ 116 MHz,  BFC @  58 MHz    [Default speed]
+	     F2:  CPU @  58 MHz,  BFC @  29 MHz    [fx-CG 10/20 default]
+	     F3:  CPU @  94 MHz,  BFC @  47 MHz    [Clearly slow: F2 < F3 < F1]
+	     F4:  CPU @ 232 MHz,  BFC @  58 MHz    [Fastest CPU option]
+	     F5:  CPU @ 189 MHz,  BFC @  94 MHz    [Fastest bus option] */
+
+	CLOCK_SPEED_F1 = 1,
+	CLOCK_SPEED_F2 = 2,
+	CLOCK_SPEED_F3 = 3,
+	CLOCK_SPEED_F4 = 4,
+	CLOCK_SPEED_F5 = 5,
+
+	/* The default clock speed is always Ftune's F1 */
+	CLOCK_SPEED_DEFAULT = CLOCK_SPEED_F1,
+};
+
+/* clock_get_speed(): Determine the current clock speed
+
+   This function compares the current hardware state with the settings for each
+   speed level and returns the current one. If the hardware state does not
+   correspond to any of Ftune's settings, CLOCK_SPEED_UNKNOWN is returned. */
+int clock_get_speed(void);
+
+/* clock_set_speed(): Set the current clock speed
+
+   This function sets the clock speed to the desired level. This is "the
+   overclock function", although depending on the model or settings it is also
+   the downclocking function.
+
+   The process of changing clock speeds is non-trivial, requires waiting for
+   the DMA to finish its work and slightly affects running timers. You should
+   avoid changing the clock speed constantly if not necessary. If this function
+   detects that the desired clock speed is already in use, it returns without
+   performing any change.
+
+   Currently the clock speed is not reset during a world switch nor when
+   leaving the add-in. */
+void clock_set_speed(int speed);
+
+/* If you want to faithfully save and restore the clock state while properly
+   handling clock speeds that are not Ftune/PTune's defaults, you can get a
+   full copy of the settings.
+
+   WARNING: Applying random settings with cpg_set_overclock_setting() might
+   damage your calculator! */
+
+struct cpg_overclock_setting
+{
+    uint32_t FLLFRQ, FRQCR;
+    uint32_t CS0BCR, CS2BCR, CS3BCR, CS5aBCR;
+    uint32_t CS0WCR, CS2WCR, CS3WCR, CS5aWCR;
+};
+
+/* Queries the clock setting from the hardware. */
+void cpg_get_overclock_setting(struct cpg_overclock_setting *s);
+
+/* Applies the specified overclock setting. */
+void cpg_set_overclock_setting(struct cpg_overclock_setting const *s);
 
 //---
 //	Sleep functions
@@ -72,4 +173,8 @@ void sleep_us_spin(uint64_t delay_us);
 /* sleep_ms(): Sleep for a fixed duration in milliseconds */
 #define sleep_ms(delay_ms) sleep_us((delay_ms) * 1000ull)
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GINT_CLOCK */

include/gint/config.h.in

@@ -16,10 +16,18 @@
      0x03f7c0a0 = Commit 3f7c0a0 */
 #define GINT_HASH 0x@GINT_GIT_HASH@
 
-/* GINT_USER_VRAM: Selects whether to store VRAMs in the user stack (occupying
-   350k/512k of the area) or in the system stack (the default). (fx-CG 50) */
+/* 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
+
+/* GINT_USER_VRAM: Selects whether to store VRAMs in the user stack or in the
+   OS stack. Deprecated, now controlled by GINT_NO_OS_STACK. (fx-CG 50) */
 #cmakedefine GINT_USER_VRAM
 
+#ifdef GINT_USER_VRAM
+# define GINT_NO_OS_STACK
+#endif
+
 /* GINT_STATIC_GRAY: Selects whether additional gray VRAMs are allocated
    statically or in the system heap (fx-9860G) */
 #cmakedefine GINT_STATIC_GRAY
@@ -30,4 +38,7 @@
    enabled or disabled at runtime. */
 #cmakedefine GINT_KMALLOC_DEBUG
 
+/* GINT_USB_DEBUG: Selects whether USB debug functions are enabled */
+#cmakedefine GINT_USB_DEBUG
+
 #endif /* GINT_CONFIG */

include/gint/cpu.h

@@ -5,6 +5,10 @@
 #ifndef GINT_CPU
 #define GINT_CPU
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #include <gint/defs/types.h>
 
 //---
@@ -107,6 +111,36 @@ void sleep_block(void);
 /* sleep_unblock(): Cancel a processor sleep block */
 void sleep_unblock(void);
 
+//---
+// Interrupt-cancellable sleeps
+//
+// The sleep() function has the significant drawback of not synchronizing with
+// interrupts. Programs usually run [while(<interrupt not occurred>) sleep()],
+// which fails if the interrupt occurs between the time the condition is
+// checked and time the sleep instruction is executed.
+//
+// Interrupt-cancellable sleep is a software mechanism by which the interrupt
+// disables the sleep instruction itself (by replacing it with a nop), which
+// ensures that the CPU cannot go to sleep after the interrupt occurs.
+//---
+
+/* cpu_csleep_t: A cancellable sleep function
+   This object holds sleep code that can be disabled by an interrupt. The size
+   and layout of this variable is dependent on some assembler code. This should
+   be allocated on the stack, heap, or on-chip memory, because the data segment
+   is not executable! */
+typedef GALIGNED(4) uint8_t cpu_csleep_t[20];
+
+/* cpu_csleep_init(): Create an ICS function
+   This function initializes the provided ICS routine. */
+void cpu_csleep_init(cpu_csleep_t *ics);
+
+/* cpu_csleep(): Run the sleep function until the sleep is cancelled */
+void cpu_csleep(cpu_csleep_t *ics);
+
+/* cpu_csleep_cancel(): Cancel the sleep function from within an interrupt */
+void cpu_csleep_cancel(cpu_csleep_t *ics);
+
 //---
 // Configuration
 //---
@@ -117,4 +151,8 @@ void sleep_unblock(void);
    configure(), this is reset to 0. */
 void cpu_configure_VBR(uint32_t VBR);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GINT_CPU */

include/gint/defs/attributes.h

@@ -10,12 +10,13 @@
 /* Objects from the gint's uninitialized BSS section */
 #define GBSS		__attribute__((section(".gint.bss")))
 /* Additional sections that are only needed on SH3 */
+#define GRODATA3	__attribute__((section(".gint.rodata.sh3")))
 #define GDATA3		__attribute__((section(".gint.data.sh3")))
 #define GBSS3		__attribute__((section(".gint.bss.sh3")))
 /* Objects for the ILRAM, XRAM and YRAM regions */
 #define GILRAM		__attribute__((section(".ilram")))
-#define GXRAM		__attribute__((section(".xram")))
-#define GYRAM		__attribute__((section(".yram")))
+#define GXRAM		__attribute__((section(".xyram")))
+#define GYRAM		__attribute__((section(".xyram")))
 
 /* Unused parameters or variables */
 #define GUNUSED		__attribute__((unused))

include/gint/defs/call.h

@@ -11,6 +11,10 @@
 #ifndef GINT_DEFS_CALL
 #define GINT_DEFS_CALL
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /* gint_call_arg_t: All types of arguments allowed in an indirect call
 
    Because a function call cannot be easily pieced together, there are
@@ -111,19 +115,31 @@ typedef struct {
    * error: cast to union type from type not present in union
      -> This is emitted if you pass a parameter of an invalid type. */
 #define GINT_CALL(func, ...) \
-	((gint_call_t){ .function = func, .args = { \
+	((gint_call_t){ .function = (void *)func, .args = { \
 		__VA_OPT__(GINT_CALL_ARGS1(__VA_ARGS__)) \
 	}})
 #define GINT_CALL_ARGS1(a1, ...) \
-	(gint_call_arg_t)(a1), __VA_OPT__(GINT_CALL_ARGS2(__VA_ARGS__))
+	GINT_CALL_ARG(a1), __VA_OPT__(GINT_CALL_ARGS2(__VA_ARGS__))
 #define GINT_CALL_ARGS2(a2, ...) \
-	(gint_call_arg_t)(a2), __VA_OPT__(GINT_CALL_ARGS3(__VA_ARGS__))
+	GINT_CALL_ARG(a2), __VA_OPT__(GINT_CALL_ARGS3(__VA_ARGS__))
 #define GINT_CALL_ARGS3(a3, ...) \
-	(gint_call_arg_t)(a3), __VA_OPT__(GINT_CALL_ARGS4(__VA_ARGS__))
+	GINT_CALL_ARG(a3), __VA_OPT__(GINT_CALL_ARGS4(__VA_ARGS__))
 #define GINT_CALL_ARGS4(a4, ...) \
 	({ __VA_OPT__(_Static_assert(0, \
 		"GINT_CALL: too many arguments (maximum 4)");) \
-	(gint_call_arg_t)(a4); })
+	GINT_CALL_ARG(a4); })
+
+#ifdef __cplusplus
+ /* Kind of ugly but I don't have super cool templated logic right now.
+    TODO: Allow any 4-byte type using C++ magic. */
+ #define GINT_CALL_ARG(expr) ({ \
+ 	auto __arg = (expr); \
+ 	(*reinterpret_cast<gint_call_arg_t *>(&__arg)); \
+ })
+#else
+ /* GCC extension: Cast to union */
+ #define GINT_CALL_ARG(expr) (gint_call_arg_t)(expr)
+#endif
 
 /* GINT_CALL_NULL: Empty function call */
 #define GINT_CALL_NULL ((gint_call_t){ .function = NULL, .args = {} })
@@ -131,8 +147,14 @@ typedef struct {
 /* gint_call(): Perform an indirect call */
 static GINLINE int gint_call(gint_call_t cb)
 {
+#ifdef __cplusplus
+	int (*f)(int r4, int r5, int r6, int r7) = (decltype(f))cb.function;
+#else
 	int (*f)(int r4, int r5, int r6, int r7) = cb.function;
-	return f(cb.args[0].i, cb.args[1].i, cb.args[2].i, cb.args[3].i);
+#endif
+
+        gint_call_arg_t *args = cb.args;
+	return f ? f(args[0].i, args[1].i, args[2].i, args[3].i) : -1;
 }
 
 //---
@@ -195,4 +217,8 @@ static GINLINE gint_call_t GINT_CALL_INC_STOP(int volatile *pointer)
 	return GINT_CALL(GINT_CALL_INC_STOP_function, pointer);
 }
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GINT_DEFS_CALL */

include/gint/defs/timeout.h

@@ -0,0 +1,36 @@
+//---
+// gint:defs:timeout - RTC-based timeouts
+//
+// This header provides an interface for simplistic timers used for timeout
+// waiting. Currently they are based on the RTC with a resolution of 1/128 s.
+//---
+
+#ifndef GINT_DEFS_TIMEOUT
+#define GINT_DEFS_TIMEOUT
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <time.h>
+#include <stdbool.h>
+
+/* Object holding information about a timeout (specifically, when it expires).
+   TODO: timeout: consider using a struct timespec with clock_gettime()? */
+typedef clock_t timeout_t;
+
+static inline timeout_t timeout_make_ms(int ms)
+{
+    return clock() + (int64_t)ms * CLOCKS_PER_SEC / 1000;
+}
+
+static inline bool timeout_elapsed(timeout_t const *t)
+{
+    return t && clock() >= *t;
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* GINT_DEFS_TIMEOUT */

include/gint/defs/types.h

@@ -13,13 +13,13 @@
 #include <stdint.h>
 /* For human-readable boolean types */
 #include <stdbool.h>
+/* Common system types: ssize_t, off_t, etc. */
+#include <sys/types.h>
+/* For va_list */
+#include <stdarg.h>
 
 /* Fixed-width types for bit fields are quite meaningless */
 typedef unsigned int uint;
-/* Signed size_t */
-typedef signed int ssize_t;
-/* Offset in file (used in standard functions) */
-typedef unsigned int off_t;
 
 //---
 //	Structure elements

include/gint/defs/util.h

@@ -14,6 +14,11 @@
 #define GAUTOTYPE __auto_type
 #endif
 
+#ifdef __cplusplus
+#include <algorithm>
+using std::min;
+using std::max;
+#else
 /* min(), max() (without double evaluation) */
 #define	min(a, b) ({			\
 	GAUTOTYPE _a = (a);		\
@@ -25,6 +30,7 @@
 	GAUTOTYPE _b = (b);		\
 	_a > _b ? _a : _b;		\
 })
+#endif
 
 /* sgn() (without double evaluation) */
 #define	sgn(s) ({			\

include/gint/display-cg.h

@@ -1,11 +1,15 @@
 //---
-//	gint:display-cg - fxcg50 rendering functions
+// gint:display-cg - fx-CG 50 rendering functions
 //
-//	This module covers all 16-bit opaque rendering functions. For
-//	gamma-related functions, color composition, check out a color library.
+// This module covers rendering functions specific to the fx-CG 50. In addition
+// to triple-buffering management, this mainly includes image manipulation
+// tools as well as the very versatile dimage_effect() and dsubimage_effect()
+// functions that support high-performance image rendering with a number of
+// geometric and color effects.
 //
-//	All the functions in this module work on a 396x224 resolution - gint
-//	lets you use the full surface!
+// The fx-CG OS restricts the display to a 384x216 rectangle rougly around the
+// center, leaving margins on three sides. However, gint configures the display
+// to use the full 396x224 surface!
 //---
 
 #ifndef GINT_DISPLAY_CG
@@ -13,7 +17,12 @@
 
 #ifdef FXCG50
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #include <gint/defs/types.h>
+#include <gint/image.h>
 
 /* Dimensions of the VRAM */
 #define DWIDTH 396
@@ -53,67 +62,35 @@ enum {
    green is not used). */
 #define C_RGB(r,g,b) (((r) << 11) | ((g) << 6) | (b))
 
-//---
-//	Image rendering (bopti)
-//---
+/* See <gint/image.h> for the details on image manipulation. */
+typedef image_t bopti_image_t;
 
-/* bopti_image_t: Image files encoded for bopti
-   This format is created by the fxSDK's [fxconv] tool from standard images. */
-typedef struct
-{
-	/* Color profile (type of palette), could be extended into a bit field
-	   later on */
-	uint16_t profile;
-
-	/* Color code assigned to transparent pixels (unused in 16-bit) */
-	uint16_t alpha;
-
-	/* Full width and height, in pixels */
-	uint16_t width;
-	uint16_t height;
-
-	/* Color palette:
-	   * 16-bit and 16-bit alpha: none
-	   * 8-bit: 256 colors (total 512 bytes)
-	   * 4-bit: 16 colors (total 32 bytes)
-	   Then raw pixel data in row-major order. */
-	uint16_t data[];
-
-} GPACKED(4) bopti_image_t;
-
-/* Old alias to image_t, now deprecated because of libimg */
-typedef bopti_image_t image_t __attribute__((deprecated(
-	"image_t has been renamed to bopti_image_t")));
 
 //---
 //	Video RAM management
 //---
 
-/* dsetvram() - Control video RAM address and triple buffering
+/* dsetvram(): Control video RAM address and triple buffering
 
    Normal rendering under gint uses double-buffering: there is one image
    displayed on the screen and one in memory, in a region called the video RAM
    (VRAM). The application draws frames in the VRAM then sends them to the
    screen only when they are finished, using dupdate().
 
-   On fxcg50, the performance bottleneck is almost always the graphical
-   rendering (especially in games) because the high amount of data, 173 kB per
-   frame in full-resolution, makes graphics manipulation computationally
-   expensive. The transfer also takes about 10 ms in itself.
+   On fx-CG, sending frames with dupdate() is a common bottleneck because it
+   takes about 11 ms. Fortunately, while the DMA is sending the frame to the
+   display, the CPU is available to do work in parallel. This function sets up
+   triple buffering (ie. a second VRAM) so that the CPU can start working on
+   the next frame while the DMA is sending the current one.
 
-   Since gint transfers data to the screen using the DMA, it is possible to run
-   the application while the finished frame is being transferred. However,
-   writing to the VRAM during this period will cause display artifacts since
-   the VRAM it is still being read by the DMA.
+   However, experience shows minimal performance improvements, because writing
+   to main RAM does not parallelize with DMA transfers. Since gint 2.8, this
+   is no longer the default, and the memory for the extra VRAM is instead
+   available via malloc().
 
-   The solution to this is to use triple-buffering with the display and two
-   VRAMs that are alternately being written to while the other is being
-   transferred. The VRAM switching is handled by dupdate() and is activated
-   whenever two VRAMs are configured.
-
-   By default gint uses triple buffering with two VRAMs in the system stack.
-
-   VRAMs must be contiguous, 32-aligned, (2*396*224)-byte buffers.
+   VRAMs must be contiguous, 32-aligned, (2*396*224)-byte buffers with 32 bytes
+   of extra data on each side (ie. 32 bytes into a 32-aligned buffer of size
+   177472).
 
    @main       Main VRAM area, used alone if [secondary] is NULL
    @secondary  Additional VRAM area, enables triple buffering if non-NULL */
@@ -123,6 +100,10 @@ void dsetvram(uint16_t *main, uint16_t *secondary);
    Returns the VRAM buffer addresses used to render on fx-CG 50. */
 void dgetvram(uint16_t **main, uint16_t **secondary);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* FXCG50 */
 
 #endif /* GINT_DISPLAY_CG */

include/gint/display-fx.h

@@ -11,6 +11,10 @@
 
 #ifdef FX9860G
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #include <gint/defs/types.h>
 
 /* Dimensions of the VRAM */
@@ -83,6 +87,10 @@ typedef struct
 
 } GPACKED(4) bopti_image_t;
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* FX9860G */
 
 #endif /* GINT_DISPLAY_FX */

include/gint/display.h

@@ -9,7 +9,12 @@
 #ifndef GINT_DISPLAY
 #define GINT_DISPLAY
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #include <gint/defs/types.h>
+#include <gint/defs/call.h>
 
 /* Platform-specific functions include VRAM management and the definition of
    the color_t type. */
@@ -22,8 +27,6 @@
 #include <gint/display-cg.h>
 #endif
 
-/* TODO: dinfo() or similar */
-
 //---
 //	Video RAM management
 //---
@@ -58,6 +61,50 @@
    fx-CG 50: 11 ms */
 void dupdate(void);
 
+/* dupdate_set_hook(): Define a function to be called after each dupdate()
+
+   This functions configures the update hook, which is called after each
+   dupdate() has sent VRAM to the display (but before VRAMs are switched when
+   triple-buffering is used on fx-CG 50).
+
+   The hook is mostly useful to send a copy of the frame to another medium,
+   typically through a USB connection to a projector-style application. See
+   usb_fxlink_videocapture() in <gint/usb-ff-bulk.h> for an example.
+
+   The function is an indirect call; create one with the GINT_CALL() macro from
+   <gint/defs/call.h>. Pass GINT_CALL_NULL to disable the feature.
+
+   @function  Indirect call to perform after each dupdate(). */
+void dupdate_set_hook(gint_call_t function);
+
+/* dupdate_get_hook(): Get a copy of the dupdate() hook */
+gint_call_t dupdate_get_hook(void);
+
+//---
+// Rendering mode control
+//---
+
+/* dmode: Rendering mode settings
+
+   This structure indicates the current window settings. Rendering is limited
+   to the rectangle spanning from (left,top) included, to (right,bottom)
+   excluded. The default is from (0,0) to (DWIDTH,DHEIGHT). */
+struct dwindow {
+   int left, top;
+   int right, bottom;
+};
+extern struct dwindow dwindow;
+
+/* dwindow_set(): Set the rendering window
+
+   This function changes [dwindow] settings to limit rendering to a sub-surface
+   of the VRAM. Note that this doesn't change the coordinate system; the pixel
+   at (DWIDTH/2, DHEIGHT/2) is always in the middle of the screen regardless of
+   the window setting. However, it might be masked out by the window.
+
+   Returns the old dwindow settings (if it needs to be restored later). */
+struct dwindow dwindow_set(struct dwindow new_mode);
+
 //---
 //	Area rendering functions
 //---
@@ -127,6 +174,11 @@ void drect_border(int x1, int y1, int x2, int y2,
    *: When the gray engine is on, see dgray(). */
 void dpixel(int x, int y, int color);
 
+/* dgetpixel(): Get a pixel's color
+   Returns the current color of any pixel in the VRAM. This function ignores
+   the rendering window. Returns -1 if (x,y) is out of bounds. */
+int dgetpixel(int x, int y);
+
 /* dline(): Render a straight line
 
    This function draws a line using a Bresenham-style algorithm. Please note
@@ -398,4 +450,8 @@ enum {
 void dsubimage(int x, int y, bopti_image_t const *image, int left, int top,
 	int width, int height, int flags);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GINT_DISPLAY */

include/gint/dma.h

@@ -5,6 +5,10 @@
 #ifndef GINT_DMA
 #define GINT_DMA
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #include <gint/defs/types.h>
 #include <gint/defs/call.h>
 
@@ -117,4 +121,8 @@ void *dma_memset(void *dst, uint32_t pattern, size_t size);
 void *dma_memcpy(void * __restrict dst, const void * __restrict src,
    size_t size);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GINT_DMA */

include/gint/drivers.h

@@ -5,6 +5,10 @@
 #ifndef GINT_DRIVERS
 #define GINT_DRIVERS
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #include <gint/defs/attributes.h>
 #include <gint/defs/types.h>
 
@@ -300,4 +304,8 @@ void gint_world_switch_in(gint_world_t world_os, gint_world_t world_addin);
 /* Switch from a gint-managed world to the OS world */
 void gint_world_switch_out(gint_world_t world_addin, gint_world_t world_os);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GINT_DRIVERS */

include/gint/drivers/asyncio.h

@@ -0,0 +1,293 @@
+//---
+// gint:usb:asyncio - Asynchronous I/O common definitions
+//---
+
+#ifndef GINT_USB_ASYNCIO
+#define GINT_USB_ASYNCIO
+
+#include <gint/defs/types.h>
+#include <gint/defs/call.h>
+
+/* Data tracking the progress of a multi-part multi-round async I/O operation.
+
+   * Writes are multi-part because they are constructed over several calls to
+     write(2) followed by a "commit" with fynsc(2). They are additionally
+     multi-round because each call to write(2) requires mutiple rounds of
+     hardware communication when the hardware buffer is smaller than the data.
+
+   * Reads are multi-part because each transaction from the host requires
+     several calls to read(2) ("user segments") if the user's buffer is shorter
+     than the full transaction. In addition, reads are multi-round because a
+     single read(2) to a user buffer takes multiple rounds of hardware
+     communication ("hardware segments") whenever the user buffer is larger
+     than the hardware buffer.
+
+   The process of performing such an I/O operation, as tracked by this
+   structure and use throughout gint, is as follows.
+
+   ## Writes
+
+                                   WRITING ---------------------.
+                                     ^ |                        | HW buffer
+                       Start writing | | Not full               | full: start
+                                     | |                        | transmission
+                     write(2)        | v                        v
+      --> IDLE ------------------> PENDING <------------- FLYING-WRITE
+           ^                         ^ |   DONE interrupt
+           | DONE           write(2) | |
+           | interrupt               | |
+           |                         | | Data exhausted
+           |     fsync(2): start     | v
+      FLYING-SYNC <------------ IN-PROGRESS
+                   transmission
+
+   Initially the operation is in the IDLE state. When a write(2) is issued, it
+   interacts with hardware then transitions to the IN-PROGRESS state, where it
+   remains for any subsequent write(2). A fsync(2) will properly commit data to
+   the hardware, finish the operation and return to the IDLE state.
+
+   The FLYING-WRITE and FLYING-SYNC states refer to waiting periods, after
+   issuing hardware commands, during which hardware communicates. Usually an
+   interrupt signals when hardware is ready to resume work.
+
+   Note that in a series of write(2), hardware is only instructed to send data
+   once the hardware buffer is full. Therefore, a write(2) might transition
+   directly from IDLE or IN-PROGRESS, to PENDING, to IN-PROGRESS, without
+   actually communicating with the outside world.
+
+   An asynchronous write(2) might return to the caller as soon as writing is
+   finished even if the operation is left in the FLYING-WRITE state, and it may
+   even return while the operation is in the WRITING state if the DMA is used.
+
+   The invariants and meaning for each state are as follow:
+
+   State(s)       Characterization             Description
+   ============================================================================
+   IDLE           type == ASYNCIO_NONE         No I/O operation
+   ----------------------------------------------------------------------------
+   PENDING        data_w && round_size == 0    Ready to write pending data
+   ----------------------------------------------------------------------------
+   WRITING,       round_size > 0               CPU/DMA write to HW in progress
+   FLYING-WRITE                                HW transmission in progress
+   ----------------------------------------------------------------------------
+   IN-PROGRESS    !data_w && type == WRITE     Waiting for write(2) or fsync(2)
+   ----------------------------------------------------------------------------
+   FLYING-SYNC    type == ASYNCIO_SYNC         HW commit in progress
+   ============================================================================
+
+   The series of asyncio_op function calls for a write is as follows:
+
+     transaction ::= write* fsync
+     write ::= asyncio_op_start_write round+ asyncio_op_finish_write
+     round ::= asyncio_op_start_write_round asyncio_op_finish_write_round
+     fsync ::= asyncio_op_start_sync asyncio_op_finish_sync
+
+   Each write(2) (with a single user-provided buffer) is split into multiple
+   rounds that each fill the (small) hardware buffer. More writes can follow
+   until an fynsc(2) commits the pipe.
+
+   ## Reads
+
+                     IN interrupt
+     --> IDLE-EMPTY --------------> IDLE-READY
+             |  \               read(2) | ^
+     read(2) |   \ Transaction          | | User buffer
+             |    \ exhausted*          | | filled
+             |     '----<----------.    | |
+             |                      \   | |
+             |       IN interrupt    \  | |
+             v   .--------->--------. \ v | .---.  Read from
+          WAITING                    READING     v hardware
+                 '---------<--------'       '---'
+               HW buffer exhausted with
+                 user buffer not full
+
+   On this diagram, the right side indicates the presence of data to read from
+   hardware while the bottom side indicates a read(2) request by the user.
+   Notice the diagonal arrow back to IDLE-EMPTY insteaf of WAITING, which
+   highlights that read(2) will always return at the end of a transaction even
+   if the user-provided buffer is not full (to avoid waiting).
+
+   A read(2) request (a "user segment") might consume several full hardware
+   buffers ("hardware segments") if the user buffer is large, thus looping
+   repeatedly between WAITING and READING. Conversely, each hardware segment
+   might fulfill many read(2) requests if the user buffer is small, thus
+   looping between IDLE-READY and READING.
+
+   * Note that if the transaction finishes right as the user buffer fills up,
+   we return to IDLE-READY and the next call to read(2) will successfully read
+   0 bytes and transition back to IDLE-EMPTY. This allows the user to read the
+   entire transaction by reading data until they get fewer bytes than requested
+   without running the risk of blocking on the next transaction.
+
+   The invariants and meaning for each state are as follow. The right side
+   (presence of a hardware segment) is indicated by `buffer_used >= 0`, while
+   the bottom side (presence of a read(2) request) is indicated by `size > 0`.
+   As an exception, IDLE-EMPTY uses `buffer_used == 0` so that the default
+   zero-initialization of transfer data is sufficient.
+
+   State          Invariant characterization   Description
+   ============================================================================
+   IDLE-EMPTY     type == ASYNCIO_NONE         No I/O operation, the pipe is
+                  && buffer_used == 0          idle with no request and no
+                  && size == 0                 hardware segment (but we might
+                  && round_size == 0           still be mid-transaction)
+   ----------------------------------------------------------------------------
+   IDLE-READY     type == ASYNCIO_READ         There is a hardware segment not
+                  && buffer_used >= 0          marked as complete, but no
+                  && size == 0                 read(2) request to consume it
+                  && round_size == 0
+   ----------------------------------------------------------------------------
+   WAITING        type == ASYNCIO_READ         There is a read(2) request but
+                  && buffer_used < 0           no hardware segment, and either
+                  && size > 0                  the request is new or the
+                  && round_size == 0           transaction isn't exhausted
+   ----------------------------------------------------------------------------
+   READING        type == ASYNCIO_READ         A read round in progress and
+                  && buffer_used >= 0          either the read(2) request or
+                  && size > 0                  hardware segment will be
+                  && round_size > 0            exhausted when it ends
+   ============================================================================
+
+   The series of asyncio_op function calls for a read is a bit more complicated
+   because transactions are divided into two non-comparable sequences of
+   segments: one for packets received by the hardware buffer (on BRDY), one for
+   the data being copied to user buffers (on read(2)).
+
+   |<------ Transaction from the host (no size limit) ------>|
+
+   v BRDY      v BRDY      v BRDY      v BRDY      v BRDY
+   +-----------+-----------+-----------+-----------+---------+
+   | HW buffer | HW buffer | HW buffer | HW buffer | (short) |  HW segments
+   +-----------+------+----+-----------+-----------+---------+
+   | R1        | R2   | R3 | R4        | R5        | R6      |  Read rounds
+   +-----------+------+----+-----------+-----------+---------+
+   | User buffer #1   |  User buffer #2            | (short) |  User segments
+   +------------------+----------------------------+---------+
+   ^ read(2)          ^ read(2)                    ^ read(2)
+
+   Reads rounds are exactly the intersections between hardware segments and
+   read(2) user segments.
+
+   States can be checked and transitioned with the API functions below. */
+
+enum { ASYNCIO_NONE, ASYNCIO_READ, ASYNCIO_WRITE, ASYNCIO_SYNC };
+
+typedef volatile struct
+{
+    /* Type of I/O operation (NONE/WRITE/SYNC/READ) */
+    uint8_t type;
+    /* Whether the DMA should be used for hardware access */
+    bool dma            :1;
+    /* For reading pipes, whether the transaction is expected to continue with
+       another hardware segment after the current one */
+    bool cont_r         :1;
+    /* For reading pipes, interrupt flag signaling an incoming hardware segment
+       not yet added to the operation */
+    bool interrupt_r    :1;
+    /* For reading pipes, whether the current read call should close the
+       current hardware segment if all the data is read even if the read call
+       is not partial */
+    bool autoclose_r    :1;
+    /* Hardware resource being used for access (meaning depends on hardware).
+       Usually, this is assigned for the duration of hardware transaction.
+       This value is user-managed and not modified by asyncio_op functions. */
+    uint8_t controller;
+
+    /* Number of bytes in short buffer (0..3) */
+    uint8_t shbuf_size;
+    /* Short buffer */
+    uint32_t shbuf;
+
+    /* Size of data currently in the hardware buffer */
+    int16_t buffer_used;
+    /* Size of data being read/written in the current round (which may itself
+       be asynchronous if it's using the DMA) */
+    uint16_t round_size;
+
+    union {
+        /* Address of data to transfer, incremented gradually [write] */
+        void const *data_w;
+        /* Address of buffer to store data to, incremented gradually [read] */
+        void *data_r;
+    };
+    /* Size of data left to transfer to satisfy the complete request */
+    int size;
+    /* For reading operations, pointer to total amount of transferred data */
+    int *realized_size_r;
+    /* Callback at the end of the current write, final commit, or read */
+    gint_call_t callback;
+
+} asyncio_op_t;
+
+//---
+// Initialization and query functions
+//---
+
+/* asyncio_op_clear(): Initialize/clear the storage for an I/O operation */
+void asyncio_op_clear(asyncio_op_t *op);
+
+/* asyncio_op_busy(): Check whether the transfer is busy for syscalls
+
+   This function checks whether the transfer is in a state where the CPU is
+   busy wrt. starting a new syscall, ie. read(2), write(2) or fsync(2). Returns
+   true if the CPU is busy and the call has to wait, false if the call can
+   proceed immediately. */
+bool asyncio_op_busy(asyncio_op_t const *op);
+
+//---
+// I/O functions
+//---
+
+/* Start/finish a write(2) call. */
+void asyncio_op_start_write(asyncio_op_t *op,
+    void const *data, size_t size, bool use_dma, gint_call_t const *callback);
+void asyncio_op_finish_write(asyncio_op_t *op);
+
+/* Start/finish a single-block write to hardware. */
+void asyncio_op_start_write_round(asyncio_op_t *op, size_t size);
+void asyncio_op_finish_write_round(asyncio_op_t *op);
+
+/* Start an fsync(2) operation (after one or more writes) and finish it. */
+void asyncio_op_start_sync(asyncio_op_t *op, gint_call_t const *callback);
+void asyncio_op_finish_sync(asyncio_op_t *op);
+
+/* Start a read(2) call. The call will finish automatically when the final
+   round finishes. If `autoclose` is set, the current hardware segment will
+   be marked as completed if the round reads it entirely, even if the request
+   is fulfilled. */
+void asyncio_op_start_read(asyncio_op_t *op, void *data, size_t size,
+    bool use_dma, int *realized_size, bool autoclose,
+    gint_call_t const *callback);
+
+/* Start a hardware segment. `cont` should be true if there will be another
+   segment in the same transaction. The segment will finish automatically when
+   it is completely consumed by a read round. */
+void asyncio_op_start_read_hwseg(asyncio_op_t *op, size_t size, bool cont);
+
+bool asyncio_op_has_read_call(asyncio_op_t const *op);
+
+bool asyncio_op_has_read_hwseg(asyncio_op_t const *op);
+
+/* Start a single-block read from hardware. The requested size is automatically
+   t->size, however the round may of course be smaller depending on how much
+   data is available. Returns the round size. */
+int asyncio_op_start_read_round(asyncio_op_t *op);
+
+enum {
+    ASYNCIO_HWSEG_EXHAUSTED = 0x01,
+    ASYNCIO_REQUEST_FINISHED = 0x02,
+    ASYNCIO_TRANSACTION_EXHAUSTED = 0x04,
+};
+
+/* Finish a single-block read from hardware. This function also finishes the
+   current hardware segment and read call if appropriate, *except* that it
+   doesn't invoke the read(2) callback. You should make a copy of it before
+   calling and invoke it manually after. Returns a combination of the above
+   flags indicating what finished along with the round. */
+int asyncio_op_finish_read_round(asyncio_op_t *op);
+
+/* Cancel a read call. This keeps the hardware segment part intact. */
+void asyncio_op_cancel_read(asyncio_op_t *op);
+
+#endif /* GINT_USB_ASYNCIO */

include/gint/drivers/iokbd.h

@@ -7,6 +7,10 @@
 #ifndef GINT_DRIVERS_IOKBD
 #define GINT_DRIVERS_IOKBD
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #include <gint/defs/types.h>
 
 /* iokbd_scan() - scan ports A/B/M to generate 12 rows of key data
@@ -14,4 +18,8 @@
    @scan  12-byte buffer filled with row data */
 void iokbd_scan(uint8_t *scan);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GINT_DRIVERS_IOKBD */

include/gint/drivers/keydev.h

@@ -2,27 +2,19 @@
 //	gint:keydev - Kernel's keyboard input devices
 //---
 
-#include <gint/keyboard.h>
-
 #ifndef GINT_KEYDEV
 #define GINT_KEYDEV
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <gint/keyboard.h>
+#include <stdbool.h>
+
 /* Size of the buffer event queue */
 #define KEYBOARD_QUEUE_SIZE 32
 
-/* keydev_event_t: Change of state in a full row */
-typedef struct {
-	/* Device time for the event */
-	uint16_t time;
-	/* Keys that changed state */
-	uint8_t changed;
-	/* Row number */
-	uint8_t row :4;
-	/* Type of change, either KEYEV_DOWN or KEYEV_UP */
-	uint8_t kind :4;
-
-} keydev_event_t;
-
 /* Event transforms
 
    Every keyboard input device has a built-in event stream editor that can
@@ -80,14 +72,26 @@ typedef struct {
 enum {
 	/* Delayed SHIFT: Pressing then immediately releasing SHIFT when the
 	   keyboard is idle applies SHIFT to the next repeat streak. */
-	KEYDEV_TR_DELAYED_SHIFT    = 0x01,
+	KEYDEV_TR_DELAYED_SHIFT    = 0x01, /* = GETKEY_MOD_SHIFT */
 	/* Delayed ALPHA: Idem with the ALPHA key */
-	KEYDEV_TR_DELAYED_ALPHA    = 0x02,
+	KEYDEV_TR_DELAYED_ALPHA    = 0x02, /* = GETKEY_MOD_ALPHA */
+	/* Combination of the delayed modifiers */
+	KEYDEV_TR_DELAYED_MODS     = KEYDEV_TR_DELAYED_SHIFT
+	                           | KEYDEV_TR_DELAYED_ALPHA,
+
 	/* Instant SHIFT: Each individual event of every repeat streak gets
 	   SHIFT applied if SHIFT is pressed at the time of the repeat. */
 	KEYDEV_TR_INSTANT_SHIFT    = 0x04,
 	/* Instant ALPHA: Idem with the ALPHA key */
 	KEYDEV_TR_INSTANT_ALPHA    = 0x08,
+	/* Combination of the instance modifiers */
+	KEYDEV_TR_INSTANT_MODS     = KEYDEV_TR_INSTANT_SHIFT
+	                           | KEYDEV_TR_INSTANT_ALPHA,
+
+	/* Combination of all modifiers */
+	KEYDEV_TR_ALL_MODS         = KEYDEV_TR_DELAYED_MODS
+	                           | KEYDEV_TR_INSTANT_MODS,
+
 	/* Repeats: Keys are repeated according to a repeat filter function */
 	KEYDEV_TR_REPEATS          = 0x10,
 	/* Delete Modifiers: Remove modifier keys from generated events, which
@@ -97,6 +101,9 @@ enum {
 	KEYDEV_TR_DELETE_RELEASES  = 0x40,
 };
 
+/* keydev_repeat_profile_t: Function deciding when and how to repeat keys. */
+typedef int (*keydev_repeat_profile_t)(int key, int duration, int count);
+
 /* keydev_transform_t: Full specification for transforms on the event stream */
 typedef struct {
 	/* List of enabled transforms. The order is cannot be changed because
@@ -118,10 +125,13 @@ typedef struct {
 	   that the precision of the delay is limited by the speed at which the
 	   keyboard is scanned, which is nowhere near microsecond-level. By
 	   default (128 Hz) the precision is about 7.8 ms. */
-	int (*repeater)(int key, int duration, int count);
+	keydev_repeat_profile_t repeater;
 
 } GPACKEDENUM keydev_transform_t;
 
+/* keydev_async_filter_t: Low-level asynchronous event filter. */
+typedef bool (*keydev_async_filter_t)(key_event_t event);
+
 /* keydev_t: Keyboard device
 
    This structure represents the state and settings of a keyboard device that
@@ -129,9 +139,9 @@ typedef struct {
    is useful for demo/replays that input events without the physical keyboard,
    and a couple of corner uses like control over USB.
 
-   The keyboard device has built-in event transformations, which modifty the
+   The keyboard device has built-in event transformations, which modify the
    stream of events by adding information, combining modifiers, and removing
-   undesired events. Because the event transformation reky on the current state
+   undesired events. Because the event transformation rely on the current state
    of the keyboard, they must be run by the driver whenever events are read, so
    they are tied to the device.
 
@@ -139,35 +149,27 @@ typedef struct {
    keydown() are shortcuts for keydev functions using the physical keyboard as
    their input. */
 typedef struct {
-	/* Latest state of keys we are aware of. At every processing step, the
-	   different between this and the fresh information is queued and this
-	   is updated. state_now is identical to the real state obtained from
-	   the device unless earlier events failed to be queued, in which case
-	   a difference is maintained so they will be reconsidered later. */
-	GALIGNED(4) uint8_t state_now[12];
-	/* State of keys based on produced events. (state_queue + queue) is
-	   always identical to (state_now). When the queue is empty both states
-	   are the same. This is the user's view of the keyboard. */
-	GALIGNED(4) uint8_t state_queue[12];
 	/* Current device time in scanning-ticks */
 	uint time;
 	/* Last time when repeats were considered */
 	uint time_repeats;
 
-	/* Event queue (circular buffer) */
-	keydev_event_t queue[KEYBOARD_QUEUE_SIZE];
 	/* Next event in queue, position after last event in queue */
 	int8_t queue_next;
 	int8_t queue_end;
 	/* Number of events lost because of missing queue space */
 	uint events_lost;
-	/* Crafted events waiting to be picked up */
-	key_event_t out[8];
-	int out_size;
 
 	/* Event transforms */
 	keydev_transform_t tr;
 
+	/* Asynchronous event filter. This is a low-level filter which is
+	   called when events are generated to process and filter them. It
+	   provides the unique ability to run keyboard-triggered code even if
+	   the program's main thread is busy, for instance running some sort of
+	   infinite loop. */
+	keydev_async_filter_t async_filter;
+
 	// <Delayed Modifiers>
 
 	/* delayed_* is set when the delayed modifier is active (after a press/
@@ -182,13 +184,29 @@ typedef struct {
 
 	/* Candidate key for repeats (or 0 if no key is candidate yet) */
 	int rep_key;
-	/* Number of repeats alreay sent */
+	/* Number of repeats already sent */
 	int rep_count;
 	/* Time since key was first pressed (us) */
 	int rep_time;
 	/* Delay until next repeat, set by the repeat planner (us) */
 	int rep_delay;
 
+	/* Latest state of keys we are aware of. At every processing step, the
+	   difference between this and the fresh information is queued and this
+	   is updated. state_now is identical to the real state obtained from
+	   the device unless earlier events failed to be queued, in which case
+	   a difference is maintained so they will be reconsidered later. */
+	GALIGNED(4) uint8_t state_now[12];
+	/* State of keys based on produced events. (state_queue + queue) is
+	   always identical to (state_now). When the queue is empty both states
+	   are the same. This is the user's view of the keyboard. */
+	GALIGNED(4) uint8_t state_queue[12];
+	/* Event queue (circular buffer) */
+	key_event_t queue[KEYBOARD_QUEUE_SIZE];
+
+	/* Parameters for the standard repeat function */
+	int rep_standard_first, rep_standard_next;
+
 } keydev_t;
 
 /* keydev_std(): Standard keyboard input device
@@ -214,6 +232,12 @@ void keydev_process_state(keydev_t *d, uint8_t state[12]);
    devices (such as demo replays) to feed in new events. */
 void keydev_process_key(keydev_t *d, int keycode, bool state);
 
+/* keydev_repeat_event(): Generate a repeat event if applicable
+   At the end of every scan tick, this source will generate a repeat event if
+   the repeat transform is enabled and the conditions for a repeat are
+   satisfied. */
+key_event_t keydev_repeat_event(keydev_t *d);
+
 /* keydev_tick(): Prepare the next tick
    This function maintains time trackers in the device and should be called in
    each frame after the scanning is finished and the keydev_process_*()
@@ -227,24 +251,22 @@ void keydev_tick(keydev_t *d, uint us);
 
 /* keydev_unqueue_event(): Retrieve the next keyboard event in queue
 
-   This source provides the queued KEYEV_UP and KEYEV_DOWN events generated
-   from the regular scans in chronological order. It does not generate the
-   KEYEV_HOLD events though, keyev_repeat_event() must be used to obtain these
-   at the end of every tick. */
+   This source provides the queued KEYEV_UP, KEYEV_DOWN and KEYEV_HOLD events
+   generated from the regular scans in chronological order. It does not apply
+   transforms; to do this, use keydev_read(). */
 key_event_t keydev_unqueue_event(keydev_t *d);
 
-/* keydev_repeat_event(): Generate a repeat event if applicable
-
-   At the end of every scan tick (or later if the application is unable to keep
-   up), this source will generate a repeat event if the repeat transform is
-   enabled and the conditions for a repeat are satisfied. */
-key_event_t keydev_repeat_event(keydev_t *d);
-
 /* keydev_idle(): Check if all keys are released
    A list of keys to ignore can be specified as variable arguments. The list
    must be terminated by a 0 keycode. */
 bool keydev_idle(keydev_t *d, ...);
 
+/* keydev_async_filter(): Obtain current async filter */
+keydev_async_filter_t keydev_async_filter(keydev_t const *d);
+
+/* keydev_set_async_filter(): Set low-level async filter */
+void keydev_set_async_filter(keydev_t *d, keydev_async_filter_t filter);
+
 //---
 //	High-level API to read from the device
 //---
@@ -258,7 +280,35 @@ keydev_transform_t keydev_transform(keydev_t *d);
 /* keydev_set_transform(): Set transform parameters */
 void keydev_set_transform(keydev_t *d, keydev_transform_t tr);
 
-/* keydev_read(): Retrieve the next transformed event */
-key_event_t keydev_read(keydev_t *d);
+/* keydev_set_standard_repeats(): Enable a simple repeater
+
+   This function changes the [repeater] member of the devices's transform. It
+   loads the default repeat profile which applies one delay (in us) before the
+   first repeat, and then a second, usually shorter delay, between subsequent
+   repeats.
+
+   The unit of the argument is in microseconds, but the granularity of the
+   delay is dependent on the keyboard scan frequency. In the default setting
+   (128 Hz scans), the possible repeat delays are approximately 8 ms, 16 ms,
+   23 ms, 31 ms. The system default is (500 ms, 125 ms). With the 128 Hz
+   setting, this default is reached exactly without approximation. gint's
+   default is (400 ms, 40 ms) for more reactivity.
+
+   Note: Due to a current API limitation, every input device uses the delays
+   for the physical keyboard.
+
+   @first_us  Delay between key press and first repeat (microseconds)
+   @next_us   Delay between subsequent repeats (microseconds) */
+void keydev_set_standard_repeats(keydev_t *d, int first_us, int next_us);
+
+/* keydev_read(): Retrieve the next transformed event
+   If there is no event, returns an event with type KEYEV_NONE, unless
+   [wait=true], in which case waits for an event to occur or *timeout to
+   become non-zero (if timeout is not NULL), whichever comes first. */
+key_event_t keydev_read(keydev_t *d, bool wait, volatile int *timeout);
+
+#ifdef __cplusplus
+}
+#endif
 
 #endif /* GINT_KEYDEV */

include/gint/drivers/r61524.h

@@ -8,6 +8,10 @@
 #ifndef GINT_DRIVERS_R61524
 #define GINT_DRIVERS_R61524
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #include <gint/defs/types.h>
 
 enum {
@@ -31,6 +35,34 @@ enum {
    @method  Transfer method, see above */
 void r61524_display(uint16_t *vram, int start, int height, int method);
 
+/* r61524_display_rect(): Send a rectangular section of VRAM to the display
+
+   This function updates the rectangle going from (xmin,ymin) to (xmax,ymax) in
+   the VRAM to the display (both ends included). This can be faster than a full
+   dupdate() or a striped r61524_display() depending on the situation. However,
+   because the source VRAM is not contiguous, the transfer is only possible by
+   CPU, so this is only interesting for small regions.
+
+   @vram        Source VRAM with a stride of 396*2 bytes
+   @xmin @xmax  Horizontal range to be updated (both included)
+   @ymin @ymax  Vertical range to be updated (both included) */
+void r61524_display_rect(uint16_t *vram, int xmin, int xmax, int ymin,
+   int ymax);
+
+/* r61524_start_frame(): Prepare the display for a region update
+
+   This function sets up the display driver to receive graphics data to update
+   the rectangle going from (xmin,ymin) to (xmax,ymax) (both included). This is
+   the initial step of r61524_display(), which is normally followed by writing
+   all the data to 0xb4000000.
+
+   In order to write with the DMA, it is necessary to write the full horizontal
+   range and select ymin and ymax to be congruent to 0 and 3 modulo 4.
+
+   This function can be used to implement additional display driver update
+   methods or alternate rendering pipelines. */
+void r61524_start_frame(int xmin, int xmax, int ymin, int ymax);
+
 /* r162524_win_get() and r61524_win_set(): Manipulate the display window
 
    These functions change the screen rectangle where data is shown. Normally
@@ -43,4 +75,20 @@ void r61524_display(uint16_t *vram, int start, int height, int method);
 void r61524_win_get(uint16_t *HSA, uint16_t *HEA, uint16_t *VSA,uint16_t *VEA);
 void r61524_win_set(uint16_t HSA, uint16_t HEA, uint16_t VSA, uint16_t VEA);
 
+//---
+// Low-level functions
+//---
+
+/* r61524_get(): Read the value of an R61524 register
+   This is provided for testing and if you know what you're doing. */
+uint16_t r61524_get(int ID);
+
+/* r61524_set(): Write the value of an R61524 register
+   This is provided for testing and if you know what you're doing. */
+void r61524_set(int ID, uint16_t value);
+
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GINT_DRIVERS_R61524 */

include/gint/drivers/states.h

@@ -9,11 +9,18 @@
 #ifndef GINT_DRIVERS_STATES
 #define GINT_DRIVERS_STATES
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <gint/config.h>
 #include <gint/mpu/dma.h>
+#include <gint/clock.h>
 
 /* Clock Pulse Generator (see cpg/cpg.c) */
 typedef struct {
 	uint32_t SSCGCR;
+	struct cpg_overclock_setting speed;
 } cpg_state_t;
 
 /* CPU (see cpu/cpu.c) */
@@ -82,13 +89,27 @@ typedef struct {
 typedef struct {
 	/* Control and power-up. We don't save power-related registers from other
 	   modules nor UPONCR, because they must be changed to use the module */
-	uint16_t SYSCFG, DVSTCTR, TESTMODE, REG_C2;
-	/* FIFO configuration */
-	uint16_t CFIFOSEL, D0FIFOSEL, D1FIFOSEL;
+	uint16_t SYSCFG, BUSWAIT, DVSTCTR, SOFCFG, TESTMODE, REG_C2;
 	/* Interrupt configuration */
-	uint16_t INTENB0, BRDYENB, NRDYENB, BEMPENB, SOFCFG;
-	/* Default Control Pipe (maybe not needed) */
-	uint16_t DCPCFG, DCPMAXP, DCPCTR;
+	uint16_t INTENB0, INTENB1, BRDYENB, NRDYENB, BEMPENB;
+	/* Default Control Pipe */
+	uint16_t DCPMAXP;
+
+#ifdef GINT_USB_DEBUG
+	/* Registers tracked read-only for state analysis and debugging */
+	uint16_t SYSSTS, FRMNUM, UFRMNUM;
+	uint16_t CFIFOSEL, D0FIFOSEL, D1FIFOSEL, CFIFOCTR, D0FIFOCTR, D1FIFOCTR;
+	uint16_t INTSTS0, INTSTS1, BRDYSTS, NRDYSTS, BEMPSTS;
+	uint16_t DCPCFG, DCPCTR;
+	uint16_t USBADDR, USBREQ, USBVAL, USBINDX, USBLENG;
+	uint16_t PIPESEL, PIPECFG[9], PIPEnCTR[9], PIPEBUF[9];
+	/* Ignored: UPONCR, PIPEnMAXP, PIPEnPERI, PIPEnTRN, PIPEnTRE, DEVADDn */
+#endif
+
 } usb_state_t;
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GINT_DRIVERS_STATES */

include/gint/drivers/t6k11.h

@@ -7,6 +7,10 @@
 #ifndef GINT_DRIVERS_T6K11
 #define GINT_DRIVERS_T6K11
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #include <gint/defs/types.h>
 
 /* t6k11_display() - send vram data to the LCD device
@@ -51,4 +55,8 @@ void t6k11_contrast(int contrast);
    @setting  Requested backlight setting */
 void t6k11_backlight(int setting);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GINT_DRIVERS_T6K11 */

include/gint/exc.h

@@ -9,6 +9,10 @@
 #ifndef GINT_EXC
 #define GINT_EXC
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #include <gint/defs/attributes.h>
 #include <stdint.h>
 
@@ -64,4 +68,8 @@ void gint_exc_catch(int (*handler)(uint32_t code));
    @instructions  Number of instructions to skip (usually only one) */
 void gint_exc_skip(int instructions);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GINT_EXC */

include/gint/fs.h

@@ -0,0 +1,107 @@
+//---
+// gint:fs - Filesystem abstraction
+//---
+
+#ifndef GINT_FS
+#define GINT_FS
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <sys/types.h>
+#include <stddef.h>
+
+/* Maximum number of file descriptors */
+#define FS_FD_MAX 16
+
+/* fs_descriptor_type_t: Overloaded file descriptor functions
+
+   This structure provides the base functions for every type of file
+   descriptor. The prototypes are standard, except that the first argument
+   (int fd) is replaced by (void *data) which points to the custom data
+   allocator for the descriptor. */
+typedef struct {
+    /* See <unistd.h> for a description of these functions */
+    ssize_t (*read)(void *data, void *buf, size_t size);
+    ssize_t (*write)(void *data, void const *buf, size_t size);
+    off_t (*lseek)(void *data, off_t offset, int whence);
+    int (*close)(void *data);
+
+} fs_descriptor_type_t;
+
+/* fs_descriptor_t: File descriptor information
+   This internal type describes the entries of the descriptor table. */
+typedef struct {
+    /* Interface functions */
+    fs_descriptor_type_t const *type;
+    /* Custom data (can also be an integer cast to (void *)) */
+    void *data;
+
+} fs_descriptor_t;
+
+/* fs_get_descriptor(): Get a file descriptor's data
+
+   This function is used internally in order to implement read(), write(), and
+   other standard functions functions. It could be useful for other APIs that
+   want to present their resources as file descriptors but still implement
+   extra non-standard functions; this allows them to use the file descriptor as
+   input and still access the custom data.
+
+   Returns NULL if there is no file descriptor with this number, in which case
+   the caller probably needs to set errno = EBADF. */
+fs_descriptor_t const *fs_get_descriptor(int fd);
+
+/* fs_create_descriptor(): Create a new file descriptor
+
+   This function is used in open() and its variants to allocate new file
+   descriptors. The descriptor's data is created with a copy of the provided
+   structure, which must include a non-NULL type attribute.
+
+   This function always returns the smallest file descriptor that is unused by
+   the application and is not 0, 1 or 2; unless it runs out of file
+   descriptors, in which case it returns -1 and the caller might want to set
+   errno = ENFILE. */
+int fs_create_descriptor(fs_descriptor_t const *data);
+
+/* fs_free_descriptor(): Close a file descriptor's slot
+
+   This function frees the specified file descriptor. It is automatically
+   called by close() after the descriptor type's close() function, so there is
+   normally no need to call this function directly. */
+void fs_free_descriptor(int fd);
+
+/* open_generic(): Open a file descriptor using custom file functions
+
+   Opens a new file descriptor of the specified type with the provided user
+   data. If reuse_fd < 0, a new file descriptor is allocated, otherwise the
+   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);
+
+/* fs_path_normalize(): Normalize a path to eliminate ., .. and redundant /
+
+   This function creates a copy of the specified path which is an absolute path
+   with redundant / removed and . and .. components resolved. For instance:
+
+     "" -> "/"
+     "/subfolder/./" -> "/subfolder"
+     "/../subfolder/../subfolder" -> "/subfolder"
+     "/../../x/y/../t" -> "/x/t"
+
+   The new string is created with malloc() and should be free()'d after use. */
+char *fs_path_normalize(char const *path);
+
+/* fs_path_normalize_fc(): Normalize a path and translate it to FONTCHARACTER
+
+   This function is similar to fs_path_normalize(), but it creates a 16-bit
+   string that starts with \\fls0\ rather than /, and can be used in direct
+   calls to BFile. */
+uint16_t *fs_path_normalize_fc(char const *path);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* GINT_FS */

include/gint/gint.h

@@ -5,6 +5,10 @@
 #ifndef GINT_GINT
 #define GINT_GINT
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #include <gint/defs/types.h>
 #include <gint/defs/call.h>
 #include <gint/config.h>
@@ -37,6 +41,13 @@ int gint_world_switch(gint_call_t function);
 __attribute__((deprecated("Use gint_world_switch() instead")))
 void gint_switch(void (*function)(void));
 
+/* gint_world_sync(): Synchronize asynchronous drivers
+
+   This function waits for asynchronous tasks to complete by unbinding all
+   drivers. This is useful in certain hardware operations while remaining in
+   gint. */
+void gint_world_sync(void);
+
 /* gint_osmenu(): Call the calculator's main menu
 
    This function safely invokes the calculator's main menu with gint_switch().
@@ -48,14 +59,23 @@ void gint_switch(void (*function)(void));
    call to getkey(), but can also be called manually. */
 void gint_osmenu(void);
 
+/* gint_osmenu_native(): Like gint_osmenu() without the world switch
+   This is a replacement for gint_osmenu() which can be used when the current
+   kernel is already the native OS kernel. */
+void gint_osmenu_native(void);
+
 /* gint_setrestart(): Set whether to restart the add-in after exiting
 
-   An add-in that reaches the end of its code exits. On the calculator, except
-   using OS-dependent settings, it cannot be started again unless another
-   application is launched first.
+   An add-in that returns from its main() function automatically exits to the
+   OS' main menu. However, when this happens the OS does not allow the add-in
+   to be restarted unless another add-in is launched first. (This is because
+   the OS tries to *resume* the current add-in, which then proceeds to exit
+   again immediately.)
 
-   This setting allows the add-in to restart by calling gint_osmenu() instead
-   of exiting. This can give a proper illusion of restarting if used correctly.
+   This function enables a gint trick where after main() returns the add-in
+   will invoke the main menu with gint_osmenu() rather than exiting. If the
+   add-in is selected again, gint will jump back to the entry point, creating
+   the illusion that the add-in exited and was then restarted.
 
    @restart  0 to exit, 1 to restart by using gint_osmenu() */
 void gint_setrestart(int restart);
@@ -89,4 +109,28 @@ static GINLINE void *gint_inthandler(int code, void const *h, size_t size) {
    Returns the return value of the callback. */
 extern int (*gint_inth_callback)(gint_call_t const *call);
 
+/* 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
+   add-in is unloaded, which is either when we exit from main() or when
+   starting another application from the main menu. Crucially, this is only
+   *after* selecting an application, not before opening the main menu. The
+   quit handler is not invoked if the user re-enters the add-in.
+
+   This is based on the SetQuitHandler() syscall, and therefore the callback
+   runs in the OS world by default. If [run_in_os_world] is set to false, a
+   world switch will be performed to run the callback in the gint world.
+
+   TODO: Currently the quit handler is not called when exiting from main().
+   TODO: Detail how this interacts with destructor functions!
+   TODO: [run_in_os_world == false] is not honored yet (because unstable)
+
+   @call             Callback to be performed when leaving add-in
+   @run_in_os_world  true to stay in OS world, false to use gint world */
+void gint_set_quit_handler(gint_call_t gcall, bool run_in_os_world);
+
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GINT_GINT */

include/gint/gray.h

@@ -5,6 +5,10 @@
 #ifndef GINT_GRAY
 #define GINT_GRAY
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #include <gint/defs/types.h>
 #include <gint/display.h>
 
@@ -148,4 +152,8 @@ void dgray_getvram(uint32_t **light, uint32_t **dark);
    These pointers can be used to make screen captures. */
 void dgray_getscreen(uint32_t **light, uint32_t **dark);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GINT_GRAY */

include/gint/hardware.h

@@ -14,6 +14,10 @@
 #ifndef GINT_HARDWARE
 #define GINT_HARDWARE
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /* For compatibility with ASM, include the following bits only in C code */
 #ifndef CPP_ASM
 
@@ -41,6 +45,12 @@ void hw_detect(void);
 #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
@@ -66,6 +76,7 @@ void hw_detect(void);
 #define HWKBD    8    /* Keyboard */
 #define HWKBDSF       /* Deprecated: use keysc_scan_frequency() */
 #define HWDD          /* Deprecated: use the T6K11/R61524 API */
+#define HWFS    11    /* Filesystem type */
 
 /*
 **  MPU type
@@ -100,6 +111,8 @@ void hw_detect(void);
 #define HWCALC_FXCG50        5
 /* fx-CG 50 emulator, hardcoded in kernel/inth.S */
 #define HWCALC_FXCG_MANAGER  6
+/* fx-9860G Slim, SH-3-based fx-9860G with hardware differences */
+#define HWCALC_FX9860G_SLIM  7
 
 /*
 **  Keyboard
@@ -114,4 +127,19 @@ void hw_detect(void);
 /* The keyboard uses a KEYSC-based scan method. This is only possible on SH4 */
 #define HWKBD_KSI      0x04
 
+/*
+**  Filesystem type
+*/
+
+/* Unknown or no filesystem. */
+#define HWFS_NONE        0
+/* CASIO's in-house filesystem, now deprecated. */
+#define HWFS_CASIOWIN    1
+/* Wrapper around Kyoto Software Research's Fugue VFAT implementation. */
+#define HWFS_FUGUE       2
+
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GINT_HARDWARE */

include/gint/image.h

@@ -0,0 +1,847 @@
+//---
+// gint:image - Image manipulation and rendering
+//
+// Note: this module is currently only available on fx-CG.
+//
+// This header provides image manipulation functions. This mainly consists of a
+// reference-based image format, various access and modification functions, and
+// a number of high-performance transformations and rendering effects. If you
+// find yourself limited by rendering time, note that RAM writing speed is
+// often the bottleneck, and image rendering is much faster in Azur (which is
+// what the renderer was initially designed for).
+//
+// This module supports 3 bit depths: full-color 16-bit (RGB565), indexed 8-bit
+// (P8) and indexed 4-bit (P4). All three have an "alpha" variation where one
+// color is treated as transparent, leading to 6 total formats.
+//
+// The image renderers support so-called *dynamic effects*, which are image
+// transformations performed on-the-fly while rendering, without generating an
+// intermediate image. They comprise straightforward transformations that
+// achieve similar performance to straight rendering and can be combined to
+// some extent, which makes them reliable whenever applicable.
+//
+// For images of the RGB16 and P8 bit depths, the module supports a rich API
+// with image subsurfaces and a fairly large sets of geometric and color
+// transforms, including some in-place. P4 is not supported in most of these
+// functions because the dense bit packing is both impractical and slower for
+// these applications.
+//---
+
+#ifndef GINT_IMAGE
+#define GINT_IMAGE
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef FXCG50
+#error <gint/image.h> is only supported on FXCG50
+#else
+
+#include <gint/defs/attributes.h>
+#include <gint/defs/types.h>
+
+struct dwindow;
+
+//---
+// Image structures
+//---
+
+/* Image formats. Note that transparency really only indicates the default
+   rendering method, as a transparent background can always be added or removed
+   by a dynamic effect on any image. */
+enum {
+    IMAGE_RGB565      = 0,  /* RGB565 without alpha */
+    IMAGE_RGB565A     = 1,  /* RGB565 with one transparent color */
+    IMAGE_P8_RGB565   = 4,  /* 8-bit palette, all opaque colors */
+    IMAGE_P8_RGB565A  = 5,  /* 8-bit with one transparent color */
+    IMAGE_P4_RGB565   = 6,  /* 4-bit palette, all opaque colors */
+    IMAGE_P4_RGB565A  = 3,  /* 4-bit with one transparent color */
+
+    IMAGE_DEPRECATED_P8 = 2,
+};
+
+/* Quick macros to compare formats by storage size */
+#define IMAGE_IS_RGB16(format) \
+    ((format) == IMAGE_RGB565 || (format) == IMAGE_RGB565A)
+#define IMAGE_IS_P8(format) \
+    ((format) == IMAGE_P8_RGB565 || (format) == IMAGE_P8_RGB565A)
+#define IMAGE_IS_P4(format) \
+    ((format) == IMAGE_P4_RGB565 || (format) == IMAGE_P4_RGB565A)
+/* Check whether image format has an alpha color */
+#define IMAGE_IS_ALPHA(format) \
+    ((format) == IMAGE_RGB565A || \
+     (format) == IMAGE_P8_RGB565A || \
+     (format) == IMAGE_P4_RGB565A)
+/* Check whether image format uses a palette */
+#define IMAGE_IS_INDEXED(format) \
+    (IMAGE_IS_P8(format) || IMAGE_IS_P4(format))
+
+/* Image flags. These are used for memory management, mostly. */
+enum {
+    IMAGE_FLAGS_DATA_RO         = 0x01,  /* Data is read-only */
+    IMAGE_FLAGS_PALETTE_RO      = 0x02,  /* Palette is read-only */
+    IMAGE_FLAGS_DATA_ALLOC      = 0x04,  /* Data is malloc()'d */
+    IMAGE_FLAGS_PALETTE_ALLOC   = 0x08,  /* Palette is malloc()'d */
+};
+
+/* image_t: gint's native bitmap image format
+   Images of this format can be created through this header's API but also by
+   using the fxSDK's built-in image converters with fxconv. */
+typedef struct
+{
+    /* Color format, one of the IMAGE_* values defined above */
+    uint8_t format;
+    /* Additional flags, a combination of IMAGE_FLAGS_* values */
+    uint8_t flags;
+    /* Number of colors in the palette; this includes alpha for transparent
+       images, as alpha is always the first entry.
+       RGB16: 0
+       P8: Ranges between 1 and 256
+       P4: 16 */
+    int16_t color_count;
+    /* Full width and height, in pixels */
+    uint16_t width;
+    uint16_t height;
+    /* Byte stride between lines */
+    int stride;
+
+    /* Pixel data in row-major order, left to right.
+       - RGB16: 2 bytes per entry, each row padded to 4 bytes for alignment.
+         Each 2-byte value is an RGB565 color.
+       - P8: 1 signed byte per entry. Each byte is a palette index shifted by
+         128 (to access the color, use palette[<value>+128]).
+       - P4: 4 bits per entry, each row padded to a full byte. Each entry is a
+         direct palette index between 0 and 15. */
+    void *data;
+
+    /* For P8 and P4, color palette. The number of entries allocated in the
+       array is equal to the color_count attribute. */
+    uint16_t *palette;
+
+} GPACKED(4) image_t;
+
+/* Dynamic effects: these transformations can be applied on images while
+   rendering. Not all effects can be combined; unless specified otherwise:
+   - HFLIP and VFLIP can both be added regardless of any other effect
+   - At most one color effect can be applied */
+enum {
+    /* Value 0x01 is reserved, because it is DIMAGE_NOCLIP, which although
+       part of the old API still needs to be supported. */
+
+    /* [Any]: Skip clipping the command against the source image */
+    IMAGE_NOCLIP_INPUT   = 0x04,
+    /* [Any]: Skip clipping the command against the output VRAM */
+    IMAGE_NOCLIP_OUTPUT  = 0x08,
+    /* [Any]: Skip clipping both */
+    IMAGE_NOCLIP         = IMAGE_NOCLIP_INPUT | IMAGE_NOCLIP_OUTPUT,
+
+    // Geometric effects. These values should remain at exactly bit 8 and
+    // following, or change gint_image_mkcmd() along with it.
+
+    /* [Any]: Flip image vertically */
+    IMAGE_VFLIP          = 0x0100,
+    /* [Any]: Flip image horizontally */
+    IMAGE_HFLIP          = 0x0200,
+
+    // Color effects
+
+    /* [RGB565, P8_RGB565, P4_RGB565]: Make a color transparent
+       Adds one argument:
+       * Color to clear (RGB16: 16-bit value; P8/P4: palette index) */
+    IMAGE_CLEARBG        = 0x10,
+    /* [RGB565, P8_RGB565, P4_RGB565]: Turn a color into another
+       Adds two arguments:
+       * Color to replace (RGB16: 16-bit value; P8/P4: palette index)
+       * Replacement color (16-bit value) */
+    IMAGE_SWAPCOLOR      = 0x20,
+    /* [RGB565A, P8_RGB565A, P4_RGB565A]: Add a background
+        Adds one argument:
+        * Background color (16-bit value) */
+    IMAGE_ADDBG          = 0x40,
+    /* [RGB565A, P8_RGB565A, P4_RGB565A]: Dye all non-transparent pixels
+       Adds one argument:
+       * Dye color (16-bit value) */
+    IMAGE_DYE            = 0x80,
+};
+
+//---
+// Image creation and destruction
+//---
+
+/* image_alloc(): Create a new (uninitialized) image
+
+   This function allocates a new image of the specified dimensions and format.
+   It always allocates a new data array; if you need to reuse a data array, use
+   the lower-level image_create() or image_create_sub().
+
+   The first parameters [width] and [height] specify the dimensions of the new
+   image in pixels. The [format] should be one of the IMAGE_* formats, for
+   example IMAGE_RGB565A or IMAGE_P4_RGB565.
+
+   This function does not specify or initialize the palette of the new image;
+   use image_set_palette(), image_alloc_palette() or image_copy_palette()
+   after calling this function.
+
+   The returned image structure must be freed with image_free() after use.
+
+   @width         Width of the new image
+   @height        Height of the new image
+   @format        Pixel format; one of the IMAGE_* formats defined above */
+image_t *image_alloc(int width, int height, int format);
+
+/* image_set_palette(): Specify an external palette for an image
+
+   This function sets the image's palette to the provided address. The number
+   of entries allocated must be specified in size. It is also the caller's
+   responsibility to ensure that the palette covers all the indices used in the
+   image data.
+
+   The old palette, if owned by the image, is freed. If [owns=true] the
+   palette's ownership is given to the image, otherwise it is kept external. */
+void image_set_palette(image_t *img, uint16_t *palette, int size, bool owns);
+
+/* image_alloc_palette(): Allocate a new palette for an image
+
+   This function allocates a new palette for an image. The number of entries is
+   specified in size; for P8 it can vary between 1 and 256, for P4 it is
+   ignored (P4 images always have 16 colors).
+
+   The old palette, if owned by the image, is freed. The entries of the new
+   palette are all initialized to 0. If size is -1, the format's default
+   palette size is used. Returns true on success. */
+bool image_alloc_palette(image_t *img, int size);
+
+/* image_copy_palette(): Copy another image's palette
+
+   This function allocates a new palette for an image, and initializes it with
+   a copy of another image's palette. For P8 the palette can be resized by
+   specifying a value other than -1 as the size; by default, the source image's
+   palette size is used (within the limits of the new format). Retuns true on
+   success. */
+bool image_copy_palette(image_t const *src, image_t *dst, int size);
+
+/* image_create(): Create a bare image with no data/palette
+
+   This function allocates a new image structure but without data or palette.
+   The [data] and [palette] members are NULL, [color_count] and [stride] are 0.
+
+   This function is useful to create images that reuse externally-provided
+   information. It is intended that the user of this function sets the [data]
+   and [stride] fields themselves, along with the IMAGE_FLAGS_DATA_ALLOC flag
+   if the image should own its data.
+
+   The [palette] and [color_count] members can be set with image_set_palette(),
+   image_alloc_palette(), image_copy_palette(), or manually.
+
+   The returned image structure must be freed with image_free() after use. */
+image_t *image_create(int width, int height, int format);
+
+/* image_create_vram(): Create a reference to gint_vram
+
+   This function creates a new RGB565 image that references gint_vram. Using
+   this image as target for transformation functions can effectively render
+   transformed images to VRAM.
+
+   The value of gint_vram is captured when this function is called, and does
+   not update after dupdate() when triple-buffering is used. The user should
+   account for this option. (Using this function twice then replacing one of
+   the [data] pointers is allowed.)
+
+   The VRAM image owns no data but it does own its own structure so it must
+   still be freed with image_free() after use. */
+image_t *image_create_vram(void);
+
+/* image_free(): Free and image and the data it owns
+
+   This function frees the provided image structure and the data that it owns.
+   Images converted by fxconv should not be freed; nonetheless, this functions
+   distinguishes them and should work. Images are not expected to be created on
+   the stack.
+
+   If the image has the IMAGE_FLAGS_DATA_ALLOC flag, the data pointer is also
+   freed. Similarly, the image has the IMAGE_FLAGS_PALETTE_ALLOC flag, the
+   palette is freed. Make sure to not free images when references to them still
+   exist, as this could cause the reference's pointers to become dangling. */
+void image_free(image_t *img);
+
+//---
+// Basic image access and information
+//---
+
+/* image_valid(): Check if an image is valid
+   An image is considered valid if it has a valid profile, a non-NULL data
+   pointer, and for palette formats a valid palette pointer. */
+bool image_valid(image_t const *img);
+
+/* image_alpha(): Get the alpha value for an image format
+
+   This function returns the alpha value for any specific image format:
+   * RGB16: 0x0001
+   * P8: -128 (0x80)
+   * P4: 0
+   For non-transparent formats, it returns a value that is different from all
+   valid pixel values of the format, which means it is always safe to compare a
+   pixel value to the image_alpha() of the format. */
+int image_alpha(int format);
+
+/* image_get_pixel(): Read a pixel from the data array
+
+   This function reads a pixel from the image's data array at position (x,y).
+   It returns the pixel's value, which is either a full-color value (RGB16) or
+   a possibly-negative palette index (P8/P4). See the description of the [data]
+   field of image_t for more details. The value of the pixel can be decoded
+   into a 16-bit color either manually or by using the image_decode_pixel()
+   function.
+
+   Note that reading large amounts of image data with this function will be
+   slow; if you need reasonable performance, consider iterating on the data
+   array manually. */
+int image_get_pixel(image_t const *img, int x, int y);
+
+/* image_decode_pixel(): Decode a pixel value
+
+   This function decodes a pixel's value obtained from the data array (for
+   instance with image_get_pixel()). For RGB16 formats this does nothing, but
+   for palette formats this accesses the palette at a suitable position.
+
+   Note that reading large amounts of data with this function will be slow; if
+   you need reasonable performance, consider inlining the format-specific
+   method or iterating on the data array manually. */
+int image_decode_pixel(image_t const *img, int pixel);
+
+/* image_data_size(): Compute the size of the [data] array
+   This function returns the size of the data array, in bytes. This can be used
+   to duplicate it. Note that for sub-images this is a subsection of another
+   image's data array, and might be much larger than the sub-image. */
+int image_data_size(image_t const *img);
+
+//---
+// Basic image modifications
+//---
+
+/* image_set_pixel(): Set a pixel in the data array
+
+   This function writes a pixel into the image's data array at position (x,y).
+   The pixel value must be of the proper format, as specified in the definition
+   of the [data] field of image_t.
+
+   Formats: RGB16, P8, P4 */
+void image_set_pixel(image_t const *img, int x, int y, int value);
+
+/* image_copy(): Convert and copy an image
+
+   This function copies an image into another image while converting certain
+   formats. Unlike transforms, this function does clip, so there are no
+   conditions on the size of the target.
+
+   If [copy_alpha] is true, transparent pixels are copied verbatim, which
+   effectively replaces the top-left corner of [dst] with [src]. If it's false,
+   transparent pixels of [src] are skipped, effectively rendering [src] over
+   the top-left corner of [src].
+
+   This function converts between all formats except from RGB16 to P8/P4, since
+   this requires generating a palette (which is a complex endeavour).
+   Conversions from P8/P4 to RGB16 simply decode the palette. Conversions
+   between P8/P4 preserve the contents but renumber the palette entries. From
+   P4 to P8, the image is always preserved. From P8 to P4, the image is only
+   preserved if it has less than 16 colors (this is intended to allow P4 images
+   to be converted to P8 for edition by this library, and then back to P4). The
+   following table summarizes the conversions:
+
+     Source format →      RGB16           P8                P4
+     Target format ↓  +-----------+----------------+------------------+
+               RGB16  |    Copy     Decode palette    Decode palette  |
+                  P8  |     -            Copy        Enlarge palette  |
+                  P4  |     -       Narrow palette         Copy       |
+                      +-----------+----------------+------------------+
+
+   Note that conversions to RGB16 are not lossless because RGB565, P8 and P4
+   can represent any color; if a color equal to image_alpha(IMAGE_RGB565A) is
+   found during conversion, this function transforms it slightly to look
+   similar instead of erroneously generating a transparent pixel.
+
+   Formats: RGB16 → RGB16, P8 → Anything, P4 → Anything
+   Size requirement: none (clipping is performed)
+   Supports in-place: No (useless) */
+void image_copy(image_t const *src, image_t *dst, bool copy_alpha);
+
+/* image_copy_alloc(): Convert and copy into a new image
+   This function is similar to image_copy(), but it allocates a target image of
+   the desired format before copying. */
+image_t *image_copy_alloc(image_t const *src, int new_format);
+
+/* image_fill(): Fill an image with a single pixel value */
+void image_fill(image_t *img, int value);
+
+/* image_clear(): Fill a transparent image with its transparent value */
+void image_clear(image_t *img);
+
+//---
+// Sub-image extraction
+//---
+
+/* image_sub(): Build a reference to a sub-image
+
+   This function is used to create references to sub-images of RGB16 and P8
+   images. The [data] pointer of the sub-image points somewhere within the data
+   array of the source, and its [palette] pointer is identical to the source's.
+
+   The last parameter is a pointer to a preallocated image_t structure (usually
+   on the stack) that gets filled with the data. Doing this instead of
+   allocating a new object with malloc() means that there is no need to
+   image_free() the sub-image, and thus it can be used inline:
+
+     image_t tmp;
+     image_hflip(src, image_sub(dst, x, y, w, h, &tmp));
+
+   A preprocessor macro is used to make the last parameter optional. If it's
+   not specified, a pointer to a static image_t will be returned instead. This
+   is useful in inline calls as shown above, which then simplify to:
+
+     image_hflip(src, image_sub(dst, x, y, w, h));
+
+   However, another call to image_sub() or image_at() will override the
+   sub-image, so you should only use this in such temporary settings. If you
+   need multiple image_sub() or image_at() calls in the same statement, only
+   one can use the short form.
+
+   If the requested rectangle does not intersect the source, the sub-image will
+   be of dimension 0x0. If the image format does not support sub-images (P4),
+   the sub-image will test invalid with image_valid(). */
+image_t *image_sub(image_t const *src, int x, int y, int w, int h,
+    image_t *dst);
+
+/* 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)
+
+/* 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)
+
+//---
+// Geometric image transforms
+//
+// All geometric transforms render to position (0,0) of the target image and
+// fail if the target image is not large enough to hold the transformed result
+// (unlike the rendering functions which render only the visible portion).
+//
+// To render at position (x,y) of the target image, use img_at(). For instance:
+//   image_hflip(src, image_at(dst, x, y));
+//
+// Each transform function has an [_alloc] variant which does the same
+// transform but allocates the target image on the fly and returns it. Remember
+// 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.)
+//
+// Some functions support in-place transforms. This means they can be called
+// with the source as destination, and will transform the image without needing
+// new memory. For instance, image_hflip(src, src) flips in-place and replaces
+// src with a flipped version of itself.
+//
+// (However, it is not possible to transform in-place if the source and
+//  destination intersect in non-trivial ways. The result will be incorrect.)
+//
+// When transforming to a new image, transparent pixels are ignored, so if the
+// destination already has some data, it will not be erased automatically. Use
+// image_clear() beforehand to achieve that effect. This allows alpha blending
+// while transforming, which is especially useful on the VRAM.
+//---
+
+/* image_hflip(): Flip horizontally
+   Formats: RGB16, P8
+   Size requirement: destination at least as large as source (no clipping)
+   Supports in-place: Yes */
+void image_hflip(image_t const *src, image_t *dst, bool copy_alpha);
+image_t *image_hflip_alloc(image_t const *src);
+
+/* image_vflip(): Flip vertically
+   Formats: RGB16, P8
+   Size requirement: destination at least as large as source (no clipping)
+   Supports in-place: Yes */
+void image_vflip(image_t const *src, image_t *dst, bool copy_alpha);
+image_t *image_vflip_alloc(image_t const *src);
+
+/* image_linear(): Linear transformation
+
+   This function implements a generic linear transformation. This is a powerful
+   function that can perform any combination of rotation, mirroring and scaling
+   with nearest-neighbor sampling.
+
+   The [image_linear_map] structure defines the settings for the transform.
+   Users familiar with linear algebra might want to use it directly, but they
+   are most conveniently generated with the rotation and scaling functions
+   listed below.
+
+   Note: Currently the structure for the transform is modified by the
+   operation and cannot be reused.
+
+   The image_linear_alloc() variant allocates a new image in addition to
+   performing the transform. The image is created with size (map->dst_w,
+   map->dst_h) which is always a reasonable default. If a target image of
+   smaller size is supplied to image_linear(), clipping is performed; only the
+   top-left corner of the full output is actually rendered.
+
+   Formats: RGB16, P8
+   Size requirement: none (clipping is performed)
+   Supports in-place: No */
+
+struct image_linear_map {
+    /* Dimensions of the source and destination */
+    int src_w, src_h, dst_w, dst_h;
+    /* Input and output stride in bytes */
+    int src_stride, dst_stride;
+
+    /* The following parameters define the linear transformation as a mapping
+       from coordinates in the destination image (x and y) into coordinates in
+       the source image (u and v).
+       - (u, v) indicate where the top-left corner of the destination lands in
+         the source image.
+       - (dx_u, dx_v) indicate the source-image movement for each movement of
+         x += 1 in the destination.
+       - (dy_u, dy_v) indicate the source-image movement for each movement of
+         y += 1 in the destination.
+       All of these values are specified as 16:16 fixed-point, ie. they encode
+       decimal values by multiplying them by 65536. */
+    int u, v, dx_u, dx_v, dy_u, dy_v;
+};
+
+void image_linear(image_t const *src, image_t *dst,
+    struct image_linear_map *map);
+image_t *image_linear_alloc(image_t const *src,
+    struct image_linear_map *map);
+
+/* image_scale(): Upscale or downscale an image
+
+   This function generates a linear map to be used in image_linear() to scale
+   the input image. The scaling factor gamma can be specified independently for
+   the x and y dimensions. It is expressed as 16:16 fixed-point; you can set
+   any decimal value multiplied by 65536, for instance 1.5*65536 to increase
+   the width and height by 50%. */
+void image_scale(image_t const *src, int gamma_x, int gamma_y,
+    struct image_linear_map *map);
+
+/* image_rotate(): Rotate an image around its center
+
+   This function generates a linear map to be used in image_linear() to perform
+   a rotation around the center of an image. If [resize=true], the target is
+   enlarged to make sure all the rotated pixels can be represented. This can
+   increase the final surface by a factor of up to 2. If the original image
+   doesn't extend to its corners, it is recommended to leave [resize=false] as
+   it noticeably affects performance. */
+void image_rotate(image_t const *src, float angle, bool resize,
+    struct image_linear_map *map);
+
+/* image_rotate_around(): Rotate an image around any point
+
+   This function generalizes image_rotate() by allowing rotations around any
+   center, even a point not within the image. The center is specified through
+   two coordinates (*center_x, *center_y). If the center is near the side of
+   the image, a normal rotation would move most of the pixels out of frame;
+   this function moves the frame to make sure the whole image remains visible.
+   *center_x and *center_y are updated to indicate the position of the center
+   of rotation within the new frame (the target image). */
+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(): Rotate an image around any point and scale it
+
+   This function generalizes image_rotate_around() by adding a scaling factor
+   to the transformation. The scaling factor gamma is expressed as 16:16
+   fixed-point. If [resize=true] the image is further extended to make sure no
+   parts are cut out, as in other rotation functions. */
+void image_rotate_around_scale(
+    image_t const *src, float angle, int gamma,
+    bool resize, int *center_x, int *center_y,
+    struct image_linear_map *map);
+
+//---
+// Color transforms
+//---
+
+/* TODO: Color transforms */
+
+//---
+// Image rendering functions
+//
+// The following functions extend dimage() and dsubimage(). The [effects]
+// parameter takes a combination of IMAGE_* flags and effects, limited to the
+// combinations previously described, with additional arguments depending on
+// the color effect being applied.
+//
+//   dimage_effect(x, y, img, effects, ...)
+//   dsubimage_effect(x, y, img, left, top, w, h, effects, ...)
+//
+// However if you use these super-generic functions you will link the code for
+// all effects and all formats into your add-in, which takes a fair amount of
+// space. If that's a problem, you can use the more specific functions below:
+//
+// * dimage_<FORMAT>_<EFFECT>() for one particular format (rgb16, p8, p4) along
+//   with one particular color effect (clearbg, swapcolor, addbg, dye).
+// * dimage_<FORMAT>() is like the above when no color effect is applied.
+//
+// All of them support the HFLIP and VFLIP flags. For effect-specific functions
+// the corresponding effect flag can be omitted (fi. IMAGE_CLEARBG is implicit
+// when using dimage_p8_clearbg()).
+//---
+
+/* dimage_effect(): Generalized dimage() supporting dynamic effects */
+#define dimage_effect(x, y, img, eff, ...) \
+    dsubimage_effect(x, y, img, 0, 0, (img)->width, (img)->height, eff, \
+        ##__VA_ARGS__)
+/* dsubimage_effect(): Generalized dsubimage() supporting dynamic effects */
+void dsubimage_effect(int x, int y, image_t const *img,
+    int left, int top, int w, int h, int effects, ...);
+
+/* Specific versions for each format */
+#define DIMAGE_SIG1(NAME, ...) \
+    void dimage_ ## NAME(int x, int y, image_t const *img,##__VA_ARGS__); \
+    void dsubimage_ ## NAME(int x, int y, image_t const *img, \
+        int left, int top, int w, int h, ##__VA_ARGS__);
+#define DIMAGE_SIG(NAME, ...) \
+    DIMAGE_SIG1(rgb16 ## NAME, ##__VA_ARGS__) \
+    DIMAGE_SIG1(p8 ## NAME, ##__VA_ARGS__) \
+    DIMAGE_SIG1(p4 ## NAME, ##__VA_ARGS__)
+
+/* d[sub]image_{rgb16,p8,p4}_effect(..., effects, <extra arguments>) */
+DIMAGE_SIG(_effect, int effects, ...)
+/* d[sub]image_{rgb16,p8,p4}(..., effects) (no color effect, like dimage()) */
+DIMAGE_SIG(, int effects)
+/* d[sub]image_{rgb16,p8,p4}_clearbg(..., effects, bg_color_or_index) */
+DIMAGE_SIG(_clearbg, int effects, int bg_color_or_index)
+/* d[sub]image_{rgb16,p8,p4}_swapcolor(..., effects, source, replacement) */
+DIMAGE_SIG(_swapcolor, int effects, int source, int replacement)
+/* d[sub]image_{rgb16,p8,p4}_addbg(..., effects, bg_color) */
+DIMAGE_SIG(_addbg, int effects, int bg_color)
+/* d[sub]image_{rgb16,p8,p4}_dye(..., effects, dye_color) */
+DIMAGE_SIG(_dye, int effects, int dye_color)
+
+/* d[sub]image_p4_clearbg_alt(..., effects, bg_index)
+   This is functionally identical to CLEARBG, but it uses an alternative
+   rendering method that is faster for larger images with wide transparent
+   areas. You can swap it with the normal CLEARBG freely. */
+DIMAGE_SIG1(p4_clearbg_alt, int effects, int bg_index)
+
+#define dimage_rgb16_effect(x, y, img, eff, ...) \
+    dsubimage_rgb16_effect(x, y, img, 0, 0, (img)->width, (img)->height, \
+        eff, ##__VA_ARGS__)
+#define dimage_p8_effect(x, y, img, eff, ...) \
+    dsubimage_p8_effect(x, y, img, 0, 0, (img)->width, (img)->height, \
+        eff, ##__VA_ARGS__)
+#define dimage_p4_effect(x, y, img, eff, ...) \
+    dsubimage_p4_effect(x, y, img, 0, 0, (img)->width, (img)->height, \
+        eff, ##__VA_ARGS__)
+
+#undef DIMAGE_SIG
+#undef DIMAGE_SIG1
+
+//---
+// Clipping utilities
+//---
+
+/* Double box specifying both a source and target area */
+struct gint_image_box
+{
+    /* Target location of top-left corner */
+    int x, y;
+    /* Width and height of rendered sub-image */
+    int w, h;
+    /* Source bounding box (low included, high excluded) */
+    int left, top;
+};
+
+/* Clip the provided box against the input. If, after clipping, the box no
+   longer intersects the output window, returns false. Otherwise, returns
+   true. */
+bool gint_image_clip_input(image_t const *img, struct gint_image_box *box,
+    struct dwindow const *window);
+
+/* Clip the provided box against the output. */
+void gint_image_clip_output(struct gint_image_box *b,
+   struct dwindow const *window);
+
+//---
+// Internal image rendering routines
+//
+// The following functions (or non-functions) are implemented in assembler and
+// make up the internal interface of the image renderer. If you just want to
+// display images, use dimage() and variations; these are only useful if you
+// have a different rendering system and wish to use image rendering with
+// dynamic effects in it.
+//---
+
+/* Renderer command. This structure includes most of the information used by
+   the image renderer to perform blits. Some of the information on the target
+   is also passed as direct arguments, which is more convenient and slightly
+   faster.
+
+   Most of the values here can be set with gint_image_mkcmd(). The last two
+   members, along with the return values of the gint_image_FORMAT_loop()
+   functions, are used to update the command if one needs to draw *parts* of
+   the image and resume the rendering later. This is used in Azur. */
+struct gint_image_cmd
+{
+    /* Shader ID. This is used in Azur, and ignored in gint */
+    uint8_t shader_id;
+    /* Dynamic effects not already dispatched by renderer
+        Bit 0: VFLIP
+        Bit 1: HFLIP */
+    uint8_t effect;
+
+    /* Number of pixels to render per line. For formats that force either x
+       or width alignment (most of them), this is already adjusted to a
+       suitable multiple (usually a multiple of 2). */
+    int16_t columns;
+
+    /* Stride of the input image (number of pixels between each row), in
+       pixels, without subtracting the number of columns */
+    int16_t input_stride;
+
+    /* Number of lines in the command. This can be adjusted freely, and is
+       particularly useful in Azur for fragmented rendering. */
+    uint8_t lines;
+
+    /* [Any effect]: Offset of first edge */
+    int8_t edge_1;
+
+    /* Core loop; this is an internal label of the renderer */
+    void const *loop;
+    /* Output pixel array, offset by target x/y */
+    void const *output;
+    /* Input pixel array, offset by source x/y. For formats that force x
+       alignment, this is already adjusted. */
+    void const *input;
+    /* Palette, when applicable */
+    uint16_t const *palette;
+
+    /* [Any effect]: Offset of right edge */
+    int16_t edge_2;
+    /* [CLEARBG, SWAPCOLOR]: Source color */
+    uint16_t color_1;
+    /* [SWAPCOLOR]: Destination color */
+    uint16_t color_2;
+
+    /* Remaining height (for updates between fragments) */
+    int16_t height;
+    /* Local x position (for updates between fragments) */
+    int16_t x;
+};
+
+/* gint_image_mkcmd(): Prepare a rendering command with dynamic effects
+
+   This function crafts an image renderer command. It loads all the settings
+   except for effect-dependent parameters: the [.loop] label, the color section
+   of [.effect], and color effect settings. See the effect-specific functions
+   to see how they are defined.
+
+   The benefit of this approach is that the rendering code does not need to be
+   linked in unless an effect is actually used, which avoids blowing up the
+   size of the add-in as the number of support dynamic effects increases.
+
+   @box         Requested on-screen box (will be clipped depending on effects)
+   @img         Source image
+   @effects     Set of dynamic effects to be applied, as an [IMAGE_*] bitmask
+   @left_edge   Whether to force 2-alignment on the input (box->left)
+   @right_edge  Whether to force 2-alignment on the width
+   @cmd         Command to be filled
+   @window      Rendering window (usually {0, 0, DWIDTH, DHEIGHT})
+
+   Returns false if there is nothing to render because of clipping (in which
+   case [cmd] is unchanged), true otherwise. [*box] is also updated to reflect
+   the final box after clipping but not accounting for edges.  */
+bool gint_image_mkcmd(struct gint_image_box *box, image_t const *img,
+    int effects, bool left_edge, bool right_edge,
+    struct gint_image_cmd *cmd, struct dwindow const *window);
+
+/* Entry point of the renderers. These functions can be called normally as long
+   as you can build the commands (eg. by using gint_image_mkcmd() then filling
+   the effect-specific information). */
+void *gint_image_rgb16_loop  (int output_width, struct gint_image_cmd *cmd);
+void *gint_image_p8_loop     (int output_width, struct gint_image_cmd *cmd);
+void *gint_image_p4_loop     (int output_width, struct gint_image_cmd *cmd);
+
+/* Renderer fragments. The following can absolutely not be called from C code
+   as they aren't full functions (and this isn't their prototype). These are
+   continuations to be specified in the [.loop] field of a command before using
+   one of the functions above. */
+
+void gint_image_rgb16_normal(void);
+void gint_image_rgb16_clearbg(void);
+void gint_image_rgb16_swapcolor(void);
+void gint_image_rgb16_dye(void);
+
+void gint_image_p8_normal(void);
+void gint_image_p8_clearbg(void);
+void gint_image_p8_swapcolor(void);
+void gint_image_p8_dye(void);
+
+void gint_image_p4_normal(void);
+void gint_image_p4_clearbg(void);
+void gint_image_p4_clearbg_alt(void);
+void gint_image_p4_swapcolor(void);
+void gint_image_p4_dye(void);
+
+//---
+// Image library utilities
+//
+// The following functions and macros are mostly internal utilities; they are
+// exposed here in case user applications want to extend the set of image
+// transforms with custom additions.
+//---
+
+/* image_target(): Check if an image can be used as target for a transform
+
+   This function is used to quickly check whether a transform from [src] to
+   [dst] is possible. It requires image_valid(src) and image_valid(dst), plus
+   any optional constraints specified as variadic arguments. These constraints
+   can be:
+
+   * NOT_P4: fails if [dst] is P4.
+   * DATA_RW: fails if [dst] is not data-writable.
+   * PALETTE_RW: fails if [dst] is not palette-writable.
+   * SAME_SIZE: fails if [dst] is not at least as large as [src].
+
+   For example, in image_hflip(), we write:
+     if(!image_target(src, dst, NOT_P4, DATA_RW, SAME_SIZE)) return; */
+
+enum {
+    IMAGE_TARGET_NONE,
+    IMAGE_TARGET_NOT_P4,
+    IMAGE_TARGET_DATA_RW,
+    IMAGE_TARGET_PALETTE_RW,
+    IMAGE_TARGET_SAME_SIZE,
+    IMAGE_TARGET_SAME_FORMAT,
+    IMAGE_TARGET_SAME_DEPTH,
+};
+bool image_target(image_t const *src, image_t *dst, ...);
+
+#define image_target(src, dst, ...) \
+    image_target(src, dst, image_target_arg1(__VA_ARGS__ __VA_OPT__(,) NONE))
+#define image_target_arg1(c, ...) \
+    IMAGE_TARGET_ ## c __VA_OPT__(, image_target_arg2(__VA_ARGS__))
+#define image_target_arg2(c, ...) \
+    IMAGE_TARGET_ ## c __VA_OPT__(, image_target_arg3(__VA_ARGS__))
+#define image_target_arg3(c, ...) \
+    IMAGE_TARGET_ ## c __VA_OPT__(, image_target_arg4(__VA_ARGS__))
+#define image_target_arg4(c, ...) \
+    IMAGE_TARGET_ ## c __VA_OPT__(, image_target_arg5(__VA_ARGS__))
+#define image_target_arg5(c, ...) \
+    IMAGE_TARGET_ ## c __VA_OPT__(, image_target_arg6(__VA_ARGS__))
+#define image_target_arg6(c, ...) \
+    IMAGE_TARGET_ ## c __VA_OPT__(, image_target_too_many_args(__VA_ARGS__))
+
+/* image_alpha_2(): Conditional alpha */
+#define image_alpha_2(fmt, copy_alpha) \
+        ((copy_alpha) ? 0x10000 : image_alpha(fmt))
+
+#endif /* FXCG50 */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* GINT_IMAGE */

include/gint/intc.h

@@ -5,6 +5,10 @@
 #ifndef GINT_INTC
 #define GINT_INTC
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #include <gint/defs/types.h>
 #include <gint/defs/call.h>
 
@@ -131,4 +135,8 @@ void *intc_handler(int event_code, void const *handler, size_t size);
    Returns true on success, false if the event code is invalid. */
 bool intc_handler_function(int event_code, gint_call_t function);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GINT_INTC */

include/gint/keyboard.h

@@ -5,6 +5,10 @@
 #ifndef GINT_KEYBOARD
 #define GINT_KEYBOARD
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /* Keyboard, key events, keydown() and getkey()
 
    gint's keyboard driver regularly scans the keyboard matrix and produces *key
@@ -203,7 +207,7 @@ enum {
 	/* Enable modifiers keys */
 	GETKEY_MOD_SHIFT   = 0x01,
 	GETKEY_MOD_ALPHA   = 0x02,
-	/* SHIFT + OPTN toggles backlight (requires GETKEY_MOD_SHIFT) */
+	/* SHIFT + OPTN (requires GETKEY_MOD_SHIFT) or LIGHT toggles backlight */
 	GETKEY_BACKLIGHT   = 0x04,
 	/* MENU triggers a task switch and displays the main menu */
 	GETKEY_MENU        = 0x08,
@@ -221,10 +225,6 @@ enum {
 	GETKEY_DEFAULT     = 0xdf,
 };
 
-/* getkey_profile_t: Custom repeat profile function
-   See getkey_set_repeat_profile() for details. */
-typedef int (*getkey_profile_t)(int key, int duration, int count);
-
 /* getkey_feature_t: Custom feature function
    See getkey_set_feature_function() for details. */
 typedef bool (*getkey_feature_t)(key_event_t event);
@@ -242,58 +242,20 @@ typedef bool (*getkey_feature_t)(key_event_t event);
    value whenever you want to interrupt the call; using a timer with
    [timer_timeout] as callback is suitable. See <gint/timer.h>.
 
+   Event transforms in getkey_opt() (SHIFT, ALPHA and repetitions) are handled
+   by changing the transform settings on the keyboard device. These settings
+   are restored when getkey_opt() returns, so if they are originally disabled
+   (which they are unless set manually) then the status of the SHIFT and ALPHA
+   keys is lost between calls (this has an effect it getkey_opt() is
+   interrupted by timeout). Therefore, in order to use modifiers across several
+   calls to getkey_opt(), make sure to enable the transforms on the keyboard
+   device; see <gint/drivers/keydev.h> for details.
+
    @options  An or-combination of values from the GETKEY_* enumeration
    @timeout  Optional pointer to a timeout value
    Returns a key event of type KEYEV_DOWN or KEYEV_HOLD with [mod=1]. */
 key_event_t getkey_opt(int options, volatile int *timeout);
 
-/* getkey_repeat(): Set repeat delays for getkey()
-
-   This function updates the repeat delays of getkey() and getkey_opt(). The
-   unit of the argument is in milliseconds, but the granularity of the delay is
-   dependent on the keyboard scan frequency.
-
-   In the default setting (128 Hz scans), the possible repeat delays are
-   approximately 8 ms, 16 ms, 23 ms, 31 ms... the provided arguments will be
-   rounded to the closest feasible delays to ensure that repetitions are
-   perfectly regular, rather than approximating the requested frequency.
-
-   The system default is (500 ms, 125 ms). With the 128 Hz setting, this
-   default is reached exactly without approximation. gint's default is (400 ms,
-   40 ms) for more reactivity.
-
-   @first  Delay between key press and first repeat (no more than one hour)
-   @next   Delay between subsequent repeats (no more than one hour) */
-void getkey_repeat(int first, int next);
-
-/* getkey_repeat_profile(): Get the current repeat profile function */
-getkey_profile_t getkey_repeat_profile(void);
-
-/* getkey_set_repeat_profile(): Set the repeat profile function
-
-   The repeat profile is called by getkey() and getkey_opt() when a key is
-   pressed or held, and getkey() is planning to repeat it. The profile decides
-   whether such repetition is allowed, and if so, how long it shoud take. The
-   profile has access to the following information:
-
-   @key       Key for which a repetition is being considered
-   @duration  Duration since the key was first pressed (us)
-   @count     Number of previous repeats (0 on the first call)
-
-   The profile function must either return a positive number of microseconds to
-   wait until the next repeat, or -1 to block the repeat indefinitely. Note
-   that the keyboard device typically updates every 7-8 ms, timings are tracked
-   in microseconds only to limit deviations.
-
-   Setting a repeat profile overrides GETKEY_REP_ARROWS, GETKEY_REP_ALL, and
-   the repeat delays. Calling with profile=NULL restores this behavior.
-
-   This mechanism replaces a "repeat filter" that existed until gint 2.4. The
-   main difference is that the repeat filter was called when the repeat event
-   arrived, whereas the repeat profile is called one repeat earlier to schedule
-   the repeat exactly when needed. */
-void getkey_set_repeat_profile(getkey_profile_t profile);
-
 /* getkey_feature_function(): Get the current feature function */
 getkey_feature_t getkey_feature_function(void);
 
@@ -329,4 +291,36 @@ int keycode_function(int keycode);
    returns 7 for KEY_7) and -1 for other keys. */
 int keycode_digit(int keycode);
 
+#ifdef __cplusplus
+}
+#endif
+
+//---
+// Deprecated functions for repeat control
+//
+// The following types and functions have been deprecated. The handling of
+// repeats is done inside the keyboard device (see <gint/drivers/keydev.h>).
+// Until gint 2.9, the device had repeats disabled by default and getkey()
+// enabled them. The problem is that repeats usually occur while getkey() is
+// not running, so repeats wouldn't work as expected.
+//
+// Thus, getkey()-specific APIs related to repeat settings are now deprecated
+// in favor of the ones provided by <gint/drivers/keydev.h>, which apply
+// globally instead of just when getkey() is being run.
+//---
+
+typedef void *getkey_profile_t;
+
+__attribute__((deprecated(
+    "Use keydev_set_standard_repeats(), which is permanent, instead")))
+void getkey_repeat(int first, int next);
+
+__attribute__((deprecated(
+    "Use keydev_transform(keydev_std()).repeater instead")))
+getkey_profile_t getkey_repeat_profile(void);
+
+__attribute__((deprecated(
+    "Set the [repeater] attribute with keydev_set_transform() instead")))
+void getkey_set_repeat_profile(getkey_profile_t profile);
+
 #endif /* GINT_KEYBOARD */

include/gint/keycodes.h

@@ -5,6 +5,10 @@
 #ifndef GINT_KEYCODES
 #define GINT_KEYCODES
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /* Raw matrix codes */
 enum {
 	KEY_F1		= 0x91,
@@ -71,6 +75,10 @@ enum {
 	   of the matrix one could use a ghosting effect to boot the calc. */
 	KEY_ACON	= 0x07,
 
+	/* Virtual key codes */
+	KEY_HELP	= 0x20, /* fx-9860G Slim: 0x75 */
+	KEY_LIGHT	= 0x10, /* fx-9860G Slim: 0x76 */
+
 	/* Key aliases (handle with care =D) */
 	KEY_X2		= KEY_SQUARE,
 	KEY_CARET	= KEY_POWER,
@@ -83,4 +91,8 @@ enum {
 	KEY_MINUS	= KEY_SUB,
 };
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GINT_KEYCODES */

include/gint/kmalloc.h

@@ -5,6 +5,10 @@
 #ifndef GINT_KMALLOC
 #define GINT_KMALLOC
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #include <gint/config.h>
 #include <gint/defs/types.h>
 
@@ -35,6 +39,20 @@ void *krealloc(void *ptr, size_t size);
 /* kfree(): Free memory allocated with kalloc() */
 void kfree(void *ptr);
 
+/* kmalloc_max(): Allocate the largest block available in an arena
+
+   This function is like kmalloc(), but it find the largest block in the arena
+   and returns it whole after setting its size in *size. This is useful if you
+   need memory to manage with another allocator, or you don't yet know the size
+   of the data to be generated. The block can later be shrunk with realloc().
+
+   Currently only gint-managed arenas support this operation.
+
+   @size        Will be set to size of returned block (if there is one)
+   @arean_name  Name of arena to allocate in (*cannot* be NULL)
+   Returns the address of the largest block available, NULL on error. */
+void *kmalloc_max(size_t *size, char const *arena_name);
+
 //---
 // Extension API for new areas and statistics
 //---
@@ -49,6 +67,8 @@ typedef struct {
 	void * (*realloc)(void *ptr, size_t newsize, void *data);
 	/* kfree() handles ptr == NULL*/
 	void (*free)(void *ptr, void *data);
+	/* kmalloc_max() backend */
+	void * (*malloc_max)(size_t *size, void *data);
 
 	/* Name, should be unique; gint reserves names starting with "_" */
 	char const *name;
@@ -164,4 +184,8 @@ int kmallocdbg_sequence_length(kmalloc_arena_t *a);
 
 #endif /* GINT_KMALLOC_DEBUG */
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GINT_KMALLOC */

include/gint/mmu.h

@@ -5,7 +5,12 @@
 #ifndef GINT_MMU
 #define GINT_MMU
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #include <gint/mpu/mmu.h>
+#include <stdbool.h>
 
 //---
 //	Unified interface
@@ -36,6 +41,17 @@ void *mmu_uram(void);
    fx-9860G, and 512k on fx-CG 50. */
 uint32_t mmu_uram_size(void);
 
+/* mmu_is_rom(): Determine if an address points to ROM
+
+   Checks whether the supplied pointer points to ROM or to a virtualized
+   portion of ROM. For the sake of efficiency, this function uses heuristics
+   about the structure of P0 rather than actually checking the TLB.
+
+   This is useful during filesystem accesses because only data outside of ROM
+   can be written to files. Pointers for which this function returns true
+   cannot be used as a source for BFile_Write(). */
+bool mmu_is_rom(void const *ptr);
+
 //---
 //	SH7705 TLB
 //---
@@ -73,7 +89,7 @@ uint32_t tlb_translate(uint32_t page, uint32_t *size);
 /* utlb_addr() - get the P4 address of a UTLB address entry
    @E  Entry number (should be in range 0..63)
    Returns a pointer to the entry. */
-const utlb_addr_t *utlb_addr(uint E);
+utlb_addr_t const *utlb_addr(uint E);
 
 /* utlb_data() - get the P4 address of a UTLB data entry
    @E  Entry number (should be in range 0..63)
@@ -94,4 +110,18 @@ void utlb_mapped_memory(uint32_t *rom, uint32_t *ram);
 /* utlb_translate(): Get the physical address for a virtual page */
 uint32_t utlb_translate(uint32_t page, uint32_t *size);
 
+/* itlb_addr(): Get the P4 address of an ITLB address entry
+   @E  Entry number (0..3)
+   Returns a pointer to the entry. */
+itlb_addr_t const *itlb_addr(uint E);
+
+/* itlb_data(): Get the P4 address of an ITLB data entry
+   @E  Entry number (0..3)
+   Returns a pointer to the entry. */
+itlb_data_t const *itlb_data(uint E);
+
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GINT_MMU */

include/gint/mpu/bsc.h

@@ -0,0 +1,224 @@
+//---
+// gint:mpu:bsc - Bus State Controller
+//---
+
+#ifndef GINT_MPU_BSC
+#define GINT_MPU_BSC
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <gint/defs/attributes.h>
+#include <gint/defs/types.h>
+
+//---
+// SH7705 But State Controller. Refer to:
+//   Renesas SH7705 Group Hardware Manual
+//   Section 7: Bus State Controller (BSC)
+//---
+
+typedef volatile lword_union(sh7705_bsc_CSnBCR_t,
+	uint32_t	:2;
+	uint32_t IWW	:2; /* Wait cycles for Write-Read and Write-Write */
+	uint32_t	:1;
+	uint32_t IWRWD	:2; /* Wait cycles for other-space Read-Write */
+	uint32_t	:1;
+	uint32_t IWRWS	:2; /* Wait cycles for same-space Read-Write */
+	uint32_t	:1;
+	uint32_t IWRRD	:2; /* Wait cycles for other-space Read-Read */
+	uint32_t	:1;
+	uint32_t IWRRS	:2; /* Wait cycles for same-space Read-Read */
+	uint32_t	:1;
+	uint32_t TYPE	:3; /* Memory type */
+	uint32_t	:1;
+	uint32_t BSZ	:2; /* Data bus size */
+	uint32_t	:9;
+);
+
+/* Warning: the layout of this register changes with n *and* with the memory
+   type. This version is not exhaustive. Check the manual! */
+typedef volatile lword_union(sh7705_bsc_CSnWCR_t,
+	uint32_t	:13;
+	uint32_t WW	:3; /* Write access wait cycles */
+	uint32_t 	:3;
+	uint32_t SW	:2; /* Wait from CSn/address to RD/WEn assertion */
+	uint32_t WR	:4; /* Access wait cycles */
+	uint32_t WM	:1; /* Whether to use external wait */
+	uint32_t	:4;
+	uint32_t HW	:2; /* Wait from RD/WEn to CSn/address negation */
+);
+
+typedef volatile struct
+{
+	lword_union(CMNCR,
+		uint32_t	:24;
+		uint32_t DMAIW	:2; /* DMA single-address wait states */
+		uint32_t DMAIWA	:1; /* DMAIW wait states insertion method */
+		uint32_t	:1;
+		uint32_t const ENDIAN	:1; /* Global CPU endianness flag */
+		uint32_t	:1;
+		uint32_t HIZMEM	:1; /* High-Z memory Control*/
+		uint32_t HIZCNT	:1; /* High-Z Control*/
+	);
+
+	sh7705_bsc_CSnBCR_t CS0BCR;
+	sh7705_bsc_CSnBCR_t CS2BCR;
+	sh7705_bsc_CSnBCR_t CS3BCR;
+	sh7705_bsc_CSnBCR_t CS4BCR;
+	sh7705_bsc_CSnBCR_t CS5ABCR;
+	sh7705_bsc_CSnBCR_t CS5BBCR;
+	sh7705_bsc_CSnBCR_t CS6ABCR;
+	sh7705_bsc_CSnBCR_t CS6BBCR;
+
+	sh7705_bsc_CSnWCR_t CS0WCR;
+	sh7705_bsc_CSnWCR_t CS2WCR;
+	sh7705_bsc_CSnWCR_t CS3WCR;
+	sh7705_bsc_CSnWCR_t CS4WCR;
+	sh7705_bsc_CSnWCR_t CS5AWCR;
+	sh7705_bsc_CSnWCR_t CS5BWCR;
+	sh7705_bsc_CSnWCR_t CS6AWCR;
+	sh7705_bsc_CSnWCR_t CS6BWCR;
+
+	/* TODO: There are more registers (not involved in overclocking). */
+} GPACKED(4) sh7705_bsc_t;
+
+#define SH7705_BSC (*(sh7705_bsc_t *)0xa4fd0000)
+
+
+//---
+// SH7305 But State Controller. Refer to:
+//   Renesas SH7730 Group Hardware Manual
+//   Section 11: Bus State Controller (BSC)
+//---
+
+typedef volatile lword_union(sh7305_bsc_CSnBCR_t,
+	uint32_t	:1;
+	uint32_t IWW	:3;
+	uint32_t IWRWD	:3;
+	uint32_t IWRWS	:3;
+	uint32_t IWRRD	:3;
+	uint32_t IWRRS	:3;
+	uint32_t TYPE	:4;
+	uint32_t	:1;
+	uint32_t BSZ	:2;
+	uint32_t	:9;
+);
+
+typedef volatile lword_union(sh7305_bsc_CSnWCR_06A6B_t,
+	uint32_t	:11;
+	uint32_t BAS	:1;
+	uint32_t	:1;
+	uint32_t WW	:3;
+	uint32_t ADRSFIX:1;
+	uint32_t	:2;
+	uint32_t SW	:2;
+	uint32_t WR	:4;
+	uint32_t WM	:1;
+	uint32_t	:4;
+	uint32_t HW	:2;
+);
+
+typedef volatile lword_union(sh7305_bsc_CSnWCR_45A5B_t,
+	uint32_t	:11;
+	uint32_t BAS	:1;
+	uint32_t	:1;
+	uint32_t WW	:3;
+	uint32_t	:3;
+	uint32_t SW	:2;
+	uint32_t WR	:4;
+	uint32_t WM	:1;
+	uint32_t	:4;
+	uint32_t HW	:2;
+);
+
+typedef volatile struct
+{
+	lword_union(CMNCR,
+		uint32_t	:6;
+		uint32_t CKOSTP	:1;
+		uint32_t CKODRV	:1;
+		uint32_t	:7;
+		uint32_t DMSTP	:1;
+		uint32_t	:1;
+		uint32_t BSD	:1;
+		uint32_t MAP	:2;
+		uint32_t BLOCK	:1;
+		uint32_t	:7;
+		uint32_t ENDIAN	:1;
+		uint32_t	:1;
+		uint32_t HIZMEM	:1;
+		uint32_t HIZCNT	:1;
+	);
+
+	sh7305_bsc_CSnBCR_t CS0BCR;
+	sh7305_bsc_CSnBCR_t CS2BCR;
+	sh7305_bsc_CSnBCR_t CS3BCR;
+	sh7305_bsc_CSnBCR_t CS4BCR;
+	sh7305_bsc_CSnBCR_t CS5ABCR;
+	sh7305_bsc_CSnBCR_t CS5BBCR;
+	sh7305_bsc_CSnBCR_t CS6ABCR;
+	sh7305_bsc_CSnBCR_t CS6BBCR;
+
+	sh7305_bsc_CSnWCR_06A6B_t  CS0WCR;
+	lword_union(CS2WCR,
+		uint32_t	:8;
+		uint32_t BW	:2;
+		uint32_t PMD	:1;
+		uint32_t BAS	:1;
+		uint32_t	:1;
+		uint32_t WW	:3;
+		uint32_t	:3;
+		uint32_t SW	:2;
+		uint32_t WR	:4;
+		uint32_t WM	:1;
+		uint32_t	:4;
+		uint32_t HW	:2;
+	);
+	lword_union(CS3WCR,
+		uint32_t	:17;
+		uint32_t TRP	:2;
+		uint32_t	:1;
+		uint32_t TRCD	:2;
+		uint32_t	:1;
+		uint32_t A3CL	:2;
+		uint32_t	:2;
+		uint32_t TRWL	:2;
+		uint32_t	:1;
+		uint32_t TRC	:2;
+	);
+	sh7305_bsc_CSnWCR_45A5B_t  CS4WCR;
+	sh7305_bsc_CSnWCR_45A5B_t  CS5AWCR;
+	sh7305_bsc_CSnWCR_45A5B_t  CS5BWCR;
+	sh7305_bsc_CSnWCR_06A6B_t  CS6AWCR;
+	sh7305_bsc_CSnWCR_06A6B_t  CS6BWCR;
+
+	lword_union(SDCR,
+		uint32_t	:11;
+		uint32_t A2ROW	:2;
+		uint32_t	:1;
+		uint32_t A2COL	:2;
+		uint32_t	:4;
+		uint32_t RFSH 	:1;
+		uint32_t RMODE	:1;
+		uint32_t PDOWN	:1;
+		uint32_t BACTV	:1;
+		uint32_t	:3;
+		uint32_t A3ROW	:2;
+		uint32_t	:1;
+		uint32_t A3COL	:2;
+	);
+
+	uint32_t RTCSR;
+	uint32_t RTCNT;
+	uint32_t RTCOR;
+
+} GPACKED(4) sh7305_bsc_t;
+
+#define SH7305_BSC (*(sh7305_bsc_t *)0xfec10000)
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* GINT_MPU_BSC */

include/gint/mpu/cpg.h

@@ -5,6 +5,10 @@
 #ifndef GINT_MPU_CPG
 #define GINT_MPU_CPG
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #include <gint/defs/attributes.h>
 #include <gint/defs/types.h>
 
@@ -28,6 +32,12 @@ typedef volatile struct
 		uint16_t PFC	:2;	/* Peripheral clock divider */
 	);
 
+	byte_union(UCLKCR,
+		uint8_t	USSCS	:2;	/* Source Clock Selection Bit */
+		uint8_t USBEN	:1;	/* USB On-Chip Oscillator Enable */
+		uint8_t		:5;
+	);
+
 } GPACKED(4) sh7705_cpg_t;
 
 #define SH7705_CPG (*((sh7705_cpg_t *)0xffffff80))
@@ -43,7 +53,7 @@ typedef volatile struct
    documentation. */
 typedef volatile struct
 {
-	lword_union(FRQCRA,
+	lword_union(FRQCR,
 		uint32_t KICK	:1;	/* Flush FRQCRA modifications */
 		uint32_t	:1;
 		uint32_t STC	:6;	/* PLL multiplication [*] */
@@ -64,7 +74,15 @@ typedef volatile struct
 		uint32_t SRC	:2;	/* Clock source select */
 		uint32_t DIVA	:6;	/* Division ratio for port A */
 	);
-	pad(0x08);
+	pad(0x04);
+
+	lword_union(DDCLKCR,
+		uint32_t	:23;
+		uint32_t CLKSTP	:1;	/* Clock Stop */
+		uint32_t _	:1;	/* Unknown */
+		uint32_t	:1;
+		uint32_t DIV	:6;
+	);
 
 	lword_union(USBCLKCR,
 		uint32_t	:23;
@@ -82,7 +100,9 @@ typedef volatile struct
 		uint32_t CKOFF	:1;	/* CKO Output Stop */
 		uint32_t	:1;
 	);
-	pad(0x14);
+
+	uint32_t PLL2CR;
+	pad(0x10);
 
 	lword_union(SPUCLKCR,
 		uint32_t	:23;
@@ -105,9 +125,16 @@ typedef volatile struct
 		uint32_t	:3;
 		uint32_t FLF	:11;	/* FLL Multiplication Ratio */
 	);
+	pad(0x0c);
+
+	uint32_t LSTATS;
 
 } GPACKED(4) sh7305_cpg_t;
 
 #define SH7305_CPG (*((sh7305_cpg_t *)0xa4150000))
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GINT_MPU_CPG */

include/gint/mpu/dma.h

@@ -9,6 +9,10 @@
 #ifndef GINT_MPU_DMA
 #define GINT_MPU_DMA
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #include <gint/defs/types.h>
 
 //---
@@ -86,4 +90,8 @@ typedef volatile struct
 
 #define SH7305_DMA (*((sh7305_dma_t *)0xfe008020))
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GINT_MPU_DMA */

include/gint/mpu/intc.h

@@ -12,6 +12,10 @@
 #ifndef GINT_MPU_INTC
 #define GINT_MPU_INTC
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #include <gint/defs/types.h>
 
 //---
@@ -294,7 +298,11 @@ typedef struct
 //---
 
 /* Provided by intc/intc.c */
-extern sh7705_intc_t SH7705_INTC;
-extern sh7305_intc_t SH7305_INTC;
+extern sh7705_intc_t const SH7705_INTC;
+extern sh7305_intc_t const SH7305_INTC;
+
+#ifdef __cplusplus
+}
+#endif
 
 #endif /* GINT_MPU_INTC */

include/gint/mpu/mmu.h

@@ -8,6 +8,10 @@
 #ifndef GINT_MPU_MMU
 #define GINT_MPU_MMU
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #include <gint/defs/attributes.h>
 #include <gint/defs/types.h>
 
@@ -45,12 +49,10 @@ typedef struct
 } GPACKED(4) tlb_data_t;
 
 //---
-//	SH7305 TLB. Refer to:
-//	  "Renesas SH7724 User's Manual: Hardware"
-//	  Section 7: "Memory Management Unit (MMU)"
+//	SH7305 TLB. Refer to SH4AL-DSP manual, section 7 (MMU)
 //---
 
-/* utlb_addr_t - address part of a UTLB entry */
+/* utlb_addr_t: Address part of a UTLB entry */
 typedef struct
 {
 	uint VPN	:22;
@@ -60,7 +62,7 @@ typedef struct
 
 } GPACKED(4) utlb_addr_t;
 
-/* utlb_data_t - data part of a UTLB entry */
+/* utlb_data_t: Data part of a UTLB entry */
 typedef struct
 {
 	uint		:3;
@@ -77,6 +79,34 @@ typedef struct
 
 } GPACKED(4) utlb_data_t;
 
+/* itlb_addr_t: Address part of an ITLB entry */
+typedef struct
+{
+	uint VPN	:22;
+	uint		:1;
+	uint V		:1;
+	uint ASID	:8;
+
+} GPACKED(4) itlb_addr_t;
+
+/* itlb_data_t: Data part of an ITLB entry */
+typedef struct
+{
+	uint		:3;
+	uint PPN	:19;
+	uint		:1;
+	uint V		:1;
+	uint SZ1	:1;
+	uint PR		:1;
+	uint		:1;
+	uint SZ0	:1;
+	uint C		:1;
+	uint 		:1;
+	uint SH		:1;
+	uint		:1;
+
+} GPACKED(4) itlb_data_t;
+
 typedef volatile struct
 {
 	lword_union(PTEH,
@@ -152,4 +182,8 @@ typedef volatile struct
 
 #define SH7305_MMU (*(sh7305_mmu_t *)0xff000000)
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GINT_MPU_MMU */

include/gint/mpu/pfc.h

@@ -8,6 +8,10 @@
 #ifndef GINT_MPU_PFC
 #define GINT_MPU_PFC
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #include <gint/defs/attributes.h>
 #include <gint/defs/types.h>
 
@@ -72,7 +76,164 @@ typedef volatile struct
 #define SH7705_PFC (*((sh7705_pfc_t *)0xa4000100))
 
 //---
-//	TODO: Document the SH7305 Pin Function Controller
+//  SH7305 Pin Function Controller.
+//  This is somewhat reminiscent of the SH7724, but there are many differences.
+//  The official emulator is the basis for this module.
 //---
 
+/* All port control registers (PCRx) have 2-bit entries specifying 4 pin modes:
+     00: Special functions
+     01: Output
+     10: Input (pull-up ON)
+     11: Input (pull-up OFF)
+
+   Some pins do not accept all settings. The SH7724 has these exceptions:
+   - PGCR (all pins): Input now allowed (00 and 01 only)
+   - PJCR.P5MD/P6MD/P7MD: Input not allowed (00 and 01 only)
+
+   Also, some entries are not configurable or are not mapped to actual pins.
+   Again the SH7724 has these exceptions:
+   - PGCR.P6MD/P7MD: No setting
+   - PJCR.P4MD: No setting
+   - PSCR.P7MD: No setting */
+typedef volatile word_union(sh7305_pfc_control_t,
+	uint16_t P7MD	:2;
+	uint16_t P6MD	:2;
+	uint16_t P5MD	:2;
+	uint16_t P4MD	:2;
+	uint16_t P3MD	:2;
+	uint16_t P2MD	:2;
+	uint16_t P1MD	:2;
+	uint16_t P0MD	:2;
+);
+
+/* Data register; a plain 8-bit value. Each bit can be either read or written
+   depending on the mode of the corresponding pin. */
+typedef volatile byte_union(sh7305_pfc_data_t,
+	uint8_t P7DT	:1;
+	uint8_t P6DT	:1;
+	uint8_t P5DT	:1;
+	uint8_t P4DT	:1;
+	uint8_t P3DT	:1;
+	uint8_t P2DT	:1;
+	uint8_t P1DT	:1;
+	uint8_t P0DT	:1;
+);
+
+typedef volatile struct
+{
+	sh7305_pfc_control_t
+		PACR, PBCR, PCCR, PDCR, PECR, PFCR, PGCR, PHCR,
+		PJCR, PKCR, PLCR, PMCR, PNCR, PQCR, PRCR, PSCR;
+
+	sh7305_pfc_data_t PADR;
+	pad(1);
+	sh7305_pfc_data_t PBDR;
+	pad(1);
+	sh7305_pfc_data_t PCDR;
+	pad(1);
+	sh7305_pfc_data_t PDDR;
+	pad(1);
+	sh7305_pfc_data_t PEDR;
+	pad(1);
+	sh7305_pfc_data_t PFDR;
+	pad(1);
+	sh7305_pfc_data_t PGDR;
+	pad(1);
+	sh7305_pfc_data_t PHDR;
+	pad(1);
+	sh7305_pfc_data_t PJDR;
+	pad(1);
+	sh7305_pfc_data_t PKDR;
+	pad(1);
+	sh7305_pfc_data_t PLDR;
+	pad(1);
+	sh7305_pfc_data_t PMDR;
+	pad(1);
+	sh7305_pfc_data_t PNDR;
+	pad(1);
+	sh7305_pfc_data_t PQDR;
+	pad(1);
+	sh7305_pfc_data_t PRDR;
+	pad(1);
+	sh7305_pfc_data_t PSDR;
+	pad(1);
+
+	sh7305_pfc_control_t PTCR;
+	sh7305_pfc_control_t PUCR;
+	sh7305_pfc_control_t PVCR;
+	pad(6);
+	sh7305_pfc_control_t PPCR;
+
+	/* PSEM*:  Multiplexing pin settings. These are highly MPU-dependent and
+	           the assignment is basically unknown.
+	   HIZCR*: High-impedance settings for pins' I/O buffers. */
+	uint16_t PSELA;
+	uint16_t PSELB;
+	uint16_t PSELC;
+	uint16_t PSELD;
+	uint16_t PSELE;
+	uint16_t HIZCRA;
+	uint16_t HIZCRB;
+	uint16_t HIZCRC;
+	uint16_t PSELF;
+
+	sh7305_pfc_data_t PTDR;
+	pad(1);
+	sh7305_pfc_data_t PUDR;
+	pad(1);
+	sh7305_pfc_data_t PVDR;
+	pad(5);
+	sh7305_pfc_data_t PPDR;
+	pad(0x15);
+
+	/* Module function selection registers.
+	   WARNING: These are the SH7724 bits, not necessarily the SH7305! */
+	word_union(MSELCRA,
+		uint16_t		:8;
+		uint16_t UNKNOWN_USB	:2;
+		uint16_t		:6;
+	);
+	word_union(MSELCRB,
+		uint16_t XTAL_USB	:2;
+		uint16_t		:6;
+		uint16_t SCIF2_PORT	:1;
+		uint16_t		:1;
+		uint16_t SCIF3_PORT	:1;
+		uint16_t		:3;
+		uint16_t LDC_VSYNC_DIR	:1;
+		uint16_t		:1;
+	);
+
+	// TODO: Doc
+	uint16_t DRVCRD, DRVCRA, DRVCRB, DRVCRC;
+	pad(4);
+
+	/* Pull-up control registers. Not sure what these are since that's
+	   normally handled in the modes for P*CR? */
+	uint8_t PULCRA, PULCRB, PULCRC, PULCRD, PULCRE, PULCRF, PULCRG,
+		PULCRH, PULCRJ, PULCRK, PULCRL, PULCRM, PULCRN, PULCRQ,
+		PULCRR, PULCRS;
+	pad(0x20);
+	uint8_t PULCRT;
+	uint8_t PULCRU;
+	uint8_t PULCRV;
+	uint8_t PULCRBSC;
+	pad(1);
+	uint8_t PULCRTRST;
+	uint8_t PULCRP;
+	pad(1);
+
+	uint16_t PSELG;
+	pad(12);
+	uint16_t PSELH;
+
+} sh7305_pfc_t;
+
+#define SH7305_PFC (*((sh7305_pfc_t *)0xa4050100))
+
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GINT_MPU_PFC */

include/gint/mpu/power.h

@@ -5,6 +5,10 @@
 #ifndef GINT_MPU_POWER
 #define GINT_MPU_POWER
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #include <gint/defs/types.h>
 
 //---
@@ -103,4 +107,8 @@ typedef volatile struct
 
 #define SH7305_POWER (*((sh7305_power_t *)0xa4150020))
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GINT_MPU_POWER */

include/gint/mpu/rtc.h

@@ -5,6 +5,10 @@
 #ifndef GINT_MPU_RTC
 #define GINT_MPU_RTC
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #include <gint/defs/attributes.h>
 
 //---
@@ -75,4 +79,8 @@ typedef volatile struct
 #define SH7705_RTC (*((rtc_t *)0xfffffec0))
 #define SH7305_RTC (*((rtc_t *)0xa413fec0))
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GINT_MPU_RTC */

include/gint/mpu/scif.h

@@ -0,0 +1,218 @@
+//---
+// gint:mpu:scif - Serial Communication Interface with FIFO (SCIF)
+//---
+
+#ifndef GINT_MPU_SCIF
+#define GINT_MPU_SCIF
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <gint/defs/attributes.h>
+#include <gint/defs/types.h>
+
+//---
+// SH7705 SCIF (from: SH7705 manual, section 16)
+//---
+
+typedef volatile struct
+{
+	/* Serial Mode Register */
+	word_union(SCSMR,
+		uint16_t	:5;
+		uint16_t SRC	:3; /* Sampling Control */
+		uint16_t CA	:1; /* Communication Mode */
+		uint16_t CHR	:1; /* Character Length */
+		uint16_t PE	:1; /* Parity Enable */
+		uint16_t OE	:1; /* Parity Mode */
+		uint16_t STOP	:1; /* Stop Bit Length */
+		uint16_t	:1;
+		uint16_t CKS	:2; /* Clock Select */
+	);
+	pad(0x2);
+
+	/* Bit Rate Register */
+	uint8_t SCBRR;
+	pad(0x3);
+
+	/* Serial Control Register */
+	word_union(SCSCR,
+		uint16_t	:4;
+		uint16_t TSIE	:1; /* Transmit Data Stop Interrupt Enable */
+		uint16_t ERIE	:1; /* Receive Error Interrupt Enable */
+		uint16_t BRIE	:1; /* Break Interrupt Enable */
+		uint16_t DRIE	:1; /* Receive Data Ready Interrupt Enable */
+		uint16_t TIE	:1; /* Transmit Interrupt Enable */
+		uint16_t RIE	:1; /* Receive Interrupt Enable */
+		uint16_t TE	:1; /* Transmit Enable */
+		uint16_t RE	:1; /* Receive Mode */
+		uint16_t	:2;
+		uint16_t CKE	:2; /* Clock Enable */
+	);
+	pad(0x2);
+
+	/* Transmit Data Stop Register */
+	uint8_t SCTDSR;
+	pad(0x3);
+
+	/* FIFO Error Count Register */
+	word_union(SCFER,
+		uint16_t	:2;
+		uint16_t PER	:6; /* Parity Error Count */
+		uint16_t	:2;
+		uint16_t FER	:6; /* Framing Error Count */
+	);
+	pad(0x2);
+
+	/* Serial Status Register */
+	word_union(SCSSR,
+		uint16_t	:6;
+		uint16_t ORER	:1; /* Overrun Error */
+		uint16_t TSF	:1; /* Transmit Data Stop */
+		uint16_t ER	:1; /* Receive Error */
+		uint16_t TEND	:1; /* Transmit End */
+		uint16_t TDFE	:1; /* Transmit FIFO Data Empty */
+		uint16_t BRK	:1; /* Break Detect */
+		uint16_t FER	:1; /* Framing Error */
+		uint16_t PER	:1; /* Parity Error */
+		uint16_t RDF	:1; /* Receive FIFO Data Full */
+		uint16_t DR	:1; /* Receive Data Ready */
+
+	);
+	pad(0x2);
+
+	/* FIFO Control Register */
+	word_union(SCFCR,
+		uint16_t TSE	:1; /* Transmit Data Stop Enable */
+		uint16_t TCRST	:1; /* Transmit Count Reset */
+		uint16_t	:3;
+		uint16_t RSTRG	:3; /* RTS Output Active Trigger */
+		uint16_t RTRG	:2; /* Receive FIFO Data Number Trigger */
+		uint16_t TTRG	:2; /* Transmit FIFO Data Number Trigger */
+		uint16_t MCE	:1; /* Modem Control Enable */
+		uint16_t TFRST	:1; /* Transmit FIFO Data Register Reset */
+		uint16_t RFRST	:1; /* Receive FIFO Data Register Reset */
+		uint16_t LOOP	:1; /* Loopback Test */
+	);
+	pad(0x2);
+
+	/* FIFO Data Count Register */
+	word_union(SCFDR,
+		uint16_t	:1;
+		uint16_t T	:7; /* Pending bytes in transmit FIFO */
+		uint16_t	:1;
+		uint16_t R	:7; /* Received bytes in receive FIFO */
+	);
+	pad(0x2);
+
+	/* Serial FIFO Transmit Data Register (64 bytes rolling register) */
+	uint8_t SCFTDR;
+	pad(0x3);
+
+	/* Serial FIFO Receive Data Register (64 bytes rolling register) */
+	uint8_t SCFRDR;
+
+} GPACKED(4) sh7705_scif_t;
+
+#define SH7705_SCIF (*((sh7705_scif_t *)0xa4410000))
+
+//---
+// SH7305 SCIF (from: SH7305 emulator and SH7730 SCIF)
+// The module is very close to the SH7724 but it has a couple extra bits in
+// SCFCR, which shows that it is closer to the SH7730 SCIF.
+//---
+
+typedef volatile struct
+{
+	/* Serial Mode Register */
+	word_union(SCSMR,
+		uint16_t	:8;
+		uint16_t CA	:1; /* Communication Mode */
+		uint16_t CHR	:1; /* Character Length */
+		uint16_t PE	:1; /* Parity Enable */
+		uint16_t OE	:1; /* Parity Mode */
+		uint16_t STOP	:1; /* Stop Bit Length */
+		uint16_t	:1;
+		uint16_t CKS	:2; /* Clock Select */
+	);
+	pad(0x2);
+
+	/* Serial Bit Rate Register */
+	uint8_t SCBRR;
+	pad(0x3);
+
+	/* Serial Control Register */
+	word_union(SCSCR,
+		uint16_t	:8;
+		uint16_t TIE	:1; /* Transmit Interrupt Enable */
+		uint16_t RIE	:1; /* Receive Interrupt Enable */
+		uint16_t TE	:1; /* Transmit Enable */
+		uint16_t RE	:1; /* Receive Mode */
+		uint16_t REIE	:1; /* Receive Error Interrupt Enable */
+		uint16_t	:1;
+		uint16_t CKE	:2; /* Clock Enable */
+	);
+	pad(0x2);
+
+	/* Serial FIFO Transmit Data Register */
+	uint8_t SCFTDR;
+	pad(0x3);
+
+	/* Serial FIFO Status Register */
+	word_union(SCFSR,
+		uint16_t const PERC	:4; /* Number of Parity Errors */
+		uint16_t const FERC	:4; /* Number of Framing Errors */
+		uint16_t ER		:1; /* Receive Error */
+		uint16_t TEND		:1; /* Transmit End */
+		uint16_t TDFE		:1; /* Transmit FIFO Data Empty */
+		uint16_t BRK		:1; /* Break Detection */
+		uint16_t const FER	:1; /* Framing Error */
+		uint16_t const PER	:1; /* Parity Error */
+		uint16_t RDF		:1; /* Receive FIFO Data Full */
+		uint16_t DR		:1; /* Data Ready */
+	);
+	pad(0x2);
+
+	/* Serial FIFO Receive Data Register */
+	uint8_t SCFRDR;
+	pad(0x3);
+
+	/* Serial FIFO Control Register */
+	word_union(SCFCR,
+		uint16_t	:5;
+		uint16_t RSTRG	:3; /* RTS Output Active Trigger */
+		uint16_t RTRG	:2; /* Receive FIFO Data Trigger */
+		uint16_t TTRG	:2; /* Transmit FIFO Data Trigger */
+		uint16_t MCE	:1; /* Model Control Enable */
+		uint16_t TFRST	:1; /* Transmit FIFO Data Register Reset */
+		uint16_t RFRST	:1; /* Receive FIFO Data Register Reset */
+		uint16_t LOOP	:1; /* Loopback Test */
+	);
+	pad(0x2);
+
+	/* Serial FIFO Data Count Register */
+	word_union(SCFDR,
+		uint16_t	:3;
+		uint16_t TFDC	:5; /* Number of Data Bytes in Transmit FIFO */
+		uint16_t	:3;
+		uint16_t RFDC	:5; /* Number of Data Bytes in Receive FIFO */
+	);
+	pad(0x6);
+
+	/* Serial Line Status */
+	word_union(SCLSR,
+		uint16_t	:15;
+		uint16_t ORER	:1; /* Overrun Error */
+	);
+	pad(0x2);
+
+} GPACKED(4) sh7305_scif_t;
+
+#define SH7305_SCIF (*((sh7305_scif_t *)0xa4410000))
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* GINT_MPU_SCIF */

include/gint/mpu/spu.h

@@ -5,6 +5,10 @@
 #ifndef GINT_MPU_SPU
 #define GINT_MPU_SPU
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #include <gint/defs/types.h>
 
 typedef volatile struct
@@ -94,4 +98,8 @@ typedef volatile struct
 #define SH7305_DSP0 (*(spu_dsp_t *)0xfe2ffd00)
 #define SH7305_DSP1 (*(spu_dsp_t *)0xfe3ffd00)
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GINT_MPU_SPU */

include/gint/mpu/tmu.h

@@ -9,6 +9,10 @@
 #ifndef GINT_MPU_TMU
 #define GINT_MPU_TMU
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #include <gint/defs/types.h>
 
 //---
@@ -101,4 +105,8 @@ typedef volatile struct
 typedef volatile etmu_t sh7305_etmu_t[6];
 #define SH7305_ETMU (*(sh7305_etmu_t *)0xa44d0030)
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GINT_MPU_TMU */

include/gint/mpu/usb.h

@@ -5,8 +5,25 @@
 #ifndef GINT_MPU_USB
 #define GINT_MPU_USB
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #include <gint/defs/types.h>
 
+typedef struct
+{
+	word_union(TRE,
+		uint16_t	:6;
+		uint16_t TRENB	:1;	/* Transaction Counter Enable */
+		uint16_t TRCLR	:1;	/* Transaction Counter Clear */
+		uint16_t	:8;
+	);
+	word_union(TRN,
+		uint16_t TRCNT	:16;	/* Transaction Counter */
+	);
+} sh7305_usb_pipetr;
+
 typedef volatile struct
 {
 	/* System Configuration Control Register */
@@ -24,12 +41,16 @@ typedef volatile struct
 
 	/* CPU Bus Wait Setting Register */
 	word_union(BUSWAIT,
-		uint16_t	:12;
+		uint16_t	:8;
+		uint16_t _1	:1;	/* Unknown role; can be set */
+		uint16_t	:1;
+		uint16_t _2	:1;	/* Unknown role; can be set */
+		uint16_t	:1;
 		uint16_t BWAIT	:4;	/* Bus Wait */
 	);
 
 	/* System Configuration Status Register */
-	word_union(SYSSTS,
+	const word_union(SYSSTS,
 		uint16_t	:14;
 		uint16_t LNST	:2;	/* Line Status */
 	);
@@ -37,7 +58,9 @@ typedef volatile struct
 
 	/* Device State Control Register */
 	word_union(DVSTCTR,
-		uint16_t	:7;
+		uint16_t _1	:1;	/* Unknown role; can be set */
+		uint16_t	:2;
+		uint16_t _2	:4;	/* Unknown role; can be set */
 		uint16_t WKUP	:1;	/* Wakeup Output */
 		uint16_t RWUPE	:1;	/* Wakeup Detection Enable */
 		uint16_t USBRT	:1;	/* USB Reset Output */
@@ -88,8 +111,9 @@ typedef volatile struct
 		uint16_t DREQE	:1;	/* DMA Transfert Request Enable */
 		uint16_t MBW	:2;	/* Access Bits Width */
 		uint16_t	:1;
-		uint16_t BIGEND	:1;	/* Endiant Control */
-		uint16_t	:4;
+		uint16_t BIGEND	:1;	/* Endian Control */
+		uint16_t _1	:1;	/* Unknown role; can be set */
+		uint16_t	:3;
 		uint16_t CURPIPE:4;	/* Port Access Pipe Specification */
 	);
 	word_union(D0FIFOCTR,
@@ -107,7 +131,8 @@ typedef volatile struct
 		uint16_t MBW	:2;	/* Access Bits Width */
 		uint16_t	:1;
 		uint16_t BIGEND	:1;	/* Endian Control */
-		uint16_t	:4;
+		uint16_t _1	:1;	/* Unknown role; can be set */
+		uint16_t	:3;
 		uint16_t CURPIPE:4;	/* Port Access Pipe Specification */
 	);
 	word_union(D1FIFOCTR,
@@ -130,50 +155,26 @@ typedef volatile struct
 		uint16_t BRDYE	:1;	/* Buffer Ready */
 		uint16_t	:8;
 	);
-	pad(4);
+	word_union(INTENB1,
+		uint16_t _1	:1;	/* Unknown role; can be set */
+		uint16_t BCHGE	:1;	/* Bus Change */
+		uint16_t	:1;
+		uint16_t DTCHE	:1;	/* Disconnection Detection */
+		uint16_t ATTCHE	:1;	/* Connection Detection */
+		uint16_t	:4;
+		uint16_t EOFERRE:1;	/* EOF Error Detection */
+		uint16_t SIGNE	:1;	/* Setup Transaction Error */
+		uint16_t SACKE	:1;	/* Setup Transaction Normal Response */
+		uint16_t	:4;
+	);
+	pad(2);
 
 	/* BRDY Interrupt Enable Register */
-	word_union(BRDYENB,
-		uint16_t	:6;
-		uint16_t PIPE9BRDYE :1;
-		uint16_t PIPE8BRDYE :1;
-		uint16_t PIPE6BRDYE :1;
-		uint16_t PIPE7BRDYE :1;
-		uint16_t PIPE5BRDYE :1;
-		uint16_t PIPE3BRDYE :1;
-		uint16_t PIPE4BRDYE :1;
-		uint16_t PIPE2BRDYE :1;
-		uint16_t PIPE1BRDYE :1;
-		uint16_t PIPE0BRDYE :1;
-	);
+	uint16_t BRDYENB;
 	/* NRDY Interrupt Enable Register */
-	word_union(NRDYENB,
-		uint16_t	:6;
-		uint16_t PIPE9NRDYE :1;
-		uint16_t PIPE8NRDYE :1;
-		uint16_t PIPE6NRDYE :1;
-		uint16_t PIPE7NRDYE :1;
-		uint16_t PIPE5NRDYE :1;
-		uint16_t PIPE3NRDYE :1;
-		uint16_t PIPE4NRDYE :1;
-		uint16_t PIPE2NRDYE :1;
-		uint16_t PIPE1NRDYE :1;
-		uint16_t PIPE0NRDYE :1;
-	);
+	uint16_t NRDYENB;
 	/* BEMP Interrupt Enable Register */
-	word_union(BEMPENB,
-		uint16_t	:6;
-		uint16_t PIPE9BEMPE :1;
-		uint16_t PIPE8BEMPE :1;
-		uint16_t PIPE6BEMPE :1;
-		uint16_t PIPE7BEMPE :1;
-		uint16_t PIPE5BEMPE :1;
-		uint16_t PIPE3BEMPE :1;
-		uint16_t PIPE4BEMPE :1;
-		uint16_t PIPE2BEMPE :1;
-		uint16_t PIPE1BEMPE :1;
-		uint16_t PIPE0BEMPE :1;
-	);
+	uint16_t BEMPENB;
 
 	/* SOF Control Register */
 	word_union(SOFCFG,
@@ -182,7 +183,10 @@ typedef volatile struct
 		uint16_t	:1;
 		uint16_t BRDYM	:1;	/* BRDY Status Clear Timing */
 		uint16_t enable	:1; 	/* SHOULD BE SET TO 1 MANUALLY */
-		uint16_t	:5;
+		uint16_t	:1;
+		uint16_t _1	:1;	/* Unknown role; can be set */
+		uint16_t _2	:1;	/* Unknown role; can be set */
+		uint16_t	:2;
 	);
 	pad(2);
 
@@ -201,56 +205,32 @@ typedef volatile struct
 		uint16_t VALID	:1;	/* USB Request Reception */
 		uint16_t CTSQ	:3;	/* Control Transfer Stage */
 	);
-	pad(4);
+	word_union(INTSTS1,
+		uint16_t _1	:1;	/* Unknown role */
+		uint16_t BCHG	:1;	/* Bus Change */
+		uint16_t	:1;
+		uint16_t DTCH	:1;	/* Disconnection Detection */
+		uint16_t ATTCH	:1;	/* Connection Detection */
+		uint16_t	:4;
+		uint16_t EOFERR	:1;	/* EOF Error Detection */
+		uint16_t SIGN	:1;	/* Setup Transaction Error */
+		uint16_t SACK	:1;	/* Setup Transaction Normal Response */
+		uint16_t	:4;
+	);
+	pad(2);
 
 	/* BRDY Interrupt Status Register */
-	word_union(BRDYSTS,
-		uint16_t	:6;
-		uint16_t PIPE9BRDY :1;
-		uint16_t PIPE8BRDY :1;
-		uint16_t PIPE6BRDY :1;
-		uint16_t PIPE7BRDY :1;
-		uint16_t PIPE5BRDY :1;
-		uint16_t PIPE3BRDY :1;
-		uint16_t PIPE4BRDY :1;
-		uint16_t PIPE2BRDY :1;
-		uint16_t PIPE1BRDY :1;
-		uint16_t PIPE0BRDY :1;
-	);
+	uint16_t BRDYSTS;
 	/* NRDY Interrupt Status Register */
-	word_union(NRDYSTS,
-		uint16_t	:6;
-		uint16_t PIPE9NRDY :1;
-		uint16_t PIPE8NRDY :1;
-		uint16_t PIPE6NRDY :1;
-		uint16_t PIPE7NRDY :1;
-		uint16_t PIPE5NRDY :1;
-		uint16_t PIPE3NRDY :1;
-		uint16_t PIPE4NRDY :1;
-		uint16_t PIPE2NRDY :1;
-		uint16_t PIPE1NRDY :1;
-		uint16_t PIPE0NRDY :1;
-	);
+	uint16_t NRDYSTS;
 	/* BEMP Interrupt Status Register */
-	word_union(BEMPSTS,
-		uint16_t	:6;
-		uint16_t PIPE9BEMP :1;
-		uint16_t PIPE8BEMP :1;
-		uint16_t PIPE6BEMP :1;
-		uint16_t PIPE7BEMP :1;
-		uint16_t PIPE5BEMP :1;
-		uint16_t PIPE3BEMP :1;
-		uint16_t PIPE4BEMP :1;
-		uint16_t PIPE2BEMP :1;
-		uint16_t PIPE1BEMP :1;
-		uint16_t PIPE0BEMP :1;
-	);
+	uint16_t BEMPSTS;
 
 	/* Frame Number Registers */
 	word_union(FRMNUM,
 		uint16_t OVRN	:1;	/* Overrun/Underrun Detection Status */
 		uint16_t CRCE	:1;	/* Receive Data Error */
-		uint16_t cons	:3;
+		uint16_t const	:3;
 		uint16_t FRNM	:11;	/* Frame Number */
 	);
 	word_union(UFRMNUM,
@@ -285,7 +265,10 @@ typedef volatile struct
 
 	/* DCP Configuration Register */
 	word_union(DCPCFG,
-		uint16_t	:11;
+		uint16_t	:7;
+		uint16_t _1	:1;	/* Unknown role; can be set */
+		uint16_t _2	:1;	/* Unknown role; can be set */
+		uint16_t	:2;
 		uint16_t DIR	:1;	/* Transfer Direction */
 		uint16_t	:4;
 	);
@@ -337,7 +320,7 @@ typedef volatile struct
 	/* Pipe Buffer Setting Register */
 	word_union(PIPEBUF,
 		uint16_t	:1;
-		uint16_t BUFSIZE	: 5;	/* Buffer Size */
+		uint16_t BUFSIZE:5;	/* Buffer Size */
 		uint16_t	:2;
 		uint16_t BUFNMB	:8;	/* Buffer Number */
 	);
@@ -375,56 +358,20 @@ typedef volatile struct
 	);
 	pad(14);
 
-	/* PIPEn Transaction Counter Enable Registers and */
-	/* PIPEn Transaction Counter Registers */
-	word_union(PIPE1TRE,
-		uint16_t	:6;
-		uint16_t TRENB	:1;	/* Transaction Counter Enable */
-		uint16_t TRCLR	:1;	/* Transaction Counter Clear */
-		uint16_t	:8;
-	);
-	word_union(PIPE1TRN,
-		uint16_t TRCNT	:16;	/* Transaction Counter */
-	);
-	word_union(PIPE2TRE,
-		uint16_t	:6;
-		uint16_t TRENB	:1;	/* Transaction Counter Enable */
-		uint16_t TRCLR	:1;	/* Transaction Counter Clear */
-		uint16_t	:8;
-	);
-	word_union(PIPE2TRN,
-		uint16_t TRCNT	:16;	/* Transaction Counter */
-	);
-	word_union(PIPE3TRE,
-		uint16_t	:6;
-		uint16_t TRENB	:1;	/* Transaction Counter Enable */
-		uint16_t TRCLR	:1;	/* Transaction Counter Clear */
-		uint16_t	:8;
-	);
-	word_union(PIPE3TRN,
-		uint16_t TRCNT	:16;	/* Transaction Counter */
-	);
-	word_union(PIPE4TRE,
-		uint16_t	:6;
-		uint16_t TRENB	:1;	/* Transaction Counter Enable */
-		uint16_t TRCLR	:1;	/* Transaction Counter Clear */
-		uint16_t	:8;
-	);
-	word_union(PIPE4TRN,
-		uint16_t TRCNT	:16;	/* Transaction Counter */
-	);
-	word_union(PIPE5TRE,
-		uint16_t	:6;
-		uint16_t TRENB	:1;	/* Transaction Counter Enable */
-		uint16_t TRCLR	:1;	/* Transaction Counter Clear */
-		uint16_t	:8;
-	);
-	word_union(PIPE5TRN,
-		uint16_t TRCNT	:16;	/* Transaction Counter */
-	);
+	/* Transaction Counter Registers (PIPE1..PIPE5 only) */
+	sh7305_usb_pipetr PIPETR[5];
 	pad(0x1e);
 
 	uint16_t REG_C2;
+	pad(12);
+
+	word_union(DEVADD[11],
+		uint16_t	:1;
+		uint16_t UPPHUB	:4;	/* Address of target's hub */
+		uint16_t HUBPORT:3;	/* Hub port where target connects */
+		uint16_t USBSPD	:2;	/* Transfer speed / Target present */
+		uint16_t	:6;
+	);
 
 } GPACKED(4) sh7305_usb_t;
 
@@ -437,4 +384,8 @@ typedef volatile word_union(sh7305_usb_uponcr_t,
 #define SH7305_USB (*(sh7305_usb_t *)0xa4d80000)
 #define SH7305_USB_UPONCR (*(sh7305_usb_uponcr_t *)0xa40501d4)
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GINT_MPU_USB */

include/gint/mpu/wdt.h

@@ -0,0 +1,52 @@
+//---
+// gint:mpu:wdt - Watchdog Timer
+//---
+
+#ifndef GINT_MPU_WDT
+#define GINT_MPU_WDT
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <gint/defs/attributes.h>
+#include <gint/defs/types.h>
+
+//---
+//	SH7705 WatchDog Timer. Refer to:
+//	  "Renesas SH7705 Group Hardware Manual"
+//	  Section 10: "WatchDog Timer (WDT)"
+//---
+
+/* sh7705_wdt_t - Watch Dog Timer */
+typedef volatile struct
+{
+	/* WDT registers are unique in access size; reads are performed with
+	   8-bit accesses, but writes are performed with 16-bit accesses. */
+
+	union {
+		uint8_t READ;
+		uint16_t WRITE;
+	} WTCNT;
+
+	union {
+		byte_union(READ,
+			uint8_t TME	:1; /* Timer Enable */
+			uint8_t WTIT	:1; /* Watchdog/Interval Select */
+			uint8_t RSTS	:1; /* Watchdog Reset Select */
+			uint8_t WOVF	:1; /* Watchdog Overflow Flag */
+			uint8_t IOVF	:1; /* Interval Overflow Flag */
+			uint8_t CKS	:3; /* Clock Select */
+		);
+		uint16_t WRITE;
+	} WTCSR;
+
+} sh7705_wdt_t;
+
+#define SH7705_WDT (*((sh7705_wdt_t *)0xffffff84))
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* GINT_MPU_WDT */

include/gint/rtc.h

@@ -5,6 +5,10 @@
 #ifndef GINT_RTC
 #define GINT_RTC
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #include <gint/defs/types.h>
 #include <gint/defs/call.h>
 #include <gint/timer.h>
@@ -13,7 +17,11 @@
 //	Time management
 //---
 
-/* rtc_time_t: A point in time, representable in the RTC registers */
+/* rtc_time_t: A point in time, representable in the RTC registers
+
+   WARNING: A copy of this definition is used in fxlibc, make sure to keep it
+   in sync. (We don't install kernel headers before compiling the fxlibc, it's
+   kind of a nightmare for the modest build system.) */
 typedef struct
 {
 	uint16_t year;		/* Years (exact value, e.g. 2018) */
@@ -96,4 +104,8 @@ int rtc_start_timer(int frequency, timer_callback_t callback, ...);
 __attribute__((deprecated("Use rtc_periodic_disable() instead")))
 void rtc_stop_timer(void);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GINT_RTC */

include/gint/serial.h

@@ -0,0 +1,64 @@
+//---
+// gint:serial - Serial communication
+//---
+
+// TODO: This is a template for a future implementation.
+
+#ifndef GINT_SERIAL
+#define GINT_SERIAL
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <gint/defs/types.h>
+#include <gint/defs/call.h>
+
+typedef enum {
+	SERIAL_PARITY_NONE,
+	SERIAL_PARITY_EVEN,
+	SERIAL_PARITY_ODD,
+
+} GPACKEDENUM serial_parity_t;
+
+typedef struct {
+	/* Baud rate (valid options are 300, 600, 1200, 2400, 4800, 9600,
+	   19200, 38400, 57600 and 115200) */
+	int baudrate;
+	/* Parity */
+	serial_parity_t parity;
+	/* Data width (valid options are 7 and 8) */
+	uint8_t data_width;
+	/* Stop bits (valid options are 1 and 2) */
+	uint8_t stop_bits;
+
+} serial_config_t;
+
+// TODO: Error management...
+
+int serial_open(serial_config_t const *config);
+
+bool serial_is_open(void);
+
+void serial_write_async(void const *data, size_t size, gint_call_t callback);
+
+void serial_write_sync(void const *data, size_t size);
+
+void serial_read_async(void const *data, size_t size, gint_call_t callback);
+
+void serial_read_sync(void const *data, size_t size);
+
+// Waits for communications to finish
+void serial_wait(void);
+
+// Calls serial_wait() automatically
+void serial_close(void);
+
+// TODO: Info on how much data is pending in each buffer?
+// Ultimately we'll bind this to a file descriptor so we can't really know.
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* GINT_SERIAL */

include/gint/timer.h

@@ -5,6 +5,10 @@
 #ifndef GINT_TIMER
 #define GINT_TIMER
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #include <gint/mpu/tmu.h>
 #include <gint/hardware.h>
 #include <gint/defs/types.h>
@@ -158,10 +162,11 @@ void timer_stop(int timer);
    it may have only paused. If the timer never stops, you're in trouble. */
 void timer_wait(int timer);
 
-/* timer_spinwait(): Actively wait for a timer to raise UNF
+/* timer_spinwait(): Start a timer and actively wait for UNF
    Waits until the timer raises UNF, without sleeping. This is useful for
-   delays in driver code that is run when interrupts are disabled. This relies
-   neither on the interrupt signal nor on the UNIE flag. */
+   delays in driver code that is run when interrupts are disabled. UNIE is
+   disabled before starting the timer and waiting, so the callback is never
+   called. */
 void timer_spinwait(int timer);
 
 //---
@@ -236,4 +241,8 @@ int timer_setup(int timer, uint64_t delay_us, timer_callback_t callback, ...);
    Use GINT_CALL_SET_STOP() with timer_configure() instead. */
 int timer_timeout(volatile void *arg);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GINT_TIMER */

include/gint/usb-ff-bulk.h

@@ -1,24 +1,124 @@
 //---
-// gint:usb-ff-bulk - A trivial bulk-based transfer class
+// gint:usb-ff-bulk - A bulk-based transfer class using the fxlink protocol
+//
+// This interface (class code 0xff/0x77) implements a simple bidirectional
+// communication channel running the fxlink protocol. It basically talks to
+// fxlink's interactive mode on the host, and can broadly be used for 4 things:
+//
+// 1. Sending standard messages to fxlink (screenshots, logs...). Convenient
+//    functions are provided in this header to minimize the overhead. fxlink
+//    running in interactive mode (fxlink -t) will handle these messages in a
+//    suitable way automatically (eg. save screenshots as PNG).
+//
+// 2. Sending custom messages to fxlink (bench results, memory dumps, crash
+//    reports...). fxlink running in interactive mode will forward the data to
+//    appropriate user-provided external programs to handle the messages.
+//
+// 3. Applications based around on data streams coming from the host (screen
+//    projector, web browser...). This can be achieved by modifying fxlink or
+//    using it as a library.
+//
+// 4. Remote control from the fxlink interactive mode (fxlink -t). This is
+//    based on fxlink's 'command' and 'keyboard' protocols. This module will
+//    automatically handle commands and respond to them as long as the message
+//    handling function is called regularly.
 //---
 
 #ifndef GINT_USB_FF_BULK
 #define GINT_USB_FF_BULK
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #include <gint/usb.h>
+struct usb_fxlink_header;
 
-/* The bulk transfer interface with class code 0xff provides a very simple
-   communication channel between the calculator and a host. There is
-   (currently) a single IN pipe that sends data from the calculator to the
-   host, at high-speed (USB 2.0).
-
-   The class code of this interface is 0xff, which means that the protocol is
-   custom and requires a custom program on the host to receive the data (unlike
-   for instance LINK on a Graph 90+E which behaves as a USB stick and can be
-   used with the file browser). fxlink can be used to the effect. */
-
+/* This bulk transfer interface with class code 0xff/0x77 implements a simple
+   bidirectional communication channel between the calculator and a host,
+   running at high-speed USB 2.0 and using the fxlink protocol. You can use it
+   to communicate with fxlink's interactive mode on the host. */
 extern usb_interface_t const usb_ff_bulk;
 
+//---
+// Sending standard messages
+//---
+
+/* usb_fxlink_text(): Send raw text
+   Send a string; fxlink will display it in the terminal. This can be used to
+   back stdout/stderr. Sending lots of small messages can be slow; if that's a
+   problem, fill in message manually. If size is 0, uses strlen(text). */
+void usb_fxlink_text(char const *text, int size);
+
+/* usb_fxlink_screenshot(): Take a screenshot
+
+   This function sends a copy of the VRAM to fxlink. This is best used just
+   before dupdate() since this ensures the image sent by USB is identical to
+   the one displayed on screen.
+
+   If `onscreen` is set and there are two VRAMs (on fx-CG or when using the
+   gray engine on fx-9860G), sends a copy of the other VRAM. This is a bit more
+   intuitive when taking a screenshot of the last shown image as a result of a
+   key press. Note that this function never reads pixels directly from the
+   display (it's usually slow and currently not even implemented). */
+void usb_fxlink_screenshot(bool onscreen);
+
+/* usb_fxlink_videocapture(): Send a frame for a video recording
+
+   This function is essentially the same as usb_fxlink_screenshot(). It sends a
+   capture of the VRAM to fxlink but uses the "video" type, which fxlink
+   displays in real-time or saves as a video file. The meaning of the onscreen
+   setting is identical to usb_fxlink_screenshot().
+
+   This function can be called with onscreen=false as a dupdate() hook to
+   automatically send new frames to fxlink. */
+void usb_fxlink_videocapture(bool onscreen);
+
+#ifdef FX9860G
+/* Similar to usb_fxlink_screenshot(), but takes a gray screenshot if the gray
+   engine is currently running. */
+void usb_fxlink_screenshot_gray(bool onscreen);
+
+/* Like usb_fxlink_videocapture(), but uses VRAM data from the gray engine. */
+void usb_fxlink_videocapture_gray(bool onscreen);
+#endif
+
+//---
+// Receiving messages
+//---
+
+/* usb_fxlink_handle_messages(): Process and return incoming messages
+
+   This function processes incoming messages. It handles some types of messages
+   internally (eg. fxlink commands) and returns the others to the caller by
+   loading the provided header structure and returning true.
+
+   When this function returns true, the caller should read the message contents
+   on the interface's input pipe. Usually every read will return just a portion
+   of the message (eg. 2048 bytes) so the contents should be read with a loop.
+
+   As long as this function returns true it should be called againt to process
+   any other messages. When there is no more messages to process, this function
+   returns false. It is important to call this function regularly from the main
+   thread when quick responses are expected. */
+bool usb_fxlink_handle_messages(struct usb_fxlink_header *header);
+
+/* usb_fxlink_drop_transaction(): Drop incoming data until end of transaction
+
+   When a message arrives on the USB port incoming data *must* be processed in
+   order for the pipe to accept any further data in the future. This function
+   can be used in error situations to drop data until the end of the
+   transaction (which is usually the end of the message, at least with the
+   fxSDK's implementation of fxlink). */
+void usb_fxlink_drop_transaction(void);
+
+/* usb_fxlink_set_notifier(): Set up a notification for incoming messages
+
+   Registers the provided function to be called when data arrives on the fxlink
+   input pipe. This signals that usb_fxlink_handle_messages() should be called
+   later from the main thread. Pass NULL to disable the notification. */
+void usb_fxlink_set_notifier(void (*notifier_function)(void));
+
 //---
 // Direct bulk access
 //
@@ -27,48 +127,36 @@ extern usb_interface_t const usb_ff_bulk;
 // functions.
 //---
 
-/* usb_ff_bulk_output(): Pipe for calculator -> host communication */
+/* usb_ff_bulk_output(): Pipe number for calculator -> host communication */
 int usb_ff_bulk_output(void);
 
+/* usb_ff_bulk_input(): Pipe number for host -> calculator communication */
+int usb_ff_bulk_input(void);
+
 //---
-// fxlink protocol
+// Construction and analysis of fxlink protocol messages
 //
-// fxlink is a bulk-based communication tool in the fxSDK that can be used to
-// conveniently transfer or manipulate information during the execution of an
-// add-in. For instance, screenshots can be saved, files can be transferred,
-// and text can be logged.
+// fxlink messages consist of a simple header followed by message contents
+// (sometimes with a subheader). In addition to the functions above, it is
+// possible to craft custom fxlink messages and send them manually.
 //
-// Each communication with fxlink is a message that consists of:
-// * A first write with a message header;
-// * One or more writes with message data (of a size announced in the header);
-// * A commit on the USB pipe (to ensure that everything is sent).
-//
-// There are two ways to use the fxlink protocol in this header; you can either
-// use one of the convenience functions like usb_fxlink_screenshot() that do
-// all the steps for you, or you can perform the writes and commits yourself to
-// send custom messages.
+// To send a message manually, simple write an fxlink header to the output
+// pipe, followed by the contents. The message can be built from any number of
+// writes to the pipe. After the last write, commit the pipe.
 //---
 
 /* usb_fxlink_header_t: Message header for fxlink
 
-   fxlink supports a minimalistic protocol to receive data sent from the
-   calculator and automatically process it (such as save it to file, convert
-   to an image, etc). It is designed as a convenience feature, and it can be
-   extended with custom types rather easily.
+   Messages are categorized with an (application, type) pair; both are UTF-8
+   strings of up to 16 bytes (NUL not required). The application name "fxlink"
+   is reserved for built-in types of messages. Other names can be used freely,
+   and fxlink's interactive mode on the host side will forward messages to
+   external programs based on the application name.
 
-   A message is categorized with an (application, type) pair; both are UTF-8
-   strings of up to 16 characters. The application name "fxlink" is reserved
-   for built-in types supported by fxlink; any other custom application name
-   can be set (in which case fxlink will call a user-provided program to handle
-   the message).
-
-   The size of the data to be transferred must be specified in order of the
-   transfer to proceed correctly, as it cannot reliably be guessed on the other
-   side (and guessing wrong means all further messages will be in trouble).
-
-   As with the rest of the USB protocol, all the multi-byte integer fields in
-   this header are encoded as *little-endian*. */
-typedef struct
+   The size of the data to be transferred must be specified upfront, but this
+   restriction might be lifted in the future. As with the rest of the USB
+   protocol, all the integer are encoded as *little-endian*. */
+typedef struct usb_fxlink_header
 {
 	/* Protocol version = 0x00000100 */
 	uint32_t version;
@@ -76,33 +164,24 @@ typedef struct
 	uint32_t size;
 	/* Size of individual transfers (related to the size of the FIFO) */
 	uint32_t transfer_size;
-	/* Application name, UTF-8 (might not be zero-terminated) */
+	/* Application name and message type, UTF-8 (need not be zero-terminated) */
 	char application[16];
-	/* Message type */
 	char type[16];
 
 } usb_fxlink_header_t;
 
 /* usb_fxlink_fill_header(): Fill an fxlink message header
 
-   This function will fill the specified fxlink header. You need to specify the
-   exact amount of data that the fxlink message will contain; if you cannot
-   determine it, consider splitting the message into several messages each with
-   their own header, and use the application-specific script on the host to
-   recombine them.
-
-   Returns false if the parameters are invalid or don't fit, in this case the
-   contents of the header are unchanged. */
-bool usb_fxlink_fill_header(usb_fxlink_header_t *header, char *application,
-   char *type, uint32_t data_size);
-
-//---
-// Short functions for fxlink built-in types
-//---
+   Fills an fxlink header's fields with the provided. You need to specify the
+   exact amount of data that the fxlink message will contain. Returns false if
+   parameters are invalid or don't fit the fields. */
+bool usb_fxlink_fill_header(usb_fxlink_header_t *header,
+	char const *application, char const *type, uint32_t data_size);
 
 /* Subheader for the fxlink built-in "image" type */
 typedef struct
 {
+   /* Image size; storage is row-major */
 	uint32_t width;
 	uint32_t height;
 	/* Pixel format, see below */
@@ -111,57 +190,17 @@ typedef struct
 } usb_fxlink_image_t;
 
 /* Pixel formats */
-typedef enum
-{
+enum {
 	/* Image is an array of *big-endian* uint16_t with RGB565 format */
 	USB_FXLINK_IMAGE_RGB565 = 0,
 	/* Image is an array of bits in mono format */
 	USB_FXLINK_IMAGE_MONO,
 	/* Image is two consecutive mono arrays, one for light, one for dark */
 	USB_FXLINK_IMAGE_GRAY,
+};
 
-} usb_fxlink_image_format_t;
-
-/* usb_fxlink_screenshot(): Take a screenshot
-
-   This function takes a screenshot. If (onscreen = false), it sends the
-   contents of the VRAM. This mode is best used just before dupdate(), since
-   the VRAM contents are exactly as they will appear on screen a moment later.
-   However, this is somewhat unintuitive for interactive GUI as the user has to
-   press a button after the option is present on-screen, therefore the contents
-   of the *next* frame are captured.
-
-   If (onscreen = true), this function tries to send the pixels that are
-   currently visible on-screen, with the following heuristic:
-
-   * If there is only one VRAM, the VRAM contents are used in the hope they
-     haven't changed since the last frame was presented with dupdate().
-   * If there are two VRAMs (on fx-CG 50 or using the gray engine) the contents
-     of the VRAM not currently being draw to are sent.
-
-   This function does not read pixels directly from the display, as this is
-   usually slow and currently not even implemented. */
-void usb_fxlink_screenshot(bool onscreen);
-
-#ifdef FX9860G
-/* usb_fxlink_screenshot_gray(): Take a gray screenshot on fx-9860G
-
-   This function is similar to usb_fxlink_screenshot(), but it takes a gray
-   screenshot. It depends on the gray engine so if you use your add-in will
-   automatically have the gray engine, that's why it's separate. */
-void usb_fxlink_screenshot_gray(bool onscreen);
+#ifdef __cplusplus
+}
 #endif
 
-/* usb_fxlink_text(): Send raw text
-
-   This function sends a string with the "text" type, which fxlink prints on
-   the terminal. It will send a full fxlink message (with a commit), which is
-   inefficient if there is a lot of text to send. For better speed, send the
-   message manually by filling the header and doing the writes and commit
-   manually.
-
-   This function sends the text by blocks of 4 bytes or 2 bytes when alignment
-   and size allow, and 1 byte otherwise. If size is 0, strlen(text) is used. */
-void usb_fxlink_text(char const *text, int size);
-
 #endif /* GINT_USB_FF_BULK */

include/gint/usb.h

@@ -5,10 +5,16 @@
 #ifndef GINT_USB
 #define GINT_USB
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #include <gint/defs/types.h>
-#include <gint/std/endian.h>
+#include <gint/defs/timeout.h>
 #include <gint/gint.h>
+#include <gint/config.h>
 #include <stdarg.h>
+#include <endian.h>
 
 /* See "Interfaces to communicate with USB transfers" below for details */
 typedef struct usb_interface usb_interface_t;
@@ -23,26 +29,35 @@ enum {
 	/* There are no interfaces */
 	USB_OPEN_NO_INTERFACE = 1,
 	/* There are more interfaces than supported (16) */
-	USB_OPEN_TOO_MANY_INTERFACES,
+	USB_OPEN_TOO_MANY_INTERFACES = -2,
 	/* There are not enough endpoint numbers for every interface, or there
 	   are not enough pipes to set them up */
-	USB_OPEN_TOO_MANY_ENDPOINTS,
+	USB_OPEN_TOO_MANY_ENDPOINTS = -3,
 	/* There is not enough FIFO memory to use the requested buffer sizes */
-	USB_OPEN_NOT_ENOUGH_MEMORY,
+	USB_OPEN_NOT_ENOUGH_MEMORY = -4,
 	/* Information is missing, such as buffer size for some endpoints */
-	USB_OPEN_MISSING_DATA,
+	USB_OPEN_MISSING_DATA = -5,
 	/* Invalid parameters: bad endpoint numbers, bad buffer sizes... */
-	USB_OPEN_INVALID_PARAMS,
+	USB_OPEN_INVALID_PARAMS = -6,
+	/* USB interfaces are already opened */
+	USB_OPEN_ALREADY_OPEN = -7,
 
-	/* This pipe is busy (returned by usb_write_async()) */
-	USB_WRITE_BUSY,
-	/* Both FIFO controlles are busy, none is available to transfer */
-	USB_WRITE_NOFIFO,
+	/* General timeout for a sync_timeout call */
+	USB_TIMEOUT = -8,
+	/* This pipe is busy with another call */
+	USB_BUSY = -9,
 
-	/* This pipe is busy (returned by usb_commit_async()) */
-	USB_COMMIT_BUSY,
+	/* Both FIFO controllers are busy, none is available to transfer */
+	USB_WRITE_NOFIFO = -10,
 	/* This pipe has no ongoing transfer to commit */
-	USB_COMMIT_INACTIVE,
+	USB_COMMIT_INACTIVE = -11,
+	/* This pipe is currently not receiving any data */
+	USB_READ_IDLE = -12,
+	/* No FIFO controller is available */
+	USB_READ_NOFIFO = -13,
+
+	/* (Internal codes) */
+	USB_ERROR_ZERO_LENGTH = -100,
 };
 
 /* usb_open(): Open the USB link
@@ -125,8 +140,12 @@ struct usb_interface {
 	/* Answer class-specific SETUP requests */
 	/* TODO */
 
-	/* Receive data from an endpoint */
-	/* TODO */
+	/* Notification that an endpoint has data to be read. This function is
+	   called frequently when data is being transmitted; the particular
+	   timings depend on low-level details. The notification should be
+	   passed down to cause the main thread to read later. Do not read in
+	   the notification function! */
+	void (*notify_read)(int endpoint);
 };
 
 /* usb_interface_endpoint_t: Parameters for an interface endpoint
@@ -165,23 +184,22 @@ int usb_interface_pipe(usb_interface_t const *interface, int endpoint);
 
 /* usb_write_sync(): Synchronously write to a USB pipe
 
-   This functions writes (size) bytes of (data) into the specified pipe, by
-   units of (unit_size) bytes. The unit size must be 1, 2 or 4, and both (data)
-   and (size) must be multiples of the unit size. In general, you should try to
-   use the largest possible unit size, as it will be much faster. In a sequence
-   of writes that concludes with a commit, all the writes must use the same
-   unit size.
+   This functions writes (size) bytes of (data) into the specified pipe. If the
+   data fits into the pipe, this function returns right away, and the data is
+   *not* transmitted. Otherwise, data is written until the pipe is full, at
+   which point it is automatically transmitted. After the transfer, this
+   function resumes writing, returning only once everything is written. Even
+   then the last bytes will still not have been transmitted, to allow for other
+   writes to follow. After the last write in a sequence, use usb_commit_sync()
+   or usb_commit_async() to transmit the last bytes.
 
-   If the data fits into the pipe, this function returns right away, and the
-   data is *not* transmitted. Otherwise, data is written until the pipe is
-   full, at which point it is automatically transmitted. After the transfer,
-   this function resumes writing, returning only once everything is written.
-   Even then the last bytes will still not have been transmitted, to allow for
-   other writes to follow. After the last write in a sequence, use
-   usb_commit_sync() or usb_commit_async() to transmit the last bytes.
-
-   If (use_dma=true), the write is performed with the DMA instead of the CPU,
-   which is generally faster.
+   If (use_dma=true), the write is performed with the DMA instead of the CPU.
+   This requires at least 4-byte alignment on:
+     1. The input data;
+     2. The size of this write;
+     3. The amount of data previously written to the pipe not yet committed.
+   This is because using the DMA does not allow any insertion of CPU logic to
+   handle unaligned stuff.
 
    This function will use a FIFO controller to access the pipe. The FIFO
    controller will be reserved for further writes until the contents of the
@@ -194,13 +212,15 @@ int usb_interface_pipe(usb_interface_t const *interface, int endpoint);
    waits for the ressources to become available then proceeds normally.
 
    @pipe       Pipe to write into
-   @data       Source data (unit_size-aligned)
-   @size       Size of source (multiple of unit_size)
-   @unit_size  FIFO access size (must be 1, 2, or 4)
+   @data       Source data
+   @size       Size of source
    @dma        Whether to use the DMA to perform the write
    -> Returns an error code (0 on success). */
-int usb_write_sync(int pipe, void const *data, int size, int unit_size,
-   bool use_dma);
+int usb_write_sync(int pipe, void const *data, int size, bool use_dma);
+
+/* usb_write_sync_timeout(): Synchronously write, with a timeout */
+int usb_write_sync_timeout(int pipe, void const *data, int size,
+	bool use_dma, timeout_t const *timeout);
 
 /* usb_write_async(): Asynchronously write to a USB pipe
 
@@ -222,14 +242,13 @@ int usb_write_sync(int pipe, void const *data, int size, int unit_size,
    is idle and USB_WRITE_BUSY otherwise.
 
    @pipe       Pipe to write into
-   @data       Source data (unit_size-aligned)
-   @size       Size of source (multiple of unit_size)
-   @unit_size  FIFO access size (must be 1, 2, or 4)
+   @data       Source data
+   @size       Size of source
    @dma        Whether to use the DMA to perform the write
    @callback   Optional callback to invoke when the write completes
    -> Returns an error code (0 on success). */
-int usb_write_async(int pipe, void const *data, int size, int unit_size,
-	bool use_dma, gint_call_t callback);
+int usb_write_async(int pipe, void const *data, int size, bool use_dma,
+	gint_call_t callback);
 
 /* usb_commit_sync(): Synchronously commit a write
 
@@ -237,6 +256,9 @@ int usb_write_async(int pipe, void const *data, int size, int unit_size,
    transfers whatever data is left, and returns when the transfer completes. */
 void usb_commit_sync(int pipe);
 
+/* usb_commit_sync_timeout(): Synchronously commit a write, with timeout */
+int usb_commit_sync_timeout(int pipe, timeout_t const *timeout);
+
 /* usb_commit_async(): Asynchronously commit a write
 
    This function commits the specified pipe, causing the pipe to transfer
@@ -251,23 +273,142 @@ void usb_commit_sync(int pipe);
    of the remaining data completes. */
 int usb_commit_async(int pipe, gint_call_t callback);
 
+/* usb_read_sync(): Synchronously read from a USB pipe
+
+   This function waits for data to become available on the specified `pipe`,
+   and then reads up to `size` bytes into `data`. It is "synchronized" with USB
+   transactions on the pipe in the following ways:
+
+   1. If there is no active transaction, it waits for one to arrive.
+   2. If the active transaction has no data left to read, it is skipped.
+   3. If the transaction's data is completely read, the transaction is closed
+      even if `data` is full. (See usb_read_async() for the alternative.)
+
+   Basically usb_read_sync() returns the next `size` bytes of data that the
+   calculator receives on the pipe, with a single exception: it doesn't read
+   across transactions, so if the active transaction has 100 bytes left and you
+   request 200, you will only get 100. usb_read_sync() only ever returns 0
+   bytes if there is an empty transaction, which is rare.
+
+   Because this is a blocking function, a call to usb_read_sync() will *FREEZE*
+   if there is no data to read on the pipe and the host doesn't send any. In
+   addition, it's not possible to detect how much data is left to read with
+   usb_read_sync()'s interface. If you want to avoid or debug a freeze, use
+   use usb_read_async() or set a timeout with usb_read_sync_timeout(). If you
+   want to read a transaction until the end without knowing its size in
+   advance, use usb_read_async().
+
+   If `use_dma=true`, uses the DMA for transfers. This requires 4-byte
+   alignment on the buffer, size, and number of bytes previously read in the
+   current transaction.
+
+   Returns the number of bytes read or a negative error code. */
+int usb_read_sync(int pipe, void *data, int size, bool use_dma);
+
+/* usb_read_sync_timeout(): Synchronous read with a timeout */
+int usb_read_sync_timeout(int pipe, void *data, int size, bool use_dma,
+	timeout_t const *timeout);
+
+/* Flags for usb_read_async(), see below. */
+enum {
+	/* Use the DMA for data transfer (requires full 4-byte alignment). */
+	USB_READ_USE_DMA        = 0x01,
+	/* Ignore reads of 0 bytes from exhausted transactions. */
+	USB_READ_IGNORE_ZEROS   = 0x02,
+	/* Close transactions when exhausted even by non-partial reads. */
+	USB_READ_AUTOCLOSE      = 0x04,
+	/* Wait for the read to finish before returning. */
+	USB_READ_WAIT           = 0x08,
+	/* Block for a new transaction if none is currenty active. */
+	USB_READ_BLOCK          = 0x10,
+};
+
+/* usb_read_async(): Asynchronously read from a USB pipe
+
+   This function is similar to usb_read_sync() but it is asynchronous, ie. it
+   returns after starting the read and then runs in the background. Without
+   options, usb_read_async() is guaranteed to return quickly without waiting
+   for communications. The read itself also never blocks unless there is a
+   disagreement with the host on the size of transactions.
+
+   usb_read_async() is also slightly lower-level than usb_read_sync(). In
+   particular, it only closes transactions when the data is fully read *and*
+   the user buffer is not full. If the user requests exactly the number of
+   bytes left in the transaction, the entire contents will be read but the
+   transaction will be left in an "active with 0 bytes left" state. Only on the
+   next read will the transaction be closed.
+
+   This behavior is designed so that a read closes a transaction if and only if
+   it returns fewer bytes than requested, which is useful for detecting the end
+   of transfers when their size isn't known in advance.
+
+   This function returns a preliminary error code. If it is zero, then the
+   callback will be invoked later with *rc set to the final return value of the
+   read, which is itself either an error (< 0) or the number of bytes read.
+
+   Due to its low-level nature, raw usb_read_async() is a bit impractical to
+   use and almost always requires repeated calls and callback waits. The
+   following flags are provided to make it more convenient by incorporating
+   features of usb_read_sync():
+
+   * USB_READ_IGNORE_ZEROS causes usb_read_async() to ignore reads of 0 bytes
+     from transactions that were exhausted but not closed.
+   * USB_READ_AUTOCLOSE causes usb_read_async() to always close transactions
+     when exhausted even if the read is not partial. This is useful when the
+     size of the transaction is in fact known in advance.
+   * USB_READ_WAIT causes usb_read_async() to wait for the end of the transfer
+     before returning. Unless there is a driver bug or USB_READ_BLOCK is also
+     set, this cannot cause the function to freeze since the read will always
+     complete in finite time (returning USB_READ_IDLE if no transaction is
+     active). When USB_READ_WAIT it set, `callback` and `rc` are ignored; the
+     callback is not invoked, and the status of the entire read is returned.
+   * USB_READ_BLOCK causes usb_read_async() to wait for a transaction if none
+     is active. This can stall the transfer indefinitely if the host doesn't
+     transmit any data, and freeze the call entirely if USB_READ_WAIT is set.
+     This option really makes usb_read_async() a synchronous function.
+   * A timeout is supported (pass NULL to ignore).
+
+   With all options enabled, usb_read_async() becomes functionally identical to
+   usb_read_sync_timeout(). */
+int usb_read_async(int pipe, void *data, int size, int flags, int *rc,
+	timeout_t const *timeout, gint_call_t callback);
+
+/* usb_read_cancel(): Cancel an asynchronous read
+
+   Once started, an async read will run in the background and keep writing to
+   the provided buffer. This function cancels the operation so that no further
+   writes to the buffer are made and the associated memory can be safely
+   deallocated. */
+void usb_read_cancel(int pipe);
+
 //---
-// USB debugging log
+// USB debugging functions
 //---
 
-/* usb_set_log(): Set the logging function for the USB driver
-
-   The USB driver can produce logs, which are mostly useful to troubleshoot
-   problems and add new protocols. The logging is disabled by default but can
-   be enabled by specifying this function.
-
-   It is up to you whether to store that in a buffer, rotate logs, send them to
-   storage memory or a console on the PC. */
+/* usb_set_log(): Set the logging function for the USB driver */
 void usb_set_log(void (*logger)(char const *format, va_list args));
-
+/* usb_get_log(): Get the logging function */
+void (*usb_get_log(void))(char const *format, va_list args);
 /* usb_log(): Send a message to the USB log */
 void usb_log(char const *format, ...);
 
+/* usb_set_trace(): Set the tracing function for the USB driver
+   The function is called atomically, thus cannot be interrupted, therefore it
+   is safe to call usb_trace() in interrupt handlers. */
+void usb_set_trace(void (*tracer)(char const *message));
+/* usb_get_trace(): Get the tracing function */
+void (*usb_get_trace(void))(char const *message);
+/* usb_trace(): Trace the current state of the driver */
+void usb_trace(char const *message);
+
+#ifdef GINT_USB_DEBUG
+#define USB_LOG(...) usb_log(__VA_ARGS__)
+#define USB_TRACE(...) usb_trace(__VA_ARGS__)
+#else
+#define USB_LOG(...) do {} while(0)
+#define USB_TRACE(...) do {} while(0)
+#endif
+
 //---
 // Standard descriptors
 //---
@@ -376,4 +517,8 @@ 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);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GINT_USB */

src/cpg/cpg.c

@@ -27,9 +27,8 @@ const clock_frequency_t *clock_freq(void)
 //---
 
 #if defined(FX9860G) || (!defined(FX9860G) && !defined(FXCG50))
-#define CPG SH7705_CPG
 
-static void sh7705_probe(void)
+void sh7705_probe(void)
 {
 	/* According to Sentaro21 in the sources of Ftune 1.0.1, the clock mode
 	   is thought to be 5, which means that:
@@ -41,35 +40,23 @@ static void sh7705_probe(void)
 	int ckio = xtal * pll2;
 
 	/* This signal is multiplied by the PLL1 circuit */
-	int pll1 = CPG.FRQCR.STC + 1;
+	int pll1 = SH7705_CPG.FRQCR.STC + 1;
 
-	/* Iphi and Pphi have dividers (Bphi is always equal to CKIO) */
-	int idiv = CPG.FRQCR.IFC;
-	int pdiv = CPG.FRQCR.PFC;
-
-	/* Fill in the setting structure */
+	/* Fill in the setting structure. Iϕ and Pϕ have dividers, while Bϕ is
+	   always equal to CKIO. */
 	freq.PLL1 = pll1;
 	freq.PLL2 = pll2;
 	freq.Bphi_div = 1;
-	freq.Iphi_div = idiv + 1;
-	freq.Pphi_div = pdiv + 1;
-
-	/* Deduce the frequency of the main clocks. This value is ckio/3 */
-	int ckio_3 = 9830400;
-
-	/* Exchange the setting values 2 and 3 (corresponding to /3 and /4)
-	   This means that /1, /2, /4 are now 0, 1, 2, which is perfect for a
-	   quick bit shift */
-	idiv = idiv ^ (idiv >> 1);
-	pdiv = pdiv ^ (pdiv >> 1);
+	freq.Iphi_div = SH7705_CPG.FRQCR.IFC + 1;
+	freq.Pphi_div = SH7705_CPG.FRQCR.PFC + 1;
 
+	/* Deduce the frequency of the main clocks */
 	freq.CKIO_f = ckio;
 	freq.Bphi_f = ckio;
-	freq.Iphi_f = (idiv == 3) ? ckio_3 : ckio >> idiv;
-	freq.Pphi_f = (pdiv == 3) ? ckio_3 : ckio >> pdiv;
+	freq.Iphi_f = (ckio * pll1) / freq.Iphi_div;
+	freq.Pphi_f = (ckio * pll1) / freq.Pphi_div;
 }
 
-#undef CPG
 #endif /* FX9860G and platform-agnostic */
 
 //---
@@ -82,7 +69,7 @@ static void sh7305_probe(void)
 {
 	/* The meaning of the PLL setting on SH7305 differs from the
 	   documentation of SH7224; the value must not be doubled. */
-	int pll = CPG.FRQCRA.STC + 1;
+	int pll = CPG.FRQCR.STC + 1;
 	freq.PLL = pll;
 
 	/* The FLL ratio is the value of the setting, halved if SELXM=1 */
@@ -93,9 +80,9 @@ static void sh7305_probe(void)
 	/* On SH7724, the divider ratio is given by 1 / (setting + 1), but on
 	   the SH7305 it is 1 / (2^setting + 1). */
 
-	int divb = CPG.FRQCRA.BFC;
-	int divi = CPG.FRQCRA.IFC;
-	int divp = CPG.FRQCRA.P1FC;
+	int divb = CPG.FRQCR.BFC;
+	int divi = CPG.FRQCR.IFC;
+	int divp = CPG.FRQCR.P1FC;
 
 	freq.Bphi_div = 1 << (divb + 1);
 	freq.Iphi_div = 1 << (divi + 1);
@@ -115,18 +102,13 @@ static void sh7305_probe(void)
 
 #undef CPG
 
+
 //---
 // Initialization
 //---
 
-static void configure(void)
+void cpg_compute_freq(void)
 {
-	/* Disable spread spectrum in SSGSCR */
-	if(isSH4())
-	{
-		SH7305_CPG.SSCGCR.SSEN = 0;
-	}
-
 	/* This avoids warnings about sh7705_probe() being undefined when
 	   building for fxcg50 */
 	#if defined(FX9860G) || (!defined(FX9860G) && !defined(FXCG50))
@@ -135,18 +117,31 @@ static void configure(void)
 	sh7305_probe();
 }
 
+static void configure(void)
+{
+	/* Disable spread spectrum in SSGSCR */
+	if(isSH4())
+		SH7305_CPG.SSCGCR.SSEN = 0;
+
+	cpg_compute_freq();
+}
+
 //---
 // State and driver metadata
 //---
 
 static void hsave(cpg_state_t *s)
 {
-	if(isSH4()) s->SSCGCR = SH7305_CPG.SSCGCR.lword;
+	if(isSH4())
+		s->SSCGCR = SH7305_CPG.SSCGCR.lword;
+	cpg_get_overclock_setting(&s->speed);
 }
 
 static void hrestore(cpg_state_t const *s)
 {
-	if(isSH4()) SH7305_CPG.SSCGCR.lword = s->SSCGCR;
+	if(isSH4())
+		SH7305_CPG.SSCGCR.lword = s->SSCGCR;
+	cpg_set_overclock_setting(&s->speed);
 }
 
 gint_driver_t drv_cpg = {

src/cpg/overclock.c

@@ -0,0 +1,514 @@
+//---
+// gint:cpg:overclock - Clock speed control
+//
+// Most of the data in this file has been reused from Sentaro21's Ftune and
+// Ptune utilities, which have long been the standard for overclocking CASIO
+// calculators.
+// See: http://pm.matrix.jp/ftune2e.html
+//
+// SlyVTT also contributed early testing on both the fx-CG 10/20 and fx-CG 50.
+//---
+
+#include <gint/clock.h>
+#include <gint/gint.h>
+#include <gint/hardware.h>
+#include <gint/mpu/cpg.h>
+#include <gint/mpu/bsc.h>
+#include <gint/mpu/wdt.h>
+
+//---
+// Low-level clock speed access
+//---
+
+#define SH7305_SDMR3_CL2 ((volatile uint8_t *)0xFEC15040)
+#define SH7305_SDMR3_CL3 ((volatile uint8_t *)0xFEC15060)
+
+//---
+// Predefined clock speeds
+//---
+
+/* SH7305 CPG */
+#define SH4_PLL_32x  0b011111
+#define SH4_PLL_26x  0b011001
+#define SH4_PLL_16x  0b001111
+#define SH4_DIV_2    0
+#define SH4_DIV_4    1
+#define SH4_DIV_8    2
+#define SH4_DIV_16   3
+#define SH4_DIV_32   4
+
+/* SH7705-like CPG */
+#define SH3_PLL_1x   0
+#define SH3_PLL_2x   1
+#define SH3_PLL_3x   2
+#define SH3_PLL_4x   3
+#define SH3_DIV_1    0
+#define SH3_DIV_2    1
+#define SH3_DIV_3    2
+#define SH3_DIV_4    3
+
+void cpg_get_overclock_setting(struct cpg_overclock_setting *s)
+{
+    if(isSH3()) {
+        s->FLLFRQ = -1;
+        s->FRQCR = SH7705_CPG.FRQCR.word;
+
+        s->CS0BCR = SH7705_BSC.CS0BCR.lword;
+        s->CS0WCR = SH7705_BSC.CS0WCR.lword;
+        s->CS2BCR = SH7705_BSC.CS2BCR.lword;
+        s->CS2WCR = SH7705_BSC.CS2WCR.lword;
+        s->CS3BCR = SH7705_BSC.CS3BCR.lword;
+        s->CS3WCR = SH7705_BSC.CS3WCR.lword;
+        s->CS5aBCR = SH7705_BSC.CS5ABCR.lword;
+        s->CS5aWCR = SH7705_BSC.CS5AWCR.lword;
+    }
+    else {
+        s->FLLFRQ = SH7305_CPG.FLLFRQ.lword;
+        s->FRQCR = SH7305_CPG.FRQCR.lword;
+
+        s->CS0BCR = SH7305_BSC.CS0BCR.lword;
+        s->CS0WCR = SH7305_BSC.CS0WCR.lword;
+        s->CS2BCR = SH7305_BSC.CS2BCR.lword;
+        s->CS2WCR = SH7305_BSC.CS2WCR.lword;
+        s->CS3BCR = SH7305_BSC.CS3BCR.lword;
+        s->CS3WCR = SH7305_BSC.CS3WCR.lword;
+        s->CS5aBCR = SH7305_BSC.CS5ABCR.lword;
+        s->CS5aWCR = SH7305_BSC.CS5AWCR.lword;
+    }
+}
+
+static void cpg_low_level_set_setting(struct cpg_overclock_setting const *s)
+{
+    if(isSH3()) {
+        SH7705_WDT.WTCNT.WRITE = 0;
+        SH7705_WDT.WTCSR.WRITE = 0x65;
+        SH7705_CPG.FRQCR.word = s->FRQCR | 0x1000;
+        SH7705_BSC.CS0BCR.lword = s->CS0BCR;
+        SH7705_BSC.CS0WCR.lword = s->CS0WCR;
+        SH7705_BSC.CS2BCR.lword = s->CS2BCR;
+        SH7705_BSC.CS2WCR.lword = s->CS2WCR;
+        SH7705_BSC.CS3BCR.lword = s->CS3BCR;
+        SH7705_BSC.CS3WCR.lword = s->CS3WCR;
+        SH7705_BSC.CS5ABCR.lword = s->CS5aBCR;
+        SH7705_BSC.CS5AWCR.lword = s->CS5aWCR;
+    }
+    else {
+        SH7305_BSC.CS0WCR.WR = 11; /* 18 cycles */
+
+        SH7305_CPG.FLLFRQ.lword = s->FLLFRQ;
+        SH7305_CPG.FRQCR.lword = s->FRQCR;
+        SH7305_CPG.FRQCR.KICK = 1;
+        while(SH7305_CPG.LSTATS != 0) {}
+
+        SH7305_BSC.CS0BCR.lword = s->CS0BCR;
+        SH7305_BSC.CS0WCR.lword = s->CS0WCR;
+        SH7305_BSC.CS2BCR.lword = s->CS2BCR;
+        SH7305_BSC.CS2WCR.lword = s->CS2WCR;
+        SH7305_BSC.CS3BCR.lword = s->CS3BCR;
+        SH7305_BSC.CS3WCR.lword = s->CS3WCR;
+
+        if(SH7305_BSC.CS3WCR.A3CL == 1)
+            *SH7305_SDMR3_CL2 = 0;
+        else
+            *SH7305_SDMR3_CL3 = 0;
+
+        SH7305_BSC.CS5ABCR.lword = s->CS5aBCR;
+        SH7305_BSC.CS5AWCR.lword = s->CS5aWCR;
+    }
+}
+
+void cpg_set_overclock_setting(struct cpg_overclock_setting const *s)
+{
+    uint32_t old_Pphi = clock_freq()->Pphi_f;
+
+    /* Wait for asynchronous tasks to complete */
+    gint_world_sync();
+
+    /* Disable interrupts during the change */
+    cpu_atomic_start();
+
+    /* Load the clock settings */
+    cpg_low_level_set_setting(s);
+
+    /* Determine the change in frequency for Pϕ and recompute CPG data */
+    cpg_compute_freq();
+    uint32_t new_Pphi = clock_freq()->Pphi_f;
+
+    /* Update timers' TCNT and TCOR to match the new clock speed */
+    void timer_rescale(uint32_t old_Pphi, uint32_t new_Pphi);
+    timer_rescale(old_Pphi, new_Pphi);
+
+    cpu_atomic_end();
+}
+
+#ifdef FX9860G
+
+static struct cpg_overclock_setting const settings_fx9860g_sh3[5] = {
+    /* CLOCK_SPEED_F1 */
+    { .FRQCR   = 0x1001,
+      .CS0BCR  = 0x02480400,
+      .CS2BCR  = 0x02483400,
+      .CS3BCR  = 0x36DB0600,
+      .CS5aBCR = 0x224A0200,
+      .CS0WCR  = 0x00000140,
+      .CS2WCR  = 0x00000140,
+      .CS3WCR  = 0x00000500,
+      .CS5aWCR = 0x00000D41 },
+    /* CLOCK_SPEED_F2 */
+    { .FRQCR   = (SH3_PLL_2x<<8)+(SH3_DIV_1<<4)+SH3_DIV_2,
+      .CS0BCR  = 0x02480400,
+      .CS2BCR  = 0x02483400,
+      .CS3BCR  = 0x36DB0600,
+      .CS5aBCR = 0x224A0200,
+      .CS0WCR  = 0x00000140,
+      .CS2WCR  = 0x00000140,
+      .CS3WCR  = 0x00000500,
+      .CS5aWCR = 0x00000D41 },
+    /* CLOCK_SPEED_F3 */
+    { .FRQCR   = (SH3_PLL_3x<<8)+(SH3_DIV_1<<4)+SH3_DIV_3,
+      .CS0BCR  = 0x02480400,
+      .CS2BCR  = 0x02483400,
+      .CS3BCR  = 0x36DB0600,
+      .CS5aBCR = 0x224A0200,
+      .CS0WCR  = 0x00000140,
+      .CS2WCR  = 0x00000140,
+      .CS3WCR  = 0x00000500,
+      .CS5aWCR = 0x00000D41 },
+    /* CLOCK_SPEED_F4 */
+    { .FRQCR   = (SH3_PLL_4x<<8)+(SH3_DIV_1<<4)+SH3_DIV_4,
+      .CS0BCR  = 0x02480400,
+      .CS2BCR  = 0x02483400,
+      .CS3BCR  = 0x36DB0600,
+      .CS5aBCR = 0x224A0200,
+      .CS0WCR  = 0x00000140,
+      .CS2WCR  = 0x00000140,
+      .CS3WCR  = 0x00000500,
+      .CS5aWCR = 0x00000D41 },
+    /* CLOCK_SPEED_F5 */
+    { .FRQCR   = (SH3_PLL_4x<<8)+(SH3_DIV_1<<4)+SH3_DIV_4,
+      .CS0BCR  = 0x02480400,
+      .CS2BCR  = 0x02483400,
+      .CS3BCR  = 0x36DB0600,
+      .CS5aBCR = 0x224A0200,
+      .CS0WCR  = 0x000000C0,
+      .CS2WCR  = 0x000100C0,
+      .CS3WCR  = 0x00000500,
+      .CS5aWCR = 0x00000D41 },
+};
+
+static struct cpg_overclock_setting const settings_fx9860g_sh4[5] = {
+    /* CLOCK_SPEED_F1 */
+    { .FLLFRQ  = 0x00004384,
+      .FRQCR   = 0x0F202203,
+      .CS0BCR  = 0x24920400,
+      .CS2BCR  = 0x24923400,
+      .CS3BCR  = 0x24924400,
+      .CS5aBCR = 0x224A0200,
+      .CS0WCR  = 0x000005C0,
+      .CS2WCR  = 0x00000140,
+      .CS3WCR  = 0x000024D0,
+      .CS5aWCR = 0x00000D41 },
+    /* CLOCK_SPEED_F2 */
+    { .FLLFRQ  = 0x00004384,
+      .FRQCR   = (SH4_PLL_16x<<24)+(SH4_DIV_4<<20)+(SH4_DIV_8<<12)+(SH4_DIV_8<<8)+SH4_DIV_16,
+      .CS0BCR  = 0x24920400,
+      .CS2BCR  = 0x24923400,
+      .CS3BCR  = 0x24924400,
+      .CS5aBCR = 0x224A0200,
+      .CS0WCR  = 0x000001C0,
+      .CS2WCR  = 0x00000140,
+      .CS3WCR  = 0x000024D0,
+      .CS5aWCR = 0x00000D41 },
+    /* CLOCK_SPEED_F3 */
+    { .FLLFRQ  = 0x00004384,
+      .FRQCR   = (SH4_PLL_16x<<24)+(SH4_DIV_8<<20)+(SH4_DIV_8<<12)+(SH4_DIV_8<<8)+SH4_DIV_16,
+      .CS0BCR  = 0x04900400,
+      .CS2BCR  = 0x04903400,
+      .CS3BCR  = 0x24924400,
+      .CS5aBCR = 0x24920200,
+      .CS0WCR  = 0x00000140,
+      .CS2WCR  = 0x00000140,
+      .CS3WCR  = 0x000024D0,
+      .CS5aWCR = 0x00000D41 },
+    /* CLOCK_SPEED_F4 */
+    { .FLLFRQ  = 0x00004384,
+      .FRQCR   = (SH4_PLL_32x<<24)+(SH4_DIV_4<<20)+(SH4_DIV_8<<12)+(SH4_DIV_8<<8)+SH4_DIV_16,
+      .CS0BCR  = 0x04900400,
+      .CS2BCR  = 0x04903400,
+      .CS3BCR  = 0x24924400,
+      .CS5aBCR = 0x224A0200,
+      .CS0WCR  = 0x000001C0,
+      .CS2WCR  = 0x00020140,
+      .CS3WCR  = 0x000024D0,
+      .CS5aWCR = 0x00000D41 },
+    /* CLOCK_SPEED_F5 */
+    { .FLLFRQ  = 0x00004384,
+      .FRQCR   = (SH4_PLL_32x<<24)+(SH4_DIV_2<<20)+(SH4_DIV_4<<12)+(SH4_DIV_4<<8)+SH4_DIV_16,
+      .CS0BCR  = 0x14900400,
+      .CS2BCR  = 0x04903400,
+      .CS3BCR  = 0x24924400,
+      .CS5aBCR = 0x224A0200,
+      .CS0WCR  = 0x000003C0,
+      .CS2WCR  = 0x000302C0,
+      .CS3WCR  = 0x000024D0,
+      .CS5aWCR = 0x00000D41 },
+};
+
+static struct cpg_overclock_setting const settings_g35pe2[5] = {
+    /* CLOCK_SPEED_F1 */
+    { .FLLFRQ  = 0x00004384,
+      .FRQCR   = 0x0F112213,
+      .CS0BCR  = 0x24920400,
+      .CS2BCR  = 0x24923400,
+      .CS3BCR  = 0x24924400,
+      .CS5aBCR = 0x224A0200,
+      .CS0WCR  = 0x000001C0,
+      .CS2WCR  = 0x000001C0,
+      .CS3WCR  = 0x000024D0,
+      .CS5aWCR = 0x00031340 },
+    /* CLOCK_SPEED_F2 */
+    { .FLLFRQ  = 0x00004384,
+      .FRQCR   = (SH4_PLL_16x<<24)+(SH4_DIV_4<<20)+(SH4_DIV_8<<12)+(SH4_DIV_8<<8)+SH4_DIV_16,
+      .CS0BCR  = 0x24920400,
+      .CS2BCR  = 0x24923400,
+      .CS3BCR  = 0x24924400,
+      .CS5aBCR = 0x224A0200,
+      .CS0WCR  = 0x000001C0,
+      .CS2WCR  = 0x00000140,
+      .CS3WCR  = 0x000024D0,
+      .CS5aWCR = 0x00000D41 },
+    /* CLOCK_SPEED_F3 */
+    { .FLLFRQ  = 0x00004384,
+      .FRQCR   = (SH4_PLL_16x<<24)+(SH4_DIV_8<<20)+(SH4_DIV_8<<12)+(SH4_DIV_8<<8)+SH4_DIV_16,
+      .CS0BCR  = 0x04900400,
+      .CS2BCR  = 0x04903400,
+      .CS3BCR  = 0x24924400,
+      .CS5aBCR = 0x24920200,
+      .CS0WCR  = 0x00000140,
+      .CS2WCR  = 0x00000140,
+      .CS3WCR  = 0x000024D0,
+      .CS5aWCR = 0x00000D41 },
+    /* CLOCK_SPEED_F4 */
+    { .FLLFRQ  = 0x00004384,
+      .FRQCR   = (SH4_PLL_32x<<24)+(SH4_DIV_4<<20)+(SH4_DIV_8<<12)+(SH4_DIV_8<<8)+SH4_DIV_16,
+      .CS0BCR  = 0x04900400,
+      .CS2BCR  = 0x04903400,
+      .CS3BCR  = 0x24924400,
+      .CS5aBCR = 0x224A0200,
+      .CS0WCR  = 0x000001C0,
+      .CS2WCR  = 0x00020140,
+      .CS3WCR  = 0x000024D0,
+      .CS5aWCR = 0x00031B40 },
+    /* CLOCK_SPEED_F5 */
+    { .FLLFRQ  = 0x00004384,
+      .FRQCR   = (SH4_PLL_32x<<24)+(SH4_DIV_2<<20)+(SH4_DIV_4<<12)+(SH4_DIV_8<<8)+SH4_DIV_16,
+      .CS0BCR  = 0x14900400,
+      .CS2BCR  = 0x04903400,
+      .CS3BCR  = 0x24924400,
+      .CS5aBCR = 0x224A0200,
+      .CS0WCR  = 0x000001C0,
+      .CS2WCR  = 0x00020140,
+      .CS3WCR  = 0x000024D0,
+      .CS5aWCR = 0x00031B40 },
+};
+
+#endif /* FX9860G */
+
+#ifdef FXCG50
+
+static struct cpg_overclock_setting const settings_prizm[5] = {
+    /* CLOCK_SPEED_F1 */
+    { .FLLFRQ  = 0x00004000 + 900,
+      .FRQCR   = 0x0F102203,
+      .CS0BCR  = 0x24920400,
+      .CS2BCR  = 0x24923400,
+      .CS3BCR  = 0x24924400,
+      .CS5aBCR = 0x15140400,
+      .CS0WCR  = 0x000001C0,
+      .CS2WCR  = 0x00000140,
+      .CS3WCR  = 0x000024D0,
+      .CS5aWCR = 0x00010240 },
+    /* CLOCK_SPEED_F2 */
+    { .FLLFRQ  = 0x00004000 + 900,
+      .FRQCR   = (SH4_PLL_32x<<24)+(SH4_DIV_8<<20)+(SH4_DIV_16<<12)+(SH4_DIV_16<<8)+SH4_DIV_32,
+      .CS0BCR  = 0x04900400,
+      .CS2BCR  = 0x04903400,
+      .CS3BCR  = 0x24924400,
+      .CS5aBCR = 0x15140400,
+      .CS0WCR  = 0x00000140,
+      .CS2WCR  = 0x000100C0,
+      .CS3WCR  = 0x000024D0,
+      .CS5aWCR = 0x00010240 },
+    /* CLOCK_SPEED_F3 */
+    { .FLLFRQ  = 0x00004000 + 900,
+      .FRQCR   = (SH4_PLL_32x<<24)+(SH4_DIV_4<<20)+(SH4_DIV_8<<12)+(SH4_DIV_8<<8)+SH4_DIV_32,
+      .CS0BCR  = 0x24900400,
+      .CS2BCR  = 0x04903400,
+      .CS3BCR  = 0x24924400,
+      .CS5aBCR = 0x15140400,
+      .CS0WCR  = 0x000002C0,
+      .CS2WCR  = 0x000201C0,
+      .CS3WCR  = 0x000024D0,
+      .CS5aWCR = 0x00010240 },
+    /* CLOCK_SPEED_F4 */
+    { .FLLFRQ  = 0x00004000 + 900,
+      .FRQCR   = (SH4_PLL_32x<<24)+(SH4_DIV_4<<20)+(SH4_DIV_4<<12)+(SH4_DIV_4<<8)+SH4_DIV_32,
+      .CS0BCR  = 0x44900400,
+      .CS2BCR  = 0x04903400,
+      .CS3BCR  = 0x24924400,
+      .CS5aBCR = 0x15140400,
+      .CS0WCR  = 0x00000440,
+      .CS2WCR  = 0x00040340,
+      .CS3WCR  = 0x000024D0,
+      .CS5aWCR = 0x00010240 },
+    /* CLOCK_SPEED_F5 */
+    { .FLLFRQ  = 0x00004000 + 900,
+      .FRQCR   = (SH4_PLL_26x<<24)+(SH4_DIV_2<<20)+(SH4_DIV_4<<12)+(SH4_DIV_4<<8)+SH4_DIV_16,
+      .CS0BCR  = 0x34900400,
+      .CS2BCR  = 0x04903400,
+      .CS3BCR  = 0x24924400,
+      .CS5aBCR = 0x15140400,
+      .CS0WCR  = 0x000003C0,
+      .CS2WCR  = 0x000402C0,
+      .CS3WCR  = 0x000024D0,
+      .CS5aWCR = 0x00010240 },
+};
+
+static struct cpg_overclock_setting const settings_fxcg50[5] = {
+    /* CLOCK_SPEED_F1 */
+    { .FLLFRQ  = 0x00004000 + 900,
+      .FRQCR   = 0x0F011112,
+      .CS0BCR  = 0x36DA0400,
+      .CS2BCR  = 0x36DA3400,
+      .CS3BCR  = 0x36DB4400,
+      .CS5aBCR = 0x17DF0400,
+      .CS0WCR  = 0x000003C0,
+      .CS2WCR  = 0x000003C0,
+      .CS3WCR  = 0x000024D1,
+      .CS5aWCR = 0x000203C1 },
+    /* CLOCK_SPEED_F2 */
+    { .FLLFRQ  = 0x00004000 + 900,
+      .FRQCR   = (SH4_PLL_16x<<24)+(SH4_DIV_4<<20)+(SH4_DIV_8<<12)+(SH4_DIV_8<<8)+SH4_DIV_8,
+      .CS0BCR  = 0x24920400,
+      .CS2BCR  = 0x24923400,
+      .CS3BCR  = 0x24924400,
+      .CS5aBCR = 0x17DF0400,
+      .CS0WCR  = 0x00000340,
+      .CS2WCR  = 0x000003C0,
+      .CS3WCR  = 0x000024D1,
+      .CS5aWCR = 0x000203C1 },
+    /* CLOCK_SPEED_F3 */
+    { .FLLFRQ  = 0x00004000 + 900,
+      .FRQCR  = (SH4_PLL_26x<<24)+(SH4_DIV_4<<20)+(SH4_DIV_8<<12)+(SH4_DIV_8<<8)+SH4_DIV_8,
+      .CS0BCR  = 0x24920400,
+      .CS2BCR  = 0x24923400,
+      .CS3BCR  = 0x24924400,
+      .CS5aBCR = 0x17DF0400,
+      .CS0WCR  = 0x00000240,
+      .CS2WCR  = 0x000003C0,
+      .CS3WCR  = 0x000024D1,
+      .CS5aWCR = 0x000203C1 },
+    /* CLOCK_SPEED_F4 */
+    { .FLLFRQ  = 0x00004000 + 900,
+      .FRQCR  = (SH4_PLL_32x<<24)+(SH4_DIV_2<<20)+(SH4_DIV_4<<12)+(SH4_DIV_8<<8)+SH4_DIV_16,
+      .CS0BCR  = 0x24920400,
+      .CS2BCR  = 0x24923400,
+      .CS3BCR  = 0x24924400,
+      .CS5aBCR = 0x17DF0400,
+      .CS0WCR  = 0x000002C0,
+      .CS2WCR  = 0x000003C0,
+      .CS3WCR  = 0x000024D1,
+      .CS5aWCR = 0x000203C1 },
+    /* CLOCK_SPEED_F5 */
+    { .FLLFRQ  = 0x00004000 + 900,
+      .FRQCR  = (SH4_PLL_26x<<24)+(SH4_DIV_2<<20)+(SH4_DIV_4<<12)+(SH4_DIV_4<<8)+SH4_DIV_8,
+      .CS0BCR  = 0x24920400,
+      .CS2BCR  = 0x24923400,
+      .CS3BCR  = 0x24924400,
+      .CS5aBCR = 0x17DF0400,
+      .CS0WCR  = 0x00000440,
+      .CS2WCR  = 0x000003C0,
+      .CS3WCR  = 0x000024D1,
+      .CS5aWCR = 0x000203C1 },
+};
+
+#endif /* FXCG50 */
+
+static struct cpg_overclock_setting const *get_settings(void)
+{
+#ifdef FX9860G
+    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 */
+
+#ifdef FXCG50
+    if(gint[HWCALC] == HWCALC_PRIZM)
+        return settings_prizm;
+    if(gint[HWCALC] == HWCALC_FXCG50)
+        return settings_fxcg50;
+#endif /* FXCG50 */
+
+    return NULL;
+}
+
+int clock_get_speed(void)
+{
+    struct cpg_overclock_setting const *settings = get_settings();
+    if(!settings)
+        return CLOCK_SPEED_UNKNOWN;
+
+    if(isSH3()) {
+        for(int i = 0; i < 5; i++) {
+            struct cpg_overclock_setting const *s = &settings[i];
+
+            if(SH7705_CPG.FRQCR.word == (s->FRQCR | 0x1000)
+                && SH7705_BSC.CS0BCR.lword == s->CS0BCR
+                && SH7705_BSC.CS2BCR.lword == s->CS2BCR
+                && SH7705_BSC.CS3BCR.lword == s->CS3BCR
+                && SH7705_BSC.CS5ABCR.lword == s->CS5aBCR
+                && SH7705_BSC.CS0WCR.lword == s->CS0WCR
+                && SH7705_BSC.CS2WCR.lword == s->CS2WCR
+                && SH7705_BSC.CS3WCR.lword == s->CS3WCR
+                && SH7705_BSC.CS5AWCR.lword == s->CS5aWCR)
+                return CLOCK_SPEED_F1 + i;
+        }
+    }
+    else {
+        for(int i = 0; i < 5; i++) {
+            struct cpg_overclock_setting const *s = &settings[i];
+
+            if(SH7305_CPG.FLLFRQ.lword == s->FLLFRQ
+                && SH7305_CPG.FRQCR.lword == s->FRQCR
+                && SH7305_BSC.CS0BCR.lword == s->CS0BCR
+                && SH7305_BSC.CS2BCR.lword == s->CS2BCR
+                && SH7305_BSC.CS3BCR.lword == s->CS3BCR
+                && SH7305_BSC.CS5ABCR.lword == s->CS5aBCR
+                && SH7305_BSC.CS0WCR.lword == s->CS0WCR
+                && SH7305_BSC.CS2WCR.lword == s->CS2WCR
+                && SH7305_BSC.CS3WCR.lword == s->CS3WCR
+                && SH7305_BSC.CS5AWCR.lword == s->CS5aWCR)
+                return CLOCK_SPEED_F1 + i;
+        }
+    }
+
+    return CLOCK_SPEED_UNKNOWN;
+}
+
+void clock_set_speed(int level)
+{
+    if(level < CLOCK_SPEED_F1 || level > CLOCK_SPEED_F5)
+        return;
+    if(clock_get_speed() == level)
+        return;
+
+    struct cpg_overclock_setting const *settings = get_settings();
+    if(!settings)
+        return;
+
+    struct cpg_overclock_setting const *s = &settings[level - CLOCK_SPEED_F1];
+    cpg_set_overclock_setting(s);
+}

src/cpu/ics.s

@@ -0,0 +1,64 @@
+.global _cpu_csleep_init
+.global _cpu_csleep
+.global _cpu_csleep_cancel
+
+_cpu_csleep_init:
+	mov.l	.memcpy, r1
+	mova	sleep, r0
+	mov	r0, r5
+	jmp	@r1
+	mov	#(sleep_end - sleep), r6
+
+.align 4
+.memcpy:
+	.long	_memcpy
+
+_cpu_csleep:
+	mov.l	r8, @-r15
+	sts.l	pr, @-r15
+	mov	r4, r8
+
+	/* Check if the sleep instruction is still there */
+1:	mov.w	@(8, r8), r0
+	extu.w	r0, r0
+	cmp/eq	#0x001b, r0
+	bf	2f
+
+	/* Invalidate the cache in case of previous ICS being cached */
+	mov	r8, r0
+	icbi	@r0
+	add	#18, r0
+	icbi	@r0
+
+	/* Execute the sleep, and loop */
+	jsr	@r8
+	nop
+	bra	1b
+	nop
+
+2:	lds.l	@r15+, pr
+	rts
+	mov.l	@r15+, r8
+
+_cpu_csleep_cancel:
+	mov	#0x0009, r0
+	add	#8, r4
+	mov.w	r0, @r4
+	icbi	@r4
+	rts
+	nop
+
+.align 4
+
+/* This is identical in functionality to the CPU driver's sleep() function */
+sleep:
+	mov.l	2f, r0
+	mov.l	@r0, r0
+	cmp/pl	r0
+	bt	1f
+	sleep
+1:	rts
+	nop
+	nop
+2:	.long	_cpu_sleep_block_counter
+sleep_end:

src/dma/dma.c

@@ -8,6 +8,7 @@
 #include <gint/drivers/states.h>
 #include <gint/clock.h>
 #include <gint/exc.h>
+#include <gint/cpu.h>
 
 #define DMA SH7305_DMA
 #define POWER SH7305_POWER
@@ -18,6 +19,8 @@ typedef volatile sh7305_dma_channel_t channel_t;
 static gint_call_t dma_callbacks[6] = { 0 };
 /* Sleep blocking flags for all channels */
 static bool dma_sleep_blocking[6] = { 0 };
+/* ICS for dma_channel_wait() for all channels */
+static cpu_csleep_t *dma_wait_ics[6] = { 0 };
 
 /* dma_channel(): Get address of a DMA channel */
 static channel_t *dma_channel(int channel)
@@ -113,6 +116,11 @@ static int dma_setup(int channel, dma_size_t size, uint blocks,
 	if(ch->DAR >= 0xe5007000 && ch->DAR <= 0xe5204000)
 		dma_sleep_blocking[channel] = true;
 
+	if(ch->SAR >= 0xfe200000 && ch->SAR <= 0xfe3fffff)
+		dma_sleep_blocking[channel] = true;
+	if(ch->DAR >= 0xfe200000 && ch->DAR <= 0xfe3fffff)
+		dma_sleep_blocking[channel] = true;
+
 	return 0;
 }
 
@@ -138,6 +146,7 @@ bool dma_transfer_async(int channel, dma_size_t size, uint blocks,
 static void dma_interrupt_transfer_ended(int channel)
 {
 	channel_t *ch = dma_channel(channel);
+	ch->CHCR.IE = 0;
 	ch->CHCR.DE = 0;
 	ch->CHCR.TE = 0;
 
@@ -147,31 +156,60 @@ static void dma_interrupt_transfer_ended(int channel)
 	if(dma_sleep_blocking[channel])
 		sleep_unblock();
 
-	if(dma_callbacks[channel].function)
+	/* Cancel any sleep operation that is synchronized with this interrupt */
+	if(dma_wait_ics[channel])
+		cpu_csleep_cancel(dma_wait_ics[channel]);
+
+	gint_call(dma_callbacks[channel]);
+	dma_callbacks[channel] = GINT_CALL_NULL;
+}
+
+/* dma_channel_wait(): Wait for a particular channel's transfer to finish
+
+   This function is used both during normal gint operation and during foreign
+   unbinds of the DMA driver. The waiting method varies with interrupt settings
+   and device ownership. */
+static void dma_channel_wait(int channel, bool foreign)
+{
+	channel_t *ch = dma_channel(channel);
+	if(!ch) return;
+
+	/* If interrupts are disabled or we don't own the device, spin-wait by
+	   checking either for TE to be set (Transfer Ended) or DE to be gone
+	   (channel disabled).
+
+	   There are definitely race conditions if the DMA is restarted between
+	   our checks; only the context of the calls guarantee soundness.
+
+	   * If interrupts are disabled, we assume there is no one that could
+	     start the DMA again, since we are the only thread of execution.
+	   * If the device is owned by another kernel, then we're transitioning
+	     so we have to wait for *all* tasks to complete anyway. The risk is
+	     rather to stop too early. */
+	if(!ch->CHCR.IE || foreign)
 	{
-		gint_call(dma_callbacks[channel]);
-		dma_callbacks[channel] = GINT_CALL_NULL;
+		while(ch->CHCR.DE && !ch->CHCR.TE) {}
+		return;
 	}
+
+	/* Initialize an interrupt-cancellable sleep, to ensure
+	   synchronization */
+	cpu_csleep_t ics;
+	cpu_csleep_init(&ics);
+	dma_wait_ics[channel] = &ics;
+
+	/* Now the ICS is set; if the interrupt has not occurred yet then the
+	   handler is guaranteed to cancel the sleep at some point */
+	if(ch->CHCR.DE && !ch->CHCR.TE) cpu_csleep(&ics);
+
+	/* Clear the ICS pointer for next time */
+	dma_wait_ics[channel] = NULL;
 }
 
 /* dma_transfer_wait(): Wait for a transfer to finish */
 void dma_transfer_wait(int channel)
 {
-	if(channel < 0)
-	{
-		for(int channel = 0; channel < 6; channel++)
-			dma_transfer_wait(channel);
-		return;
-	}
-
-	channel_t *ch = dma_channel(channel);
-	if(!ch) return;
-
-	while(ch->CHCR.DE && !ch->CHCR.TE)
-	{
-		/* Sleep only if the interrupt is enabled to wake us up */
-		if(ch->CHCR.IE) sleep();
-	}
+	dma_channel_wait(channel, false);
 }
 
 bool dma_transfer_sync(int channel, dma_size_t size, uint length,
@@ -258,10 +296,18 @@ static void configure(void)
 	DMA.OR.DME = 1;
 }
 
-static void universal_unbind(void)
+static void funbind(void)
 {
-	/* Make sure any DMA transfer is finished before leaving the app */
-	dma_transfer_wait(-1);
+	/* Wait for all OS transfers to finish before taking over */
+	for(int channel = 0; channel < 6; channel++)
+		dma_channel_wait(channel, true);
+}
+
+static void unbind(void)
+{
+	/* Make sure all DMA transfers are finished before leaving gint */
+	for(int channel = 0; channel < 6; channel++)
+		dma_channel_wait(channel, false);
 }
 
 static bool hpowered(void)
@@ -322,8 +368,8 @@ static void hrestore(dma_state_t const *s)
 gint_driver_t drv_dma0 = {
 	.name         = "DMA",
 	.configure    = configure,
-	.funbind      = universal_unbind,
-	.unbind       = universal_unbind,
+	.funbind      = funbind,
+	.unbind       = unbind,
 	.hpowered     = hpowered,
 	.hpoweron     = hpoweron,
 	.hpoweroff    = hpoweroff,

src/dma/memcpy.c

@@ -4,6 +4,18 @@
 void *dma_memcpy(void * __restrict dst, const void * __restrict src,
 	size_t size)
 {
-	dma_transfer_sync(1, DMA_32B, size >> 5, src, DMA_INC, dst, DMA_INC);
+	int block_size = DMA_32B;
+	int block_count = size >> 5;
+
+	/* Use 4-byte transfers to access SPU memory */
+	if(((uint32_t)src >= 0xfe200000 && (uint32_t)src < 0xfe400000) ||
+	   ((uint32_t)dst >= 0xfe200000 && (uint32_t)dst < 0xfe400000))
+	{
+		block_size = DMA_4B;
+		block_count = size >> 2;
+	}
+
+	dma_transfer_sync(1, block_size, block_count, src, DMA_INC, dst,
+		DMA_INC);
 	return dst;
 }

src/dma/memset.c

@@ -14,6 +14,17 @@ void *dma_memset(void *dst, uint32_t l, size_t size)
 	   different memory regions, making the DMA faster than the CPU. */
 	for(int i = 0; i < 8; i++) ILbuf[i] = l;
 
-	dma_transfer_sync(1, DMA_32B, size>>5, ILbuf, DMA_FIXED, dst, DMA_INC);
+	int block_size = DMA_32B;
+	int block_count = size >> 5;
+
+	/* Use 4-byte transfers to access SPU memory */
+	if((uint32_t)dst >= 0xfe200000 && (uint32_t)dst < 0xfe400000)
+	{
+		block_size = DMA_4B;
+		block_count = size >> 2;
+	}
+
+	dma_transfer_sync(1, block_size, block_count, ILbuf, DMA_FIXED, dst,
+		DMA_INC);
 	return dst;
 }

src/fs/close.c

@@ -0,0 +1,19 @@
+#include <unistd.h>
+#include <gint/fs.h>
+#include <errno.h>
+
+int close(int fd)
+{
+	fs_descriptor_t const *d = fs_get_descriptor(fd);
+	if(!d) {
+		errno = EBADF;
+		return (ssize_t)-1;
+	}
+
+	int rc = 0;
+	if(d->type->close)
+		rc = d->type->close(d->data);
+
+	fs_free_descriptor(fd);
+	return rc;
+}

src/fs/closedir.c

@@ -0,0 +1,10 @@
+#include <dirent.h>
+#include <unistd.h>
+#include <stdlib.h>
+
+int closedir(DIR *dp)
+{
+	int rc = close(dp->fd);
+	free(dp);
+	return rc;
+}

src/fs/creat.c

@@ -0,0 +1,6 @@
+#include <fcntl.h>
+
+int creat(char const *path, mode_t mode)
+{
+	return open(path, O_CREAT | O_WRONLY | O_TRUNC, mode);
+}

src/fs/fdopendir.c

@@ -0,0 +1,27 @@
+#include <gint/fs.h>
+#include <dirent.h>
+#include <stdlib.h>
+#include <errno.h>
+#include "fugue/fugue.h"
+
+DIR *fdopendir(int fd)
+{
+	fs_descriptor_t const *desc = fs_get_descriptor(fd);
+	if(desc == NULL) {
+		errno = EBADF;
+		return NULL;
+	}
+	if(desc->type != &fugue_dir_descriptor_type) {
+		errno = ENOTDIR;
+		return NULL;
+	}
+
+	DIR *dp = malloc(sizeof *dp);
+	if(!dp) {
+		errno = ENOMEM;
+		return NULL;
+	}
+
+	dp->fd = fd;
+	return dp;
+}

src/fs/fs.c

@@ -0,0 +1,103 @@
+#include <gint/fs.h>
+#include <gint/defs/attributes.h>
+#include <unistd.h>
+#include <errno.h>
+#include <stdlib.h>
+
+/* File descriptor table */
+static fs_descriptor_t *fdtable;
+
+fs_descriptor_t const *fs_get_descriptor(int fd)
+{
+	if(!fdtable || (unsigned)fd >= FS_FD_MAX)
+		return NULL;
+	if(fdtable[fd].type == NULL)
+		return NULL;
+
+	return &fdtable[fd];
+}
+
+int fs_create_descriptor(fs_descriptor_t const *data)
+{
+	if(!fdtable || data->type == NULL)
+		return -1;
+
+	/* Leave 0/1/2 for stdin, stdout and stderr */
+	for(int i = 3; i < FS_FD_MAX; i++) {
+		if(fdtable[i].type == NULL) {
+			fdtable[i] = *data;
+			return i;
+		}
+	}
+
+	return -1;
+}
+
+void fs_free_descriptor(int fd)
+{
+	if(!fdtable || (unsigned)fd >= FS_FD_MAX)
+		return;
+
+	fdtable[fd].type = NULL;
+	fdtable[fd].data = NULL;
+}
+
+int open_generic(fs_descriptor_type_t *type, void *data, int fd)
+{
+	if(!fdtable) {
+		errno = ENOMEM;
+		return -1;
+	}
+	if(!type) {
+		errno = EINVAL;
+		return -1;
+	}
+	fs_descriptor_t d = {
+		.type = type,
+		.data = data
+	};
+
+	/* Re-use file descriptor mode */
+	if(fd >= 0) {
+		if(fd >= FS_FD_MAX) {
+			errno = EBADF;
+			return -1;
+		}
+		if(fdtable[fd].type) {
+			errno = ENFILE;
+			return -1;
+		}
+
+		fdtable[fd] = d;
+		return fd;
+	}
+	/* Normal allocation mode */
+	else {
+		return fs_create_descriptor(&d);
+	}
+}
+
+/* Standard streams */
+
+static fs_descriptor_type_t devnull = {
+	.read   = NULL,
+	.write  = NULL,
+	.lseek  = NULL,
+	.close  = NULL,
+};
+
+GCONSTRUCTOR static void init_fs(void)
+{
+	fdtable = calloc(FS_FD_MAX, sizeof *fdtable);
+	if(!fdtable)
+		return;
+
+	fdtable[STDIN_FILENO].type = &devnull;
+	fdtable[STDIN_FILENO].data = NULL;
+
+	fdtable[STDOUT_FILENO].type = &devnull;
+	fdtable[STDOUT_FILENO].data = NULL;
+
+	fdtable[STDERR_FILENO].type = &devnull;
+	fdtable[STDERR_FILENO].data = NULL;
+}

src/fs/fugue/BFile_Ext_Stat.c

@@ -0,0 +1,24 @@
+#include <gint/bfile.h>
+#include "util.h"
+
+int BFile_Ext_Stat(uint16_t const *path, int *type, int *size)
+{
+	int search_handle, rc;
+	uint16_t found_file[256];
+	struct BFile_FileInfo fileinfo;
+
+	rc = BFile_FindFirst(path, &search_handle, found_file, &fileinfo);
+	if(rc < 0) {
+		if(type) *type = -1;
+		if(size) *size = -1;
+		rc = -1;
+	}
+	else {
+		if(type) *type = fileinfo.type;
+		if(size) *size = fileinfo.file_size;
+		rc = 0;
+	}
+
+	BFile_FindClose(search_handle);
+	return rc;
+}

src/fs/fugue/fugue.c

@@ -0,0 +1,145 @@
+#include <gint/fs.h>
+#include <gint/hardware.h>
+#include <gint/bfile.h>
+#include <gint/mmu.h>
+#include <gint/defs/util.h>
+#include <string.h>
+#include <fcntl.h>
+#include <errno.h>
+#include "fugue.h"
+#include "util.h"
+
+ssize_t fugue_read(void *data0, void *buf, size_t size)
+{
+	fugue_fd_t *data = data0;
+	int fugue_fd = data->fd;
+
+	/* Fugue allows to read past EOF up to the end of the sector */
+	int filesize = BFile_Size(fugue_fd);
+	if(data->pos + (int)size > filesize)
+		size = filesize - data->pos;
+
+	int rc = BFile_Read(fugue_fd, buf, size, -1);
+	if(rc < 0) {
+		errno = bfile_error_to_errno(rc);
+		return -1;
+	}
+	data->pos += rc;
+	return size;
+}
+
+static void *temp_ram(size_t total_size, size_t *block_size)
+{
+	for(size_t candidate = 16384; candidate >= 64; candidate >>= 1) {
+		if(candidate > 64 && candidate >= 2 * total_size)
+			continue;
+
+		size_t size = min(candidate, total_size);
+		void *ram = malloc(size);
+		if(ram) {
+			*block_size = size;
+			return ram;
+		}
+	}
+
+	return NULL;
+}
+
+ssize_t fugue_write(void *data0, const void *buf, size_t size)
+{
+	fugue_fd_t *data = data0;
+	int fugue_fd = data->fd;
+
+	/* The main concern of this function is that we cannot write from ROM.
+	   If [buf] is in ROM then we have to copy it to RAM, preferably within
+	   the limits of available heap memory. */
+	if(mmu_is_rom(buf)) {
+		size_t alloc_size, written=0;
+
+		void *ram = temp_ram(size, &alloc_size);
+		if(!ram) {
+			errno = ENOMEM;
+			return -1;
+		}
+
+		while(written < size) {
+			size_t block_size = min(size - written, alloc_size);
+			memcpy(ram, buf + written, block_size);
+
+			int rc = BFile_Write(fugue_fd, ram, block_size);
+			if(rc < 0) {
+				errno = bfile_error_to_errno(rc);
+				written = -1;
+				break;
+			}
+
+			written += rc;
+			data->pos += rc;
+
+			/* Partial write */
+			if(rc < (int)block_size) break;
+		}
+
+		free(ram);
+		return written;
+	}
+	/* Otherwise, we can write normally */
+	else {
+		int rc = BFile_Write(fugue_fd, buf, size);
+		if(rc < 0) {
+			errno = bfile_error_to_errno(rc);
+			return -1;
+		}
+		data->pos += rc;
+		return rc;
+	}
+}
+
+off_t fugue_lseek(void *data0, off_t offset, int whence)
+{
+	fugue_fd_t *data = data0;
+	int fugue_fd = data->fd;
+
+	int filesize = BFile_Size(fugue_fd);
+
+	if(whence == SEEK_CUR)
+		offset += data->pos;
+	else if(whence == SEEK_END)
+		offset += filesize;
+
+	/* BFile_Seek() clamps to the file size, but still returns the argument
+	   when it does... */
+	offset = min(offset, filesize);
+
+	int rc = BFile_Seek(fugue_fd, offset);
+	if(rc < 0) {
+		errno = bfile_error_to_errno(rc);
+		return -1;
+	}
+	data->pos = offset;
+
+	/* rc is the amount of space left in the file (including pre-allocated
+	   space), so instead just return offset directly */
+	return offset;
+}
+
+int fugue_close(void *data0)
+{
+	fugue_fd_t *data = data0;
+	int fugue_fd = data->fd;
+
+	int rc = BFile_Close(fugue_fd);
+	if(rc < 0) {
+		errno = bfile_error_to_errno(rc);
+		return -1;
+	}
+	free(data);
+	return 0;
+}
+
+const fs_descriptor_type_t fugue_descriptor_type = {
+	.read   = fugue_read,
+	.write  = fugue_write,
+	.lseek  = fugue_lseek,
+	.close  = fugue_close,
+};

src/fs/fugue/fugue.h

@@ -0,0 +1,40 @@
+#ifndef FS_FUGUE_FUGUE_H
+#define FS_FUGUE_FUGUE_H
+
+#include <gint/fs.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <dirent.h>
+#include <sys/stat.h>
+
+/* File descriptor type */
+extern const fs_descriptor_type_t fugue_descriptor_type;
+/* Directory descriptor type */
+extern const fs_descriptor_type_t fugue_dir_descriptor_type;
+
+/* Since on Graph 35+E II / fx-9860G III there is no (known) syscall to update
+   the file position, we need to track it ourselves, hopefully faithfully. */
+typedef struct {
+    int fd;
+    int pos;
+} fugue_fd_t;
+
+/* Specific implementations of some standard functions */
+
+int fugue_open(char const *path, int flags, mode_t mode);
+
+int fugue_unlink(char const *path);
+
+int fugue_rename(char const *oldpath, char const *newpath);
+
+int fugue_mkdir(char const *path, mode_t mode);
+
+int fugue_rmdir(char const *path);
+
+int fugue_stat(char const * restrict path, struct stat * restrict statbuf);
+
+/* Other functions */
+
+void *fugue_dir_explore(char const *path);
+
+#endif /* FS_FUGUE_FUGUE_H */

src/fs/fugue/fugue_dir.c

@@ -0,0 +1,159 @@
+#include <gint/fs.h>
+#include <gint/hardware.h>
+#include <gint/bfile.h>
+#include <dirent.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+#include "util.h"
+#include "fugue.h"
+
+typedef struct
+{
+	/* Number of entries */
+	int count;
+	/* All entries */
+	struct dirent **entries;
+	/* Current position in directory */
+	off_t pos;
+
+} dir_t;
+
+/* There is no well-standardized API for reading from directory descriptors.
+   getdents(2) is a thing, but it's mostly Linux-specific and has no glibc
+   wrapper, so no userspace application is using it directly. We define our
+   directory descriptor interface to mimic opendir(3) for efficiency. */
+
+ssize_t fugue_dir_read(void *data, void *buf, GUNUSED size_t size)
+{
+	struct dirent **dirent_ptr = buf;
+	if(size < sizeof *dirent_ptr)
+		return 0;
+
+	dir_t *dp = data;
+	if(dp->pos >= dp->count)
+		*dirent_ptr = NULL;
+	else
+		*dirent_ptr = dp->entries[dp->pos++];
+
+	return sizeof *dirent_ptr;
+}
+
+ssize_t fugue_dir_write(GUNUSED void *data, GUNUSED const void *buf,
+	GUNUSED size_t size)
+{
+	errno = EISDIR;
+	return -1;
+}
+
+off_t fugue_dir_lseek(void *data, off_t offset, int whence)
+{
+	dir_t *dp = data;
+
+	if(whence == SEEK_CUR)
+		offset += dp->pos;
+	if(whence == SEEK_END)
+		offset += dp->count;
+
+	/* dp->count, being at the end of the enumeration, is a valid offset */
+	if(offset < 0 || offset >= dp->count + 1) {
+		errno = EINVAL;
+		return -1;
+	}
+
+	dp->pos = offset;
+	return dp->pos;
+}
+
+int fugue_dir_close(void *data)
+{
+	dir_t *dp = data;
+
+	if(dp && dp->entries) {
+		for(int i = 0; i < dp->count; i++)
+			free(dp->entries[i]);
+		free(dp->entries);
+	}
+	free(dp);
+
+	return 0;
+}
+
+const fs_descriptor_type_t fugue_dir_descriptor_type = {
+	.read   = fugue_dir_read,
+	.write  = fugue_dir_write,
+	.lseek  = fugue_dir_lseek,
+	.close  = fugue_dir_close,
+};
+
+void *fugue_dir_explore(char const *path)
+{
+	struct BFile_FileInfo info;
+	char *wildcard=NULL;
+	uint16_t *fc_path=NULL, *search=NULL;
+
+	dir_t *dp = malloc(sizeof *dp);
+	if(!dp) goto alloc_failure;
+
+	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;
+
+	wildcard = malloc(strlen(path) + 3);
+	if(!wildcard) goto alloc_failure;
+	strcpy(wildcard, path);
+	strcat(wildcard, "/*");
+
+	search = fs_path_normalize_fc(wildcard);
+	if(!search) goto alloc_failure;
+
+	rc = BFile_FindFirst(search, &sd, fc_path, &info);
+	if(rc < 0) {
+		if(rc != BFile_EntryNotFound)
+			errno = bfile_error_to_errno(rc);
+		goto end;
+	}
+
+	do {
+		if(dp->count+1 > allocated) {
+			struct dirent **new_entries = realloc(dp->entries,
+				(allocated + 8) * sizeof *dp->entries);
+			if(!new_entries)
+				goto alloc_failure;
+			dp->entries = new_entries;
+			allocated += 8;
+		}
+
+		size_t name_length = fc_len(fc_path);
+		size_t s = sizeof(struct dirent) + name_length + 1;
+		struct dirent *ent = malloc(s);
+		if(!ent) goto alloc_failure;
+
+		ent->d_ino = 0;
+		ent->d_type = bfile_type_to_dirent(info.type);
+		fc_to_utf8(ent->d_name, fc_path, name_length + 1);
+		dp->entries[dp->count++] = ent;
+
+		rc = BFile_FindNext(sd, fc_path, &info);
+	}
+	while(rc >= 0);
+	goto end;
+
+alloc_failure:
+	errno = ENOMEM;
+	fugue_dir_close(dp);
+end:
+	free(wildcard);
+	free(search);
+	free(fc_path);
+	if(sd >= 0)
+		BFile_FindClose(sd);
+	return dp;
+}

src/fs/fugue/fugue_mkdir.c

@@ -0,0 +1,26 @@
+#include <gint/hardware.h>
+#include <gint/bfile.h>
+#include <gint/fs.h>
+#include <errno.h>
+#include "util.h"
+
+int fugue_mkdir(char const *path, GUNUSED mode_t mode)
+{
+	ENOTSUP_IF_NOT_FUGUE(-1);
+
+	uint16_t *fcpath = fs_path_normalize_fc(path);
+	if(!fcpath) {
+		errno = ENOMEM;
+		return -1;
+	}
+
+	int rc = BFile_Create(fcpath, BFile_Folder, NULL);
+	if(rc < 0) {
+		errno = bfile_error_to_errno(rc);
+		free(fcpath);
+		return -1;
+	}
+
+	free(fcpath);
+	return 0;
+}

src/fs/fugue/fugue_open.c

@@ -0,0 +1,143 @@
+#include <gint/fs.h>
+#include <gint/bfile.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <string.h>
+#include "util.h"
+#include "fugue.h"
+
+static int new_file_size;
+
+int fugue_open(char const *path, int flags, GUNUSED mode_t mode)
+{
+	ENOTSUP_IF_NOT_FUGUE(-1);
+
+	uint16_t *fcpath = fs_path_normalize_fc(path);
+	int fugue_fd, err, rc=-1, type, fd=-1;
+
+	if(!fcpath) {
+		errno = ENOMEM;
+		return -1;
+	}
+
+	/* Open mode */
+	int bfile_mode = BFile_ReadOnly;
+	if(flags & O_WRONLY)
+		bfile_mode = BFile_WriteOnly;
+	else if(flags & O_RDWR)
+		bfile_mode = BFile_ReadWrite;
+
+	/* Exclusive open means no sense unless creation is also requested */
+	bool excl = (flags & O_EXCL) && (flags & O_CREAT);
+	/* Truncation requires the file to be removed/recreated */
+	bool trunc = (flags & O_TRUNC) && (flags & O_CREAT);
+
+	/* Stat the entry. A special case is needed for the root, which doesn't
+	   respond well. fs_path_normalize_fc() normalizes the path so we just
+	   have to check for the fixed string "\\fls0\". */
+	bool exists;
+	if(!memcmp(fcpath, u"\\\\fls0\\", 16)) {
+		exists = true;
+		type = BFile_Type_Directory;
+	}
+	else {
+		exists = (BFile_Ext_Stat(fcpath, &type, NULL) == 0);
+		if(!exists) type = -1;
+	}
+
+	/* If the entry exists and O_EXCL was requested, fail. */
+	if(exists && excl) {
+		errno = EEXIST;
+		rc = -1;
+		goto end;
+	}
+
+	/* If the entry is not a directory but O_DIRECTORY is set, fail. If the
+	   directory doesn't exist, we fail regardless of O_CREAT. */
+	if((flags & O_DIRECTORY) && type != BFile_Type_Directory) {
+		errno = (exists ? ENOTDIR : ENOENT);
+		rc = -1;
+		goto end;
+	}
+
+	/* If the entry is a directory, open it as such */
+	if(type == BFile_Type_Directory) {
+		void *dp = fugue_dir_explore(path);
+		fs_descriptor_t data = {
+			.type = &fugue_dir_descriptor_type,
+			.data = dp,
+		};
+		fd = fs_create_descriptor(&data);
+		rc = fd;
+		goto end;
+	}
+
+	/* Try and open the file normally, unless O_TRUNC is specified without
+	   O_EXCL, in which case we simply delete and recreate the file. */
+	if(trunc)
+		fugue_fd = BFile_EntryNotFound;
+	else
+		fugue_fd = BFile_Open(fcpath, bfile_mode);
+
+	/* If O_TRUNC is requested and either the file exists or we can create
+	   it, remove it. (If fugue_fd < 0 an opening error might still have
+	   occurred so we delete it just in case.) */
+	if((flags & O_TRUNC) && (fugue_fd >= 0 || (flags & O_CREAT))) {
+		if(fugue_fd >= 0)
+			BFile_Close(fugue_fd);
+		BFile_Remove(fcpath);
+		fugue_fd = BFile_EntryNotFound;
+	}
+
+	/* If the file does not exist and O_CREAT is set, create it */
+	if((flags & O_CREAT) && ((flags & O_TRUNC) || fugue_fd < 0)) {
+		new_file_size = 0;
+		err = BFile_Create(fcpath, BFile_File, &new_file_size);
+		if(err < 0) {
+			errno = bfile_error_to_errno(err);
+			rc = -1;
+			goto end;
+		}
+		fugue_fd = BFile_Open(fcpath, bfile_mode);
+	}
+
+	if(fugue_fd < 0) {
+		errno = bfile_error_to_errno(fugue_fd);
+		rc = fugue_fd;
+		goto end;
+	}
+
+	/* If O_APPEND is set, move to the end of the file */
+	// TODO: O_APPEND should move the cursor before *each* write
+	int pos = 0;
+	if((flags & O_APPEND)) {
+		pos = BFile_Size(fugue_fd);
+		BFile_Seek(fugue_fd, pos);
+	}
+
+	/* Return the now-open file descriptor */
+	fugue_fd_t *data = malloc(sizeof *data);
+	if(!data) {
+		BFile_Close(fugue_fd);
+		goto end;
+	}
+	data->fd = fugue_fd;
+	data->pos = pos;
+
+	fs_descriptor_t fd_data = {
+		.type = &fugue_descriptor_type,
+		.data = data,
+	};
+	rc = fd = fs_create_descriptor(&fd_data);
+
+	if(fd == -1) {
+		BFile_Close(fugue_fd);
+		free(data);
+		errno = ENFILE;
+		goto end;
+	}
+
+end:
+	free(fcpath);
+	return rc;
+}

src/fs/fugue/fugue_rename.c

@@ -0,0 +1,38 @@
+#include <gint/hardware.h>
+#include <gint/bfile.h>
+#include <gint/fs.h>
+#include <errno.h>
+#include <sys/stat.h>
+#include "util.h"
+
+int fugue_rename(char const *oldpath, char const *newpath)
+{
+	ENOTSUP_IF_NOT_FUGUE(-1);
+	int rc = -1;
+
+	uint16_t *fcpath_1 = NULL;
+	uint16_t *fcpath_2 = NULL;
+
+	fcpath_1 = fs_path_normalize_fc(oldpath);
+	if(!fcpath_1) {
+		errno = ENOMEM;
+		goto end;
+	}
+	fcpath_2 = fs_path_normalize_fc(newpath);
+	if(!fcpath_2) {
+		errno = ENOMEM;
+		goto end;
+	}
+
+	rc = BFile_Rename(fcpath_1, fcpath_2);
+	if(rc < 0) {
+		errno = bfile_error_to_errno(rc);
+		rc = -1;
+	}
+	else rc = 0;
+
+end:
+	free(fcpath_1);
+	free(fcpath_2);
+	return rc;
+}

src/fs/fugue/fugue_rmdir.c

@@ -0,0 +1,51 @@
+#include <gint/hardware.h>
+#include <gint/bfile.h>
+#include <gint/fs.h>
+#include <errno.h>
+#include <dirent.h>
+#include <string.h>
+#include "util.h"
+#include "fugue.h"
+
+int fugue_rmdir(char const *path)
+{
+	ENOTSUP_IF_NOT_FUGUE(-1);
+
+	/* Check if the folder is empty */
+	DIR *dp = opendir(path);
+	if(!dp) return -1;
+
+	bool empty = true;
+	struct dirent *ent;
+
+	while((ent = readdir(dp))) {
+		if(strcmp(ent->d_name, ".") != 0 &&
+		   strcmp(ent->d_name, "..") != 0) {
+			empty = false;
+			break;
+		}
+	}
+
+	closedir(dp);
+
+	if(!empty) {
+		errno = ENOTEMPTY;
+		return -1;
+	}
+
+	uint16_t *fcpath = fs_path_normalize_fc(path);
+	if(!fcpath) {
+		errno = ENOMEM;
+		return -1;
+	}
+
+	int rc = BFile_Remove(fcpath);
+	if(rc < 0) {
+		errno = bfile_error_to_errno(rc);
+		rc = -1;
+	}
+	else rc = 0;
+
+	free(fcpath);
+	return rc;
+}

src/fs/fugue/fugue_stat.c

@@ -0,0 +1,36 @@
+#include <sys/stat.h>
+#include <gint/fs.h>
+#include <gint/bfile.h>
+#include "fugue.h"
+#include <errno.h>
+#include <stdlib.h>
+#include "util.h"
+
+int fugue_stat(char const * restrict path, struct stat * restrict statbuf)
+{
+	ENOTSUP_IF_NOT_FUGUE(-1);
+
+	uint16_t *fcpath = fs_path_normalize_fc(path);
+	if(!fcpath) {
+		errno = ENOMEM;
+		return -1;
+	}
+
+	int type, size, rc;
+	rc = BFile_Ext_Stat(fcpath, &type, &size);
+	free(fcpath);
+
+	if(rc < 0) {
+		errno = bfile_error_to_errno(rc);
+		return -1;
+	}
+
+	statbuf->st_mode = bfile_type_to_mode_t(type) | 0777;
+	statbuf->st_size = -1;
+
+	if(S_ISREG(statbuf->st_mode)) {
+		statbuf->st_size = size;
+	}
+
+	return 0;
+}

src/fs/fugue/fugue_unlink.c

@@ -0,0 +1,41 @@
+#include <gint/hardware.h>
+#include <gint/bfile.h>
+#include <gint/fs.h>
+#include <errno.h>
+#include <sys/stat.h>
+#include "util.h"
+
+int fugue_unlink(char const *path)
+{
+	ENOTSUP_IF_NOT_FUGUE(-1);
+
+	uint16_t *fcpath = fs_path_normalize_fc(path);
+	if(!fcpath) {
+		errno = ENOMEM;
+		return -1;
+	}
+
+	int type, size, rc;
+	rc = BFile_Ext_Stat(fcpath, &type, &size);
+	if(rc < 0) {
+		errno = bfile_error_to_errno(rc);
+		rc = -1;
+		goto end;
+	}
+	if(bfile_type_to_mode_t(type) != S_IFREG) {
+		errno = ENOTDIR;
+		rc = -1;
+		goto end;
+	}
+
+	rc = BFile_Remove(fcpath);
+	if(rc < 0) {
+		errno = bfile_error_to_errno(rc);
+		rc = -1;
+	}
+	else rc = 0;
+
+end:
+	free(fcpath);
+	return rc;
+}

src/fs/fugue/util.c

@@ -0,0 +1,245 @@
+#include "util.h"
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <stdarg.h>
+#include <gint/bfile.h>
+#include <dirent.h>
+#include <sys/stat.h>
+
+int bfile_error_to_errno(int e)
+{
+	/* TODO: Find BFile code for too many fds and map it to ENFILE. */
+	switch(e) {
+	case BFile_EntryNotFound:	return ENOENT;
+	case BFile_IllegalPath:		return EINVAL;
+	case BFile_DeviceFull:		return EDQUOT;
+	case BFile_IllegalDevice:	return EINVAL;
+	case BFile_AccessDenied:	return EACCES;
+	case BFile_PermissionError:	return EACCES;
+	case BFile_EntryFull:		return EDQUOT;
+	case BFile_AlreadyExists:	return EEXIST;
+	case BFile_ReadOnlyFile:	return EACCES;
+	case BFile_EnumerateEnd:	return ENOENT;
+	case BFile_IllegalSeekPos:	return EINVAL;
+	case BFile_NotMountDevice:	return ENOENT;
+	case BFile_DeviceNotFound:	return ENOENT;
+	default:			return errno;
+	}
+}
+
+int bfile_type_to_mode_t(int bfile_type)
+{
+	switch(bfile_type) {
+	case BFile_Type_Directory:      return S_IFDIR;
+	case BFile_Type_Dot:            return S_IFDIR;
+	case BFile_Type_DotDot:         return S_IFDIR;
+	case BFile_Type_MainMem:        return S_IFBLK;
+	case BFile_Type_File:           return S_IFREG;
+	case BFile_Type_Archived:       return S_IFREG;
+	default:                        return S_IFREG;
+	}
+}
+
+int bfile_type_to_dirent(int bfile_type)
+{
+	switch(bfile_type) {
+	case BFile_Type_Directory:      return DT_DIR;
+	case BFile_Type_Dot:            return DT_DIR;
+	case BFile_Type_DotDot:         return DT_DIR;
+	case BFile_Type_MainMem:        return DT_BLK;
+	case BFile_Type_File:           return DT_REG;
+	case BFile_Type_Archived:       return DT_REG;
+	default:                        return DT_UNKNOWN;
+	}
+}
+
+/* Length of FONTCHARACTER and UTF-8 strings, counting only ASCII characters */
+size_t utf8_len(char const *utf8)
+{
+	size_t len = 0;
+	for(size_t i = 0; utf8[i] != 0; i++)
+		len += (utf8[i] >= 0 && (uint8_t)utf8[i] <= 0x7f);
+	return len;
+}
+size_t fc_len(uint16_t const *fc)
+{
+	size_t len = 0;
+	for(size_t i = 0; fc[i] != 0 && fc[i] != 0xffff; i++)
+		len += (fc[i] <= 0x7f);
+	return len;
+}
+
+void utf8_to_fc(uint16_t *fc, char const *utf8, size_t fc_len)
+{
+	size_t j = 0;
+
+	for(size_t i = 0; j < fc_len && utf8[i] != 0; i++) {
+		if(utf8[i] == '/')
+			fc[j++] = '\\';
+		else if(utf8[i] >= 0 && (uint8_t)utf8[i] <= 0x7f)
+			fc[j++] = utf8[i];
+	}
+
+	if(j < fc_len)
+		fc[j++] = 0;
+}
+
+void fc_to_utf8(char *utf8, uint16_t const *fc, size_t utf8_len)
+{
+	size_t j = 0;
+
+	for(size_t i = 0; j < utf8_len && fc[i] != 0 && fc[i] != 0xffff; i++) {
+		if(fc[i] == '\\')
+			utf8[j++] = '/';
+		else if(fc[i] <= 0x7f)
+			utf8[j++] = fc[i];
+	}
+
+	if(j < utf8_len)
+		utf8[j++] = 0;
+}
+
+uint16_t *utf8_to_fc_alloc(uint16_t *prefix, char const *utf8,
+	uint16_t *suffix)
+{
+	size_t lenp=0, lens=0;
+	if(prefix) {
+		while(prefix[lenp] != 0 && prefix[lenp] != 0xffff)
+			lenp++;
+	}
+	if(suffix) {
+		while(suffix[lens] != 0 && suffix[lens] != 0xffff)
+			lens++;
+	}
+
+	size_t len = utf8_len(utf8);
+	uint16_t *fc = malloc((lenp+len+lens+1) * sizeof *fc);
+
+	if(fc != NULL) {
+		if(prefix)
+			memcpy(fc, prefix, lenp * sizeof *prefix);
+		utf8_to_fc(fc + lenp, utf8, len);
+		if(suffix)
+			memcpy(fc + lenp + len, suffix, lens * sizeof *suffix);
+		fc[lenp+len+lens] = 0;
+	}
+	return fc;
+}
+
+char *fc_to_utf8_alloc(uint16_t const *fc)
+{
+	size_t len = fc_len(fc);
+	char *utf8 = malloc(len+1);
+	if(utf8 != NULL)
+		fc_to_utf8(utf8, fc, len+1);
+	return utf8;
+}
+
+/* Split a path into components. Only the top array needs to be freed */
+char **fs_split_components(char *path, int *count)
+{
+	char **comps = NULL;
+	*count = 0;
+	int allocated = 0;
+
+	char *token = strtok(path, "/");
+
+	while(token) {
+		if(*count + 1 > allocated) {
+			allocated += 8;
+			char **new_comps = realloc(comps,
+				allocated * sizeof *comps);
+			if(!new_comps) {
+				*count = -1;
+				return NULL;
+			}
+			comps = new_comps;
+		}
+		comps[*count] = token;
+		*count += 1;
+
+		token = strtok(NULL, "/");
+	}
+
+	return comps;
+}
+
+/* Generalization of fs_path_normalize(). Returns a [char *] if use_fc=false,
+   otherwise returns an [uint16_t *]. */
+static void *path_normalize(char const *path, bool use_fc)
+{
+	char *path_dup = strdup(path);
+	if(!path_dup) return NULL;
+
+	int components=0;
+	char **comps = fs_split_components(path_dup, &components);
+	if(components == -1) {
+		free(path_dup);
+		return NULL;
+	}
+
+	/* Now rewrite comps[] to skip "." and apply ".." */
+	int wr = 0;
+	for(int rd=0; rd < components; rd++) {
+		char *comp = comps[rd];
+		if(!strcmp(comp, "."))
+			continue;
+		else if(!strcmp(comp, ".."))
+			wr -= (wr > 0);
+		else
+			comps[wr++] = comp;
+	}
+
+	/* Count total length */
+	int length = (use_fc ? 7 : 1) + (wr >= 1 ? wr - 1 : 0);
+	for(int i = 0; i < wr; i++) {
+		length += utf8_len(comps[i]);
+	}
+
+	/* Allocate string then copy */
+	if(use_fc) {
+		uint16_t *fc = malloc((length + 1) * sizeof *fc);
+		uint16_t *fc_init = fc;
+
+		memcpy(fc, u"\\\\fls0\\", 7*2);
+		fc += 7;
+
+		for(int i = 0; i < wr; i++) {
+			if(i > 0) *fc++ = '\\';
+			utf8_to_fc(fc, comps[i], (size_t)-1);
+			fc += utf8_len(comps[i]);
+		}
+
+		*fc++ = 0;
+		free(path_dup);
+		free(comps);
+		return fc_init;
+	}
+	else {
+		char *utf8 = malloc(length + 1);
+		char *utf8_init = utf8;
+		*utf8++ = '/';
+
+		for(int i = 0; i < wr; i++) {
+			if(i > 0) *utf8++ = '/';
+			strcpy(utf8, comps[i]);
+			utf8 += utf8_len(comps[i]);
+		}
+
+		*utf8++ = 0;
+		free(path_dup);
+		free(comps);
+		return utf8_init;
+	}
+}
+
+char *fs_path_normalize(char const *path)
+{
+	return path_normalize(path, false);
+}
+
+uint16_t *fs_path_normalize_fc(char const *path)
+{
+	return path_normalize(path, true);
+}

src/fs/fugue/util.h

@@ -0,0 +1,51 @@
+#ifndef FS_UTIL_H
+#define FS_UTIL_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <gint/hardware.h>
+#include <errno.h>
+
+#define ENOTSUP_IF_NOT_FUGUE(rc) \
+   if(gint[HWFS] != HWFS_FUGUE) { errno = ENOTSUP; return (rc); }
+
+/* Translate common BFile error codes to errno values. */
+int bfile_error_to_errno(int bfile_error_code);
+
+/* Translate BFile file types to st_mode values. */
+int bfile_type_to_mode_t(int bfile_type);
+
+/* Translate BFile file types to struct dirent values. */
+int bfile_type_to_dirent(int bfile_type);
+
+/* TODO: These functions do not actually translate special characters between
+   encodings, they simply strip them. */
+
+/* Length of UTF-8 string _as copied by utf8_to_fc functions_ */
+size_t utf8_len(char const *utf8);
+/* Length of FONTCHARACTER string _as copied by fc_to_utf8 functions_ */
+size_t fc_len(uint16_t const *fc);
+
+/* Convert UTF-8 to FONTCHARACTER; outputs fc_len characters with padding. If
+   fc[fc_len-1] is not 0 after the call, then fc is too short. */
+void utf8_to_fc(uint16_t *fc, char const *utf8, size_t fc_len);
+
+/* Same in the other direction. */
+void fc_to_utf8(char *utf8, uint16_t const *fc, size_t utf8_len);
+
+/* Same as utf8_to_fc() but allocates a string with malloc(). */
+uint16_t *utf8_to_fc_alloc(uint16_t *prefix, char const *utf8,
+   uint16_t *suffix);
+
+/* Same as fc_to_utf8() but allocates a string with malloc(). */
+char *fc_to_utf8_alloc(uint16_t const *fc);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FS_UTIL_H */

src/fs/lseek.c

@@ -0,0 +1,23 @@
+#include <unistd.h>
+#include <gint/fs.h>
+#include <errno.h>
+
+off_t lseek(int fd, off_t offset, int whence)
+{
+	if(whence != SEEK_SET && whence != SEEK_CUR && whence != SEEK_END) {
+		errno = EINVAL;
+		return (off_t)-1;
+	}
+
+	fs_descriptor_t const *d = fs_get_descriptor(fd);
+	if(!d) {
+		errno = EBADF;
+		return (ssize_t)-1;
+	}
+
+	if(d->type->lseek)
+		return d->type->lseek(d->data, offset, whence);
+
+	/* No seek function: cannot seek */
+	return 0;
+}

src/fs/mkdir.c

@@ -0,0 +1,8 @@
+#include <unistd.h>
+#include "fugue/fugue.h"
+
+int mkdir(char const *path, mode_t mode)
+{
+	/* Standard mkdir() is the Fugue filesystem only */
+	return fugue_mkdir(path, mode);
+}

src/fs/open.c

@@ -0,0 +1,14 @@
+#include <fcntl.h>
+#include <stdarg.h>
+#include "fugue/fugue.h"
+
+int open(char const *path, int flags, ...)
+{
+	va_list args;
+	va_start(args, flags);
+	mode_t mode = va_arg(args, int);
+	va_end(args);
+
+	/* Standard open() is the Fugue filesystem only */
+	return fugue_open(path, flags, mode);
+}

src/fs/opendir.c

@@ -0,0 +1,23 @@
+#include <dirent.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include <errno.h>
+
+DIR *opendir(const char *name)
+{
+	DIR *dp = malloc(sizeof *dp);
+	if(!dp) {
+		errno = ENOMEM;
+		return NULL;
+	}
+
+	int fd = open(name, O_DIRECTORY | O_RDONLY);
+	if(fd < 0) {
+		free(dp);
+		return NULL;
+	}
+
+	dp->fd = fd;
+	return dp;
+}

src/fs/pread.c

@@ -0,0 +1,24 @@
+#include <unistd.h>
+#include <gint/fs.h>
+#include <errno.h>
+
+ssize_t pread(int fd, void *buf, size_t size, off_t offset)
+{
+	off_t current = lseek(fd, 0, SEEK_CUR);
+	if(current == (off_t)-1)
+		return (ssize_t)-1;
+
+	ssize_t rc = -1;
+
+	if(lseek(fd, offset, SEEK_SET) == (off_t)-1)
+		goto end;
+
+	rc = read(fd, buf, size);
+	if(rc < 0)
+		goto end;
+
+end:
+	/* At the end, always try to restore the current position */
+	lseek(fd, current, SEEK_CUR);
+	return rc;
+}

src/fs/pwrite.c

@@ -0,0 +1,22 @@
+#include <unistd.h>
+
+ssize_t pwrite(int fd, const void *buf, size_t size, off_t offset)
+{
+	off_t current = lseek(fd, 0, SEEK_CUR);
+	if(current == (off_t)-1)
+		return (ssize_t)-1;
+
+	ssize_t rc = -1;
+
+	if(lseek(fd, offset, SEEK_SET) == (off_t)-1)
+		goto end;
+
+	rc = write(fd, buf, size);
+	if(rc < 0)
+		goto end;
+
+end:
+	/* At the end, always try to restore the current position */
+	lseek(fd, current, SEEK_CUR);
+	return rc;
+}

src/fs/read.c

@@ -0,0 +1,18 @@
+#include <unistd.h>
+#include <gint/fs.h>
+#include <errno.h>
+
+ssize_t read(int fd, void *buf, size_t size)
+{
+	fs_descriptor_t const *d = fs_get_descriptor(fd);
+	if(!d) {
+		errno = EBADF;
+		return (ssize_t)-1;
+	}
+
+	if(d->type->read)
+		return d->type->read(d->data, buf, size);
+
+	/* No read function: we can't read anything */
+	return 0;
+}

src/fs/readdir.c

@@ -0,0 +1,9 @@
+#include <dirent.h>
+#include <unistd.h>
+
+struct dirent *readdir(DIR *dp)
+{
+	struct dirent *ent = NULL;
+	read(dp->fd, &ent, sizeof ent);
+	return ent;
+}

src/fs/rename.c

@@ -0,0 +1,8 @@
+#include <stdio.h>
+#include "fugue/fugue.h"
+
+int rename(char const *oldpath, char const *newpath)
+{
+	/* Standard rename() is the Fugue filesystem only */
+	return fugue_rename(oldpath, newpath);
+}

src/fs/rewinddir.c

@@ -0,0 +1,7 @@
+#include <dirent.h>
+#include <unistd.h>
+
+void rewinddir(DIR *dp)
+{
+	lseek(dp->fd, 0, SEEK_SET);
+}

src/fs/rmdir.c

@@ -0,0 +1,8 @@
+#include <unistd.h>
+#include "fugue/fugue.h"
+
+int rmdir(char const *path)
+{
+	/* Standard rmdir() is the Fugue filesystem only */
+	return fugue_rmdir(path);
+}

src/fs/seekdir.c

@@ -0,0 +1,7 @@
+#include <dirent.h>
+#include <unistd.h>
+
+void seekdir(DIR *dp, long loc)
+{
+	lseek(dp->fd, loc, SEEK_SET);
+}

src/fs/stat.c

@@ -0,0 +1,8 @@
+#include <sys/stat.h>
+#include "fugue/fugue.h"
+
+int stat(char const * restrict path, struct stat * restrict statbuf)
+{
+	/* Standard stat() is the Fugue filesystem only */
+	return fugue_stat(path, statbuf);
+}

src/fs/telldir.c

@@ -0,0 +1,7 @@
+#include <dirent.h>
+#include <unistd.h>
+
+long telldir(DIR *dp)
+{
+	return lseek(dp->fd, 0, SEEK_CUR);
+}

src/fs/unlink.c

@@ -0,0 +1,8 @@
+#include <unistd.h>
+#include "fugue/fugue.h"
+
+int unlink(char const *path)
+{
+	/* Standard unlink() is the Fugue filesystem only */
+	return fugue_unlink(path);
+}

src/fs/write.c

@@ -0,0 +1,18 @@
+#include <unistd.h>
+#include <gint/fs.h>
+#include <errno.h>
+
+ssize_t write(int fd, const void *buf, size_t size)
+{
+	fs_descriptor_t const *d = fs_get_descriptor(fd);
+	if(!d) {
+		errno = EBADF;
+		return (ssize_t)-1;
+	}
+
+	if(d->type->write)
+		return d->type->write(d->data, buf, size);
+
+	/* No write function: discard the contents but show no error */
+	return size;
+}

src/gray/engine.c

@@ -41,6 +41,7 @@ static struct rendering_mode const gray_mode = {
 	.dclear       = gclear,
 	.drect        = grect,
 	.dpixel       = gpixel,
+	.dgetpixel    = ggetpixel,
 	.gint_dhline  = gint_ghline,
 	.gint_dvline  = gint_gvline,
 	.dtext_opt    = gtext_opt,
@@ -51,6 +52,7 @@ static struct rendering_mode const gray_exit_mode = {
 	.dclear       = NULL,
 	.drect        = NULL,
 	.dpixel       = NULL,
+	.dgetpixel    = NULL,
 	.gint_dhline  = NULL,
 	.gint_dvline  = NULL,
 	.dtext_opt    = NULL,

src/gray/ggetpixel.c

@@ -0,0 +1,15 @@
+#include <gint/gray.h>
+#include <gint/defs/types.h>
+
+int ggetpixel(int x, int y)
+{
+	uint32_t *light, *dark;
+	dgray_getvram(&light, &dark);
+
+	int offset = (y << 2) + (x >> 5);
+	uint32_t mask = 1 << (~x & 31);
+
+	bool l = (light[offset] & mask) != 0;
+	bool d = (dark [offset] & mask) != 0;
+	return (d << 1) | l;
+}

src/image/fixed.h

@@ -0,0 +1,47 @@
+//---
+// gint:image:fixed - Minimal fixed-point interface for linear transformations
+//---
+
+#ifndef GINT_IMAGE_FIXED
+#define GINT_IMAGE_FIXED
+
+/* Constants */
+#define fconst(x) ((x) * 65536)
+
+/* Multiplication */
+static inline int fmul(int x, int y)
+{
+    return ((int64_t)x * (int64_t)y) >> 16;
+}
+
+/* Division */
+static inline int fdiv(int x, int y)
+{
+    return ((int64_t)x << 16) / y;
+}
+
+/* Integer square root */
+static inline int isqrt(int n)
+{
+    if(n <= 0) return 0;
+    if(n < 4) return 1;
+
+    int low_bound = isqrt(n / 4) * 2;
+    int high_bound = low_bound + 1;
+
+    return (high_bound * high_bound <= n) ? high_bound : low_bound;
+}
+
+/* Floor operation */
+static inline int ffloor(int x)
+{
+    return (x >> 16);
+}
+
+/* Round operation */
+static inline int fround(int x)
+{
+    return ffloor(x + fconst(0.5));
+}
+
+#endif /* GINT_IMAGE_FIXED */

src/image/image_alloc.c

@@ -0,0 +1,27 @@
+#include <gint/image.h>
+#include <stdlib.h>
+#include <gint/defs/util.h>
+
+image_t *image_alloc(int width, int height, int format)
+{
+    image_t *img = image_create(width, height, format);
+    if(!img)
+        return NULL;
+
+    if(IMAGE_IS_RGB16(format))
+        img->stride = ((width + 1) >> 1) * 4;
+    else if(IMAGE_IS_P8(format))
+        img->stride = width;
+    else if(IMAGE_IS_P4(format))
+        img->stride = ((width + 1) >> 1);
+
+    void *data = malloc(height * img->stride);
+    if(!data) {
+        image_free(img);
+        return NULL;
+    }
+
+    img->data = data;
+    img->flags |= IMAGE_FLAGS_DATA_ALLOC;
+    return img;
+}

src/image/image_alloc_palette.c

@@ -0,0 +1,31 @@
+#include <gint/image.h>
+#include <gint/defs/util.h>
+#include <stdlib.h>
+#include <string.h>
+
+bool image_alloc_palette(image_t *img, int size)
+{
+    if(!img || !IMAGE_IS_INDEXED(img->format))
+        return false;
+    if(img->flags & IMAGE_FLAGS_PALETTE_ALLOC)
+        free(img->palette);
+
+    if(IMAGE_IS_P8(img->format)) {
+        size = (size <= 0) ? 256 : min(size, 256);
+    }
+    if(IMAGE_IS_P4(img->format)) {
+        size = 16;
+    }
+
+    img->palette = calloc(size, 2);
+    img->color_count = 0;
+    img->flags &= ~IMAGE_FLAGS_PALETTE_ALLOC;
+
+    if(!img->palette)
+        return false;
+
+    memset(img->palette, 0, 2*size);
+    img->color_count = size;
+    img->flags |= IMAGE_FLAGS_PALETTE_ALLOC;
+    return true;
+}

src/image/image_alpha.c

@@ -0,0 +1,16 @@
+#include <gint/image.h>
+
+int image_alpha(int format)
+{
+    switch(format) {
+    case IMAGE_RGB565A:
+        return 0x0001;
+    case IMAGE_P8_RGB565A:
+        return -128;
+    case IMAGE_P4_RGB565A:
+        return 0;
+    default:
+        /* A value that cannot be found in any pixel of any format */
+        return 0x10000;
+    }
+}