redoste
/
gint
forked from Lephenixnoir/gint
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
481 Commits 5 Branches 24 Tags 2.1 MiB
Commit Graph

37 Commits

Author SHA1 Message Date
Lephe b5f0f08183
usb: use optimized DSP loop for read from module 2023-03-26 20:40:48 +02:00
Lephe 1423f40a96
usb: disable USB_LOG_TR() when no log is configured 
For some reason this has a *massive* impact on read performance, like
78 ms -> 20 ms on a full-screen read (177 kB) on the CG-50.
 2023-03-26 20:40:08 +02:00
Lephe 3a2a194693
usb: unaligned reading (release candidate on features) 
The only thing left on the bucket list is performance.
 2023-03-26 11:36:40 +02:00
Lephe 4983849510
usb: consolidate reading logic again, now beta-worthy 
This looks like it could work in the long term. The only issue that
really hasn't been addressed is how to use packet counters to cut
transactions when there's no ZLP, but we can leave that for later.
 2023-03-18 19:51:57 +01:00
Lephe fc1f510288
usb: consolidate reading mode (basic multi-segment reads now working) 2023-03-12 17:53:44 +01:00
Lephe c59b2f90fb
usb: prototype reading mode 
Currently only tested with short messages using the fxlink interface.
There is much to be expanded upon, but this is a worthy start.
 2023-03-04 18:06:38 +01:00
Lephe eb1f9a35a1
usb: use negative values for error codes 
This will allow usb_read_sync() to return a combined error code / size
read integer.
 2023-03-04 18:06:38 +01:00
Lephe f4e13afa84
usb: fix a missing PIPESEL access 
This resulted in a random PIPECFG access.
 2023-03-04 10:59:06 +01:00
