Lephenixnoir
/
gint
10
14
Fork 8
Code Issues 4 Pull Requests Releases Wiki Activity
gint/CMakeLists.txt

169 lines
4.5 KiB
CMake
Raw Normal View History

switch build system to CMake This factors the burden of compiler specification in the fxSDK while providing substantially more support through CMake modules.
2021-01-25 15:31:20 +01:00
# Build system for the gint unikernel
cmake: lower minimum required version to 3.15
2021-05-10 15:27:06 +02:00
cmake_minimum_required(VERSION 3.15)
bump version to 2.5.0
2021-05-25 21:21:24 +02:00
project(Gint VERSION 2.5.0 LANGUAGES C ASM)
switch build system to CMake This factors the burden of compiler specification in the fxSDK while providing substantially more support through CMake modules.
2021-01-25 15:31:20 +01:00
include(GitVersionNumber)
include(Fxconv)
cmake: restore options USER_VRAM and STATIC_GRAY
2021-01-25 19:06:42 +01:00
option(GINT_USER_VRAM "Put all VRAMs into the user stack (fx-CG 50 only)")
option(GINT_STATIC_GRAY "Use static memory instead of malloc for gray buffers (fx-9860G only)")
kmalloc: implement a custom segregated list allocator The new allocator uses a segregated best-fit algorithm with exact-size lists for all sizes between 8 bytes (the minimum) and 60 bytes, one list for blocks of size 64-252 and one for larger blocks. Arenas managed by this allocator have built-in statistics that track used and free memory (accounting for block headers), peak memory, and various allocation results. In addition, the allocator has self-checks in the form of integrity verifications, that can be enabled with -DGINT_KMALLOC_DEBUG=1 at configuration time or with the :dev configuration for GiteaPC. This is used by gintctl. The kmalloc interface is extended with a new arena covering all unused memory in user RAM, managed by gint's allocator. It spans about 4 kB on SH3 fx-9860G, 16 kB on SH4 fx-9860G, and 500 kB on fx-CG 50, in addition to the OS heap. This new arena is now the default arena for malloc(), except on SH3 where some heap problems are currently known.
2021-03-15 15:04:24 +01:00
option(GINT_KMALLOC_DEBUG "Enable debug functions for kmalloc")
cmake: restore options USER_VRAM and STATIC_GRAY
2021-01-25 19:06:42 +01:00
cmake: CMAKE_INSTALL_MESSAGE=LAZY
2021-04-11 18:48:57 +02:00
set(CMAKE_INSTALL_MESSAGE LAZY)
cmake: restore options USER_VRAM and STATIC_GRAY
2021-01-25 19:06:42 +01:00
# Generate <gint/config.h> with commit hash, version name and options
cmake: do not require a build from the gint tree (#15)
2021-05-11 08:27:24 +02:00
if(EXISTS "${CMAKE_SOURCE_DIR}/.git")
git_version_number(SHORT_HASH "GINT_GIT_HASH" TAG_RELATIVE "GINT_GIT_VERSION")
else()
set(GINT_GIT_HASH "")
set(GINT_GIT_VERSION "${PROJECT_VERSION}")
endif()
switch build system to CMake This factors the burden of compiler specification in the fxSDK while providing substantially more support through CMake modules.
2021-01-25 15:31:20 +01:00
configure_file(include/gint/config.h.in include/gint/config.h)
set(SOURCES_COMMON
src/cpg/cpg.c
kernel: driver and world system overhaul Changes in the driver and world system: * Rewrite driver logic to include more advanced concepts. The notion of binding a driver to a device is introduced to formalize wait(); power management is now built-in instead of being handled by the drivers (for instance DMA). The new driver model is described in great detail in <gint/drivers.h> * Formalized the concept of "world switch" where the hardware state is saved and later restored. As a tool, the world switch turns out to be very stable, and allows a lot of hardware manipulation that would be edgy at best when running in the OS world. * Added a GINT_DRV_SHARED flag for drivers to specify that their state is shared between worlds and not saved/restored. This has a couple of uses. * Exposed a lot more of the internal driver/world system as their is no particular downside to it. This includes stuff in <gint/drivers.h> and the driver's state structures in <gint/drivers/states.h>. This is useful for debugging and for cracked concepts, but there is no API stability guarantee. * Added a more flexible driver level system that allows any 2-digit level to be used. Feature changes: * Added a CPU driver that provides the VBR change as its state save. Because the whole context switch relied on interrupts being disabled anyway, there is no longer an inversion of control when setting the VBR; this is just part of the CPU driver's configuration. The CPU driver may also support other features such as XYRAM block transfer in the future. * Moved gint_inthandler() to the INTC driver under the name intc_handler(), pairing up again with intc_priority(). * Added a reentrant atomic lock based on the test-and-set primitive. Interrupts are disabled with IMASK=15 for the duration of atomic operations. * Enabled the DMA driver on SH7305-based fx-9860G. The DMA provides little benefit on this platform because the RAM is generally faster and buffers are ultimately small. The DMA is still not available on SH3-based fx-9860G models. * Solved an extremely obnoxious bug in timer_spin_wait() where the timer is not freed, causing the callback to be called when interrupts are re-enabled. This increments a random value on the stack. As a consequence of the change, removed the long delays in the USB driver since they are not actually needed. Minor changes: * Deprecated some of the elements in <gint/hardware.h>. There really is no good way to "enumerate" devices yet. * Deprecated gint_switch() in favor of a new function gint_world_switch() which uses the GINT_CALL abstraction. * Made the fx-9860G VRAM 32-aligned so that it can be used for tests with the DMA. Some features of the driver and world systems have not been implemented yet, but may be in the future: * Some driver flags should be per-world in order to create multiple gint worlds. This would be useful in Yatis' hypervisor. * A GINT_DRV_LAZY flag would be useful for drivers that don't want to be started up automatically during a world switch. This is relevant for drivers that have a slow start/stop sequence. However, this is tricky to do correctly as it requires dynamic start/stop and also tracking which world the current hardware state belongs to.
2021-04-23 18:50:20 +02:00
src/cpu/atomic.c
src/cpu/cpu.c
src/cpu/registers.s
cpu: allow functions to block the sleep() function This change introduces new sleep_block() and sleep_unblock() functions that control whether the sleep() function actually sleeps. This type of behavior was already implemented in the DMA driver, since DMA access to on-chip memory is paused when sleeping (on-chip memory being paused itself), which would make waiting for a DMA transfer a freeze. Because DMA transfers are now asynchronous, and USB transfers that may involve on-chip memory are coming, this API change allows the DMA and USB drivers to block the sleep() function so that user code can sleep() for interrupts without having to worry about asynchronous tasks requiring on-chip memory to complete.
2021-05-05 15:17:23 +02:00
src/cpu/sleep.c
kernel: driver and world system overhaul Changes in the driver and world system: * Rewrite driver logic to include more advanced concepts. The notion of binding a driver to a device is introduced to formalize wait(); power management is now built-in instead of being handled by the drivers (for instance DMA). The new driver model is described in great detail in <gint/drivers.h> * Formalized the concept of "world switch" where the hardware state is saved and later restored. As a tool, the world switch turns out to be very stable, and allows a lot of hardware manipulation that would be edgy at best when running in the OS world. * Added a GINT_DRV_SHARED flag for drivers to specify that their state is shared between worlds and not saved/restored. This has a couple of uses. * Exposed a lot more of the internal driver/world system as their is no particular downside to it. This includes stuff in <gint/drivers.h> and the driver's state structures in <gint/drivers/states.h>. This is useful for debugging and for cracked concepts, but there is no API stability guarantee. * Added a more flexible driver level system that allows any 2-digit level to be used. Feature changes: * Added a CPU driver that provides the VBR change as its state save. Because the whole context switch relied on interrupts being disabled anyway, there is no longer an inversion of control when setting the VBR; this is just part of the CPU driver's configuration. The CPU driver may also support other features such as XYRAM block transfer in the future. * Moved gint_inthandler() to the INTC driver under the name intc_handler(), pairing up again with intc_priority(). * Added a reentrant atomic lock based on the test-and-set primitive. Interrupts are disabled with IMASK=15 for the duration of atomic operations. * Enabled the DMA driver on SH7305-based fx-9860G. The DMA provides little benefit on this platform because the RAM is generally faster and buffers are ultimately small. The DMA is still not available on SH3-based fx-9860G models. * Solved an extremely obnoxious bug in timer_spin_wait() where the timer is not freed, causing the callback to be called when interrupts are re-enabled. This increments a random value on the stack. As a consequence of the change, removed the long delays in the USB driver since they are not actually needed. Minor changes: * Deprecated some of the elements in <gint/hardware.h>. There really is no good way to "enumerate" devices yet. * Deprecated gint_switch() in favor of a new function gint_world_switch() which uses the GINT_CALL abstraction. * Made the fx-9860G VRAM 32-aligned so that it can be used for tests with the DMA. Some features of the driver and world systems have not been implemented yet, but may be in the future: * Some driver flags should be per-world in order to create multiple gint worlds. This would be useful in Yatis' hypervisor. * A GINT_DRV_LAZY flag would be useful for drivers that don't want to be started up automatically during a world switch. This is relevant for drivers that have a slow start/stop sequence. However, this is tricky to do correctly as it requires dynamic start/stop and also tracking which world the current hardware state belongs to.
2021-04-23 18:50:20 +02:00
src/dma/dma.c
src/dma/inth.s
src/dma/memcpy.c
src/dma/memset.c
switch build system to CMake This factors the burden of compiler specification in the fxSDK while providing substantially more support through CMake modules.
2021-01-25 15:31:20 +01:00
src/intc/intc.c
use GINT_CALL() in every API that has callbacks * Change gint_inth_callback() * Add intc_handler_function() to use C functions as handlers instead of writing assembler, and use it in the RTC and USB * Revisit the TMU handlers, which after moving out the callbacks, now fit into 3 gates (great!), and adapt the ETMU handler * Improve the timer driver (less code = better code, removed magic constants assuming the VBR layout on SH3/SH4, etc.) * Remove 2 gates and a gap from the compact scheme on SH3 * Define timer_configure() to replace timer_setup(), which could not be cleanly updated to support GINT_CALL() * Replace rtc_start/stop_timer with rtc_periodic_enable/disable, which is less confusing because of ETMU being "RTC timers"
2021-04-27 14:29:38 +02:00
src/intc/inth.s
switch build system to CMake This factors the burden of compiler specification in the fxSDK while providing substantially more support through CMake modules.
2021-01-25 15:31:20 +01:00
src/kernel/exch.c
src/kernel/exch.s
src/kernel/hardware.c
src/kernel/inth.S
src/kernel/kernel.c
src/kernel/osmenu.c
src/kernel/start.c
src/kernel/syscalls.S
src/kernel/tlbh.S
kernel: driver and world system overhaul Changes in the driver and world system: * Rewrite driver logic to include more advanced concepts. The notion of binding a driver to a device is introduced to formalize wait(); power management is now built-in instead of being handled by the drivers (for instance DMA). The new driver model is described in great detail in <gint/drivers.h> * Formalized the concept of "world switch" where the hardware state is saved and later restored. As a tool, the world switch turns out to be very stable, and allows a lot of hardware manipulation that would be edgy at best when running in the OS world. * Added a GINT_DRV_SHARED flag for drivers to specify that their state is shared between worlds and not saved/restored. This has a couple of uses. * Exposed a lot more of the internal driver/world system as their is no particular downside to it. This includes stuff in <gint/drivers.h> and the driver's state structures in <gint/drivers/states.h>. This is useful for debugging and for cracked concepts, but there is no API stability guarantee. * Added a more flexible driver level system that allows any 2-digit level to be used. Feature changes: * Added a CPU driver that provides the VBR change as its state save. Because the whole context switch relied on interrupts being disabled anyway, there is no longer an inversion of control when setting the VBR; this is just part of the CPU driver's configuration. The CPU driver may also support other features such as XYRAM block transfer in the future. * Moved gint_inthandler() to the INTC driver under the name intc_handler(), pairing up again with intc_priority(). * Added a reentrant atomic lock based on the test-and-set primitive. Interrupts are disabled with IMASK=15 for the duration of atomic operations. * Enabled the DMA driver on SH7305-based fx-9860G. The DMA provides little benefit on this platform because the RAM is generally faster and buffers are ultimately small. The DMA is still not available on SH3-based fx-9860G models. * Solved an extremely obnoxious bug in timer_spin_wait() where the timer is not freed, causing the callback to be called when interrupts are re-enabled. This increments a random value on the stack. As a consequence of the change, removed the long delays in the USB driver since they are not actually needed. Minor changes: * Deprecated some of the elements in <gint/hardware.h>. There really is no good way to "enumerate" devices yet. * Deprecated gint_switch() in favor of a new function gint_world_switch() which uses the GINT_CALL abstraction. * Made the fx-9860G VRAM 32-aligned so that it can be used for tests with the DMA. Some features of the driver and world systems have not been implemented yet, but may be in the future: * Some driver flags should be per-world in order to create multiple gint worlds. This would be useful in Yatis' hypervisor. * A GINT_DRV_LAZY flag would be useful for drivers that don't want to be started up automatically during a world switch. This is relevant for drivers that have a slow start/stop sequence. However, this is tricky to do correctly as it requires dynamic start/stop and also tracking which world the current hardware state belongs to.
2021-04-23 18:50:20 +02:00
src/kernel/world.c
switch build system to CMake This factors the burden of compiler specification in the fxSDK while providing substantially more support through CMake modules.
2021-01-25 15:31:20 +01:00
src/keysc/getkey.c
src/keysc/iokbd.c
src/keysc/keycodes.c
keydev: add a keyboard device layer to abstract away globals The new keyboard device (keydev) interface implements the kernel's view of a keyboard providing input events. Its main role is to abstract all the globals of the KEYSC driver and getkey functions into a separate object: the "keyboard device". The device implements event transformations such as modifiers and repeats, instead of leaving them to getkey. While this can seem surprising at first, a real keyboard controller is responsible for repeats and modifier actions depend on the state of the keyboard which is only tracked in real-time. In this commit, getkey() has not changed yet apart from indirectly using the keydev interface with pollevent(). It will be changed soon to use event transforms in keydev_read(), and will be left in charge of providing repeat profiles, handling return-to-menu, backlight changes and timeouts, all of which are user convenience features.
2021-03-05 09:31:34 +01:00
src/keysc/keydev.c
switch build system to CMake This factors the burden of compiler specification in the fxSDK while providing substantially more support through CMake modules.
2021-01-25 15:31:20 +01:00
src/keysc/keysc.c
kmalloc: implement a custom segregated list allocator The new allocator uses a segregated best-fit algorithm with exact-size lists for all sizes between 8 bytes (the minimum) and 60 bytes, one list for blocks of size 64-252 and one for larger blocks. Arenas managed by this allocator have built-in statistics that track used and free memory (accounting for block headers), peak memory, and various allocation results. In addition, the allocator has self-checks in the form of integrity verifications, that can be enabled with -DGINT_KMALLOC_DEBUG=1 at configuration time or with the :dev configuration for GiteaPC. This is used by gintctl. The kmalloc interface is extended with a new arena covering all unused memory in user RAM, managed by gint's allocator. It spans about 4 kB on SH3 fx-9860G, 16 kB on SH4 fx-9860G, and 500 kB on fx-CG 50, in addition to the OS heap. This new arena is now the default arena for malloc(), except on SH3 where some heap problems are currently known.
2021-03-15 15:04:24 +01:00
src/kmalloc/arena_gint.c
kmalloc: create the kmalloc interface This change introduces a centralized memory allocator in the kernel. This interface can call into multiple arenas, including the default OS heap and planned arenas managed by a gint algorithm. The main advantage of this method is that it allows the heap to be extended over previously-unused areas of RAM such as the end of the static RAM region (apart from where the stack resides). Not using the OS heap is also sometimes a matter of correctness since on some OS versions the heap is known to fragment badly and degrade over time. I hope the deep control this interfaces gives over meomry allocation will allow very particular applications like object-specific allocators in fragmented SPU memory. This change does not introduce any new algorithm or arena so programs should behave exactly as before.
2021-03-12 17:22:24 +01:00
src/kmalloc/arena_osheap.c
src/kmalloc/kmalloc.c
improve structure of sources and formatted printer * Create an `src/3rdparty` folder for third-party code (to add the Grisu2B alfogithm soon). * Split the formatted printer into gint's kprint (src/kprint), its extension and interface (include/gint/kprint.h), and its use in the standard stdio functions (src/std/print.c). * Slightly improve the interface of kformat_geometry() to avoid relying on knowing format specifiers. * Add a function to register more formatters, to allow floating-point formatters without requiring them.
2021-02-01 12:10:45 +01:00
src/kprint/kprint.c
kprint: add floating-point formatting based in Grisu2b 59,56
2021-02-02 22:18:15 +01:00
src/kprint/kformat_fp.c
switch build system to CMake This factors the burden of compiler specification in the fxSDK while providing substantially more support through CMake modules.
2021-01-25 15:31:20 +01:00
src/mmu/mmu.c
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/dvline.c
src/render/topti.c
src/rtc/rtc.c
rtc: add an rtc_ticks() function similar to RTC_GetTicks()
2021-01-31 09:19:19 +01:00
src/rtc/rtc_ticks.c
switch build system to CMake This factors the burden of compiler specification in the fxSDK while providing substantially more support through CMake modules.
2021-01-25 15:31:20 +01:00
src/spu/spu.c
std/stdio: support asprintf() and vasprintf()
2021-02-15 09:48:10 +01:00
src/std/aprint.c
kmalloc: create the kmalloc interface This change introduces a centralized memory allocator in the kernel. This interface can call into multiple arenas, including the default OS heap and planned arenas managed by a gint algorithm. The main advantage of this method is that it allows the heap to be extended over previously-unused areas of RAM such as the end of the static RAM region (apart from where the stack resides). Not using the OS heap is also sometimes a matter of correctness since on some OS versions the heap is known to fragment badly and degrade over time. I hope the deep control this interfaces gives over meomry allocation will allow very particular applications like object-specific allocators in fragmented SPU memory. This change does not introduce any new algorithm or arena so programs should behave exactly as before.
2021-03-12 17:22:24 +01:00
src/std/malloc.c
improve structure of sources and formatted printer * Create an `src/3rdparty` folder for third-party code (to add the Grisu2B alfogithm soon). * Split the formatted printer into gint's kprint (src/kprint), its extension and interface (include/gint/kprint.h), and its use in the standard stdio functions (src/std/print.c). * Slightly improve the interface of kformat_geometry() to avoid relying on knowing format specifiers. * Add a function to register more formatters, to allow floating-point formatters without requiring them.
2021-02-01 12:10:45 +01:00
src/std/print.c
switch build system to CMake This factors the burden of compiler specification in the fxSDK while providing substantially more support through CMake modules.
2021-01-25 15:31:20 +01:00
src/tmu/inth-etmu.s
src/tmu/inth-tmu.s
src/tmu/sleep.c
src/tmu/tmu.c
usb: USB 2.0 function driver (WIP) * Add the power management functions (mostly stable even under overclock; requires some testing, but no known issue) * Add a dynamic configuration system where interfaces can declare descriptors with arbitrary endpoint numbers and additional parameters, and the driver allocates USB resources (endpoints, pipes and FIFO memory) between interfaces at startup. This allows implementations of different classes to be independent from each other. * Add responses to common SETUP requests. * Add pipe logic that allows programs to write data synchronously or asynchronously to pipes, in a single or several fragments, regardless of the buffer size (still WIP with a few details to polish and the API is not public yet). * Add a WIP bulk IN interface that allows sending data to the host. This will eventually support the fxlink protocol.
2021-04-11 19:04:54 +02:00
src/usb/classes/ff-bulk.c
src/usb/configure.c
src/usb/pipes.c
src/usb/setup.c
src/usb/string.c
src/usb/usb.c
improve structure of sources and formatted printer * Create an `src/3rdparty` folder for third-party code (to add the Grisu2B alfogithm soon). * Split the formatted printer into gint's kprint (src/kprint), its extension and interface (include/gint/kprint.h), and its use in the standard stdio functions (src/std/print.c). * Slightly improve the interface of kformat_geometry() to avoid relying on knowing format specifiers. * Add a function to register more formatters, to allow floating-point formatters without requiring them.
2021-02-01 12:10:45 +01:00
src/3rdparty/tinymt32/rand.c
src/3rdparty/tinymt32/tinymt32.c
kprint: add floating-point formatting based in Grisu2b 59,56
2021-02-02 22:18:15 +01:00
src/3rdparty/grisu2b_59_56/grisu2b_59_56.c
switch build system to CMake This factors the burden of compiler specification in the fxSDK while providing substantially more support through CMake modules.
2021-01-25 15:31:20 +01:00
)
set(SOURCES_FX
src/gray/engine.c
src/gray/gclear.c
src/gray/gint_gline.c
src/gray/gpixel.c
src/gray/grect.c
src/gray/gsubimage.c
src/gray/gtext.c
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/dpixel.c
src/render-fx/drect.c
src/render-fx/dsubimage.c
src/render-fx/dupdate.c
src/render-fx/gint_dline.c
src/render-fx/masks.c
src/render-fx/topti-asm.s
src/render-fx/topti.c
src/t6k11/t6k11.c
usb: FIFO controllers and fxlink API This changes fixes the way gint uses the FIFO controllers D0F and D1F to access the FIFO. It previously used D0F in the main thread and D1F during interrupt handling, but this is incorrect for several reasons, mainly the possible change of controllers between a write and a commit, and numerous instances of two FIFOs managing the same pipe caused by the constant switching. gint now treats FIFO controllers as resources allocated to pipes for the duration of a commit-terminated sequence of writes. The same controller is used for a single pipe in both normal and interrupt modes, and released when the pipe is committed. If no controller is available, asynchronous writes fail and synchronous ones wait. The fxlink API is also added with a small amount of functions, namely to transfer screenshots and raw text. Currently these are synchronous and do not use the DMA, this will be improved later. Finally: * Removed pipe logic from src/usb/setup.c, instead letting pipes.c handle the special case of the DCP (which might be regularized later) * Removed the usb_pipe_mode_{read,write} functions as they're actually about FIFo controllers and it's not clear yet how a pipe with both read and write should be handled. This is left for the future. * Clarified end-of-sequence semantics after a successful commit.
2021-05-07 15:22:46 +02:00
src/usb/classes/ff-bulk-gray.c
switch build system to CMake This factors the burden of compiler specification in the fxSDK while providing substantially more support through CMake modules.
2021-01-25 15:31:20 +01:00
)
set(SOURCES_CG
src/r61524/r61524.c
src/render-cg/bopti-asm.s
src/render-cg/bopti.c
src/render-cg/dclear.c
src/render-cg/dpixel.c
src/render-cg/drect.c
src/render-cg/dsubimage.c
src/render-cg/dupdate.c
src/render-cg/dvram.c
src/render-cg/gint_dline.c
src/render-cg/topti-asm.s
src/render-cg/topti.c
)
set(ASSETS_FX src/font5x7.png)
set(ASSETS_CG src/font8x9.png)
cmake: declare assets through the fxSDK utility
2021-01-27 20:48:59 +01:00
fxconv_declare_assets(${ASSETS_FX} ${ASSETS_CG})
switch build system to CMake This factors the burden of compiler specification in the fxSDK while providing substantially more support through CMake modules.
2021-01-25 15:31:20 +01:00
kprint: add floating-point formatting based in Grisu2b 59,56
2021-02-02 22:18:15 +01:00
include_directories(
"${PROJECT_SOURCE_DIR}/include"
"${PROJECT_BINARY_DIR}/include"
"${FXSDK_COMPILER_INSTALL}/include/openlibm")
kernel: driver and world system overhaul Changes in the driver and world system: * Rewrite driver logic to include more advanced concepts. The notion of binding a driver to a device is introduced to formalize wait(); power management is now built-in instead of being handled by the drivers (for instance DMA). The new driver model is described in great detail in <gint/drivers.h> * Formalized the concept of "world switch" where the hardware state is saved and later restored. As a tool, the world switch turns out to be very stable, and allows a lot of hardware manipulation that would be edgy at best when running in the OS world. * Added a GINT_DRV_SHARED flag for drivers to specify that their state is shared between worlds and not saved/restored. This has a couple of uses. * Exposed a lot more of the internal driver/world system as their is no particular downside to it. This includes stuff in <gint/drivers.h> and the driver's state structures in <gint/drivers/states.h>. This is useful for debugging and for cracked concepts, but there is no API stability guarantee. * Added a more flexible driver level system that allows any 2-digit level to be used. Feature changes: * Added a CPU driver that provides the VBR change as its state save. Because the whole context switch relied on interrupts being disabled anyway, there is no longer an inversion of control when setting the VBR; this is just part of the CPU driver's configuration. The CPU driver may also support other features such as XYRAM block transfer in the future. * Moved gint_inthandler() to the INTC driver under the name intc_handler(), pairing up again with intc_priority(). * Added a reentrant atomic lock based on the test-and-set primitive. Interrupts are disabled with IMASK=15 for the duration of atomic operations. * Enabled the DMA driver on SH7305-based fx-9860G. The DMA provides little benefit on this platform because the RAM is generally faster and buffers are ultimately small. The DMA is still not available on SH3-based fx-9860G models. * Solved an extremely obnoxious bug in timer_spin_wait() where the timer is not freed, causing the callback to be called when interrupts are re-enabled. This increments a random value on the stack. As a consequence of the change, removed the long delays in the USB driver since they are not actually needed. Minor changes: * Deprecated some of the elements in <gint/hardware.h>. There really is no good way to "enumerate" devices yet. * Deprecated gint_switch() in favor of a new function gint_world_switch() which uses the GINT_CALL abstraction. * Made the fx-9860G VRAM 32-aligned so that it can be used for tests with the DMA. Some features of the driver and world systems have not been implemented yet, but may be in the future: * Some driver flags should be per-world in order to create multiple gint worlds. This would be useful in Yatis' hypervisor. * A GINT_DRV_LAZY flag would be useful for drivers that don't want to be started up automatically during a world switch. This is relevant for drivers that have a slow start/stop sequence. However, this is tricky to do correctly as it requires dynamic start/stop and also tracking which world the current hardware state belongs to.
2021-04-23 18:50:20 +02:00
add_compile_options(-Wall -Wextra -std=c11 -Os -fstrict-volatile-bitfields -mtas)
switch build system to CMake This factors the burden of compiler specification in the fxSDK while providing substantially more support through CMake modules.
2021-01-25 15:31:20 +01:00
kprint: add floating-point formatting based in Grisu2b 59,56
2021-02-02 22:18:15 +01:00
# Silence extended warnings on Grisu2b code
set_source_files_properties(src/3rdparty/grisu2b_59_56/grisu2b_59_56.c PROPERTIES
COMPILE_OPTIONS "-Wno-all;-Wno-extra")
switch build system to CMake This factors the burden of compiler specification in the fxSDK while providing substantially more support through CMake modules.
2021-01-25 15:31:20 +01:00
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")
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")
endif()
set_target_properties("${NAME}" PROPERTIES OUTPUT_NAME "${NAME}")
cmake: install FindGint.cmake (previously in the fxSDK)
2021-01-27 08:57:23 +01:00
# Library file
switch build system to CMake This factors the burden of compiler specification in the fxSDK while providing substantially more support through CMake modules.
2021-01-25 15:31:20 +01:00
install(TARGETS "${NAME}" DESTINATION "${FXSDK_COMPILER_INSTALL}")
cmake: install FindGint.cmake (previously in the fxSDK)
2021-01-27 08:57:23 +01:00
# Linker script
switch build system to CMake This factors the burden of compiler specification in the fxSDK while providing substantially more support through CMake modules.
2021-01-25 15:31:20 +01:00
install(FILES "${CMAKE_CURRENT_SOURCE_DIR}/${LINKER_SCRIPT}"
DESTINATION "${FXSDK_COMPILER_INSTALL}")
cmake: install FindGint.cmake (previously in the fxSDK)
2021-01-27 08:57:23 +01:00
# Headers
switch build system to CMake This factors the burden of compiler specification in the fxSDK while providing substantially more support through CMake modules.
2021-01-25 15:31:20 +01:00
install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/include"
DESTINATION "${FXSDK_COMPILER_INSTALL}"
FILES_MATCHING PATTERN "*.h")
cmake: install FindGint.cmake (previously in the fxSDK)
2021-01-27 08:57:23 +01:00
# Auto-generated config header
switch build system to CMake This factors the burden of compiler specification in the fxSDK while providing substantially more support through CMake modules.
2021-01-25 15:31:20 +01:00
install(FILES "${CMAKE_CURRENT_BINARY_DIR}/include/gint/config.h"
DESTINATION "${FXSDK_COMPILER_INSTALL}/include/gint")
cmake: install FindGint.cmake (previously in the fxSDK)
2021-01-27 08:57:23 +01:00
# CMake module to find gint
install(FILES cmake/FindGint.cmake DESTINATION "${FXSDK_CMAKE_MODULE_PATH}")