From 422d14cb5bde5a925d3dffcd2fb9385ddf3bc1a3 Mon Sep 17 00:00:00 2001 From: cyan06 Date: Sun, 5 Jul 2015 14:45:51 +0000 Subject: [PATCH] svn commit forgot a file... --- source/usbloader/neek.cpp | 483 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 483 insertions(+) create mode 100644 source/usbloader/neek.cpp diff --git a/source/usbloader/neek.cpp b/source/usbloader/neek.cpp new file mode 100644 index 00000000..7acd4036 --- /dev/null +++ b/source/usbloader/neek.cpp @@ -0,0 +1,483 @@ +/**************************************************************************** + * Copyright (C) 2015 Cyan + * + * 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 3 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, see . + ****************************************************************************/ +#include +#include +#include +#include +#include + +#include "neek.hpp" +#include "memory/mem2.h" +#include "Controls/DeviceHandler.hpp" +#include "FileOperations/fileops.h" +#include "settings/CSettings.h" +#include "sys.h" +#include "gecko.h" + +typedef struct { + u32 hdrsize; + u32 loadersize; + u32 elfsize; + u32 argument; +} ioshdr; + +#define MEM_REG_BASE 0xd8b4000 +#define MEM_PROT (MEM_REG_BASE + 0x20a) +#define TITLE_ID(x,y) (((u64)(x) << 32) | (y)) + +static u32 *kernel = NULL; + +static inline void disable_memory_protection(void) { + write32(MEM_PROT, read32(MEM_PROT) & 0x0000FFFF); +} + +bool neekLoadKernel (const char* nandpath) +{ + gprintf( "NEEK: Loading Kernel.bin... "); + char kernelPath[30]; + if(isWiiU()) + snprintf(kernelPath, sizeof(kernelPath), "%s:/sneek/vwiikernel.bin", DeviceHandler::GetDevicePrefix(nandpath)); + if(!isWiiU() || !CheckFile(kernelPath)) + snprintf(kernelPath, sizeof(kernelPath), "%s:/sneek/kernel.bin", DeviceHandler::GetDevicePrefix(nandpath)); + if(!CheckFile(kernelPath)) + { + gprintf("File not found.\n"); + return false; + } + + FILE *f = NULL; + f = fopen(kernelPath, "rb"); + if(!f) + { + gprintf("Failed loading file %s.\n", kernelPath); + return false; + } + + fseek(f, 0, SEEK_END); + long fsize = ftell(f); + rewind(f); + + // Allocate kernel to mem2 + kernel = (u32 *) MEM2_alloc(fsize); + if(!kernel) + { + return false; + } + + fread(kernel, 1, fsize, f); + //((ioshdr*)kernel)->argument = 0x42; // set argument size + DCFlushRange(kernel, fsize); + + gprintf("Loaded to 0x%08x, size: %d\n", kernel, fsize); + gprintf("NEEK: offset memory address: %08x\n", (u32)kernel - 0x80000000); // offset + + fclose(f); + return true; +} + +/* +static void neekClearKernel(void) +{ + if(kernel) + MEM2_free(kernel); + kernel = NULL; +} +*/ + +int neekBoot(void) +{ + gprintf("Booting S/Uneek !!\n"); + if(kernel == NULL) + { + gprintf("Kernel not loaded !! Exiting...\n"); + return -1; + } + + /** boot mini without BootMii IOS code by Crediar. **/ + + disable_memory_protection(); + unsigned int i = 0x939F02F0; + unsigned char ES_ImportBoot2[16] = + { 0x68, 0x4B, 0x2B, 0x06, 0xD1, 0x0C, 0x68, 0x8B, 0x2B, 0x00, 0xD1, 0x09, 0x68, 0xC8, 0x68, 0x42 }; + + if( memcmp( (void*)(i), ES_ImportBoot2, sizeof(ES_ImportBoot2) ) != 0 ) + for( i = 0x939F0000; i < 0x939FE000; i+=4 ) + if( memcmp( (void*)(i), ES_ImportBoot2, sizeof(ES_ImportBoot2) ) == 0 ) + break; + + if(i >= 0x939FE000) + { + gprintf("ES_ImportBoot2 not patched !! Exiting...\n"); + //SYS_ResetSystem( SYS_RETURNTOMENU, 0, 0 ); + return -1; + } + + DCInvalidateRange( (void*)i, 0x20 ); + + *(vu32*)(i+0x00) = 0x48034904; // LDR R0, 0x10, LDR R1, 0x14 + *(vu32*)(i+0x04) = 0x477846C0; // BX PC, NOP + *(vu32*)(i+0x08) = 0xE6000870; // SYSCALL + *(vu32*)(i+0x0C) = 0xE12FFF1E; // BLR + //*(vu32*)(i+0x10) = 0x11000000; // kernel offset from 0x80000000. Kernel loaded to (void *)0x91000000 + *(vu32*)(i+0x10) = (u32)kernel - 0x80000000; // kernel offset + *(vu32*)(i+0x14) = 0x0000FF01; // version + + DCFlushRange( (void*)i, 0x20 ); + __IOS_ShutdownSubsystems(); + + s32 fd = IOS_Open( "/dev/es", 0 ); + + u8 *buffer = (u8*)memalign( 32, 0x100 ); + memset( buffer, 0, 0x100 ); + + IOS_IoctlvAsync( fd, 0x1F, 0, 0, (ioctlv*)buffer, NULL, NULL ); + return 0; + +} + +/**************************************************************************** + * neekIsNeek2o + * + * Detects Kernel.bin format + * + * @return values : + * -1 : kernel.bin not found + * 0 : sneek or uneek kernel.bin + * 1 : sneek2o or uneek2o kernel.bin + ***************************************************************************/ +int neekIsNeek2o(const char* nandpath) +{ + int found = 0; + char tempPath[100]; + if(isWiiU()) + snprintf(tempPath, sizeof(tempPath), "%s:/sneek/vwiikernel.bin", DeviceHandler::GetDevicePrefix(nandpath)); + + if(!isWiiU() || !CheckFile(tempPath)) + snprintf(tempPath, sizeof(tempPath), "%s:/sneek/kernel.bin", DeviceHandler::GetDevicePrefix(nandpath)); + + if(!CheckFile(tempPath)) + return -1; + + u8 *buffer = NULL; + u32 filesize = 0; + const char* str = "NEEK2O"; + if(LoadFileToMem(tempPath, &buffer, &filesize)) + { + for(u32 i = filesize-strlen(str); i > 0; i--) + { + if( memcmp(buffer+i, str, strlen(str)) == 0) + { + found = 1; + break; + } + } + } + else + return -1; + + if(buffer) + free(buffer); + + return found; +} + +/**************************************************************************** + * neekPathFormat + * + * Convert and trim full path to path format used by neek + ***************************************************************************/ +int neekPathFormat(char* nandpath_out, const char* nandpath_in, u32 len) +{ + const char* neekNandPathTemp = strchr(nandpath_in, '/'); + if(!neekNandPathTemp) + return -1; + + snprintf(nandpath_out, len, "%s", neekNandPathTemp); + + if(nandpath_out[strlen(nandpath_out)-1] == '/') + *(strrchr(nandpath_out, '/')) = '\0'; // remove trailing slash + + return 1; +} + +/**************************************************************************** + * neek2oSetBootSettings + * + * Generate the neek2o autoboot settings + * + * neek_config: Pointer to cfg + * TitleID : Full path to Channel (00010001 + ABCD) or ID4 for Wii/GC games (00000000 + ID) + * Magic : 0x0 for channel, 0x5d1c9ea3 for Wii game, 0xC2339F3D for gamecube and quadforce games + * returnTo : true/false to return to another neek channel instead of system menu + * nandpath : Set a different temporary Nand Path to use (full path to nand) + * + ***************************************************************************/ +bool neek2oSetBootSettings(NEEK_CFG* neek_config, u64 TitleID, u32 Magic, u64 returnto, const char* nandpath ) +{ + if(!neek_config) + return false; + + char tmpPath[100]; + memset(neek_config, 0, sizeof(NEEK_CFG)); + + // Magic and version for DML + neek_config->magic = NEEK_MAGIC; + + // GameID + if(!Magic) + neek_config->titleid = TitleID; // Set channel ID + else + { + neek_config->gameid = (u32)TitleID; // Wii or Gamecube title ID4 to autoboot + neek_config->gamemagic = Magic; // set to 0x5d1c9ea3 for Wii game, 0xC2339F3D for gamecube and quadforce games + neek_config->config |= NCON_EXT_BOOT_GAME ; // set Disc booting + } + + // Return to + if(returnto) + { + // check if NK2O is installed + snprintf(tmpPath, sizeof(tmpPath), "%s/title/00010001/4e4b324f/content/title.tmd", nandpath != NULL ? nandpath : Settings.NandEmuChanPath); + if(CheckFile(tmpPath)) + { + neek_config->returnto = TITLE_ID(0x00010001, 'NK2O'); // Currently forced to NK2O user channel + neek_config->config |= NCON_EXT_RETURN_TO; // enable "return to" patch + } + + if(isWiiU()) + { + neek_config->returnto = TITLE_ID(0x00010002, 'HCVA');// Currently forced to "Return to WiiU" system channel + neek_config->config |= NCON_EXT_RETURN_TO; // enable "return to" patch + } + } + + if(!(neek_config->config & NCON_EXT_RETURN_TO)) + { + // delete residual "return to" file if last shutdown was unclean. + snprintf(tmpPath, sizeof(tmpPath), "%s:/sneek/reload.sys", DeviceHandler::GetDevicePrefix(nandpath)); + if(CheckFile(tmpPath)) + RemoveFile(tmpPath); + } + + if(nandpath && strlen(nandpath) > 0) + { + // ensure path is correct format + char neekNandPath[256] = ""; + if(neekPathFormat(neekNandPath, nandpath, sizeof(neekNandPath))) + { + snprintf(neek_config->nandpath, sizeof(neek_config->nandpath), "%s", neekNandPath); + neek_config->config |= NCON_EXT_NAND_PATH ; // Use custom nand path + // neek_config->config |= NCON_HIDE_EXT_PATH; // Set custom nand path as temporary + } + } + + //set a custom di folder + //snprintf(neek_config->dipath, sizeof(neek_config->dipath), "/sneek/vwii"); // Set path for di.bin and diconfig.bin + //neek_config->config |= NCON_EXT_DI_PATH; // Use custom di path + + DCFlushRange(neek_config, sizeof(NEEK_CFG)); + + //hexdump(neek_config, sizeof(NEEK_CFG)); + + return true; +} + + +/**************************************************************************** + * neek2oSetNAND + * + * Generates nandcfg.bin if missing and adds missing EmuNAND path + * Sets default EmuNAND path for neek2o + * + * @return values : + * -1 : error + * x : Default path set to EmuNAND number x + ***************************************************************************/ +int neek2oSetNAND(const char* nandpath) +{ + // format path string for neek + char neekNandPath[256] = ""; + if(neekPathFormat(neekNandPath, nandpath, sizeof(neekNandPath)) < 0) + return -1; + + FILE *f = NULL; + u32 ret = -1; + bool found = false; + u32 i = 0; + + char nandconfigPath[100]; + snprintf(nandconfigPath, sizeof(nandconfigPath), "%s:/sneek/nandcfg.bin", DeviceHandler::GetDevicePrefix(nandpath)); + + // vWii neek2o - different filename but not the same format? + //if(isWiiU()) + // snprintf(nandconfigPath, sizeof(nandconfigPath), "%s:/sneek/vwiincfg.bin", DeviceHandler::GetDevicePrefix(nandpath)); + +#ifdef DEBUG + gprintf("nandconfigPath : %s\n", nandconfigPath); +#endif + + // create the file if it doesn't exist + if(!CheckFile(nandconfigPath) || FileSize(nandconfigPath) < NANDCONFIG_HEADER_SIZE+1) + { + u8* nandConfigHeader[NANDCONFIG_HEADER_SIZE]; + memset(nandConfigHeader, 0, NANDCONFIG_HEADER_SIZE); + + f = fopen(nandconfigPath, "wb"); + if(!f) + { + gprintf("Failed creating file %s.\n", nandconfigPath); + return -1; + } + + // create an empty header with 0 NAND + fwrite(nandConfigHeader, 1, NANDCONFIG_HEADER_SIZE, f); + fclose(f); + } + + f = fopen(nandconfigPath, "rb"); + if(!f) + { + gprintf("Failed loading file %s.\n", nandconfigPath); + return -1; + } + + fseek(f , 0 , SEEK_END); + u32 filesize = ftell(f); + rewind(f); + + /* Allocate memory */ + NandConfig *nandCfg = (NandConfig *) MEM2_alloc(filesize); + if (!nandCfg) + { + fclose (f); + return -1; + } + + // Read the file + ret = fread (nandCfg, 1, filesize, f); + if(ret != filesize) + { + gprintf("Failed loading file %s to Mem.\n", nandconfigPath); + fclose (f); + MEM2_free(nandCfg); + return -1; + } + +#ifdef DEBUG + hexdump(nandCfg, NANDCONFIG_HEADER_SIZE); +#endif + + // don't parse if wrong file + if(nandCfg->NandCnt > NANDCONFIG_MAXNAND || nandCfg->NandSel > nandCfg->NandCnt) // wrong header, delete file. + { + fclose(f); + MEM2_free(nandCfg); + RemoveFile(nandconfigPath); // delete corrupted file. + return -1; + } + +#ifdef DEBUG + // List found nands from the file + gprintf("NandCnt = %d\n", nandCfg->NandCnt); + gprintf("NandSel = %d\n", nandCfg->NandSel); + for( i = 0 ; i < nandCfg->NandCnt ; i++) + { + gprintf("Path %d = %s %s\n", i, &nandCfg->Nands[i], strcmp((const char *)&nandCfg->Nands[i], neekNandPath) == 0 ? "found" : ""); + } +#endif + + for( i = 0 ; i < nandCfg->NandCnt ; i++) + { + if(strcmp((const char *)&nandCfg->Nands[i], neekNandPath) == 0) + { + found = true; + break; + } + } + + if(found) // NAND path already present in nandcfg.bin + { + // set selected nand in header if different + if(nandCfg->NandSel != i) + { + nandCfg->NandSel = i; + nandCfg->Padding1 = i; // same value? + DCFlushRange(nandCfg, NANDCONFIG_HEADER_SIZE); +#ifdef DEBUG + gprintf("new nandCfg->sel = %d", nandCfg->NandSel); + hexdump(nandCfg, NANDCONFIG_HEADER_SIZE); +#endif + freopen(nandconfigPath, "wb", f); + ret = fwrite(nandCfg, sizeof(char), filesize, f); // Write full file + } + } + else // new NAND path to nandcfg.bin + { + NandInfo * newNand = (NandInfo *) MEM2_alloc(sizeof(NandInfo)); + if(newNand) + { + memset(newNand, 0, sizeof(NandInfo)); + snprintf(newNand->Path, sizeof(newNand->Path), neekNandPath); + snprintf(newNand->Name, sizeof(newNand->Name), strlen(neekNandPath) == 0 ? "root" : strrchr(neekNandPath, '/')+1); + snprintf(newNand->DiPath, sizeof(newNand->DiPath), "/sneek"); + DCFlushRange(newNand, sizeof(NandInfo)); +#ifdef DEBUG + gprintf("new nandCfg"); + hexdump(newNand, sizeof(NandInfo)); +#endif + nandCfg->NandCnt++; + nandCfg->NandSel = ++i; + + // prevent NAND selection bigger than number of NANDs. + if(nandCfg->NandSel >= nandCfg->NandCnt) + { + nandCfg->NandSel = nandCfg->NandCnt -1; + i--; + } + + freopen(nandconfigPath, "wb", f); + ret = fwrite(nandCfg, sizeof(char), filesize, f); // Write full file + ret = fwrite(newNand,1,sizeof(NandInfo),f); // append new NANDInfo + if(ret != sizeof(NandInfo)) + gprintf("Writing new NAND info failed\n"); + + MEM2_free(newNand); + } + } + + // verify the header is correctly written + freopen(nandconfigPath, "rb", f); + ret = fread (nandCfg, 1, NANDCONFIG_HEADER_SIZE, f); + if(ret != NANDCONFIG_HEADER_SIZE) + { + gprintf("Failed loading file %s to Mem.\n", nandconfigPath); + fclose (f); + MEM2_free(nandCfg); + return -1; + } + ret = nandCfg->NandSel; + fclose (f); + MEM2_free(nandCfg); +#ifdef DEBUG + gprintf("verify header:\n"); + hexdump(nandCfg, NANDCONFIG_HEADER_SIZE); +#endif + if(ret == i) + return ret ; + + return -1; +}