src/video/Xext/Xxf86dga/XF86DGA.c
author Ryan C. Gordon <icculus@icculus.org>
Tue, 10 Jul 2007 13:52:07 +0000
branchSDL-1.2
changeset 4033 24c3ca822658
parent 4031 f0b8bbaf8de5
child 4144 904defc0792e
permissions -rw-r--r--
Added a '*/' for whiney compilers that don't like comments-in-comments.
     1 /* $XFree86: xc/lib/Xxf86dga/XF86DGA.c,v 3.19 2001/08/18 02:41:30 dawes Exp $ */
     2 /*
     3 
     4 Copyright (c) 1995  Jon Tombs
     5 Copyright (c) 1995,1996  The XFree86 Project, Inc
     6 
     7 */
     8 
     9 /* THIS IS NOT AN X CONSORTIUM STANDARD */
    10 
    11 #ifdef __EMX__ /* needed here to override certain constants in X headers */
    12 #define INCL_DOS
    13 #define INCL_DOSIOCTL
    14 #include <os2.h>
    15 #endif
    16 
    17 #if defined(linux)
    18 #define HAS_MMAP_ANON
    19 #include <sys/types.h>
    20 #include <sys/mman.h>
    21 /*#include <asm/page.h>*/   /* PAGE_SIZE */
    22 #define HAS_SC_PAGESIZE /* _SC_PAGESIZE may be an enum for Linux */
    23 #define HAS_GETPAGESIZE
    24 #endif /* linux */
    25 
    26 #if defined(CSRG_BASED)
    27 #define HAS_MMAP_ANON
    28 #define HAS_GETPAGESIZE
    29 #include <sys/types.h>
    30 #include <sys/mman.h>
    31 #endif /* CSRG_BASED */
    32 
    33 #if defined(DGUX)
    34 #define HAS_GETPAGESIZE
    35 #define MMAP_DEV_ZERO
    36 #include <sys/types.h>
    37 #include <sys/mman.h>
    38 #include <unistd.h>
    39 #endif /* DGUX */
    40 
    41 #if defined(SVR4) && !defined(DGUX)
    42 #define MMAP_DEV_ZERO
    43 #include <sys/types.h>
    44 #include <sys/mman.h>
    45 #include <unistd.h>
    46 #endif /* SVR4 && !DGUX */
    47 
    48 #if defined(sun) && !defined(SVR4) /* SunOS */
    49 #define MMAP_DEV_ZERO   /* doesn't SunOS have MAP_ANON ?? */
    50 #define HAS_GETPAGESIZE
    51 #include <sys/types.h>
    52 #include <sys/mman.h>
    53 #endif /* sun && !SVR4 */
    54 
    55 #ifdef XNO_SYSCONF
    56 #undef _SC_PAGESIZE
    57 #endif
    58 
    59 #define NEED_EVENTS
    60 #define NEED_REPLIES
    61 
    62 #include <X11/Xlibint.h>
    63 #include "../extensions/xf86dga.h"
    64 #include "../extensions/xf86dgastr.h"
    65 #include "../extensions/Xext.h"
    66 #include "../extensions/extutil.h"
    67 
    68 extern XExtDisplayInfo* SDL_NAME(xdga_find_display)(Display*);
    69 extern char *SDL_NAME(xdga_extension_name);
    70 
    71 #define XF86DGACheckExtension(dpy,i,val) \
    72   XextCheckExtension (dpy, i, SDL_NAME(xdga_extension_name), val)
    73 
    74 /*****************************************************************************
    75  *                                                                           *
    76  *		    public XFree86-DGA Extension routines                    *
    77  *                                                                           *
    78  *****************************************************************************/
    79 
    80 Bool SDL_NAME(XF86DGAQueryExtension) (
    81     Display *dpy,
    82     int *event_basep,
    83     int *error_basep
    84 ){
    85     return SDL_NAME(XDGAQueryExtension)(dpy, event_basep, error_basep);
    86 }
    87 
    88 Bool SDL_NAME(XF86DGAQueryVersion)(
    89     Display* dpy,
    90     int* majorVersion, 
    91     int* minorVersion
    92 ){
    93     return SDL_NAME(XDGAQueryVersion)(dpy, majorVersion, minorVersion);
    94 }
    95 
    96 Bool SDL_NAME(XF86DGAGetVideoLL)(
    97     Display* dpy,
    98     int screen,
    99     int *offset,
   100     int *width, 
   101     int *bank_size, 
   102     int *ram_size
   103 ){
   104     XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
   105     xXF86DGAGetVideoLLReply rep;
   106     xXF86DGAGetVideoLLReq *req;
   107 
   108     XF86DGACheckExtension (dpy, info, False);
   109 
   110     LockDisplay(dpy);
   111     GetReq(XF86DGAGetVideoLL, req);
   112     req->reqType = info->codes->major_opcode;
   113     req->dgaReqType = X_XF86DGAGetVideoLL;
   114     req->screen = screen;
   115     if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
   116 	UnlockDisplay(dpy);
   117 	SyncHandle();
   118 	return False;
   119     }
   120 
   121     *offset = /*(char *)*/rep.offset;
   122     *width = rep.width;
   123     *bank_size = rep.bank_size;
   124     *ram_size = rep.ram_size;
   125 	
   126     UnlockDisplay(dpy);
   127     SyncHandle();
   128     return True;
   129 }
   130 
   131     
   132 Bool SDL_NAME(XF86DGADirectVideoLL)(
   133     Display* dpy,
   134     int screen,
   135     int enable
   136 ){
   137     XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
   138     xXF86DGADirectVideoReq *req;
   139 
   140     XF86DGACheckExtension (dpy, info, False);
   141 
   142     LockDisplay(dpy);
   143     GetReq(XF86DGADirectVideo, req);
   144     req->reqType = info->codes->major_opcode;
   145     req->dgaReqType = X_XF86DGADirectVideo;
   146     req->screen = screen;
   147     req->enable = enable;
   148     UnlockDisplay(dpy);
   149     SyncHandle();
   150     XSync(dpy,False);
   151     return True;
   152 }
   153 
   154 Bool SDL_NAME(XF86DGAGetViewPortSize)(
   155     Display* dpy,
   156     int screen,
   157     int *width, 
   158     int *height
   159 ){
   160     XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
   161     xXF86DGAGetViewPortSizeReply rep;
   162     xXF86DGAGetViewPortSizeReq *req;
   163 
   164     XF86DGACheckExtension (dpy, info, False);
   165 
   166     LockDisplay(dpy);
   167     GetReq(XF86DGAGetViewPortSize, req);
   168     req->reqType = info->codes->major_opcode;
   169     req->dgaReqType = X_XF86DGAGetViewPortSize;
   170     req->screen = screen;
   171     if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
   172 	UnlockDisplay(dpy);
   173 	SyncHandle();
   174 	return False;
   175     }
   176 
   177     *width = rep.width;
   178     *height = rep.height;
   179 	
   180     UnlockDisplay(dpy);
   181     SyncHandle();
   182     return True;
   183 }
   184     
   185     
   186 Bool SDL_NAME(XF86DGASetViewPort)(
   187     Display* dpy,
   188     int screen,
   189     int x, 
   190     int y
   191 ){
   192     XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
   193     xXF86DGASetViewPortReq *req;
   194 
   195     XF86DGACheckExtension (dpy, info, False);
   196 
   197     LockDisplay(dpy);
   198     GetReq(XF86DGASetViewPort, req);
   199     req->reqType = info->codes->major_opcode;
   200     req->dgaReqType = X_XF86DGASetViewPort;
   201     req->screen = screen;
   202     req->x = x;
   203     req->y = y;
   204     UnlockDisplay(dpy);
   205     SyncHandle();
   206     XSync(dpy,False);
   207     return True;
   208 }
   209 
   210     
   211 Bool SDL_NAME(XF86DGAGetVidPage)(
   212     Display* dpy,
   213     int screen,
   214     int *vpage
   215 ){
   216     XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
   217     xXF86DGAGetVidPageReply rep;
   218     xXF86DGAGetVidPageReq *req;
   219 
   220     XF86DGACheckExtension (dpy, info, False);
   221 
   222     LockDisplay(dpy);
   223     GetReq(XF86DGAGetVidPage, req);
   224     req->reqType = info->codes->major_opcode;
   225     req->dgaReqType = X_XF86DGAGetVidPage;
   226     req->screen = screen;
   227     if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
   228 	UnlockDisplay(dpy);
   229 	SyncHandle();
   230 	return False;
   231     }
   232 
   233     *vpage = rep.vpage;
   234     UnlockDisplay(dpy);
   235     SyncHandle();
   236     return True;
   237 }
   238 
   239     
   240 Bool SDL_NAME(XF86DGASetVidPage)(
   241     Display* dpy,
   242     int screen,
   243     int vpage
   244 ){
   245     XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
   246     xXF86DGASetVidPageReq *req;
   247 
   248     XF86DGACheckExtension (dpy, info, False);
   249 
   250     LockDisplay(dpy);
   251     GetReq(XF86DGASetVidPage, req);
   252     req->reqType = info->codes->major_opcode;
   253     req->dgaReqType = X_XF86DGASetVidPage;
   254     req->screen = screen;
   255     req->vpage = vpage;
   256     UnlockDisplay(dpy);
   257     SyncHandle();
   258     XSync(dpy,False);
   259     return True;
   260 }
   261 
   262 Bool SDL_NAME(XF86DGAInstallColormap)(
   263     Display* dpy,
   264     int screen,
   265     Colormap cmap
   266 ){
   267     XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
   268     xXF86DGAInstallColormapReq *req;
   269 
   270     XF86DGACheckExtension (dpy, info, False);
   271 
   272     LockDisplay(dpy);
   273     GetReq(XF86DGAInstallColormap, req);
   274     req->reqType = info->codes->major_opcode;
   275     req->dgaReqType = X_XF86DGAInstallColormap;
   276     req->screen = screen;
   277     req->id = cmap;
   278     UnlockDisplay(dpy);
   279     SyncHandle();
   280     XSync(dpy,False);
   281     return True;
   282 }
   283 
   284 Bool SDL_NAME(XF86DGAQueryDirectVideo)(
   285     Display *dpy,
   286     int screen,
   287     int *flags
   288 ){
   289     XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
   290     xXF86DGAQueryDirectVideoReply rep;
   291     xXF86DGAQueryDirectVideoReq *req;
   292 
   293     XF86DGACheckExtension (dpy, info, False);
   294 
   295     LockDisplay(dpy);
   296     GetReq(XF86DGAQueryDirectVideo, req);
   297     req->reqType = info->codes->major_opcode;
   298     req->dgaReqType = X_XF86DGAQueryDirectVideo;
   299     req->screen = screen;
   300     if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
   301 	UnlockDisplay(dpy);
   302 	SyncHandle();
   303 	return False;
   304     }
   305     *flags = rep.flags;
   306     UnlockDisplay(dpy);
   307     SyncHandle();
   308     return True;
   309 }
   310 
   311 Bool SDL_NAME(XF86DGAViewPortChanged)(
   312     Display *dpy,
   313     int screen,
   314     int n
   315 ){
   316     XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
   317     xXF86DGAViewPortChangedReply rep;
   318     xXF86DGAViewPortChangedReq *req;
   319 
   320     XF86DGACheckExtension (dpy, info, False);
   321 
   322     LockDisplay(dpy);
   323     GetReq(XF86DGAViewPortChanged, req);
   324     req->reqType = info->codes->major_opcode;
   325     req->dgaReqType = X_XF86DGAViewPortChanged;
   326     req->screen = screen;
   327     req->n = n;
   328     if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
   329 	UnlockDisplay(dpy);
   330 	SyncHandle();
   331 	return False;
   332     }
   333     UnlockDisplay(dpy);
   334     SyncHandle();
   335     return rep.result;
   336 }
   337 
   338 
   339 
   340 /* Helper functions */
   341 
   342 #include <X11/Xmd.h>
   343 #include "../extensions/xf86dga.h"
   344 #include <stdlib.h>
   345 #include <stdio.h>
   346 #include <fcntl.h>
   347 #if defined(ISC) 
   348 # define HAS_SVR3_MMAP
   349 # include <sys/types.h>
   350 # include <errno.h>
   351 
   352 # include <sys/at_ansi.h>
   353 # include <sys/kd.h>
   354 
   355 # include <sys/sysmacros.h>
   356 # include <sys/immu.h>
   357 # include <sys/region.h>
   358 
   359 # include <sys/mmap.h>
   360 #else
   361 # if !defined(Lynx)
   362 #  if !defined(__EMX__)
   363 #   include <sys/mman.h>
   364 #  endif
   365 # else
   366 #  include <sys/types.h>
   367 #  include <errno.h>
   368 #  include <smem.h>
   369 # endif
   370 #endif
   371 #include <sys/wait.h>
   372 #include <signal.h>
   373 #include <unistd.h>
   374 
   375 #if defined(SVR4) && !defined(sun) && !defined(SCO325)
   376 #define DEV_MEM "/dev/pmem"
   377 #elif defined(SVR4) && defined(sun)
   378 #define DEV_MEM "/dev/xsvc"
   379 #else
   380 #define DEV_MEM "/dev/mem"
   381 #endif
   382 
   383 typedef struct {
   384     unsigned long physaddr;	/* actual requested physical address */
   385     unsigned long size;		/* actual requested map size */
   386     unsigned long delta;	/* delta to account for page alignment */
   387     void *	  vaddr;	/* mapped address, without the delta */
   388     int		  refcount;	/* reference count */
   389 } MapRec, *MapPtr;
   390 
   391 typedef struct {
   392     Display *	display;
   393     int		screen;
   394     MapPtr	map;
   395 } ScrRec, *ScrPtr;
   396 
   397 static int mapFd = -1;
   398 static int numMaps = 0;
   399 static int numScrs = 0;
   400 static MapPtr *mapList = NULL;
   401 static ScrPtr *scrList = NULL;
   402 
   403 static MapPtr
   404 AddMap(void)
   405 {
   406     MapPtr *old;
   407 
   408     old = mapList;
   409     mapList = realloc(mapList, sizeof(MapPtr) * (numMaps + 1));
   410     if (!mapList) {
   411 	mapList = old;
   412 	return NULL;
   413     }
   414     mapList[numMaps] = malloc(sizeof(MapRec));
   415     if (!mapList[numMaps])
   416 	return NULL;
   417     return mapList[numMaps++];
   418 }
   419 
   420 static ScrPtr
   421 AddScr(void)
   422 {
   423     ScrPtr *old;
   424 
   425     old = scrList;
   426     scrList = realloc(scrList, sizeof(ScrPtr) * (numScrs + 1));
   427     if (!scrList) {
   428 	scrList = old;
   429 	return NULL;
   430     }
   431     scrList[numScrs] = malloc(sizeof(ScrRec));
   432     if (!scrList[numScrs])
   433 	return NULL;
   434     return scrList[numScrs++];
   435 }
   436 
   437 static MapPtr
   438 FindMap(unsigned long address, unsigned long size)
   439 {
   440     int i;
   441 
   442     for (i = 0; i < numMaps; i++) {
   443 	if (mapList[i]->physaddr == address &&
   444 	    mapList[i]->size == size)
   445 	    return mapList[i];
   446     }
   447     return NULL;
   448 }
   449 
   450 static ScrPtr
   451 FindScr(Display *display, int screen)
   452 {
   453     int i;
   454 
   455     for (i = 0; i < numScrs; i++) {
   456 	if (scrList[i]->display == display &&
   457 	    scrList[i]->screen == screen)
   458 	    return scrList[i];
   459     }
   460     return NULL;
   461 }
   462 
   463 static void *
   464 MapPhysAddress(unsigned long address, unsigned long size)
   465 {
   466     unsigned long offset, delta;
   467     int pagesize = -1;
   468     void *vaddr;
   469     MapPtr mp;
   470 #if defined(ISC) && defined(HAS_SVR3_MMAP)
   471     struct kd_memloc mloc;
   472 #elif defined(__EMX__)
   473     APIRET rc;
   474     ULONG action;
   475     HFILE hfd;
   476 #endif
   477 
   478     if ((mp = FindMap(address, size))) {
   479 	mp->refcount++;
   480 	return (void *)((unsigned long)mp->vaddr + mp->delta);
   481     }
   482 
   483 #if defined(_SC_PAGESIZE) && defined(HAS_SC_PAGESIZE)
   484     pagesize = sysconf(_SC_PAGESIZE);
   485 #endif
   486 #ifdef _SC_PAGE_SIZE
   487     if (pagesize == -1)
   488 	pagesize = sysconf(_SC_PAGE_SIZE);
   489 #endif
   490 #ifdef HAS_GETPAGESIZE
   491     if (pagesize == -1)
   492 	pagesize = getpagesize();
   493 #endif
   494 #ifdef PAGE_SIZE
   495     if (pagesize == -1)
   496 	pagesize = PAGE_SIZE;
   497 #endif
   498     if (pagesize == -1)
   499 	pagesize = 4096;
   500 
   501    delta = address % pagesize;
   502    offset = address - delta;
   503 
   504 #if defined(ISC) && defined(HAS_SVR3_MMAP)
   505     if (mapFd < 0) {
   506 	if ((mapFd = open("/dev/mmap", O_RDWR)) < 0)
   507 	    return NULL;
   508     }
   509     mloc.vaddr = (char *)0;
   510     mloc.physaddr = (char *)offset;
   511     mloc.length = size + delta;
   512     mloc.ioflg=1;
   513 
   514     if ((vaddr = (void *)ioctl(mapFd, MAP, &mloc)) == (void *)-1)
   515 	return NULL;
   516 #elif defined (__EMX__)
   517     /*
   518      * Dragon warning here! /dev/pmap$ is never closed, except on progam exit.
   519      * Consecutive calling of this routine will make PMAP$ driver run out
   520      * of memory handles. Some umap/close mechanism should be provided
   521      */
   522 
   523     rc = DosOpen("/dev/pmap$", &hfd, &action, 0, FILE_NORMAL, FILE_OPEN,
   524 		 OPEN_ACCESS_READWRITE | OPEN_SHARE_DENYNONE, (PEAOP2)NULL);
   525     if (rc != 0)
   526 	return NULL;
   527     {
   528 	struct map_ioctl {
   529 		union {
   530 			ULONG phys;
   531 			void* user;
   532 		} a;
   533 		ULONG size;
   534 	} pmap,dmap;
   535 	ULONG plen,dlen;
   536 #define XFREE86_PMAP	0x76
   537 #define PMAP_MAP	0x44
   538 
   539 	pmap.a.phys = offset;
   540 	pmap.size = size + delta;
   541 	rc = DosDevIOCtl(hfd, XFREE86_PMAP, PMAP_MAP,
   542 			 (PULONG)&pmap, sizeof(pmap), &plen,
   543 			 (PULONG)&dmap, sizeof(dmap), &dlen);
   544 	if (rc == 0) {
   545 		vaddr = dmap.a.user;
   546 	}
   547    }
   548    if (rc != 0)
   549 	return NULL;
   550 #elif defined (Lynx)
   551     vaddr = (void *)smem_create("XF86DGA", (char *)offset, 
   552 				size + delta, SM_READ|SM_WRITE);
   553 #else
   554 #ifndef MAP_FILE
   555 #define MAP_FILE 0
   556 #endif
   557     if (mapFd < 0) {
   558 	if ((mapFd = open(DEV_MEM, O_RDWR)) < 0)
   559 	    return NULL;
   560     }
   561     vaddr = (void *)mmap(NULL, size + delta, PROT_READ | PROT_WRITE,
   562                         MAP_FILE | MAP_SHARED, mapFd, (off_t)offset);
   563     if (vaddr == (void *)-1)
   564 	return NULL;
   565 #endif
   566 
   567     if (!vaddr) {
   568 	if (!(mp = AddMap()))
   569 	    return NULL;
   570 	mp->physaddr = address;
   571 	mp->size = size;
   572 	mp->delta = delta;
   573 	mp->vaddr = vaddr;
   574 	mp->refcount = 1;
   575     }
   576     return (void *)((unsigned long)vaddr + delta);
   577 }
   578 
   579 /*
   580  * Still need to find a clean way of detecting the death of a DGA app
   581  * and returning things to normal - Jon
   582  * This is here to help debugging without rebooting... Also C-A-BS
   583  * should restore text mode.
   584  */
   585 
   586 int
   587 SDL_NAME(XF86DGAForkApp)(int screen)
   588 {
   589     pid_t pid;
   590     int status;
   591     int i;
   592 
   593      /* fork the app, parent hangs around to clean up */
   594     if ((pid = fork()) > 0) {
   595 	ScrPtr sp;
   596 
   597 	waitpid(pid, &status, 0);
   598 	for (i = 0; i < numScrs; i++) {
   599 	    sp = scrList[i];
   600 	    SDL_NAME(XF86DGADirectVideoLL)(sp->display, sp->screen, 0);
   601 	    XSync(sp->display, False);
   602 	}
   603         if (WIFEXITED(status))
   604 	    _exit(0);
   605 	else
   606 	    _exit(-1);
   607     }
   608     return pid;
   609 }
   610 
   611 
   612 Bool
   613 SDL_NAME(XF86DGADirectVideo)(
   614     Display *dis,
   615     int screen,
   616     int enable
   617 ){
   618     ScrPtr sp;
   619     MapPtr mp = NULL;
   620 
   621     if ((sp = FindScr(dis, screen)))
   622 	mp = sp->map;
   623 
   624     if (enable & XF86DGADirectGraphics) {
   625 #if !defined(ISC) && !defined(HAS_SVR3_MMAP) && !defined(Lynx) \
   626 	&& !defined(__EMX__)
   627 	if (mp && mp->vaddr)
   628 	    mprotect(mp->vaddr, mp->size + mp->delta, PROT_READ | PROT_WRITE);
   629 #endif
   630     } else {
   631 #if !defined(ISC) && !defined(HAS_SVR3_MMAP) && !defined(Lynx) \
   632 	&& !defined(__EMX__)
   633 	if (mp && mp->vaddr)
   634 	    mprotect(mp->vaddr, mp->size + mp->delta, PROT_READ);
   635 #elif defined(Lynx)
   636 	/* XXX this doesn't allow enable after disable */
   637 	smem_create(NULL, mp->vaddr, mp->size + mp->delta, SM_DETACH);
   638 	smem_remove("XF86DGA");
   639 #endif
   640     }
   641 
   642     SDL_NAME(XF86DGADirectVideoLL)(dis, screen, enable);
   643     return 1;
   644 }
   645 
   646 
   647 static void
   648 XF86cleanup(int sig)
   649 {
   650     ScrPtr sp;
   651     int i;
   652     static char beenhere = 0;
   653 
   654     if (beenhere)
   655 	_exit(3);
   656     beenhere = 1;
   657 
   658     for (i = 0; i < numScrs; i++) {
   659 	sp = scrList[i];
   660 	SDL_NAME(XF86DGADirectVideo)(sp->display, sp->screen, 0);
   661 	XSync(sp->display, False);
   662     }
   663     _exit(3);
   664 }
   665 
   666 Bool
   667 SDL_NAME(XF86DGAGetVideo)(
   668     Display *dis,
   669     int screen,
   670     char **addr,
   671     int *width, 
   672     int *bank, 
   673     int *ram
   674 ){
   675     /*unsigned long*/ int offset;
   676     static int beenHere = 0;
   677     ScrPtr sp;
   678     MapPtr mp;
   679 
   680     if (!(sp = FindScr(dis, screen))) {
   681 	if (!(sp = AddScr())) {
   682 	    fprintf(stderr, "XF86DGAGetVideo: malloc failure\n");
   683 	    exit(-2);
   684 	}
   685 	sp->display = dis;
   686 	sp->screen = screen;
   687 	sp->map = NULL;
   688     }
   689 
   690     SDL_NAME(XF86DGAGetVideoLL)(dis, screen , &offset, width, bank, ram);
   691 
   692     *addr = MapPhysAddress(offset, *bank);
   693     if (*addr == NULL) {
   694 	fprintf(stderr, "XF86DGAGetVideo: failed to map video memory (%s)\n",
   695 		strerror(errno));
   696 	exit(-2);
   697     }
   698 
   699     if ((mp = FindMap(offset, *bank)))
   700 	sp->map = mp;
   701 
   702     if (!beenHere) {
   703 	beenHere = 1;
   704 	atexit((void(*)(void))XF86cleanup);
   705 	/* one shot XF86cleanup attempts */
   706 	signal(SIGSEGV, XF86cleanup);
   707 #ifdef SIGBUS
   708 	signal(SIGBUS, XF86cleanup);
   709 #endif
   710 	signal(SIGHUP, XF86cleanup);
   711 	signal(SIGFPE, XF86cleanup);  
   712     }
   713 
   714     return 1;
   715 }
   716