/* ------------------------------------------------------------------------
Main thread for the ezbgm module.
After execution, initialize interrupt environment, register command, and
then wait until there is a request from the EE.
------------------------------------------------------------------------ */
int sce_bgm_loop()
{
sceSifQueueData qd;
sceSifServeData sd;
//-- Initialize interrupt environment in advance.
CpuEnableIntr();
EnableIntr( INUM_DMA_4 );
EnableIntr( INUM_DMA_7 );
//--- Register function that is called according to request
sceSifInitRpc(0);
sceSifSetRpcQueue( &qd, GetThreadId() );
sceSifRegisterRpc( &sd, EZBGM_DEV, bgmFunc, (void*)gRpcArg, NULL, NULL, &qd );
PRINTF(("goto bgm cmd loop\n"));
//--- Command-wait loop
sceSifRpcLoop(&qd);
return 0;
}
static int SMapInit ( IPAddr IP, IPAddr NM, IPAddr GW ) {
int i;
iop_sys_clock_t ClockTicks;
dev9IntrDisable ( INTR_BITMSK );
EnableIntr ( IOP_IRQ_DEV9 );
CpuEnableIntr ();
UNKN_1464 = 3;
if ( ( iSendMutex = CreateMutex ( IOP_MUTEX_UNLOCKED ) ) < 0 ) return 0;
if ( ( iSendReqMutex = CreateMutex ( IOP_MUTEX_UNLOCKED ) ) < 0 ) return 0;
if ( !SMap_Init () ) return 0;
for ( i = 2; i < 7; ++i ) dev9RegisterIntrCb ( i, SMapInterrupt );
USec2SysClock ( TIMER_INTERVAL, &ClockTicks );
SetAlarm ( &ClockTicks, Timer, ( void* )ClockTicks.lo );
netif_add ( &NIF, &IP, &NM, &GW, NULL, SMapIFInit, tcpip_input );
netif_set_default ( &NIF );
return 1;
} /* end SMapInit */
s32 SdInit(s32 flag)
{
flag &= 1;
InitSpu2();
InitSpdif();
Reset(flag);
InitVoices();
InitCoreVolume(flag);
EnableIntr(IOP_IRQ_DMA_SPU);
EnableIntr(IOP_IRQ_DMA_SPU2);
EnableIntr(IOP_IRQ_SPU);
return 0;
}
s32 SdInit(s32 flag)
{
flag &= 1;
InitSpu2();
InitSpdif();
Reset(flag);
InitVoices();
InitCoreVolume(flag);
EnableIntr(0x24);
EnableIntr(0x28);
EnableIntr(9);
return 0;
}
VOID main()
{
EnableAllIntrs();
InitSound(TM_TMR1);
SetVector(VC_INT1, Int0Isr);
SetIntrPriority(VC_INT1, IP_LOW);
EnableIntr(VC_INT1);
for (;;) PlayTune(tune, 7);
}
//////////////////////////////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 */
static void read_thread(void *arg)
{
USE_SPD_REGS;
volatile iop_dmac_chan_t *dev9_chan = (volatile iop_dmac_chan_t *)DEV9_DMAC_BASE;
struct eng_args *args = (struct eng_args *)arg;
ata_dma_transfer_t *t = &dma_transfer;
u32 res;
while (1) {
while (SleepThread() || WaitSema(args->semid))
;
ClearEventFlag(args->evflg, 0);
dma_setup(0);
EnableIntr(IOP_IRQ_DMA_DEV9);
}
}
static void write_thread(void *arg)
{
USE_SPD_REGS;
volatile iop_dmac_chan_t *dev9_chan = (volatile iop_dmac_chan_t *)DEV9_DMAC_BASE;
struct eng_args *args = (struct eng_args *)arg;
ata_dma_transfer_t *t = &dma_transfer;
u32 res;
while (1) {
while (SleepThread() || WaitSema(args->semid))
;
ClearEventFlag(args->evflg, 0);
dma_setup(1);
EnableIntr(IOP_IRQ_DMA_DEV9);
/* Initiate the DMA transfer. */
dev9_chan->madr = (u32)dma_buffer;
dev9_chan->bcr = ((t->size / 128) << 16) | 32;
dev9_chan->chcr = 0x01000201;
SPD_REG8(0x4e) = t->command; /* ATA command register. */
SPD_REG8(SPD_R_PIO_DIR) = 1;
SPD_REG8(SPD_R_PIO_DATA) = 0;
SPD_REG8(SPD_R_XFR_CTRL) |= 0x80;
WaitEventFlag(args->evflg, (EF_DMA_DONE|EF_ATA_DONE), 0x11, &res);
SPD_REG8(SPD_R_XFR_CTRL) &= 0x7f;
DisableIntr(IOP_IRQ_DMA_DEV9, NULL);
/* If we got the ATA end signal, force stop the transfer. */
if (res & EF_ATA_DONE)
dma_stop(1);
SignalSema(args->semid);
}
}
/*
* - Register SBUS handler
* - Clear handler table
*/
int sbus_intr_init()
{
int i, state, res = 0;
if (initialized)
return res;
CpuSuspendIntr(&state);
for (i = 0; i < 32; ++i) {
sbus_handler_table[i].handler = NULL;
sbus_handler_table[i].arg = NULL;
}
if (RegisterIntrHandler(IOP_IRQ_SBUS, 1, sbus_dispatch, NULL) < 0) {
res = -SBUS_E_INIT;
goto out;
}
EnableIntr(IOP_IRQ_SBUS);
initialized = 1;
out:
CpuResumeIntr(state);
return res;
}
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;
}
