Пример #1
0
static int WaitValidNetState(int (*checkingFunction)(void)){
	int SemaID, retry_cycles;
	ee_sema_t SemaData;

	// Wait for a valid network status;
	SemaData.option = SemaData.attr = 0;
	SemaData.init_count = 0;
	SemaData.max_count = 1;
	if((SemaID = CreateSema(&SemaData)) < 0)
		return SemaID;

	for(retry_cycles = 0; checkingFunction() == 0; retry_cycles++) {
		SetAlarm(1000 * rmGetHsync(), &EthStatusCheckCb, &SemaID);
		WaitSema(SemaID);

		if(retry_cycles >= 30)	//30s = 30*1000ms
		{
			DeleteSema(SemaID);
			return -1;
		}
	}

	DeleteSema(SemaID);
	return 0;
}
Пример #2
0
void sceCdSemaExit(void)
{
	if (callbackThreadId) {
		sceCdCallbackNum = -1;
		SignalSema(callbackSemaId);
	}
	DeleteSema(nCmdSemaId);
	DeleteSema(sCmdSemaId);
	DeleteSema(callbackSemaId);
}
Пример #3
0
void NetManDeinitRPCClient(void){
	WaitSema(NetManIOSemaID);

	SifCallRpc(&NETMAN_rpc_cd, NETMAN_IOP_RPC_FUNC_DEINIT, 0, NULL, 0, ReceiveBuffer, sizeof(struct NetManInitResult), NULL, NULL);
	TerminateThread(TxThreadID);
	DeleteThread(TxThreadID);
	DeleteSema(NetManIOSemaID);
	DeleteSema(NetManTxSemaID);

	IsInitialized=0;
}
Пример #4
0
static void ioWorkerThread(void) {
	while (!gIOTerminate) {
		SleepThread();

		// no processing when io is blocked
		if (isIOBlocked)
			continue;
			
		// if term requested exit immediately from the loop
		if (gIOTerminate)
			break;
		
		// do we have a request in the queue?
		while (gReqList) {
			WaitSema(gProcSemaId);
			
			struct io_request_t* req = gReqList;
			ioProcessRequest(req);

			// lock the queue tip as well now
			WaitSema(gEndSemaId);
			
			// can't be sure if the request was
			gReqList = req->next;
			free(req);
						
			if (!gReqList)
				gReqEnd = NULL;

			SignalSema(gProcSemaId);
			SignalSema(gEndSemaId);
		}
	}
	
	// delete the pending requests
	while (gReqList) {
		struct io_request_t* req = gReqList;
		gReqList = gReqList->next;
		free(req); // TODO: Leak over here - we need a propper flag to free/not the user data
	}
	
	// delete the semaphores
	DeleteSema(gProcSemaId);
	DeleteSema(gEndSemaId);
	
	isIORunning = 0;

	ExitDeleteThread();
}
Пример #5
0
static void ioWorkerThread(void *arg) {
	while (!gIOTerminate) {
		SleepThread();

		// if term requested exit immediately from the loop
		if (gIOTerminate)
			break;

		// do we have a request in the queue?
		WaitSema(gProcSemaId);
		while (gReqList) {
			// if term requested exit immediately from the loop
			if (gIOTerminate)
				break;

			struct io_request_t* req = gReqList;
			ioProcessRequest(req);

			// lock the queue tip as well now
			WaitSema(gEndSemaId);

			// can't be sure if the request was
			gReqList = req->next;
			free(req);

			if (!gReqList)
				gReqEnd = NULL;

			SignalSema(gEndSemaId);
		}
		SignalSema(gProcSemaId);
	}

	// delete the pending requests
	while (gReqList) {
		struct io_request_t* req = gReqList;
		gReqList = gReqList->next;
		free(req);
	}

	// delete the semaphores
	DeleteSema(gProcSemaId);
	DeleteSema(gEndSemaId);

	isIORunning = 0;

	ExitDeleteThread();
}
Пример #6
0
int mass_stor_disconnect(int devId) {
	mass_dev* dev;
	dev = mass_stor_findDevice(devId, 0);

	printf("USBHDFSD: disconnect: devId=%i\n", devId);

	if (dev == NULL)
	{
		printf("USBHDFSD: Error - disconnect: no device storage!\n");
		return 0;
	}

	if (dev->status & USBMASS_DEV_STAT_CONN)
	{
		mass_stor_release(dev);
		part_disconnect(dev);
		scache_kill(dev->cache);
		dev->cache = NULL;
		dev->devId = -1;

		DeleteSema(dev->ioSema);

		if(dev->callback != NULL) dev->callback(USBMASS_DEV_EV_DISCONN);
	}

	return 0;
}
Пример #7
0
int poweroffInit()
{
	int res;
	static int _init_count = -1;

	if(_init_count == _iop_reboot_count)
		return 0;
	_init_count = _iop_reboot_count;

	while(((res = SifBindRpc(&cd0, PWROFF_IRX, 0)) >= 0) && (cd0.server == NULL))
		nopdelay();

	ee_thread_t thread;
	ee_thread_status_t thisThread;

	ee_sema_t sema;

	// Terminate and delete any previously created threads
	if (powerOffThreadId >= 0) {
		TerminateThread(powerOffThreadId);
		DeleteThread(powerOffThreadId);
		powerOffThreadId = -1;
	}

	// Delete any previously created semaphores
	if (PowerOffSema >= 0)
	{
		DeleteSema(PowerOffSema);
		PowerOffSema = -1;
	}

	sema.init_count = 0;
	sema.max_count = 1;
	sema.option = 0;
	PowerOffSema = CreateSema(&sema);

	ReferThreadStatus(GetThreadId(), &thisThread);

	if (thisThread.current_priority == 0) {
		ChangeThreadPriority(GetThreadId(), 51);
		thread.initial_priority = 50;
	} else
		thread.initial_priority = thisThread.current_priority - 1;

	thread.stack_size = 512 * 16;
	thread.gp_reg = &_gp;
	thread.func = PowerOffThread;
	thread.stack = (void *)poffThreadStack;
	powerOffThreadId = CreateThread(&thread);
	StartThread(powerOffThreadId, NULL);
	
	DIntr();
	SifAddCmdHandler(POFF_SIF_CMD, _poff_intr_callback, NULL);
	EIntr();

	int autoShutdown = 0;
	SifCallRpc(&cd0, PWROFF_ENABLE_AUTO_SHUTOFF, 0, NULL, 0, &autoShutdown, sizeof(autoShutdown), 0, 0);
	
	return res;
}
Пример #8
0
void usb_bulk_command(mass_dev* dev, cbw_packet* packet ) {
	int ret;
	iop_sema_t s;
	usb_callback_data cb_data;

	s.initial = 0;
	s.max = 1;
	s.option = 0;
	s.attr = 0;
	cb_data.semh = CreateSema(&s);

	ret =  UsbBulkTransfer(
		dev->bulkEpO,		//bulk output pipe
		packet,			//data ptr
		31,			//data length
		usb_callback,
		(void*)&cb_data
	);
    
	if (ret != USB_RC_OK) {
		printf("USBHDFSD: Error - sending bulk command %d\n", ret);
	} else {
		WaitSema(cb_data.semh);
	}
	DeleteSema(cb_data.semh);
}
Пример #9
0
int usb_bulk_get_max_lun(mass_dev* dev) {
	int ret;
	usb_callback_data cb_data;
	iop_sema_t s;
	char max_lun;

	s.initial = 0;
	s.max = 1;
	s.option = 0;
	s.attr = 0;
	cb_data.semh = CreateSema(&s);

	//Call Bulk only mass storage reset
	ret = UsbControlTransfer(
		dev->controlEp, 		//default pipe
		0xA1,
		0xFE,
		0,
		dev->interfaceNumber, //interface number
		1,			//length
		&max_lun,			//data
		usb_callback,
		(void*) &cb_data
		);

	if (ret != USB_RC_OK) {
		printf("USBHDFSD: Error - get_max_lun %d\n", ret);
        max_lun = -ret;
	} else {
		WaitSema(cb_data.semh);
	}
	DeleteSema(cb_data.semh);
	return max_lun;
}
Пример #10
0
int InitThread(void)
{
	ee_sema_t sema;
	ee_thread_t thread;

	sema.max_count = 255;
	sema.init_count = 0;
	sema.option = (u32)"KernelTopThread";
	if((topSema = CreateSema(&sema)) < 0)
		return -1;

	thread.func = &topThread;
	thread.stack = stack;
	thread.stack_size = sizeof(stack);
	thread.gp_reg = &_gp;
	thread.option = (u32)"KernelTopThread";
	thread.initial_priority = 0;
	if((topId = CreateThread(&thread)) < 0)
	{
		DeleteSema(topSema);
		return -1;
	}

	topArg.requestOut = 0;
	topArg.requestIn = 0;
	StartThread(topId, &topArg);

	ChangeThreadPriority(GetThreadId(), 1);

	return topId;
}
Пример #11
0
void usb_bulk_clear_halt(mass_dev* dev, int direction) {
	int ret;
	usb_callback_data cb_data;
	iop_sema_t s;
	int endpoint;

	s.initial = 0;
	s.max = 1;
	s.option = 0;
	s.attr = 0;
	cb_data.semh = CreateSema(&s);

	if (direction == 0) {
		endpoint = dev->bulkEpIAddr;
		//endpoint = dev->bulkEpI;
	} else {
		endpoint = dev->bulkEpOAddr;
	}

	ret = UsbClearEndpointFeature(
		dev->controlEp, 		//Config pipe
		0,			//HALT feature
		endpoint,
		usb_callback,
		(void*)&cb_data
		);

	if (ret != USB_RC_OK) {
		printf("USBHDFSD: Error - sending clear halt %d\n", ret);
	} else {
		WaitSema(cb_data.semh);
	}
	DeleteSema(cb_data.semh);
}
Пример #12
0
int SifCallRpc(SifRpcClientData_t *cd, int rpc_number, int mode,
		void *sendbuf, int ssize, void *recvbuf, int rsize,
		SifRpcEndFunc_t endfunc, void *efarg)
{
	ee_sema_t sema;
	SifRpcCallPkt_t *call;

	call = (SifRpcCallPkt_t *)_rpc_get_packet(&_sif_rpc_data);
	if (!call)
		return -E_SIF_PKT_ALLOC;

	cd->hdr.pkt_addr  = call;
	cd->hdr.rpc_id    = call->rpc_id;
	cd->hdr.sema_id   = -1;
	cd->end_function  = endfunc;
	cd->end_param     = efarg;

	call->rpc_number  = rpc_number;
	call->send_size   = ssize;
	call->receive     = recvbuf;
	call->recv_size   = rsize;
	call->rmode       = 1;
	call->pkt_addr    = call;
	call->client      = cd;
	call->server      = cd->server;

	if (!(mode & SIF_RPC_M_NOWBDC)) {
		if (ssize > 0)
			SifWriteBackDCache(sendbuf, ssize);
		if (rsize > 0)
			SifWriteBackDCache(recvbuf, rsize);
	}

	if (mode & SIF_RPC_M_NOWAIT) {
		if (!endfunc)
			call->rmode = 0;

		if (!SifSendCmd(0x8000000a, call, RPC_PACKET_SIZE, sendbuf,
					cd->buff, ssize))
			return -E_SIF_PKT_SEND;

		return 0;
	}

	sema.max_count  = 1;
	sema.init_count = 0;
	cd->hdr.sema_id = CreateSema(&sema);
	if (cd->hdr.sema_id < 0)
		return -E_LIB_SEMA_CREATE;

	if (!SifSendCmd(0x8000000a, call, RPC_PACKET_SIZE, sendbuf,
				cd->buff, ssize))
		return -E_SIF_PKT_SEND;

	WaitSema(cd->hdr.sema_id);
	DeleteSema(cd->hdr.sema_id);

	return 0;
}
Пример #13
0
Ps2ReadFile::~Ps2ReadFile(void) {
	if (_cacheOpRunning)
		cacheReadSync();
	free(_cacheBuf);
	if (_fd >= 0)
		fio.close(_fd);
	DeleteSema(_sema);
}
Пример #14
0
void OSystem_PS2::deleteMutex(MutexRef mutex) {
	WaitSema(_mutexSema);
	Ps2Mutex *sysMutex = (Ps2Mutex*)mutex;
	if (sysMutex->owner || sysMutex->count)
		printf("WARNING: Deleting LOCKED mutex!\n");
	DeleteSema(sysMutex->sema);
	sysMutex->sema = -1;
	SignalSema(_mutexSema);
}
Пример #15
0
//---------------------------------------------------------------------------
static void fs_reset(void)
{
	int i;
	for (i = 0; i < MAX_FILES; i++) { fsRec[i].dirent.file_flag = -1; }
#ifndef WIN32
	if(_lock_sema_id >= 0) { DeleteSema(_lock_sema_id); }
#endif
	_fs_init_lock();
}
Пример #16
0
/** Shutdowns audsrv
    @returns AUDSRV_ERR_NOERROR
*/
int audsrv_quit()
{
	WaitSema(completion_sema);

	SifCallRpc(&cd0, AUDSRV_QUIT, 0, sbuff, 1*4, sbuff, 4, _audsrv_intr, NULL);
	set_error(AUDSRV_ERR_NOERROR);

	DeleteSema(completion_sema);
	return 0;
}
Пример #17
0
int shutdown()
{
    if (alloc_sema >= 0) {
	DeleteSema(alloc_sema);
    }

    FreeSysMemory(heap_start);

    return 0;
}
Пример #18
0
static void deinitCleanup(void)
{
	if(TxThreadID >= 0)
	{
		TerminateThread(TxThreadID);
		DeleteThread(TxThreadID);
		TxThreadID = -1;
	}
	if(NetManIOSemaID >= 0)
	{
		DeleteSema(NetManIOSemaID);
		NetManIOSemaID = -1;
	}
	if(NetManTxSemaID >= 0)
	{
		DeleteSema(NetManTxSemaID);
		NetManTxSemaID = -1;
	}
}
Пример #19
0
void fioExit(void)
{
	if(_fio_init)
	{
		_fio_init = 0;
		memset(&_fio_cd, 0, sizeof _fio_cd);
		if (_fio_completion_sema >= 0)
		{
			DeleteSema(_fio_completion_sema);
        	}
	}
}
Пример #20
0
int usb_bulk_status(mass_dev* dev, csw_packet* csw, int tag) {
	int ret;
	iop_sema_t s;
	usb_callback_data cb_data;

	s.initial = 0;
	s.max = 1;
	s.option = 0;
	s.attr = 0;
	cb_data.semh = CreateSema(&s);

	csw->signature = CSW_TAG;
	csw->tag = tag;
	csw->dataResidue = 0;
	csw->status = 0;

	ret = UsbBulkTransfer(
		dev->bulkEpI,		//bulk input pipe
		csw,			//data ptr
		13,			//data length
		usb_callback,
		(void*)&cb_data
        );

	if (ret != USB_RC_OK) {
		printf("USBHDFSD: Error - sending bulk status %d\n", ret);
		DeleteSema(cb_data.semh);
		return -1;
	} else {
		WaitSema(cb_data.semh);
    	DeleteSema(cb_data.semh);
        if (cb_data.returnSize != 13)
            printf("USBHDFSD: bulk csw.status returnSize: %i\n", cb_data.returnSize);
        if (csw->dataResidue != 0)
            printf("USBHDFSD: bulk csw.status residue: %i\n", csw->dataResidue);
    	XPRINTF("USBHDFSD: bulk csw.status: %i\n", csw->status);
    	return csw->status;
	}
}
Пример #21
0
void
sys_sem_free(sys_sem_t Sema)
{
	dbgprintf("sys_sem_free: Sema: %d (TID: %d)\n",Sema,GetThreadId());

	if(Sema==SYS_SEM_NULL)
	{
		printf("sys_sem_free: Trying to delete illegal sema: %d\n",Sema);
		return;
	}
	DeleteSema(Sema);
	--sema_count;
}
Пример #22
0
int poweroffInit(void)
{
	ee_thread_t thread;
	ee_sema_t sema;
	int res;
	static int _init_count = -1;

	if(_init_count == _iop_reboot_count)
		return 0;
	_init_count = _iop_reboot_count;

	while(((res = SifBindRpc(&cd0, PWROFF_IRX, 0)) >= 0) && (cd0.server == NULL))
		nopdelay();

	// Terminate and delete any previously created threads
	if (powerOffThreadId >= 0) {
		TerminateThread(powerOffThreadId);
		DeleteThread(powerOffThreadId);
		powerOffThreadId = -1;
	}

	// Delete any previously created semaphores
	if (PowerOffSema >= 0)
	{
		DeleteSema(PowerOffSema);
		PowerOffSema = -1;
	}

	sema.init_count = 0;
	sema.max_count = 1;
	sema.option = 0;
	PowerOffSema = CreateSema(&sema);

	thread.initial_priority = POWEROFF_THREAD_PRIORITY;
	thread.stack_size = sizeof(poffThreadStack);
	thread.gp_reg = &_gp;
	thread.func = PowerOffThread;
	thread.stack = (void *)poffThreadStack;
	powerOffThreadId = CreateThread(&thread);
	StartThread(powerOffThreadId, NULL);

	DI();
	SifAddCmdHandler(POFF_SIF_CMD, _poff_intr_callback, NULL);
	EI();

	int autoShutdown = 0;
	SifCallRpc(&cd0, PWROFF_ENABLE_AUTO_SHUTOFF, 0, NULL, 0, &autoShutdown, sizeof(autoShutdown), NULL, NULL);

	return res;
}
Пример #23
0
static void deinitCleanup(void){
	if(TxThreadID >= 0){
		TerminateThread(TxThreadID);
		DeleteThread(TxThreadID);
		TxThreadID = -1;
	}
	if(NetManIOSemaID >= 0){
		DeleteSema(NetManIOSemaID);
		NetManIOSemaID = -1;
	}
	if(NetManTxSemaID >= 0){
		DeleteSema(NetManTxSemaID);
		NetManTxSemaID = -1;
	}
	if(TxFIFOData1.FrameBuffer != NULL){
		free(TxFIFOData1.FrameBuffer);
		TxFIFOData1.FrameBuffer = NULL;
	}
	if(TxFIFOData2.FrameBuffer != NULL){
		free(TxFIFOData2.FrameBuffer);
		TxFIFOData2.FrameBuffer = NULL;
	}
}
Пример #24
0
int audsrv_quit()
{
	WaitSema(completion_sema);

	SifCallRpc(&cd0, AUDSRV_QUIT, 0, sbuff, 1*4, sbuff, 4, NULL, NULL);
	set_error(AUDSRV_ERR_NOERROR);

	SifRemoveRpc(&cb_srv, &cb_queue);
	SifRemoveRpcQueue(&cb_queue);
	TerminateThread(rpc_server_thread_id);
	DeleteThread(rpc_server_thread_id);

	DeleteSema(completion_sema);
	return 0;
}
Пример #25
0
void ethDeinitModules(void) {
	if(ethInitSemaID >=0)
		WaitSema(ethInitSemaID);

	HttpDeinit();
	nbnsDeinit();
	NetManDeinit();
	ethModulesLoaded = 0;
	gNetworkStartup = ERROR_ETH_NOT_STARTED;

	if(ethInitSemaID >=0)
	{
		DeleteSema(ethInitSemaID);
		ethInitSemaID = -1;
	}
}
Пример #26
0
unsigned int sleep(unsigned int seconds)
{
    ee_sema_t sema;
    struct sleep_data sd;
    
	sema.init_count = 0;
	sema.max_count  = 1;
	sema.option     = 0;
    
    sd.wait = clock() + seconds * CLOCKS_PER_SEC;
    sd.s = CreateSema(&sema);
    SetAlarm(HSYNC_COUNT, _sleep_waker, &sd);
    WaitSema(sd.s);
    DeleteSema(sd.s);
    
	return 0;
}
Пример #27
0
int fioInit()
{
	int res;
	ee_sema_t compSema;
	static int _rb_count = 0;

	if(_rb_count != _iop_reboot_count)
	{
	    _rb_count = _iop_reboot_count;

	    if (_fio_completion_sema >= 0)
	    {
	        DeleteSema(_fio_completion_sema);
            }

	    memset(&_fio_cd, 0, sizeof _fio_cd);
	    _fio_init = 0;
	}

        if (_fio_init)
		return 0;

	SifInitRpc(0);

	while (((res = SifBindRpc(&_fio_cd, 0x80000001, 0)) >= 0) &&
			(_fio_cd.server == NULL))
		nopdelay();

	if (res < 0)
		return res;

	compSema.init_count = 1;
	compSema.max_count = 1;
	compSema.option = 0;
	_fio_completion_sema = CreateSema(&compSema);
	if (_fio_completion_sema < 0)
		return -E_LIB_SEMA_CREATE;

	_fio_init = 1;
	_fio_block_mode = FIO_WAIT;

	return 0;
}
Пример #28
0
int usb_bulk_transfer(int pipe, void* buffer, int transferSize) {
	int ret;
	char* buf = (char*) buffer;
	int blockSize = transferSize;
	int offset = 0;
	iop_sema_t s;
	usb_callback_data cb_data;

	s.initial = 0;
	s.max = 1;
	s.option = 0;
	s.attr = 0;
	cb_data.semh = CreateSema(&s);

	while (transferSize > 0) {
		if (transferSize < blockSize) {
			blockSize = transferSize;
		}

		ret = UsbBulkTransfer(
			pipe,		//bulk pipe epI(Read)  epO(Write)
			(buf + offset),		//data ptr
			blockSize,		//data length
			usb_callback,
			(void*)&cb_data
            );
		if (ret != USB_RC_OK) {
			printf("USBHDFSD: Error - sending bulk data transfer %d\n", ret);
			cb_data.returnCode = -1;
			break;
		} else {
			WaitSema(cb_data.semh);
			//XPRINTF("USBHDFSD: retCode=%i retSize=%i \n", cb_data.returnCode, cb_data.returnSize);
			if (cb_data.returnCode > 0) {
				break;
			}
			offset += cb_data.returnSize;
			transferSize-= cb_data.returnSize;
		}
	}
	DeleteSema(cb_data.semh);
	return cb_data.returnCode;
}
Пример #29
0
void usb_bulk_reset(mass_dev* dev, int mode) {
	int ret;
	usb_callback_data cb_data;
	iop_sema_t s;

	s.initial = 0;
	s.max = 1;
	s.option = 0;
	s.attr = 0;
	cb_data.semh = CreateSema(&s);

	//Call Bulk only mass storage reset
	ret = UsbControlTransfer(
		dev->controlEp, 		//default pipe
		0x21,			//bulk reset
		0xFF,
		0,
		dev->interfaceNumber, //interface number
		0,			//length
		NULL,			//data
		usb_callback,
		(void*) &cb_data
		);

	if (ret != USB_RC_OK) {
		printf("USBHDFSD: Error - sending reset %d\n", ret);
	} else {
		WaitSema(cb_data.semh);

    	//clear bulk-in endpoint
    	if (mode & 0x01) {
    		usb_bulk_clear_halt(dev, 0);
    	}

    	//clear bulk-out endpoint
    	if (mode & 0x02) {
    		usb_bulk_clear_halt(dev, 1);
    	}
	}
	DeleteSema(cb_data.semh);
}
Пример #30
0
void usb_set_device_feature(mass_dev* dev, int feature) {
	int ret;
	usb_callback_data cb_data;
	iop_sema_t s;

	s.initial = 0;
	s.max = 1;
	s.option = 0;
	s.attr = 0;
	cb_data.semh = CreateSema(&s);

	XPRINTF("USBHDFSD: setting device feature controlEp=%i, feature=%i\n", dev->controlEp, feature);
	ret = UsbSetDeviceFeature(dev->controlEp, feature, usb_callback, (void*)&cb_data);

	if (ret != USB_RC_OK) {
		printf("USBHDFSD: Error - sending set_device feature %d\n", ret);
	} else {
		WaitSema(cb_data.semh);
	}
	DeleteSema(cb_data.semh);
}