mini/main.c

224 lines
4.8 KiB
C
Raw Normal View History

2008-12-28 14:35:37 +01:00
#include "types.h"
#include "utils.h"
#include "start.h"
#include "hollywood.h"
#include "sdhc.h"
#include "string.h"
#include "memory.h"
#include "elf.h"
#include "gecko.h"
#include "ff.h"
#include "panic.h"
#include "powerpc_elf.h"
2009-01-08 23:27:22 +01:00
#include "irq.h"
#include "ipc.h"
#include "exception.h"
#include "crypto.h"
#include "nand.h"
#include "boot2.h"
void *vector;
2008-12-28 14:35:37 +01:00
typedef struct {
u32 hdrsize;
u32 loadersize;
u32 elfsize;
u32 argument;
} ioshdr;
2009-01-06 00:13:39 +01:00
u32 match[] = {
0xF7FFFFB8,
0xBC024708,
1,
2,
};
static inline void mem1_poke(u8 *dst, u8 bv)
{
u32 *p = (u32*)(((u32)dst) & ~3);
u32 val = *p;
2009-01-06 00:13:39 +01:00
switch(((u32)dst) & 3) {
case 0:
val = (val & 0x00FFFFFF) | bv << 24;
break;
case 1:
val = (val & 0xFF00FFFF) | bv << 16;
break;
case 2:
val = (val & 0xFFFF00FF) | bv << 8;
break;
case 3:
val = (val & 0xFFFFFF00) | bv;
break;
}
2009-01-06 00:13:39 +01:00
*p = val;
}
2008-12-28 14:35:37 +01:00
2009-01-06 00:13:39 +01:00
void *memcpy_mem1(void *dst, const void *src, size_t n)
{
unsigned char *p;
const unsigned char *q;
for (p = dst, q = src; n; n--) {
mem1_poke(p++, *q++);
}
return dst;
}
static void patch_mem(u8 *offset, u32 size, u64 titleID)
{
while(size>sizeof(match)) {
if(!memcmp(offset, match, sizeof(match))) {
gecko_printf("--> Patching @ %p\n", offset+8);
gecko_printf("--> To TitleID %08x%08x\n", (u32)(titleID>>32), (u32)titleID);
memcpy_mem1(offset+8, &titleID, sizeof(u64));
return;
}
offset++;
size -= 1;
}
}
void boot2_patchelf(u8 *elf, u64 titleID) {
gecko_puts("Patching boot2 ELF...\n");
2008-12-28 14:35:37 +01:00
if(memcmp("\x7F" "ELF\x01\x02\x01\x61\x01",elf,9)) {
2009-01-06 00:13:39 +01:00
gecko_printf("Invalid ELF header! 0x%02x 0x%02x 0x%02x 0x%02x\n",elf[0], elf[1], elf[2], elf[3]);
return;
2008-12-28 14:35:37 +01:00
}
2009-01-06 00:13:39 +01:00
2008-12-28 14:35:37 +01:00
Elf32_Ehdr *ehdr = (Elf32_Ehdr*)elf;
if(ehdr->e_phoff == 0) {
2009-01-06 00:13:39 +01:00
gecko_printf("ELF has no program headers!\n");
return;
2008-12-28 14:35:37 +01:00
}
int count = ehdr->e_phnum;
Elf32_Phdr *phdr = (Elf32_Phdr*)(elf + ehdr->e_phoff);
2009-01-06 00:13:39 +01:00
gecko_printf("PHDRS at %p\n",phdr);
2008-12-28 14:35:37 +01:00
while(count--)
{
if(phdr->p_type != PT_LOAD) {
2009-01-06 00:13:39 +01:00
gecko_printf("Skipping PHDR of type %d\n",phdr->p_type);
2008-12-28 14:35:37 +01:00
} else {
void *src = elf + phdr->p_offset;
2009-01-06 00:13:39 +01:00
gecko_printf("PATCH %p -> %p/%p [0x%x]\n",src, phdr->p_paddr, phdr->p_vaddr, phdr->p_filesz);
if(phdr->p_vaddr == (void*)0x20100000) {
gecko_printf("-> Found ES code PHDR\n");
patch_mem(src, phdr->p_filesz, titleID);
}
2008-12-28 14:35:37 +01:00
}
phdr++;
}
2009-01-06 00:13:39 +01:00
gecko_puts("Done!\n");
2008-12-28 14:35:37 +01:00
}
#define PPC_BOOT_FILE "/system/ppcboot.elf"
FATFS fatfs;
2009-01-06 00:13:39 +01:00
void *patch_boot2(void *base, u64 titleID)
2008-12-28 20:28:33 +01:00
{
ioshdr *hdr = (ioshdr*)base;
ioshdr *parhdr = (ioshdr*)hdr->argument;
u8 *elf;
2009-01-06 00:13:39 +01:00
gecko_puts("Patching BOOT2 for leet hax\n");
2008-12-28 20:28:33 +01:00
gecko_printf("Parent BOOT2 header (@%p):\n",parhdr);
gecko_printf(" Header size: %08x\n", parhdr->hdrsize);
gecko_printf(" Loader size: %08x\n", parhdr->loadersize);
gecko_printf(" ELF size: %08x\n", parhdr->elfsize);
gecko_printf(" Argument: %08x\n", parhdr->argument);
2009-01-06 00:13:39 +01:00
2008-12-28 20:28:33 +01:00
elf = (u8*) parhdr;
elf += parhdr->hdrsize + parhdr->loadersize;
gecko_printf("ELF at %p\n",elf);
2009-01-06 00:13:39 +01:00
boot2_patchelf(elf, titleID);
parhdr->argument = 0x42;
2009-01-06 00:13:39 +01:00
gecko_printf("Vector: %p\n", (void*)(((u32)parhdr) + parhdr->hdrsize));
return (void*)(((u32)parhdr) + parhdr->hdrsize);
2008-12-28 20:28:33 +01:00
}
2008-12-28 14:35:37 +01:00
void *_main(void *base)
{
FRESULT fres;
int res;
2009-01-06 00:13:39 +01:00
gecko_init();
2008-12-28 14:35:37 +01:00
gecko_puts("MiniIOS v0.1 loading\n");
gecko_puts("Initializing exceptions...\n");
exception_initialize();
gecko_puts("Configuring caches and MMU...\n");
mem_initialize();
2009-03-06 05:28:43 +01:00
gecko_printf("IOSflags: %08x %08x %08x\n",
read32(0xffffff00), read32(0xffffff04), read32(0xffffff08));
gecko_printf(" %08x %08x %08x\n",
read32(0xffffff0c), read32(0xffffff10), read32(0xffffff14));
2009-01-08 23:27:22 +01:00
irq_initialize();
irq_enable(IRQ_TIMER);
irq_enable(IRQ_GPIO1B);
irq_enable(IRQ_GPIO1);
irq_enable(IRQ_RESET);
gecko_puts("Interrupts initialized\n");
2009-01-06 00:13:39 +01:00
crypto_initialize();
gecko_puts("crypto support initialized\n");
nand_initialize();
gecko_puts("NAND initialized.\n");
boot2_init();
gecko_puts("Boot2 loaded to memory.\n");
// gecko_printf("boot2_run = %d\n", boot2_run(0x10001, 0x48415858));
// goto end;
gecko_puts("Initializing IPC...\n");
ipc_initialize();
2009-01-06 00:13:39 +01:00
2009-03-06 05:28:51 +01:00
gecko_puts("Initializing SD...\n");
2009-02-02 12:36:46 +01:00
sd_initialize();
gecko_puts("Mounting SD...\n");
fres = f_mount(0, &fatfs);
if(fres != FR_OK) {
gecko_printf("Error %d while trying to mount SD\n", fres);
panic2(0, PANIC_MOUNT);
}
gecko_puts("Trying to boot:" PPC_BOOT_FILE "\n");
2009-01-06 00:13:39 +01:00
2008-12-28 14:35:37 +01:00
res = powerpc_load_file(PPC_BOOT_FILE);
if(res < 0) {
gecko_printf("Failed to boot PPC: %d\n", res);
gecko_puts("Continuing anyway\n");
}
gecko_puts("Going into IPC mainloop...\n");
ipc_process_slow();
gecko_puts("IPC mainloop done!\n");
gecko_puts("Shutting down IPC...\n");
ipc_shutdown();
gecko_puts("Shutting down interrupts...\n");
irq_shutdown();
gecko_puts("Shutting down caches and MMU...\n");
mem_shutdown();
2009-01-06 00:13:39 +01:00
//vector = patch_boot2(base, (((u64)tidh)<<32) | tidl);
end:
2008-12-28 20:28:33 +01:00
gecko_printf("Vectoring to %p...\n",vector);
return vector;
2008-12-28 14:35:37 +01:00
}