distrib/sdl-1.2.12/src/video/Xext/Xxf86dga/XF86DGA.c - platform/external/qemu - Gitiles

 /* $XFree86: xc/lib/Xxf86dga/XF86DGA.c,v 3.19 2001/08/18 02:41:30 dawes Exp $ */
 /*

 Copyright (c) 1995  Jon Tombs
 Copyright (c) 1995,1996  The XFree86 Project, Inc

 */

 /* THIS IS NOT AN X CONSORTIUM STANDARD */

 #ifdef __EMX__ /* needed here to override certain constants in X headers */
 #define INCL_DOS
 #define INCL_DOSIOCTL
 #include <os2.h>
 #endif

 #if defined(linux)
 #define HAS_MMAP_ANON
 #include <sys/types.h>
 #include <sys/mman.h>
 /*#include <asm/page.h>*/   /* PAGE_SIZE */
 #define HAS_SC_PAGESIZE /* _SC_PAGESIZE may be an enum for Linux */
 #define HAS_GETPAGESIZE
 #endif /* linux */

 #if defined(CSRG_BASED)
 #define HAS_MMAP_ANON
 #define HAS_GETPAGESIZE
 #include <sys/types.h>
 #include <sys/mman.h>
 #endif /* CSRG_BASED */

 #if defined(DGUX)
 #define HAS_GETPAGESIZE
 #define MMAP_DEV_ZERO
 #include <sys/types.h>
 #include <sys/mman.h>
 #include <unistd.h>
 #endif /* DGUX */

 #if defined(SVR4) && !defined(DGUX)
 #define MMAP_DEV_ZERO
 #include <sys/types.h>
 #include <sys/mman.h>
 #include <unistd.h>
 #endif /* SVR4 && !DGUX */

 #if defined(sun) && !defined(SVR4) /* SunOS */
 #define MMAP_DEV_ZERO   /* doesn't SunOS have MAP_ANON ?? */
 #define HAS_GETPAGESIZE
 #include <sys/types.h>
 #include <sys/mman.h>
 #endif /* sun && !SVR4 */

 #ifdef XNO_SYSCONF
 #undef _SC_PAGESIZE
 #endif

 #define NEED_EVENTS
 #define NEED_REPLIES

 #include <X11/Xlibint.h>
 #include "../extensions/xf86dga.h"
 #include "../extensions/xf86dgastr.h"
 #include "../extensions/Xext.h"
 #include "../extensions/extutil.h"

 extern XExtDisplayInfo* SDL_NAME(xdga_find_display)(Display*);
 extern char *SDL_NAME(xdga_extension_name);

 #define XF86DGACheckExtension(dpy,i,val) \
   XextCheckExtension (dpy, i, SDL_NAME(xdga_extension_name), val)

 /*****************************************************************************
  *                                                                           *
  *		    public XFree86-DGA Extension routines                    *
  *                                                                           *
  *****************************************************************************/

 Bool SDL_NAME(XF86DGAQueryExtension) (
     Display *dpy,
     int *event_basep,
     int *error_basep
 ){
     return SDL_NAME(XDGAQueryExtension)(dpy, event_basep, error_basep);
 }

 Bool SDL_NAME(XF86DGAQueryVersion)(
     Display* dpy,
     int* majorVersion,
     int* minorVersion
 ){
     return SDL_NAME(XDGAQueryVersion)(dpy, majorVersion, minorVersion);
 }

 Bool SDL_NAME(XF86DGAGetVideoLL)(
     Display* dpy,
     int screen,
     int *offset,
     int *width,
     int *bank_size,
     int *ram_size
 ){
     XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
     xXF86DGAGetVideoLLReply rep;
     xXF86DGAGetVideoLLReq *req;

     XF86DGACheckExtension (dpy, info, False);

     LockDisplay(dpy);
     GetReq(XF86DGAGetVideoLL, req);
     req->reqType = info->codes->major_opcode;
     req->dgaReqType = X_XF86DGAGetVideoLL;
     req->screen = screen;
     if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
 	UnlockDisplay(dpy);
 	SyncHandle();
 	return False;
     }

     *offset = /*(char *)*/rep.offset;
     *width = rep.width;
     *bank_size = rep.bank_size;
     *ram_size = rep.ram_size;

     UnlockDisplay(dpy);
     SyncHandle();
     return True;
 }


 Bool SDL_NAME(XF86DGADirectVideoLL)(
     Display* dpy,
     int screen,
     int enable
 ){
     XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
     xXF86DGADirectVideoReq *req;

     XF86DGACheckExtension (dpy, info, False);

     LockDisplay(dpy);
     GetReq(XF86DGADirectVideo, req);
     req->reqType = info->codes->major_opcode;
     req->dgaReqType = X_XF86DGADirectVideo;
     req->screen = screen;
     req->enable = enable;
     UnlockDisplay(dpy);
     SyncHandle();
     XSync(dpy,False);
     return True;
 }

 Bool SDL_NAME(XF86DGAGetViewPortSize)(
     Display* dpy,
     int screen,
     int *width,
     int *height
 ){
     XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
     xXF86DGAGetViewPortSizeReply rep;
     xXF86DGAGetViewPortSizeReq *req;

     XF86DGACheckExtension (dpy, info, False);

     LockDisplay(dpy);
     GetReq(XF86DGAGetViewPortSize, req);
     req->reqType = info->codes->major_opcode;
     req->dgaReqType = X_XF86DGAGetViewPortSize;
     req->screen = screen;
     if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
 	UnlockDisplay(dpy);
 	SyncHandle();
 	return False;
     }

     *width = rep.width;
     *height = rep.height;

     UnlockDisplay(dpy);
     SyncHandle();
     return True;
 }


 Bool SDL_NAME(XF86DGASetViewPort)(
     Display* dpy,
     int screen,
     int x,
     int y
 ){
     XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
     xXF86DGASetViewPortReq *req;

     XF86DGACheckExtension (dpy, info, False);

     LockDisplay(dpy);
     GetReq(XF86DGASetViewPort, req);
     req->reqType = info->codes->major_opcode;
     req->dgaReqType = X_XF86DGASetViewPort;
     req->screen = screen;
     req->x = x;
     req->y = y;
     UnlockDisplay(dpy);
     SyncHandle();
     XSync(dpy,False);
     return True;
 }


 Bool SDL_NAME(XF86DGAGetVidPage)(
     Display* dpy,
     int screen,
     int *vpage
 ){
     XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
     xXF86DGAGetVidPageReply rep;
     xXF86DGAGetVidPageReq *req;

     XF86DGACheckExtension (dpy, info, False);

     LockDisplay(dpy);
     GetReq(XF86DGAGetVidPage, req);
     req->reqType = info->codes->major_opcode;
     req->dgaReqType = X_XF86DGAGetVidPage;
     req->screen = screen;
     if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
 	UnlockDisplay(dpy);
 	SyncHandle();
 	return False;
     }

     *vpage = rep.vpage;
     UnlockDisplay(dpy);
     SyncHandle();
     return True;
 }


 Bool SDL_NAME(XF86DGASetVidPage)(
     Display* dpy,
     int screen,
     int vpage
 ){
     XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
     xXF86DGASetVidPageReq *req;

     XF86DGACheckExtension (dpy, info, False);

     LockDisplay(dpy);
     GetReq(XF86DGASetVidPage, req);
     req->reqType = info->codes->major_opcode;
     req->dgaReqType = X_XF86DGASetVidPage;
     req->screen = screen;
     req->vpage = vpage;
     UnlockDisplay(dpy);
     SyncHandle();
     XSync(dpy,False);
     return True;
 }

 Bool SDL_NAME(XF86DGAInstallColormap)(
     Display* dpy,
     int screen,
     Colormap cmap
 ){
     XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
     xXF86DGAInstallColormapReq *req;

     XF86DGACheckExtension (dpy, info, False);

     LockDisplay(dpy);
     GetReq(XF86DGAInstallColormap, req);
     req->reqType = info->codes->major_opcode;
     req->dgaReqType = X_XF86DGAInstallColormap;
     req->screen = screen;
     req->id = cmap;
     UnlockDisplay(dpy);
     SyncHandle();
     XSync(dpy,False);
     return True;
 }

 Bool SDL_NAME(XF86DGAQueryDirectVideo)(
     Display *dpy,
     int screen,
     int *flags
 ){
     XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
     xXF86DGAQueryDirectVideoReply rep;
     xXF86DGAQueryDirectVideoReq *req;

     XF86DGACheckExtension (dpy, info, False);

     LockDisplay(dpy);
     GetReq(XF86DGAQueryDirectVideo, req);
     req->reqType = info->codes->major_opcode;
     req->dgaReqType = X_XF86DGAQueryDirectVideo;
     req->screen = screen;
     if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
 	UnlockDisplay(dpy);
 	SyncHandle();
 	return False;
     }
     *flags = rep.flags;
     UnlockDisplay(dpy);
     SyncHandle();
     return True;
 }

 Bool SDL_NAME(XF86DGAViewPortChanged)(
     Display *dpy,
     int screen,
     int n
 ){
     XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
     xXF86DGAViewPortChangedReply rep;
     xXF86DGAViewPortChangedReq *req;

     XF86DGACheckExtension (dpy, info, False);

     LockDisplay(dpy);
     GetReq(XF86DGAViewPortChanged, req);
     req->reqType = info->codes->major_opcode;
     req->dgaReqType = X_XF86DGAViewPortChanged;
     req->screen = screen;
     req->n = n;
     if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
 	UnlockDisplay(dpy);
 	SyncHandle();
 	return False;
     }
     UnlockDisplay(dpy);
     SyncHandle();
     return rep.result;
 }


 /* Helper functions */

 #include <X11/Xmd.h>
 #include "../extensions/xf86dga.h"
 #include <stdlib.h>
 #include <stdio.h>
 #include <fcntl.h>
 #if defined(ISC)
 # define HAS_SVR3_MMAP
 # include <sys/types.h>
 # include <errno.h>

 # include <sys/at_ansi.h>
 # include <sys/kd.h>

 # include <sys/sysmacros.h>
 # include <sys/immu.h>
 # include <sys/region.h>

 # include <sys/mmap.h>
 #else
 # if !defined(Lynx)
 #  if !defined(__EMX__)
 #   include <sys/mman.h>
 #  endif
 # else
 #  include <sys/types.h>
 #  include <errno.h>
 #  include <smem.h>
 # endif
 #endif
 #include <sys/wait.h>
 #include <signal.h>
 #include <unistd.h>

 #if defined(SVR4) && !defined(sun) && !defined(SCO325)
 #define DEV_MEM "/dev/pmem"
 #elif defined(SVR4) && defined(sun)
 #define DEV_MEM "/dev/xsvc"
 #else
 #define DEV_MEM "/dev/mem"
 #endif

 typedef struct {
     unsigned long physaddr;	/* actual requested physical address */
     unsigned long size;		/* actual requested map size */
     unsigned long delta;	/* delta to account for page alignment */
     void *	  vaddr;	/* mapped address, without the delta */
     int		  refcount;	/* reference count */
 } MapRec, *MapPtr;

 typedef struct {
     Display *	display;
     int		screen;
     MapPtr	map;
 } ScrRec, *ScrPtr;

 static int mapFd = -1;
 static int numMaps = 0;
 static int numScrs = 0;
 static MapPtr *mapList = NULL;
 static ScrPtr *scrList = NULL;

 static MapPtr
 AddMap(void)
 {
     MapPtr *old;

     old = mapList;
     mapList = realloc(mapList, sizeof(MapPtr) * (numMaps + 1));
     if (!mapList) {
 	mapList = old;
 	return NULL;
     }
     mapList[numMaps] = malloc(sizeof(MapRec));
     if (!mapList[numMaps])
 	return NULL;
     return mapList[numMaps++];
 }

 static ScrPtr
 AddScr(void)
 {
     ScrPtr *old;

     old = scrList;
     scrList = realloc(scrList, sizeof(ScrPtr) * (numScrs + 1));
     if (!scrList) {
 	scrList = old;
 	return NULL;
     }
     scrList[numScrs] = malloc(sizeof(ScrRec));
     if (!scrList[numScrs])
 	return NULL;
     return scrList[numScrs++];
 }

 static MapPtr
 FindMap(unsigned long address, unsigned long size)
 {
     int i;

     for (i = 0; i < numMaps; i++) {
 	if (mapList[i]->physaddr == address &&
 	    mapList[i]->size == size)
 	    return mapList[i];
     }
     return NULL;
 }

 static ScrPtr
 FindScr(Display *display, int screen)
 {
     int i;

     for (i = 0; i < numScrs; i++) {
 	if (scrList[i]->display == display &&
 	    scrList[i]->screen == screen)
 	    return scrList[i];
     }
     return NULL;
 }

 static void *
 MapPhysAddress(unsigned long address, unsigned long size)
 {
     unsigned long offset, delta;
     int pagesize = -1;
     void *vaddr;
     MapPtr mp;
 #if defined(ISC) && defined(HAS_SVR3_MMAP)
     struct kd_memloc mloc;
 #elif defined(__EMX__)
     APIRET rc;
     ULONG action;
     HFILE hfd;
 #endif

     if ((mp = FindMap(address, size))) {
 	mp->refcount++;
 	return (void *)((unsigned long)mp->vaddr + mp->delta);
     }

 #if defined(_SC_PAGESIZE) && defined(HAS_SC_PAGESIZE)
     pagesize = sysconf(_SC_PAGESIZE);
 #endif
 #ifdef _SC_PAGE_SIZE
     if (pagesize == -1)
 	pagesize = sysconf(_SC_PAGE_SIZE);
 #endif
 #ifdef HAS_GETPAGESIZE
     if (pagesize == -1)
 	pagesize = getpagesize();
 #endif
 #ifdef PAGE_SIZE
     if (pagesize == -1)
 	pagesize = PAGE_SIZE;
 #endif
     if (pagesize == -1)
 	pagesize = 4096;

    delta = address % pagesize;
    offset = address - delta;

 #if defined(ISC) && defined(HAS_SVR3_MMAP)
     if (mapFd < 0) {
 	if ((mapFd = open("/dev/mmap", O_RDWR)) < 0)
 	    return NULL;
     }
     mloc.vaddr = (char *)0;
     mloc.physaddr = (char *)offset;
     mloc.length = size + delta;
     mloc.ioflg=1;

     if ((vaddr = (void *)ioctl(mapFd, MAP, &mloc)) == (void *)-1)
 	return NULL;
 #elif defined (__EMX__)
     /*
      * Dragon warning here! /dev/pmap$ is never closed, except on progam exit.
      * Consecutive calling of this routine will make PMAP$ driver run out
      * of memory handles. Some umap/close mechanism should be provided
      */

     rc = DosOpen("/dev/pmap$", &hfd, &action, 0, FILE_NORMAL, FILE_OPEN,
 		 OPEN_ACCESS_READWRITE | OPEN_SHARE_DENYNONE, (PEAOP2)NULL);
     if (rc != 0)
 	return NULL;
     {
 	struct map_ioctl {
 		union {
 			ULONG phys;
 			void* user;
 		} a;
 		ULONG size;
 	} pmap,dmap;
 	ULONG plen,dlen;
 #define XFREE86_PMAP	0x76
 #define PMAP_MAP	0x44

 	pmap.a.phys = offset;
 	pmap.size = size + delta;
 	rc = DosDevIOCtl(hfd, XFREE86_PMAP, PMAP_MAP,
 			 (PULONG)&pmap, sizeof(pmap), &plen,
 			 (PULONG)&dmap, sizeof(dmap), &dlen);
 	if (rc == 0) {
 		vaddr = dmap.a.user;
 	}
    }
    if (rc != 0)
 	return NULL;
 #elif defined (Lynx)
     vaddr = (void *)smem_create("XF86DGA", (char *)offset,
 				size + delta, SM_READ|SM_WRITE);
 #else
 #ifndef MAP_FILE
 #define MAP_FILE 0
 #endif
     if (mapFd < 0) {
 	if ((mapFd = open(DEV_MEM, O_RDWR)) < 0)
 	    return NULL;
     }
     vaddr = (void *)mmap(NULL, size + delta, PROT_READ | PROT_WRITE,
                         MAP_FILE | MAP_SHARED, mapFd, (off_t)offset);
     if (vaddr == (void *)-1)
 	return NULL;
 #endif

     if (!vaddr) {
 	if (!(mp = AddMap()))
 	    return NULL;
 	mp->physaddr = address;
 	mp->size = size;
 	mp->delta = delta;
 	mp->vaddr = vaddr;
 	mp->refcount = 1;
     }
     return (void *)((unsigned long)vaddr + delta);
 }

 /*
  * Still need to find a clean way of detecting the death of a DGA app
  * and returning things to normal - Jon
  * This is here to help debugging without rebooting... Also C-A-BS
  * should restore text mode.
  */

 int
 SDL_NAME(XF86DGAForkApp)(int screen)
 {
     pid_t pid;
     int status;
     int i;

      /* fork the app, parent hangs around to clean up */
     if ((pid = fork()) > 0) {
 	ScrPtr sp;

 	waitpid(pid, &status, 0);
 	for (i = 0; i < numScrs; i++) {
 	    sp = scrList[i];
 	    SDL_NAME(XF86DGADirectVideoLL)(sp->display, sp->screen, 0);
 	    XSync(sp->display, False);
 	}
         if (WIFEXITED(status))
 	    _exit(0);
 	else
 	    _exit(-1);
     }
     return pid;
 }


 Bool
 SDL_NAME(XF86DGADirectVideo)(
     Display *dis,
     int screen,
     int enable
 ){
     ScrPtr sp;
     MapPtr mp = NULL;

     if ((sp = FindScr(dis, screen)))
 	mp = sp->map;

     if (enable & XF86DGADirectGraphics) {
 #if !defined(ISC) && !defined(HAS_SVR3_MMAP) && !defined(Lynx) \
 	&& !defined(__EMX__)
 	if (mp && mp->vaddr)
 	    mprotect(mp->vaddr, mp->size + mp->delta, PROT_READ | PROT_WRITE);
 #endif
     } else {
 #if !defined(ISC) && !defined(HAS_SVR3_MMAP) && !defined(Lynx) \
 	&& !defined(__EMX__)
 	if (mp && mp->vaddr)
 	    mprotect(mp->vaddr, mp->size + mp->delta, PROT_READ);
 #elif defined(Lynx)
 	/* XXX this doesn't allow enable after disable */
 	smem_create(NULL, mp->vaddr, mp->size + mp->delta, SM_DETACH);
 	smem_remove("XF86DGA");
 #endif
     }

     SDL_NAME(XF86DGADirectVideoLL)(dis, screen, enable);
     return 1;
 }


 static void
 XF86cleanup(int sig)
 {
     ScrPtr sp;
     int i;
     static char beenhere = 0;

     if (beenhere)
 	_exit(3);
     beenhere = 1;

     for (i = 0; i < numScrs; i++) {
 	sp = scrList[i];
 	SDL_NAME(XF86DGADirectVideo)(sp->display, sp->screen, 0);
 	XSync(sp->display, False);
     }
     _exit(3);
 }

 Bool
 SDL_NAME(XF86DGAGetVideo)(
     Display *dis,
     int screen,
     char **addr,
     int *width,
     int *bank,
     int *ram
 ){
     /*unsigned long*/ int offset;
     static int beenHere = 0;
     ScrPtr sp;
     MapPtr mp;

     if (!(sp = FindScr(dis, screen))) {
 	if (!(sp = AddScr())) {
 	    fprintf(stderr, "XF86DGAGetVideo: malloc failure\n");
 	    exit(-2);
 	}
 	sp->display = dis;
 	sp->screen = screen;
 	sp->map = NULL;
     }

     SDL_NAME(XF86DGAGetVideoLL)(dis, screen , &offset, width, bank, ram);

     *addr = MapPhysAddress(offset, *bank);
     if (*addr == NULL) {
 	fprintf(stderr, "XF86DGAGetVideo: failed to map video memory (%s)\n",
 		strerror(errno));
 	exit(-2);
     }

     if ((mp = FindMap(offset, *bank)))
 	sp->map = mp;

     if (!beenHere) {
 	beenHere = 1;
 	atexit((void(*)(void))XF86cleanup);
 	/* one shot XF86cleanup attempts */
 	signal(SIGSEGV, XF86cleanup);
 #ifdef SIGBUS
 	signal(SIGBUS, XF86cleanup);
 #endif
 	signal(SIGHUP, XF86cleanup);
 	signal(SIGFPE, XF86cleanup);
     }

     return 1;
 }
	/* $XFree86: xc/lib/Xxf86dga/XF86DGA.c,v 3.19 2001/08/18 02:41:30 dawes Exp $ */
	/*

	Copyright (c) 1995 Jon Tombs
	Copyright (c) 1995,1996 The XFree86 Project, Inc

	*/

	/* THIS IS NOT AN X CONSORTIUM STANDARD */

	#ifdef __EMX__ /* needed here to override certain constants in X headers */
	#define INCL_DOS
	#define INCL_DOSIOCTL
	#include <os2.h>
	#endif

	#if defined(linux)
	#define HAS_MMAP_ANON
	#include <sys/types.h>
	#include <sys/mman.h>
	/#include <asm/page.h>/ /* PAGE_SIZE */
	#define HAS_SC_PAGESIZE /* _SC_PAGESIZE may be an enum for Linux */
	#define HAS_GETPAGESIZE
	#endif /* linux */

	#if defined(CSRG_BASED)
	#define HAS_MMAP_ANON
	#define HAS_GETPAGESIZE
	#include <sys/types.h>
	#include <sys/mman.h>
	#endif /* CSRG_BASED */

	#if defined(DGUX)
	#define HAS_GETPAGESIZE
	#define MMAP_DEV_ZERO
	#include <sys/types.h>
	#include <sys/mman.h>
	#include <unistd.h>
	#endif /* DGUX */

	#if defined(SVR4) && !defined(DGUX)
	#define MMAP_DEV_ZERO
	#include <sys/types.h>
	#include <sys/mman.h>
	#include <unistd.h>
	#endif /* SVR4 && !DGUX */

	#if defined(sun) && !defined(SVR4) /* SunOS */
	#define MMAP_DEV_ZERO /* doesn't SunOS have MAP_ANON ?? */
	#define HAS_GETPAGESIZE
	#include <sys/types.h>
	#include <sys/mman.h>
	#endif /* sun && !SVR4 */

	#ifdef XNO_SYSCONF
	#undef _SC_PAGESIZE
	#endif

	#define NEED_EVENTS
	#define NEED_REPLIES

	#include <X11/Xlibint.h>
	#include "../extensions/xf86dga.h"
	#include "../extensions/xf86dgastr.h"
	#include "../extensions/Xext.h"
	#include "../extensions/extutil.h"

	extern XExtDisplayInfo* SDL_NAME(xdga_find_display)(Display*);
	extern char *SDL_NAME(xdga_extension_name);

	#define XF86DGACheckExtension(dpy,i,val) \
	XextCheckExtension (dpy, i, SDL_NAME(xdga_extension_name), val)

	/*****************************************************************************
	* *
	* public XFree86-DGA Extension routines *
	* *
	*****************************************************************************/

	Bool SDL_NAME(XF86DGAQueryExtension) (
	Display *dpy,
	int *event_basep,
	int *error_basep
	){
	return SDL_NAME(XDGAQueryExtension)(dpy, event_basep, error_basep);
	}

	Bool SDL_NAME(XF86DGAQueryVersion)(
	Display* dpy,
	int* majorVersion,
	int* minorVersion
	){
	return SDL_NAME(XDGAQueryVersion)(dpy, majorVersion, minorVersion);
	}

	Bool SDL_NAME(XF86DGAGetVideoLL)(
	Display* dpy,
	int screen,
	int *offset,
	int *width,
	int *bank_size,
	int *ram_size
	){
	XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
	xXF86DGAGetVideoLLReply rep;
	xXF86DGAGetVideoLLReq *req;

	XF86DGACheckExtension (dpy, info, False);

	LockDisplay(dpy);
	GetReq(XF86DGAGetVideoLL, req);
	req->reqType = info->codes->major_opcode;
	req->dgaReqType = X_XF86DGAGetVideoLL;
	req->screen = screen;
	if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
	UnlockDisplay(dpy);
	SyncHandle();
	return False;
	}

	offset = /(char )/rep.offset;
	*width = rep.width;
	*bank_size = rep.bank_size;
	*ram_size = rep.ram_size;

	UnlockDisplay(dpy);
	SyncHandle();
	return True;
	}


	Bool SDL_NAME(XF86DGADirectVideoLL)(
	Display* dpy,
	int screen,
	int enable
	){
	XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
	xXF86DGADirectVideoReq *req;

	XF86DGACheckExtension (dpy, info, False);

	LockDisplay(dpy);
	GetReq(XF86DGADirectVideo, req);
	req->reqType = info->codes->major_opcode;
	req->dgaReqType = X_XF86DGADirectVideo;
	req->screen = screen;
	req->enable = enable;
	UnlockDisplay(dpy);
	SyncHandle();
	XSync(dpy,False);
	return True;
	}

	Bool SDL_NAME(XF86DGAGetViewPortSize)(
	Display* dpy,
	int screen,
	int *width,
	int *height
	){
	XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
	xXF86DGAGetViewPortSizeReply rep;
	xXF86DGAGetViewPortSizeReq *req;

	XF86DGACheckExtension (dpy, info, False);

	LockDisplay(dpy);
	GetReq(XF86DGAGetViewPortSize, req);
	req->reqType = info->codes->major_opcode;
	req->dgaReqType = X_XF86DGAGetViewPortSize;
	req->screen = screen;
	if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
	UnlockDisplay(dpy);
	SyncHandle();
	return False;
	}

	*width = rep.width;
	*height = rep.height;

	UnlockDisplay(dpy);
	SyncHandle();
	return True;
	}


	Bool SDL_NAME(XF86DGASetViewPort)(
	Display* dpy,
	int screen,
	int x,
	int y
	){
	XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
	xXF86DGASetViewPortReq *req;

	XF86DGACheckExtension (dpy, info, False);

	LockDisplay(dpy);
	GetReq(XF86DGASetViewPort, req);
	req->reqType = info->codes->major_opcode;
	req->dgaReqType = X_XF86DGASetViewPort;
	req->screen = screen;
	req->x = x;
	req->y = y;
	UnlockDisplay(dpy);
	SyncHandle();
	XSync(dpy,False);
	return True;
	}


	Bool SDL_NAME(XF86DGAGetVidPage)(
	Display* dpy,
	int screen,
	int *vpage
	){
	XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
	xXF86DGAGetVidPageReply rep;
	xXF86DGAGetVidPageReq *req;

	XF86DGACheckExtension (dpy, info, False);

	LockDisplay(dpy);
	GetReq(XF86DGAGetVidPage, req);
	req->reqType = info->codes->major_opcode;
	req->dgaReqType = X_XF86DGAGetVidPage;
	req->screen = screen;
	if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
	UnlockDisplay(dpy);
	SyncHandle();
	return False;
	}

	*vpage = rep.vpage;
	UnlockDisplay(dpy);
	SyncHandle();
	return True;
	}


	Bool SDL_NAME(XF86DGASetVidPage)(
	Display* dpy,
	int screen,
	int vpage
	){
	XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
	xXF86DGASetVidPageReq *req;

	XF86DGACheckExtension (dpy, info, False);

	LockDisplay(dpy);
	GetReq(XF86DGASetVidPage, req);
	req->reqType = info->codes->major_opcode;
	req->dgaReqType = X_XF86DGASetVidPage;
	req->screen = screen;
	req->vpage = vpage;
	UnlockDisplay(dpy);
	SyncHandle();
	XSync(dpy,False);
	return True;
	}

	Bool SDL_NAME(XF86DGAInstallColormap)(
	Display* dpy,
	int screen,
	Colormap cmap
	){
	XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
	xXF86DGAInstallColormapReq *req;

	XF86DGACheckExtension (dpy, info, False);

	LockDisplay(dpy);
	GetReq(XF86DGAInstallColormap, req);
	req->reqType = info->codes->major_opcode;
	req->dgaReqType = X_XF86DGAInstallColormap;
	req->screen = screen;
	req->id = cmap;
	UnlockDisplay(dpy);
	SyncHandle();
	XSync(dpy,False);
	return True;
	}

	Bool SDL_NAME(XF86DGAQueryDirectVideo)(
	Display *dpy,
	int screen,
	int *flags
	){
	XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
	xXF86DGAQueryDirectVideoReply rep;
	xXF86DGAQueryDirectVideoReq *req;

	XF86DGACheckExtension (dpy, info, False);

	LockDisplay(dpy);
	GetReq(XF86DGAQueryDirectVideo, req);
	req->reqType = info->codes->major_opcode;
	req->dgaReqType = X_XF86DGAQueryDirectVideo;
	req->screen = screen;
	if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
	UnlockDisplay(dpy);
	SyncHandle();
	return False;
	}
	*flags = rep.flags;
	UnlockDisplay(dpy);
	SyncHandle();
	return True;
	}

	Bool SDL_NAME(XF86DGAViewPortChanged)(
	Display *dpy,
	int screen,
	int n
	){
	XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
	xXF86DGAViewPortChangedReply rep;
	xXF86DGAViewPortChangedReq *req;

	XF86DGACheckExtension (dpy, info, False);

	LockDisplay(dpy);
	GetReq(XF86DGAViewPortChanged, req);
	req->reqType = info->codes->major_opcode;
	req->dgaReqType = X_XF86DGAViewPortChanged;
	req->screen = screen;
	req->n = n;
	if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
	UnlockDisplay(dpy);
	SyncHandle();
	return False;
	}
	UnlockDisplay(dpy);
	SyncHandle();
	return rep.result;
	}



	/* Helper functions */

	#include <X11/Xmd.h>
	#include "../extensions/xf86dga.h"
	#include <stdlib.h>
	#include <stdio.h>
	#include <fcntl.h>
	#if defined(ISC)
	# define HAS_SVR3_MMAP
	# include <sys/types.h>
	# include <errno.h>

	# include <sys/at_ansi.h>
	# include <sys/kd.h>

	# include <sys/sysmacros.h>
	# include <sys/immu.h>
	# include <sys/region.h>

	# include <sys/mmap.h>
	#else
	# if !defined(Lynx)
	# if !defined(__EMX__)
	# include <sys/mman.h>
	# endif
	# else
	# include <sys/types.h>
	# include <errno.h>
	# include <smem.h>
	# endif
	#endif
	#include <sys/wait.h>
	#include <signal.h>
	#include <unistd.h>

	#if defined(SVR4) && !defined(sun) && !defined(SCO325)
	#define DEV_MEM "/dev/pmem"
	#elif defined(SVR4) && defined(sun)
	#define DEV_MEM "/dev/xsvc"
	#else
	#define DEV_MEM "/dev/mem"
	#endif

	typedef struct {
	unsigned long physaddr; /* actual requested physical address */
	unsigned long size; /* actual requested map size */
	unsigned long delta; /* delta to account for page alignment */
	void * vaddr; /* mapped address, without the delta */
	int refcount; /* reference count */
	} MapRec, *MapPtr;

	typedef struct {
	Display * display;
	int screen;
	MapPtr map;
	} ScrRec, *ScrPtr;

	static int mapFd = -1;
	static int numMaps = 0;
	static int numScrs = 0;
	static MapPtr *mapList = NULL;
	static ScrPtr *scrList = NULL;

	static MapPtr
	AddMap(void)
	{
	MapPtr *old;

	old = mapList;
	mapList = realloc(mapList, sizeof(MapPtr) * (numMaps + 1));
	if (!mapList) {
	mapList = old;
	return NULL;
	}
	mapList[numMaps] = malloc(sizeof(MapRec));
	if (!mapList[numMaps])
	return NULL;
	return mapList[numMaps++];
	}

	static ScrPtr
	AddScr(void)
	{
	ScrPtr *old;

	old = scrList;
	scrList = realloc(scrList, sizeof(ScrPtr) * (numScrs + 1));
	if (!scrList) {
	scrList = old;
	return NULL;
	}
	scrList[numScrs] = malloc(sizeof(ScrRec));
	if (!scrList[numScrs])
	return NULL;
	return scrList[numScrs++];
	}

	static MapPtr
	FindMap(unsigned long address, unsigned long size)
	{
	int i;

	for (i = 0; i < numMaps; i++) {
	if (mapList[i]->physaddr == address &&
	mapList[i]->size == size)
	return mapList[i];
	}
	return NULL;
	}

	static ScrPtr
	FindScr(Display *display, int screen)
	{
	int i;

	for (i = 0; i < numScrs; i++) {
	if (scrList[i]->display == display &&
	scrList[i]->screen == screen)
	return scrList[i];
	}
	return NULL;
	}

	static void *
	MapPhysAddress(unsigned long address, unsigned long size)
	{
	unsigned long offset, delta;
	int pagesize = -1;
	void *vaddr;
	MapPtr mp;
	#if defined(ISC) && defined(HAS_SVR3_MMAP)
	struct kd_memloc mloc;
	#elif defined(__EMX__)
	APIRET rc;
	ULONG action;
	HFILE hfd;
	#endif

	if ((mp = FindMap(address, size))) {
	mp->refcount++;
	return (void *)((unsigned long)mp->vaddr + mp->delta);
	}

	#if defined(_SC_PAGESIZE) && defined(HAS_SC_PAGESIZE)
	pagesize = sysconf(_SC_PAGESIZE);
	#endif
	#ifdef _SC_PAGE_SIZE
	if (pagesize == -1)
	pagesize = sysconf(_SC_PAGE_SIZE);
	#endif
	#ifdef HAS_GETPAGESIZE
	if (pagesize == -1)
	pagesize = getpagesize();
	#endif
	#ifdef PAGE_SIZE
	if (pagesize == -1)
	pagesize = PAGE_SIZE;
	#endif
	if (pagesize == -1)
	pagesize = 4096;

	delta = address % pagesize;
	offset = address - delta;

	#if defined(ISC) && defined(HAS_SVR3_MMAP)
	if (mapFd < 0) {
	if ((mapFd = open("/dev/mmap", O_RDWR)) < 0)
	return NULL;
	}
	mloc.vaddr = (char *)0;
	mloc.physaddr = (char *)offset;
	mloc.length = size + delta;
	mloc.ioflg=1;

	if ((vaddr = (void )ioctl(mapFd, MAP, &mloc)) == (void )-1)
	return NULL;
	#elif defined (__EMX__)
	/*
	* Dragon warning here! /dev/pmap$ is never closed, except on progam exit.
	* Consecutive calling of this routine will make PMAP$ driver run out
	* of memory handles. Some umap/close mechanism should be provided
	*/

	rc = DosOpen("/dev/pmap$", &hfd, &action, 0, FILE_NORMAL, FILE_OPEN,
	OPEN_ACCESS_READWRITE \| OPEN_SHARE_DENYNONE, (PEAOP2)NULL);
	if (rc != 0)
	return NULL;
	{
	struct map_ioctl {
	union {
	ULONG phys;
	void* user;
	} a;
	ULONG size;
	} pmap,dmap;
	ULONG plen,dlen;
	#define XFREE86_PMAP 0x76
	#define PMAP_MAP 0x44

	pmap.a.phys = offset;
	pmap.size = size + delta;
	rc = DosDevIOCtl(hfd, XFREE86_PMAP, PMAP_MAP,
	(PULONG)&pmap, sizeof(pmap), &plen,
	(PULONG)&dmap, sizeof(dmap), &dlen);
	if (rc == 0) {
	vaddr = dmap.a.user;
	}
	}
	if (rc != 0)
	return NULL;
	#elif defined (Lynx)
	vaddr = (void )smem_create("XF86DGA", (char )offset,
	size + delta, SM_READ\|SM_WRITE);
	#else
	#ifndef MAP_FILE
	#define MAP_FILE 0
	#endif
	if (mapFd < 0) {
	if ((mapFd = open(DEV_MEM, O_RDWR)) < 0)
	return NULL;
	}
	vaddr = (void *)mmap(NULL, size + delta, PROT_READ \| PROT_WRITE,
	MAP_FILE \| MAP_SHARED, mapFd, (off_t)offset);
	if (vaddr == (void *)-1)
	return NULL;
	#endif

	if (!vaddr) {
	if (!(mp = AddMap()))
	return NULL;
	mp->physaddr = address;
	mp->size = size;
	mp->delta = delta;
	mp->vaddr = vaddr;
	mp->refcount = 1;
	}
	return (void *)((unsigned long)vaddr + delta);
	}

	/*
	* Still need to find a clean way of detecting the death of a DGA app
	* and returning things to normal - Jon
	* This is here to help debugging without rebooting... Also C-A-BS
	* should restore text mode.
	*/

	int
	SDL_NAME(XF86DGAForkApp)(int screen)
	{
	pid_t pid;
	int status;
	int i;

	/* fork the app, parent hangs around to clean up */
	if ((pid = fork()) > 0) {
	ScrPtr sp;

	waitpid(pid, &status, 0);
	for (i = 0; i < numScrs; i++) {
	sp = scrList[i];
	SDL_NAME(XF86DGADirectVideoLL)(sp->display, sp->screen, 0);
	XSync(sp->display, False);
	}
	if (WIFEXITED(status))
	_exit(0);
	else
	_exit(-1);
	}
	return pid;
	}


	Bool
	SDL_NAME(XF86DGADirectVideo)(
	Display *dis,
	int screen,
	int enable
	){
	ScrPtr sp;
	MapPtr mp = NULL;

	if ((sp = FindScr(dis, screen)))
	mp = sp->map;

	if (enable & XF86DGADirectGraphics) {
	#if !defined(ISC) && !defined(HAS_SVR3_MMAP) && !defined(Lynx) \
	&& !defined(__EMX__)
	if (mp && mp->vaddr)
	mprotect(mp->vaddr, mp->size + mp->delta, PROT_READ \| PROT_WRITE);
	#endif
	} else {
	#if !defined(ISC) && !defined(HAS_SVR3_MMAP) && !defined(Lynx) \
	&& !defined(__EMX__)
	if (mp && mp->vaddr)
	mprotect(mp->vaddr, mp->size + mp->delta, PROT_READ);
	#elif defined(Lynx)
	/* XXX this doesn't allow enable after disable */
	smem_create(NULL, mp->vaddr, mp->size + mp->delta, SM_DETACH);
	smem_remove("XF86DGA");
	#endif
	}

	SDL_NAME(XF86DGADirectVideoLL)(dis, screen, enable);
	return 1;
	}


	static void
	XF86cleanup(int sig)
	{
	ScrPtr sp;
	int i;
	static char beenhere = 0;

	if (beenhere)
	_exit(3);
	beenhere = 1;

	for (i = 0; i < numScrs; i++) {
	sp = scrList[i];
	SDL_NAME(XF86DGADirectVideo)(sp->display, sp->screen, 0);
	XSync(sp->display, False);
	}
	_exit(3);
	}

	Bool
	SDL_NAME(XF86DGAGetVideo)(
	Display *dis,
	int screen,
	char **addr,
	int *width,
	int *bank,
	int *ram
	){
	/unsigned long/ int offset;
	static int beenHere = 0;
	ScrPtr sp;
	MapPtr mp;

	if (!(sp = FindScr(dis, screen))) {
	if (!(sp = AddScr())) {
	fprintf(stderr, "XF86DGAGetVideo: malloc failure\n");
	exit(-2);
	}
	sp->display = dis;
	sp->screen = screen;
	sp->map = NULL;
	}

	SDL_NAME(XF86DGAGetVideoLL)(dis, screen , &offset, width, bank, ram);

	addr = MapPhysAddress(offset, bank);
	if (*addr == NULL) {
	fprintf(stderr, "XF86DGAGetVideo: failed to map video memory (%s)\n",
	strerror(errno));
	exit(-2);
	}

	if ((mp = FindMap(offset, *bank)))
	sp->map = mp;

	if (!beenHere) {
	beenHere = 1;
	atexit((void(*)(void))XF86cleanup);
	/* one shot XF86cleanup attempts */
	signal(SIGSEGV, XF86cleanup);
	#ifdef SIGBUS
	signal(SIGBUS, XF86cleanup);
	#endif
	signal(SIGHUP, XF86cleanup);
	signal(SIGFPE, XF86cleanup);
	}

	return 1;
	}