diff --git a/.gitignore b/.gitignore index 3abb66f..f454228 100644 --- a/.gitignore +++ b/.gitignore @@ -1,4 +1,5 @@ build +arm9/data/load.bin *.elf *.nds *.pcf diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 0000000..623726f --- /dev/null +++ b/.gitmodules @@ -0,0 +1,3 @@ +[submodule "nds-bootloader"] + path = nds-bootloader + url = https://github.com/devkitPro/nds-bootloader diff --git a/arm9/Makefile b/arm9/Makefile index cc57e5a..f5721ff 100644 --- a/arm9/Makefile +++ b/arm9/Makefile @@ -16,8 +16,8 @@ include $(DEVKITARM)/ds_rules # all directories are relative to this makefile #--------------------------------------------------------------------------------- BUILD := build -SOURCES := source source/ui source/font -INCLUDES := include ../share $(SOURCES) +SOURCES := source source/ui source/font source/launcher +INCLUDES := include ../share $(SOURCES) DATA := data GRAPHICS := @@ -27,7 +27,7 @@ GRAPHICS := ARCH := -marm -mthumb-interwork -march=armv5te -mtune=arm946e-s CFLAGS := -g -Wall -O3\ - $(ARCH) $(INCLUDE) -DARM9 + $(ARCH) $(INCLUDE) -DARM9 -D_NO_BOOTSTUB_ CXXFLAGS := $(CFLAGS) -fno-rtti -fno-exceptions ASFLAGS := -g $(ARCH) LDFLAGS = -specs=ds_arm9.specs -g $(ARCH) -Wl,-Map,$(notdir $*.map) diff --git a/arm9/source/launcher/HomebrewLauncher.cpp b/arm9/source/launcher/HomebrewLauncher.cpp new file mode 100644 index 0000000..ea5ab79 --- /dev/null +++ b/arm9/source/launcher/HomebrewLauncher.cpp @@ -0,0 +1,23 @@ +/* + Copyright (C) 2024 lifehackerhansol + + SPDX-License-Identifier: GPL-3.0-or-later +*/ + +#include +#include +#include + +#include "HomebrewLauncher.h" +#include "ILauncher.h" +#include "nds_loader_arm9.h" + +bool HomebrewLauncher::launchRom(std::string romPath, std::string savePath, u32 flags, + u32 cheatOffset, u32 cheatSize) { + std::vector argv; + argv.push_back(romPath.c_str()); + eRunNdsRetCode rc = runNdsFile(argv[0], argv.size(), &argv[0]); + if (rc == RUN_NDS_OK) return true; + + return false; +} diff --git a/arm9/source/launcher/HomebrewLauncher.h b/arm9/source/launcher/HomebrewLauncher.h new file mode 100644 index 0000000..6afddfe --- /dev/null +++ b/arm9/source/launcher/HomebrewLauncher.h @@ -0,0 +1,17 @@ +/* + Copyright (C) 2024 lifehackerhansol + + SPDX-License-Identifier: GPL-3.0-or-later +*/ + +#pragma once + +#include + +#include "ILauncher.h" + +class HomebrewLauncher : public ILauncher { + public: + bool launchRom(std::string romPath, std::string savePath, u32 flags, u32 cheatOffset, + u32 cheatSize) override; +}; diff --git a/arm9/source/launcher/ILauncher.h b/arm9/source/launcher/ILauncher.h new file mode 100644 index 0000000..39b599d --- /dev/null +++ b/arm9/source/launcher/ILauncher.h @@ -0,0 +1,16 @@ +/* + Copyright (C) 2024 lifehackerhansol + + SPDX-License-Identifier: GPL-3.0-or-later +*/ + +#pragma once + +#include + +class ILauncher { + public: + virtual ~ILauncher() {} + virtual bool launchRom(std::string romPath, std::string savePath, u32 flags, u32 cheatOffset, + u32 cheatSize) = 0; +}; diff --git a/arm9/source/launcher/nds_loader_arm9.c b/arm9/source/launcher/nds_loader_arm9.c new file mode 100644 index 0000000..de933ba --- /dev/null +++ b/arm9/source/launcher/nds_loader_arm9.c @@ -0,0 +1,445 @@ +// clang-format off + +/*----------------------------------------------------------------- + Copyright (C) 2005 - 2010 + Michael "Chishm" Chisholm + Dave "WinterMute" Murphy + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License + as published by the Free Software Foundation; either version 2 + of the License, or (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + +------------------------------------------------------------------*/ +#include +#include +#include +#include +#include + +#include +#include + +#include "load_bin.h" + +#ifndef _NO_BOOTSTUB_ +#include "bootstub_bin.h" +#include "exceptionstub_bin.h" +#endif + +#include "nds_loader_arm9.h" +#define LCDC_BANK_C (u16*)0x06840000 +#define STORED_FILE_CLUSTER (*(((u32*)LCDC_BANK_C) + 1)) +#define INIT_DISC (*(((u32*)LCDC_BANK_C) + 2)) +#define WANT_TO_PATCH_DLDI (*(((u32*)LCDC_BANK_C) + 3)) + + +/* + b startUp + +storedFileCluster: + .word 0x0FFFFFFF @ default BOOT.NDS +initDisc: + .word 0x00000001 @ init the disc by default +wantToPatchDLDI: + .word 0x00000001 @ by default patch the DLDI section of the loaded NDS +@ Used for passing arguments to the loaded app +argStart: + .word _end - _start +argSize: + .word 0x00000000 +dldiOffset: + .word _dldi_start - _start +dsiSD: + .word 0 +dsiMode: + .word 0 +*/ + +#define STORED_FILE_CLUSTER_OFFSET 4 +#define INIT_DISC_OFFSET 8 +#define WANT_TO_PATCH_DLDI_OFFSET 12 +#define ARG_START_OFFSET 16 +#define ARG_SIZE_OFFSET 20 +#define HAVE_DSISD_OFFSET 28 +#define DSIMODE_OFFSET 32 + + +typedef signed int addr_t; +typedef unsigned char data_t; + +#define FIX_ALL 0x01 +#define FIX_GLUE 0x02 +#define FIX_GOT 0x04 +#define FIX_BSS 0x08 + +enum DldiOffsets { + DO_magicString = 0x00, // "\xED\xA5\x8D\xBF Chishm" + DO_magicToken = 0x00, // 0xBF8DA5ED + DO_magicShortString = 0x04, // " Chishm" + DO_version = 0x0C, + DO_driverSize = 0x0D, + DO_fixSections = 0x0E, + DO_allocatedSpace = 0x0F, + + DO_friendlyName = 0x10, + + DO_text_start = 0x40, // Data start + DO_data_end = 0x44, // Data end + DO_glue_start = 0x48, // Interworking glue start -- Needs address fixing + DO_glue_end = 0x4C, // Interworking glue end + DO_got_start = 0x50, // GOT start -- Needs address fixing + DO_got_end = 0x54, // GOT end + DO_bss_start = 0x58, // bss start -- Needs setting to zero + DO_bss_end = 0x5C, // bss end + + // IO_INTERFACE data + DO_ioType = 0x60, + DO_features = 0x64, + DO_startup = 0x68, + DO_isInserted = 0x6C, + DO_readSectors = 0x70, + DO_writeSectors = 0x74, + DO_clearStatus = 0x78, + DO_shutdown = 0x7C, + DO_code = 0x80 +}; + +static addr_t readAddr (data_t *mem, addr_t offset) { + return ((addr_t*)mem)[offset/sizeof(addr_t)]; +} + +static void writeAddr (data_t *mem, addr_t offset, addr_t value) { + ((addr_t*)mem)[offset/sizeof(addr_t)] = value; +} + +static void vramcpy (void* dst, const void* src, int len) +{ + u16* dst16 = (u16*)dst; + u16* src16 = (u16*)src; + + //dmaCopy(src, dst, len); + + for ( ; len > 0; len -= 2) { + *dst16++ = *src16++; + } +} + +static addr_t quickFind (const data_t* data, const data_t* search, size_t dataLen, size_t searchLen) { + const int* dataChunk = (const int*) data; + int searchChunk = ((const int*)search)[0]; + addr_t i; + addr_t dataChunkEnd = (addr_t)(dataLen / sizeof(int)); + + for ( i = 0; i < dataChunkEnd; i++) { + if (dataChunk[i] == searchChunk) { + if ((i*sizeof(int) + searchLen) > dataLen) { + return -1; + } + if (memcmp (&data[i*sizeof(int)], search, searchLen) == 0) { + return i*sizeof(int); + } + } + } + + return -1; +} + +// Normal DLDI uses "\xED\xA5\x8D\xBF Chishm" +// Bootloader string is different to avoid being patched +static const data_t dldiMagicLoaderString[] = "\xEE\xA5\x8D\xBF Chishm"; // Different to a normal DLDI file + +#define DEVICE_TYPE_DLDI 0x49444C44 + +static bool dldiPatchLoader (data_t *binData, u32 binSize, bool clearBSS) +{ + addr_t memOffset; // Offset of DLDI after the file is loaded into memory + addr_t patchOffset; // Position of patch destination in the file + addr_t relocationOffset; // Value added to all offsets within the patch to fix it properly + addr_t ddmemOffset; // Original offset used in the DLDI file + addr_t ddmemStart; // Start of range that offsets can be in the DLDI file + addr_t ddmemEnd; // End of range that offsets can be in the DLDI file + addr_t ddmemSize; // Size of range that offsets can be in the DLDI file + + addr_t addrIter; + + data_t *pDH; + data_t *pAH; + + size_t dldiFileSize = 0; + + // Find the DLDI reserved space in the file + patchOffset = quickFind (binData, dldiMagicLoaderString, binSize, sizeof(dldiMagicLoaderString)); + + if (patchOffset < 0) { + // does not have a DLDI section + return false; + } + + pDH = (data_t*)(io_dldi_data); + + pAH = &(binData[patchOffset]); + + if (*((u32*)(pDH + DO_ioType)) == DEVICE_TYPE_DLDI) { + // No DLDI patch + return false; + } + + if (pDH[DO_driverSize] > pAH[DO_allocatedSpace]) { + // Not enough space for patch + return false; + } + + dldiFileSize = 1 << pDH[DO_driverSize]; + + memOffset = readAddr (pAH, DO_text_start); + if (memOffset == 0) { + memOffset = readAddr (pAH, DO_startup) - DO_code; + } + ddmemOffset = readAddr (pDH, DO_text_start); + relocationOffset = memOffset - ddmemOffset; + + ddmemStart = readAddr (pDH, DO_text_start); + ddmemSize = (1 << pDH[DO_driverSize]); + ddmemEnd = ddmemStart + ddmemSize; + + // Remember how much space is actually reserved + pDH[DO_allocatedSpace] = pAH[DO_allocatedSpace]; + // Copy the DLDI patch into the application + vramcpy (pAH, pDH, dldiFileSize); + + // Fix the section pointers in the header + writeAddr (pAH, DO_text_start, readAddr (pAH, DO_text_start) + relocationOffset); + writeAddr (pAH, DO_data_end, readAddr (pAH, DO_data_end) + relocationOffset); + writeAddr (pAH, DO_glue_start, readAddr (pAH, DO_glue_start) + relocationOffset); + writeAddr (pAH, DO_glue_end, readAddr (pAH, DO_glue_end) + relocationOffset); + writeAddr (pAH, DO_got_start, readAddr (pAH, DO_got_start) + relocationOffset); + writeAddr (pAH, DO_got_end, readAddr (pAH, DO_got_end) + relocationOffset); + writeAddr (pAH, DO_bss_start, readAddr (pAH, DO_bss_start) + relocationOffset); + writeAddr (pAH, DO_bss_end, readAddr (pAH, DO_bss_end) + relocationOffset); + // Fix the function pointers in the header + writeAddr (pAH, DO_startup, readAddr (pAH, DO_startup) + relocationOffset); + writeAddr (pAH, DO_isInserted, readAddr (pAH, DO_isInserted) + relocationOffset); + writeAddr (pAH, DO_readSectors, readAddr (pAH, DO_readSectors) + relocationOffset); + writeAddr (pAH, DO_writeSectors, readAddr (pAH, DO_writeSectors) + relocationOffset); + writeAddr (pAH, DO_clearStatus, readAddr (pAH, DO_clearStatus) + relocationOffset); + writeAddr (pAH, DO_shutdown, readAddr (pAH, DO_shutdown) + relocationOffset); + + if (pDH[DO_fixSections] & FIX_ALL) { + // Search through and fix pointers within the data section of the file + for (addrIter = (readAddr(pDH, DO_text_start) - ddmemStart); addrIter < (readAddr(pDH, DO_data_end) - ddmemStart); addrIter++) { + if ((ddmemStart <= readAddr(pAH, addrIter)) && (readAddr(pAH, addrIter) < ddmemEnd)) { + writeAddr (pAH, addrIter, readAddr(pAH, addrIter) + relocationOffset); + } + } + } + + if (pDH[DO_fixSections] & FIX_GLUE) { + // Search through and fix pointers within the glue section of the file + for (addrIter = (readAddr(pDH, DO_glue_start) - ddmemStart); addrIter < (readAddr(pDH, DO_glue_end) - ddmemStart); addrIter++) { + if ((ddmemStart <= readAddr(pAH, addrIter)) && (readAddr(pAH, addrIter) < ddmemEnd)) { + writeAddr (pAH, addrIter, readAddr(pAH, addrIter) + relocationOffset); + } + } + } + + if (pDH[DO_fixSections] & FIX_GOT) { + // Search through and fix pointers within the Global Offset Table section of the file + for (addrIter = (readAddr(pDH, DO_got_start) - ddmemStart); addrIter < (readAddr(pDH, DO_got_end) - ddmemStart); addrIter++) { + if ((ddmemStart <= readAddr(pAH, addrIter)) && (readAddr(pAH, addrIter) < ddmemEnd)) { + writeAddr (pAH, addrIter, readAddr(pAH, addrIter) + relocationOffset); + } + } + } + + if (clearBSS && (pDH[DO_fixSections] & FIX_BSS)) { + // Initialise the BSS to 0, only if the disc is being re-inited + memset (&pAH[readAddr(pDH, DO_bss_start) - ddmemStart] , 0, readAddr(pDH, DO_bss_end) - readAddr(pDH, DO_bss_start)); + } + + return true; +} + +eRunNdsRetCode runNds (const void* loader, u32 loaderSize, u32 cluster, bool initDisc, bool dldiPatchNds, int argc, const char** argv) +{ + char* argStart; + u16* argData; + u16 argTempVal = 0; + int argSize; + const char* argChar; + + irqDisable(IRQ_ALL); + + // Direct CPU access to VRAM bank C + VRAM_C_CR = VRAM_ENABLE | VRAM_C_LCD; + // Load the loader/patcher into the correct address + vramcpy (LCDC_BANK_C, loader, loaderSize); + + // Set the parameters for the loader + // STORED_FILE_CLUSTER = cluster; + writeAddr ((data_t*) LCDC_BANK_C, STORED_FILE_CLUSTER_OFFSET, cluster); + // INIT_DISC = initDisc; + writeAddr ((data_t*) LCDC_BANK_C, INIT_DISC_OFFSET, initDisc); + + writeAddr ((data_t*) LCDC_BANK_C, DSIMODE_OFFSET, isDSiMode()); + if(argv[0][0]=='s' && argv[0][1]=='d') { + dldiPatchNds = false; + writeAddr ((data_t*) LCDC_BANK_C, HAVE_DSISD_OFFSET, 1); + } + + // WANT_TO_PATCH_DLDI = dldiPatchNds; + writeAddr ((data_t*) LCDC_BANK_C, WANT_TO_PATCH_DLDI_OFFSET, dldiPatchNds); + // Give arguments to loader + argStart = (char*)LCDC_BANK_C + readAddr((data_t*)LCDC_BANK_C, ARG_START_OFFSET); + argStart = (char*)(((int)argStart + 3) & ~3); // Align to word + argData = (u16*)argStart; + argSize = 0; + + for (; argc > 0 && *argv; ++argv, --argc) + { + for (argChar = *argv; *argChar != 0; ++argChar, ++argSize) + { + if (argSize & 1) + { + argTempVal |= (*argChar) << 8; + *argData = argTempVal; + ++argData; + } + else + { + argTempVal = *argChar; + } + } + if (argSize & 1) + { + *argData = argTempVal; + ++argData; + } + argTempVal = 0; + ++argSize; + } + *argData = argTempVal; + + writeAddr ((data_t*) LCDC_BANK_C, ARG_START_OFFSET, (addr_t)argStart - (addr_t)LCDC_BANK_C); + writeAddr ((data_t*) LCDC_BANK_C, ARG_SIZE_OFFSET, argSize); + + + if(dldiPatchNds) { + // Patch the loader with a DLDI for the card + if (!dldiPatchLoader ((data_t*)LCDC_BANK_C, loaderSize, initDisc)) { + return RUN_NDS_PATCH_DLDI_FAILED; + } + } + + irqDisable(IRQ_ALL); + + // Give the VRAM to the ARM7 + VRAM_C_CR = VRAM_ENABLE | VRAM_C_ARM7_0x06000000; + // Reset into a passme loop + REG_EXMEMCNT |= ARM7_OWNS_ROM | ARM7_OWNS_CARD; + *((vu32*)0x02FFFFFC) = 0; + *((vu32*)0x02FFFE04) = (u32)0xE59FF018; + *((vu32*)0x02FFFE24) = (u32)0x02FFFE04; + + resetARM7(0x06000000); + + swiSoftReset(); + return RUN_NDS_OK; +} + +eRunNdsRetCode runNdsFile (const char* filename, int argc, const char** argv) { + struct stat st; + char filePath[PATH_MAX]; + int pathLen; + const char* args[1]; + + + if (stat (filename, &st) < 0) { + return RUN_NDS_STAT_FAILED; + } + + if (argc <= 0 || !argv) { + // Construct a command line if we weren't supplied with one + if (!getcwd (filePath, PATH_MAX)) { + return RUN_NDS_GETCWD_FAILED; + } + pathLen = strlen (filePath); + strcpy (filePath + pathLen, filename); + args[0] = filePath; + argv = args; + } + + bool havedsiSD = false; + + if(argv[0][0]=='s' && argv[0][1]=='d') havedsiSD = true; + + installBootStub(havedsiSD); + + return runNds (load_bin, load_bin_size, st.st_ino, true, true, argc, argv); +} + +/* + b startUp + +storedFileCluster: + .word 0x0FFFFFFF @ default BOOT.NDS +initDisc: + .word 0x00000001 @ init the disc by default +wantToPatchDLDI: + .word 0x00000001 @ by default patch the DLDI section of the loaded NDS +@ Used for passing arguments to the loaded app +argStart: + .word _end - _start +argSize: + .word 0x00000000 +dldiOffset: + .word _dldi_start - _start +dsiSD: + .word 0 +*/ + +void(*exceptionstub)(void) = (void(*)(void))0x2ffa000; + +bool installBootStub(bool havedsiSD) { +#ifndef _NO_BOOTSTUB_ + extern char *fake_heap_end; + struct __bootstub *bootstub = (struct __bootstub *)fake_heap_end; + u32 *bootloader = (u32*)(fake_heap_end+bootstub_bin_size); + + memcpy(bootstub,bootstub_bin,bootstub_bin_size); + memcpy(bootloader,load_bin,load_bin_size); + bool ret = false; + + bootloader[8] = isDSiMode(); + if( havedsiSD) { + ret = true; + bootloader[3] = 0; // don't dldi patch + bootloader[7] = 1; // use internal dsi SD code + } else { + ret = dldiPatchLoader((data_t*)bootloader, load_bin_size,false); + } + bootstub->arm9reboot = (VoidFn)(((u32)bootstub->arm9reboot)+fake_heap_end); + bootstub->arm7reboot = (VoidFn)(((u32)bootstub->arm7reboot)+fake_heap_end); + bootstub->bootsize = load_bin_size; + + memcpy(exceptionstub,exceptionstub_bin,exceptionstub_bin_size); + + exceptionstub(); + + DC_FlushAll(); + + return ret; +#else + return true; +#endif + +} diff --git a/arm9/source/launcher/nds_loader_arm9.h b/arm9/source/launcher/nds_loader_arm9.h new file mode 100644 index 0000000..48a792d --- /dev/null +++ b/arm9/source/launcher/nds_loader_arm9.h @@ -0,0 +1,51 @@ +// clang-format off + +/*----------------------------------------------------------------- + Copyright (C) 2005 - 2010 + Michael "Chishm" Chisholm + Dave "WinterMute" Murphy + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License + as published by the Free Software Foundation; either version 2 + of the License, or (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + +------------------------------------------------------------------*/ + +#ifndef NDS_LOADER_ARM9_H +#define NDS_LOADER_ARM9_H + +#ifdef __cplusplus +extern "C" { +#endif + +typedef enum { + RUN_NDS_OK = 0, + RUN_NDS_STAT_FAILED, + RUN_NDS_GETCWD_FAILED, + RUN_NDS_PATCH_DLDI_FAILED, +} eRunNdsRetCode; + +#define LOAD_DEFAULT_NDS 0 + +eRunNdsRetCode runNds(const void* loader, u32 loaderSize, u32 cluster, bool initDisc, + bool dldiPatchNds, int argc, const char** argv); + +eRunNdsRetCode runNdsFile(const char* filename, int argc, const char** argv); + +bool installBootStub(bool havedsiSD); + +#ifdef __cplusplus +} +#endif + +#endif // NDS_LOADER_ARM7_H diff --git a/arm9/source/mainwnd.cpp b/arm9/source/mainwnd.cpp index 2b9b79c..1772ee3 100644 --- a/arm9/source/mainwnd.cpp +++ b/arm9/source/mainwnd.cpp @@ -35,6 +35,8 @@ #include #include +#include "launcher/HomebrewLauncher.h" + using namespace akui; cMainWnd::cMainWnd(s32 x, s32 y, u32 w, u32 h, cWindow* parent, const std::string& text) @@ -582,7 +584,7 @@ void cMainWnd::setParam(void) { gs().uiName = uiNames[uiIndexAfter]; gs().langDirectory = langNames[langIndexAfter]; gs().saveSettings(); - loadRom("fat:/akmenu4.nds", "", 0, 0, 0); + HomebrewLauncher().launchRom("fat:/akmenu4.nds", "", 0, 0, 0); } } @@ -592,7 +594,7 @@ void cMainWnd::setParam(void) { if (ID_YES == ret) { gs().langDirectory = langNames[langIndexAfter]; gs().saveSettings(); - loadRom("fat:/akmenu4.nds", "", 0, 0, 0); + HomebrewLauncher().launchRom("fat:/akmenu4.nds", "", 0, 0, 0); } } diff --git a/arm9/source/romlauncher.cpp b/arm9/source/romlauncher.cpp index 62f6e1d..0270723 100644 --- a/arm9/source/romlauncher.cpp +++ b/arm9/source/romlauncher.cpp @@ -10,7 +10,9 @@ #include "exptools.h" #include "flags.h" #include "language.h" -#include "romloader.h" + +#include "launcher/HomebrewLauncher.h" +#include "launcher/ILauncher.h" static SAVE_TYPE PrefillGame(u32 aGameCode) { if (0x45444759 == aGameCode) // YGDE: 2209 - Diary Girl (USA) @@ -132,6 +134,8 @@ TLaunchResult launchRom(const std::string& aFullPath, DSRomInfo& aRomInfo, bool long cheatOffset = 0; size_t cheatSize = 0; std::string saveName; + ILauncher* launcher = nullptr; +#if 0 if (!aRomInfo.isHomebrew()) { u32 gameCode; memcpy(&gameCode, aRomInfo.saveInfo().gameCode, sizeof(gameCode)); // because alignment @@ -146,17 +150,6 @@ TLaunchResult launchRom(const std::string& aFullPath, DSRomInfo& aRomInfo, bool if (protection) speed = 0x1fff; dma = aRomInfo.saveInfo().isDMA(); flags |= PATCH_DMA; - /* - if((gameCode&0xffffff)==0x425841) //2385 - Daigassou! Band-Brothers DX (Japan) - { - isBigSave=true; - } - if((gameCode&0xffffff)==0x414156) //5054 - Eigokoro Kyoushitsu DS (Japan) (NDSi - Enhanced) - { - isBigSave=true; - } - */ if ((gameCode & 0xffffff) == 0x425855) // 4950 - Jam with the Band (Europe) (En,Fr,De,Es,It) { @@ -202,16 +195,21 @@ TLaunchResult launchRom(const std::string& aFullPath, DSRomInfo& aRomInfo, bool } } __NDSHeader->cardControl13 = 0x00406000 | speed; + // 3in1 support - if (gameCode == 0x4a524255 || gameCode == 0x50524255) { - expansion().SoftReset(); - cExpansion::SetRompage(0x300); - cExpansion::OpenNorWrite(); - cExpansion::EnableBrowser(); - } - if (aRomInfo.saveInfo().getRumble()) { - expansion().SoftReset(); - cExpansion::SetShake(0xEF + aRomInfo.saveInfo().getRumble()); + fifoSendValue32(FIFO_USER_01, MENU_MSG_SYSTEM); + fifoWaitValue32(FIFO_USER_02); + if (2 != fifoGetValue32(FIFO_USER_02)) { // not dsi + if (gameCode == 0x4a524255 || gameCode == 0x50524255) { + expansion().SoftReset(); + cExpansion::SetRompage(0x300); + cExpansion::OpenNorWrite(); + cExpansion::EnableBrowser(); + } + if (aRomInfo.saveInfo().getRumble()) { + expansion().SoftReset(); + cExpansion::SetShake(0xEF + aRomInfo.saveInfo().getRumble()); + } } if (aRomInfo.saveInfo().isDownloadPlay()) flags |= PATCH_DOWNLOAD_PLAY; if (aRomInfo.saveInfo().isCheat()) { @@ -231,16 +229,16 @@ TLaunchResult launchRom(const std::string& aFullPath, DSRomInfo& aRomInfo, bool if (aRomInfo.saveInfo().isLinkage()) flags |= PATCH_LINKAGE; u8 language = aRomInfo.saveInfo().getLanguage(); if (language) flags |= (language << PATCH_LANGUAGE_SHIFT) & PATCH_LANGUAGE_MASK; + + launcher = new NdsBootstrapLauncher(); } else { - if (!aMenu) saveManager().saveLastInfo(aFullPath); - const u16 lameboy[] = {'L', 'a', 'm', 'e', 'b', 'o', 'y'}; - if (memcmp(aRomInfo.banner().titles[0], lameboy, sizeof(lameboy)) == 0) { - expansion().SoftReset(); - cExpansion::SetShake(0xF0); - } - if (gs().homebrewreset) flags |= PATCH_SOFT_RESET; +#endif + if (!aMenu) saveManager().saveLastInfo(aFullPath); + launcher = new HomebrewLauncher(); +#if 0 } - loadRom(aFullPath, saveName, flags, cheatOffset, cheatSize); +#endif + launcher->launchRom(aFullPath, saveName, flags, cheatOffset, cheatSize); return ELaunchRomOk; } diff --git a/build.sh b/build.sh new file mode 100755 index 0000000..3d19fe1 --- /dev/null +++ b/build.sh @@ -0,0 +1,3 @@ +mkdir arm9/data +make -C nds-bootloader LOADBIN=$PWD/arm9/data/load.bin +make diff --git a/clean.sh b/clean.sh new file mode 100755 index 0000000..6f9aebe --- /dev/null +++ b/clean.sh @@ -0,0 +1,3 @@ +make clean +make -C nds-bootloader clean +rm arm9/data/load.bin diff --git a/language/English/language.txt b/language/English/language.txt index e3008f7..e2ef189 100644 --- a/language/English/language.txt +++ b/language/English/language.txt @@ -275,4 +275,7 @@ microsd card = microSD Card slot2 card = Slot2 Card favorites = Favorites +[hbloader] +load failed = Failed to load homebrew app. + [end] diff --git a/licenses/GPL2.txt b/licenses/GPL2.txt new file mode 100644 index 0000000..642e42e --- /dev/null +++ b/licenses/GPL2.txt @@ -0,0 +1,342 @@ + + + GNU GENERAL PUBLIC LICENSE + Version 2, June 1991 + + Copyright (C) 1989, 1991 Free Software Foundation, Inc. + 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +License is intended to guarantee your freedom to share and change free +software--to make sure the software is free for all its users. This +General Public License applies to most of the Free Software +Foundation's software and to any other program whose authors commit to +using it. (Some other Free Software Foundation software is covered by +the GNU Library General Public License instead.) You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +this service if you wish), that you receive source code or can get it +if you want it, that you can change the software or use pieces of it +in new free programs; and that you know you can do these things. + + To protect your rights, we need to make restrictions that forbid +anyone to deny you these rights or to ask you to surrender the rights. +These restrictions translate to certain responsibilities for you if you +distribute copies of the software, or if you modify it. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must give the recipients all the rights that +you have. You must make sure that they, too, receive or can get the +source code. And you must show them these terms so they know their +rights. + + We protect your rights with two steps: (1) copyright the software, and +(2) offer you this license which gives you legal permission to copy, +distribute and/or modify the software. + + Also, for each author's protection and ours, we want to make certain +that everyone understands that there is no warranty for this free +software. If the software is modified by someone else and passed on, we +want its recipients to know that what they have is not the original, so +that any problems introduced by others will not reflect on the original +authors' reputations. + + Finally, any free program is threatened constantly by software +patents. We wish to avoid the danger that redistributors of a free +program will individually obtain patent licenses, in effect making the +program proprietary. To prevent this, we have made it clear that any +patent must be licensed for everyone's free use or not licensed at all. + + The precise terms and conditions for copying, distribution and +modification follow. + + GNU GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License applies to any program or other work which contains +a notice placed by the copyright holder saying it may be distributed +under the terms of this General Public License. The "Program", below, +refers to any such program or work, and a "work based on the Program" +means either the Program or any derivative work under copyright law: +that is to say, a work containing the Program or a portion of it, +either verbatim or with modifications and/or translated into another +language. (Hereinafter, translation is included without limitation in +the term "modification".) Each licensee is addressed as "you". + +Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running the Program is not restricted, and the output from the Program +is covered only if its contents constitute a work based on the +Program (independent of having been made by running the Program). +Whether that is true depends on what the Program does. + + 1. You may copy and distribute verbatim copies of the Program's +source code as you receive it, in any medium, provided that you +conspicuously and appropriately publish on each copy an appropriate +copyright notice and disclaimer of warranty; keep intact all the +notices that refer to this License and to the absence of any warranty; +and give any other recipients of the Program a copy of this License +along with the Program. + +You may charge a fee for the physical act of transferring a copy, and +you may at your option offer warranty protection in exchange for a fee. + + 2. You may modify your copy or copies of the Program or any portion +of it, thus forming a work based on the Program, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) You must cause the modified files to carry prominent notices + stating that you changed the files and the date of any change. + + b) You must cause any work that you distribute or publish, that in + whole or in part contains or is derived from the Program or any + part thereof, to be licensed as a whole at no charge to all third + parties under the terms of this License. + + c) If the modified program normally reads commands interactively + when run, you must cause it, when started running for such + interactive use in the most ordinary way, to print or display an + announcement including an appropriate copyright notice and a + notice that there is no warranty (or else, saying that you provide + a warranty) and that users may redistribute the program under + these conditions, and telling the user how to view a copy of this + License. (Exception: if the Program itself is interactive but + does not normally print such an announcement, your work based on + the Program is not required to print an announcement.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Program, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Program, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Program. + +In addition, mere aggregation of another work not based on the Program +with the Program (or with a work based on the Program) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may copy and distribute the Program (or a work based on it, +under Section 2) in object code or executable form under the terms of +Sections 1 and 2 above provided that you also do one of the following: + + a) Accompany it with the complete corresponding machine-readable + source code, which must be distributed under the terms of Sections + 1 and 2 above on a medium customarily used for software interchange; or, + + b) Accompany it with a written offer, valid for at least three + years, to give any third party, for a charge no more than your + cost of physically performing source distribution, a complete + machine-readable copy of the corresponding source code, to be + distributed under the terms of Sections 1 and 2 above on a medium + customarily used for software interchange; or, + + c) Accompany it with the information you received as to the offer + to distribute corresponding source code. (This alternative is + allowed only for noncommercial distribution and only if you + received the program in object code or executable form with such + an offer, in accord with Subsection b above.) + +The source code for a work means the preferred form of the work for +making modifications to it. For an executable work, complete source +code means all the source code for all modules it contains, plus any +associated interface definition files, plus the scripts used to +control compilation and installation of the executable. However, as a +special exception, the source code distributed need not include +anything that is normally distributed (in either source or binary +form) with the major components (compiler, kernel, and so on) of the +operating system on which the executable runs, unless that component +itself accompanies the executable. + +If distribution of executable or object code is made by offering +access to copy from a designated place, then offering equivalent +access to copy the source code from the same place counts as +distribution of the source code, even though third parties are not +compelled to copy the source along with the object code. + + 4. You may not copy, modify, sublicense, or distribute the Program +except as expressly provided under this License. Any attempt +otherwise to copy, modify, sublicense or distribute the Program is +void, and will automatically terminate your rights under this License. +However, parties who have received copies, or rights, from you under +this License will not have their licenses terminated so long as such +parties remain in full compliance. + + 5. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Program or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Program (or any work based on the +Program), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Program or works based on it. + + 6. Each time you redistribute the Program (or any work based on the +Program), the recipient automatically receives a license from the +original licensor to copy, distribute or modify the Program subject to +these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties to +this License. + + 7. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Program at all. For example, if a patent +license would not permit royalty-free redistribution of the Program by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Program. + +If any portion of this section is held invalid or unenforceable under +any particular circumstance, the balance of the section is intended to +apply and the section as a whole is intended to apply in other +circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system, which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 8. If the distribution and/or use of the Program is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Program under this License +may add an explicit geographical distribution limitation excluding +those countries, so that distribution is permitted only in or among +countries not thus excluded. In such case, this License incorporates +the limitation as if written in the body of this License. + + 9. The Free Software Foundation may publish revised and/or new versions +of the General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + +Each version is given a distinguishing version number. If the Program +specifies a version number of this License which applies to it and "any +later version", you have the option of following the terms and conditions +either of that version or of any later version published by the Free +Software Foundation. If the Program does not specify a version number of +this License, you may choose any version ever published by the Free Software +Foundation. + + 10. If you wish to incorporate parts of the Program into other free +programs whose distribution conditions are different, write to the author +to ask for permission. For software which is copyrighted by the Free +Software Foundation, write to the Free Software Foundation; we sometimes +make exceptions for this. Our decision will be guided by the two goals +of preserving the free status of all derivatives of our free software and +of promoting the sharing and reuse of software generally. + + NO WARRANTY + + 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY +FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN +OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES +PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED +OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS +TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE +PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, +REPAIR OR CORRECTION. + + 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR +REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, +INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING +OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED +TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY +YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER +PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE +POSSIBILITY OF SUCH DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + + +Also add information on how to contact you by electronic and paper mail. + +If the program is interactive, make it output a short notice like this +when it starts in an interactive mode: + + Gnomovision version 69, Copyright (C) year name of author + Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, the commands you use may +be called something other than `show w' and `show c'; they could even be +mouse-clicks or menu items--whatever suits your program. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the program, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the program + `Gnomovision' (which makes passes at compilers) written by James Hacker. + + , 1 April 1989 + Ty Coon, President of Vice + +This General Public License does not permit incorporating your program into +proprietary programs. If your program is a subroutine library, you may +consider it more useful to permit linking proprietary applications with the +library. If this is what you want to do, use the GNU Library General +Public License instead of this License. diff --git a/licenses/README.txt b/licenses/README.txt index 3905454..2c3cad3 100644 --- a/licenses/README.txt +++ b/licenses/README.txt @@ -2,4 +2,6 @@ This program is originally based on the akmenu project by the Acekard team, who This program is further developed by yellow wood goblin, who released the source under the GPL-3.0-or-later license. See GPL3.txt for more info. -This provided source is licensed under the GPL-3.0-or-later license. +This provided source integrates devkitPro's bootloader, which is licensed under the GPL-2.0-or-later license. See GPL2.txt for more info. + +This provided source is collectively licensed under the GPL-3.0-or-later license. diff --git a/nds-bootloader b/nds-bootloader new file mode 160000 index 0000000..35f54d8 --- /dev/null +++ b/nds-bootloader @@ -0,0 +1 @@ +Subproject commit 35f54d8e036ac2326331914ea6d2f38d11353b8d