mirror of
https://github.com/wiidev/usbloadergx.git
synced 2024-11-16 00:15:08 +01:00
e510233154
*Fixed reset of the loader when loading game with IOS reload and disabled WiiTDB titles (Issue 1874) *Added new 'Inherit' or 'Use global' setting for game settings. If that option is set than the global setting is used for that option. (Issue 1842) *Fixed timeout timer on startup to count correctly. (Issue 1907) *Added two new video modes to force progressive video mode, 'FORCE PAL480p' and 'FORCE NTSC480p' (basically the same but oh well) (Issue 1902) *Added the new 'Return to' procedure for the d2x v4 IOS for Test purpose (didn't test it, need feedback on this one). The old method is used if this procedure fails. Please test it on problematic games (e.g. PoP). (Issue 1892)
494 lines
11 KiB
C
494 lines
11 KiB
C
/* mload.c (for PPC) (c) 2009, Hermes
|
|
|
|
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
|
|
*/
|
|
|
|
#include "mload.h"
|
|
|
|
static const char mload_fs[] ATTRIBUTE_ALIGN(32) = "/dev/mload";
|
|
|
|
static s32 mload_fd = -1;
|
|
static s32 hid = -1;
|
|
|
|
/*--------------------------------------------------------------------------------------------------------------*/
|
|
|
|
// to init/test if the device is running
|
|
|
|
int mload_init()
|
|
{
|
|
int n;
|
|
|
|
if (hid < 0) hid = iosCreateHeap(0x800);
|
|
|
|
if (hid < 0)
|
|
{
|
|
if (mload_fd >= 0)
|
|
IOS_Close(mload_fd);
|
|
|
|
mload_fd = -1;
|
|
|
|
return hid;
|
|
}
|
|
|
|
if (mload_fd >= 0)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
for (n = 0;n < 20;n++) // try 5 seconds
|
|
{
|
|
mload_fd = IOS_Open(mload_fs, 0);
|
|
|
|
if (mload_fd >= 0) break;
|
|
|
|
usleep(250*1000);
|
|
}
|
|
|
|
if (mload_fd < 0)
|
|
{
|
|
|
|
if (hid >= 0)
|
|
{
|
|
iosDestroyHeap(hid);
|
|
hid = -1;
|
|
}
|
|
}
|
|
|
|
return mload_fd;
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------------------------------------------*/
|
|
|
|
// to close the device (remember call it when rebooting the IOS!)
|
|
|
|
int mload_close()
|
|
{
|
|
int ret;
|
|
|
|
if (hid >= 0)
|
|
{
|
|
iosDestroyHeap(hid);
|
|
hid = -1;
|
|
}
|
|
|
|
if (mload_fd < 0) return -1;
|
|
|
|
ret = IOS_Close(mload_fd);
|
|
|
|
mload_fd = -1;
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------------------------------------------*/
|
|
|
|
// to get the thread id of mload
|
|
|
|
int mload_get_thread_id()
|
|
{
|
|
int ret;
|
|
|
|
if (mload_init() < 0) return -1;
|
|
|
|
ret = IOS_IoctlvFormat(hid, mload_fd, MLOAD_MLOAD_THREAD_ID, ":");
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------------------------------------------*/
|
|
|
|
// get the base and the size of the memory readable/writable to load modules
|
|
|
|
int mload_get_load_base(u32 *starlet_base, int *size)
|
|
{
|
|
int ret;
|
|
|
|
if (mload_init() < 0) return -1;
|
|
|
|
ret = IOS_IoctlvFormat(hid, mload_fd, MLOAD_GET_LOAD_BASE, ":ii", starlet_base, size);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------------------------------------------*/
|
|
|
|
// load and run a module from starlet (it need to allocate MEM2 to send the elf file)
|
|
// the module must be a elf made with stripios
|
|
|
|
int mload_module(void *addr, int len)
|
|
{
|
|
int ret;
|
|
void *buf = NULL;
|
|
|
|
|
|
if (mload_init() < 0) return -1;
|
|
|
|
if (hid >= 0)
|
|
{
|
|
iosDestroyHeap(hid);
|
|
hid = -1;
|
|
}
|
|
|
|
hid = iosCreateHeap(len + 0x800);
|
|
|
|
if (hid < 0) return hid;
|
|
|
|
buf = iosAlloc(hid, len);
|
|
|
|
if (!buf) {ret = -1;goto out;}
|
|
|
|
|
|
memcpy(buf, addr, len);
|
|
|
|
ret = IOS_IoctlvFormat(hid, mload_fd, MLOAD_LOAD_MODULE, ":d", buf, len);
|
|
|
|
if (ret < 0) goto out;
|
|
|
|
ret = IOS_IoctlvFormat(hid, mload_fd, MLOAD_RUN_MODULE, ":");
|
|
|
|
if (ret < 0) {ret = -666;goto out;}
|
|
|
|
out:
|
|
|
|
if (hid >= 0)
|
|
{
|
|
iosDestroyHeap(hid);
|
|
hid = -1;
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------------------------------------------*/
|
|
|
|
// load a module from the PPC
|
|
// the module must be a elf made with stripios
|
|
|
|
int mload_elf(void *my_elf, data_elf *data_elf)
|
|
{
|
|
int n, m;
|
|
int p;
|
|
u8 *adr;
|
|
u32 elf = (u32) my_elf;
|
|
|
|
if (elf & 3) return -1; // aligned to 4 please!
|
|
|
|
elfheader *head = (void *) elf;
|
|
|
|
elfphentry *entries;
|
|
|
|
if (head->ident0 != 0x7F454C46) return -1;
|
|
|
|
if (head->ident1 != 0x01020161) return -1;
|
|
|
|
if (head->ident2 != 0x01000000) return -1;
|
|
|
|
p = head->phoff;
|
|
|
|
data_elf->start = (void *) head->entry;
|
|
|
|
for (n = 0; n < head->phnum; n++)
|
|
{
|
|
entries = (void *) (elf + p);
|
|
p += sizeof(elfphentry);
|
|
|
|
if (entries->type == 4)
|
|
{
|
|
adr = (void *) (elf + entries->offset);
|
|
|
|
if (getbe32(0) != 0) return -2; // bad info (sure)
|
|
|
|
for (m = 4; m < entries->memsz; m += 8)
|
|
{
|
|
switch (getbe32(m))
|
|
{
|
|
case 0x9:
|
|
data_elf->start = (void *) getbe32(m + 4);
|
|
break;
|
|
case 0x7D:
|
|
data_elf->prio = getbe32(m + 4);
|
|
break;
|
|
case 0x7E:
|
|
data_elf->size_stack = getbe32(m + 4);
|
|
break;
|
|
case 0x7F:
|
|
data_elf->stack = (void *) (getbe32(m + 4));
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
if (entries->type == 1 && entries->memsz != 0 && entries->vaddr != 0)
|
|
{
|
|
|
|
if (mload_memset((void *) entries->vaddr, 0, entries->memsz) < 0) return -1;
|
|
|
|
if (mload_seek(entries->vaddr, SEEK_SET) < 0) return -1;
|
|
|
|
if (mload_write((void *) (elf + entries->offset), entries->filesz) < 0) return -1;
|
|
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------------------------------------------*/
|
|
|
|
// run one thread (you can use to load modules or binary files)
|
|
|
|
int mload_run_thread(void *starlet_addr, void *starlet_top_stack, int stack_size, int priority)
|
|
{
|
|
int ret;
|
|
|
|
|
|
if (mload_init() < 0) return -1;
|
|
|
|
ret = IOS_IoctlvFormat(hid, mload_fd, MLOAD_RUN_THREAD, "iiii:", starlet_addr, starlet_top_stack, stack_size, priority);
|
|
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------------------------------------------*/
|
|
|
|
// stops one starlet thread
|
|
|
|
int mload_stop_thread(int id)
|
|
{
|
|
int ret;
|
|
|
|
if (mload_init() < 0) return -1;
|
|
|
|
ret = IOS_IoctlvFormat(hid, mload_fd, MLOAD_STOP_THREAD, "i:", id);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------------------------------------------*/
|
|
|
|
// continue one stopped starlet thread
|
|
|
|
int mload_continue_thread(int id)
|
|
{
|
|
int ret;
|
|
|
|
if (mload_init() < 0) return -1;
|
|
|
|
ret = IOS_IoctlvFormat(hid, mload_fd, MLOAD_CONTINUE_THREAD, "i:", id);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------------------------------------------*/
|
|
|
|
// fix starlet address to read/write (uses SEEK_SET, etc as mode)
|
|
|
|
int mload_seek(int offset, int mode)
|
|
{
|
|
if (mload_init() < 0) return -1;
|
|
|
|
return IOS_Seek(mload_fd, offset, mode);
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------------------------------------------*/
|
|
|
|
// read bytes from starlet (it update the offset)
|
|
|
|
int mload_read(void* buf, u32 size)
|
|
{
|
|
if (mload_init() < 0) return -1;
|
|
|
|
return IOS_Read(mload_fd, buf, size);
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------------------------------------------*/
|
|
|
|
// write bytes from starlet (it update the offset)
|
|
|
|
int mload_write(const void * buf, u32 size)
|
|
{
|
|
if (mload_init() < 0) return -1;
|
|
|
|
return IOS_Write(mload_fd, buf, size);
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------------------------------------------*/
|
|
|
|
// fill a block (similar to memset)
|
|
|
|
int mload_memset(void *starlet_addr, int set, int len)
|
|
{
|
|
int ret;
|
|
|
|
if (mload_init() < 0) return -1;
|
|
|
|
ret = IOS_IoctlvFormat(hid, mload_fd, MLOAD_MEMSET, "iii:", starlet_addr, set, len);
|
|
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------------------------------------------*/
|
|
|
|
// get the ehci datas ( ehcmodule.elf uses this address)
|
|
|
|
void * mload_get_ehci_data()
|
|
{
|
|
int ret;
|
|
|
|
if (mload_init() < 0) return NULL;
|
|
|
|
ret = IOS_IoctlvFormat(hid, mload_fd, MLOAD_GET_EHCI_DATA, ":");
|
|
|
|
if (ret < 0) return NULL;
|
|
|
|
return (void *) ret;
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------------------------------------------*/
|
|
|
|
// set the dev/es ioctlv in routine
|
|
|
|
int mload_set_ES_ioctlv_vector(void *starlet_addr)
|
|
{
|
|
int ret;
|
|
|
|
if (mload_init() < 0) return -1;
|
|
|
|
ret = IOS_IoctlvFormat(hid, mload_fd, MLOAD_SET_ES_IOCTLV, "i:", starlet_addr);
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
|
|
int mload_getw(const void * addr, u32 *dat)
|
|
{
|
|
int ret;
|
|
|
|
if (mload_init() < 0) return -1;
|
|
|
|
ret = IOS_IoctlvFormat(hid, mload_fd, MLOAD_GETW, "i:i", addr, dat);
|
|
|
|
return ret;
|
|
}
|
|
|
|
int mload_geth(const void * addr, u16 *dat)
|
|
{
|
|
int ret;
|
|
|
|
if (mload_init() < 0) return -1;
|
|
|
|
ret = IOS_IoctlvFormat(hid, mload_fd, MLOAD_GETH, "i:h", addr, dat);
|
|
|
|
return ret;
|
|
}
|
|
|
|
int mload_getb(const void * addr, u8 *dat)
|
|
{
|
|
int ret;
|
|
|
|
if (mload_init() < 0) return -1;
|
|
|
|
ret = IOS_IoctlvFormat(hid, mload_fd, MLOAD_GETB, "i:b", addr, dat);
|
|
|
|
return ret;
|
|
}
|
|
|
|
int mload_setw(const void * addr, u32 dat)
|
|
{
|
|
int ret;
|
|
|
|
if (mload_init() < 0) return -1;
|
|
|
|
ret = IOS_IoctlvFormat(hid, mload_fd, MLOAD_SETW, "ii:", addr, dat);
|
|
|
|
return ret;
|
|
}
|
|
|
|
int mload_seth(const void * addr, u16 dat)
|
|
{
|
|
int ret;
|
|
|
|
if (mload_init() < 0) return -1;
|
|
|
|
ret = IOS_IoctlvFormat(hid, mload_fd, MLOAD_SETH, "ih:", addr, dat);
|
|
|
|
return ret;
|
|
}
|
|
|
|
int mload_setb(const void * addr, u8 dat)
|
|
{
|
|
int ret;
|
|
|
|
if (mload_init() < 0) return -1;
|
|
|
|
ret = IOS_IoctlvFormat(hid, mload_fd, MLOAD_SETB, "ib:", addr, dat);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------------------------------------------*/
|
|
|
|
// to get log buffer
|
|
// this function return the size of the log buffer and prepare it to read with mload_read() the datas
|
|
|
|
int mload_get_log()
|
|
{
|
|
int ret;
|
|
|
|
if (mload_init() < 0) return -1;
|
|
|
|
ret = IOS_IoctlvFormat(hid, mload_fd, MLOAD_GET_LOG, ":");
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
void mload_reset_log()
|
|
{
|
|
if (mload_init() < 0) return ;
|
|
|
|
IOS_IoctlvFormat(hid, mload_fd, MLOAD_RESET_LOG, ":");
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------------------------------------------*/
|
|
|
|
// to get IOS base for dev/es to create the cIOS
|
|
|
|
int mload_get_IOS_base()
|
|
{
|
|
int ret;
|
|
|
|
if (mload_init() < 0) return -1;
|
|
|
|
ret = IOS_IoctlvFormat(hid, mload_fd, MLOAD_GET_IOS_BASE, ":");
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|