mirror of
https://git.planet-casio.com/Lephenixnoir/gint.git
synced 2025-04-04 09:37:10 +02:00
c9264a06d5
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.
109 lines
3.7 KiB
C
109 lines
3.7 KiB
C
//---
|
|
// gint:dma - Direct Memory Access for efficient data transfer
|
|
//---
|
|
|
|
#ifndef GINT_DMA
|
|
#define GINT_DMA
|
|
|
|
#include <gint/defs/types.h>
|
|
|
|
/* dma_size_t - Transfer block size */
|
|
typedef enum
|
|
{
|
|
/* Normal transfers of 1, 2, 4, 8, 16 or 32 bytes at a time */
|
|
DMA_1B = 0,
|
|
DMA_2B = 1,
|
|
DMA_4B = 2,
|
|
DMA_8B = 7,
|
|
DMA_16B = 3,
|
|
DMA_32B = 4,
|
|
|
|
/* Transfers of 16 or 32 bytes divided in two operations */
|
|
DMA_16B_DIV = 11,
|
|
DMA_32B_DIV = 12,
|
|
|
|
} dma_size_t;
|
|
|
|
/* dma_address_t - Addressing mode for source and destination regions */
|
|
typedef enum
|
|
{
|
|
/* Fixed address mode: the same address is read/written at each step */
|
|
DMA_FIXED = 0,
|
|
/* Increment: address is incremented by transfer size at each step */
|
|
DMA_INC = 1,
|
|
/* Decrement: only allowed for 1/2/4-byte transfers */
|
|
DMA_DEC = 2,
|
|
/* Fixed division mode: address is fixed even in 16/32-divide mode */
|
|
DMA_FIXEDDIV = 3,
|
|
|
|
} dma_address_t;
|
|
|
|
/* dma_transfer() - Start a data transfer on channel 0
|
|
This function returns just when the transfer starts. The transfer will end
|
|
later on and the DMA will be stopped by an interrupt. Call
|
|
dma_transfer_wait() if you need to wait for the transfer to finish. Don't
|
|
start a new transfer until the current one is finished!
|
|
|
|
@channel DMA channel (0..5)
|
|
@size Transfer size
|
|
@blocks Number of blocks (transferred memory = size * blocks)
|
|
@src Source pointer, must be aligned with transfer size
|
|
@src_mode Source address mode
|
|
@dst Destination address, must be aligned with transfer size
|
|
@dst_mode Destination address mode */
|
|
void dma_transfer(int channel, dma_size_t size, uint length,
|
|
void const *src, dma_address_t src_mode,
|
|
void *dst, dma_address_t dst_mode);
|
|
|
|
/* dma_transfer_wait() - Wait for a transfer to finish
|
|
|
|
You should call this function when you need to transfer to be complete
|
|
before continuing execution. If you are sure that the transfer is finished,
|
|
this is not necessary (the only way to know is to look at the DMA registers
|
|
or record interrupts).
|
|
|
|
@channel DMA channel (0..5) */
|
|
void dma_transfer_wait(int channel);
|
|
|
|
/* dma_transfer_noint() - Perform a data transfer without interrupts
|
|
This function performs a transfer much like dma_transfer(), but doesn't use
|
|
interrupts and *actively waits* for the transfer to finish, returning when
|
|
it's finished. Don't call dma_transfer_wait() after using this function.
|
|
|
|
Not using interrupts is a bad design idea for a majority of programs, and is
|
|
only ever needed to display panic messages inside exception handlers. */
|
|
void dma_transfer_noint(int channel, dma_size_t size, uint blocks,
|
|
void const *src, dma_address_t src_mode,
|
|
void *dst, dma_address_t dst_mode);
|
|
|
|
//---
|
|
// DMA-based memory manipulation functions
|
|
//---
|
|
|
|
/* dma_memset(): Fast 32-aligned memset
|
|
|
|
This function is your typical memset(), except that the destination and size
|
|
must be 32-aligned, and that the pattern is 4 bytes instead of one. It is
|
|
replicated to 32 bytes then used to fill the destination area. This 4-byte
|
|
fixed size may be lifted in future versions.
|
|
|
|
This function cannot be used with virtualized (P0) addresses.
|
|
|
|
@dst Destination address (32-aligned)
|
|
@pattern 4-byte pattern to fill @dst
|
|
@size Sie of destination area (32-aligned) */
|
|
void *dma_memset(void *dst, uint32_t pattern, size_t size);
|
|
|
|
/* dma_memcpy(): Fast 32-aligned memcpy
|
|
|
|
This function works exactly like memcpy(), but it expects 32-aligned source,
|
|
destination, and size, and uses the DMA to efficiently copy.
|
|
|
|
This function cannot be used with virtualized (P0) addresses.
|
|
|
|
@dst Destination address (32-aligned)
|
|
@dst Source addresss (32-aligned)
|
|
@size Size of region (32-aligned) */
|
|
void *dma_memcpy(void * restrict dst, const void * restrict src, size_t size);
|
|
|
|
#endif /* GINT_DMA */
|