mirror of
https://github.com/wiiu-env/wut.git
synced 2024-12-13 15:02:35 +01:00
Merge pull request #73 from QuarkTheAwesome/doc-decaf
COS Docs: Pull stuff in from Decaf
This commit is contained in:
James
GitHub
commit
c2df6eab3b
@ -18,12 +18,50 @@ typedef enum OSMemoryType
|
||||
OS_MEM2 = 2,
|
||||
} OSMemoryType;
|
||||
|
||||
/**
|
||||
* Moves chunks of memory around, similarly to memmove. Overlapping source and
|
||||
* destination regions are supported.
|
||||
*
|
||||
* \param dst
|
||||
* The destination address for the move.
|
||||
*
|
||||
* \param src
|
||||
* The source address for the move.
|
||||
*
|
||||
* \param size
|
||||
* The size of the data to be moved, in bytes.
|
||||
*
|
||||
* \param flush
|
||||
* Whether to flush the data caches for the source and destination.
|
||||
*
|
||||
* \return
|
||||
* dst is returned.
|
||||
*
|
||||
* \note
|
||||
* This function makes use of the cache to speed up the copy, so a flush is
|
||||
* recommended.
|
||||
*/
|
||||
void *
|
||||
OSBlockMove(void *dst,
|
||||
const void *src,
|
||||
uint32_t size,
|
||||
BOOL flush);
|
||||
|
||||
/**
|
||||
* Fills a chunk of memory with the given value, like memset.
|
||||
*
|
||||
* \param dst
|
||||
* Pointer to the memory to fill.
|
||||
*
|
||||
* \param val
|
||||
* Byte value to be set.
|
||||
*
|
||||
* \param size
|
||||
* Number of bytes to be set to val.
|
||||
*
|
||||
* \return
|
||||
* dst is returned.
|
||||
*/
|
||||
void *
|
||||
OSBlockSet(void *dst,
|
||||
uint8_t val,
|
||||
@ -36,14 +74,58 @@ OSAllocFromSystem(uint32_t size,
|
||||
void
|
||||
OSFreeToSystem(void *ptr);
|
||||
|
||||
/**
|
||||
* Gets the location and size of the foreground bucket memory area.
|
||||
*
|
||||
* \note
|
||||
* This function may not account for the system reserved portion of the
|
||||
* foreground bucket. Consider using OSGetForegroundBucketFreeArea() instead.
|
||||
*
|
||||
* \param outAddr
|
||||
* Pointer to write the foreground bucket's address to.
|
||||
*
|
||||
* \param outSize
|
||||
* Pointer to write the foreground bucket's size to.
|
||||
*
|
||||
* \return
|
||||
* \c true on success.
|
||||
*/
|
||||
BOOL
|
||||
OSGetForegroundBucket(uint32_t *outAddr,
|
||||
uint32_t *outSize);
|
||||
|
||||
/**
|
||||
* Gets the location and size of the application-usable portion of the
|
||||
* foreground bucket area.
|
||||
*
|
||||
* \param outAddr
|
||||
* Pointer to write the bucket area's address to.
|
||||
*
|
||||
* \param outSize
|
||||
* Pointer to write the bucket area's size to.
|
||||
*
|
||||
* \return
|
||||
* \c true on success.
|
||||
*/
|
||||
BOOL
|
||||
OSGetForegroundBucketFreeArea(uint32_t *outAddr,
|
||||
uint32_t *outSize);
|
||||
|
||||
/**
|
||||
* Gets the location and size of available memory areas.
|
||||
*
|
||||
* \param type
|
||||
* Type of memory to get information about. See #OSMemoryType.
|
||||
*
|
||||
* \param outAddr
|
||||
* Pointer to write the area's address to.
|
||||
*
|
||||
* \param outSize
|
||||
* Pointer to write the area's size to.
|
||||
*
|
||||
* \return
|
||||
* 0 on success, -1 otherwise.
|
||||
*/
|
||||
int
|
||||
OSGetMemBound(OSMemoryType type,
|
||||
uint32_t *outAddr,
|
||||
|
||||
@ -26,36 +26,153 @@ typedef enum OSMemoryMapMode
|
||||
uint32_t
|
||||
OSEffectiveToPhysical(uint32_t virtualAddress);
|
||||
|
||||
/**
|
||||
* Allocates virtual address range for later mapping.
|
||||
*
|
||||
* \param virtualAddress
|
||||
* Requested start address for the range. If there is no preference, NULL can be
|
||||
* used.
|
||||
*
|
||||
* \param size
|
||||
* Size of address range to allocate.
|
||||
*
|
||||
* \param align
|
||||
* Alignment of address range to allocate.
|
||||
*
|
||||
* \return
|
||||
* The starting address of the newly allocated range, or NULL on failure.
|
||||
*
|
||||
* \sa
|
||||
* - OSFreeVirtAddr()
|
||||
* - OSMapMemory()
|
||||
*/
|
||||
uint32_t
|
||||
OSAllocVirtAddr(uint32_t virtualAddress,
|
||||
uint32_t size,
|
||||
uint32_t align);
|
||||
|
||||
/**
|
||||
* Frees a previously allocated virtual address range back to the system.
|
||||
*
|
||||
* \param virtualAddress
|
||||
* The start of the virtual address range to free.
|
||||
*
|
||||
* \param size
|
||||
* The size of the virtual address range to free.
|
||||
*
|
||||
* \return
|
||||
* \c true on success.
|
||||
*/
|
||||
BOOL
|
||||
OSFreeVirtAddr(uint32_t virtualAddress,
|
||||
uint32_t size);
|
||||
|
||||
/**
|
||||
* Determines the status of the given virtual memory address - mapped read-write
|
||||
* or read-only, free, allocated or invalid.
|
||||
*
|
||||
* \param virtualAddress
|
||||
* The virtual address to query.
|
||||
*
|
||||
* \return
|
||||
* The status of the memory address - see #OSMemoryMapMode.
|
||||
*/
|
||||
OSMemoryMapMode
|
||||
OSQueryVirtAddr(uint32_t virtualAddress);
|
||||
|
||||
/**
|
||||
* Maps a physical address to a virtual address, with a given size and set of
|
||||
* permissions.
|
||||
*
|
||||
* \param virtualAddress
|
||||
* The target virtual address for the mapping.
|
||||
*
|
||||
* \param physicalAddress
|
||||
* Physical address of the memory to back the mapping.
|
||||
*
|
||||
* \param size
|
||||
* Size, in bytes, of the desired mapping. Likely has an alignment requirement.
|
||||
*
|
||||
* \param mode
|
||||
* Permissions to map the memory with - see #OSMemoryMapMode.
|
||||
*
|
||||
* \return
|
||||
* \c true on success.
|
||||
*
|
||||
* \sa
|
||||
* - OSAllocVirtAddr()
|
||||
* - OSUnmapMemory()
|
||||
*/
|
||||
BOOL
|
||||
OSMapMemory(uint32_t virtualAddress,
|
||||
uint32_t physicalAddress,
|
||||
uint32_t size,
|
||||
OSMemoryMapMode mode);
|
||||
|
||||
/**
|
||||
* Unmaps previously mapped memory.
|
||||
*
|
||||
* \param virtualAddress
|
||||
* Starting address of the area to unmap.
|
||||
*
|
||||
* \param size
|
||||
* Size of the memory area to unmap.
|
||||
*
|
||||
* \return
|
||||
* \c true on success.
|
||||
*/
|
||||
BOOL
|
||||
OSUnmapMemory(uint32_t virtualAddress,
|
||||
uint32_t size);
|
||||
|
||||
/**
|
||||
* Gets the range of virtual addresses available for mapping.
|
||||
*
|
||||
* \param outVirtualAddress
|
||||
* Pointer to write the starting address of the memory area to.
|
||||
*
|
||||
* \param outSize
|
||||
* Pointer to write the size of the memory area to.
|
||||
*
|
||||
* \sa
|
||||
* - OSMapMemory()
|
||||
*/
|
||||
void
|
||||
OSGetMapVirtAddrRange(uint32_t *outVirtualAddress,
|
||||
uint32_t *outSize);
|
||||
|
||||
/**
|
||||
* Gets the range of available physical memory (not reserved for app code or
|
||||
* data).
|
||||
*
|
||||
* \param outPhysicalAddress
|
||||
* Pointer to write the starting physical address of the memory area to.
|
||||
*
|
||||
* \param outSize
|
||||
* Pointer to write the size of the memory area to.
|
||||
*
|
||||
* \if false
|
||||
* Is memory returned by this function actually safe to map and use? couldn't
|
||||
* get a straight answer from decaf-emu's kernel_memory.cpp...
|
||||
* \endif
|
||||
*/
|
||||
void
|
||||
OSGetAvailPhysAddrRange(uint32_t *outPhysicalAddress,
|
||||
uint32_t *outSize);
|
||||
|
||||
/**
|
||||
* Gets the range of physical memory used for the application's data.
|
||||
*
|
||||
* \param outPhysicalAddress
|
||||
* Pointer to write the starting physical address of the memory area to.
|
||||
*
|
||||
* \param outSize
|
||||
* Pointer to write the size of the memory area to.
|
||||
*
|
||||
* \if false
|
||||
* does this include the main heap?
|
||||
* \endif
|
||||
*/
|
||||
void
|
||||
OSGetDataPhysAddrRange(uint32_t *outPhysicalAddress,
|
||||
uint32_t *outSize);
|
||||
|
||||
@ -11,8 +11,19 @@
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/**
|
||||
* Called when the application needs to save.
|
||||
*/
|
||||
typedef void (*ProcUISaveCallback)(void);
|
||||
/**
|
||||
* Called when the application needs to save.
|
||||
* void* argument is provided in ProcUIInitEx().
|
||||
*/
|
||||
typedef uint32_t (*ProcUISaveCallbackEx)(void *);
|
||||
/**
|
||||
* Generic ProcUI callback.
|
||||
* void* argument is provided in ProcUIRegisterCallback().
|
||||
*/
|
||||
typedef uint32_t (*ProcUICallback)(void *);
|
||||
|
||||
typedef enum ProcUICallbackType
|
||||
@ -48,9 +59,33 @@ ProcUIInForeground();
|
||||
BOOL
|
||||
ProcUIInShutdown();
|
||||
|
||||
/**
|
||||
* Initialises the ProcUI library for use.
|
||||
*
|
||||
* \param saveCallback
|
||||
* A callback to be called when the application needs to save. The callback
|
||||
* cannot be NULL and it must call OSSavesDone_ReadyToRelease().
|
||||
*
|
||||
* \sa
|
||||
* - OSSavesDone_ReadyToRelease()
|
||||
*/
|
||||
void
|
||||
ProcUIInit(ProcUISaveCallback saveCallback);
|
||||
|
||||
/**
|
||||
* Initialises the ProcUI library for use; using a save callback that takes
|
||||
* arguments.
|
||||
*
|
||||
* \param saveCallback
|
||||
* A callback to be called when the application needs to save. The callback
|
||||
* cannot be NULL and it must call OSSavesDone_ReadyToRelease().
|
||||
*
|
||||
* \param arg
|
||||
* An argument to pass into saveCallbackEx.
|
||||
*
|
||||
* \sa
|
||||
* - OSSavesDone_ReadyToRelease()
|
||||
*/
|
||||
void
|
||||
ProcUIInitEx(ProcUISaveCallbackEx saveCallback,
|
||||
void *arg);
|
||||
@ -58,9 +93,53 @@ ProcUIInitEx(ProcUISaveCallbackEx saveCallback,
|
||||
BOOL
|
||||
ProcUIIsRunning();
|
||||
|
||||
/**
|
||||
* Main runloop for ProcUI. This function processes messages from the OS and
|
||||
* provides it an opportinity to take control (to open the HOME menu overlay,
|
||||
* for example). Returns the current state of the application.
|
||||
*
|
||||
* \param block
|
||||
* Determines whether the function should block before returning. If \c false,
|
||||
* the function returns immediately.
|
||||
*
|
||||
* \return
|
||||
* The current state of the program. See #ProcUIStatus.
|
||||
*
|
||||
* \warning
|
||||
* At this time, using ProcUI's non-blocking mode is not recommended as not much
|
||||
* is known about it. Instead, set block to \c true and examine the return
|
||||
* value.
|
||||
*
|
||||
* \note
|
||||
* This function should only be called from the main core. See OSIsMainCore().
|
||||
*
|
||||
* \if false
|
||||
* meta: what happens when block=false? is the return value trustworthy? how
|
||||
* does it interact with ProcUIRegisterCallback?
|
||||
* \endif
|
||||
*/
|
||||
ProcUIStatus
|
||||
ProcUIProcessMessages(BOOL block);
|
||||
|
||||
/**
|
||||
* Register a callback for certain ProcUI events.
|
||||
*
|
||||
* \param type
|
||||
* The event to register a callback for. See #ProcUICallbackType.
|
||||
*
|
||||
* \param callback
|
||||
* Function pointer for the callback to call when the given event occurs.
|
||||
*
|
||||
* \param param
|
||||
* Argument for the callback. This will be passed in as the *second* argument.
|
||||
*
|
||||
* \param priority
|
||||
* The priority of the callback.
|
||||
*
|
||||
* \if false
|
||||
* higher-priority callbacks exec first? dunno
|
||||
* \endif
|
||||
*/
|
||||
void
|
||||
ProcUIRegisterCallback(ProcUICallbackType type,
|
||||
ProcUICallback callback,
|
||||
@ -81,6 +160,23 @@ ProcUISetSaveCallback(ProcUISaveCallbackEx saveCallback,
|
||||
void
|
||||
ProcUIShutdown();
|
||||
|
||||
/**
|
||||
* ProcUIProcessMessages(), but for secondary cores.
|
||||
*
|
||||
* \param block
|
||||
* Determines whether the function should block before returning. If \c false,
|
||||
* the function returns immediately.
|
||||
*
|
||||
* \warning
|
||||
* At this time, using ProcUI's non-blocking mode is not recommended as not much
|
||||
* is known about it. Instead, set block to \c true and examine the return
|
||||
* value.
|
||||
*
|
||||
* \if false
|
||||
* didn't know what this did, only seen it in the else{} from OSIsMainCore...
|
||||
* please research and correct!
|
||||
* \endif
|
||||
*/
|
||||
ProcUIStatus
|
||||
ProcUISubProcessMessages(BOOL block);
|
||||
|
||||
|
||||
@ -69,8 +69,11 @@ typedef enum VPADTouchPadValidity
|
||||
|
||||
typedef enum VPADReadError
|
||||
{
|
||||
//! No error occured, and data was written to the buffers.
|
||||
VPAD_READ_SUCCESS = 0,
|
||||
//! There was no sample new data available to write.
|
||||
VPAD_READ_NO_SAMPLES = -1,
|
||||
//! The requested controller or channel was invalid.
|
||||
VPAD_READ_INVALID_CONTROLLER = -2,
|
||||
} VPADReadError;
|
||||
|
||||
@ -108,13 +111,15 @@ WUT_CHECK_SIZE(VPADDirection, 0x24);
|
||||
|
||||
struct VPADTouchData
|
||||
{
|
||||
//! The x-coordinate of a touched point.
|
||||
uint16_t x;
|
||||
//! The y-coordinate of a touched point.
|
||||
uint16_t y;
|
||||
|
||||
//! 0 if screen is not currently being touched
|
||||
uint16_t touched;
|
||||
|
||||
//! Bitfield of VPADTouchPadValidity to indicate how touch sample accuracy
|
||||
//! Bitfield of #VPADTouchPadValidity to indicate how touch sample accuracy
|
||||
uint16_t validity;
|
||||
};
|
||||
WUT_CHECK_OFFSET(VPADTouchData, 0x00, x);
|
||||
@ -219,19 +224,69 @@ WUT_CHECK_OFFSET(VPADStatus, 0xA2, micStatus);
|
||||
WUT_CHECK_OFFSET(VPADStatus, 0xA3, slideVolumeEx);
|
||||
WUT_CHECK_SIZE(VPADStatus, 0xAC);
|
||||
|
||||
//! Deprecated
|
||||
/**
|
||||
* Initialises the VPAD library for use.
|
||||
*
|
||||
* \deprecated
|
||||
* As of Cafe OS 5.5.x (OSv10 v15702) this function simply logs a deprecation
|
||||
* message and returns. However, this may not be the case on older versions.
|
||||
*/
|
||||
void
|
||||
VPADInit();
|
||||
|
||||
void
|
||||
VPADShutdown();
|
||||
|
||||
/**
|
||||
* Read controller data from the desired Gamepad.
|
||||
*
|
||||
* \note
|
||||
* Retail Wii U systems have a single Gamepad on \link VPADChan::VPAD_CHAN_0 VPAD_CHAN_0. \endlink
|
||||
*
|
||||
* \param chan
|
||||
* The channel to read from.
|
||||
*
|
||||
* \param buffers
|
||||
* Pointer to an array of VPADStatus buffers to fill.
|
||||
*
|
||||
* \param count
|
||||
* Number of buffers to fill.
|
||||
*
|
||||
* \param outError
|
||||
* Pointer to write read error to (if any). See #VPADReadError for meanings.
|
||||
*
|
||||
* \return
|
||||
* 0 on success or 1 on failure. Check error for reason.
|
||||
*
|
||||
* \sa
|
||||
* - VPADStatus
|
||||
*/
|
||||
int32_t
|
||||
VPADRead(VPADChan chan,
|
||||
VPADStatus *buffers,
|
||||
uint32_t count,
|
||||
VPADReadError *outError);
|
||||
|
||||
/**
|
||||
* Transform touch data according to the current calibration data.
|
||||
* The calibration used may either be the system default or set by the
|
||||
* application via VPADSetTPCalibrationParam().
|
||||
*
|
||||
* \note
|
||||
* Retail Wii U systems have a single Gamepad on \link VPADChan::VPAD_CHAN_0 VPAD_CHAN_0. \endlink
|
||||
*
|
||||
* \param chan
|
||||
* Denotes which channel to get the calibration data from.
|
||||
*
|
||||
* \param calibratedData
|
||||
* Pointer to write calibrated touch data to.
|
||||
*
|
||||
* \param uncalibratedData
|
||||
* Pointer to the source data to apply the calibration to.
|
||||
*
|
||||
* \sa
|
||||
* - VPADTouchData
|
||||
*/
|
||||
void
|
||||
VPADGetTPCalibratedPoint(VPADChan chan,
|
||||
VPADTouchData *calibratedData,
|
||||
@ -391,11 +446,43 @@ VPADInitGyroAccReviseParam(VPADChan chan);
|
||||
void
|
||||
VPADInitGyroZeroDriftMode(VPADChan chan);
|
||||
|
||||
/**
|
||||
* Turns on the rumble motor on the desired Gamepad.
|
||||
* A custom rumble pattern can be set by setting bytes in the input buffer.
|
||||
*
|
||||
* \note
|
||||
* Retail Wii U systems have a single Gamepad on \link VPADChan::VPAD_CHAN_0 VPAD_CHAN_0. \endlink
|
||||
*
|
||||
* \param chan
|
||||
* The channel of the Gamepad to rumble.
|
||||
*
|
||||
* \param pattern
|
||||
* Pointer to an array of bytes, where each byte represents the status of the
|
||||
* rumble at a given time. 0xFF denotes rumble while 0x00 denotes no rumble.
|
||||
*
|
||||
* \param length
|
||||
* The size of the rumble pattern, in bytes.
|
||||
*
|
||||
* \if false
|
||||
* meta: find out if the bytes in buffer are an analog intensity control (e.g
|
||||
* is 0x7F "half intensity"?) or are simply binary motor on/off toggles
|
||||
* \endif
|
||||
*/
|
||||
int32_t
|
||||
VPADControlMotor(VPADChan chan,
|
||||
uint8_t *pattern,
|
||||
uint8_t length);
|
||||
|
||||
/**
|
||||
* Stops the desired Gamepad's rumble motor and cancels any ongoing rumble
|
||||
* pattern.
|
||||
*
|
||||
* \note
|
||||
* Retail Wii U systems have a single Gamepad on \link VPADChan::VPAD_CHAN_0 VPAD_CHAN_0. \endlink
|
||||
*
|
||||
* \param chan
|
||||
* The channel of the Gamepad to stop rumbling.
|
||||
*/
|
||||
void
|
||||
VPADStopMotor(VPADChan chan);
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user