From e2bc15192f3f692f331714d7c8bb850c1a8e66c0 Mon Sep 17 00:00:00 2001 From: Vicki Pfau Date: Sun, 23 Feb 2020 13:23:33 -0800 Subject: [PATCH] GBA e-Reader: Split out into separate file --- include/mgba/internal/gba/hardware.h | 3 + src/gba/CMakeLists.txt | 1 + src/gba/ereader.c | 452 +++++++++++++++++++++++++++ src/gba/hardware.c | 444 -------------------------- 4 files changed, 456 insertions(+), 444 deletions(-) create mode 100644 src/gba/ereader.c diff --git a/include/mgba/internal/gba/hardware.h b/include/mgba/internal/gba/hardware.h index 66fe17c08..42467db36 100644 --- a/include/mgba/internal/gba/hardware.h +++ b/include/mgba/internal/gba/hardware.h @@ -16,6 +16,9 @@ CXX_GUARD_START mLOG_DECLARE_CATEGORY(GBA_HW); +#define EREADER_DOTCODE_STRIDE 1200 +#define EREADER_DOTCODE_SIZE (EREADER_DOTCODE_STRIDE * 40 + 200) + #define IS_GPIO_REGISTER(reg) ((reg) == GPIO_REG_DATA || (reg) == GPIO_REG_DIRECTION || (reg) == GPIO_REG_CONTROL) struct GBARTCGenericSource { diff --git a/src/gba/CMakeLists.txt b/src/gba/CMakeLists.txt index 94bb8f09f..5b4a52c0c 100644 --- a/src/gba/CMakeLists.txt +++ b/src/gba/CMakeLists.txt @@ -9,6 +9,7 @@ set(SOURCE_FILES cheats/parv3.c core.c dma.c + ereader.c gba.c hardware.c hle-bios.c diff --git a/src/gba/ereader.c b/src/gba/ereader.c new file mode 100644 index 000000000..5159a7df1 --- /dev/null +++ b/src/gba/ereader.c @@ -0,0 +1,452 @@ + +/* Copyright (c) 2013-2020 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/. */ +#include + +#include +#include +#include + +#define EREADER_BLOCK_SIZE 40 + +static void _eReaderReset(struct GBACartridgeHardware* hw); +static void _eReaderWriteControl0(struct GBACartridgeHardware* hw, uint8_t value); +static void _eReaderWriteControl1(struct GBACartridgeHardware* hw, uint8_t value); +static void _eReaderReadData(struct GBACartridgeHardware* hw); + +const int EREADER_NYBBLE_5BIT[16][5] = { + { 0, 0, 0, 0, 0 }, + { 0, 0, 0, 0, 1 }, + { 0, 0, 0, 1, 0 }, + { 1, 0, 0, 1, 0 }, + { 0, 0, 1, 0, 0 }, + { 0, 0, 1, 0, 1 }, + { 0, 0, 1, 1, 0 }, + { 1, 0, 1, 1, 0 }, + { 0, 1, 0, 0, 0 }, + { 0, 1, 0, 0, 1 }, + { 0, 1, 0, 1, 0 }, + { 1, 0, 1, 0, 0 }, + { 0, 1, 1, 0, 0 }, + { 0, 1, 1, 0, 1 }, + { 1, 0, 0, 0, 1 }, + { 1, 0, 0, 0, 0 } +}; + +const uint8_t EREADER_CALIBRATION_TEMPLATE[] = { + 0x43, 0x61, 0x72, 0x64, 0x2d, 0x45, 0x20, 0x52, 0x65, 0x61, 0x64, 0x65, 0x72, 0x20, 0x32, 0x30, + 0x30, 0x31, 0x00, 0x00, 0xcf, 0x72, 0x2f, 0x37, 0x3a, 0x3a, 0x3a, 0x38, 0x33, 0x30, 0x30, 0x37, + 0x3a, 0x39, 0x37, 0x35, 0x33, 0x2f, 0x2f, 0x34, 0x36, 0x36, 0x37, 0x36, 0x34, 0x31, 0x2d, 0x30, + 0x32, 0x34, 0x35, 0x35, 0x34, 0x30, 0x2a, 0x2d, 0x2d, 0x2f, 0x31, 0x32, 0x31, 0x2f, 0x29, 0x2a, + 0x2c, 0x2b, 0x2c, 0x2e, 0x2e, 0x2d, 0x18, 0x2d, 0x8f, 0x03, 0x00, 0x00, 0xc0, 0xfd, 0x77, 0x00, + 0x00, 0x00, 0x01 +}; + +const uint16_t EREADER_ADDRESS_CODES[] = { + 1023, + 1174, + 2628, + 3373, + 4233, + 6112, + 6450, + 7771, + 8826, + 9491, + 11201, + 11432, + 12556, + 13925, + 14519, + 16350, + 16629, + 18332, + 18766, + 20007, + 21379, + 21738, + 23096, + 23889, + 24944, + 26137, + 26827, + 28578, + 29190, + 30063, + 31677, + 31956, + 33410, + 34283, + 35641, + 35920, + 37364, + 38557, + 38991, + 40742, + 41735, + 42094, + 43708, + 44501, + 45169, + 46872, + 47562, + 48803, + 49544, + 50913, + 51251, + 53082, + 54014, + 54679 +}; + +void GBAHardwareInitEReader(struct GBACartridgeHardware* hw) { + hw->devices |= HW_EREADER; + _eReaderReset(hw); + + if (hw->p->memory.savedata.data[0xD000] == 0xFF) { + memset(&hw->p->memory.savedata.data[0xD000], 0, 0x1000); + memcpy(&hw->p->memory.savedata.data[0xD000], EREADER_CALIBRATION_TEMPLATE, sizeof(EREADER_CALIBRATION_TEMPLATE)); + } + if (hw->p->memory.savedata.data[0xE000] == 0xFF) { + memset(&hw->p->memory.savedata.data[0xE000], 0, 0x1000); + memcpy(&hw->p->memory.savedata.data[0xE000], EREADER_CALIBRATION_TEMPLATE, sizeof(EREADER_CALIBRATION_TEMPLATE)); + } +} + +void GBAHardwareEReaderWrite(struct GBACartridgeHardware* hw, uint32_t address, uint16_t value) { + address &= 0x700FF; + switch (address >> 17) { + case 0: + hw->eReaderRegisterUnk = value & 0xF; + break; + case 1: + hw->eReaderRegisterReset = (value & 0x8A) | 4; + if (value & 2) { + _eReaderReset(hw); + } + break; + case 2: + mLOG(GBA_HW, GAME_ERROR, "e-Reader write to read-only registers: %05X:%04X", address, value); + break; + default: + mLOG(GBA_HW, STUB, "Unimplemented e-Reader write: %05X:%04X", address, value); + } +} + +void GBAHardwareEReaderWriteFlash(struct GBACartridgeHardware* hw, uint32_t address, uint8_t value) { + address &= 0xFFFF; + switch (address) { + case 0xFFB0: + _eReaderWriteControl0(hw, value); + break; + case 0xFFB1: + _eReaderWriteControl1(hw, value); + break; + case 0xFFB2: + hw->eReaderRegisterLed &= 0xFF00; + hw->eReaderRegisterLed |= value; + break; + case 0xFFB3: + hw->eReaderRegisterLed &= 0x00FF; + hw->eReaderRegisterLed |= value << 8; + break; + default: + mLOG(GBA_HW, STUB, "Unimplemented e-Reader write to flash: %04X:%02X", address, value); + } +} + +uint16_t GBAHardwareEReaderRead(struct GBACartridgeHardware* hw, uint32_t address) { + address &= 0x700FF; + uint16_t value; + switch (address >> 17) { + case 0: + return hw->eReaderRegisterUnk; + case 1: + return hw->eReaderRegisterReset; + case 2: + if (address > 0x40088) { + return 0; + } + LOAD_16(value, address & 0xFE, hw->eReaderData); + return value; + } + mLOG(GBA_HW, STUB, "Unimplemented e-Reader read: %05X", address); + return 0; +} + +uint8_t GBAHardwareEReaderReadFlash(struct GBACartridgeHardware* hw, uint32_t address) { + address &= 0xFFFF; + switch (address) { + case 0xFFB0: + return hw->eReaderRegisterControl0; + case 0xFFB1: + return hw->eReaderRegisterControl1; + default: + mLOG(GBA_HW, STUB, "Unimplemented e-Reader read from flash: %04X", address); + return 0; + } +} + +static void _eReaderAnchor(uint8_t* origin) { + origin[EREADER_DOTCODE_STRIDE * 0 + 1] = 1; + origin[EREADER_DOTCODE_STRIDE * 0 + 2] = 1; + origin[EREADER_DOTCODE_STRIDE * 0 + 3] = 1; + origin[EREADER_DOTCODE_STRIDE * 1 + 0] = 1; + origin[EREADER_DOTCODE_STRIDE * 1 + 1] = 1; + origin[EREADER_DOTCODE_STRIDE * 1 + 2] = 1; + origin[EREADER_DOTCODE_STRIDE * 1 + 3] = 1; + origin[EREADER_DOTCODE_STRIDE * 1 + 4] = 1; + origin[EREADER_DOTCODE_STRIDE * 2 + 0] = 1; + origin[EREADER_DOTCODE_STRIDE * 2 + 1] = 1; + origin[EREADER_DOTCODE_STRIDE * 2 + 2] = 1; + origin[EREADER_DOTCODE_STRIDE * 2 + 3] = 1; + origin[EREADER_DOTCODE_STRIDE * 2 + 4] = 1; + origin[EREADER_DOTCODE_STRIDE * 3 + 0] = 1; + origin[EREADER_DOTCODE_STRIDE * 3 + 1] = 1; + origin[EREADER_DOTCODE_STRIDE * 3 + 2] = 1; + origin[EREADER_DOTCODE_STRIDE * 3 + 3] = 1; + origin[EREADER_DOTCODE_STRIDE * 3 + 4] = 1; + origin[EREADER_DOTCODE_STRIDE * 4 + 1] = 1; + origin[EREADER_DOTCODE_STRIDE * 4 + 2] = 1; + origin[EREADER_DOTCODE_STRIDE * 4 + 3] = 1; +} + +static void _eReaderAlignment(uint8_t* origin) { + origin[8] = 1; + origin[10] = 1; + origin[12] = 1; + origin[14] = 1; + origin[16] = 1; + origin[18] = 1; + origin[21] = 1; + origin[23] = 1; + origin[25] = 1; + origin[27] = 1; + origin[29] = 1; + origin[31] = 1; +} + +static void _eReaderAddress(uint8_t* origin, int a) { + origin[EREADER_DOTCODE_STRIDE * 7 + 2] = 1; + uint16_t addr = EREADER_ADDRESS_CODES[a]; + int i; + for (i = 0; i < 16; ++i) { + origin[EREADER_DOTCODE_STRIDE * (16 + i) + 2] = (addr >> (15 - i)) & 1; + } +} + +void GBAHardwareEReaderScan(struct GBACartridgeHardware* hw, const void* data, size_t size) { + if (!hw->eReaderDots) { + hw->eReaderDots = anonymousMemoryMap(EREADER_DOTCODE_SIZE); + } + memset(hw->eReaderDots, 0, EREADER_DOTCODE_SIZE); + + int base; + switch (size) { + case 2912: + base = 25; + break; + case 1872: + base = 1; + break; + default: + return; + } + + size_t i; + for (i = 0; i < (size / 104) + 1; ++i) { + uint8_t* origin = &hw->eReaderDots[35 * i + 200]; + _eReaderAnchor(&origin[EREADER_DOTCODE_STRIDE * 0]); + _eReaderAnchor(&origin[EREADER_DOTCODE_STRIDE * 35]); + _eReaderAddress(origin, base + i); + } + for (i = 0; i < size / 104; ++i) { + uint8_t block[1040]; + uint8_t* origin = &hw->eReaderDots[35 * i + 200]; + _eReaderAlignment(&origin[EREADER_DOTCODE_STRIDE * 2]); + _eReaderAlignment(&origin[EREADER_DOTCODE_STRIDE * 37]); + + int b; + for (b = 0; b < 104; ++b) { + const int* nybble5; + nybble5 = EREADER_NYBBLE_5BIT[((const uint8_t*) data)[i * 104 + b] >> 4]; + block[b * 10 + 0] = nybble5[0]; + block[b * 10 + 1] = nybble5[1]; + block[b * 10 + 2] = nybble5[2]; + block[b * 10 + 3] = nybble5[3]; + block[b * 10 + 4] = nybble5[4]; + nybble5 = EREADER_NYBBLE_5BIT[((const uint8_t*) data)[i * 104 + b] & 0xF]; + block[b * 10 + 5] = nybble5[0]; + block[b * 10 + 6] = nybble5[1]; + block[b * 10 + 7] = nybble5[2]; + block[b * 10 + 8] = nybble5[3]; + block[b * 10 + 9] = nybble5[4]; + } + + b = 0; + int y; + for (y = 0; y < 3; ++y) { + memcpy(&origin[EREADER_DOTCODE_STRIDE * (4 + y) + 7], &block[b], 26); + b += 26; + } + for (y = 0; y < 26; ++y) { + memcpy(&origin[EREADER_DOTCODE_STRIDE * (7 + y) + 3], &block[b], 34); + b += 34; + } + for (y = 0; y < 3; ++y) { + memcpy(&origin[EREADER_DOTCODE_STRIDE * (33 + y) + 7], &block[b], 26); + b += 26; + } + } + hw->eReaderX = -24; +} + +void _eReaderReset(struct GBACartridgeHardware* hw) { + memset(hw->eReaderData, 0, sizeof(hw->eReaderData)); + hw->eReaderRegisterUnk = 0; + hw->eReaderRegisterReset = 4; + hw->eReaderRegisterControl0 = 0; + hw->eReaderRegisterControl1 = 0x80; + hw->eReaderRegisterLed = 0; + hw->eReaderState = 0; + hw->eReaderActiveRegister = 0; +} + +void _eReaderWriteControl0(struct GBACartridgeHardware* hw, uint8_t value) { + EReaderControl0 control = value & 0x7F; + EReaderControl0 oldControl = hw->eReaderRegisterControl0; + if (hw->eReaderState == EREADER_SERIAL_INACTIVE) { + if (EReaderControl0IsClock(oldControl) && EReaderControl0IsData(oldControl) && !EReaderControl0IsData(control)) { + hw->eReaderState = EREADER_SERIAL_STARTING; + } + } else if (EReaderControl0IsClock(oldControl) && !EReaderControl0IsData(oldControl) && EReaderControl0IsData(control)) { + hw->eReaderState = EREADER_SERIAL_INACTIVE; + + } else if (hw->eReaderState == EREADER_SERIAL_STARTING) { + if (EReaderControl0IsClock(oldControl) && !EReaderControl0IsData(oldControl) && !EReaderControl0IsClock(control)) { + hw->eReaderState = EREADER_SERIAL_BIT_0; + hw->eReaderCommand = EREADER_COMMAND_IDLE; + } + } else if (EReaderControl0IsClock(oldControl) && !EReaderControl0IsClock(control)) { + mLOG(GBA_HW, DEBUG, "[e-Reader] Serial falling edge: %c %i", EReaderControl0IsDirection(control) ? '>' : '<', EReaderControl0GetData(control)); + // TODO: Improve direction control + if (EReaderControl0IsDirection(control)) { + hw->eReaderByte |= EReaderControl0GetData(control) << (7 - (hw->eReaderState - EREADER_SERIAL_BIT_0)); + ++hw->eReaderState; + if (hw->eReaderState == EREADER_SERIAL_END_BIT) { + mLOG(GBA_HW, DEBUG, "[e-Reader] Wrote serial byte: %02x", hw->eReaderByte); + switch (hw->eReaderCommand) { + case EREADER_COMMAND_IDLE: + hw->eReaderCommand = hw->eReaderByte; + break; + case EREADER_COMMAND_SET_INDEX: + hw->eReaderActiveRegister = hw->eReaderByte; + hw->eReaderCommand = EREADER_COMMAND_WRITE_DATA; + break; + case EREADER_COMMAND_WRITE_DATA: + switch (hw->eReaderActiveRegister & 0x7F) { + case 0: + case 0x57: + case 0x58: + case 0x59: + case 0x5A: + // Read-only + mLOG(GBA_HW, GAME_ERROR, "Writing to read-only e-Reader serial register: %02X", hw->eReaderActiveRegister); + break; + default: + if ((hw->eReaderActiveRegister & 0x7F) > 0x5A) { + mLOG(GBA_HW, GAME_ERROR, "Writing to non-existent e-Reader serial register: %02X", hw->eReaderActiveRegister); + break; + } + hw->eReaderSerial[hw->eReaderActiveRegister & 0x7F] = hw->eReaderByte; + break; + } + ++hw->eReaderActiveRegister; + break; + default: + mLOG(GBA_HW, ERROR, "Hit undefined state %02X in e-Reader state machine", hw->eReaderCommand); + break; + } + hw->eReaderState = EREADER_SERIAL_BIT_0; + hw->eReaderByte = 0; + } + } else if (hw->eReaderCommand == EREADER_COMMAND_READ_DATA) { + int bit = hw->eReaderSerial[hw->eReaderActiveRegister & 0x7F] >> (7 - (hw->eReaderState - EREADER_SERIAL_BIT_0)); + control = EReaderControl0SetData(control, bit); + ++hw->eReaderState; + if (hw->eReaderState == EREADER_SERIAL_END_BIT) { + ++hw->eReaderActiveRegister; + mLOG(GBA_HW, DEBUG, "[e-Reader] Read serial byte: %02x", hw->eReaderSerial[hw->eReaderActiveRegister & 0x7F]); + } + } + } else if (!EReaderControl0IsDirection(control)) { + // Clear the error bit + control = EReaderControl0ClearData(control); + } + hw->eReaderRegisterControl0 = control; + if (!EReaderControl0IsScan(oldControl) && EReaderControl0IsScan(control)) { + hw->eReaderX = 0; + hw->eReaderY = 0; + } else if (EReaderControl0IsLedEnable(control) && EReaderControl0IsScan(control) && !EReaderControl1IsScanline(hw->eReaderRegisterControl1)) { + _eReaderReadData(hw); + } + mLOG(GBA_HW, STUB, "Unimplemented e-Reader Control0 write: %02X", value); +} + +void _eReaderWriteControl1(struct GBACartridgeHardware* hw, uint8_t value) { + EReaderControl1 control = (value & 0x32) | 0x80; + hw->eReaderRegisterControl1 = control; + if (EReaderControl0IsScan(hw->eReaderRegisterControl0) && !EReaderControl1IsScanline(control)) { + ++hw->eReaderY; + if (hw->eReaderY == (hw->eReaderSerial[0x15] | (hw->eReaderSerial[0x14] << 8))) { + hw->eReaderY = 0; + if (hw->eReaderX < 3400) { + hw->eReaderX += 220; + } + } + _eReaderReadData(hw); + } + mLOG(GBA_HW, STUB, "Unimplemented e-Reader Control1 write: %02X", value); +} + +void _eReaderReadData(struct GBACartridgeHardware* hw) { + memset(hw->eReaderData, 0, EREADER_BLOCK_SIZE); + if (hw->eReaderDots) { + int y = hw->eReaderY - 10; + if (y < 0 || y >= 120) { + memset(hw->eReaderData, 0, EREADER_BLOCK_SIZE); + } else { + int i; + uint8_t* origin = &hw->eReaderDots[EREADER_DOTCODE_STRIDE * (y / 3) + 16]; + for (i = 0; i < 20; ++i) { + uint16_t word = 0; + int x = hw->eReaderX + i * 16; + word |= origin[(x + 0) / 3] << 8; + word |= origin[(x + 1) / 3] << 9; + word |= origin[(x + 2) / 3] << 10; + word |= origin[(x + 3) / 3] << 11; + word |= origin[(x + 4) / 3] << 12; + word |= origin[(x + 5) / 3] << 13; + word |= origin[(x + 6) / 3] << 14; + word |= origin[(x + 7) / 3] << 15; + word |= origin[(x + 8) / 3]; + word |= origin[(x + 9) / 3] << 1; + word |= origin[(x + 10) / 3] << 2; + word |= origin[(x + 11) / 3] << 3; + word |= origin[(x + 12) / 3] << 4; + word |= origin[(x + 13) / 3] << 5; + word |= origin[(x + 14) / 3] << 6; + word |= origin[(x + 15) / 3] << 7; + STORE_16(word, (19 - i) << 1, hw->eReaderData); + } + } + } + hw->eReaderRegisterControl1 = EReaderControl1FillScanline(hw->eReaderRegisterControl1); + if (EReaderControl0IsLedEnable(hw->eReaderRegisterControl0)) { + uint16_t led = 2754; // TODO: Figure out why this breaks if using the LED register + GBARaiseIRQ(hw->p, IRQ_GAMEPAK, -led); + } +} diff --git a/src/gba/hardware.c b/src/gba/hardware.c index 423afc0ea..24c04733b 100644 --- a/src/gba/hardware.c +++ b/src/gba/hardware.c @@ -12,97 +12,9 @@ #include #include -#define EREADER_BLOCK_SIZE 40 -#define EREADER_DOTCODE_STRIDE 1200 -#define EREADER_DOTCODE_SIZE (EREADER_DOTCODE_STRIDE * 40 + 200) - mLOG_DEFINE_CATEGORY(GBA_HW, "GBA Pak Hardware", "gba.hardware"); MGBA_EXPORT const int GBA_LUX_LEVELS[10] = { 5, 11, 18, 27, 42, 62, 84, 109, 139, 183 }; -const uint16_t EREADER_ADDRESS_CODES[] = { - 1023, - 1174, - 2628, - 3373, - 4233, - 6112, - 6450, - 7771, - 8826, - 9491, - 11201, - 11432, - 12556, - 13925, - 14519, - 16350, - 16629, - 18332, - 18766, - 20007, - 21379, - 21738, - 23096, - 23889, - 24944, - 26137, - 26827, - 28578, - 29190, - 30063, - 31677, - 31956, - 33410, - 34283, - 35641, - 35920, - 37364, - 38557, - 38991, - 40742, - 41735, - 42094, - 43708, - 44501, - 45169, - 46872, - 47562, - 48803, - 49544, - 50913, - 51251, - 53082, - 54014, - 54679 -}; - -const int EREADER_NYBBLE_5BIT[16][5] = { - { 0, 0, 0, 0, 0 }, - { 0, 0, 0, 0, 1 }, - { 0, 0, 0, 1, 0 }, - { 1, 0, 0, 1, 0 }, - { 0, 0, 1, 0, 0 }, - { 0, 0, 1, 0, 1 }, - { 0, 0, 1, 1, 0 }, - { 1, 0, 1, 1, 0 }, - { 0, 1, 0, 0, 0 }, - { 0, 1, 0, 0, 1 }, - { 0, 1, 0, 1, 0 }, - { 1, 0, 1, 0, 0 }, - { 0, 1, 1, 0, 0 }, - { 0, 1, 1, 0, 1 }, - { 1, 0, 0, 0, 1 }, - { 1, 0, 0, 0, 0 } -}; - -const uint8_t EREADER_CALIBRATION_TEMPLATE[] = { - 0x43, 0x61, 0x72, 0x64, 0x2d, 0x45, 0x20, 0x52, 0x65, 0x61, 0x64, 0x65, 0x72, 0x20, 0x32, 0x30, - 0x30, 0x31, 0x00, 0x00, 0xcf, 0x72, 0x2f, 0x37, 0x3a, 0x3a, 0x3a, 0x38, 0x33, 0x30, 0x30, 0x37, - 0x3a, 0x39, 0x37, 0x35, 0x33, 0x2f, 0x2f, 0x34, 0x36, 0x36, 0x37, 0x36, 0x34, 0x31, 0x2d, 0x30, - 0x32, 0x34, 0x35, 0x35, 0x34, 0x30, 0x2a, 0x2d, 0x2d, 0x2f, 0x31, 0x32, 0x31, 0x2f, 0x29, 0x2a, - 0x2c, 0x2b, 0x2c, 0x2e, 0x2e, 0x2d, 0x18, 0x2d, 0x8f, 0x03, 0x00, 0x00, 0xc0, 0xfd, 0x77, 0x00, - 0x00, 0x00, 0x01 -}; static void _readPins(struct GBACartridgeHardware* hw); static void _outputPins(struct GBACartridgeHardware* hw, unsigned pins); @@ -125,11 +37,6 @@ static uint16_t _gbpRead(struct mKeyCallback*); static uint16_t _gbpSioWriteRegister(struct GBASIODriver* driver, uint32_t address, uint16_t value); static void _gbpSioProcessEvents(struct mTiming* timing, void* user, uint32_t cyclesLate); -static void _eReaderReset(struct GBACartridgeHardware* hw); -static void _eReaderWriteControl0(struct GBACartridgeHardware* hw, uint8_t value); -static void _eReaderWriteControl1(struct GBACartridgeHardware* hw, uint8_t value); -static void _eReaderReadData(struct GBACartridgeHardware* hw); - static const int RTC_BYTES[8] = { 0, // Force reset 0, // Empty @@ -691,357 +598,6 @@ void _gbpSioProcessEvents(struct mTiming* timing, void* user, uint32_t cyclesLat gbp->p->p->memory.io[REG_SIOCNT >> 1] = gbp->d.p->siocnt & ~0x0080; } -// == e-Reader - -void GBAHardwareInitEReader(struct GBACartridgeHardware* hw) { - hw->devices |= HW_EREADER; - _eReaderReset(hw); - - if (hw->p->memory.savedata.data[0xD000] == 0xFF) { - memset(&hw->p->memory.savedata.data[0xD000], 0, 0x1000); - memcpy(&hw->p->memory.savedata.data[0xD000], EREADER_CALIBRATION_TEMPLATE, sizeof(EREADER_CALIBRATION_TEMPLATE)); - } - if (hw->p->memory.savedata.data[0xE000] == 0xFF) { - memset(&hw->p->memory.savedata.data[0xE000], 0, 0x1000); - memcpy(&hw->p->memory.savedata.data[0xE000], EREADER_CALIBRATION_TEMPLATE, sizeof(EREADER_CALIBRATION_TEMPLATE)); - } -} - -void GBAHardwareEReaderWrite(struct GBACartridgeHardware* hw, uint32_t address, uint16_t value) { - address &= 0x700FF; - switch (address >> 17) { - case 0: - hw->eReaderRegisterUnk = value & 0xF; - break; - case 1: - hw->eReaderRegisterReset = (value & 0x8A) | 4; - if (value & 2) { - _eReaderReset(hw); - } - break; - case 2: - mLOG(GBA_HW, GAME_ERROR, "e-Reader write to read-only registers: %05X:%04X", address, value); - break; - default: - mLOG(GBA_HW, STUB, "Unimplemented e-Reader write: %05X:%04X", address, value); - } -} - -void GBAHardwareEReaderWriteFlash(struct GBACartridgeHardware* hw, uint32_t address, uint8_t value) { - address &= 0xFFFF; - switch (address) { - case 0xFFB0: - _eReaderWriteControl0(hw, value); - break; - case 0xFFB1: - _eReaderWriteControl1(hw, value); - break; - case 0xFFB2: - hw->eReaderRegisterLed &= 0xFF00; - hw->eReaderRegisterLed |= value; - break; - case 0xFFB3: - hw->eReaderRegisterLed &= 0x00FF; - hw->eReaderRegisterLed |= value << 8; - break; - default: - mLOG(GBA_HW, STUB, "Unimplemented e-Reader write to flash: %04X:%02X", address, value); - } -} - -uint16_t GBAHardwareEReaderRead(struct GBACartridgeHardware* hw, uint32_t address) { - address &= 0x700FF; - uint16_t value; - switch (address >> 17) { - case 0: - return hw->eReaderRegisterUnk; - case 1: - return hw->eReaderRegisterReset; - case 2: - if (address > 0x40088) { - return 0; - } - LOAD_16(value, address & 0xFE, hw->eReaderData); - return value; - } - mLOG(GBA_HW, STUB, "Unimplemented e-Reader read: %05X", address); - return 0; -} - -uint8_t GBAHardwareEReaderReadFlash(struct GBACartridgeHardware* hw, uint32_t address) { - address &= 0xFFFF; - switch (address) { - case 0xFFB0: - return hw->eReaderRegisterControl0; - case 0xFFB1: - return hw->eReaderRegisterControl1; - default: - mLOG(GBA_HW, STUB, "Unimplemented e-Reader read from flash: %04X", address); - return 0; - } -} - -static void _eReaderAnchor(uint8_t* origin) { - origin[EREADER_DOTCODE_STRIDE * 0 + 1] = 1; - origin[EREADER_DOTCODE_STRIDE * 0 + 2] = 1; - origin[EREADER_DOTCODE_STRIDE * 0 + 3] = 1; - origin[EREADER_DOTCODE_STRIDE * 1 + 0] = 1; - origin[EREADER_DOTCODE_STRIDE * 1 + 1] = 1; - origin[EREADER_DOTCODE_STRIDE * 1 + 2] = 1; - origin[EREADER_DOTCODE_STRIDE * 1 + 3] = 1; - origin[EREADER_DOTCODE_STRIDE * 1 + 4] = 1; - origin[EREADER_DOTCODE_STRIDE * 2 + 0] = 1; - origin[EREADER_DOTCODE_STRIDE * 2 + 1] = 1; - origin[EREADER_DOTCODE_STRIDE * 2 + 2] = 1; - origin[EREADER_DOTCODE_STRIDE * 2 + 3] = 1; - origin[EREADER_DOTCODE_STRIDE * 2 + 4] = 1; - origin[EREADER_DOTCODE_STRIDE * 3 + 0] = 1; - origin[EREADER_DOTCODE_STRIDE * 3 + 1] = 1; - origin[EREADER_DOTCODE_STRIDE * 3 + 2] = 1; - origin[EREADER_DOTCODE_STRIDE * 3 + 3] = 1; - origin[EREADER_DOTCODE_STRIDE * 3 + 4] = 1; - origin[EREADER_DOTCODE_STRIDE * 4 + 1] = 1; - origin[EREADER_DOTCODE_STRIDE * 4 + 2] = 1; - origin[EREADER_DOTCODE_STRIDE * 4 + 3] = 1; -} - -static void _eReaderAlignment(uint8_t* origin) { - origin[8] = 1; - origin[10] = 1; - origin[12] = 1; - origin[14] = 1; - origin[16] = 1; - origin[18] = 1; - origin[21] = 1; - origin[23] = 1; - origin[25] = 1; - origin[27] = 1; - origin[29] = 1; - origin[31] = 1; -} - -static void _eReaderAddress(uint8_t* origin, int a) { - origin[EREADER_DOTCODE_STRIDE * 7 + 2] = 1; - uint16_t addr = EREADER_ADDRESS_CODES[a]; - int i; - for (i = 0; i < 16; ++i) { - origin[EREADER_DOTCODE_STRIDE * (16 + i) + 2] = (addr >> (15 - i)) & 1; - } -} - -void GBAHardwareEReaderScan(struct GBACartridgeHardware* hw, const void* data, size_t size) { - if (!hw->eReaderDots) { - hw->eReaderDots = anonymousMemoryMap(EREADER_DOTCODE_SIZE); - } - memset(hw->eReaderDots, 0, EREADER_DOTCODE_SIZE); - - int base; - switch (size) { - case 2912: - base = 25; - break; - case 1872: - base = 1; - break; - default: - return; - } - - size_t i; - for (i = 0; i < (size / 104) + 1; ++i) { - uint8_t* origin = &hw->eReaderDots[35 * i + 200]; - _eReaderAnchor(&origin[EREADER_DOTCODE_STRIDE * 0]); - _eReaderAnchor(&origin[EREADER_DOTCODE_STRIDE * 35]); - _eReaderAddress(origin, base + i); - } - for (i = 0; i < size / 104; ++i) { - uint8_t block[1040]; - uint8_t* origin = &hw->eReaderDots[35 * i + 200]; - _eReaderAlignment(&origin[EREADER_DOTCODE_STRIDE * 2]); - _eReaderAlignment(&origin[EREADER_DOTCODE_STRIDE * 37]); - - int b; - for (b = 0; b < 104; ++b) { - const int* nybble5; - nybble5 = EREADER_NYBBLE_5BIT[((const uint8_t*) data)[i * 104 + b] >> 4]; - block[b * 10 + 0] = nybble5[0]; - block[b * 10 + 1] = nybble5[1]; - block[b * 10 + 2] = nybble5[2]; - block[b * 10 + 3] = nybble5[3]; - block[b * 10 + 4] = nybble5[4]; - nybble5 = EREADER_NYBBLE_5BIT[((const uint8_t*) data)[i * 104 + b] & 0xF]; - block[b * 10 + 5] = nybble5[0]; - block[b * 10 + 6] = nybble5[1]; - block[b * 10 + 7] = nybble5[2]; - block[b * 10 + 8] = nybble5[3]; - block[b * 10 + 9] = nybble5[4]; - } - - b = 0; - int y; - for (y = 0; y < 3; ++y) { - memcpy(&origin[EREADER_DOTCODE_STRIDE * (4 + y) + 7], &block[b], 26); - b += 26; - } - for (y = 0; y < 26; ++y) { - memcpy(&origin[EREADER_DOTCODE_STRIDE * (7 + y) + 3], &block[b], 34); - b += 34; - } - for (y = 0; y < 3; ++y) { - memcpy(&origin[EREADER_DOTCODE_STRIDE * (33 + y) + 7], &block[b], 26); - b += 26; - } - } - hw->eReaderX = -24; -} - -void _eReaderReset(struct GBACartridgeHardware* hw) { - memset(hw->eReaderData, 0, sizeof(hw->eReaderData)); - hw->eReaderRegisterUnk = 0; - hw->eReaderRegisterReset = 4; - hw->eReaderRegisterControl0 = 0; - hw->eReaderRegisterControl1 = 0x80; - hw->eReaderRegisterLed = 0; - hw->eReaderState = 0; - hw->eReaderActiveRegister = 0; -} - -void _eReaderWriteControl0(struct GBACartridgeHardware* hw, uint8_t value) { - EReaderControl0 control = value & 0x7F; - EReaderControl0 oldControl = hw->eReaderRegisterControl0; - if (hw->eReaderState == EREADER_SERIAL_INACTIVE) { - if (EReaderControl0IsClock(oldControl) && EReaderControl0IsData(oldControl) && !EReaderControl0IsData(control)) { - hw->eReaderState = EREADER_SERIAL_STARTING; - } - } else if (EReaderControl0IsClock(oldControl) && !EReaderControl0IsData(oldControl) && EReaderControl0IsData(control)) { - hw->eReaderState = EREADER_SERIAL_INACTIVE; - - } else if (hw->eReaderState == EREADER_SERIAL_STARTING) { - if (EReaderControl0IsClock(oldControl) && !EReaderControl0IsData(oldControl) && !EReaderControl0IsClock(control)) { - hw->eReaderState = EREADER_SERIAL_BIT_0; - hw->eReaderCommand = EREADER_COMMAND_IDLE; - } - } else if (EReaderControl0IsClock(oldControl) && !EReaderControl0IsClock(control)) { - mLOG(GBA_HW, DEBUG, "[e-Reader] Serial falling edge: %c %i", EReaderControl0IsDirection(control) ? '>' : '<', EReaderControl0GetData(control)); - // TODO: Improve direction control - if (EReaderControl0IsDirection(control)) { - hw->eReaderByte |= EReaderControl0GetData(control) << (7 - (hw->eReaderState - EREADER_SERIAL_BIT_0)); - ++hw->eReaderState; - if (hw->eReaderState == EREADER_SERIAL_END_BIT) { - mLOG(GBA_HW, DEBUG, "[e-Reader] Wrote serial byte: %02x", hw->eReaderByte); - switch (hw->eReaderCommand) { - case EREADER_COMMAND_IDLE: - hw->eReaderCommand = hw->eReaderByte; - break; - case EREADER_COMMAND_SET_INDEX: - hw->eReaderActiveRegister = hw->eReaderByte; - hw->eReaderCommand = EREADER_COMMAND_WRITE_DATA; - break; - case EREADER_COMMAND_WRITE_DATA: - switch (hw->eReaderActiveRegister & 0x7F) { - case 0: - case 0x57: - case 0x58: - case 0x59: - case 0x5A: - // Read-only - mLOG(GBA_HW, GAME_ERROR, "Writing to read-only e-Reader serial register: %02X", hw->eReaderActiveRegister); - break; - default: - if ((hw->eReaderActiveRegister & 0x7F) > 0x5A) { - mLOG(GBA_HW, GAME_ERROR, "Writing to non-existent e-Reader serial register: %02X", hw->eReaderActiveRegister); - break; - } - hw->eReaderSerial[hw->eReaderActiveRegister & 0x7F] = hw->eReaderByte; - break; - } - ++hw->eReaderActiveRegister; - break; - default: - mLOG(GBA_HW, ERROR, "Hit undefined state %02X in e-Reader state machine", hw->eReaderCommand); - break; - } - hw->eReaderState = EREADER_SERIAL_BIT_0; - hw->eReaderByte = 0; - } - } else if (hw->eReaderCommand == EREADER_COMMAND_READ_DATA) { - int bit = hw->eReaderSerial[hw->eReaderActiveRegister & 0x7F] >> (7 - (hw->eReaderState - EREADER_SERIAL_BIT_0)); - control = EReaderControl0SetData(control, bit); - ++hw->eReaderState; - if (hw->eReaderState == EREADER_SERIAL_END_BIT) { - ++hw->eReaderActiveRegister; - mLOG(GBA_HW, DEBUG, "[e-Reader] Read serial byte: %02x", hw->eReaderSerial[hw->eReaderActiveRegister & 0x7F]); - } - } - } else if (!EReaderControl0IsDirection(control)) { - // Clear the error bit - control = EReaderControl0ClearData(control); - } - hw->eReaderRegisterControl0 = control; - if (!EReaderControl0IsScan(oldControl) && EReaderControl0IsScan(control)) { - hw->eReaderX = 0; - hw->eReaderY = 0; - } else if (EReaderControl0IsLedEnable(control) && EReaderControl0IsScan(control) && !EReaderControl1IsScanline(hw->eReaderRegisterControl1)) { - _eReaderReadData(hw); - } - mLOG(GBA_HW, STUB, "Unimplemented e-Reader Control0 write: %02X", value); -} - -void _eReaderWriteControl1(struct GBACartridgeHardware* hw, uint8_t value) { - EReaderControl1 control = (value & 0x32) | 0x80; - hw->eReaderRegisterControl1 = control; - if (EReaderControl0IsScan(hw->eReaderRegisterControl0) && !EReaderControl1IsScanline(control)) { - ++hw->eReaderY; - if (hw->eReaderY == (hw->eReaderSerial[0x15] | (hw->eReaderSerial[0x14] << 8))) { - hw->eReaderY = 0; - if (hw->eReaderX < 3400) { - hw->eReaderX += 220; - } - } - _eReaderReadData(hw); - } - mLOG(GBA_HW, STUB, "Unimplemented e-Reader Control1 write: %02X", value); -} - -void _eReaderReadData(struct GBACartridgeHardware* hw) { - memset(hw->eReaderData, 0, EREADER_BLOCK_SIZE); - if (hw->eReaderDots) { - int y = hw->eReaderY - 10; - if (y < 0 || y >= 120) { - memset(hw->eReaderData, 0, EREADER_BLOCK_SIZE); - } else { - int i; - uint8_t* origin = &hw->eReaderDots[EREADER_DOTCODE_STRIDE * (y / 3) + 16]; - for (i = 0; i < 20; ++i) { - uint16_t word = 0; - int x = hw->eReaderX + i * 16; - word |= origin[(x + 0) / 3] << 8; - word |= origin[(x + 1) / 3] << 9; - word |= origin[(x + 2) / 3] << 10; - word |= origin[(x + 3) / 3] << 11; - word |= origin[(x + 4) / 3] << 12; - word |= origin[(x + 5) / 3] << 13; - word |= origin[(x + 6) / 3] << 14; - word |= origin[(x + 7) / 3] << 15; - word |= origin[(x + 8) / 3]; - word |= origin[(x + 9) / 3] << 1; - word |= origin[(x + 10) / 3] << 2; - word |= origin[(x + 11) / 3] << 3; - word |= origin[(x + 12) / 3] << 4; - word |= origin[(x + 13) / 3] << 5; - word |= origin[(x + 14) / 3] << 6; - word |= origin[(x + 15) / 3] << 7; - STORE_16(word, (19 - i) << 1, hw->eReaderData); - } - } - } - hw->eReaderRegisterControl1 = EReaderControl1FillScanline(hw->eReaderRegisterControl1); - if (EReaderControl0IsLedEnable(hw->eReaderRegisterControl0)) { - uint16_t led = 2754; // TODO: Figure out why this breaks if using the LED register - GBARaiseIRQ(hw->p, IRQ_GAMEPAK, -led); - } -} - // == Serialization void GBAHardwareSerialize(const struct GBACartridgeHardware* hw, struct GBASerializedState* state) {