コード例 #1
0
ファイル: say.c プロジェクト: vidarh/ACE
/* functions */
void cleanup_narrator()
{
 if (wmes)  CloseDevice(wmes);
 if (WPort) DeletePort(WPort);
 if (RPort) DeletePort(RPort);
 if (wmes)  DeleteExtIO(wmes);
 if (rmes)  DeleteExtIO(rmes);
}
コード例 #2
0
ファイル: Console.c プロジェクト: vidarh/amiga-spec
void cleanup()
    {
    if(OpenedConsole) CloseConsole(writeReq);
    if(readReq)       DeleteExtIO(readReq);
    if(readPort)      DeletePort(readPort);
    if(writeReq)      DeleteExtIO(writeReq);
    if(writePort)     DeletePort(writePort);
    if(win)           CloseWindow(win);
    if(IntuitionBase) CloseLibrary(IntuitionBase);
    }
コード例 #3
0
ファイル: ConsoleIO.c プロジェクト: jayminer81/NiKom
void CloseIO(void) {
	if(consoleyes) CloseConsole();
	if(conreadreq) DeleteExtIO((struct IORequest *)conreadreq);
	if(conreadport) DeleteMsgPort(conreadport);
	if(conwritereq) DeleteExtIO((struct IORequest *)conwritereq);
	if(conwriteport) DeleteMsgPort(conwriteport);

	if(timeryes) CloseTimer(timerreq);
	if(timerreq) DeleteExtIO((struct IORequest *)timerreq);
	if(timerport) DeleteMsgPort(timerport);
}
コード例 #4
0
ファイル: signal.c プロジェクト: DailyR/mudos
__stkargs void cleanup_timer(struct timerequest ** tr)
{
    struct MsgPort *tp;
    struct timerequest *tmp;
    UBYTE pFlags;

    if (*tr) {
	tmp = *tr;
	tp = tmp->tr_node.io_Message.mn_ReplyPort;
	if (tp) {
	    /* abort the current request */
	    pFlags = tp->mp_Flags;	/* still needed for DeletePort */
	    tp->mp_Flags = PA_IGNORE;
	    AbortIO((struct IORequest *) tmp);
	    WaitIO((struct IORequest *) tmp);
	    while (GetMsg(tp));
	    Forbid();
	    tp->mp_Flags = pFlags;
	    DeletePort(tp);
	    Permit();
	}
	CloseDevice((struct IORequest *) tmp);
	DeleteExtIO((struct IORequest *) tmp);
    }
    *tr = NULL;
}
コード例 #5
0
ファイル: cw_device.c プロジェクト: AreaScout/vice
int cw_device_close(void)
{
    unsigned int i;

    /* mute all sids */
    memset(sidbuf, 0, sizeof(sidbuf));
    for (i = 0; i < sizeof(sidbuf); i++) {
        write_sid(i, 0, i / 0x20);
    }

    for (i = 0; i < 2; i++) {
        if (gCatweaselReq[i]) {
            CloseDevice((struct IORequest *)gCatweaselReq[i]);
            if (gCatweaselReq[i] != NULL) {
                DeleteExtIO((struct IORequest *)gCatweaselReq[i]);
            }
            if (gDiskPort[i] != NULL) {
                DeletePort(gDiskPort[i]);
            }
            gCatweaselReq[i] = NULL;
            gDiskPort[i] = NULL;
        }
    }
	
    log_message(LOG_DEFAULT, "CatWeasel Device: closed");

    return 0;
}
コード例 #6
0
ファイル: signal.c プロジェクト: DailyR/mudos
__stkargs int setup_timer(LONG unit, struct timerequest ** tr)
{
    struct MsgPort *timerport;
    struct timerequest *req;

    if (*tr)
	return 1;

    if (!(timerport = (struct MsgPort *) CreatePort(0L, 0L))) {
	*tr = NULL;
	printf("setup_timer: could not create port\n");
	return 0;
    }
    if (!(req = (struct timerequest *) CreateExtIO(timerport
						,sizeof(struct timerequest))
	)) {
	DeletePort(timerport);
	*tr = NULL;
	printf("setup_timer: could not get request\n");
	return 0;
    }
    if (OpenDevice(TIMERNAME, unit, (struct IORequest *) req, 0L)) {
	CloseDevice((struct IORequest *) req);
	DeleteExtIO((struct IORequest *) req);
	DeletePort(timerport);
	printf("setup_timer: could not open timer\n");
	*tr = NULL;
	return 0;
    }
    *tr = req;
    return 1;
}
コード例 #7
0
ファイル: noise.c プロジェクト: axelmuhr/Helios-NG
void stop_noise(void)
{
   AbortIO(&(audioreq->ioa_Request));
   FreeMem(chipnoisedata, sizeof(noisedata) );
   CloseDevice(&(audioreq->ioa_Request));
   DeleteExtIO(&(audioreq->ioa_Request), sizeof(*audioreq)*2);
   DeletePort(nport);
}
コード例 #8
0
ファイル: archdep.c プロジェクト: r-type/vice-libretro
static void gettimeofday_shutdown(void)
{
    if (TimerIO) {
        CloseDevice(TimerIO);
        DeleteExtIO(TimerIO);
    }

    if (TimerMP) {
        DeletePort(TimerMP);
    }
    TimerBase = NULL;
}
コード例 #9
0
ファイル: usleep.c プロジェクト: OS2World/APP-GRAPHICS-IRIT
void
delete_timer(struct timerequest *tr)
{
  struct MsgPort *tp;
  if (tr != 0) {
    tp = tr->tr_node.io_Message.mn_ReplyPort;
    if (tp != 0) {
      DeletePort(tp);
    }
    CloseDevice((struct IORequest *) tr);
    DeleteExtIO((struct IORequest *) tr);
  }
}
コード例 #10
0
ファイル: timer.c プロジェクト: SimonKagstrom/sarien-j2me
void closetimer()
{
	if (TimerIO)
	{
		/* Delete any pending timer requests */
		if (!(CheckIO((struct IORequest *)TimerIO))) AbortIO((struct IORequest *)TimerIO);

		CloseDevice((struct IORequest *) TimerIO);
		DeleteExtIO((struct IORequest *) TimerIO);
	}

	if (TimerMP)
	{
		DeletePort(TimerMP);
	}
}
コード例 #11
0
ファイル: cw_device.c プロジェクト: AreaScout/vice
int cw_device_open(void)
{
    static int atexitinitialized = 0;
    unsigned int i;

    if (atexitinitialized) {
        cw_device_close();
    }

    gSIDs = 0;
    gSwapSIDs = FALSE;

    for (i = 0; i < 2; i++) {
        if ((gDiskPort[i] = CreatePort(NULL, 0)) != NULL) {
            if (gCatweaselReq[i] = (struct IOExtTD *)CreateExtIO(gDiskPort[i], sizeof(struct IOExtTD))) {
                if (OpenDevice("catweaselsid.device", i, (struct IORequest *)gCatweaselReq[i], 0)) {
                    DeleteExtIO((struct IORequest *)gCatweaselReq[i]);
                    DeletePort(gDiskPort[i]);
                    gCatweaselReq[i] = NULL;
                    gDiskPort[i] = NULL;
                } else {
                    gSIDs++;
                }
            }
        }
    }

    if (gSIDs == 0) {
        return -1;
    }

    if (gCatweaselReq[1] && gCatweaselReq[0] == NULL) {
        gSwapSIDs = TRUE;
    }
	
    /* install exit handler, so device is closed on exit */
    if (!atexitinitialized) {
        atexitinitialized = 1;
        atexit((voidfunc_t)cw_device_close);
    }

    sidfh = 1; /* ok */

    return 1;
}
コード例 #12
0
ファイル: amigaos_window.c プロジェクト: jaekim708/kiss
void _glfwPlatformCloseWindow( void )
{
    // Restore mouse pointer (if hidden)
    _glfwPlatformShowMouseCursor();

    // Destroy OpenGL context
    if( _glfwWin.Context )
    {
#ifdef _GLFW_STORMMESA
        AmigaMesaDestroyContext( _glfwWin.Context );
#endif
        _glfwWin.Context = NULL;
    }

    // Close window
    if( _glfwWin.Window )
    {
        CloseWindow( _glfwWin.Window );
        _glfwWin.Window = NULL;
    }

    // Close screen
    if( _glfwWin.Fullscreen && _glfwWin.Screen )
    {
        CloseScreen( _glfwWin.Screen );
    }
    _glfwWin.Screen = NULL;

    // Close input device I/O request
    if( _glfwWin.InputIO )
    {
        CloseDevice( (struct IORequest *) _glfwWin.InputIO );
        DeleteExtIO( (struct IORequest *) _glfwWin.InputIO );
        _glfwWin.InputIO = NULL;
    }

    // Close input device message port
    if( _glfwWin.InputMP )
    {
        DeletePort( _glfwWin.InputMP );
        _glfwWin.InputMP = NULL;
    }

}
コード例 #13
0
ファイル: test.c プロジェクト: cnvogelg/axb
int main(void)
{
    struct IOStdReq *ior;
    struct MsgPort *mp;
    char buff[10];

    Printf("main\n");
    if (mp = (struct MsgPort *)CreatePort(0,0))
    {
        Printf("got port\n");
        if (ior = (struct IOStdReq *)
                       CreateExtIO(mp, sizeof(struct IOStdReq)))
        {
            Printf("got extio\n");
            if (OpenDevice("example.device",0,(struct IORequest*)ior,0) == 0)
            {
                Printf("opened device\n");

                ior->io_Data = buff;
                ior->io_Command = CMD_READ;
                ior->io_Length = 1;
                DoIO((struct IORequest *)ior);
                Printf("done read\n");

                ior->io_Data = buff;
                ior->io_Command = CMD_WRITE;
                ior->io_Length = 1;
                DoIO((struct IORequest *)ior);
                Printf("done write\n");

                CloseDevice((struct IORequest *)ior);
            }
            DeleteExtIO((struct IORequest *)ior);
        }
        DeletePort(mp);
    }
    Printf("done\n");
    return 0;
}
コード例 #14
0
ファイル: debug.c プロジェクト: samskivert/garshneblanker
int main( void )
{
	struct Process *Proc = ( struct Process * )FindTask( 0L );
	BlankMsg *FreeMsg;
	LONG ReturnVal = 0;
	
	if( Proc->pr_CLI )
	{
		STRPTR Str = BADDR((( struct CommandLineInterface * )
							BADDR( Proc->pr_CLI ))->cli_CommandName );
		CopyMem( Str + 1, PrefsPath, *Str );
		PrefsPath[*Str] = '\0';
		strcat( PrefsPath, ".prefs" );
	}
	
	IntuitionBase = OpenLibrary( "intuition.library", 37L );
	GfxBase = OpenLibrary( GRAPHICSNAME, 37L );
	GarshnelibBase = OpenLibrary( "Garshnelib.library", 37L );
	
	if( IntuitionBase && GfxBase && GarshnelibBase )
	{
		ClientPort = CreateMsgPort();
		TimerPort = CreateMsgPort();
		
		if( ClientPort && TimerPort )
		{
			TimeOutIO = ( struct timerequest * )
				CreateExtIO( TimerPort, sizeof( struct timerequest ));
			
			if( TimeOutIO && !OpenDevice( "timer.device", UNIT_VBLANK,
										 ( struct IORequest * )TimeOutIO, 0L ))
			{
				ClientPort->mp_Node.ln_Name = PortName;
				ClientPort->mp_Node.ln_Pri = 0L;
				AddPort( ClientPort );
				CurPrefs = LoadPrefs( PrefsPath );
				
				CurrentTime( &InitSecs, &InitMicros );
				RangeSeed = InitSecs + InitMicros;
				
				Blank( CurPrefs );

				while( FreeMsg = ( BlankMsg * )GetMsg( ClientPort ))
				{
					if( FreeMsg->bm_Type & BF_REPLY )
						FreeVec( FreeMsg );
					else
					{
						FreeMsg->bm_Type |= BF_REPLY;
						ReplyMsg(( struct Message * )FreeMsg );
					}
				}
				
				if( CurPrefs )
					FreeVec( CurPrefs );
			
				if( !PortRemoved )
					RemPort( ClientPort );
			}
			
			if( TimeOutIO )
			{
				if( TimeOutIO->tr_node.io_Device )
					CloseDevice(( struct IORequest * )TimeOutIO );
				DeleteExtIO(( struct IORequest * )TimeOutIO );
			}
		}
		else
		{
			Complain( "ClientPort or TimerPort failed to open." );
			ReturnVal = 2;
		}

		if( ClientPort )
		{
			BlankMsg *TmpMsg;
			while( TmpMsg = ( BlankMsg * )GetMsg( ClientPort ))
			{
				TmpMsg->bm_Flags |= BF_REPLY;
				ReplyMsg(( struct Message * )TmpMsg );
			}
			DeleteMsgPort( ClientPort );
		}

		if( TimerPort )
			DeleteMsgPort( TimerPort );
	}
	else
	{
		Complain( "A library failed to open." );
		ReturnVal = 1;
	}
	
	if( GarshnelibBase )
		CloseLibrary( GarshnelibBase );
	
	if( GfxBase )
		CloseLibrary( GfxBase );
	
	if( IntuitionBase )
		CloseLibrary( IntuitionBase );
	
	return ReturnVal;
}
コード例 #15
0
ファイル: amigaos_window.c プロジェクト: jaekim708/kiss
int _glfwPlatformOpenWindow( int width, int height, int redbits,
    int greenbits, int bluebits, int alphabits, int depthbits,
    int stencilbits, int mode, int accumredbits, int accumgreenbits,
    int accumbluebits, int accumalphabits, int auxbuffers, int stereo,
    int refreshrate )
{
    struct TagItem tagList[ 25 ];
    int tagNR, accumbits;

    // Calculate sum of accumulator bits
    accumbits = accumredbits + accumgreenbits + accumbluebits +
                accumalphabits;

    // Clear window state
    _glfwWin.Screen        = NULL;
    _glfwWin.Window        = NULL;
    _glfwWin.Context       = NULL;
    _glfwWin.PointerHidden = 0;
    _glfwWin.PointerSprite = NULL;
    _glfwWin.InputMP       = NULL;
    _glfwWin.InputIO       = NULL;

    // Create input.device message port
    if( !(_glfwWin.InputMP = CreatePort( NULL, 0 )) )
    {
        _glfwPlatformCloseWindow();
        return GL_FALSE;
    }

    // Create input.device I/O request
    if( !(_glfwWin.InputIO = (struct IOStdReq *)
          CreateExtIO( _glfwWin.InputMP, sizeof(struct IOStdReq) )) )
    {
        _glfwPlatformCloseWindow();
        return GL_FALSE;
    }

    // Open input.device (for pointer position manipulation)
    if( OpenDevice( "input.device", 0,
                    (struct IORequest *)_glfwWin.InputIO, 0 ) )
    {
        DeleteExtIO( (struct IORequest *) _glfwWin.InputIO );
        _glfwWin.InputIO = NULL;
        _glfwPlatformCloseWindow();
        return GL_FALSE;
    }

    // Do we want fullscreen?
    if( _glfwWin.Fullscreen )
    {
        // Open a new Amiga screen
        if( !_glfwOpenScreen( &width, &height, &redbits, &greenbits,
                              &bluebits, refreshrate ) )
        {
            _glfwWin.Fullscreen = GL_FALSE;
        }
    }

    // Select window properties
    tagNR = 0;
    tagList[ tagNR   ].ti_Tag  = WA_Left;
    tagList[ tagNR++ ].ti_Data = 0;
    tagList[ tagNR   ].ti_Tag  = WA_Top;
    tagList[ tagNR++ ].ti_Data = 0;
    tagList[ tagNR   ].ti_Tag  = WA_IDCMP;
    tagList[ tagNR++ ].ti_Data = IDCMP_REFRESHWINDOW |
                                 IDCMP_CLOSEWINDOW |
                                 IDCMP_NEWSIZE |
                                 IDCMP_ACTIVEWINDOW |
                                 IDCMP_INACTIVEWINDOW |
                                 IDCMP_RAWKEY |
                                 IDCMP_MOUSEMOVE |
                                 IDCMP_MOUSEBUTTONS;
    tagList[ tagNR   ].ti_Tag  = WA_ReportMouse;
    tagList[ tagNR++ ].ti_Data = TRUE;
    tagList[ tagNR   ].ti_Tag  = WA_RMBTrap;
    tagList[ tagNR++ ].ti_Data = TRUE;
    tagList[ tagNR   ].ti_Tag  = WA_NoCareRefresh;
    tagList[ tagNR++ ].ti_Data = FALSE;
    tagList[ tagNR   ].ti_Tag  = WA_SimpleRefresh;
    tagList[ tagNR++ ].ti_Data = TRUE;
    tagList[ tagNR   ].ti_Tag  = WA_Activate;
    tagList[ tagNR++ ].ti_Data = TRUE;
    tagList[ tagNR   ].ti_Tag  = WA_CloseGadget;
    tagList[ tagNR++ ].ti_Data = _glfwWin.Fullscreen ? FALSE : TRUE;
    tagList[ tagNR   ].ti_Tag  = WA_SizeGadget;
    tagList[ tagNR++ ].ti_Data = _glfwWin.Fullscreen ? FALSE : ( _glfwWinHints.WindowNoResize ? FALSE : TRUE );
    tagList[ tagNR   ].ti_Tag  = WA_DepthGadget;
    tagList[ tagNR++ ].ti_Data = _glfwWin.Fullscreen ? FALSE : TRUE;
    tagList[ tagNR   ].ti_Tag  = WA_DragBar;
    tagList[ tagNR++ ].ti_Data = _glfwWin.Fullscreen ? FALSE : TRUE;
    tagList[ tagNR   ].ti_Tag  = WA_Borderless;
    tagList[ tagNR++ ].ti_Data = _glfwWin.Fullscreen ? TRUE : FALSE;
    tagList[ tagNR   ].ti_Tag  = WA_Backdrop;
    tagList[ tagNR++ ].ti_Data = _glfwWin.Fullscreen ? TRUE : FALSE;
    if( _glfwWin.Fullscreen )
    {
        tagList[ tagNR   ].ti_Tag  = WA_CustomScreen;
        tagList[ tagNR++ ].ti_Data = (ULONG) _glfwWin.Screen;
        tagList[ tagNR   ].ti_Tag  = WA_Width;
        tagList[ tagNR++ ].ti_Data = width;
        tagList[ tagNR   ].ti_Tag  = WA_Height;
        tagList[ tagNR++ ].ti_Data = height;
    }
    else
    {
        tagList[ tagNR   ].ti_Tag  = WA_GimmeZeroZero;
        tagList[ tagNR++ ].ti_Data = TRUE;
        tagList[ tagNR   ].ti_Tag  = WA_InnerWidth;
        tagList[ tagNR++ ].ti_Data = width;
        tagList[ tagNR   ].ti_Tag  = WA_InnerHeight;
        tagList[ tagNR++ ].ti_Data = height;
        tagList[ tagNR   ].ti_Tag  = WA_MinWidth;
        tagList[ tagNR++ ].ti_Data = 20;
        tagList[ tagNR   ].ti_Tag  = WA_MinHeight;
        tagList[ tagNR++ ].ti_Data = 20;
        tagList[ tagNR   ].ti_Tag  = WA_MaxWidth;
        tagList[ tagNR++ ].ti_Data = 9999;
        tagList[ tagNR   ].ti_Tag  = WA_MaxHeight;
        tagList[ tagNR++ ].ti_Data = 9999;
        tagList[ tagNR   ].ti_Tag  = WA_Title;
        tagList[ tagNR++ ].ti_Data = (ULONG) "GLFW Window";
        tagList[ tagNR   ].ti_Tag  = WA_ScreenTitle;
        tagList[ tagNR++ ].ti_Data = (ULONG) "GLFW Application";
    }
    tagList[ tagNR ].ti_Tag = TAG_DONE;

    // Open window
    _glfwWin.Window = OpenWindowTagList( NULL, tagList );
    if( !_glfwWin.Window )
    {
        _glfwPlatformCloseWindow();
        return GL_FALSE;
    }

    // Fullscreen/windowed post fixups
    if( _glfwWin.Fullscreen )
    {
        // Don't show screen title
        ShowTitle( _glfwWin.Screen, FALSE );

        // Remember window size
        _glfwWin.Width  = _glfwWin.Window->Width;
        _glfwWin.Height = _glfwWin.Window->Height;
    }
    else
    {
        // If we are not in fullscreen mode, get screen handle from window
        _glfwWin.Screen = _glfwWin.Window->WScreen;

        // Get ModeID for the current video mode
        _glfwWin.ModeID = GetVPModeID( &_glfwWin.Screen->ViewPort );

        // Remember window size
        _glfwWin.Width  = _glfwWin.Window->GZZWidth;
        _glfwWin.Height = _glfwWin.Window->GZZHeight;
    }

    // Put window on top
    WindowToFront( _glfwWin.Window );

    // Create OpenGL context
#ifdef _GLFW_STORMMESA
    tagNR = 0;
    tagList[ tagNR   ].ti_Tag  = AMA_Window;
    tagList[ tagNR++ ].ti_Data = (ULONG) _glfwWin.Window;
    tagList[ tagNR   ].ti_Tag  = AMA_RastPort;
    tagList[ tagNR++ ].ti_Data = (ULONG) _glfwWin.Window->RPort;
    tagList[ tagNR   ].ti_Tag  = AMA_Screen;
    tagList[ tagNR++ ].ti_Data = (ULONG) _glfwWin.Screen;
    tagList[ tagNR   ].ti_Tag  = AMA_Left;
    tagList[ tagNR++ ].ti_Data = 0;
    tagList[ tagNR   ].ti_Tag  = AMA_Bottom;
    tagList[ tagNR++ ].ti_Data = 0;
    tagList[ tagNR   ].ti_Tag  = AMA_Width;
    tagList[ tagNR++ ].ti_Data = _glfwWin.Width;
    tagList[ tagNR   ].ti_Tag  = AMA_Height;
    tagList[ tagNR++ ].ti_Data = _glfwWin.Height;
    tagList[ tagNR   ].ti_Tag  = AMA_DoubleBuf;
    tagList[ tagNR++ ].ti_Data = GL_TRUE;
    tagList[ tagNR   ].ti_Tag  = AMA_RGBMode;
    tagList[ tagNR++ ].ti_Data = GL_TRUE;
    tagList[ tagNR   ].ti_Tag  = AMA_AlphaFlag;
    tagList[ tagNR++ ].ti_Data = alphabits ? GL_TRUE : GL_FALSE;
    tagList[ tagNR   ].ti_Tag  = AMA_NoDepth;
    tagList[ tagNR++ ].ti_Data = depthbits ? GL_FALSE : GL_TRUE;
    tagList[ tagNR   ].ti_Tag  = AMA_NoStencil;
    tagList[ tagNR++ ].ti_Data = stencilbits ? GL_FALSE : GL_TRUE;
    tagList[ tagNR   ].ti_Tag  = AMA_NoAccum;
    tagList[ tagNR++ ].ti_Data = accumbits ? GL_FALSE : GL_TRUE;
    tagList[ tagNR   ].ti_Tag  = AMA_DirectRender;
    tagList[ tagNR++ ].ti_Data = GL_TRUE;
    tagList[ tagNR   ].ti_Tag  = AMA_DrawMode;
    tagList[ tagNR++ ].ti_Data = AMESA_AGA_C2P;
    tagList[ tagNR   ].ti_Tag  = TAG_DONE;
    _glfwWin.Context = AmigaMesaCreateContext( tagList );
#endif
    if( !_glfwWin.Context )
    {
        _glfwPlatformCloseWindow();
        return GL_FALSE;
    }

    // Make current
#ifdef _GLFW_STORMMESA
    AmigaMesaMakeCurrent( _glfwWin.Context, _glfwWin.Context->buffer );
#endif

    return GL_TRUE;
}
コード例 #16
0
ファイル: ami-rexx.c プロジェクト: diablodiab/libretro-uae
void DeleteStdIO (struct IORequest *ioreq)
{
    DeleteExtIO (ioreq);
}
コード例 #17
0
ファイル: iddr.c プロジェクト: MHeinrichs/AIDE2.19
void main(int argc,char *argv[]) {
   int unit;

   char *devicename; /* ML */

   if (argc!=2 && argc!=3) exit(0);
   unit = argv[1][0]-'0';
   if (unit!=0 && unit!=1) exit(0);

   port = (struct MsgPort *)CreatePort(0,0);
   if (!port) exit(10);

   req = (struct IOStdReq *)CreateExtIO(port, sizeof(struct IOExtTD));
   if (!req) exit(11);

   devicename="ide.device";  /* ML */
   if (argc==3) devicename=argv[2]; /* ML */
   if (OpenDevice (devicename,unit,(struct IORequest *)req,0)) exit(12);

   mu = (struct MyUnit *)req->io_Unit;
   if (argc==2) {
      printf("Device %d:\n",mu->mdu_UnitNum);
      if (mu->mdu_drv_type==ATAPI_DRV) {
         printf("  ATAPI device\n");
         printf("  Motor is          : ");
         if (mu->mdu_motor==0) printf("OFF\n"); else printf("ON\n");
         printf("  Disk change count : %d\n",mu->mdu_change_cnt);
         printf("  Disk inserted     : ");
         if (mu->mdu_no_disk==0) printf("YES\n"); else printf("NO\n");
      }
      else if (mu->mdu_drv_type==ATA_DRV) {
         printf("  ATA device\n");
         if (mu->mdu_lba) {
            printf("  LBA");
            if (mu->mdu_numlba) printf(" - %d user addressable sectors\n",mu->mdu_numlba);
            else printf("\n");
         } else printf("  no LBA\n");
         printf("  Sectors per track : %d\n",mu->mdu_sectors_per_track);
         printf("  Heads             : %d\n",mu->mdu_heads);
         printf("  Cylinders         : %d\n",mu->mdu_cylinders);
         printf("  Size              : %d MB\n",mu->mdu_sectors_per_track*mu->mdu_heads*mu->mdu_cylinders/2048);
         printf("  Motor is          : ");
         if (mu->mdu_motor==0) printf("OFF\n"); else printf("ON\n");
      }
      else printf("  not present\n",unit);
      if (mu->mdu_drv_type!=UNKNOWN_DRV && mu->mdu_auto) {
         printf("  Serial number     : %s\n",mu->mdu_ser_num);
         printf("  Firmware revision : %s\n",mu->mdu_firm_rev);
         printf("  Model number      : %s\n",mu->mdu_model_num);
      }
   }
   else {
      sprintf(hlp,"Ram:Drive%d",unit);
      if ((fd = fopen(hlp,"w"))!=NULL) {
         if (mu->mdu_drv_type==ATAPI_DRV) {
            fprintf(fd,"ATAPI\n");
         }
         else if (mu->mdu_drv_type==ATA_DRV) {
            fprintf(fd,"ATA\n");
            if (mu->mdu_lba) {
               fprintf(fd,"LBA %d\n",mu->mdu_numlba);
            } else fprintf(fd,"noLBA 0\n");
            fprintf(fd,"%d\n",mu->mdu_sectors_per_track);
            fprintf(fd,"%d\n",mu->mdu_heads);
            fprintf(fd,"%d\n",mu->mdu_cylinders);
            fprintf(fd,"%d\n",mu->mdu_sectors_per_track*mu->mdu_heads*mu->mdu_cylinders/2048);
         }
         else fprintf(fd,"NONE\n");
         if (mu->mdu_drv_type!=UNKNOWN_DRV) {
            if (mu->mdu_auto) {
               fprintf(fd,"[%s]\n",mu->mdu_ser_num);
               fprintf(fd,"[%s]\n",mu->mdu_firm_rev);
               fprintf(fd,"[%s]\n",mu->mdu_model_num);
            }
            else fprintf(fd,"X\nX\nX\n");
         }
      }
      fclose(fd);
   }

   CloseDevice((struct IORequest *)req);
   DeleteExtIO((struct IORequest *)req);
   DeletePort(port);
   exit(0);
}