Lephenixnoir
/
gint
10
14
Fork 8
Code Issues 4 Pull Requests Releases Wiki Activity
gint/src/usb/usb.c

370 lines
8.7 KiB
C
Raw Normal View History

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
#include <gint/usb.h>
#include <gint/mpu/usb.h>
#include <gint/mpu/power.h>
#include <gint/mpu/cpg.h>
usb: improve driver with updated knowledge and prepare reading * Finish updating the register list * Use RTC-based timeouts to not involve more interrupts * Be a lot more conservative about PID=BUF * Start setting up parameters and checking invariants for future bidirectional communications
2023-01-29 19:37:19 +01:00
#include <gint/mpu/pfc.h>
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
#include <gint/drivers.h>
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
#include <gint/drivers/states.h>
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
#include <gint/clock.h>
#include <gint/intc.h>
usb: add a USB_TRACE() debugging mechanism
2022-12-03 11:04:43 +01:00
#include <gint/cpu.h>
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
#include "usb_private.h"
#define USB SH7305_USB
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
static void usb_interrupt_handler(void);
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
/* Shorthand to clear a bit in INTSTS0 */
#define INTSTS0_clear(field_name) { \
__typeof__(USB.INTSTS0) __intsts0 = { .word = 0xffff }; \
__intsts0.field_name = 0; \
do USB.INTSTS0 = __intsts0; \
while(USB.INTSTS0.field_name != 0); \
}
/* Callback function to invoke when the USB module is configured */
/* TODO: usb_open() callback: Let interfaces specify when they're ready! */
gint: rename the callbacks GINT_CALL, as there are synchronous ones This will be useful for world switch calls which are not "callbacks" but simply polymorphic function pointers.
2021-04-20 13:52:18 +02:00
static gint_call_t usb_open_callback = GINT_CALL_NULL;
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
/* Whether the USB link is currently open */
static bool volatile usb_open_status = false;
//---
usb: add a USB_TRACE() debugging mechanism
2022-12-03 11:04:43 +01:00
// Debugging functions
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
//---
static void (*usb_logger)(char const *format, va_list args) = NULL;
usb: add a USB_TRACE() debugging mechanism
2022-12-03 11:04:43 +01:00
static void (*usb_tracer)(char const *message) = NULL;
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
void usb_set_log(void (*logger)(char const *format, va_list args))
{
usb_logger = logger;
}
void usb_log(char const *format, ...)
{
if(!usb_logger) return;
va_list args;
va_start(args, format);
usb_logger(format, args);
va_end(args);
}
usb: add a USB_TRACE() debugging mechanism
2022-12-03 11:04:43 +01:00
void usb_set_trace(void (*tracer)(char const *message))
{
usb_tracer = tracer;
}
void usb_trace(char const *message)
{
if(usb_tracer) {
cpu_atomic_start();
usb_tracer(message);
cpu_atomic_end();
}
}
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
//---
// Module powering and depowering
//---
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
static bool hpowered(void)
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
{
return (SH7305_CPG.USBCLKCR.CLKSTP == 0) &&
(SH7305_POWER.MSTPCR2.USB0 == 0);
}
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
static void hpoweron(void)
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
{
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
if(hpowered()) return;
usb: improve driver with updated knowledge and prepare reading * Finish updating the register list * Use RTC-based timeouts to not involve more interrupts * Be a lot more conservative about PID=BUF * Start setting up parameters and checking invariants for future bidirectional communications
2023-01-29 19:37:19 +01:00
SH7305_PFC.MSELCRA.UNKNOWN_USB = 0;
SH7305_PFC.MSELCRB.XTAL_USB = 0;
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
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
/* Leave some delay for the clock to settle. The OS leaves
100 ms, but it just never seems necessary. */
SH7305_CPG.USBCLKCR.CLKSTP = 0;
sleep_us_spin(1000);
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
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
SH7305_POWER.MSTPCR2.USB0 = 0;
SH7305_USB_UPONCR.word = 0x0600;
usb: fix module not being restored after usb_close() usb_close() would unpower the module and gint_world_switch_out() assumed it was powered, so the context switch would fail.
2021-04-27 14:45:12 +02:00
}
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
usb: fix module not being restored after usb_close() usb_close() would unpower the module and gint_world_switch_out() assumed it was powered, so the context switch would fail.
2021-04-27 14:45:12 +02:00
/* Finish the poweron procedure by enabling writes in the registers */
static void hpoweron_write(void)
{
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
/* Turn on SCKE, which activates all other registers. The existing
BUSWAIT delay might not be high enough, so wait a little bit before
modifying registers; a couple CPU cycles is enough. */
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
USB.SYSCFG.SCKE = 1;
for(int i = 0; i < 10; i++) __asm__ volatile("nop");
usb: enable writing with DMA Nothing particular to change, simply make sure that the DMA channels have higher priority than the USB module, otherwise the BEMP interrupt might be executed before the DMA frees the channel, resulting in the transfer failing because the channel is still busy. Also reduce BUSWAIT since it works even on high overclock levels, and keeping it high won't help increase performance.
2021-05-07 17:41:36 +02:00
/* Set BUSWAIT to a safe value */
USB.BUSWAIT.word = 5;
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
}
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
static void hpoweroff(void)
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
{
SH7305_USB_UPONCR.word = 0x0000;
/* This delay is crucial and omitting it has caused constant freezes in
the past. Blame undocumented clock magic? */
sleep_us_spin(1000);
SH7305_POWER.MSTPCR2.USB0 = 1;
SH7305_CPG.USBCLKCR.CLKSTP = 1;
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
sleep_us_spin(1000);
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
/* The values used by the OS (a PFC driver could do better) */
usb: improve driver with updated knowledge and prepare reading * Finish updating the register list * Use RTC-based timeouts to not involve more interrupts * Be a lot more conservative about PID=BUF * Start setting up parameters and checking invariants for future bidirectional communications
2023-01-29 19:37:19 +01:00
SH7305_PFC.MSELCRB.XTAL_USB = 3;
SH7305_PFC.MSELCRA.UNKNOWN_USB = 1;
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
}
gint: rename the callbacks GINT_CALL, as there are synchronous ones This will be useful for world switch calls which are not "callbacks" but simply polymorphic function pointers.
2021-04-20 13:52:18 +02:00
int usb_open(usb_interface_t const **interfaces, gint_call_t callback)
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
{
usb: improve driver with updated knowledge and prepare reading * Finish updating the register list * Use RTC-based timeouts to not involve more interrupts * Be a lot more conservative about PID=BUF * Start setting up parameters and checking invariants for future bidirectional communications
2023-01-29 19:37:19 +01:00
/* TODO: Check whether the calculator can host devices (probably no) */
bool host = false;
usb: hide USB_LOG() behind a compile-time debug option
2022-11-29 20:03:03 +01:00
USB_LOG("---- usb_open ----\n");
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
int rc = usb_configure_solve(interfaces);
usb_configure_log();
if(rc != 0)
{
usb: hide USB_LOG() behind a compile-time debug option
2022-11-29 20:03:03 +01:00
USB_LOG("configure failure: %d\n", rc);
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
return rc;
}
usb_open_callback = callback;
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
if(!hpowered()) hpoweron();
usb: fix module not being restored after usb_close() usb_close() would unpower the module and gint_world_switch_out() assumed it was powered, so the context switch would fail.
2021-04-27 14:45:12 +02:00
hpoweron_write();
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
usb: update module details with register analysis experiments Unknown writable bits and host-only registers were found.
2023-01-28 13:09:15 +01:00
USB.REG_C2 = 0x0020;
usb: improve driver with updated knowledge and prepare reading * Finish updating the register list * Use RTC-based timeouts to not involve more interrupts * Be a lot more conservative about PID=BUF * Start setting up parameters and checking invariants for future bidirectional communications
2023-01-29 19:37:19 +01:00
/* Disconnect (DPRPU=0) if we were previously connected as a function. Also
drive down DRPR, since both are required for setting DCFM. */
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
USB.SYSCFG.DPRPU = 0;
usb: improve driver with updated knowledge and prepare reading * Finish updating the register list * Use RTC-based timeouts to not involve more interrupts * Be a lot more conservative about PID=BUF * Start setting up parameters and checking invariants for future bidirectional communications
2023-01-29 19:37:19 +01:00
USB.SYSCFG.DRPD = 0;
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
usb: improve driver with updated knowledge and prepare reading * Finish updating the register list * Use RTC-based timeouts to not involve more interrupts * Be a lot more conservative about PID=BUF * Start setting up parameters and checking invariants for future bidirectional communications
2023-01-29 19:37:19 +01:00
if(host) {
/* Select the host controller */
USB.SYSCFG.DCFM = 1;
/* Clear registers to prepare for host operation */
USB.SYSCFG.USBE = 0;
/* Do not require high-speed operation; also accept full-speed */
USB.SYSCFG.HSE = 0;
/* Pull DPRD and eliminate chattering */
USB.SYSCFG.DRPD = 1;
GUNUSED volatile int LNST = USB.SYSSTS.LNST;
/* Enable the module */
USB.SYSCFG.USBE = 1;
}
else {
/* Select the function controller */
USB.SYSCFG.DCFM = 0;
/* Clear registers to prepare for function operation */
USB.SYSCFG.USBE = 0;
/* Use high-speed only */
USB.SYSCFG.HSE = 1;
/* Enable the module */
USB.SYSCFG.USBE = 1;
}
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
/* Prepare the default control pipe. */
USB.DCPCFG.DIR = 0;
USB.DCPMAXP.DEVSEL = 0;
USB.DCPMAXP.MXPS = 64;
USB.SOFCFG.enable = 1;
/* Configure CFIFOSEL to use the DCP */
USB.CFIFOSEL.RCNT = 0;
USB.CFIFOSEL.REW = 0;
USB.CFIFOSEL.BIGEND = 1;
/* Clear D0FIFOSEL and D1FIFOSEL so that pipes can be configured */
USB.D0FIFOSEL.word = 0x0000;
USB.D1FIFOSEL.word = 0x0000;
/* Configure other pipes to use activated interfaces */
usb_configure();
usb: fix some messages being lost after a post-world-switch reconnect
2022-12-03 11:05:35 +01:00
usb_configure_clear_pipes();
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
/* Initialize transfer tracker for multi-part transfers */
usb_pipe_init_transfers();
/* VBSE=1 RSME=0 SOFE=0 DVSE=1 CTRE=1 BEMPE=1 NRDYE=0 BRDYE=0 */
USB.INTENB0.word = 0x9c00;
usb: remove incorrectly-ordered bits in USB registers
2023-01-20 13:47:43 +01:00
USB.BRDYENB = 0x0000;
USB.NRDYENB = 0x0000;
USB.BEMPENB = 0x0000;
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
intc: allow any call in intc_handler_function()
2021-04-28 17:37:40 +02:00
intc_handler_function(0xa20, GINT_CALL(usb_interrupt_handler));
usb: enable writing with DMA Nothing particular to change, simply make sure that the DMA channels have higher priority than the USB module, otherwise the BEMP interrupt might be executed before the DMA frees the channel, resulting in the transfer failing because the channel is still busy. Also reduce BUSWAIT since it works even on high overclock levels, and keeping it high won't help increase performance.
2021-05-07 17:41:36 +02:00
intc_priority(INTC_USB, 8);
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
usb: improve driver with updated knowledge and prepare reading * Finish updating the register list * Use RTC-based timeouts to not involve more interrupts * Be a lot more conservative about PID=BUF * Start setting up parameters and checking invariants for future bidirectional communications
2023-01-29 19:37:19 +01:00
/* Pull D+ up to 3.3V, notifying connection when possible. Read
SYSSTS.LNST as required after modifying DPRPU */
USB.SYSCFG.DPRPU = 1;
GUNUSED volatile int LNST = USB.SYSSTS.LNST;
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
return 0;
}
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
bool usb_is_open(void)
{
return usb_open_status;
}
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
void usb_open_wait(void)
{
while(!usb_open_status) sleep();
}
void usb_close(void)
{
intc_priority(INTC_USB, 0);
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
hpoweroff();
usb: hide USB_LOG() behind a compile-time debug option
2022-11-29 20:03:03 +01:00
USB_LOG("---- usb_close ----\n");
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
gint: rename the callbacks GINT_CALL, as there are synchronous ones This will be useful for world switch calls which are not "callbacks" but simply polymorphic function pointers.
2021-04-20 13:52:18 +02:00
usb_open_callback = GINT_CALL_NULL;
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
usb_open_status = false;
}
//---
// Userspace interrupt handler
//---
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
static void usb_interrupt_handler(void)
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
{
usb: hide USB_LOG() behind a compile-time debug option
2022-11-29 20:03:03 +01:00
GUNUSED static char const * const device_st[] = {
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
"powered", "default", "address", "configured",
"suspended-powered", "suspended-default", "suspended-address",
"suspended-configured",
};
/* Save PIPESEL to avoid concurrent access issues */
uint16_t pipesel = USB.PIPESEL.word;
if(USB.INTSTS0.VBINT)
{
INTSTS0_clear(VBINT);
usb: hide USB_LOG() behind a compile-time debug option
2022-11-29 20:03:03 +01:00
USB_LOG("VBUS %s\n", USB.INTSTS0.VBSTS ? "up" : "down");
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
}
else if(USB.INTSTS0.CTRT)
{
INTSTS0_clear(CTRT);
if(USB.INTSTS0.VALID) usb_req_setup();
}
else if(USB.INTSTS0.DVST)
{
INTSTS0_clear(DVST);
usb: hide USB_LOG() behind a compile-time debug option
2022-11-29 20:03:03 +01:00
USB_LOG("DVST %s", device_st[USB.INTSTS0.DVSQ]);
if(USB.INTSTS0.DVSQ == 2) USB_LOG(": %04x\n",USB.USBADDR.word);
else USB_LOG("\n");
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
/* When configured, run the callback for usb_open() */
if(USB.INTSTS0.DVSQ == 3)
{
usb: fix some messages being lost after a post-world-switch reconnect
2022-12-03 11:05:35 +01:00
usb_configure_clear_pipes();
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
usb_open_status = true;
if(usb_open_callback.function)
{
gint: rename the callbacks GINT_CALL, as there are synchronous ones This will be useful for world switch calls which are not "callbacks" but simply polymorphic function pointers.
2021-04-20 13:52:18 +02:00
gint_call(usb_open_callback);
usb_open_callback = GINT_CALL_NULL;
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
}
}
}
else if(USB.INTSTS0.BEMP)
{
/* Invoke callbacks for each buffer-empty interrupt */
usb: remove incorrectly-ordered bits in USB registers
2023-01-20 13:47:43 +01:00
uint16_t status = USB.BEMPSTS;
USB.BEMPSTS = 0;
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
for(int i = 1; i <= 9; i++)
{
if(status & (1 << i)) usb_pipe_write_bemp(i);
}
}
usb: hide USB_LOG() behind a compile-time debug option
2022-11-29 20:03:03 +01:00
else USB_LOG("<%04X> -> ???\n", USB.INTSTS0.word);
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
/* Restore PIPESEL which can have been used for transfers */
USB.PIPESEL.word = pipesel;
}
//---
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
// State and driver metadata
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
//---
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
void hsave(usb_state_t *s)
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
{
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
s->SYSCFG = USB.SYSCFG.word;
s->DVSTCTR = USB.DVSTCTR.word;
s->TESTMODE = USB.TESTMODE.word;
s->REG_C2 = USB.REG_C2;
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
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
s->CFIFOSEL = USB.CFIFOSEL.word;
s->D0FIFOSEL = USB.D0FIFOSEL.word;
s->D1FIFOSEL = USB.D1FIFOSEL.word;
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
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
s->INTENB0 = USB.INTENB0.word;
usb: remove incorrectly-ordered bits in USB registers
2023-01-20 13:47:43 +01:00
s->BRDYENB = USB.BRDYENB;
s->NRDYENB = USB.NRDYENB;
s->BEMPENB = USB.BEMPENB;
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
s->SOFCFG = USB.SOFCFG.word;
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
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
s->DCPCFG = USB.DCPCFG.word;
s->DCPMAXP = USB.DCPMAXP.word;
s->DCPCTR = USB.DCPCTR.word;
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
/* Leave the module open for gint to use it, or for the next restore
to proceed more quickly (if during a world switch) */
}
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
static void hrestore(usb_state_t const *s)
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
{
usb: fix module not being restored after usb_close() usb_close() would unpower the module and gint_world_switch_out() assumed it was powered, so the context switch would fail.
2021-04-27 14:45:12 +02:00
hpoweron_write();
usb: fix transmissions resuming early after world switch When the driver goes through a world switch a reconnection with the host is needed before operations can resume. This requires usb_open_status to be reset. Also: bind a FIFO before a commit that involves data transfer, mirroring what happens in writes. This ensures that PID is set to BUF, mainly.
2022-11-12 14:49:12 +01:00
/* We will need to reconnect with the PC */
usb_open_status = false;
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
USB.DVSTCTR.word = s->DVSTCTR;
USB.TESTMODE.word = s->TESTMODE;
USB.REG_C2 = s->REG_C2;
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
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
USB.CFIFOSEL.word = s->CFIFOSEL;
USB.D0FIFOSEL.word = s->D0FIFOSEL;
USB.D1FIFOSEL.word = s->D1FIFOSEL;
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
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
USB.INTENB0.word = s->INTENB0;
usb: remove incorrectly-ordered bits in USB registers
2023-01-20 13:47:43 +01:00
USB.BRDYENB = s->BRDYENB;
USB.NRDYENB = s->NRDYENB;
USB.BEMPENB = s->BEMPENB;
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
USB.SOFCFG.word = s->SOFCFG;
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
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
USB.DCPCFG.word = s->DCPCFG;
USB.DCPMAXP.word = s->DCPMAXP;
USB.DCPCTR.word = s->DCPCTR;
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
/* Clear remaining interrupts. Read-only bits will be ignored */
USB.INTSTS0.word = 0;
usb: remove incorrectly-ordered bits in USB registers
2023-01-20 13:47:43 +01:00
USB.BRDYSTS = 0;
USB.NRDYSTS = 0;
USB.BEMPSTS = 0;
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
/* Restore SYSCFG last as clearing SCKE disables writing */
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
USB.SYSCFG.word = s->SYSCFG;
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
}
gint_driver_t drv_usb = {
.name = "USB",
usb: improve driver with updated knowledge and prepare reading * Finish updating the register list * Use RTC-based timeouts to not involve more interrupts * Be a lot more conservative about PID=BUF * Start setting up parameters and checking invariants for future bidirectional communications
2023-01-29 19:37:19 +01:00
/* TODO: usb: Wait for remaining transfers in unbind() */
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
.hpowered = hpowered,
.hpoweron = hpoweron,
.hpoweroff = hpoweroff,
.hsave = (void *)hsave,
.hrestore = (void *)hrestore,
.state_size = sizeof(usb_state_t),
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
};
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
GINT_DECLARE_DRIVER(16, drv_usb);