Lephe 911691461f
usb: clarify functions used to access endpoint configuration 
The previous scheme was really unclear. Now, an endpoint_t carries all
of the endpoint info (instead of the global address being implicitly
its array index, which couldn't be returned).

An _endpoint address_ is the 8-bit value consisting of an endpoint
number (bits 0x0f) and a direction (bit 0x80).

The _global address_ of an endpoint is the address used to communicate
with the host, and it is unique. The _local address_ of an endpoint is
the interface-specific numbering that gint provides to allow interfaces
to compose without risks of address collisions.

The complete data for an endpoint can be queried with the new functions
usb_get_endpoint_by_*() which accept global addresses, local addresses,
and pipe numbers.
 2023-03-04 10:58:07 +01:00
Lephe aee67a76f3
usb: clear pipes/FIFOs during world switches, delay configuration 
* Clear pipes and FIFOs during world switches to avoid interference
  with the OS. LINK uses pipes 3 and 4, and attempts to add a second
  pipe to the fxlink interface (thus using pipe 4) would interfere with
  LINK and somehow prevent the pipe from being used (Wireshark captures
  showed no responses on that pipe). Forcing a blank state is a valid
  move because that state occurs naturally after a RESET, thus LINK and
  other add-ins must support it as well.

* Delay the application of configuration to the USB configuration stage
  (specifically, the DVST configured interrupt, even though technically
  we should do that in SET_CONFIGURATION 0). This is because we
  previously relied on world switches preserving pipe settings (by not
  changing them) to reconnect the gint driver after a world switch.
  This is no longer possible as the world switch now clears the pipes.
  The new timing makes the driver automatically re-configure as the
  connection restarts.
 2023-02-18 17:15:28 +01:00
Lephe c0671649df
usb: prevent double opening 
This could happen in gintctl's USB tracer and obviously cause all sorts
of problems.
 2023-02-18 16:48:28 +01:00
Lephe 53c67af52d
usb: fix wrong interface numbering (+ comments) 
This worked previously because the only interface (number 0) had its
interface descriptor in first position (position 0).
 2023-02-18 16:47:49 +01:00
Lephe 6910714c2c
asyncio: remove unused field asyncio_op_t.flying_w 2023-02-16 16:09:53 +01:00
Lephe af5c16a3d3
usb: massively improve writing logic 
* Move logic around tracking transfers to asyncio.c.

* Add a "short buffer" holding 0-3 bytes between writes, so that the
  driver performs only 4-byte writes in the FIFO and a short write in
  the commit, if needed.
  - This is partially due to me thinking at some point that degrading
    writing size was impossible, but it might actually be possible by
    writing to FIFO/FIFO+2 or FIFO/FIFO+1/FIFO+2/FIFO+3.
  - In any case I think this new approach wins on performance.

* Get rid of unit_size since we now always use 4 bytes.

* Add a waiting function which is used in usb_close() (and once tested
  should be used in world switches too).

* Eliminate some of the special cases for the DCP, though not all (in
  particular I can't get the commit to rely on the BEMP interrupt yet,
  nor can I properly clear PID to NAK when unbinding).
 2023-02-09 23:00:44 +01:00
Lephe a091efc894
usb: replace struct transfer with a more generic async. I/O op structure (WIP) 
This lays the ground for both generalization to reading and sharing
that logic with the serial driver.
 2023-01-31 16:04:35 +01:00
Lephe 6f758cd36c
defs: allow NULL callbacks in gint_call() 2023-01-31 16:04:35 +01:00
Lephe 18e0db3886
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-31 16:04:35 +01:00
Lephe cf2b86deaa
usb: update module details with register analysis experiments 
Unknown writable bits and host-only registers were found.
 2023-01-28 13:10:03 +01:00
Lephe 42853103aa
usb: remove incorrectly-ordered bits in USB registers 2023-01-25 16:28:20 +01:00
Lephe a4cf3516e7
usb: fix some messages being lost after a post-world-switch reconnect 2022-12-03 11:05:35 +01:00
Lephe 177879d432
usb: add a USB_TRACE() debugging mechanism 2022-12-03 11:04:43 +01:00
Lephe feb74a38ec
usb: hide USB_LOG() behind a compile-time debug option 2022-11-29 20:03:03 +01:00
Lephe 5e35871c98
usb: add timeout variants for functions 
We're not using them yet (specifically in fxlink) because timeouts
leave the pipes in undesirable states that currently end up crashing.
Some reset mechanism is needed, plus support from the protocol for
canceling messages, etc.
 2022-11-13 08:56:59 +01:00
Lephe 5f9553f3b8
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:51:00 +01:00
Lephe d110ab608e
usb: fix freeze on sync commit for inactive pipes 
Performing an asynchronous commit on an inactive pipe would yield
USB_COMMIT_INACTVE and *not* invoke the callback (as intended),
which usb_commit_sync() ignored, causing a freeze.

This issue appeared after a world switch, which (for reasons not yet
known) appear to fail the first writes until a commit, and that commit
would then hit an inactive pipe.
 2022-11-11 17:47:29 +01:00
Lephe c9df6326e4
reduce static RAM usage to maintain SH3 support 2022-10-09 18:15:12 +02:00
Lephe d3a2cf07a0
usb: add video capture through the fxlink protocol 2021-08-11 01:43:26 +02:00
Lephe 8e730c2f78
replace gint/std headers with standard ones 2021-06-08 11:01:27 +02:00
Lephe 31dcc6fd6c
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-12 09:17:25 +02:00
Lephe a547235f8f
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-12 09:17:25 +02:00
Lephe 392d033e4a
usb: improve and expose the sync/async write API 
* Properly define the callback time of a write/commit as the time when
  the pipe is available again for further writing.
* Refuse commits when writes are pending; instead, enforce a strict
  order of finishing writes before committing, which makes sense since
  consecutive writes are ordered this way already.
* Properly support callbacks for writes and for commits.
* Define the synchronous APIs in terms of waiting until the callbacks
  for equivalent asynchronous functions are invoked (plus initial
  waiting for pipes to be ready).
 2021-05-12 09:17:24 +02:00
Lephe 42081c9968
intc: allow any call in intc_handler_function() 2021-05-12 09:17:24 +02:00
Lephe 50cbcd4ac1
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
Lephe c37f150600
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
Lephe c9264a06d5
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 20:44:08 +02:00
Lephe 770b4e0117
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 17:51:53 +02:00
Lephe 1315c26099
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