int _start(int argc, char *argv[])
{
// install IOP debug system.
if(iop_dbg_install() != 0)
{
//printf("Failed installing IOP debug system!\n");
return(1); // return "non-resident"
}
// register our IRX exports.
if(RegisterLibraryEntries(&_exp_iopdebug) != 0)
{
iop_dbg_remove();
//printf("Error registering library!\n");
return(1);
}
FlushIcache();
FlushDcache();
//printf("IOPDEBUG installed!\n");
return(0); // return "resident"
}
int _start( int argc, char *argv[])
{
printf("USB HDD FileSystem Driver v%d.%d\n", MAJOR_VER, MINOR_VER);
if (RegisterLibraryEntries(&_exp_usbmass) != 0) {
printf("USBHDFSD: Already registered.\n");
return MODULE_NO_RESIDENT_END;
}
// initialize the FAT driver
if(InitFAT() != 0)
{
printf("USBHDFSD: Error initializing FAT driver!\n");
return MODULE_NO_RESIDENT_END;
}
// initialize the USB driver
if(InitUSB() != 0)
{
printf("USBHDFSD: Error initializing USB driver!\n");
return MODULE_NO_RESIDENT_END;
}
// initialize the file system driver
if(InitFS() != 0)
{
printf("USBHDFSD: Error initializing FS driver!\n");
return MODULE_NO_RESIDENT_END;
}
// return resident
return MODULE_RESIDENT_END;
}
//////////////////////////////entrypoint///////////////////////////////
int _start(int argc, char* argv[]){
int x;
register int ch;
if (RegisterLibraryEntries(&dmacman_stub)) //loadcore
return 1;
CpuSuspendIntr(&x); //intrman
dmacSetDPCR(0x07777777);
dmacSetDPCR2(0x07777777);
dmacSetDPCR3(0x00000777);
for (ch=0; ch<13; ch++){
dmacSetD_MADR(ch, 0);
dmacSetD_BCR (ch, 0);
dmacSetD_CHCR(ch, 0);
}
dmacSetD_TADR( DMAch_SPU, 0);
dmacSetD_TADR( DMAch_SIF0,0);
dmacSet_4_9_A( DMAch_SPU, 0);
dmacSet_4_9_A( DMAch_SIF0,0);
dmacSet_4_9_A( DMAch_SIF1,0);
dmacSetBF801578(1);
CpuResumeIntr(x); //intrman
return 0;
}
static inline int InitializeLWIP(void){
sys_sem_t Sema;
int iRet;
dbgprintf("PS2IP: Module Loaded.\n");
if ((iRet=RegisterLibraryEntries(&_exp_ps2ip))!=0)
{
printf("PS2IP: RegisterLibraryEntries returned: %d\n", iRet);
}
RxPBufsFree=LWIP_STACK_MAX_RX_PBUFS;
NetManRxPacketBufferPoolFreeStart=0;
recv_pbuf_queue_start=recv_pbuf_queue_end=NULL;
sys_sem_new(&Sema, 0);
dbgprintf("PS2IP: Calling tcpip_init\n");
tcpip_init(InitDone,&Sema);
sys_arch_sem_wait(&Sema, 0);
sys_sem_free(&Sema);
dbgprintf("PS2IP: tcpip_init called\n");
#if NOSYS
InitTimer();
#endif
dbgprintf("PS2IP: System Initialised\n");
return 0;
}
int _start(int argc, char **argv)
{
iop_sema_t sem_info;
if (RegisterLibraryEntries(&_exp_alloc) != 0)
return 1;
// check arguments for a heap_size parameter.
if (argc > 1) {
heap_size = strtoul(argv[1], NULL, 0);
}
if (!(heap_start = AllocSysMemory(ALLOC_FIRST, heap_size, NULL)))
return -1;
heap_end = heap_start + heap_size;
_heap_ptr = heap_start;
sem_info.attr = 1;
sem_info.option = 1;
sem_info.initial = 1;
sem_info.max = 1;
alloc_sema = CreateSema(&sem_info);
return 0;
}
int _start(int argc, const char **argv)
{
if (RegisterLibraryEntries(&_exp_sbusintr) != 0)
return 1;
return 0;
}
s32 _start(char **argv, int argc)
{
if(RegisterLibraryEntries(&_exp_ds3ps2) != 0) {
//Failed
return 1;
}
UsbRegisterDriver(&driver);
return 0;
}
s32 _start(char **argv, int argc)
{
printf(BANNER, VERSION);
if(RegisterLibraryEntries(&_exp_libsd) != 0) return 1;
InitSpu2();
return 0;
}
//////////////////////////////entrypoint///////////////////////////////
int _start(int argc, char* argv[]){
int x;
CpuSuspendIntr(&x);
if (RegisterLibraryEntries(&export_stub)==0) {
CpuResumeIntr(x);
return 0;
}
CpuResumeIntr(x);
return 1;
}
//////////////////////////////entrypoint///////////////////////////////[00]
int _start(){
register int *v, i;
_dprintf("%s\n", __FUNCTION__);
if (v=QueryBootMode(3)){
_dprintf("bootmode: %x\n", v[1]);
if (v[1] & 1){ printf("%s No SIF service(sifcmd)\n", __FUNCTION__);return 1;}
if (v[1] & 2){ printf("%s No SIFCMD/RPC service\n", __FUNCTION__); return 1;}
}
if (SifCheckInit()==0)
SifInit();
if (RegisterLibraryEntries(&sifcmd_stub)) return 1;
cmd_common.sif1_rcvBuffer=sif1_rcvBuffer;
cmd_common.b=b;
cmd_common.sysCmdBuffer=sysCmds;
cmd_common.sysCmdBufferSize=32;
cmd_common.saddr=0;
cmd_common.cmdBuffer=0;
cmd_common.cmdBufferSize=0;
cmd_common.Sreg=Sreg;
cmd_common.func=0;
cmd_common.param=0;
for (i=0; i<32; i++) {
sysCmds[i].func=0;
sysCmds[i].data=0;
}
for (i=0; i<32; i++) {
Sreg[i]=0;
}
sysCmds[0].func=(cmdh_func)cmd80000000_CHANGE_SADDR;
sysCmds[0].data=&cmd_common;
sysCmds[1].func=(cmdh_func)cmd80000001_SET_SREG;
sysCmds[1].data=&cmd_common;
cmd_common.systemStatusFlag=GetSystemStatusFlag();
sysCmds[2].func=(cmdh_func)cmd80000002_INIT_CMD;
sysCmds[2].data=&cmd_common;
RegisterIntrHandler(INT_DMA10, 1, SIF1_handler, (void*)&cmd_common);
EnableIntr(INT_DMA10 | IMODE_DMA_IQE);
SifSetIOPrcvaddr((u32)sif1_rcvBuffer);
return 0;
}
int _start ( int argc, const char** argv ) {
int retVal = MODULE_NO_RESIDENT_END;
if ( RegisterLibraryEntries ( &_exp_sio2man ) == 0 ) {
int lState;
int lThreadID;
iop_thread_t lThread;
iop_event_t lEvent;
lEvent.attr = 2;
lEvent.bits = 0;
s_EventFlag = CreateEventFlag ( &lEvent );
lThread.attr = TH_C;
lThread.thread = _MainThread;
lThread.stacksize = 0x2000;
lThread.priority = 24;
lThreadID = CreateThread ( &lThread );
s_Callback0 = NULL;
s_Callback1 = NULL;
s_Callback2 = NULL;
s_Callback3 = NULL;
SIO2_SetCtrl3BC ();
CpuSuspendIntr ( &lState );
RegisterIntrHandler ( IOP_IRQ_SIO2, 1, _IntHandler, &s_EventFlag );
EnableIntr ( IOP_IRQ_SIO2 );
CpuResumeIntr ( lState );
dmac_ch_set_dpcr ( IOP_DMAC_SIO2in, 3 );
dmac_ch_set_dpcr ( IOP_DMAC_SIO2out, 3 );
dmac_enable ( IOP_DMAC_SIO2in );
dmac_enable ( IOP_DMAC_SIO2out );
StartThread ( lThreadID, NULL );
retVal = MODULE_RESIDENT_END;
} /* end if */
return retVal;
} /* end _start */
int _start(int argc, char **argv)
{
if(RegisterLibraryEntries(&_exp_iomanx) != 0)
{
return 1;
}
memset(dev_list, 0, sizeof(dev_list));
memset(file_table, 0, sizeof(file_table));
if(hook_ioman() != 0)
{
return 1;
}
return 0;
}
int _start(int argc, char *argv[]){
iop_sema_t sema;
if(RegisterLibraryEntries(&_exp_netman) == 0){
sema.attr = 0;
sema.option = 0;
sema.initial = 1;
sema.max = 1;
NetManIOSemaID = CreateSema(&sema);
NetmanInitRPCServer();
return MODULE_RESIDENT_END;
}
return MODULE_NO_RESIDENT_END;
}
//-------------------------------------------------------------------------
int _start(int argc, char** argv)
{
iop_thread_t thread_param;
RegisterLibraryEntries(&_exp_cdvdfsv);
FlushDcache();
CpuEnableIntr();
thread_param.attr = TH_C;
thread_param.option = 0;
thread_param.thread = (void *)init_thread;
thread_param.stacksize = 0x800;
thread_param.priority = 0x50;
init_thread_id = CreateThread(&thread_param);
StartThread(init_thread_id, 0);
return MODULE_RESIDENT_END;
}
int _start(int argc, char **argv)
{
int rv;
if(RegisterLibraryEntries(&_exp_ioptrap) != 0) return 1;
memset(handlers, 0, sizeof(trap_exception_handler_t) * 16);
printf("ioptrap starts.\n");
if((rv = RegisterDefaultExceptionHandler(def_exc_handler)) < 0) {
printf("RegisterDefaultExceptionHandler failed, rv=%d\n", rv);
return 1;
}
if((rv = RegisterPriorityExceptionHandler(IOP_EXCEPTION_HDB, 0, bp_exc_handler)) < 0) {
// shouldn't we release the default exception handler here... ?
printf("RegisterDefaultExceptionHandler failed, rv=%d\n", rv);
return 1;
}
do_tests();
return 0;
}
/** Main start function of the module
@param argc: Unused
@param argv: Unused
@returns 0 on success, -1 on error
*/
int _start(int argc, char **argv)
{
int res = 1;
printf(BANNER, VERSION);
if ((res = RegisterLibraryEntries(&_exp_devfs)) != 0) {
M_PRINTF("Library is already registered, exiting.\n");
printf("res=%d\n", res);
}
else
{
res = init_devfs();
}
M_PRINTF("devfs_device_t size=%d\n", sizeof(devfs_device_t));
M_PRINTF("Driver loaded.\n");
return res;
}
int _start(int argc, char* argv[])
{
printf("Block Device Manager (BDM) v%d.%d\n", MAJOR_VER, MINOR_VER);
if (RegisterLibraryEntries(&_exp_bdm) != 0) {
M_PRINTF("ERROR: Already registered!\n");
return MODULE_NO_RESIDENT_END;
}
// initialize the block device manager
if (bdm_init() < 0) {
M_PRINTF("ERROR: BDM init failed!\n");
return MODULE_NO_RESIDENT_END;
}
// initialize the partition driver
part_init();
// return resident
return MODULE_RESIDENT_END;
}
int
_start(int argc,char** argv)
{
sys_sem_t Sema;
int iRet;
dbgprintf("PS2IP: Module Loaded.\n");
if ((iRet=RegisterLibraryEntries(&_exp_ps2ip))!=0)
{
printf("PS2IP: RegisterLibraryEntries returned: %d\n",iRet);
}
sys_init();
mem_init();
memp_init();
pbuf_init();
dbgprintf("PS2IP: sys_init, mem_init, memp_init, pbuf_init called\n");
netif_init();
dbgprintf("PS2IP: netif_init called\n");
Sema=sys_sem_new(0);
dbgprintf("PS2IP: Calling tcpip_init\n");
tcpip_init(InitDone,&Sema);
sys_arch_sem_wait(Sema,0);
sys_sem_free(Sema);
dbgprintf("PS2IP: tcpip_init called\n");
AddLoopIF();
InitTimer();
dbgprintf("PS2IP: System Initialised\n");
return iRet;
}
int _start(int argc, const char **argv)
{
int state;
shutdown();
if (RegisterLibraryEntries(&_exp_sio2man) != 0)
return 1;
if (init)
return 1;
init = 1;
sio2_ctrl_set(0x3bc);
cb1 = NULL; cb2 = NULL; cb3 = NULL; cb4 = NULL;
event_flag = create_event_flag();
thid = create_main_thread();
CpuSuspendIntr(&state);
RegisterIntrHandler(IOP_IRQ_SIO2, 1, sio2_intr_handler, &event_flag);
EnableIntr(IOP_IRQ_SIO2);
CpuResumeIntr(state);
dmac_ch_set_dpcr(IOP_DMAC_SIO2in, 3);
dmac_ch_set_dpcr(IOP_DMAC_SIO2out, 3);
dmac_enable(IOP_DMAC_SIO2in);
dmac_enable(IOP_DMAC_SIO2out);
StartThread(thid, NULL);
#ifndef XSIO2MAN
EPRINTF("Logging started.\n");
#endif
return 0;
}
int _start(int argc, char **argv)
{
u32 state;
if (RegisterLibraryEntries(&_exp_siftoo) != 0)
return 1;
/* Add our SBUS interrupt handler. */
if (sbus_intr_init() < 0) {
printf("Unable to initialize SBUS interrupt driver, exiting.\n");
return 1;
}
if (sbus_intr_handler_add(SIF2_SBUS_IRQ, sif2_control, NULL) < 0) {
printf("Unable to register SIFToo Control handler, exiting.\n");
return 1;
}
CpuSuspendIntr((int *)&state);
sceSifDma2Init();
CpuResumeIntr(state);
return 0;
}
//--------------------------------------------------------------
int _start(int argc, const char **argv)
{
iop_thread_t thread_param;
register int thread_id;
iop_library_t *libptr;
int i, mcman_loaded;
void **export_tab;
#ifdef SIO_DEBUG
sio_init(38400, 0, 0, 0, 0);
#endif
#ifdef DEBUG
DPRINTF("mcserv: _start...\n");
#endif
// Get mcman lib ptr
mcman_loaded = 0;
libptr = GetLoadcoreInternalData()->let_next;
while (libptr != 0) {
for (i=0; i<8; i++) {
if (libptr->name[i] != mcman_modname[i])
break;
}
if (i == 8) {
mcman_loaded = 1;
break;
}
libptr = libptr->prev;
}
if (!mcman_loaded) {
#ifdef DEBUG
DPRINTF("mcserv: mcman module is not loaded...\n");
#endif
goto err_out;
}
#ifdef DEBUG
DPRINTF("mcserv: mcman version=%03x\n", libptr->version);
#endif
if (libptr->version > 0x200)
mcman_type = XMCMAN;
// Get mcman export table
export_tab = (void **)(((struct irx_export_table *)libptr)->fptrs);
// Set functions pointers to match MCMAN exports
McDetectCard = export_tab[5];
McOpen = export_tab[6];
McClose = export_tab[7];
McRead = export_tab[8];
McWrite = export_tab[9];
McSeek = export_tab[10];
McFormat = export_tab[11];
McGetDir = export_tab[12];
McDelete = export_tab[13];
McFlush = export_tab[14];
McChDir = export_tab[15];
McSetFileInfo = export_tab[16];
McEraseBlock = export_tab[17];
McReadPage = export_tab[18];
McWritePage = export_tab[19];
McDataChecksum = export_tab[20];
McReplaceBadBlock = export_tab[24]; // dummy in MCMAN !!!
McReadPS1PDACard = export_tab[29];
McWritePS1PDACard = export_tab[30];
McUnformat = export_tab[36];
McRetOnly = export_tab[37];
McGetFreeClusters = export_tab[38];
McGetMcType = export_tab[39];
McSetPS1CardFlag = export_tab[40];
// Set functions pointers to match XMCMAN exports if needed
if (mcman_type == XMCMAN) {
McDetectCard2 = export_tab[21];
McGetFormat = export_tab[22];
McGetEntSpace = export_tab[23];
McGetModuleInfo = export_tab[42];
McCheckBlock = export_tab[45];
}
// Register mcserv dummy export table
#ifdef DEBUG
DPRINTF("mcserv: registering exports...\n");
#endif
if (RegisterLibraryEntries(&_exp_mcserv) != 0)
goto err_out;
CpuEnableIntr();
#ifdef DEBUG
DPRINTF("mcserv: starting RPC thread...\n");
#endif
thread_param.attr = TH_C;
thread_param.thread = (void *)thread_rpc_S_0400;
thread_param.priority = 0x68;
thread_param.stacksize = 0x1000;
thread_param.option = 0;
thread_id = CreateThread(&thread_param);
mcserv_tidS_0400 = thread_id;
StartThread(thread_id, 0);
#ifdef DEBUG
DPRINTF("mcserv: _start returns MODULE_RESIDENT_END...\n");
#endif
return MODULE_RESIDENT_END;
err_out:
#ifdef DEBUG
DPRINTF("mcserv: _start returns MODULE_NO_RESIDENT_END...\n");
#endif
return MODULE_NO_RESIDENT_END;
}
s32 _start(char **argv, int argc)
{
iop_event_t event;
iop_thread_t thread;
u32 i;
printf(BANNER,VERSION);
if(RegisterLibraryEntries(&_exp_mtapman) != 0)
{
M_PRINTF("RegisterLibraryEntries failed.\n");
return 1;
}
if(InitRpcServers() == 0)
{
M_PRINTF("Failed to setup RPC Servers.\n");
return 1;
}
event.attr = 2;
event.bits = 0;
event_flag = CreateEventFlag(&event);
if(event_flag < 0)
{
M_PRINTF("Could not create event flag (%i)\n.", (int)event_flag);
return 1;
}
thread.attr = TH_C;
thread.thread = update_slot_numbers_thread;
thread.stacksize = 0x800;
thread.priority = 32;
threadid_main = CreateThread(&thread);
if(threadid_main < 0)
{
M_PRINTF("Could not create thread (%i)\n.", (int)threadid_main);
return 1;
}
StartThread(threadid_main, 0);
for(i=0; i < 4; i++)
{
state_open[i] = 0;
state_getcon[i] = 0;
state_slots[i] = 0;
}
sio2_mtap_change_slot_set(change_slot);
sio2_mtap_get_slot_max_set(get_slots1);
sio2_mtap_get_slot_max_set2(get_slots2);
sio2_mtap_update_slots_set(update_slot_numbers);
td.in = in_buffer;
td.out = out_buffer;
return 0;
}
