void ARQ_RemoveRequest(ARQRequest *req)
{
u32 level;
_CPU_ISR_Disable(level);
__lwp_queue_extractI(&req->node);
if(__ARQReqPendingLo && __ARQReqPendingLo==req && __ARQCallbackLo==NULL) __ARQReqPendingLo = NULL;
_CPU_ISR_Restore(level);
}
void DSP_Halt()
{
u32 level,old;
_CPU_ISR_Disable(level);
old = _dspReg[5];
_dspReg[5] = (old&~(DSPCR_AIINT|DSPCR_ARINT|DSPCR_DSPINT))|DSPCR_HALT;
_CPU_ISR_Restore(level);
}
static s32 __exi_probe(s32 nChn)
{
u64 time;
s32 ret = 1;
u32 level;
u32 val;
exibus_priv *exi = &eximap[nChn];
#ifdef _EXI_DEBUG
printf("__exi_probe(%d)\n",nChn);
#endif
_CPU_ISR_Disable(level);
val = _exiReg[nChn*5];
if(!(exi->flags&EXI_FLAG_ATTACH)) {
if(val&EXI_EXT_IRQ) {
__exi_clearirqs(nChn,0,0,1);
exi->exi_idtime = 0;
last_exi_idtime[nChn] = 0;
}
if(_exiReg[nChn*5]&EXI_EXT_BIT) {
time = gettime();
if(last_exi_idtime[nChn]==0) last_exi_idtime[nChn] = time;
if((val=diff_usec(last_exi_idtime[nChn],time)+10)<30) ret = 0;
else ret = 1;
#ifdef _EXI_DEBUG
printf("val = %u, ret = %d, last_exi_idtime[chn] = %llu\n",val,ret,last_exi_idtime[nChn]);
#endif
_CPU_ISR_Restore(level);
return ret;
} else {
exi->exi_idtime = 0;
last_exi_idtime[nChn] = 0;
_CPU_ISR_Restore(level);
return 0;
}
}
if(!(_exiReg[nChn*5]&EXI_EXT_BIT) || (_exiReg[nChn*5]&EXI_EXT_IRQ)) {
exi->exi_idtime = 0;
last_exi_idtime[nChn] = 0;
ret = 0;
}
_CPU_ISR_Restore(level);
return ret;
}
void DSP_Reset()
{
u16 old;
u32 level;
_CPU_ISR_Disable(level);
old = _dspReg[5];
_dspReg[5] = (old&~(DSPCR_AIINT|DSPCR_ARINT|DSPCR_DSPINT))|(DSPCR_DSPRESET|DSPCR_RES);
_CPU_ISR_Restore(level);
}
void DSP_AssertInt()
{
u32 level;
#ifdef _DSP_DEBUG
printf("DSP_AssertInt()\n");
#endif
_CPU_ISR_Disable(level);
_dspReg[5] = (_dspReg[5]&~(DSPCR_AIINT|DSPCR_ARINT|DSPCR_DSPINT))|DSPCR_PIINT;
_CPU_ISR_Restore(level);
}
void RealDSP::Init()
{
_dspReg[5] = (_dspReg[5] & ~(DSPCR_AIINT|DSPCR_ARINT|DSPCR_DSPINT)) | DSPCR_DSPRESET;
_dspReg[5] = (_dspReg[5] & ~(DSPCR_HALT|DSPCR_AIINT|DSPCR_ARINT|DSPCR_DSPINT));
u32 level;
_CPU_ISR_Disable(level);
IRQ_Request(IRQ_DSP_DSP, dsp_irq_handler, nullptr);
_CPU_ISR_Restore(level);
}
ARCallback AR_RegisterCallback(ARCallback callback)
{
u32 level;
ARCallback old;
_CPU_ISR_Disable(level);
old = __ARDmaCallback;
__ARDmaCallback = callback;
_CPU_ISR_Restore(level);
return old;
}
static __inline__ void __usbgecko_exi_wait(s32 chn)
{
u32 level;
_CPU_ISR_Disable(level);
if(!usbgecko_inited) __usbgecko_init();
while(EXI_Lock(chn,EXI_DEVICE_0,__usbgecko_exi_unlock)==0) {
LWP_ThreadSleep(wait_exi_queue[chn]);
}
_CPU_ISR_Restore(level);
}
void ARQ_FlushQueue()
{
u32 level;
_CPU_ISR_Disable(level);
__lwp_queue_init_empty(&__ARQReqQueueLo);
__lwp_queue_init_empty(&__ARQReqQueueHi);
if(!__ARQCallbackLo) __ARQReqPendingLo = NULL;
_CPU_ISR_Restore(level);
}
void ARQ_PostRequest(ARQRequest *req,u32 owner,u32 dir,u32 prio,u32 aram_addr,u32 mram_addr,u32 len)
{
u32 level;
ARQ_PostRequestAsync(req,owner,dir,prio,aram_addr,mram_addr,len,__ARQCallbackSync);
_CPU_ISR_Disable(level);
while(req->state!=ARQ_TASK_FINISHED) {
LWP_ThreadSleep(__ARQSyncQueue);
}
_CPU_ISR_Restore(level);
}
u32 InitMem2Manager ()
{
int size = (10*1024*1024);
u32 level;
_CPU_ISR_Disable(level);
size &= ~0x1f; // round down, because otherwise we may exceed the area
void *mem2_heap_ptr = (void *)((u32)SYS_GetArena2Hi()-size);
SYS_SetArena2Hi(mem2_heap_ptr);
_CPU_ISR_Restore(level);
size = __lwp_heap_init(&mem2_heap, mem2_heap_ptr, size, 32);
return size;
}
void LCAllocNoInvalidate(void *addr,u32 bytes)
{
u32 level,cnt,hid2;
cnt = bytes>>5;
hid2 = mfspr(920);
if(!(hid2&0x10000000)) {
_CPU_ISR_Disable(level);
__LCEnable();
_CPU_ISR_Restore(level);
}
LCAllocTags(FALSE,addr,cnt);
}
s32 USBStorage_Initialize()
{
u32 level;
if(__inited)
return IPC_OK;
_CPU_ISR_Disable(level);
LWP_InitQueue(&__usbstorage_waitq);
if(!arena_ptr) {
arena_ptr = (u8*)ROUNDDOWN32(((u32)SYS_GetArena2Hi() - HEAP_SIZE));
if((u32)arena_ptr < (u32)SYS_GetArena2Lo()) {
_CPU_ISR_Restore(level);
return IPC_ENOMEM;
}
SYS_SetArena2Hi(arena_ptr);
}
__lwp_heap_init(&__heap, arena_ptr, HEAP_SIZE, 32);
__inited = true;
_CPU_ISR_Restore(level);
return IPC_OK;
}
u32 mem2_getblocksize (void *ptr)
{
heap_block *block;
u32 dsize,level;
_CPU_ISR_Disable(level);
u32 offset = *(((u32*)ptr)-1);
block = __lwp_heap_blockat(ptr,-offset+-HEAP_BLOCK_USED_OVERHEAD);
dsize = block->front_flag&~HEAP_BLOCK_USED;
_CPU_ISR_Restore(level);
return dsize;
}
u32 AR_Free(u32 *len)
{
u32 level;
_CPU_ISR_Disable(level);
__ARBlockLen--;
if(len) *len = *__ARBlockLen;
__ARStackPointer -= *__ARBlockLen;
__ARFreeBlocks++;
_CPU_ISR_Restore(level);
return __ARStackPointer;
}
bool BootExecFile (void)
{
green_fix ();
/* cleaning up and load dol */
SYS_ResetSystem(SYS_SHUTDOWN, 0, 0);
_CPU_ISR_Disable (cookie);
__exception_closeall ();
exeEntryPoint ();
_CPU_ISR_Restore (cookie);
return true;
}
u32 AR_Alloc(u32 len)
{
u32 level;
u32 curraddr;
_CPU_ISR_Disable(level);
curraddr = __ARStackPointer;
__ARStackPointer += len;
*__ARBlockLen++ = len;
__ARFreeBlocks--;
_CPU_ISR_Restore(level);
return curraddr;
}
void* btmemr_malloc(u32 size)
{
u32 level;
u32 ptr,ptr2;
struct mem *rmem,*rmem2;
if(size==0) return NULL;
if(size%MEM_ALIGNMENT) size += MEM_ALIGNMENT - ((size+SIZEOF_STRUCT_MEM)%SIZEOF_STRUCT_MEM);
if(size>MEM_SIZE) return NULL;
_CPU_ISR_Disable(level);
for(ptr = (u8_t*)ram_free - ram_block;ptr<MEM_SIZE;ptr=((struct mem*)&ram_block[ptr])->next) {
rmem = (struct mem*)&ram_block[ptr];
if(!rmem->used && rmem->next - (ptr + SIZEOF_STRUCT_MEM)>=size + SIZEOF_STRUCT_MEM) {
ptr2 = ptr + SIZEOF_STRUCT_MEM + size;
rmem2 = (struct mem*)&ram_block[ptr2];
rmem2->prev = ptr;
rmem2->next = rmem->next;
rmem->next = ptr2;
if(rmem->next!=MEM_SIZE) ((struct mem*)&ram_block[rmem2->next])->prev = ptr2;
rmem2->used = 0;
rmem->used = 1;
if(rmem==ram_free) {
while(ram_free->used && ram_free!=ram_end) ram_free = (struct mem*)&ram_block[ram_free->next];
}
_CPU_ISR_Restore(level);
return (u8_t*)rmem+SIZEOF_STRUCT_MEM;
}
}
_CPU_ISR_Restore(level);
return NULL;
}
void InitMem2Manager()
{
int size = (32*1024*1024)+(256*1024)+32;
u32 level;
_CPU_ISR_Disable(level);
mem2_ptr = (u8*)((u32)SYS_GetArena2Hi()-size);
SYS_SetArena2Hi(mem2_ptr);
_CPU_ISR_Restore(level);
mem2_size = size;
Mem2ManagerReset();
#ifdef WII_NETTRACE
net_print_string( NULL, 0, "InitMem2Manager: %d, %u\n", mem2_size, mem2_ptr );
#endif
}
dsptask_t* DSP_AddTask(dsptask_t *task)
{
u32 level;
#ifdef _DSP_DEBUG
printf("DSP_AddTask(%p)\n",task);
#endif
_CPU_ISR_Disable(level);
__dsp_inserttask(task);
task->state = DSPTASK_INIT;
task->flags = DSPTASK_ATTACH;
_CPU_ISR_Restore(level);
if(__dsp_firsttask==task) __dsp_boottask(task);
return task;
}
void __console_init_ex(void *conbuffer,int tgt_xstart,int tgt_ystart,int tgt_stride,int con_xres,int con_yres,int con_stride)
{
unsigned int level;
console_data_s *con = &stdcon;
_CPU_ISR_Disable(level);
con->destbuffer = conbuffer;
con->target_x = tgt_xstart;
con->target_y = tgt_ystart;
con->con_xres = con_xres;
con->con_yres = con_yres;
con->tgt_stride = tgt_stride;
con->con_stride = con_stride;
con->con_cols = con_xres / FONT_XSIZE;
con->con_rows = con_yres / FONT_YSIZE;
con->cursor_row = 0;
con->cursor_col = 0;
con->saved_row = 0;
con->saved_col = 0;
con->font = console_font_8x16;
con->foreground = COLOR_WHITE;
con->background = COLOR_BLACK;
curr_con = con;
if(_bg_buffer) {
_bg_grab();
con->background = _bg_color;
}
__console_clear();
fb_change = 1;
retrace_cnt = 0;
devoptab_list[STD_OUT] = &dotab_stdout;
devoptab_list[STD_ERR] = &dotab_stdout;
VIDEO_SetPostRetraceCallback(__console_vipostcb);
_CPU_ISR_Restore(level);
setvbuf(stdout, NULL , _IONBF, 0);
setvbuf(stderr, NULL , _IONBF, 0);
}
s32 __STM_SetEventHook()
{
s32 ret;
u32 level;
if(__stm_initialized==0) return STM_ENOTINIT;
__stm_ehclear = 0;
_CPU_ISR_Disable(level);
ret = IOS_IoctlAsync(__stm_eh_fd,IOCTL_STM_EVENTHOOK,__stm_ehbufin,0x20,__stm_ehbufout,0x20,__STMEventHandler,NULL);
if(ret<0) __stm_ehregistered = 0;
else __stm_ehregistered = 1;
_CPU_ISR_Restore(level);
return ret;
}
void btmemr_free(void *ptr)
{
u32 level;
struct mem *rmem;
if(ptr==NULL) return;
if((u8_t*)ptr<(u8_t*)ram_block || (u8_t*)ptr>=(u8_t*)ram_end) return;
_CPU_ISR_Disable(level);
rmem = (struct mem*)((u8_t*)ptr - SIZEOF_STRUCT_MEM);
rmem->used = 0;
if(rmem<ram_free) ram_free = rmem;
plug_holes(rmem);
_CPU_ISR_Restore(level);
}
DSPCallback DSP_RegisterCallback(DSPCallback usr_cb)
{
u32 level;
DSPCallback ret;
#ifdef _DSP_DEBUG
printf("DSP_RegisterCallback()\n");
#endif
_CPU_ISR_Disable(level);
ret = __dsp_intcb;
if(usr_cb)
__dsp_intcb = usr_cb;
else
__dsp_intcb = __dsp_def_taskcb;
_CPU_ISR_Restore(level);
return ret;
}
u32 __lwp_sema_surrender(lwp_sema *sema,u32 id)
{
u32 level,ret;
lwp_cntrl *thethread;
ret = LWP_SEMA_SUCCESSFUL;
if((thethread=__lwp_threadqueue_dequeue(&sema->wait_queue))) return ret;
else {
_CPU_ISR_Disable(level);
if(sema->count<=sema->attrs.max_cnt)
++sema->count;
else
ret = LWP_SEMA_MAXCNT_EXCEEDED;
_CPU_ISR_Restore(level);
}
return ret;
}
static __inline__ void __wiiuse_push_command(struct wiimote_t *wm,struct cmd_blk_t *cmd)
{
uint level;
if(!wm || !cmd) return;
cmd->next = NULL;
cmd->state = CMD_READY;
_CPU_ISR_Disable(level);
if(wm->cmd_head==NULL) {
wm->cmd_head = wm->cmd_tail = cmd;
wiiuse_send_next_command(wm);
} else {
wm->cmd_tail->next = cmd;
wm->cmd_tail = cmd;
}
_CPU_ISR_Restore(level);
}
void wii_memstats(void) {
static u32 min_free = UINT_MAX;
static u32 temp_free;
static u32 level;
_CPU_ISR_Disable(level);
#ifdef GAMECUBE
temp_free = (u32) SYS_GetArenaHi() - (u32) SYS_GetArenaLo();
#else
temp_free = (u32) SYS_GetArena1Hi() - (u32) SYS_GetArena1Lo() +
(u32) SYS_GetArena2Hi() - (u32) SYS_GetArena2Lo();
#endif
_CPU_ISR_Restore(level);
if (temp_free < min_free) {
min_free = temp_free;
fprintf(stderr, "free: %8u\n", min_free);
}
}
int BootHomebrewFromMem() {
loadStub();
if (Set_Stub_Split(0x00010001,"UNEO")<0)
Set_Stub_Split(0x00010001,"ULNR");
entrypoint entry;
u32 cpu_isr;
if (!innetbuffer) {
SDCard_deInit();
USBDevice_deInit();
SYS_ResetSystem(SYS_RETURNTOMENU, 0, 0);
}
struct __argv args;
int ret = valid_elf_image(innetbuffer);
if (ret == 1)
entry = (entrypoint) load_elf_image(innetbuffer);
else
entry = (entrypoint) load_dol(innetbuffer, &args);
free(innetbuffer);
if (!entry) {
SDCard_deInit();
SYS_ResetSystem(SYS_RETURNTOMENU, 0, 0);
}
SDCard_deInit();
WPAD_Flush(0);
WPAD_Disconnect(0);
WPAD_Shutdown();
SYS_ResetSystem(SYS_SHUTDOWN, 0, 0);
_CPU_ISR_Disable (cpu_isr);
__exception_closeall();
entry();
_CPU_ISR_Restore (cpu_isr);
return 0;
}
void AR_StartDMA(u32 dir,u32 memaddr,u32 aramaddr,u32 len)
{
u32 level;
_CPU_ISR_Disable(level);
// set main memory address
_dspReg[16] = (_dspReg[16]&~0x03ff)|_SHIFTR(memaddr,16,16);
_dspReg[17] = (_dspReg[17]&~0xffe0)|_SHIFTR(memaddr, 0,16);
// set aram address
_dspReg[18] = (_dspReg[18]&~0x03ff)|_SHIFTR(aramaddr,16,16);
_dspReg[19] = (_dspReg[19]&~0xffe0)|_SHIFTR(aramaddr, 0,16);
// set cntrl bits
_dspReg[20] = (_dspReg[20]&~0x8000)|_SHIFTL(dir,15,1);
_dspReg[20] = (_dspReg[20]&~0x03ff)|_SHIFTR(len,16,16);
_dspReg[21] = (_dspReg[21]&~0xffe0)|_SHIFTR(len, 0,16);
_CPU_ISR_Restore(level);
}
void btmemr_init()
{
u32 level;
struct mem *rmem;
MEMSET(ram_block,0,MEM_SIZE);
_CPU_ISR_Disable(level);
rmem = (struct mem*)ram_block;
rmem->next = MEM_SIZE;
rmem->prev = 0;
rmem->used = 0;
ram_end = (struct mem*)&ram_block[MEM_SIZE];
ram_end->used = 1;
ram_end->prev = MEM_SIZE;
ram_end->next = MEM_SIZE;
ram_free = (struct mem*)ram_block;
_CPU_ISR_Restore(level);
}
