@patleeman/pi-boy 0.1.0

package/mgba-bridge/vendor/mgba/include/mgba/internal/gba/cart/ereader.h

@@ -0,0 +1,127 @@
+/* Copyright (c) 2013-2015 Jeffrey Pfau
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+#ifndef GBA_EREADER_H
+#define GBA_EREADER_H
+
+#include <mgba-util/common.h>
+
+CXX_GUARD_START
+
+#include <mgba-util/vector.h>
+
+struct GBACartridgeHardware;
+
+#define EREADER_DOTCODE_STRIDE 1420
+#define EREADER_DOTCODE_SIZE (EREADER_DOTCODE_STRIDE * 40)
+#define EREADER_CARDS_MAX 16
+
+DECL_BITFIELD(EReaderControl0, uint8_t);
+DECL_BIT(EReaderControl0, Data, 0);
+DECL_BIT(EReaderControl0, Clock, 1);
+DECL_BIT(EReaderControl0, Direction, 2);
+DECL_BIT(EReaderControl0, LedEnable, 3);
+DECL_BIT(EReaderControl0, Scan, 4);
+DECL_BIT(EReaderControl0, Phi, 5);
+DECL_BIT(EReaderControl0, PowerEnable, 6);
+DECL_BITFIELD(EReaderControl1, uint8_t);
+DECL_BIT(EReaderControl1, Scanline, 1);
+DECL_BIT(EReaderControl1, Unk1, 4);
+DECL_BIT(EReaderControl1, Voltage, 5);
+
+enum EReaderStateMachine {
+	EREADER_SERIAL_INACTIVE = 0,
+	EREADER_SERIAL_STARTING,
+	EREADER_SERIAL_BIT_0,
+	EREADER_SERIAL_BIT_1,
+	EREADER_SERIAL_BIT_2,
+	EREADER_SERIAL_BIT_3,
+	EREADER_SERIAL_BIT_4,
+	EREADER_SERIAL_BIT_5,
+	EREADER_SERIAL_BIT_6,
+	EREADER_SERIAL_BIT_7,
+	EREADER_SERIAL_END_BIT,
+};
+
+enum EReaderCommand {
+	EREADER_COMMAND_IDLE = 0, // TODO: Verify on hardware
+	EREADER_COMMAND_WRITE_DATA = 1,
+	EREADER_COMMAND_SET_INDEX = 0x22,
+	EREADER_COMMAND_READ_DATA = 0x23,
+};
+
+struct EReaderCard {
+	void* data;
+	size_t size;
+};
+
+struct GBA;
+struct GBACartEReader {
+	struct GBA* p;
+	uint16_t data[44];
+	uint8_t serial[92];
+	uint16_t registerUnk;
+	uint16_t registerReset;
+	EReaderControl0 registerControl0;
+	EReaderControl1 registerControl1;
+	uint16_t registerLed;
+
+	// TODO: Serialize these
+	enum EReaderStateMachine state;
+	enum EReaderCommand command;
+	uint8_t activeRegister;
+	uint8_t byte;
+	int scanX;
+	int scanY;
+	uint8_t* dots;
+	struct EReaderCard cards[EREADER_CARDS_MAX];
+};
+
+struct EReaderAnchor;
+struct EReaderBlock;
+DECLARE_VECTOR(EReaderAnchorList, struct EReaderAnchor);
+DECLARE_VECTOR(EReaderBlockList, struct EReaderBlock);
+
+struct EReaderScan {
+	uint8_t* buffer;
+	unsigned width;
+	unsigned height;
+
+	uint8_t* srcBuffer;
+	size_t srcWidth;
+	size_t srcHeight;
+
+	unsigned scale;
+
+	uint8_t min;
+	uint8_t max;
+	uint8_t mean;
+	uint8_t anchorThreshold;
+
+	struct EReaderAnchorList anchors;
+	struct EReaderBlockList blocks;
+};
+
+void GBACartEReaderInit(struct GBACartEReader* ereader);
+void GBACartEReaderDeinit(struct GBACartEReader* ereader);
+void GBACartEReaderWrite(struct GBACartEReader* ereader, uint32_t address, uint16_t value);
+void GBACartEReaderWriteFlash(struct GBACartEReader* ereader, uint32_t address, uint8_t value);
+uint16_t GBACartEReaderRead(struct GBACartEReader* ereader, uint32_t address);
+uint8_t GBACartEReaderReadFlash(struct GBACartEReader* ereader, uint32_t address);
+void GBACartEReaderScan(struct GBACartEReader* ereader, const void* data, size_t size);
+
+struct EReaderScan* EReaderScanCreate(unsigned width, unsigned height);
+void EReaderScanDetectParams(struct EReaderScan*);
+void EReaderScanDetectAnchors(struct EReaderScan*);
+void EReaderScanFilterAnchors(struct EReaderScan*);
+void EReaderScanConnectAnchors(struct EReaderScan*);
+void EReaderScanCreateBlocks(struct EReaderScan*);
+void EReaderScanDetectBlockThreshold(struct EReaderScan*, int block);
+bool EReaderScanRecalibrateBlock(struct EReaderScan*, int block);
+bool EReaderScanScanBlock(struct EReaderScan*, int block, bool strict);
+
+CXX_GUARD_END
+
+#endif

package/mgba-bridge/vendor/mgba/include/mgba/internal/gba/cart/gpio.h

@@ -0,0 +1,110 @@
+/* Copyright (c) 2013-2015 Jeffrey Pfau
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+#ifndef GBA_HARDWARE_H
+#define GBA_HARDWARE_H
+
+#include <mgba-util/common.h>
+
+CXX_GUARD_START
+
+#include <mgba/core/log.h>
+#include <mgba/core/timing.h>
+#include <mgba/gba/interface.h>
+
+mLOG_DECLARE_CATEGORY(GBA_HW);
+
+#define IS_GPIO_REGISTER(reg) ((reg) == GPIO_REG_DATA || (reg) == GPIO_REG_DIRECTION || (reg) == GPIO_REG_CONTROL)
+
+enum GPIORegister {
+	GPIO_REG_DATA = 0xC4,
+	GPIO_REG_DIRECTION = 0xC6,
+	GPIO_REG_CONTROL = 0xC8
+};
+
+enum GPIODirection {
+	GPIO_WRITE_ONLY = 0,
+	GPIO_READ_WRITE = 1
+};
+
+DECL_BITFIELD(RTCControl, uint8_t);
+DECL_BIT(RTCControl, MinIRQ, 3);
+DECL_BIT(RTCControl, Hour24, 6);
+DECL_BIT(RTCControl, Poweroff, 7);
+
+enum RTCCommand {
+	RTC_RESET = 0,
+	RTC_DATETIME = 2,
+	RTC_FORCE_IRQ = 3,
+	RTC_CONTROL = 4,
+	RTC_TIME = 6
+};
+
+DECL_BITFIELD(RTCCommandData, uint32_t);
+DECL_BITS(RTCCommandData, Magic, 0, 4);
+DECL_BITS(RTCCommandData, Command, 4, 3);
+DECL_BIT(RTCCommandData, Reading, 7);
+
+struct GBARTC {
+	int32_t bytesRemaining;
+	int32_t bitsRead;
+	int32_t bits;
+	int32_t commandActive;
+	bool sckEdge;
+	bool sioOutput;
+	RTCCommandData command;
+	RTCControl control;
+	uint8_t time[7];
+	time_t lastLatch;
+	time_t offset;
+};
+
+DECL_BITFIELD(GPIOPin, uint16_t);
+
+struct GBACartridgeHardware {
+	struct GBA* p;
+	uint32_t devices;
+	enum GPIODirection readWrite;
+	uint16_t* gpioBase;
+
+	uint8_t writeLatch;
+	uint8_t pinState;
+	uint8_t direction;
+
+	struct GBARTC rtc;
+
+	uint16_t gyroSample;
+	bool gyroEdge;
+
+	unsigned lightCounter : 12;
+	uint8_t lightSample;
+	bool lightEdge;
+
+	uint16_t tiltX;
+	uint16_t tiltY;
+	int tiltState;
+};
+
+void GBAHardwareInit(struct GBACartridgeHardware* gpio, uint16_t* gpioBase);
+void GBAHardwareReset(struct GBACartridgeHardware* gpio);
+void GBAHardwareClear(struct GBACartridgeHardware* gpio);
+
+void GBAHardwareInitRTC(struct GBACartridgeHardware* gpio);
+void GBAHardwareInitGyro(struct GBACartridgeHardware* gpio);
+void GBAHardwareInitRumble(struct GBACartridgeHardware* gpio);
+void GBAHardwareInitLight(struct GBACartridgeHardware* gpio);
+void GBAHardwareInitTilt(struct GBACartridgeHardware* gpio);
+
+void GBAHardwareGPIOWrite(struct GBACartridgeHardware* gpio, uint32_t address, uint16_t value);
+void GBAHardwareTiltWrite(struct GBACartridgeHardware* gpio, uint32_t address, uint8_t value);
+uint8_t GBAHardwareTiltRead(struct GBACartridgeHardware* gpio, uint32_t address);
+
+struct GBASerializedState;
+void GBAHardwareSerialize(const struct GBACartridgeHardware* gpio, struct GBASerializedState* state);
+void GBAHardwareDeserialize(struct GBACartridgeHardware* gpio, const struct GBASerializedState* state);
+
+CXX_GUARD_END
+
+#endif

package/mgba-bridge/vendor/mgba/include/mgba/internal/gba/cart/matrix.h

@@ -0,0 +1,35 @@
+/* Copyright (c) 2013-2018 Jeffrey Pfau
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+#ifndef GBA_MATRIX_H
+#define GBA_MATRIX_H
+
+#include <mgba-util/common.h>
+
+CXX_GUARD_START
+
+#define GBA_MATRIX_MAPPINGS_MAX 16
+
+struct GBAMatrix {
+	uint32_t cmd;
+	uint32_t paddr;
+	uint32_t vaddr;
+	uint32_t size;
+
+	uint32_t mappings[GBA_MATRIX_MAPPINGS_MAX];
+};
+
+struct GBA;
+void GBAMatrixReset(struct GBA*);
+void GBAMatrixWrite(struct GBA*, uint32_t address, uint32_t value);
+void GBAMatrixWrite16(struct GBA*, uint32_t address, uint16_t value);
+
+struct GBASerializedState;
+void GBAMatrixSerialize(const struct GBA* memory, struct GBASerializedState* state);
+void GBAMatrixDeserialize(struct GBA* memory, const struct GBASerializedState* state);
+
+CXX_GUARD_END
+
+#endif

package/mgba-bridge/vendor/mgba/include/mgba/internal/gba/cart/unlicensed.h

@@ -0,0 +1,77 @@
+/* Copyright (c) 2013-2024 Jeffrey Pfau
+ * Copyright (c) 2016 taizou
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+#ifndef GBA_UNLICENSED_H
+#define GBA_UNLICENSED_H
+
+#include <mgba-util/common.h>
+
+CXX_GUARD_START
+
+#include <mgba/core/timing.h>
+
+enum GBAVFameCartType {
+	VFAME_STANDARD = 0,
+	VFAME_GEORGE = 1,
+	VFAME_ALTERNATE = 2,
+};
+
+enum GBAUnlCartType {
+	GBA_UNL_CART_NONE = 0,
+	GBA_UNL_CART_VFAME = 1,
+	GBA_UNL_CART_MULTICART = 2,
+};
+
+struct GBAVFameCart {
+	enum GBAVFameCartType cartType;
+	int sramMode;
+	int romMode;
+	int8_t writeSequence[5];
+	bool acceptingModeChange;
+};
+
+struct GBAMulticart {
+	struct mTimingEvent settle;
+	uint32_t* rom;
+	size_t fullSize;
+
+	uint8_t bank;
+	uint8_t offset;
+	uint8_t size;
+	bool sramActive;
+	bool locked;
+	uint8_t unk;
+};
+
+struct GBAUnlCart {
+	enum GBAUnlCartType type;
+	union {
+		struct GBAVFameCart vfame;
+		struct GBAMulticart multi;
+	};
+};
+
+struct GBA;
+struct GBAMemory;
+void GBAUnlCartInit(struct GBA*);
+void GBAUnlCartReset(struct GBA*);
+void GBAUnlCartUnload(struct GBA*);
+void GBAUnlCartDetect(struct GBA*);
+void GBAUnlCartWriteSRAM(struct GBA*, uint32_t address, uint8_t value);
+void GBAUnlCartWriteROM(struct GBA*, uint32_t address, uint16_t value);
+
+struct GBASerializedState;
+void GBAUnlCartSerialize(const struct GBA* gba, struct GBASerializedState* state);
+void GBAUnlCartDeserialize(struct GBA* gba, const struct GBASerializedState* state);
+
+bool GBAVFameDetect(struct GBAVFameCart* cart, uint32_t* rom, size_t romSize, uint32_t crc32);
+void GBAVFameSramWrite(struct GBAVFameCart* cart, uint32_t address, uint8_t value, uint8_t* sramData);
+uint32_t GBAVFameModifyRomAddress(struct GBAVFameCart* cart, uint32_t address, size_t romSize);
+uint32_t GBAVFameGetPatternValue(uint32_t address, int bits);
+
+CXX_GUARD_END
+
+#endif

package/mgba-bridge/vendor/mgba/include/mgba/internal/gba/cheats.h

@@ -0,0 +1,175 @@
+/* Copyright (c) 2013-2015 Jeffrey Pfau
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+#ifndef GBA_CHEATS_H
+#define GBA_CHEATS_H
+
+#include <mgba-util/common.h>
+
+CXX_GUARD_START
+
+#include <mgba/internal/arm/arm.h>
+#include <mgba/core/cheats.h>
+#include <mgba-util/vector.h>
+
+#define COMPLETE ((size_t) -1)
+
+enum GBACheatType {
+	GBA_CHEAT_AUTODETECT,
+	GBA_CHEAT_CODEBREAKER,
+	GBA_CHEAT_GAMESHARK,
+	GBA_CHEAT_PRO_ACTION_REPLAY,
+	GBA_CHEAT_VBA
+};
+
+enum GBACodeBreakerType {
+	CB_GAME_ID = 0x0,
+	CB_HOOK = 0x1,
+	CB_OR_2 = 0x2,
+	CB_ASSIGN_1 = 0x3,
+	CB_FILL = 0x4,
+	CB_FILL_8 = 0x5,
+	CB_AND_2 = 0x6,
+	CB_IF_EQ = 0x7,
+	CB_ASSIGN_2 = 0x8,
+	CB_ENCRYPT = 0x9,
+	CB_IF_NE = 0xA,
+	CB_IF_GT = 0xB,
+	CB_IF_LT = 0xC,
+	CB_IF_SPECIAL = 0xD,
+	CB_ADD_2 = 0xE,
+	CB_IF_AND = 0xF,
+};
+
+enum GBAGameSharkType {
+	GSA_ASSIGN_1 = 0x0,
+	GSA_ASSIGN_2 = 0x1,
+	GSA_ASSIGN_4 = 0x2,
+	GSA_ASSIGN_LIST = 0x3,
+	GSA_PATCH = 0x6,
+	GSA_BUTTON = 0x8,
+	GSA_IF_EQ = 0xD,
+	GSA_IF_EQ_RANGE = 0xE,
+	GSA_HOOK = 0xF
+};
+
+enum GBAActionReplay3Condition {
+	PAR3_COND_OTHER = 0x00000000,
+	PAR3_COND_EQ = 0x08000000,
+	PAR3_COND_NE = 0x10000000,
+	PAR3_COND_LT = 0x18000000,
+	PAR3_COND_GT = 0x20000000,
+	PAR3_COND_ULT = 0x28000000,
+	PAR3_COND_UGT = 0x30000000,
+	PAR3_COND_AND = 0x38000000,
+};
+
+enum GBAActionReplay3Width {
+	PAR3_WIDTH_1 = 0x00000000,
+	PAR3_WIDTH_2 = 0x02000000,
+	PAR3_WIDTH_4 = 0x04000000,
+	PAR3_WIDTH_FALSE = 0x06000000,
+};
+
+enum GBAActionReplay3Action {
+	PAR3_ACTION_NEXT = 0x00000000,
+	PAR3_ACTION_NEXT_TWO = 0x40000000,
+	PAR3_ACTION_BLOCK = 0x80000000,
+	PAR3_ACTION_DISABLE = 0xC0000000,
+};
+
+enum GBAActionReplay3Base {
+	PAR3_BASE_ASSIGN = 0x00000000,
+	PAR3_BASE_INDIRECT = 0x40000000,
+	PAR3_BASE_ADD = 0x80000000,
+	PAR3_BASE_OTHER = 0xC0000000,
+
+	PAR3_BASE_ASSIGN_1 = 0x00000000,
+	PAR3_BASE_ASSIGN_2 = 0x02000000,
+	PAR3_BASE_ASSIGN_4 = 0x04000000,
+	PAR3_BASE_INDIRECT_1 = 0x40000000,
+	PAR3_BASE_INDIRECT_2 = 0x42000000,
+	PAR3_BASE_INDIRECT_4 = 0x44000000,
+	PAR3_BASE_ADD_1 = 0x80000000,
+	PAR3_BASE_ADD_2 = 0x82000000,
+	PAR3_BASE_ADD_4 = 0x84000000,
+	PAR3_BASE_HOOK = 0xC4000000,
+	PAR3_BASE_IO_2 = 0xC6000000,
+	PAR3_BASE_IO_3 = 0xC7000000,
+};
+
+enum GBAActionReplay3Other {
+	PAR3_OTHER_END = 0x00000000,
+	PAR3_OTHER_SLOWDOWN = 0x08000000,
+	PAR3_OTHER_BUTTON_1 = 0x10000000,
+	PAR3_OTHER_BUTTON_2 = 0x12000000,
+	PAR3_OTHER_BUTTON_4 = 0x14000000,
+	PAR3_OTHER_PATCH_1 = 0x18000000,
+	PAR3_OTHER_PATCH_2 = 0x1A000000,
+	PAR3_OTHER_PATCH_3 = 0x1C000000,
+	PAR3_OTHER_PATCH_4 = 0x1E000000,
+	PAR3_OTHER_ENDIF = 0x40000000,
+	PAR3_OTHER_ELSE = 0x60000000,
+	PAR3_OTHER_FILL_1 = 0x80000000,
+	PAR3_OTHER_FILL_2 = 0x82000000,
+	PAR3_OTHER_FILL_4 = 0x84000000,
+};
+
+enum {
+	PAR3_COND = 0x38000000,
+	PAR3_WIDTH = 0x06000000,
+	PAR3_ACTION = 0xC0000000,
+	PAR3_BASE = 0xC0000000,
+
+	PAR3_WIDTH_BASE = 25
+};
+
+struct GBACheatHook {
+	uint32_t address;
+	enum ExecutionMode mode;
+	uint32_t patchedOpcode;
+	size_t refs;
+	size_t reentries;
+};
+
+DECLARE_VECTOR(GBACheatPatchList, struct GBACheatPatch);
+
+struct GBACheatSet {
+	struct mCheatSet d;
+	struct GBACheatHook* hook;
+
+	size_t incompleteCheat;
+	struct mCheatPatch* incompletePatch;
+	size_t currentBlock;
+
+	int gsaVersion;
+	uint32_t gsaSeeds[4];
+	uint32_t cbRngState;
+	uint32_t cbMaster;
+	uint8_t cbTable[0x30];
+	uint32_t cbSeeds[4];
+	int remainingAddresses;
+};
+
+struct VFile;
+
+struct mCheatDevice* GBACheatDeviceCreate(void);
+
+bool GBACheatAddCodeBreaker(struct GBACheatSet*, uint32_t op1, uint16_t op2);
+bool GBACheatAddCodeBreakerLine(struct GBACheatSet*, const char* line);
+
+bool GBACheatAddGameShark(struct GBACheatSet*, uint32_t op1, uint32_t op2);
+bool GBACheatAddGameSharkLine(struct GBACheatSet*, const char* line);
+
+bool GBACheatAddProActionReplay(struct GBACheatSet*, uint32_t op1, uint32_t op2);
+bool GBACheatAddProActionReplayLine(struct GBACheatSet*, const char* line);
+
+bool GBACheatAddVBALine(struct GBACheatSet*, const char* line);
+
+int GBACheatAddressIsReal(uint32_t address);
+
+CXX_GUARD_END
+
+#endif

package/mgba-bridge/vendor/mgba/include/mgba/internal/gba/debugger/cli.h

@@ -0,0 +1,30 @@
+/* Copyright (c) 2013-2015 Jeffrey Pfau
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+#ifndef GBA_CLI_H
+#define GBA_CLI_H
+
+#include <mgba-util/common.h>
+
+CXX_GUARD_START
+
+#include <mgba/internal/debugger/cli-debugger.h>
+
+struct mCore;
+
+struct GBACLIDebugger {
+	struct CLIDebuggerSystem d;
+
+	struct mCore* core;
+
+	bool frameAdvance;
+	bool inVblank;
+};
+
+struct GBACLIDebugger* GBACLIDebuggerCreate(struct mCore*);
+
+CXX_GUARD_END
+
+#endif

package/mgba-bridge/vendor/mgba/include/mgba/internal/gba/dma.h

@@ -0,0 +1,73 @@
+/* Copyright (c) 2013-2016 Jeffrey Pfau
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+#ifndef GBA_DMA_H
+#define GBA_DMA_H
+
+#include <mgba-util/common.h>
+
+CXX_GUARD_START
+
+#include <mgba/core/log.h>
+
+enum GBADMAControl {
+	GBA_DMA_INCREMENT = 0,
+	GBA_DMA_DECREMENT = 1,
+	GBA_DMA_FIXED = 2,
+	GBA_DMA_INCREMENT_RELOAD = 3
+};
+
+enum GBADMATiming {
+	GBA_DMA_TIMING_NOW = 0,
+	GBA_DMA_TIMING_VBLANK = 1,
+	GBA_DMA_TIMING_HBLANK = 2,
+	GBA_DMA_TIMING_CUSTOM = 3
+};
+
+DECL_BITFIELD(GBADMARegister, uint16_t);
+DECL_BITS(GBADMARegister, DestControl, 5, 2);
+DECL_BITS(GBADMARegister, SrcControl, 7, 2);
+DECL_BIT(GBADMARegister, Repeat, 9);
+DECL_BIT(GBADMARegister, Width, 10);
+DECL_BIT(GBADMARegister, DRQ, 11);
+DECL_BITS(GBADMARegister, Timing, 12, 2);
+DECL_BIT(GBADMARegister, DoIRQ, 14);
+DECL_BIT(GBADMARegister, Enable, 15);
+
+mLOG_DECLARE_CATEGORY(GBA_DMA);
+
+struct GBADMA {
+	GBADMARegister reg;
+
+	uint32_t source;
+	uint32_t dest;
+	int32_t count;
+	uint32_t nextSource;
+	uint32_t nextDest;
+	int32_t nextCount;
+	uint32_t when;
+	int32_t cycles;
+};
+
+struct GBA;
+void GBADMAInit(struct GBA* gba);
+void GBADMAReset(struct GBA* gba);
+
+uint32_t GBADMAWriteSAD(struct GBA* gba, int dma, uint32_t address);
+uint32_t GBADMAWriteDAD(struct GBA* gba, int dma, uint32_t address);
+void GBADMAWriteCNT_LO(struct GBA* gba, int dma, uint16_t count);
+uint16_t GBADMAWriteCNT_HI(struct GBA* gba, int dma, uint16_t control);
+
+struct GBADMA;
+void GBADMASchedule(struct GBA* gba, int number, struct GBADMA* info);
+void GBADMARunHblank(struct GBA* gba, int32_t cycles);
+void GBADMARunVblank(struct GBA* gba, int32_t cycles);
+void GBADMARunDisplayStart(struct GBA* gba, int32_t cycles);
+void GBADMAUpdate(struct GBA* gba);
+void GBADMARecalculateCycles(struct GBA* gba);
+
+CXX_GUARD_END
+
+#endif