void ioInit(void) {
gIOTerminate = 0;
gHandlerCount = 0;
gReqList = NULL;
gReqEnd = NULL;
gIOThreadId = 0;
gQueueSema.init_count = 1;
gQueueSema.max_count = 1;
gQueueSema.option = 0;
gProcSemaId = CreateSema(&gQueueSema);
gEndSemaId = CreateSema(&gQueueSema);
gIOPrintfSemaId = CreateSema(&gQueueSema);
// default custom simple action handler
ioRegisterHandler(IO_CUSTOM_SIMPLEACTION, &ioSimpleActionHandler);
gIOThread.attr = 0;
gIOThread.stack_size = THREAD_STACK_SIZE;
gIOThread.gp_reg = &_gp;
gIOThread.func = &ioWorkerThread;
gIOThread.stack = thread_stack;
gIOThread.initial_priority = 30;
isIORunning = 1;
gIOThreadId = CreateThread(&gIOThread);
StartThread(gIOThreadId, NULL);
}
//-------------------------------------------------------------------------
int _start(int argc, char** argv)
{
iop_sema_t smp;
SifInitRpc(0);
#ifdef _NETLOG
// init netlog
netlog_init(0, SERVER_UDP_PORT);
netlog_send("hello from debugger.irx\n");
#endif
// Starting ntpbserver Remote Procedure Call server
start_RPC_server();
// Starting server thread
start_ServerThread();
smp.attr = 1;
smp.initial = 1;
smp.max = 1;
smp.option = 0;
ntpbserver_io_sema = CreateSema(&smp);
smp.attr = 1;
smp.initial = 0; // this sema is initialised to 0 !
smp.max = 1;
smp.option = 0;
ntpbserver_cmd_sema = CreateSema(&smp);
return MODULE_RESIDENT_END;
}
int NetManInitRPCClient(void){
int result;
ee_sema_t SemaData;
ee_thread_t ThreadData;
if(!IsInitialized){
SemaData.max_count=1;
SemaData.init_count=1;
SemaData.option=SemaData.attr=0;
NetManIOSemaID=CreateSema(&SemaData);
TxActiveBankID=0;
memset(&TxFIFOData1, 0, sizeof(TxFIFOData1));
memset(&TxFIFOData2, 0, sizeof(TxFIFOData2));
CurrentTxFIFOData=UNCACHED_SEG(&TxFIFOData1);
SemaData.max_count=1;
SemaData.init_count=1;
SemaData.option=SemaData.attr=0;
TxBankAccessSema=CreateSema(&SemaData);
SemaData.max_count=1;
SemaData.init_count=1;
SemaData.option=SemaData.attr=0;
NetManTxSemaID=CreateSema(&SemaData);
ThreadData.func=&TxThread;
ThreadData.stack=TxThreadStack;
ThreadData.stack_size=sizeof(TxThreadStack);
ThreadData.gp_reg=&_gp;
ThreadData.initial_priority=0x58;
ThreadData.attr=ThreadData.option=0;
StartThread(TxThreadID=CreateThread(&ThreadData), NULL);
while((SifBindRpc(&NETMAN_rpc_cd, NETMAN_RPC_NUMBER, 0)<0)||(NETMAN_rpc_cd.server==NULL)){
nopdelay();
nopdelay();
nopdelay();
nopdelay();
}
// ((struct NetManInit*)TransmitBuffer)->AlignmentData=&AlignmentData;
if((result=SifCallRpc(&NETMAN_rpc_cd, NETMAN_IOP_RPC_FUNC_INIT, 0, TransmitBuffer, sizeof(struct NetManInit), ReceiveBuffer, sizeof(struct NetManInitResult), NULL, NULL))>=0){
result=((struct NetManInitResult*)ReceiveBuffer)->result;
TxFrameTagBuffer=((struct NetManInitResult*)ReceiveBuffer)->FrameTagBuffer;
}
IsInitialized=1;
}
else result=0;
return result;
}
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);
}
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;
}
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);
}
void _ps2sdk_alloc_init()
{
ee_sema_t alloc_sema_struct;
alloc_sema_struct.init_count = 1;
alloc_sema_struct.max_count = 1;
alloc_sema = CreateSema(&alloc_sema_struct);
}
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;
}
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;
}
void die(int onsig)
{
signal(onsig, SIG_IGN);
CloseDupes();
Msg_Close();
if (onsig) {
if (onsig <= NSIG)
WriteError("Terminated on signal %d (%s)", onsig, SigName[onsig]);
else
WriteError("Terminated with error %d", onsig);
}
if (do_mailout)
CreateSema((char *)"mailout");
t_end = time(NULL);
Syslog('+', "Send [%6lu] Received [%6lu]", sentbytes, rcvdbytes);
Syslog(' ', "FTNNNTP finished in %s", t_elapsed(t_start, t_end));
if (envptr)
free(envptr);
ExitClient(onsig);
msleep(1); /* For the linker only */
}
/*
* Check for Zone Mail Hour, return TRUE if it is.
*/
int get_zmh()
{
struct tm l_date;
char sstime[6];
time_t Now;
Now = time(NULL);
gmtime_r(&Now, &l_date);
snprintf(sstime, 6, "%02d:%02d", l_date.tm_hour, l_date.tm_min);
if ((strncmp(sstime, TCFG.zmh_start, 5) >= 0) && (strncmp(sstime, TCFG.zmh_end, 5) < 0)) {
if (!ZMH) {
CreateSema((char *)"zmh");
Syslog('!', "Start of Zone Mail Hour");
ZMH = TRUE;
}
} else {
if (ZMH) {
RemoveSema((char *)"zmh");
Syslog('!', "End of Zone Mail Hour");
ZMH = FALSE;
}
}
return ZMH;
}
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;
}
Ps2File::Ps2File() {
_fd = -1;
_fileSize = 0;
_filePos = 0;
_cacheSize = 0;
_cachePos = 0;
_eof = false;
_err = false;
_cacheBuf = (uint8 *)memalign(64, CACHE_SIZE * 2);
_cacheOpRunning = 0;
_filePos = _physFilePos = _cachePos = 0;
_fileSize = _bytesInCache = _cacheOfs = 0;
_cacheOpRunning = false;
_readBytesBlock = 0;
_stream = true;
#ifdef __PS2_FILE_SEMA__
ee_sema_t newSema;
newSema.init_count = 1;
newSema.max_count = 1;
_sema = CreateSema(&newSema);
assert(_sema >= 0);
#endif
}
/** Register This driver with usbd.irx */
int PS2CamInitDriver(void)
{
int i;
iop_sema_t sema;
printf("PS2 USB Camera Driver v.%d.%d ((C) www.ps2dev.org)\n",DRIVER_VERSON_MAJOR,DRIVER_VERSON_MINOR);
memset(&Camera[0], 0, sizeof(Camera)*MAX_CAM_DEVICE );
memset(&CamHandle[0], 0, sizeof(Camera)*MAX_CAM_DEVICE_HANDLE);
for(i=0;i<MAX_CAM_DEVICE_HANDLE;i++)
{
CamHandle[i].fd = i+1;
}
//setup sema
sema.initial= 1;
sema.max = 1;
sema.option = 0;
sema.attr = 0;
ps2cam_sema = CreateSema(&sema);
//connect to usb.irx
return UsbRegisterDriver(&cam_driver);
}
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;
}
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;
}
/** Initializes audsrv library
@returns error code
*/
int audsrv_init()
{
int ret;
if (initialized)
{
/* already done */
return 0;
}
memset(&cd0, '\0', sizeof(cd0));
while (1)
{
if (SifBindRpc(&cd0, AUDSRV_IRX, 0) < 0)
{
set_error(AUDSRV_ERR_RPC_FAILED);
return -1;
}
if (cd0.server != 0)
{
break;
}
nopdelay();
}
ee_sema_t compSema;
compSema.init_count = 1;
compSema.max_count = 1;
compSema.option = 0;
completion_sema = CreateSema(&compSema);
if (completion_sema < 0)
{
set_error(AUDSRV_ERR_FAILED_TO_CREATE_SEMA);
return -1;
}
SifCallRpc(&cd0, AUDSRV_INIT, 0, sbuff, 64, sbuff, 64, NULL, NULL);
ret = sbuff[0];
if (ret != 0)
{
set_error(ret);
return ret;
}
/* register a callback handler */
DI();
SifAddCmdHandler(AUDSRV_CDDA_CALLBACK, cdda_stopped, NULL);
SifAddCmdHandler(AUDSRV_FILLBUF_CALLBACK, fillbuf_requested, NULL);
EI();
/* initialize IOP heap (for adpcm samples) */
SifInitIopHeap();
set_error(AUDSRV_ERR_NOERROR);
return AUDSRV_ERR_NOERROR;
}
AsyncFio::AsyncFio(void) {
_runningOp = NULL;
memset((int *)_ioSlots, 0, MAX_HANDLES * sizeof(int));
ee_sema_t newSema;
newSema.init_count = 1;
newSema.max_count = 1;
_ioSema = CreateSema(&newSema);
}
void ioInit(void) {
gIOTerminate = 0;
gHandlerCount = 0;
gReqList = NULL;
gReqEnd = NULL;
gDispatcherThreadID = 0;
gIOThreadId = 0;
gQueueSema.init_count = 1;
gQueueSema.max_count = 1;
gQueueSema.option = 0;
gProcSemaId = CreateSema(&gQueueSema);
gEndSemaId = CreateSema(&gQueueSema);
gIOPrintfSemaId = CreateSema(&gQueueSema);
ChangeThreadPriority ( GetThreadId (), 29 );
// default custom simple action handler
ioRegisterHandler(IO_CUSTOM_SIMPLEACTION, &ioSimpleActionHandler);
memset(&gIOThread, 0, sizeof(gIOThread));
gIOThread.func = (void *)ioThreadDispatcher;
gIOThread.stack = disp_stack;
gIOThread.stack_size = THREAD_STACK_SIZE;
gIOThread.gp_reg = &_gp;
gIOThread.initial_priority = 0;
alarmID = SetAlarm( 625, &ioAlarmFunc, NULL);
// this one manages the thread switching in alarm intervals
gDispatcherThreadID = CreateThread(&gIOThread);
StartThread(gDispatcherThreadID, NULL);
gIOThread.func = (void *)ioWorkerThread;
gIOThread.stack = thread_stack;
gIOThread.initial_priority = 30;
isIORunning = 1;
gIOThreadId = CreateThread(&gIOThread);
StartThread(gIOThreadId, NULL);
ChangeThreadPriority ( GetThreadId (), 30 );
}
void sceCdSemaInit(void)
{
struct t_ee_sema semaParam;
// return if both semaphores are already inited
if (nCmdSemaId != -1 && sCmdSemaId != -1)
return;
semaParam.init_count = 1;
semaParam.max_count = 1;
semaParam.option = 0;
nCmdSemaId = CreateSema(&semaParam);
sCmdSemaId = CreateSema(&semaParam);
semaParam.init_count = 0;
callbackSemaId = CreateSema(&semaParam);
cbSema = 0;
}
void OSystem_PS2::initMutexes(void) {
ee_sema_t newSema;
newSema.init_count = 1;
newSema.max_count = 1;
_mutexSema = CreateSema(&newSema);
for (int i = 0; i < MAX_MUTEXES; i++) {
_mutex[i].sema = -1;
_mutex[i].count = _mutex[i].owner = 0;
}
}
McAccess::McAccess(int port, int slot) {
_port = port;
_slot = slot;
ee_sema_t newSema;
newSema.init_count = 1;
newSema.max_count = 1;
_sema = CreateSema(&newSema);
assert(mcInit(MC_TYPE_MC) >= 0);
}
static int makeMySem( void )
{
struct SemaParam sem;
sem.initCount = 0;
sem.maxCount = 1;
sem.attr = AT_THFIFO;
/* Create semaphore. */
return CreateSema(&sem);
}
int hddInit(iop_device_t *f)
{
iop_sema_t sema;
sema.attr=1;
sema.initial=1;
sema.max=1;
sema.option=0;
fioSema=CreateSema(&sema);
return 0;
}
void sys_init(void)
{
iop_sema_t sema;
dbgprintf("sys_init: Initializing (TID: %d)\n", GetThreadId());
memset(msg_pool, 0, sizeof(msg_pool));
sema.initial=sema.max=SYS_MAX_MESSAGES;
sema.attr=sema.option=0;
MsgCountSema=CreateSema(&sema);
}
FILE *ps2_fopen(const char *fname, const char *mode) {
if (cacheListSema == -1) {
ee_sema_t newSema;
newSema.init_count = 1;
newSema.max_count = 1;
cacheListSema = CreateSema(&newSema);
assert(cacheListSema >= 0);
}
printf("ps2_fopen: %s, %s\n", fname, mode);
if (!checkedPath && g_engine) {
// are we playing from cd/dvd?
const char *gameDataPath = ConfMan.get("path").c_str();
printf("Read TOC dir: %s\n", gameDataPath);
if (strncmp(gameDataPath, "cdfs:", 5) != 0)
driveStop(); // no, we aren't. stop the drive. it's noisy.
// now cache the dir tree
tocManager.readEntries(gameDataPath);
checkedPath = true;
}
if (((mode[0] != 'r') && (mode[0] != 'w')) || ((mode[1] != '\0') && (mode[1] != 'b'))) {
printf("unsupported mode \"%s\" for file \"%s\"\n", mode, fname);
return NULL;
}
bool rdOnly = (mode[0] == 'r');
int64 cacheId = -1;
if (rdOnly && tocManager.haveEntries())
cacheId = tocManager.fileExists(fname);
if (cacheId != 0) {
Ps2File *file = findInCache(cacheId);
if (file)
return (FILE*)file;
if (rdOnly) {
bool isAudioFile = strstr(fname, ".bun") || strstr(fname, ".BUN") || strstr(fname, ".Bun");
file = new Ps2ReadFile(cacheId, isAudioFile);
} else
file = new Ps2WriteFile(cacheId);
if (file->open(fname)) {
openFileCount++;
return (FILE*)file;
} else
delete file;
}
return NULL;
}
int hddInit(iop_device_t *f)
{
iop_sema_t sema;
sema.attr=1;
sema.initial=1;
sema.max=1;
sema.option=0;
fioSema=CreateSema(&sema);
AddPowerOffHandler(hddPowerOffHandler, 0);
return 0;
}
Ps2SaveFileManager::Ps2SaveFileManager(OSystem_PS2 *system, Gs2dScreen *screen) {
_system = system;
_screen = screen;
_mc = new McAccess(0, 0);
_mcDirList = (mcTable*)memalign(64, MAX_MC_ENTRIES * sizeof(mcTable));
_mcDirName[0] = '\0';
_mcCheckTime = 0;
_mcNeedsUpdate = true;
for (int mcCheckCount = 0; mcCheckCount < 3; mcCheckCount++) {
/* retry mcGetInfo 3 times. It slows down startup without mc considerably,
but cheap 3rd party memory cards apparently fail to get detected once in a while */
int mcType, mcFree, mcFormat;
int res = _mc->getInfo(&mcType, &mcFree, &mcFormat);
if ((res == 0) || (res == -1)) { // mc okay
_mcPresent = true;
printf("MC okay, result = %d. Type %d, Free %d, Format %d\n", res, mcType, mcFree, mcFormat);
checkMainDirectory();
break;
} else {
_mcPresent = false;
printf("MC failed, not present or not formatted, code %d\n", res);
}
}
// create save thread
ee_sema_t newSema;
newSema.init_count = 0;
newSema.max_count = 1;
_autoSaveSignal = CreateSema(&newSema);
_autoSaveBuf = NULL;
_autoSaveSize = 0;
_systemQuit = false;
ee_thread_t saveThread, thisThread;
ReferThreadStatus(GetThreadId(), &thisThread);
saveThread.initial_priority = thisThread.current_priority + 1;
saveThread.stack_size = 8 * 1024;
_autoSaveStack = malloc(saveThread.stack_size);
saveThread.stack = _autoSaveStack;
saveThread.func = (void *)runSaveThread;
saveThread.gp_reg = &_gp;
_autoSaveTid = CreateThread(&saveThread);
assert(_autoSaveTid >= 0);
StartThread(_autoSaveTid, this);
}
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;
}
//---------------------------------------------------------------------------
static int _fs_init_lock(void)
{
#ifndef WIN32
iop_sema_t sp;
sp.initial = 1;
sp.max = 1;
sp.option = 0;
sp.attr = 0;
if((_lock_sema_id = CreateSema(&sp)) < 0) { return(-1); }
#endif
return(0);
}
