void CAudioSignalPlayer::SetSignalSafe( const char* pName )
{
if (pName && pName[0]!=0)
SetSignal( pName );
else
SetSignal( INVALID_AUDIOSIGNAL_ID );
}
/* Waits for a signal or a timeout */
ULONG ata_WaitTO(struct IORequest* tmr, ULONG secs, ULONG micro, ULONG sigs)
{
ULONG sig = 1 << tmr->io_Message.mn_ReplyPort->mp_SigBit;
D(struct Node *t = (struct Node *)FindTask(NULL));
D(bug("[ATA ] Timed wait %lds %ldu (task='%s')\n", secs, micro,
t->ln_Name));
tmr->io_Command = TR_ADDREQUEST;
((struct timerequest*)tmr)->tr_time.tv_secs = secs;
((struct timerequest*)tmr)->tr_time.tv_micro = micro;
SendIO(tmr);
D(bug("[ATA ] Preset signals: %lx ('%s')\n", SetSignal(0, 0), t->ln_Name));
D(bug("[ATA ] Signals requested: %lx ('%s')\n", sigs, t->ln_Name));
D(bug("[ATA ] Timer signal: %lx ('%s')\n", sig, t->ln_Name));
sigs = Wait(sigs | sig);
D(bug("[ATA ] Signals received: %lx ('%s')\n", sigs, t->ln_Name));
if (0 == (sigs & sig))
{
if (!CheckIO(tmr))
AbortIO(tmr);
}
WaitIO(tmr);
SetSignal(0, sig);
return sigs & ~sig;
}
ULONG check_signals(void)
{
ULONG mask;
if (_ChkSignalLockout)
return 0L;
++_ChkSignalLockout;
mask = ((struct Task *) FindTask(NULL))->tc_SigRecvd;
/* Default Ctrl-C handling */
if (!sys_signal_hup && (mask & SIGBREAKF_CTRL_C)) {
SetSignal(0L, SIGBREAKF_CTRL_C);
write(2, "*** Break.\n", 11);
exit(EXIT_FAILURE);
}
/* Handle our special exceptions */
if (mask & sys_signal_alarm) {
(*handler_alarm) ();
SetSignal(0L, sys_signal_alarm);
}
if (mask & sys_signal_hup) {
(*handler_hup) ();
SetSignal(0L, sys_signal_hup);
}
if (mask & sys_signal_usr) {
(*handler_usr) ();
SetSignal(0L, sys_signal_usr);
}
--_ChkSignalLockout;
return mask;
}
//-----------------------------------------------------------------------------
// Sets processing function for all signals, which we want to handle
// crash - whether to catch the crash signals too
// Returns: error number
int SetSignals(bool crash) {
int ret;
int exitSignals[] = { SIGPWR, SIGQUIT, SIGINT, SIGTERM };
int crashSignals[] = { SIGBUS, SIGFPE, SIGSEGV, SIGSYS, SIGILL, SIGSTKFLT, SIGXFSZ };
int i;
int count;
// Exit signals
count = (int)(sizeof(exitSignals) / sizeof(int));
for(i = 0; i < count; i++) {
ret = SetSignal(exitSignals[i]);
if(ret) {
printf("ERROR: Can't set exit signal '%s': %s\n", strsignal(exitSignals[i]), strerror(ret));
return ret;
}
}
// Crash signals
if(crash) {
count = (int)(sizeof(crashSignals) / sizeof(int));
for(i = 0; i < count; i++) {
ret = SetSignal(crashSignals[i]);
if(ret) {
printf("ERROR: Can't set crash signal '%s': %s\n", strsignal(crashSignals[i]), strerror(ret));
return ret;
}
}
}
return 0;
}
void SetAllSignals(void)
{
SetSignal(SIGINT, &SignalHandler);
SetSignal(SIGTERM, &SignalHandler);
SetSignal(SIGQUIT, &SignalHandler);
return;
}
/**********************************************************************
* Function: ChangeName
* Description: This function will set the name of service, topic, or item
* based on the ctrlID parameter. If the service name changes
* it will change the list of topics and items
*
*
***********************************************************************/
int OBJDCLASS::ChangeName(LPSTR name, int ctrlID)
{
int rVal = 0;;
HWND hCtrl = GetDlgItem(hDlg, ctrlID);
switch (ctrlID)
{
case IDSIGNAL:
{
SetSignal(name);
if (strcmp(name, "") == 0) {
ResetAddFlag(SIGS_ADDEDSIGNAL);
rVal = 1;
}
else {
SetAddFlag(SIGS_ADDEDSIGNAL);
rVal = 0;
}
}
break;
default: return 0;
}
I_UNUSED(hCtrl);
return rVal;
}
/*
* Clean up Sana-II Interfaces
*
* Note: main interface queue is SNAFU after deinitializing
*/
void
sana_deinit(void)
{
struct sana_softc *ssc;
struct IOSana2Req *req;
assert(SanaPort);
while (ssq) {
sana_down(ssq);
if (ssq->ss_if.if_flags & IFF_RUNNING) {
sana_unrun(ssq);
}
ssc = ssq;
ssq = ssc->ss_next;
/* Close device */
req = CreateIOSana2Req(ssc);
if (req) {
CloseDevice((struct IORequest*)req);
DeleteIOSana2Req(req);
} else {
__log(LOG_ERR, "sana_deinit(): Couldn't close device %s\n",
ssc->ss_name);
}
}
if (SanaPort) {
/* Clear possible pending signals */
SetSignal(1<<SanaPort->mp_SigBit, 0L);
DeleteMsgPort(SanaPort);
SanaPort = NULL;
}
}
static void
ExpungeUnit ( struct AHIDevUnit *iounit,
struct AHIBase *AHIBase )
{
struct Task *unittask;
BYTE signal;
signal = AllocSignal(-1);
if(signal == -1)
{
/* Fallback */
signal = SIGB_SINGLE;
SetSignal(0, SIGF_SINGLE);
}
unittask = (struct Task *) iounit->Process;
iounit->Process = (struct Process *) FindTask(NULL);
iounit->SyncSignal = signal;
Signal(unittask,SIGBREAKF_CTRL_F);
Wait(1UL << signal);
AHIBase->ahib_DevUnits[iounit->UnitNum]=NULL;
FreeVec(iounit->Voices);
FreeVec(iounit);
if(signal != SIGB_SINGLE)
{
FreeSignal(signal);
}
}
void Sys_Net_Wait(struct SysNetData *netdata, struct SysSocket *socket, unsigned int timeout_us)
{
fd_set rfds;
ULONG sigmask;
WaitIO((struct IORequest *)netdata->timerrequest);
if (SetSignal(0, 0) & (1<<netdata->timerport->mp_SigBit))
Wait(1<<netdata->timerport->mp_SigBit);
FD_ZERO(&rfds);
FD_SET(socket->s, &rfds);
netdata->timerrequest->tr_node.io_Command = TR_ADDREQUEST;
netdata->timerrequest->tr_time.tv_secs = timeout_us / 1000000;
netdata->timerrequest->tr_time.tv_micro = timeout_us % 1000000;
SendIO((struct IORequest *)netdata->timerrequest);
sigmask = 1<<netdata->timerport->mp_SigBit;
WaitSelect(socket->s + 1, &rfds, 0, 0, 0, &sigmask);
AbortIO((struct IORequest *)netdata->timerrequest);
}
int
MyExecute (char **argv)
{
char * buffer, * ptr;
char ** aptr;
int len = 0;
int status;
for (aptr=argv; *aptr; aptr++)
{
len += strlen (*aptr) + 4;
}
buffer = AllocMem (len, MEMF_ANY);
if (!buffer)
fatal (NILF, "MyExecute: Cannot allocate space for calling a command");
ptr = buffer;
for (aptr=argv; *aptr; aptr++)
{
if (((*aptr)[0] == ';' && !(*aptr)[1]))
{
*ptr ++ = '"';
strcpy (ptr, *aptr);
ptr += strlen (ptr);
*ptr ++ = '"';
}
else if ((*aptr)[0] == '@' && (*aptr)[1] == '@' && !(*aptr)[2])
{
*ptr ++ = '\n';
continue;
}
else
{
strcpy (ptr, *aptr);
ptr += strlen (ptr);
}
*ptr ++ = ' ';
*ptr = 0;
}
ptr[-1] = '\n';
status = SystemTags (buffer,
SYS_UserShell, TRUE,
TAG_END);
FreeMem (buffer, len);
if (SetSignal (0L,0L) & SIGBREAKF_CTRL_C)
status = 20;
/* Warnings don't count */
if (status == 5)
status = 0;
return status;
}
void __interrupt __chkabort (void)
{
if (SetSignal(0, SIGBREAKF_CTRL_C|SIGBREAKF_CTRL_D) & SIGBREAKF_CTRL_C)
{
raise(SIGINT);
}
}
static void* CreateConnectionData(DBusConnection* connection) {
struct ConnectionData* c = AllocVec(sizeof(struct ConnectionData), MEMF_ANY|MEMF_CLEAR);
kprintf("CreateConnectionData %08lx\n", c);
if (c != NULL) {
c->connection = connection;
c->creator = FindTask(NULL);
NewList((struct List*) &c->watches);
Forbid();
kprintf("creating mainloop\n");
c->main = (struct Task*) CreateNewProcTags(NP_Entry, (ULONG) MainLoop,
NP_Name, (ULONG) "dbus.library main loop",
NP_Priority, 0,
TAG_DONE);
kprintf("created mainloop %08lx\n", c->main);
if (c->main != NULL) {
c->main->tc_UserData = c;
}
SetSignal(0, SIGF_SINGLE);
Permit();
Wait(SIGF_SINGLE);
if (c->main == NULL) {
DeleteConnectionData(c);
c = NULL;
}
}
return c;
}
VOID __saveds PingFunc( VOID )
{
struct MsgPort *ClientPort, *ReplyPort;
struct Library *SysBase;
BlankMsg PingMsg;
SysBase = *( struct Library ** )4L;
if( ReplyPort = CreateMsgPort())
{
PingMsg.bm_Mess.mn_ReplyPort = ReplyPort;
PingMsg.bm_Mess.mn_Length = sizeof( BlankMsg );
PingMsg.bm_Type = BM_PING;
/* Stealthimania, to alleviate processing at the blanker */
PingMsg.bm_Mess.mn_Node.ln_Name = ( UBYTE * )( &Blanking );
for( ;; )
{
if( SetSignal( 0L, SIGBREAKF_CTRL_C ) & SIGBREAKF_CTRL_C )
break;
if( ClientPort = FindPort( "GarshneClient" ))
{
PingMsg.bm_Flags = 0L;
PutMsg( ClientPort, ( struct Message * )( &PingMsg ));
WaitPort( ReplyPort );
GetMsg( ReplyPort );
}
}
DeletePort( ReplyPort );
}
}
//___________________________________________________________________________
KVChannelVolt::KVChannelVolt(const Char_t* signal, KVDetector* kvd): KVCalibrator
(3)
{
//Create an electronic calibration object for a specific detector (*kvd)
//specifying the signal type ("PG" - petit "low" gain - or "GG" - grand "high" gain)
SetType("Channel-Volt");
SetDetector(kvd);
SetSignal(signal);
SetGainRef(1);
}
LONG ContinueBlanking( VOID )
{
if( SetSignal( 0L, SIGBREAKF_CTRL_C ) & SIGBREAKF_CTRL_C )
return QUIT;
if( StopIt )
return QUIT;
return OK;
}
static void StartEventHandler(KonohaContext *kctx, void *args)
{
KNH_ASSERT(PLATAPI eventContext == NULL);
struct EventContext *eventContext = (struct EventContext *)PLATAPI malloc_i(sizeof(struct EventContext));
((KonohaFactory *)kctx->platApi)->eventContext = eventContext;
bzero(((KonohaFactory *)kctx->platApi)->eventContext, sizeof(struct EventContext));
eventContext->queue = (LocalQueue *)PLATAPI malloc_i(sizeof(LocalQueue));
LocalQueue_Init(kctx, eventContext->queue);
SetSignal(kctx);
}
int main(int argc, char *argv[])
{
int cnt;
char buf[BUFSIZE+1];
SetSignal(0,SIGBREAKF_CTRL_C);
while(1) {
cnt=EM_getlog(buf,BUFSIZE);
if(cnt<0) {
fprintf(stderr,"An error occured while reading logs\n");
exit(10);
}
buf[cnt]='\0';
printf("%s",buf);
if(SetSignal(0,SIGBREAKF_CTRL_C)&SIGBREAKF_CTRL_C)
break;
}
exit(0);
}
static void DeleteConnectionData(struct ConnectionData* c) {
kprintf("DeleteConnectionData %08lx\n", c);
if (c != NULL) {
if (c->main != NULL) {
SetSignal(0, SIGF_SINGLE);
Signal(c->main, SIGBREAKF_CTRL_C);
Wait(SIGF_SINGLE);
}
FreeVec(c);
}
}
void gotControlC(void)
{
#ifdef FOOBAR
if ((SetSignal(0, SIGBREAKF_CTRL_C) & SIGBREAKF_CTRL_C) != 0)
{
(void) Write(dos_fh, "Interrupt!!!\n", 13);
ISt->is_argBool = TRUE;
return;
}
#endif
ISt->is_argBool = FALSE;
return;
}
/* /// "usbForceInterfaceBinding()" */
struct NepClassHid * usbForceInterfaceBinding(struct NepHidBase *nh, struct PsdInterface *pif)
{
struct Library *ps;
struct NepClassHid *nch;
struct PsdConfig *pc;
struct PsdDevice *pd;
STRPTR devname;
UBYTE buf[64];
struct Task *tmptask;
KPRINTF(1, ("nepHidAttemptInterfaceBinding(%08lx)\n", pif));
if((ps = OpenLibrary("poseidon.library", 4)))
{
if((nch = psdAllocVec(sizeof(struct NepClassHid))))
{
nch->nch_ClsBase = nh;
nch->nch_Device = NULL;
nch->nch_Interface = pif;
nLoadClassConfig(nh);
psdSafeRawDoFmt(buf, 64, "simplemidi.class<%08lx>", nch);
nch->nch_ReadySignal = SIGB_SINGLE;
nch->nch_ReadySigTask = FindTask(NULL);
SetSignal(0, SIGF_SINGLE);
if((tmptask = psdSpawnSubTask(buf, nHidTask, nch)))
{
psdBorrowLocksWait(tmptask, 1UL<<nch->nch_ReadySignal);
if(nch->nch_Task)
{
nch->nch_ReadySigTask = NULL;
//FreeSignal(nch->nch_ReadySignal);
psdGetAttrs(PGA_INTERFACE, pif, IFA_Config, &pc, TAG_END);
psdGetAttrs(PGA_CONFIG, pc, CA_Device, &pd, TAG_END);
psdGetAttrs(PGA_DEVICE, pd, DA_ProductName, &devname, TAG_END);
psdAddErrorMsg(RETURN_OK, (STRPTR) libname,
"Play it again, '%s'!",
devname);
CloseLibrary(ps);
return(nch);
}
}
nch->nch_ReadySigTask = NULL;
//FreeSignal(nch->nch_ReadySignal);
psdFreeVec(nch);
}
CloseLibrary(ps);
}
return(NULL);
}
ULONG amigaGetTriggerSigs(void)
{
ULONG trigs = 0, sigr;
sigr = SetSignal(0L,0L);
if ( sigr & SIGBREAKF_CTRL_C ) trigs |= DNETC_MSG_SHUTDOWN;
#ifndef NO_GUI
if ( DnetcBase && ModeReqIsSet(-1) ) trigs |= dnetcguiHandleMsgs(sigr);
#endif
#ifndef __OS3PPC__
/*
** 68K / OS4 / MorphOS
*/
if ( TriggerPort && sigr & 1L << TriggerPort->mp_SigBit ) {
struct TriggerMessage *msg;
while ((msg = (struct TriggerMessage *)GetMsg(TriggerPort))) {
trigs |= msg->tm_TriggerType;
ReplyMsg((struct Message *)msg);
}
}
#elif !defined(__POWERUP__)
/*
** WarpOS
*/
if ( TriggerPort && sigr & 1L << TriggerPort->mp_Port.mp_SigBit ) {
struct TriggerMessage *msg;
while ((msg = (struct TriggerMessage *)GetMsgPPC(TriggerPort))) {
trigs |= msg->tm_TriggerType;
ReplyMsgPPC((struct Message *)msg);
}
}
#else
/*
** PowerUp
*/
{
void *msg;
while ((msg = PPCGetMessage(TriggerPort))) {
trigs |= PPCGetMessageAttr(msg,PPCMSGTAG_MSGID);
PPCReplyMessage(msg);
}
}
#endif
return(trigs);
}
static struct Task *create_inputtask( struct inputtask_params *params)
{
struct Task *task;
APTR stack;
task = AllocMem(sizeof (struct Task), MEMF_PUBLIC|MEMF_CLEAR);
if (NULL != task)
{
NEWLIST(&task->tc_MemEntry);
task->tc_Node.ln_Type=NT_TASK;
task->tc_Node.ln_Name= INPUTTASK_NAME;
task->tc_Node.ln_Pri = INPUTTASK_PRIORITY;
stack=AllocMem(INPUTTASK_STACKSIZE, MEMF_PUBLIC);
if(NULL != stack)
{
task->tc_SPLower=stack;
task->tc_SPUpper=(BYTE *)stack + INPUTTASK_STACKSIZE;
task->tc_UserData=params;
#if AROS_STACK_GROWS_DOWNWARDS
task->tc_SPReg=(BYTE *)task->tc_SPUpper-SP_OFFSET-sizeof(APTR);
#else
task->tc_SPReg=(BYTE *)task->tc_SPLower-SP_OFFSET+sizeof(APTR);
#endif
/* You have to clear signals first. */
SetSignal(0, params->ok_signal | params->nok_signal);
if(AddTask(task, inputtask_entry, NULL) != NULL)
{
/* Everything went OK. Wait for task to initialize */
ULONG sigset;
D(bug("WAITING FOR SIGNAL\n"));
sigset = Wait( params->ok_signal | params->nok_signal );
D(bug("GOT SIGNAL\n"));
if (sigset & params->ok_signal)
return task;
}
FreeMem(stack, INPUTTASK_STACKSIZE);
}
FreeMem(task,sizeof(struct Task));
}
return NULL;
}
void ether_exit(void)
{
// Stop process
if (net_proc) {
SetSignal(0, SIGF_SINGLE);
Signal(&net_proc->pr_Task, SIGBREAKF_CTRL_C);
Wait(SIGF_SINGLE);
}
// Delete reply port
if (reply_port) {
DeleteMsgPort(reply_port);
reply_port = NULL;
}
}
static void SmallDelay(struct ExecBase *SysBase)
{
struct Interrupt i;
i.is_Code = (APTR)AHITimerTickCode;
i.is_Data = FindTask(0);
i.is_Node.ln_Name = "AROS AHI Driver Timer Tick Server";
i.is_Node.ln_Pri = 0;
i.is_Node.ln_Type = NT_INTERRUPT;
SetSignal(0, SIGBREAKF_CTRL_F);
AddIntServer(INTB_TIMERTICK, &i);
Wait(SIGBREAKF_CTRL_F);
RemIntServer(INTB_TIMERTICK, &i);
}
ULONG TellWBTaskToCloseWindows(struct IntuitionBase *IntuitionBase)
{
DEBUG_WORKBENCH(dprintf("TellWBTaskToCloseWindows: currenttask <%s>\n",
FindTask(NULL)->tc_Node.ln_Name));
if
(
GetPrivIBase(IntuitionBase)->WorkBenchMP != NULL
&& GetPrivIBase(IntuitionBase)->WorkBenchMP->mp_SigTask != FindTask(NULL)
)
{
struct MsgPort replymp;
struct IntuiMessage imsg;
/* Setup our reply port. By doing this manually, we can use SIGB_SINGLE
* and thus avoid allocating a signal (which may fail). */
memset( &replymp, 0, sizeof( replymp ) );
replymp.mp_Node.ln_Type = NT_MSGPORT;
replymp.mp_Flags = PA_SIGNAL;
replymp.mp_SigBit = SIGB_SINGLE;
replymp.mp_SigTask = FindTask( NULL );
NEWLIST( &replymp.mp_MsgList );
/* Setup our message */
imsg.ExecMessage.mn_ReplyPort = &replymp;
imsg.Class = IDCMP_WBENCHMESSAGE;
imsg.Code = WBENCHCLOSE;
SetSignal(0, SIGF_SINGLE);
DEBUG_WORKBENCH(dprintf("TellWBTaskToCloseWindows: Send Msg\n"));
/* Sends it to the handler and wait for the reply */
PutMsg( GetPrivIBase(IntuitionBase)->WorkBenchMP,
(struct Message *) &imsg );
WaitPort( &replymp );
/* After leaving this block imsg and repymp will be automagically freed,
* so we don't have to deallocate them ourselves. */
DEBUG_WORKBENCH(dprintf("TellWBTaskToCloseWindows: done\n"));
return(TRUE);
}
else
{
DEBUG_WORKBENCH(dprintf("TellWBTaskToCloseWindows: no Workbench port\n"));
}
return(FALSE);
}
int16 ASERDPort::close()
{
// Stop process
if (serial_proc) {
SetSignal(0, SIGF_SINGLE);
Signal(&serial_proc->pr_Task, SIGBREAKF_CTRL_C);
Wait(SIGF_SINGLE);
}
// Delete reply port
if (reply_port) {
DeleteMsgPort(reply_port);
reply_port = NULL;
}
return noErr;
}
int16 ASERDPort::open(uint16 config)
{
// Don't open NULL name devices
if (device_name == NULL)
return openErr;
// Init variables
err_mask = 0;
// Create message port
reply_port = CreateMsgPort();
if (reply_port == NULL)
goto open_error;
// Start process
proc_error = false;
proc_arg = this;
SetSignal(0, SIGF_SINGLE);
serial_proc = CreateNewProcTags(
NP_Entry, (ULONG)serial_func,
NP_Name, (ULONG)"Basilisk II Serial Task",
NP_Priority, 1,
TAG_END
);
if (serial_proc == NULL)
goto open_error;
// Wait for signal from process
Wait(SIGF_SINGLE);
// Initialization error? Then bail out
if (proc_error)
goto open_error;
// Configure port
configure(config);
return noErr;
open_error:
serial_proc = NULL;
if (reply_port) {
DeleteMsgPort(reply_port);
reply_port = NULL;
}
return openErr;
}
bool ether_init(void)
{
// Do nothing if no Ethernet device specified
if (PrefsFindString("ether") == NULL)
return false;
// Initialize protocol list
NewList(&prot_list);
// Create message port
reply_port = CreateMsgPort();
if (reply_port == NULL)
goto open_error;
D(bug("signal mask %08lx\n", 1 << reply_port->mp_SigBit));
// Start process
proc_error = false;
SetSignal(0, SIGF_SINGLE);
net_proc = CreateNewProcTags(
NP_Entry, (ULONG)net_func,
NP_Name, (ULONG)"Basilisk II Ethernet Task",
NP_Priority, 1,
TAG_END
);
if (net_proc == NULL)
goto open_error;
// Wait for signal from process
Wait(SIGF_SINGLE);
// Initialization error? Then bail out
if (proc_error)
goto open_error;
// Everything OK
return true;
open_error:
net_proc = NULL;
if (reply_port) {
DeleteMsgPort(reply_port);
reply_port = NULL;
}
return false;
}
int LCDA::OnVolts(MM::PropertyBase* pProp, MM::ActionType eAct)
{
if (eAct == MM::BeforeGet)
{
float volts;
int ret = LaserBoardGetAOV(channel_ - 1, &volts);
if (ret != DEVICE_OK)
return ret;
pProp->Set((double)volts);
}
else if (eAct == MM::AfterSet)
{
double volts;
pProp->Get(volts);
return SetSignal((double) volts);
}
return DEVICE_OK;
}
static int ata_expunge(struct ataBase *ATABase)
{
if (ATABase->ataObj)
{
/*
* CLID_Hidd_Storage is a singletone, you can get it as many times as
* you want. Here we save up some space in struct ataBase by
* obtaining storageRoot object only when we need it. This happens
* rarely, so small performance loss is OK here.
*/
OOP_Object *storageRoot = OOP_NewObject(NULL, CLID_Hidd_Storage, NULL);
if (storageRoot && HW_RemoveDriver(storageRoot, ATABase->ataObj))
{
/* Destroy our singletone */
OOP_MethodID disp_msg = OOP_GetMethodID(IID_Root, moRoot_Dispose);
D(bug("[ATA ] ata_expunge: Stopping Daemon...\n"));
ATABase->daemonParent = FindTask(NULL);
SetSignal(0, SIGF_SINGLE);
Signal(ATABase->ata_Daemon, SIGBREAKF_CTRL_C);
Wait(SIGF_SINGLE);
D(bug("[ATA ] ata_expunge: Done, destroying subystem object\n"));
OOP_DoSuperMethod(ATABase->ataClass, ATABase->ataObj, &disp_msg);
}
else
{
/* Our subsystem is in use, we have some bus driver(s) around. */
D(bug("[ATA ] ata_expunge: ATA subsystem is in use\n"));
return FALSE;
}
}
D(bug("[ATA ] ata_expunge: Releasing attribute bases\n"));
OOP_ReleaseAttrBasesArray(&ATABase->hwAttrBase, attrBaseIDs);
if (ATABase->ata_UtilityBase)
CloseLibrary(ATABase->ata_UtilityBase);
D(bug("[ATA ] ata_expunge: Exiting\n"));
return TRUE;
}
