usbloadergx/source/mload/mload.c

596 lines
13 KiB
C
Raw Normal View History

/* mload.c (for PPC) (c) 2009, Hermes
2010-09-24 02:48:03 +02:00
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.
2010-09-24 02:48:03 +02:00
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.
2010-09-24 02:48:03 +02:00
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"
#include "dip_plugin.h"
#include <malloc.h>
#include "gecko.h"
static const char mload_fs[] ATTRIBUTE_ALIGN( 32 ) = "/dev/mload";
//static u32 patch_datas[8] ATTRIBUTE_ALIGN(32);
static s32 mload_fd = -1;
static s32 hid = -1;
//static data_elf my_data_elf;
//static int thread_id = -1;
//void *external_ehcmodule= NULL;
//int size_external_ehcmodule=0;
/*--------------------------------------------------------------------------------------------------------------*/
// to init/test if the device is running
int mload_init()
{
int n;
2010-09-24 02:48:03 +02:00
if (hid < 0) hid = iosCreateHeap(0x800);
2010-09-24 02:48:03 +02:00
if (hid < 0)
{
2010-09-24 02:48:03 +02:00
if (mload_fd >= 0) IOS_Close(mload_fd);
mload_fd = -1;
return hid;
}
2010-09-24 02:48:03 +02:00
if (mload_fd >= 0)
{
return 0;
}
2010-09-24 02:48:03 +02:00
for (n = 0; n < 20; n++) // try 5 seconds
{
2010-09-24 02:48:03 +02:00
mload_fd = IOS_Open(mload_fs, 0);
2010-09-24 02:48:03 +02:00
if (mload_fd >= 0) break;
2010-09-24 02:48:03 +02:00
usleep(250 * 1000);
}
2010-09-24 02:48:03 +02:00
if (mload_fd < 0)
{
2010-09-24 02:48:03 +02:00
if (hid >= 0)
{
2010-09-24 02:48:03 +02:00
iosDestroyHeap(hid);
hid = -1;
}
}
return mload_fd;
}
/*--------------------------------------------------------------------------------------------------------------*/
// to close the device (remember call it when rebooting the IOS!)
int mload_close()
{
int ret;
2010-09-24 02:48:03 +02:00
if (hid >= 0)
{
2010-09-24 02:48:03 +02:00
iosDestroyHeap(hid);
hid = -1;
}
2010-09-24 02:48:03 +02:00
if (mload_fd < 0) return -1;
2010-09-24 02:48:03 +02:00
ret = IOS_Close(mload_fd);
mload_fd = -1;
return ret;
}
/*--------------------------------------------------------------------------------------------------------------*/
// to get the thread id of mload
int mload_get_thread_id()
{
int ret;
2010-09-24 02:48:03 +02:00
if (mload_init() < 0) return -1;
2010-09-24 02:48:03 +02:00
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
2010-09-24 02:48:03 +02:00
int mload_get_load_base(u32 *starlet_base, int *size)
{
int ret;
2010-09-24 02:48:03 +02:00
if (mload_init() < 0) return -1;
2010-09-24 02:48:03 +02:00
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
2010-09-24 02:48:03 +02:00
int mload_module(void *addr, int len)
{
int ret;
void *buf = NULL;
2010-09-24 02:48:03 +02:00
if (mload_init() < 0) return -1;
2010-09-24 02:48:03 +02:00
if (hid >= 0)
{
2010-09-24 02:48:03 +02:00
iosDestroyHeap(hid);
hid = -1;
}
2010-09-24 02:48:03 +02:00
hid = iosCreateHeap(len + 0x800);
2010-09-24 02:48:03 +02:00
if (hid < 0) return hid;
2010-09-24 02:48:03 +02:00
buf = iosAlloc(hid, len);
2010-09-24 02:48:03 +02:00
if (!buf)
{
ret = -1;
goto out;
}
2010-09-24 02:48:03 +02:00
memcpy(buf, addr, len);
2010-09-24 02:48:03 +02:00
ret = IOS_IoctlvFormat(hid, mload_fd, MLOAD_LOAD_MODULE, ":d", buf, len);
2010-09-24 02:48:03 +02:00
if (ret < 0) goto out;
2010-09-24 02:48:03 +02:00
ret = IOS_IoctlvFormat(hid, mload_fd, MLOAD_RUN_MODULE, ":");
2010-09-24 02:48:03 +02:00
if (ret < 0)
{
ret = -666;
goto out;
}
2010-09-24 02:48:03 +02:00
out: if (hid >= 0)
{
2010-09-24 02:48:03 +02:00
iosDestroyHeap(hid);
hid = -1;
}
return ret;
}
/*--------------------------------------------------------------------------------------------------------------*/
// load a module from the PPC
// the module must be a elf made with stripios
2010-09-24 02:48:03 +02:00
int mload_elf(void *my_elf, data_elf *data_elf)
{
int n, m;
int p;
u8 *adr;
2010-09-24 02:48:03 +02:00
u32 elf = (u32) my_elf;
2010-09-24 02:48:03 +02:00
if (elf & 3) return -1; // aligned to 4 please!
2010-09-24 02:48:03 +02:00
elfheader *head = (void *) elf;
elfphentry *entries;
2010-09-24 02:48:03 +02:00
if (head->ident0 != 0x7F454C46) return -1;
if (head->ident1 != 0x01020161) return -1;
if (head->ident2 != 0x01000000) return -1;
p = head->phoff;
2010-09-24 02:48:03 +02:00
data_elf->start = (void *) head->entry;
2010-09-24 02:48:03 +02:00
for (n = 0; n < head->phnum; n++)
{
2010-09-24 02:48:03 +02:00
entries = (void *) (elf + p);
p += sizeof(elfphentry);
2010-09-24 02:48:03 +02:00
if (entries->type == 4)
{
2010-09-24 02:48:03 +02:00
adr = (void *) (elf + entries->offset);
2010-09-24 02:48:03 +02:00
if (getbe32( 0 ) != 0) return -2; // bad info (sure)
2010-09-24 02:48:03 +02:00
for (m = 4; m < entries->memsz; m += 8)
{
2010-09-24 02:48:03 +02:00
switch (getbe32( m ))
{
case 0x9:
2010-09-24 02:48:03 +02:00
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:
2010-09-24 02:48:03 +02:00
data_elf->stack = (void *) (getbe32( m + 4 ));
break;
}
}
}
2010-09-24 02:48:03 +02:00
else if (entries->type == 1 && entries->memsz != 0 && entries->vaddr != 0)
{
2010-09-24 02:48:03 +02:00
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)
2010-09-24 02:48:03 +02:00
int mload_run_thread(void *starlet_addr, void *starlet_top_stack, int stack_size, int priority)
{
int ret;
2010-09-24 02:48:03 +02:00
if (mload_init() < 0) return -1;
2010-09-24 02:48:03 +02:00
ret = IOS_IoctlvFormat(hid, mload_fd, MLOAD_RUN_THREAD, "iiii:", starlet_addr, starlet_top_stack, stack_size,
priority);
return ret;
}
/*--------------------------------------------------------------------------------------------------------------*/
// stops one starlet thread
2010-09-24 02:48:03 +02:00
int mload_stop_thread(int id)
{
int ret;
2010-09-24 02:48:03 +02:00
if (mload_init() < 0) return -1;
2010-09-24 02:48:03 +02:00
ret = IOS_IoctlvFormat(hid, mload_fd, MLOAD_STOP_THREAD, "i:", id);
return ret;
}
/*--------------------------------------------------------------------------------------------------------------*/
// continue one stopped starlet thread
2010-09-24 02:48:03 +02:00
int mload_continue_thread(int id)
{
int ret;
2010-09-24 02:48:03 +02:00
if (mload_init() < 0) return -1;
2010-09-24 02:48:03 +02:00
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)
2010-09-24 02:48:03 +02:00
int mload_seek(int offset, int mode)
{
2010-09-24 02:48:03 +02:00
if (mload_init() < 0) return -1;
2010-09-24 02:48:03 +02:00
return IOS_Seek(mload_fd, offset, mode);
}
/*--------------------------------------------------------------------------------------------------------------*/
// read bytes from starlet (it update the offset)
2010-09-24 02:48:03 +02:00
int mload_read(void* buf, u32 size)
{
2010-09-24 02:48:03 +02:00
if (mload_init() < 0) return -1;
2010-09-24 02:48:03 +02:00
return IOS_Read(mload_fd, buf, size);
}
/*--------------------------------------------------------------------------------------------------------------*/
// write bytes from starlet (it update the offset)
2010-09-24 02:48:03 +02:00
int mload_write(const void * buf, u32 size)
{
2010-09-24 02:48:03 +02:00
if (mload_init() < 0) return -1;
2010-09-24 02:48:03 +02:00
return IOS_Write(mload_fd, buf, size);
}
/*--------------------------------------------------------------------------------------------------------------*/
// fill a block (similar to memset)
2010-09-24 02:48:03 +02:00
int mload_memset(void *starlet_addr, int set, int len)
{
int ret;
2010-09-24 02:48:03 +02:00
if (mload_init() < 0) return -1;
2010-09-24 02:48:03 +02:00
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;
2010-09-24 02:48:03 +02:00
if (mload_init() < 0) return NULL;
2010-09-24 02:48:03 +02:00
ret = IOS_IoctlvFormat(hid, mload_fd, MLOAD_GET_EHCI_DATA, ":");
if (ret < 0) return NULL;
2010-09-24 02:48:03 +02:00
return (void *) ret;
}
/*--------------------------------------------------------------------------------------------------------------*/
// set the dev/es ioctlv in routine
2010-09-24 02:48:03 +02:00
int mload_set_ES_ioctlv_vector(void *starlet_addr)
{
int ret;
2010-09-24 02:48:03 +02:00
if (mload_init() < 0) return -1;
2010-09-24 02:48:03 +02:00
ret = IOS_IoctlvFormat(hid, mload_fd, MLOAD_SET_ES_IOCTLV, "i:", starlet_addr);
return ret;
}
2010-09-24 02:48:03 +02:00
int mload_getw(const void * addr, u32 *dat)
{
int ret;
2010-09-24 02:48:03 +02:00
if (mload_init() < 0) return -1;
2010-09-24 02:48:03 +02:00
ret = IOS_IoctlvFormat(hid, mload_fd, MLOAD_GETW, "i:i", addr, dat);
return ret;
}
2010-09-24 02:48:03 +02:00
int mload_geth(const void * addr, u16 *dat)
{
int ret;
2010-09-24 02:48:03 +02:00
if (mload_init() < 0) return -1;
2010-09-24 02:48:03 +02:00
ret = IOS_IoctlvFormat(hid, mload_fd, MLOAD_GETH, "i:h", addr, dat);
return ret;
}
2010-09-24 02:48:03 +02:00
int mload_getb(const void * addr, u8 *dat)
{
int ret;
2010-09-24 02:48:03 +02:00
if (mload_init() < 0) return -1;
2010-09-24 02:48:03 +02:00
ret = IOS_IoctlvFormat(hid, mload_fd, MLOAD_GETB, "i:b", addr, dat);
return ret;
}
2010-09-24 02:48:03 +02:00
int mload_setw(const void * addr, u32 dat)
{
int ret;
2010-09-24 02:48:03 +02:00
if (mload_init() < 0) return -1;
2010-09-24 02:48:03 +02:00
ret = IOS_IoctlvFormat(hid, mload_fd, MLOAD_SETW, "ii:", addr, dat);
return ret;
}
2010-09-24 02:48:03 +02:00
int mload_seth(const void * addr, u16 dat)
{
int ret;
2010-09-24 02:48:03 +02:00
if (mload_init() < 0) return -1;
2010-09-24 02:48:03 +02:00
ret = IOS_IoctlvFormat(hid, mload_fd, MLOAD_SETH, "ih:", addr, dat);
return ret;
}
2010-09-24 02:48:03 +02:00
int mload_setb(const void * addr, u8 dat)
{
int ret;
2010-09-24 02:48:03 +02:00
if (mload_init() < 0) return -1;
2010-09-24 02:48:03 +02:00
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;
2010-09-24 02:48:03 +02:00
if (mload_init() < 0) return -1;
2010-09-24 02:48:03 +02:00
ret = IOS_IoctlvFormat(hid, mload_fd, MLOAD_GET_LOG, ":");
return ret;
}
/*--------------------------------------------------------------------------------------------------------------*/
// to get IOS base for dev/es to create the cIOS
int mload_get_IOS_base()
{
int ret;
2010-09-24 02:48:03 +02:00
if (mload_init() < 0) return -1;
2010-09-24 02:48:03 +02:00
ret = IOS_IoctlvFormat(hid, mload_fd, MLOAD_GET_IOS_BASE, ":");
return ret;
}
/*
2010-09-24 02:48:03 +02:00
int load_ehc_module()
{
int is_ios=0;
FILE *fp;
if(!external_ehcmodule)
{
fp=fopen("SD:/apps/usbloader_gx/ehcmodule.elf","rb");
if(fp==NULL)
fp=fopen("SD:/apps/usbloadergx/ehcmodule.elf","rb");
if(fp!=NULL)
{
fseek(fp, 0, SEEK_END);
size_external_ehcmodule = ftell(fp);
external_ehcmodule = memalign(32, size_external_ehcmodule);
if(!external_ehcmodule)
{fclose(fp);}
else
{
fseek(fp, 0, SEEK_SET);
if(fread(external_ehcmodule,1, size_external_ehcmodule ,fp)!=size_external_ehcmodule)
{free(external_ehcmodule); external_ehcmodule=NULL;}
fclose(fp);
}
}
}
if(!external_ehcmodule)
{
if(mload_init()<0) return -1;
if (IOS_GetRevision() == 4) {
gprintf("Loading ehcmodule v4\n");
mload_elf((void *) ehcmodule_frag_v4_bin, &my_data_elf);
} else if (IOS_GetRevision() == 0) { // 0? Strange value for v5 ehcmodule
gprintf("Loading ehcmodule v5\n");
mload_elf((void *) ehcmodule_frag_v5_bin, &my_data_elf);
}
thread_id = mload_run_thread(my_data_elf.start, my_data_elf.stack, my_data_elf.size_stack, my_data_elf.prio);
if(thread_id < 0) return -1;
}
else
{
if(mload_init()<0) return -1;
mload_elf((void *) external_ehcmodule, &my_data_elf);
thread_id = mload_run_thread(my_data_elf.start, my_data_elf.stack, my_data_elf.size_stack, my_data_elf.prio);
if(thread_id<0) return -1;
}
usleep(350*1000);
// Test for IOS
mload_seek(0x20207c84, SEEK_SET);
mload_read(patch_datas, 4);
if(patch_datas[0]==0x6e657665)
{
is_ios=38;
}
else
{
is_ios=36;
}
if(is_ios==36)
{
// IOS 36
memcpy(ios_36, dip_plugin, 4); // copy the entry_point
memcpy((void *) dip_plugin, ios_36, 4*10); // copy the adresses from the array
mload_seek(0x1377E000, SEEK_SET); // copy dip_plugin in the starlet
mload_write(dip_plugin,size_dip_plugin);
// enables DIP plugin
mload_seek(0x20209040, SEEK_SET);
mload_write(ios_36, 4);
}
if(is_ios==38)
{
// IOS 38
memcpy(ios_38, dip_plugin, 4); // copy the entry_point
memcpy((void *) dip_plugin, ios_38, 4*10); // copy the adresses from the array
mload_seek(0x1377E000, SEEK_SET); // copy dip_plugin in the starlet
mload_write(dip_plugin,size_dip_plugin);
// enables DIP plugin
mload_seek(0x20208030, SEEK_SET);
mload_write(ios_38, 4);
}
mload_close();
return 0;
}
int patch_cios_data() {
patch_datas[0]=*((u32 *) (dip_plugin+16*4));
mload_set_ES_ioctlv_vector((void *) patch_datas[0]);
return 1;
}
*/