Пример #1
0
Файл: padx.c Проект: jur/ps2sdk
void loadmodules(int free)
{
	s32 ret;
	
	if(free == 1)
	{
		if((ret = SifLoadModule("host0:freesio2.irx", 0, NULL)) < 0)
		{
			printf("Failed to load freesio2.irx module (%d)\n", ret);
			SleepThread();
		}

		if((ret = SifLoadModule("host0:freepad.irx", 0, NULL)) < 0)
		{
			printf("Failed to load freepad.irx module (%d)\n", ret);
			SleepThread();
		}
	}
	else
	{
		if((ret = SifLoadModule("rom0:XSIO2MAN", 0, NULL)) < 0)
		{
			printf("Failed to load XSIO2MAN module (%d)\n", ret);
			SleepThread();
		}
		
		if((ret = SifLoadModule("rom0:XPADMAN", 0, NULL)) < 0)
		{
			printf("Failed to load XPADMAN module (%d)\n", ret);
			SleepThread();
		}
	}	
}
Пример #2
0
static void loadModules(void)
{
    int ret;
#ifdef ROM_PADMAN
    ret = SifLoadModule("rom0:SIO2MAN", 0, NULL);
#else
    ret = SifLoadModule("rom0:XSIO2MAN", 0, NULL);
#endif
    if (ret < 0) {
        SleepThread();
    }
	ret = SifLoadModule("rom0:CDVDMAN", 0, NULL);
	if(ret < 0) {
		SleepThread();
	}

#ifdef ROM_PADMAN
    ret = SifLoadModule("rom0:PADMAN", 0, NULL);
#else
    ret = SifLoadModule("rom0:XPADMAN", 0, NULL);
#endif
    if (ret < 0) {
        SleepThread();
    }
}
Пример #3
0
int main(void)
{
	int ret;
	/* Load LibSD (freesd will work too one day, I promise ;) */
	ret = SifLoadModule("host:LIBSD.IRX", 0, NULL);
	if (ret<0)
	{
		printf("XXXXX failed to load host:LIBSD.IRX (%d)\n", ret);
		SleepThread();
	}

	/* Load ps2snd */
	ret = SifLoadModule("host:ps2snd.irx", 0, NULL);
	if (ret<0)
	{
		printf("XXXXX failed to load host:ps2snd.irx (%d)\n", ret);
		SleepThread();
	}

	/* Start LibSD */
	if (sceSdInit(0)<0)
	{
		printf("Failed to start LibSD\n");
		SleepThread();
	}

	/* Setup master volumes for both cores */
	sceSdSetParam(0 | SD_PARAM_MVOLL, 0x3fff);
	sceSdSetParam(0 | SD_PARAM_MVOLR, 0x3fff);
	sceSdSetParam(1 | SD_PARAM_MVOLL, 0x3fff);
	sceSdSetParam(1 | SD_PARAM_MVOLR, 0x3fff);

	/*
		Open a stream, using voices 0:22 and 0:23
		It's stereo and it should be closed when the end is hit.
		The SPU buffers are at 0x6000 in spu2 ram.
		The chunksize is 1024 blocks (16kbyte)
	*/
	if (sndStreamOpen("host:stream.adpcm", SD_VOICE(0,22) | (SD_VOICE(0,23)<<16), STREAM_STEREO | STREAM_END_CLOSE, 0x6000, 1024)<0)
	{
		printf("Failed to open stream\n");
		SleepThread();
	}


	sndStreamPlay();

	SleepThread();

	return(0);
}
Пример #4
0
// 注册线程
void CDlgAutoRegister::Run()
{	
	ResetEvent(m_hEventTheadNoRun1);
	
	::CoInitialize(NULL);
	int nStart = GetSeconds(m_config.m_startTime);
	int nLast = GetSeconds(m_config.m_endTime);
	while(1)
	{
		int nCurrent = (int)time(NULL);
	//	if (nCurrent > nLast)
	//	{
	//		PostMessage(M_TASK_OVER);
	//		SetEvent(m_hEventTheadNoRun1);
	//		::CoUninitialize();
	//		return;
	//	}
		try
		{
			if (nCurrent >= nStart)
			{
				int n = m_arrayTasks.size();
				for (int i = 0; i < (int)m_arrayTasks.size(); i++)
				{
					TaskNode& task = m_arrayTasks[i];
					//Sleep(task.nDeltaSeconds S);
					SleepThread(task.nDeltaSeconds, 1);

					RegisterID(task);
				}
				::CoUninitialize();
				PostMessage(M_TASK_OVER);
				SetEvent(m_hEventTheadNoRun1);
				return ;
			}
		}
		catch(...)
		{
			IBA_LOG0(_T("出现异常1"));
		}
		

		//Sleep(1 S);
		SleepThread(1,1);
	}
	::CoUninitialize();
	PostMessage(M_TASK_OVER);
	SetEvent(m_hEventTheadNoRun1);
}
Пример #5
0
void ExecGame(void)
{

			int i;

			scr_printf("	Installing Engine...\n");
			u32 EngineStore = 0x80080000;
			u32 EngineRead = (void*)Engine;

			for (i = 0; i < sizeof(Engine); i += 4)
			{
			//scr_printf("A");
			ee_kmode_enter();
			*(u32*)EngineStore = *(u32*)EngineRead;
			ee_kmode_exit();
			EngineStore += 4;
			EngineRead += 4;
			}

			ee_kmode_enter();
			*(u32*)0x80081000 = 0x80081010; //Writes the initial storage of the codes
			ee_kmode_exit();

			waitCdReady();
			scr_printf("	Loading...\n");
			//for (a = 0; a < 40000000; a++)
			{
			}

			if(strlen(bootFileName = parseSystemCnf()) <= 0)
			{
				scr_printf("	== Fatal Error ==\n");
				SleepThread();
			}

			scr_printf("\n	Loaded Game!\n");
			u32 HookValue = (0x00080000 / 4) + 0x0C000000;
			padPortClose(0, 0);
			//scr_printf("	Shut down PAD, shutting down RPC\n	GOODBYE!!!");
			SifExitRpc();
			ee_kmode_enter();
			*(u32*)0x800002FC = HookValue;
			ee_kmode_exit();
			LoadExecPS2((const char *)bootFileName, 0, NULL);

			SleepThread();

}
Пример #6
0
// From PS2DEV.ORG - Thread dispatcher
static void ioThreadDispatcher ( void* apParam ) {
	while ( ! gIOTerminate ) { 
		SleepThread (); 
	}  /* end while */ 
	
	ExitDeleteThread();
}  /* end dispatcher */ 
Пример #7
0
void rmEndFrame(void) {
	gsKit_set_finish(gsGlobal);

	rmFlush();

	// Wait for draw ops to finish
	gsKit_finish();

	if(!gsGlobal->FirstFrame)
	{
		SleepThread();

		if(gsGlobal->DoubleBuffering == GS_SETTING_ON)
		{
			GS_SET_DISPFB2( gsGlobal->ScreenBuffer[gsGlobal->ActiveBuffer & 1] / 8192,
				gsGlobal->Width / 64, gsGlobal->PSM, 0, 0 );

			gsGlobal->ActiveBuffer ^= 1;
			gsGlobal->PrimContext ^= 1;
		}

	}

	gsKit_setactive(gsGlobal);
}
Пример #8
0
void sleep_test()
{
    int i = 0;
    int j = 0;
    int sleep = 0;
    while(1)
    {
        if (sleep == 1)
        {
            printf("WAKING UP\n");
            sleep = 0;
        }
        if (i % 100000000 == 0)
        {
            int id = GetMyId();
            printf("sleep_thread tid: %d j = %d\n", id, j);
            j++;
        }
        if (j == 5)
        {
            j++;
            printf("SLEEP FOR 5 SECONDS (tid: %d)\n", GetMyId());
            sleep = 1;
            SleepThread(5);
        }
        i++;
    }
}
Пример #9
0
static void TxThread(void *arg)
{
	int ThreadToWakeUp;

	while(1)
	{
		SleepThread();

		if(PacketReqs.count > 0)
		{
			while(PacketReqs.count > 0)
			{
				WaitSema(NetManIOSemaID);
				while(SifCallRpc(&NETMAN_rpc_cd, NETMAN_IOP_RPC_FUNC_SEND_PACKETS, 0, &PacketReqs, sizeof(PacketReqs), &ReceiveBuffer, sizeof(ReceiveBuffer.result), &TxEndCallback, NULL) < 0){};
				SignalSema(NetManIOSemaID);
			}
		}
		else
		{
			if(NetmanTxWaitingThread >= 0)
			{
				DI();
				ThreadToWakeUp=NetmanTxWaitingThread;
				NetmanTxWaitingThread=-1;
				EI();
				WakeupThread(ThreadToWakeUp);
			}
		}
	}
}
Пример #10
0
// Wait for a event until the cancel flag becomes true
bool WaitEx(EVENT *e, UINT timeout, volatile bool *cancel)
{
	bool dummy_bool = false;
	UINT64 start, giveup;
	// Validate arguments
	if (cancel == NULL)
	{
		cancel = &dummy_bool;
	}

	start = Tick64();

	if (timeout == INFINITE || timeout == 0x7FFFFFFF)
	{
		giveup = 0;
	}
	else
	{
		giveup = start + (UINT64)timeout;
	}

	while (true)
	{
		UINT64 now = Tick64();
		UINT interval_to_giveup = (UINT)(giveup - now);
		if (giveup == 0)
		{
			interval_to_giveup = INFINITE;
		}
		else
		{
			if (now >= giveup)
			{
				// Time-out occurs
				return false;
			}
		}

		interval_to_giveup = MIN(interval_to_giveup, 25);

		if (*cancel)
		{
			// Cancel flag is set to true. Time-out occurs
			return false;
		}

		if (e != NULL)
		{
			if (Wait(e, interval_to_giveup))
			{
				// Event is set
				return true;
			}
		}
		else
		{
			SleepThread(interval_to_giveup);
		}
	}
}
Пример #11
0
int NetManRpcNetIFSendPacket(const void *packet, unsigned int length){
	struct PacketTag *PacketTag;

	WaitSema(NetManTxSemaID);

	NetmanTxWaitingThread=GetThreadId();

	WaitSema(TxBankAccessSema);

	//Check is there is space in the current Tx FIFO. If not, wait for the Tx thread to empty out the other FIFO. */
	while(CurrentTxFIFOData->PacketReqs.NumPackets>=NETMAN_RPC_BLOCK_SIZE){
		SignalSema(TxBankAccessSema);
		WakeupThread(TxThreadID);
		SleepThread();
		WaitSema(TxBankAccessSema);
	}

	memcpy(&CurrentTxFIFOData->FrameBuffer[CurrentTxFIFOData->PacketReqs.TotalLength], packet, length);
	PacketTag=&CurrentTxFIFOData->PacketReqs.tags[CurrentTxFIFOData->PacketReqs.NumPackets];
	PacketTag->offset=CurrentTxFIFOData->PacketReqs.TotalLength;
	PacketTag->length=length;

	CurrentTxFIFOData->PacketReqs.TotalLength+=(length+3)&~3;
	CurrentTxFIFOData->PacketReqs.NumPackets++;

	WakeupThread(TxThreadID);

	SignalSema(TxBankAccessSema);

	NetmanTxWaitingThread=-1;

	SignalSema(NetManTxSemaID);

	return 0;
}
Пример #12
0
void fileXio_Thread(void* param)
{
	int OldState;

	printf("fileXio: fileXio RPC Server v1.00\nCopyright (c) 2003 adresd\n");
	#ifdef DEBUG
		printf("fileXio: RPC Initialize\n");
	#endif

	SifInitRpc(0);

	RWBufferSize=DEFAULT_RWSIZE;
	CpuSuspendIntr(&OldState);
	rwbuf = AllocSysMemory(ALLOC_FIRST, RWBufferSize, NULL);
	CpuResumeIntr(OldState);
	if (rwbuf == NULL)
	{
		#ifdef DEBUG
  			printf("Failed to allocate memory for RW buffer!\n");
		#endif

		SleepThread();
	}

	SifSetRpcQueue(&qd, GetThreadId());
	SifRegisterRpc(&sd0, FILEXIO_IRX, &fileXio_rpc_server, fileXio_rpc_buffer, NULL, NULL, &qd);
	SifRpcLoop(&qd);
}
Пример #13
0
// WinMain function
int PASCAL WinMain(HINSTANCE hInst, HINSTANCE hPrev, char *CmdLine, int CmdShow)
{
	INSTANCE *instance;
	is_debug = false;
	MayaquaMinimalMode();
	InitMayaqua(false, is_debug, 0, NULL);
	InitCedar();
	ViSetSkip();
	ViLoadStringTables();
	InitWinUi(_U(IDS_TITLE+skip), _A(IDS_FONT+skip), ToInt(_A(IDS_FONT_SIZE+skip)));
	instance = NewSingleInstance(VI_INSTANCE_NAME);
	if (instance == NULL)
	{
		MsgBox(NULL, MB_ICONINFORMATION, _U(IDS_INSTANCE_EXISTS+skip));
	}
	else
	{
		ViMain();
		FreeSingleInstance(instance);
		if (sleep_before_exit)
		{
			SleepThread(60 * 1000);
		}
	}
	FreeWinUi();
	ViFreeStringTables();
	FreeCedar();
	FreeMayaqua();
	return 0;
}
void testcase5_g(void)
{
    int i = 0;

    while (1)
	{
        i++;

        if (i % 10000000 == 0)
		{
            printf("%s: id=%d: Current value i = %d\n", __FUNCTION__, GetMyId(), i);

			if (i == 10000000)
			{
				printf("%s: id=%d: Sleeping thread.\n", __FUNCTION__, GetMyId());
				SleepThread(2000);
			}

			if (i == 90000000)
			{
				printf("%s: id=%d: Deleteing thread 0. Return value = %d\n", __FUNCTION__, GetMyId(), DeleteThread(0));
			}

			if (i == 150000000)
			{
				CleanUp();
			}
        }
    }
}
Пример #15
0
///////////////////////////////////////////////////////////////////////[10]
int SifCallRpc(struct sifcmd_RPC_CLIENT_DATA *client, unsigned int fno, unsigned int mode, void *send, int ssize, void *receive, int rsize, void (*end_func)(void*), void *end_para){
	RPC_PACKET_CALL *packet;

	if ((packet=(RPC_PACKET_CALL *)rpc_get_packet(&rpc_common))==0)
		return -1;
	client->hdr.pkt_addr=(void*)packet;
	client->func   = end_func;
	client->param  = end_para;
	client->hdr.rpc_id= packet->packet.packet.pid;

	packet->packet.packet.paddr  = packet;
	packet->packet.client = client;
	packet->packet.fno    = fno;
	packet->size   = ssize;
	packet->receive= receive;
	packet->rsize  = rsize;
	packet->server = client->server;

	if (mode & 1){
		packet->rmode=(end_func!=0);
		client->hdr.tid=-1;
		if (SifSendCmd(0x8000000A, packet, 0x40, send, client->buff, ssize))
			return 0;
		return -2;
	}else{
		packet->rmode=1;
		client->hdr.tid=GetThreadId();
		if (SifSendCmd(0x8000000A, packet, 0x40, send, client->buff, ssize)==0)
			return -2;
		SleepThread();
		return 0;
	}
}
Пример #16
0
///////////////////////////////////////////////////////////////////////[0F]
int SifBindRpc(struct sifcmd_RPC_CLIENT_DATA *client, unsigned int number, unsigned int mode) {
	RPC_PACKET_BIND *packet;

	client->command=0;
	client->server=0;

	packet = (RPC_PACKET_BIND *)rpc_get_packet(&rpc_common);
	if (packet==NULL) return -1;

	client->hdr.pkt_addr = packet;
	client->hdr.rpc_id   = packet->packet.pid;
	packet->packet.paddr = packet;
	packet->client = client;
	packet->fno    = number;
	
	if (mode & 1==0){
		client->hdr.tid=GetThreadId();
		if (SifSendCmd(0x80000009, packet, 0x40, 0, 0, 0)==0)
			return -2;
		SleepThread();
	}else{		//async
		client->hdr.tid=-1;
		if (SifSendCmd(0x80000009, packet, 0x40, 0, 0, 0)==0)
			return -2;
	}
	return 0;
}
Пример #17
0
///////////////////////////////////////////////////////////////////////[17]
int SifGetOtherData(struct sifcmd_RPC_RECEIVE_DATA *rd, void *src, void *dst, int size, int mode){
	RPC_PACKET_RDATA *packet;

	if ((packet=(RPC_PACKET_RDATA *)rpc_get_packet(&rpc_common))==0)
		return -1;

	rd->hdr.pkt_addr=packet;
	rd->hdr.rpc_id  =packet->packet.pid;
	packet->packet.paddr=packet;
	packet->client=(struct sifcmd_RPC_CLIENT_DATA*)rd;
	packet->src=src;
	packet->dst=dst;
	packet->size=size;

	if (mode & 1==0){
		rd->hdr.tid=GetThreadId();
		if (SifSendCmd(0x8000000C, packet, 0x40, 0, 0, 0)==0)
			return -2;
		SleepThread();
	}else{			//async
		rd->hdr.tid=-1;
		if (SifSendCmd(0x8000000C, packet, 0x40, 0, 0, 0)==0)
			return -2;
	}
	return 0;
}
Пример #18
0
int main(void)
{
	char *ini;

	dma_channel_initialize(DMA_CHANNEL_GIF,NULL,0);
	dma_channel_fast_waits(DMA_CHANNEL_GIF);

	fontx_load("rom0:KROM", &krom_u, SINGLE_BYTE, 2, 1, 1);
	fontx_load("rom0:KROM", &krom_k, DOUBLE_BYTE, 2, 1, 1);

	if((ini = fontstudio_load_ini("host:impress.ini")) != NULL)
	{
		fontstudio_parse_ini(&impress, ini, 512, 256);
		free(ini);

		draw_init_env();

		init_texture();

		run_demo(&packet);

		fontstudio_unload_ini(&impress);

		fontx_unload(&krom_u);
		fontx_unload(&krom_k);
	} else {
		printf("Error: cannot load ini file.\n");
	}

	SleepThread();

	return 0;
}
Пример #19
0
int
main (int argc,
      char *argv [])
{
  SifInitRpc (0);

  init_scr ();
  scr_printf (APP_NAME "-" VERSION "\n");

  /* decide whether to load TCP/IP or it is already loaded */
  SifExitIopHeap ();
  SifLoadFileExit ();
  SifExitRpc ();

  SifIopReset (NULL /* "rom0:UDNL rom0:EELOADCNF" */, 0);
  while (SifIopSync ())
    ;
  SifInitRpc (0);

  if (load_modules () == 0)
    {
      scr_printf ("Ready\n");
    }
  else
    scr_printf ("Failed to load\n");

  /* our job is done; IOP would handle the rest */
  SleepThread ();

  return (0);
}
Пример #20
0
// 消费线程
void CDlgAutoRegister::Run2()
{
	ResetEvent(m_hEventTheadNoRun2);
	::CoInitialize(NULL);

	while(1)
	{
		//Sleep(1 * 60 S); // 5分钟
		SleepThread(5 * 60, 2);
		try
		{
			int nCount = 0;
			m_cs.Lock();
			nCount = (int)m_arrConsumeNode.size();
			m_cs.Unlock();

			if (nCount > 0)
			{
				for (int i = 0; i < nCount; i++)
				{
					m_cs.Lock();
					ConsumeNode& node = m_arrConsumeNode[i];
					m_cs.Unlock();

					if(0 == node.bInvalid)
					{
						::CoInitialize(NULL);
						SendConsumeRecord(node);
						::CoUninitialize();
						m_cs.Lock();
						node.bInvalid = 1;
						m_cs.Unlock();
					}
					SleepThread(1, 2);
				}
			}
		}
		catch(...)
		{
			IBA_LOG0(_T("出现异常2"));
		}
		
	}

	::CoUninitialize();
	SetEvent(m_hEventTheadNoRun2);
}
Пример #21
0
BOOLEAN
DoMenuChooser (MENU_STATE *pMS, BYTE BaseState)
{
	BYTE NewState = pMS->CurState;
	BYTE OrigBase = BaseState;
	BOOLEAN useAltMenu = FALSE;
	if (optWhichMenu == OPT_PC)
		useAltMenu = GetAlternateMenu (&BaseState, &NewState);
	if (PulsedInputState.menu[KEY_MENU_LEFT] ||
			PulsedInputState.menu[KEY_MENU_UP])
		NewState = PreviousMenuState (BaseState, NewState);
	else if (PulsedInputState.menu[KEY_MENU_RIGHT] ||
			PulsedInputState.menu[KEY_MENU_DOWN])
		NewState = NextMenuState (BaseState, NewState);
	else if (useAltMenu && PulsedInputState.menu[KEY_MENU_SELECT])
	{
		NewState = ConvertAlternateMenu (BaseState, NewState);
		if (NewState == ALT_MANIFEST)
		{
			DrawMenuStateStrings (PM_ALT_CARGO, 0);
			pMS->CurState = PM_CARGO - PM_SCAN;
			return TRUE;
		}
		if (NewState == ALT_EXIT_MANIFEST)
		{
			if (OrigBase == PM_SCAN)
				DrawMenuStateStrings (PM_ALT_SCAN,
						PM_ALT_MANIFEST - PM_ALT_SCAN);
			else
				DrawMenuStateStrings (PM_ALT_STARMAP,
						PM_ALT_MANIFEST - PM_ALT_STARMAP);
			pMS->CurState = ALT_MANIFEST;
			return TRUE;
		}
		return FALSE;
	}
	else if ((optWhichMenu == OPT_PC) &&
			PulsedInputState.menu[KEY_MENU_CANCEL] && 
			(BaseState == PM_ALT_CARGO))
	{
		if (OrigBase == PM_SCAN)
			DrawMenuStateStrings (PM_ALT_SCAN,
					PM_ALT_MANIFEST - PM_ALT_SCAN);
		else
			DrawMenuStateStrings (PM_ALT_STARMAP,
					PM_ALT_MANIFEST - PM_ALT_STARMAP);
		pMS->CurState = ALT_MANIFEST;
		return TRUE;
	}
	else
		return FALSE;

	DrawMenuStateStrings (BaseState, NewState);
	if (useAltMenu)
		NewState = ConvertAlternateMenu (BaseState, NewState);
	pMS->CurState = NewState;
	SleepThread (ONE_SECOND / 20);
	return TRUE;
}
Пример #22
0
static void
runCommAnimFrame (void)
{
	LockMutex (GraphicsLock);
	UpdateCommGraphics ();
	UnlockMutex (GraphicsLock);
	SleepThread (COMM_ANIM_RATE);
}
Пример #23
0
static BOOLEAN
DoPopup (struct popup_state *self)
{
	(void)self;
	SleepThread (ONE_SECOND / 20);
	return !(PulsedInputState.menu[KEY_MENU_SELECT] || 
			PulsedInputState.menu[KEY_MENU_CANCEL]);
}
Пример #24
0
static BOOLEAN
DoPopup (struct popup_state *self)
{
	(void)self;
	SleepThread (ONE_SECOND / 20);
	return !(PulsedInputState.menu[KEY_MENU_SELECT] || 
			PulsedInputState.menu[KEY_MENU_CANCEL] ||
			(GLOBAL (CurrentActivity) & CHECK_ABORT));
}
Пример #25
0
void CDlgAutoRegister::Run3()
{	
	ResetEvent(m_hEventTheadNoRun3);

	::CoInitialize(NULL);
	while(1)
	{
		try
		{
			int nCount = 0;
			m_cs.Lock();
			nCount = (int)m_arrDeRegisterNode.size();
			m_cs.Unlock();

			if (nCount > 0)
			{
				for (int i = 0; i < nCount; i++)
				{
					m_cs.Lock();
					DeRegisterNode& node = m_arrDeRegisterNode[i];
					m_cs.Unlock();

					if(0 == node.bInvalid)
					{
						if(node.OldDeRegisterTime < COleDateTime::GetCurrentTime())
						{
							DeRegister(node);
							m_cs.Lock();
							node.bInvalid = 1;
							m_cs.Unlock();
						}
					}
					SleepThread(1, 3);
				}
			}
		}
		catch(...)
		{
			IBA_LOG0(_T("出现异常3"));
		}
		SleepThread(1 * 60, 3);	// 一分钟检测一次
	}
	SetEvent(m_hEventTheadNoRun3);
}
Пример #26
0
///////////////////////////////////////////////////////////////////////[16]
void SifRpcLoop(struct sifcmd_RPC_DATA_QUEUE *qd){
	register struct sifcmd_RPC_SERVER_DATA *s;

	do{
		if (s=SifGetNextRequest(qd))
			SifExecRequest(s);
		else
			SleepThread();
	} while (1);
}
Пример #27
0
// Maybe move to elsewhere, where it can be reused?
static BOOLEAN
waitForKey (struct wait_state *self) {
	if (PulsedInputState.menu[KEY_MENU_SELECT] ||
			PulsedInputState.menu[KEY_MENU_CANCEL])
		return FALSE;

	SleepThread (ONE_SECOND / 20);
	
	(void) self;
	return TRUE;
}
Пример #28
0
//-------------------------------------------------------------------------
void init_thread(void *args)
{
	if (!sceSifCheckInit())
		sceSifInit();

	sceSifInitRpc(0);

	cdvdfsv_buf = AllocSysMemory(ALLOC_FIRST, (CDVDFSV_BUF_SECTORS << 11)+2048, NULL);
	if (!cdvdfsv_buf)
		SleepThread();

	cdvdfsv_startrpcthreads();
}
Пример #29
0
void initalise(void)
{
	int ret;
	
	// load all modules
	loadModules();
	// init pad
	padInit(0);
	if((ret = padPortOpen(0, 0, padBuf)) == 0) {
		#if defined DEBUG
			scr_printf("padOpenPort failed: %d\n", ret);
		#endif
		SleepThread();
	}

	if(!initializePad(0, 0)) {
		#if defined DEBUG
			scr_printf("pad initalization failed!\n");
		#endif
		SleepThread();
	}
}
Пример #30
0
int main(int argc, char *argv[])
{
    SifInitRpc(0);

    SifLoadModule("host:ps2ips.irx", 0, NULL);

    if(ps2ip_init() < 0) {
        printf("ERROR: ps2ip_init falied!\n");
        SleepThread();
    }

    serverThread();
    return 0;
}